From 9180cf8edda6b2fe25025b58de8f8dcb5cabc138 Mon Sep 17 00:00:00 2001
From: Osei Fortune <fortune.osei@yahoo.com>
Date: Sat, 7 Oct 2023 22:24:29 -0400
Subject: [PATCH] chore: updates

---
 .../canvas/src/main/cpp/Caches.h              |   114 +-
 .../canvas/src/main/cpp/Helpers.h             |     8 +-
 .../main/cpp/webgl/WebGLRenderingContext.cpp  | 10479 ++++++++--------
 .../main/cpp/webgl/WebGLRenderingContext.h    |   616 +-
 .../webgl/WebGLShaderPrecisionFormatImpl.cpp  |    51 +-
 .../webgl/WebGLShaderPrecisionFormatImpl.h    |    63 +-
 .../src/main/cpp/webgl/WebGLUniformLocation.h |    50 +-
 .../cpp/webgl2/WebGL2RenderingContext.cpp     |  3576 +++---
 .../main/cpp/webgl2/WebGL2RenderingContext.h  |   185 +-
 .../canvas/src/main/cpp/webgl2/WebGLQuery.h   |    11 +
 .../canvas/src/main/cpp/webgl2/WebGLSampler.h |    11 +
 .../src/main/cpp/webgl2/WebGLSyncImpl.h       |    11 +
 .../main/cpp/webgl2/WebGLTransformFeedback.h  |    12 +
 13 files changed, 7999 insertions(+), 7188 deletions(-)

diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/Caches.h b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/Caches.h
index a6d5d265..f1be0313 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/Caches.h
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/Caches.h
@@ -13,7 +13,7 @@ class Caches {
 
     ~Caches();
 
-    static std::shared_ptr <Caches> Get(v8::Isolate *isolate);
+    static std::shared_ptr<Caches> Get(v8::Isolate *isolate);
 
     static void Remove(v8::Isolate *isolate);
 
@@ -21,162 +21,166 @@ class Caches {
 
     v8::Local<v8::Context> GetContext();
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> TextDecoderTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> TextDecoderTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> TextEncoderTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> TextEncoderTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> Path2DTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> Path2DTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> ImageDataTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> ImageDataTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> ImageAssetTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> ImageAssetTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> CanvasGradientTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> CanvasGradientTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> CanvasPatternTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> CanvasPatternTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> MatrixTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> MatrixTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> TextMetricsTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> TextMetricsTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> CanvasRenderingContext2DTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> CanvasRenderingContext2DTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> ImageBitmapTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> ImageBitmapTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> ANGLE_instanced_arraysTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> ANGLE_instanced_arraysTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> EXT_blend_minmaxTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> EXT_blend_minmaxTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> EXT_color_buffer_half_floatTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> EXT_color_buffer_half_floatTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WebGLQueryTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLQueryTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> EXT_disjoint_timer_queryTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> EXT_disjoint_timer_queryTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> EXT_shader_texture_lodTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> EXT_shader_texture_lodTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WebGLActiveInfoTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLActiveInfoTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WebGLBufferTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLBufferTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WebGLSamplerTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLSamplerTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WebGLSyncTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLSyncTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WebGLTransformFeedbackTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLTransformFeedbackTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WebGLVertexArrayObjectTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLVertexArrayObjectTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WebGLRenderingContextTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLRenderingContextTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WebGL2RenderingContextTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGL2RenderingContextTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WebGLProgramTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLProgramTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WebGLShaderTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLShaderTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WebGLFramebufferTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLFramebufferTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WebGLRenderbufferTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLRenderbufferTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WebGLTextureTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLTextureTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> OES_fbo_render_mipmapTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> OES_fbo_render_mipmapTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> EXT_sRGBTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> EXT_sRGBTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> EXT_texture_filter_anisotropicTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> EXT_texture_filter_anisotropicTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> OES_element_index_uintTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> OES_element_index_uintTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> OES_standard_derivativesTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> OES_standard_derivativesTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> OES_texture_floatTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> OES_texture_floatTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> OES_texture_float_linearTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> OES_texture_float_linearTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> OES_texture_half_float_linearTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> OES_texture_half_float_linearTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> OES_texture_half_floatTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> OES_texture_half_floatTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WEBGL_color_buffer_floatTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WEBGL_color_buffer_floatTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> OES_vertex_array_objectTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> OES_vertex_array_objectTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WEBGL_compressed_texture_atcTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WEBGL_compressed_texture_atcTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WEBGL_compressed_texture_etc1Tmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WEBGL_compressed_texture_etc1Tmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WEBGL_compressed_texture_s3tcTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WEBGL_compressed_texture_s3tcTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WEBGL_compressed_texture_s3tc_srgbTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WEBGL_compressed_texture_s3tc_srgbTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WEBGL_compressed_texture_etcTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WEBGL_compressed_texture_etcTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WEBGL_compressed_texture_pvrtcTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WEBGL_compressed_texture_pvrtcTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WEBGL_lose_contextTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WEBGL_lose_contextTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WEBGL_depth_textureTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WEBGL_depth_textureTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
-    std::unique_ptr <v8::Persistent<v8::FunctionTemplate>> WEBGL_draw_buffersTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WEBGL_draw_buffersTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
             nullptr);
 
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLShaderPrecisionFormatTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+            nullptr);
 
+    std::unique_ptr<v8::Persistent<v8::FunctionTemplate>> WebGLUniformLocationTmpl = std::unique_ptr<v8::Persistent<v8::FunctionTemplate>>(
+            nullptr);
 
 private:
-    static std::shared_ptr <ConcurrentMap<v8::Isolate *,
-            std::shared_ptr <Caches>>>
-    perIsolateCaches_;
+    static std::shared_ptr<ConcurrentMap<v8::Isolate *,
+            std::shared_ptr<Caches>>>
+            perIsolateCaches_;
     v8::Isolate *isolate_;
-    std::shared_ptr <v8::Persistent<v8::Context>> context_;
+    std::shared_ptr<v8::Persistent<v8::Context>> context_;
 };
diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/Helpers.h b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/Helpers.h
index d070d222..5ea67a96 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/Helpers.h
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/Helpers.h
@@ -55,7 +55,13 @@ enum class NativeType {
     WEBGL_lose_context,
     ANGLE_instanced_arrays,
     WEBGL_depth_texture,
-    WEBGL_draw_buffers
+    WEBGL_draw_buffers,
+    WebGLShaderPrecisionFormat,
+    WebGLUniformLocation,
+    WebGLRenderingContext,
+    WebGLSampler,
+    WebGLTransformFeedback,
+    WebGLSync
 };
 
 
diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLRenderingContext.cpp b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLRenderingContext.cpp
index b18d8b37..05936d0d 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLRenderingContext.cpp
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLRenderingContext.cpp
@@ -18,7 +18,7 @@ WebGLRenderingContext::WebGLRenderingContext(rust::Box<WebGLState> state,
 }
 
 
-v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+v8::Local<v8::FunctionTemplate> WebGLRenderingContext::GetCtor(v8::Isolate *isolate) {
     auto cache = Caches::Get(isolate);
     auto ctor = cache->WebGLRenderingContextTmpl.get();
     if (ctor != nullptr) {
@@ -32,370 +32,3107 @@ v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
     auto tmpl = ctorTmpl->InstanceTemplate();
     tmpl->SetInternalFieldCount(1);
 
+    SetConstants(isolate, tmpl);
+
+    tmpl->SetAccessor(ConvertToV8String(isolate, "drawingBufferWidth"), &GetDrawingBufferWidth);
+    tmpl->SetAccessor(ConvertToV8String(isolate, "drawingBufferHeight"), &GetDrawingBufferHeight);
+
+    tmpl->SetAccessor(ConvertToV8String(isolate, "__flipY"), &GetFlipY);
+
+    tmpl->Set(ConvertToV8String(isolate, "__resized"),
+              v8::FunctionTemplate::New(isolate, &__Resized));
+    tmpl->Set(ConvertToV8String(isolate, "__startRaf"),
+              v8::FunctionTemplate::New(isolate, &__StartRaf));
+    tmpl->Set(ConvertToV8String(isolate, "__stopRaf"),
+              v8::FunctionTemplate::New(isolate, &__StopRaf));
+
+    tmpl->Set(ConvertToV8String(isolate, "__toDataURL"),
+              v8::FunctionTemplate::New(isolate, &__ToDataURL));
+
+    tmpl->Set(ConvertToV8String(isolate, "__getSupportedExtensions"),
+              v8::FunctionTemplate::New(isolate, &__GetSupportedExtensions));
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "activeTexture"),
+            v8::FunctionTemplate::New(isolate, &ActiveTexture)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "attachShader"),
+            v8::FunctionTemplate::New(isolate, &AttachShader)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "bindAttribLocation"),
+            v8::FunctionTemplate::New(isolate, &BindAttribLocation)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "bindBuffer"),
+            v8::FunctionTemplate::New(isolate, &BindBuffer)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "bindFramebuffer"),
+            v8::FunctionTemplate::New(isolate, &BindFramebuffer)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "bindRenderbuffer"),
+            v8::FunctionTemplate::New(isolate, &BindRenderbuffer)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "bindTexture"),
+            v8::FunctionTemplate::New(isolate, &BindTexture)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "blendColor"),
+            v8::FunctionTemplate::New(isolate, &BlendColor)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "blendEquationSeparate"),
+            v8::FunctionTemplate::New(isolate, &BlendEquationSeparate)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "blendEquation"),
+            v8::FunctionTemplate::New(isolate, &BlendEquation)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "blendFuncSeparate"),
+            v8::FunctionTemplate::New(isolate, &BlendFuncSeparate)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "blendFunc"),
+            v8::FunctionTemplate::New(isolate, &BlendFunc)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "bufferData"),
+            v8::FunctionTemplate::New(isolate, &BufferData)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "bufferSubData"),
+            v8::FunctionTemplate::New(isolate, &BufferSubData)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "checkFramebufferStatus"),
+            v8::FunctionTemplate::New(isolate, &CheckFramebufferStatus)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "clearColor"),
+            v8::FunctionTemplate::New(isolate, &ClearColor)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "clearDepth"),
+            v8::FunctionTemplate::New(isolate, &ClearDepth)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "clearStencil"),
+            v8::FunctionTemplate::New(isolate, &ClearStencil)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "clear"),
+            v8::FunctionTemplate::New(isolate, &Clear)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "colorMask"),
+            v8::FunctionTemplate::New(isolate, &ColorMask)
+    );
+    tmpl->Set(
+            ConvertToV8String(isolate, "commit"),
+            v8::FunctionTemplate::New(isolate, &Commit)
+    );
+    tmpl->Set(
+            ConvertToV8String(isolate, "compileShader"),
+            v8::FunctionTemplate::New(isolate, &CompileShader)
+    );
+    tmpl->Set(
+            ConvertToV8String(isolate, "compressedTexImage2D"),
+            v8::FunctionTemplate::New(isolate, &CompressedTexImage2D)
+    );
+    tmpl->Set(
+            ConvertToV8String(isolate, "compressedTexSubImage2D"),
+            v8::FunctionTemplate::New(isolate, &CompressedTexSubImage2D)
+    );
+    tmpl->Set(
+            ConvertToV8String(isolate, "copyTexImage2D"),
+            v8::FunctionTemplate::New(isolate, &CopyTexImage2D)
+    );
+    tmpl->Set(
+            ConvertToV8String(isolate, "copyTexSubImage2D"),
+            v8::FunctionTemplate::New(isolate, &CopyTexSubImage2D)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "createBuffer"),
+            v8::FunctionTemplate::New(isolate, &CreateBuffer)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "createFramebuffer"),
+            v8::FunctionTemplate::New(isolate, &CreateFramebuffer)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "createProgram"),
+            v8::FunctionTemplate::New(isolate, &CreateProgram)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "createRenderbuffer"),
+            v8::FunctionTemplate::New(isolate, &CreateRenderbuffer)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "createShader"),
+            v8::FunctionTemplate::New(isolate, &CreateShader)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "createTexture"),
+            v8::FunctionTemplate::New(isolate, &CreateTexture)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "cullFace"),
+            v8::FunctionTemplate::New(isolate, &CullFace)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "deleteBuffer"),
+            v8::FunctionTemplate::New(isolate, &DeleteBuffer)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "deleteFramebuffer"),
+            v8::FunctionTemplate::New(isolate, &DeleteFramebuffer)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "deleteProgram"),
+            v8::FunctionTemplate::New(isolate, &DeleteProgram)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "deleteRenderbuffer"),
+            v8::FunctionTemplate::New(isolate, &DeleteRenderbuffer)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "deleteShader"),
+            v8::FunctionTemplate::New(isolate, &DeleteShader)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "deleteTexture"),
+            v8::FunctionTemplate::New(isolate, &DeleteTexture)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "depthFunc"),
+            v8::FunctionTemplate::New(isolate, &DepthFunc)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "depthMask"),
+            v8::FunctionTemplate::New(isolate, &DepthMask)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "depthRange"),
+            v8::FunctionTemplate::New(isolate, &DepthRange)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "detachShader"),
+            v8::FunctionTemplate::New(isolate, &DetachShader)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "disableVertexAttribArray"),
+            v8::FunctionTemplate::New(isolate, &DisableVertexAttribArray)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "disable"),
+            v8::FunctionTemplate::New(isolate, &Disable)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "drawArrays"),
+            v8::FunctionTemplate::New(isolate, &DrawArrays)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "drawElements"),
+            v8::FunctionTemplate::New(isolate, &DrawElements)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "enableVertexAttribArray"),
+            v8::FunctionTemplate::New(isolate, &EnableVertexAttribArray)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "enable"),
+            v8::FunctionTemplate::New(isolate, &Enable)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "finish"),
+            v8::FunctionTemplate::New(isolate, &Finish)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "flush"),
+            v8::FunctionTemplate::New(isolate, &Flush)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "framebufferRenderbuffer"),
+            v8::FunctionTemplate::New(isolate, &FramebufferRenderbuffer)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "framebufferTexture2D"),
+            v8::FunctionTemplate::New(isolate, &FramebufferTexture2D)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "frontFace"),
+            v8::FunctionTemplate::New(isolate, &FrontFace)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "generateMipmap"),
+            v8::FunctionTemplate::New(isolate, &GenerateMipmap)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getActiveAttrib"),
+            v8::FunctionTemplate::New(isolate, &GetActiveAttrib)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getActiveUniform"),
+            v8::FunctionTemplate::New(isolate, &GetActiveUniform)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getAttachedShaders"),
+            v8::FunctionTemplate::New(isolate, &GetAttachedShaders)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getAttribLocation"),
+            v8::FunctionTemplate::New(isolate, &GetAttribLocation)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getBufferParameter"),
+            v8::FunctionTemplate::New(isolate, &GetBufferParameter)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getContextAttributes"),
+            v8::FunctionTemplate::New(isolate, &GetContextAttributes)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getError"),
+            v8::FunctionTemplate::New(isolate, &GetError)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getExtension"),
+            v8::FunctionTemplate::New(isolate, &GetExtension)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getFramebufferAttachmentParameter"),
+            v8::FunctionTemplate::New(isolate, &GetFramebufferAttachmentParameter)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getParameter"),
+            v8::FunctionTemplate::New(isolate, &GetParameter)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getProgramInfoLog"),
+            v8::FunctionTemplate::New(isolate, &GetProgramInfoLog)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getProgramParameter"),
+            v8::FunctionTemplate::New(isolate, &GetProgramParameter)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getRenderbufferParameter"),
+            v8::FunctionTemplate::New(isolate, &GetRenderbufferParameter)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getShaderInfoLog"),
+            v8::FunctionTemplate::New(isolate, &GetShaderInfoLog)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getShaderParameter"),
+            v8::FunctionTemplate::New(isolate, &GetShaderParameter)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getShaderPrecisionFormat"),
+            v8::FunctionTemplate::New(isolate, &GetShaderPrecisionFormat)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getShaderSource"),
+            v8::FunctionTemplate::New(isolate, &GetShaderSource)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getSupportedExtensions"),
+            v8::FunctionTemplate::New(isolate, &GetSupportedExtensions)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getTexParameter"),
+            v8::FunctionTemplate::New(isolate, &GetTexParameter)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getUniformLocation"),
+            v8::FunctionTemplate::New(isolate, &GetUniformLocation)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getUniform"),
+            v8::FunctionTemplate::New(isolate, &GetUniform)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getVertexAttribOffset"),
+            v8::FunctionTemplate::New(isolate, &GetVertexAttribOffset)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "getVertexAttrib"),
+            v8::FunctionTemplate::New(isolate, &GetVertexAttrib)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "hint"),
+            v8::FunctionTemplate::New(isolate, &Hint)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "isBuffer"),
+            v8::FunctionTemplate::New(isolate, &IsBuffer)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "isContextLost"),
+            v8::FunctionTemplate::New(isolate, &IsContextLost)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "isEnabled"),
+            v8::FunctionTemplate::New(isolate, &IsEnabled)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "isFramebuffer"),
+            v8::FunctionTemplate::New(isolate, &IsFramebuffer)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "isProgram"),
+            v8::FunctionTemplate::New(isolate, &IsProgram)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "isRenderbuffer"),
+            v8::FunctionTemplate::New(isolate, &IsRenderbuffer)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "isShader"),
+            v8::FunctionTemplate::New(isolate, &IsShader)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "isTexture"),
+            v8::FunctionTemplate::New(isolate, &IsTexture)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "lineWidth"),
+            v8::FunctionTemplate::New(isolate, &LineWidth)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "linkProgram"),
+            v8::FunctionTemplate::New(isolate, &LinkProgram)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "pixelStorei"),
+            v8::FunctionTemplate::New(isolate, &PixelStorei)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "polygonOffset"),
+            v8::FunctionTemplate::New(isolate, &PolygonOffset)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "readPixels"),
+            v8::FunctionTemplate::New(isolate, &ReadPixels)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "renderbufferStorage"),
+            v8::FunctionTemplate::New(isolate, &RenderbufferStorage)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "sampleCoverage"),
+            v8::FunctionTemplate::New(isolate, &SampleCoverage)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "scissor"),
+            v8::FunctionTemplate::New(isolate, &Scissor)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "shaderSource"),
+            v8::FunctionTemplate::New(isolate, &ShaderSource)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "stencilFuncSeparate"),
+            v8::FunctionTemplate::New(isolate, &StencilFuncSeparate)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "stencilFunc"),
+            v8::FunctionTemplate::New(isolate, &StencilFunc)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "stencilMaskSeparate"),
+            v8::FunctionTemplate::New(isolate, &StencilMaskSeparate)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "stencilMask"),
+            v8::FunctionTemplate::New(isolate, &StencilMask)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "stencilOpSeparate"),
+            v8::FunctionTemplate::New(isolate, &StencilOpSeparate)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "stencilOp"),
+            v8::FunctionTemplate::New(isolate, &StencilOp)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "texImage2D"),
+            v8::FunctionTemplate::New(isolate, &TexImage2D)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "texParameterf"),
+            v8::FunctionTemplate::New(isolate, &TexParameterf)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "texParameteri"),
+            v8::FunctionTemplate::New(isolate, &TexParameteri)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "texSubImage2D"),
+            v8::FunctionTemplate::New(isolate, &TexSubImage2D)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "vertexAttrib1f"),
+            v8::FunctionTemplate::New(isolate, &VertexAttrib1f)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "vertexAttrib1fv"),
+            v8::FunctionTemplate::New(isolate, &VertexAttrib1fv)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "vertexAttrib2f"),
+            v8::FunctionTemplate::New(isolate, &VertexAttrib2f)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "vertexAttrib2fv"),
+            v8::FunctionTemplate::New(isolate, &VertexAttrib2fv)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "vertexAttrib3f"),
+            v8::FunctionTemplate::New(isolate, &VertexAttrib3f)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "vertexAttrib3fv"),
+            v8::FunctionTemplate::New(isolate, &VertexAttrib3fv)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "vertexAttrib4f"),
+            v8::FunctionTemplate::New(isolate, &VertexAttrib4f)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "vertexAttrib4fv"),
+            v8::FunctionTemplate::New(isolate, &VertexAttrib4fv)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "vertexAttribPointer"),
+            v8::FunctionTemplate::New(isolate, &VertexAttribPointer)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform1f"),
+            v8::FunctionTemplate::New(isolate, &Uniform1f)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform1iv"),
+            v8::FunctionTemplate::New(isolate, &Uniform1iv)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform1fv"),
+            v8::FunctionTemplate::New(isolate, &Uniform1fv)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform1i"),
+            v8::FunctionTemplate::New(isolate, &Uniform1i)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform2f"),
+            v8::FunctionTemplate::New(isolate, &Uniform2f)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform2iv"),
+            v8::FunctionTemplate::New(isolate, &Uniform2iv)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform2fv"),
+            v8::FunctionTemplate::New(isolate, &Uniform2fv)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform2i"),
+            v8::FunctionTemplate::New(isolate, &Uniform2i)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform3f"),
+            v8::FunctionTemplate::New(isolate, &Uniform3f)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform3iv"),
+            v8::FunctionTemplate::New(isolate, &Uniform3iv)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform3fv"),
+            v8::FunctionTemplate::New(isolate, &Uniform3fv)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform3i"),
+            v8::FunctionTemplate::New(isolate, &Uniform3i)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform4f"),
+            v8::FunctionTemplate::New(isolate, &Uniform4f)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform4iv"),
+            v8::FunctionTemplate::New(isolate, &Uniform4iv)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform4fv"),
+            v8::FunctionTemplate::New(isolate, &Uniform4fv)
+    );
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniform4i"),
+            v8::FunctionTemplate::New(isolate, &Uniform4i)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniformMatrix2fv"),
+            v8::FunctionTemplate::New(isolate, &UniformMatrix2fv)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniformMatrix3fv"),
+            v8::FunctionTemplate::New(isolate, &UniformMatrix3fv)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "uniformMatrix4fv"),
+            v8::FunctionTemplate::New(isolate, &UniformMatrix4fv)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "useProgram"),
+            v8::FunctionTemplate::New(isolate, &UseProgram)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "validateProgram"),
+            v8::FunctionTemplate::New(isolate, &ValidateProgram)
+    );
+
+
+    tmpl->Set(
+            ConvertToV8String(isolate, "viewport"),
+            v8::FunctionTemplate::New(isolate, &Viewport)
+    );
+
+
     cache->WebGLRenderingContextTmpl =
             std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
     return ctorTmpl;
 }
 
-WebGLRenderingContext *GetPointer(const v8::Local<v8::Object> &object) {
-    auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+WebGLRenderingContext *WebGLRenderingContext::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<WebGLRenderingContext *>(ptr);
+}
+
+
+v8::Local<v8::Value> WebGLRenderingContext::GetParameterInternal(v8::Isolate *isolate,
+                                                                 uint32_t pnameValue,
+                                                                 rust::Box<WebGLResult> result) {
+
+    auto context = isolate->GetCurrentContext();
+    v8::EscapableHandleScope scope(isolate);
+    switch (pnameValue) {
+        case GL_ACTIVE_TEXTURE:
+        case GL_ALPHA_BITS:
+        case GL_ARRAY_BUFFER_BINDING:
+        case GL_BLEND_DST_ALPHA:
+        case GL_BLEND_DST_RGB:
+        case GL_BLEND_EQUATION:
+        case GL_BLEND_EQUATION_ALPHA:
+        case GL_BLEND_SRC_ALPHA:
+        case GL_BLEND_SRC_RGB:
+        case GL_BLUE_BITS:
+        case GL_CULL_FACE_MODE:
+        case GL_CURRENT_PROGRAM:
+        case GL_DEPTH_BITS:
+        case GL_DEPTH_FUNC:
+        case GL_ELEMENT_ARRAY_BUFFER_BINDING:
+        case GL_FRAMEBUFFER_BINDING:
+        case GL_FRONT_FACE:
+        case GL_GENERATE_MIPMAP_HINT:
+        case GL_GREEN_BITS:
+        case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
+        case GL_IMPLEMENTATION_COLOR_READ_TYPE:
+        case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
+        case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
+        case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
+        case GL_MAX_RENDERBUFFER_SIZE:
+        case GL_MAX_TEXTURE_IMAGE_UNITS:
+        case GL_MAX_TEXTURE_SIZE:
+        case GL_MAX_VARYING_VECTORS:
+        case GL_MAX_VERTEX_ATTRIBS:
+        case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
+        case GL_MAX_VERTEX_UNIFORM_VECTORS:
+        case GL_PACK_ALIGNMENT:
+        case GL_RED_BITS:
+        case GL_RENDERBUFFER_BINDING:
+        case GL_SAMPLE_BUFFERS:
+        case GL_SAMPLES:
+        case GL_STENCIL_BACK_FAIL:
+        case GL_STENCIL_BACK_FUNC:
+        case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
+        case GL_STENCIL_BACK_PASS_DEPTH_PASS:
+        case GL_STENCIL_BACK_REF:
+        case GL_STENCIL_BACK_VALUE_MASK:
+        case GL_STENCIL_BACK_WRITEMASK:
+        case GL_STENCIL_BITS:
+        case GL_STENCIL_CLEAR_VALUE:
+        case GL_STENCIL_FAIL:
+        case GL_STENCIL_FUNC:
+        case GL_STENCIL_PASS_DEPTH_FAIL:
+        case GL_STENCIL_PASS_DEPTH_PASS:
+        case GL_STENCIL_REF:
+        case GL_STENCIL_VALUE_MASK:
+        case GL_STENCIL_WRITEMASK:
+        case GL_SUBPIXEL_BITS:
+        case GL_TEXTURE_BINDING_2D:
+        case GL_TEXTURE_BINDING_CUBE_MAP:
+        case GL_UNPACK_ALIGNMENT: {
+            auto value = canvas_native_webgl_result_get_i32(*result);
+            if ((pnameValue == GL_CURRENT_PROGRAM || pnameValue == GL_ARRAY_BUFFER_BINDING ||
+                 pnameValue == GL_ELEMENT_ARRAY_BUFFER_BINDING ||
+                 pnameValue == GL_TEXTURE_BINDING_2D ||
+                 pnameValue == GL_TEXTURE_BINDING_CUBE_MAP ||
+                 pnameValue == GL_RENDERBUFFER_BINDING ||
+                 pnameValue == GL_FRAMEBUFFER_BINDING) &&
+                value == 0) {
+                return scope.Escape(v8::Null(isolate));
+            }
+            return scope.Escape(v8::Number::New(isolate, (double) 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())));
+        case GL_ALIASED_LINE_WIDTH_RANGE:
+        case GL_ALIASED_POINT_SIZE_RANGE:
+        case GL_DEPTH_RANGE: {
+            auto ret = canvas_native_webgl_result_get_f32_array(*result);
+            auto buf = new VecMutableBuffer<float>(std::move(ret));
+
+
+            auto store = v8::ArrayBuffer::NewBackingStore(buf->data(), buf->buffer_size(),
+                                                          [](void *data, size_t length,
+                                                             void *deleter_data) {
+                                                              if (deleter_data != nullptr) {
+                                                                  delete (VecMutableBuffer<float> *) deleter_data;
+                                                              }
+                                                          },
+                                                          buf);
+
+            auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
+
+
+            return scope.Escape(v8::Float32Array::New(arraybuffer, 0, buf->size()));
+        }
+        case GL_BLEND_COLOR:
+        case GL_COLOR_CLEAR_VALUE: {
+            auto ret = canvas_native_webgl_result_get_f32_array(*result);
+
+            auto buf = new VecMutableBuffer<float>(std::move(ret));
+
+            auto store = v8::ArrayBuffer::NewBackingStore(buf->data(), buf->buffer_size(),
+                                                          [](void *data, size_t length,
+                                                             void *deleter_data) {
+                                                              if (deleter_data != nullptr) {
+                                                                  delete (VecMutableBuffer<float> *) deleter_data;
+                                                              }
+                                                          },
+                                                          buf);
+
+            auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
+
+
+            return scope.Escape(v8::Float32Array::New(arraybuffer, 0, buf->size()));
+
+        }
+        case (uint32_t) GLConstants::UNPACK_FLIP_Y_WEBGL:
+            return scope.Escape(v8::Boolean::New(isolate, canvas_native_webgl_state_get_flip_y(
+                    this->GetState())));
+        case (uint32_t) GLConstants::UNPACK_PREMULTIPLY_ALPHA_WEBGL:
+            return scope.Escape(v8::Boolean::New(isolate,
+                                                 canvas_native_webgl_state_get_premultiplied_alpha(
+                                                         this->GetState())));
+        case GL_BLEND:
+        case GL_CULL_FACE:
+        case GL_DEPTH_TEST:
+        case GL_DEPTH_WRITEMASK:
+        case GL_DITHER:
+        case GL_POLYGON_OFFSET_FILL:
+        case GL_SAMPLE_COVERAGE_INVERT:
+        case GL_SCISSOR_TEST:
+        case GL_STENCIL_TEST:
+            return scope.Escape(
+                    v8::Boolean::New(isolate, canvas_native_webgl_result_get_bool(*result)));
+        case GL_COLOR_WRITEMASK: {
+            auto ret = canvas_native_webgl_result_get_bool_array(*result);
+            auto len = ret.size();
+            auto array = v8::Array::New(isolate, (int) len);
+
+            for (int j = 0; j < len; ++j) {
+                array->Set(context, j, v8::Boolean::New(isolate, ret[j] == 1));
+            }
+            return array;
+        }
+        case GL_COMPRESSED_TEXTURE_FORMATS:
+        case GL_MAX_VIEWPORT_DIMS:
+        case GL_SCISSOR_BOX:
+        case GL_VIEWPORT: {
+            auto ret = canvas_native_webgl_result_get_i32_array(*result);
+            auto buf = new VecMutableBuffer<int32_t>(std::move(ret));
+
+            auto store = v8::ArrayBuffer::NewBackingStore(buf->data(), buf->buffer_size(),
+                                                          [](void *data, size_t length,
+                                                             void *deleter_data) {
+                                                              if (deleter_data != nullptr) {
+                                                                  delete (VecMutableBuffer<int32_t> *) deleter_data;
+                                                              }
+                                                          },
+                                                          buf);
+
+            auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
+
+
+            return scope.Escape(v8::Int32Array::New(arraybuffer, 0, buf->size()));
+        }
+        case GL_DEPTH_CLEAR_VALUE:
+        case GL_LINE_WIDTH:
+        case GL_POLYGON_OFFSET_FACTOR:
+        case GL_POLYGON_OFFSET_UNITS:
+        case GL_SAMPLE_COVERAGE_VALUE: {
+            return scope.Escape(v8::Number::New(isolate,
+                                                static_cast<double>(canvas_native_webgl_result_get_f32(
+                                                        *result))));
+        }
+        case GL_RENDERER:
+        case GL_SHADING_LANGUAGE_VERSION:
+        case GL_VENDOR:
+        case GL_VERSION: {
+            auto ret = canvas_native_webgl_result_get_string(*result);
+
+
+            auto value = new OneByteStringResource(std::move(ret));
+            return scope.Escape(v8::String::NewExternalOneByte(isolate, value).ToLocalChecked());
+        }
+        default:
+            return scope.Escape(v8::Null(isolate));
+
+    }
+}
+
+
+void
+WebGLRenderingContext::GetDrawingBufferWidth(v8::Local<v8::String> name,
+                                             const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto ret = canvas_native_webgl_state_get_drawing_buffer_width(ptr->GetState());
+        info.GetReturnValue().Set(ret);
+        return;
+    }
+    info.GetReturnValue().Set(0);
+}
+
+
+void WebGLRenderingContext::GetDrawingBufferHeight(v8::Local<v8::String> name,
+                                                   const v8::PropertyCallbackInfo<v8::Value> &info
+) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto ret = canvas_native_webgl_state_get_drawing_buffer_height(ptr->GetState());
+        info.GetReturnValue().Set(ret);
+        return;
+    }
+    info.GetReturnValue().Set(0);
+}
+
+void
+WebGLRenderingContext::GetFlipY(v8::Local<v8::String> name,
+                                const v8::PropertyCallbackInfo<v8::Value> &info) {
+    auto ptr = GetPointer(info.This());
+    if (ptr != nullptr) {
+        auto ret = canvas_native_webgl_state_get_flip_y(ptr->GetState());
+        info.GetReturnValue().Set(ret);
+        return;
+    }
+    info.GetReturnValue().Set(false);
+}
+
+void WebGLRenderingContext::__Resized(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    canvas_native_webgl_resized(
+            ptr->GetState());
+
+}
+
+void WebGLRenderingContext::__StartRaf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    ptr->StartRaf();
+
+}
+
+void WebGLRenderingContext::__StopRaf(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    ptr->StopRaf();
+
+}
+
+void WebGLRenderingContext::ActiveTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    auto texture = (uint32_t) args[0]->NumberValue(context).ToChecked();
+    canvas_native_webgl_active_texture(texture,
+                                       ptr->GetState());
+}
+
+void WebGLRenderingContext::AttachShader(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    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>());
+        }
+
+        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) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    if (args.Length() > 2) {
+        auto programValue = args[0];
+
+        if (programValue->IsObject()) {
+            auto type = GetNativeType(isolate, programValue.As<v8::Object>());
+            if (type == NativeType::WebGLProgram && args[1]->IsNumber() &&
+                args[2]->IsString()) {
+                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,
+                        rust::Str(name.c_str()),
+                        ptr->GetState()
+                );
+
+            }
+        }
+    }
+}
+
+void WebGLRenderingContext::BindBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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()
+                );
+            }
+        }
+    }
+}
+
+void WebGLRenderingContext::BindFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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
+                canvas_native_webgl_bind_frame_buffer(
+                        target,
+                        0,
+                        ptr->GetState()
+                );
+            }
+        }
+    }
+}
+
+void WebGLRenderingContext::BindRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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()
+                );
+            }
+        }
+    }
+}
+
+void WebGLRenderingContext::BindTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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()
+                );
+            }
+        }
+    }
+}
+
+void WebGLRenderingContext::BlendColor(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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()
+        );
+    }
+}
+
+void WebGLRenderingContext::BlendEquationSeparate(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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();
+
+        canvas_native_webgl_blend_equation_separate(
+                modeRGB,
+                modeAlpha,
+                ptr->GetState()
+        );
+    }
+}
+
+void WebGLRenderingContext::BlendEquation(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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()
+        );
+    }
+}
+
+void WebGLRenderingContext::BlendFuncSeparate(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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()
+        );
+    }
+}
+
+void WebGLRenderingContext::BlendFunc(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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();
+
+        canvas_native_webgl_blend_func(
+                sfactor,
+                dfactor,
+                ptr->GetState()
+        );
+    }
+}
+
+void WebGLRenderingContext::BufferData(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    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();
+
+        canvas_native_webgl_buffer_data_none(
+                target,
+                0,
+                usage,
+                ptr->GetState()
+        );
+    } else if (count == 3) {
+        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+
+        auto usage = (uint32_t) args[2]->NumberValue(context).ToChecked();
+
+        if (args[1]->IsObject()) {
+
+            auto sizeOrBuf = args[1];
+            if (sizeOrBuf->IsArrayBufferView()) {
+                if (sizeOrBuf->IsUint16Array()) {
+                    auto array = sizeOrBuf.As<v8::TypedArray>();
+                    auto buf = GetTypedArrayData<const uint16_t>(array);
+
+                    canvas_native_webgl_buffer_data_u16(
+                            target,
+                            buf,
+                            usage,
+                            ptr->GetState()
+                    );
+                } else if (sizeOrBuf->IsFloat32Array()) {
+                    auto array = sizeOrBuf.As<v8::TypedArray>();
+                    auto buf = GetTypedArrayData<const float>(array);
+                    canvas_native_webgl_buffer_data_f32(
+                            target,
+                            buf,
+                            usage,
+                            ptr->GetState()
+                    );
+                } else {
+                    auto array = sizeOrBuf.As<v8::TypedArray>();
+                    auto buf = GetTypedArrayData<const uint8_t>(array);
+                    canvas_native_webgl_buffer_data(
+                            target,
+                            buf,
+                            usage,
+                            ptr->GetState()
+                    );
+                }
+            } else if (sizeOrBuf->IsArrayBuffer()) {
+                auto buffer = sizeOrBuf.As<v8::ArrayBuffer>();
+                auto data = GetArrayBufferData<const uint8_t>(buffer);
+                canvas_native_webgl_buffer_data(
+                        target,
+                        data,
+                        usage,
+                        ptr->GetState()
+                );
+            }
+        } else {
+            auto sizeOrBuf = args[1]->NumberValue(context).ToChecked();
+            canvas_native_webgl_buffer_data_none(
+                    target,
+                    static_cast<ssize_t>(sizeOrBuf),
+                    usage,
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGLRenderingContext::BufferSubData(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto count = args.Length();
+
+    if (count == 2) {
+        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        auto offset = args[1]->NumberValue(context).ToChecked();
+
+        canvas_native_webgl_buffer_sub_data_none(
+                target,
+                static_cast<ssize_t>(offset),
+                ptr->GetState()
+        );
+    } else if (count == 3) {
+        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        auto offset = args[1]->NumberValue(context).ToChecked();
+
+        if (args[2]->IsObject()) {
+            auto buf = args[2];
+
+            if (buf->IsTypedArray()) {
+                auto array = buf.As<v8::TypedArray>();
+                auto buff = GetTypedArrayData<const uint8_t>(array);
+                canvas_native_webgl_buffer_sub_data(
+                        target,
+                        static_cast<ssize_t>(offset),
+                        buff,
+                        ptr->GetState()
+                );
+            } else if (buf->IsArrayBuffer()) {
+                auto arrayBuffer = buf.As<v8::ArrayBuffer>();
+
+                auto data = GetArrayBufferData<const uint8_t>(arrayBuffer);
+
+                canvas_native_webgl_buffer_sub_data(
+                        target,
+                        static_cast<rust::isize>(offset),
+                        data,
+                        ptr->GetState()
+                );
+            }
+
+        }
+
+    }
+}
+
+void
+WebGLRenderingContext::CheckFramebufferStatus(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto count = args.Length();
+
+    if (count > 0) {
+
+        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()
+            );
+
+            args.GetReturnValue().Set((int32_t) ret);
+            return;
+        }
+    }
+
+    args.GetReturnValue().Set(0);
+}
+
+void WebGLRenderingContext::ClearColor(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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()
+        );
+    }
+}
+
+void WebGLRenderingContext::ClearDepth(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    if (args.Length() > 0) {
+        auto depth = args[0]->NumberValue(context).ToChecked();
+
+        canvas_native_webgl_clear_depth(
+                static_cast<float>(depth),
+                ptr->GetState()
+        );
+    }
+}
+
+void WebGLRenderingContext::ClearStencil(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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()
+        );
+    }
+}
+
+void WebGLRenderingContext::Clear(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    //if (count > 0) {
+    auto mask = (uint32_t) args[0]->NumberValue(context).ToChecked();
+
+    canvas_native_webgl_clear(
+            mask,
+            ptr->GetState()
+    );
+
+    ptr->UpdateInvalidateState();
+    // }
+}
+
+void WebGLRenderingContext::ColorMask(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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);
+
+        canvas_native_webgl_color_mask(
+                red,
+                green,
+                blue,
+                alpha,
+                ptr->GetState()
+        );
+    }
+}
+
+void WebGLRenderingContext::Commit(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+}
+
+void WebGLRenderingContext::CompileShader(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    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()
+            );
+        }
+    }
+}
+
+void WebGLRenderingContext::CompressedTexImage2D(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    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();
+
+        canvas_native_webgl_compressed_tex_image2d_none(
+                target,
+                level,
+                internalformat,
+                width,
+                height,
+                border,
+                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 pixels = args[6];
+        if (pixels->IsObject()) {
+            if (pixels->IsTypedArray()) {
+                auto array = pixels.As<v8::TypedArray>();
+                auto buf = GetTypedArrayData<const uint8_t>(array);
+                canvas_native_webgl_compressed_tex_image2d(
+                        target,
+                        level,
+                        internalformat,
+                        width,
+                        height,
+                        border,
+                        buf,
+                        ptr->GetState()
+                );
+            } else if (pixels->IsArrayBuffer()) {
+                auto ab = pixels.As<v8::ArrayBuffer>();
+                auto buf = GetArrayBufferData<const uint8_t>(ab);
+
+                canvas_native_webgl_compressed_tex_image2d(
+                        target,
+                        level,
+                        internalformat,
+                        width,
+                        height,
+                        border,
+                        buf,
+                        ptr->GetState()
+                );
+            }
+        }
+    }
+}
+
+void
+WebGLRenderingContext::CompressedTexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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->IsTypedArray()) {
+                auto px = pixels.As<v8::TypedArray>();
+                auto buf = GetTypedArrayData<const uint8_t>(px);
+                canvas_native_webgl_compressed_tex_sub_image2d(
+                        target,
+                        level,
+                        xoffset,
+                        yoffset,
+                        width,
+                        height,
+                        format,
+                        buf,
+                        ptr->GetState()
+                );
+            } else if (pixels->IsArrayBuffer()) {
+                auto buffer = pixels.As<v8::ArrayBuffer>();
+                auto buf = GetArrayBufferData<const uint8_t>(buffer);
+
+                canvas_native_webgl_compressed_tex_sub_image2d(
+                        target,
+                        level,
+                        xoffset,
+                        yoffset,
+                        width,
+                        height,
+                        format,
+                        buf,
+                        ptr->GetState()
+                );
+            }
+        }
+    }
+
+}
+
+void WebGLRenderingContext::CopyTexImage2D(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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 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();
+
+        canvas_native_webgl_copy_tex_image2d(
+                target,
+                level,
+                internalformat,
+                x,
+                y,
+                width,
+                height,
+                border,
+                ptr->GetState()
+        );
+    }
+
+}
+
+void WebGLRenderingContext::CopyTexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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 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();
+
+        canvas_native_webgl_copy_tex_sub_image2d(
+                target,
+                level,
+                xoffset,
+                yoffset,
+                x,
+                y,
+                width,
+                height,
+                ptr->GetState()
+        );
+    }
+
+}
+
+void WebGLRenderingContext::CreateBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto buffer = canvas_native_webgl_create_buffer(
+            ptr->GetState());
+    if (buffer != 0) {
+        auto ret = WebGLBuffer::NewInstance(isolate, new WebGLBuffer(
+                buffer));
+        args.GetReturnValue().Set(ret);
+        return;
+    }
+
+    args.GetReturnValue().SetNull();
+
+}
+
+void WebGLRenderingContext::CreateFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto buffer = canvas_native_webgl_create_framebuffer(
+            ptr->GetState());
+    if (buffer != 0) {
+        auto ret = WebGLFramebuffer::NewInstance(isolate, new WebGLFramebuffer(
+                buffer));
+        args.GetReturnValue().Set(ret);
+        return;
+    }
+
+    args.GetReturnValue().SetNull();
+
+}
+
+void WebGLRenderingContext::CreateProgram(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto program = canvas_native_webgl_create_program(
+            ptr->GetState());
+    if (program != 0) {
+        auto ret = WebGLProgram::NewInstance(isolate, new WebGLProgram(
+                program));
+        args.GetReturnValue().Set(ret);
+        return;
+    }
+
+    args.GetReturnValue().SetNull();
+
+}
+
+void WebGLRenderingContext::CreateRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto buffer = canvas_native_webgl_create_renderbuffer(
+            ptr->GetState());
+    if (buffer != 0) {
+        auto ret = WebGLRenderbuffer::NewInstance(isolate, new WebGLRenderbuffer(
+                buffer));
+        args.GetReturnValue().Set(ret);
+        return;
+    }
+
+    args.GetReturnValue().SetNull();
+
+}
+
+void WebGLRenderingContext::CreateShader(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    if (args.Length() == 0) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    auto type = (uint32_t) args[0]->NumberValue(context).ToChecked();
+    auto shader = canvas_native_webgl_create_shader(
+            type, ptr->GetState());
+    if (shader != 0) {
+        auto ret = WebGLShader::NewInstance(isolate, new WebGLShader(
+                shader));
+        args.GetReturnValue().Set(ret);
+        return;
+    }
+
+    args.GetReturnValue().SetUndefined();
+
+}
+
+void WebGLRenderingContext::CreateTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto texture = canvas_native_webgl_create_texture(
+            ptr->GetState());
+    if (texture != 0) {
+        auto ret = WebGLTexture::NewInstance(isolate, new WebGLTexture(
+                texture));
+        args.GetReturnValue().Set(ret);
+        return;
+    }
+
+    args.GetReturnValue().SetUndefined();
+
+}
+
+void WebGLRenderingContext::CullFace(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    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()
+        );
+    }
+
+}
+
+void WebGLRenderingContext::DeleteBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    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()
+                    );
+                }
+            }
+        }
+    }
+
+}
+
+void WebGLRenderingContext::DeleteFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+    if (type == NativeType::WebGLFramebuffer) {
+        auto buffer = WebGLFramebuffer::GetPointer(value.As<v8::Object>());
+        if (buffer != nullptr) {
+            canvas_native_webgl_delete_framebuffer(
+                    buffer->GetFrameBuffer(),
+                    ptr->GetState()
+            );
+        }
+    }
+
+}
+
+void WebGLRenderingContext::DeleteProgram(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+
+    if (type == NativeType::WebGLProgram) {
+        auto program = WebGLProgram::GetPointer(value.As<v8::Object>());
+        if (program != nullptr) {
+            canvas_native_webgl_delete_framebuffer(
+                    program->GetProgram(),
+                    ptr->GetState()
+            );
+        }
+    }
+
+
+}
+
+void WebGLRenderingContext::DeleteRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+
+    if (type == NativeType::WebGLProgram) {
+        auto buffer = WebGLRenderbuffer::GetPointer(value.As<v8::Object>());
+        if (buffer != nullptr) {
+            canvas_native_webgl_delete_renderbuffer(
+                    buffer->GetRenderBuffer(),
+                    ptr->GetState()
+            );
+        }
+    }
+
+
+}
+
+void WebGLRenderingContext::DeleteShader(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+
+    if (type == NativeType::WebGLProgram) {
+        auto shader = WebGLShader::GetPointer(value.As<v8::Object>());
+        if (shader != nullptr) {
+            canvas_native_webgl_delete_shader(
+                    shader->GetShader(),
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGLRenderingContext::DeleteTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+
+    if (type == NativeType::WebGLProgram) {
+        auto texture = WebGLTexture::GetPointer(value.As<v8::Object>());
+        if (texture != nullptr) {
+            canvas_native_webgl_delete_texture(
+                    texture->GetTexture(),
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGLRenderingContext::DepthFunc(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto value = args[0];
+
+    if (args.Length() > 0) {
+        auto func = (uint32_t) value->NumberValue(context).ToChecked();
+
+        canvas_native_webgl_depth_func(
+                func,
+                ptr->GetState()
+        );
+    }
+}
+
+void WebGLRenderingContext::DepthMask(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+
+
+    auto value = args[0];
+
+    if (args.Length() > 0) {
+        auto mask = args[0]->BooleanValue(isolate);
+
+        canvas_native_webgl_depth_mask(
+                mask,
+                ptr->GetState()
+        );
+    }
+}
+
+void WebGLRenderingContext::DepthRange(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    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()
+        );
+    }
+}
+
+void WebGLRenderingContext::DetachShader(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    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>());
+        }
+
+        if (program != nullptr &&
+            shader != nullptr) {
+            canvas_native_webgl_detach_shader(
+                    program->GetProgram(),
+                    shader->GetShader(),
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void
+WebGLRenderingContext::DisableVertexAttribArray(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto index = (uint32_t) args[0]->NumberValue(context).ToChecked();
+
+    canvas_native_webgl_disable_vertex_attrib_array(
+            index,
+            ptr->GetState()
+    );
+}
+
+void WebGLRenderingContext::Disable(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto cap = (uint32_t) args[0]->NumberValue(context).ToChecked();
+
+    canvas_native_webgl_disable(
+            cap,
+            ptr->GetState()
+    );
+}
+
+void WebGLRenderingContext::DrawArrays(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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();
+
+    canvas_native_webgl_draw_arrays(
+            mode,
+            first,
+            count,
+            ptr->GetState()
+    );
+    ptr->UpdateInvalidateState();
+}
+
+void WebGLRenderingContext::DrawElements(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    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 offset = args[3]->NumberValue(context).ToChecked();
+
+    canvas_native_webgl_draw_elements(
+            mode,
+            count,
+            type,
+            static_cast<ssize_t>(offset),
+            ptr->GetState()
+    );
+    ptr->UpdateInvalidateState();
+}
+
+void
+WebGLRenderingContext::EnableVertexAttribArray(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto index = (uint32_t) args[0]->NumberValue(context).ToChecked();
+
+    canvas_native_webgl_enable_vertex_attrib_array(
+            index,
+            ptr->GetState()
+    );
+}
+
+void WebGLRenderingContext::Enable(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto cap = (uint32_t) args[0]->NumberValue(context).ToChecked();
+
+    canvas_native_webgl_enable(
+            cap,
+            ptr->GetState()
+    );
+}
+
+void WebGLRenderingContext::Finish(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    canvas_native_webgl_finish(
+            ptr->GetState()
+    );
+}
+
+void WebGLRenderingContext::Flush(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    canvas_native_webgl_flush(
+            ptr->GetState()
+    );
+}
+
+void
+WebGLRenderingContext::FramebufferRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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 renderbufferValue = args[3];
+    auto type = GetNativeType(isolate, renderbufferValue);
+    if (type == NativeType::WebGLRenderbuffer) {
+        auto renderbuffer = WebGLRenderbuffer::GetPointer(renderbufferValue.As<v8::Object>());
+        if (renderbuffer != nullptr) {
+            canvas_native_webgl_framebuffer_renderbuffer(
+                    target,
+                    attachment,
+                    renderbuffertarget,
+                    renderbuffer->GetRenderBuffer(),
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGLRenderingContext::FramebufferTexture2D(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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 textureValue = args[3];
+    auto type = GetNativeType(isolate, textureValue);
+    if (type == NativeType::WebGLTexture) {
+        auto texture = WebGLTexture::GetPointer(textureValue.As<v8::Object>());
+        if (texture != nullptr) {
+            canvas_native_webgl_framebuffer_texture2d(
+                    target,
+                    attachment,
+                    textarget,
+                    texture->GetTexture(),
+                    level,
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGLRenderingContext::FrontFace(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto mode = (uint32_t) args[0]->NumberValue(context).ToChecked();
+
+    canvas_native_webgl_front_face(
+            mode,
+            ptr->GetState()
+    );
+}
+
+void WebGLRenderingContext::GenerateMipmap(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+
+    canvas_native_webgl_generate_mipmap(
+            target,
+            ptr->GetState()
+    );
+}
+
+void WebGLRenderingContext::GetActiveAttrib(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto programValue = args[0];
+    auto type = GetNativeType(isolate, programValue);
+    if (type == NativeType::WebGLProgram) {
+        auto index = (int32_t) args[1]->NumberValue(context).ToChecked();
+        auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
+        if (program != nullptr) {
+            auto info = canvas_native_webgl_get_active_attrib(
+                    program->GetProgram(),
+                    index,
+                    ptr->GetState()
+            );
+            auto ret = WebGLActiveInfoImpl::NewInstance(isolate, new WebGLActiveInfoImpl(
+                    std::move(info)));
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
+
+    args.GetReturnValue().SetUndefined();
+
+}
+
+void WebGLRenderingContext::GetActiveUniform(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto programValue = args[0];
+    auto type = GetNativeType(isolate, programValue);
+    if (type == NativeType::WebGLProgram) {
+        auto index = (int32_t) args[1]->NumberValue(
+                context).ToChecked();
+        auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
+        if (program != nullptr) {
+            auto info = canvas_native_webgl_get_active_uniform(
+                    program->GetProgram(),
+                    index,
+                    ptr->GetState()
+            );
+            auto ret = WebGLActiveInfoImpl::NewInstance(isolate, new WebGLActiveInfoImpl(
+                    std::move(info)));
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
+
+    args.GetReturnValue().SetUndefined();
+
+}
+
+void WebGLRenderingContext::GetAttachedShaders(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    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 info = canvas_native_webgl_get_attached_shaders(
+                    program->GetProgram(),
+                    ptr->GetState()
+            );
+            auto len = info.size();
+            auto array = v8::Array::New(
+                    isolate, (int) len);
+            for (int i = 0; i < len; ++i) {
+                auto shader = WebGLShader::NewInstance(isolate, new WebGLShader(
+                        info[i]));
+                array->Set(context, i, shader);
+            }
+            args.GetReturnValue().Set(array);
+            return;
+        }
+    }
+
+
+    args.GetReturnValue().Set(v8::Array::New(isolate));
+
+}
+
+void WebGLRenderingContext::GetAttribLocation(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto programValue = args[0];
+    auto type = GetNativeType(isolate, programValue);
+
+    if (type == NativeType::WebGLProgram) {
+        auto name = ConvertFromV8String(isolate, args[1]);
+        auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
+        if (program != nullptr) {
+            auto location = canvas_native_webgl_get_attrib_location(
+                    program->GetProgram(),
+                    rust::Str(
+                            name.c_str()),
+                    ptr->GetState()
+            );
+            args.GetReturnValue().Set(location);
+            return;
+        }
+    }
+
+    args.GetReturnValue().Set(-1);
+
+}
+
+void WebGLRenderingContext::GetBufferParameter(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    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()
+        );
+
+        args.GetReturnValue().Set(param);
+        return;
+    }
+
+    args.GetReturnValue().SetUndefined();
+
+}
+
+void WebGLRenderingContext::GetContextAttributes(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto attr = canvas_native_webgl_get_context_attributes(
+            ptr->GetState());
+
+    auto ret = v8::Object::New(isolate);
+
+    auto alpha = canvas_native_webgl_context_attribute_get_get_alpha(
+            *attr);
+
+    ret->Set(context, ConvertToV8String(isolate, "alpha"), v8::Boolean::New(isolate, alpha));
+
+    auto antialias = canvas_native_webgl_context_attribute_get_get_antialias(
+            *attr);
+
+    ret->Set(context, ConvertToV8String(isolate, "antialias"),
+             v8::Boolean::New(isolate, antialias));
+
+    auto depth = canvas_native_webgl_context_attribute_get_get_depth(
+            *attr);
+
+    ret->Set(context, ConvertToV8String(isolate, "depth"), v8::Boolean::New(isolate, depth));
+
+    auto fail_if_major_performance_caveat = canvas_native_webgl_context_attribute_get_get_fail_if_major_performance_caveat(
+            *attr);
+
+    ret->Set(context,
+             ConvertToV8String(isolate, "failIfMajorPerformanceCaveat"),
+             v8::Boolean::New(isolate, fail_if_major_performance_caveat));
+
+    auto power_preference = canvas_native_webgl_context_attribute_get_get_power_preference(
+            *attr);
+
+    ret->Set(context, ConvertToV8String(isolate, "powerPreference"),
+             ConvertToV8OneByteString(isolate, std::move(power_preference)));
+
+    auto premultiplied_alpha = canvas_native_webgl_context_attribute_get_get_premultiplied_alpha(
+            *attr);
+
+    ret->Set(context,
+             ConvertToV8String(isolate, "premultipliedAlpha"),
+             v8::Boolean::New(isolate, premultiplied_alpha));
+
+    auto preserve_drawing_buffer = canvas_native_webgl_context_attribute_get_get_preserve_drawing_buffer(
+            *attr);
+
+    ret->Set(context,
+             ConvertToV8String(isolate, "preserveDrawingBuffer"),
+             v8::Boolean::New(isolate, preserve_drawing_buffer));
+
+    auto stencil = canvas_native_webgl_context_attribute_get_get_stencil(
+            *attr);
+
+    ret->Set(context, ConvertToV8String(isolate, "stencil"),
+             v8::Boolean::New(isolate, stencil));
+
+    auto desynchronized = canvas_native_webgl_context_attribute_get_get_desynchronized(
+            *attr);
+
+    ret->Set(context, ConvertToV8String(isolate, "desynchronized"),
+             v8::Boolean::New(isolate, desynchronized));
+
+    auto xr_compatible = canvas_native_webgl_context_attribute_get_get_xr_compatible(
+            *attr);
+
+    ret->Set(context, ConvertToV8String(isolate, "xrCompatible"),
+             v8::Boolean::New(isolate, xr_compatible));
+
+    args.GetReturnValue().Set(ret);
+
+}
+
+void WebGLRenderingContext::GetError(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().Set(0);
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto ret = canvas_native_webgl_get_error(
+            ptr->GetState());
+
+    args.GetReturnValue().Set((int32_t) ret);
+
+}
+
+void WebGLRenderingContext::GetExtension(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        return nullptr;
+        args.GetReturnValue().SetNull();
+        return;
     }
-    return static_cast<WebGLRenderingContext *>(ptr);
-}
 
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
 
-v8::Local<v8::Value> WebGLRenderingContext::GetParameterInternal(v8::Isolate *isolate,
-                                                                 uint32_t pnameValue,
-                                                                 rust::Box<WebGLResult> result) {
+    auto nameValue = args[0];
 
-    auto context = isolate->GetCurrentContext();
-    v8::EscapableHandleScope scope(isolate);
-    switch (pnameValue) {
-        case GL_ACTIVE_TEXTURE:
-        case GL_ALPHA_BITS:
-        case GL_ARRAY_BUFFER_BINDING:
-        case GL_BLEND_DST_ALPHA:
-        case GL_BLEND_DST_RGB:
-        case GL_BLEND_EQUATION:
-        case GL_BLEND_EQUATION_ALPHA:
-        case GL_BLEND_SRC_ALPHA:
-        case GL_BLEND_SRC_RGB:
-        case GL_BLUE_BITS:
-        case GL_CULL_FACE_MODE:
-        case GL_CURRENT_PROGRAM:
-        case GL_DEPTH_BITS:
-        case GL_DEPTH_FUNC:
-        case GL_ELEMENT_ARRAY_BUFFER_BINDING:
-        case GL_FRAMEBUFFER_BINDING:
-        case GL_FRONT_FACE:
-        case GL_GENERATE_MIPMAP_HINT:
-        case GL_GREEN_BITS:
-        case GL_IMPLEMENTATION_COLOR_READ_FORMAT:
-        case GL_IMPLEMENTATION_COLOR_READ_TYPE:
-        case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
-        case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
-        case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
-        case GL_MAX_RENDERBUFFER_SIZE:
-        case GL_MAX_TEXTURE_IMAGE_UNITS:
-        case GL_MAX_TEXTURE_SIZE:
-        case GL_MAX_VARYING_VECTORS:
-        case GL_MAX_VERTEX_ATTRIBS:
-        case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS:
-        case GL_MAX_VERTEX_UNIFORM_VECTORS:
-        case GL_PACK_ALIGNMENT:
-        case GL_RED_BITS:
-        case GL_RENDERBUFFER_BINDING:
-        case GL_SAMPLE_BUFFERS:
-        case GL_SAMPLES:
-        case GL_STENCIL_BACK_FAIL:
-        case GL_STENCIL_BACK_FUNC:
-        case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
-        case GL_STENCIL_BACK_PASS_DEPTH_PASS:
-        case GL_STENCIL_BACK_REF:
-        case GL_STENCIL_BACK_VALUE_MASK:
-        case GL_STENCIL_BACK_WRITEMASK:
-        case GL_STENCIL_BITS:
-        case GL_STENCIL_CLEAR_VALUE:
-        case GL_STENCIL_FAIL:
-        case GL_STENCIL_FUNC:
-        case GL_STENCIL_PASS_DEPTH_FAIL:
-        case GL_STENCIL_PASS_DEPTH_PASS:
-        case GL_STENCIL_REF:
-        case GL_STENCIL_VALUE_MASK:
-        case GL_STENCIL_WRITEMASK:
-        case GL_SUBPIXEL_BITS:
-        case GL_TEXTURE_BINDING_2D:
-        case GL_TEXTURE_BINDING_CUBE_MAP:
-        case GL_UNPACK_ALIGNMENT: {
-            auto value = canvas_native_webgl_result_get_i32(*result);
-            if ((pnameValue == GL_CURRENT_PROGRAM || pnameValue == GL_ARRAY_BUFFER_BINDING ||
-                 pnameValue == GL_ELEMENT_ARRAY_BUFFER_BINDING ||
-                 pnameValue == GL_TEXTURE_BINDING_2D ||
-                 pnameValue == GL_TEXTURE_BINDING_CUBE_MAP ||
-                 pnameValue == GL_RENDERBUFFER_BINDING ||
-                 pnameValue == GL_FRAMEBUFFER_BINDING) &&
-                value == 0) {
-                return scope.Escape(v8::Null(isolate));
-            }
-            return scope.Escape(v8::Number::New(isolate, (double) 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())));
-        case GL_ALIASED_LINE_WIDTH_RANGE:
-        case GL_ALIASED_POINT_SIZE_RANGE:
-        case GL_DEPTH_RANGE: {
-            auto ret = canvas_native_webgl_result_get_f32_array(*result);
-            auto buf = new VecMutableBuffer<float>(std::move(ret));
+    if (!nameValue->IsString()) {
+        args.GetReturnValue().SetNull();
+        return;
+    }
 
+    auto name = ConvertFromV8String(isolate, nameValue);
 
-            auto store = v8::ArrayBuffer::NewBackingStore(buf->data(), buf->buffer_size(),
-                                                          [](void *data, size_t length,
-                                                             void *deleter_data) {
-                                                              if (deleter_data != nullptr) {
-                                                                  delete (VecMutableBuffer<float> *) deleter_data;
-                                                              }
-                                                          },
-                                                          buf);
+    auto ext = canvas_native_webgl_get_extension(
+            rust::Str(name.c_str()),
+            ptr->GetState());
 
-            auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
+    if (canvas_native_webgl_context_extension_is_none(
+            *ext)) {
+        args.GetReturnValue().SetNull();
+        return;
+    }
 
+    auto type = canvas_native_webgl_context_extension_get_type(
+            *ext);
+    switch (type) {
+        case WebGLExtensionType::OES_fbo_render_mipmap: {
+            auto ret = OES_fbo_render_mipmapImpl::NewInstance(isolate,
+                                                              new OES_fbo_render_mipmapImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::EXT_blend_minmax: {
+            auto ret = EXT_blend_minmaxImpl::NewInstance(isolate, new EXT_blend_minmaxImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::EXT_color_buffer_half_float: {
+            auto ret = EXT_color_buffer_half_floatImpl::NewInstance(isolate,
+                                                                    new EXT_color_buffer_half_floatImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::EXT_disjoint_timer_query: {
+            auto ret = canvas_native_webgl_context_extension_to_ext_disjoint_timer_query(
+                    std::move(ext));
+            auto query = EXT_disjoint_timer_queryImpl::NewInstance(isolate,
+                                                                   new EXT_disjoint_timer_queryImpl(
+                                                                           std::move(ret)));
 
-            return scope.Escape(v8::Float32Array::New(arraybuffer, 0, buf->size()));
+            args.GetReturnValue().Set(query);
+            return;
+        }
+        case WebGLExtensionType::EXT_sRGB: {
+            auto ret = EXT_sRGBImpl::NewInstance(isolate, new EXT_sRGBImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::EXT_shader_texture_lod: {
+            auto ret = EXT_shader_texture_lodImpl::NewInstance(isolate,
+                                                               new EXT_shader_texture_lodImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::EXT_texture_filter_anisotropic: {
+            auto ret = EXT_texture_filter_anisotropicImpl::NewInstance(isolate,
+                                                                       new EXT_texture_filter_anisotropicImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::OES_element_index_uint: {
+            auto ret = OES_element_index_uintImpl::NewInstance(isolate,
+                                                               new OES_element_index_uintImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::OES_standard_derivatives: {
+            auto ret = OES_standard_derivativesImpl::NewInstance(
+                    isolate, new OES_standard_derivativesImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::OES_texture_float: {
+            auto ret = OES_texture_floatImpl::NewInstance(isolate, new OES_texture_floatImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::OES_texture_float_linear: {
+            auto ret = OES_texture_float_linearImpl::NewInstance(isolate,
+                                                                 new OES_texture_float_linearImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::OES_texture_half_float: {
+            auto ret = OES_texture_half_floatImpl::NewInstance(isolate,
+                                                               new OES_texture_half_floatImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::OES_texture_half_float_linear: {
+            auto ret = OES_texture_half_float_linearImpl::NewInstance(isolate,
+                                                                      new OES_texture_half_float_linearImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::OES_vertex_array_object: {
+            auto ret = canvas_native_webgl_context_extension_to_oes_vertex_array_object(
+                    std::move(ext));
+            auto array = OES_vertex_array_objectImpl::NewInstance(isolate,
+                                                                  new OES_vertex_array_objectImpl(
+                                                                          std::move(ret)));
+            args.GetReturnValue().Set(array);
+            return;
+        }
+        case WebGLExtensionType::WEBGL_color_buffer_float: {
+            auto ret = WEBGL_color_buffer_floatImpl::NewInstance(isolate,
+                                                                 new WEBGL_color_buffer_floatImpl());
+            if (ptr->GetVersion() ==
+                WebGLRenderingVersion::V2) {
+                ret->Set(context, ConvertToV8String(isolate, "ext_name"),
+                         ConvertToV8String(isolate, "EXT_color_buffer_float"));
+            }
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::WEBGL_compressed_texture_atc: {
+            auto ret = WEBGL_compressed_texture_atcImpl::NewInstance(isolate,
+                                                                     new WEBGL_compressed_texture_atcImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::WEBGL_compressed_texture_etc1: {
+            auto ret = WEBGL_compressed_texture_etc1Impl::NewInstance(isolate,
+                                                                      new WEBGL_compressed_texture_etc1Impl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::WEBGL_compressed_texture_s3tc: {
+            auto ret = WEBGL_compressed_texture_s3tcImpl::NewInstance(isolate,
+                                                                      new WEBGL_compressed_texture_s3tcImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::WEBGL_compressed_texture_s3tc_srgb: {
+            auto ret = WEBGL_compressed_texture_s3tc_srgbImpl::NewInstance(isolate,
+                                                                           new WEBGL_compressed_texture_s3tc_srgbImpl());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+        case WebGLExtensionType::WEBGL_compressed_texture_etc: {
+            auto ret = WEBGL_compressed_texture_etcImpl::NewInstance(isolate,
+                                                                     new WEBGL_compressed_texture_etcImpl());
+            args.GetReturnValue().Set(ret);
+            return;
         }
-        case GL_BLEND_COLOR:
-        case GL_COLOR_CLEAR_VALUE: {
-            auto ret = canvas_native_webgl_result_get_f32_array(*result);
-
-            auto buf = new VecMutableBuffer<float>(std::move(ret));
-
-            auto store = v8::ArrayBuffer::NewBackingStore(buf->data(), buf->buffer_size(),
-                                                          [](void *data, size_t length,
-                                                             void *deleter_data) {
-                                                              if (deleter_data != nullptr) {
-                                                                  delete (VecMutableBuffer<float> *) deleter_data;
-                                                              }
-                                                          },
-                                                          buf);
-
-            auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
-
-
-            return scope.Escape(v8::Float32Array::New(arraybuffer, 0, buf->size()));
-
+        case WebGLExtensionType::WEBGL_compressed_texture_pvrtc: {
+            auto ret = WEBGL_compressed_texture_pvrtcImpl::NewInstance(isolate,
+                                                                       new WEBGL_compressed_texture_pvrtcImpl());
+            args.GetReturnValue().Set(ret);
+            return;
         }
-        case (uint32_t) GLConstants::UNPACK_FLIP_Y_WEBGL:
-            return scope.Escape(v8::Boolean::New(isolate, canvas_native_webgl_state_get_flip_y(
-                    this->GetState())));
-        case (uint32_t) GLConstants::UNPACK_PREMULTIPLY_ALPHA_WEBGL:
-            return scope.Escape(v8::Boolean::New(isolate,
-                                                 canvas_native_webgl_state_get_premultiplied_alpha(
-                                                         this->GetState())));
-        case GL_BLEND:
-        case GL_CULL_FACE:
-        case GL_DEPTH_TEST:
-        case GL_DEPTH_WRITEMASK:
-        case GL_DITHER:
-        case GL_POLYGON_OFFSET_FILL:
-        case GL_SAMPLE_COVERAGE_INVERT:
-        case GL_SCISSOR_TEST:
-        case GL_STENCIL_TEST:
-            return scope.Escape(
-                    v8::Boolean::New(isolate, canvas_native_webgl_result_get_bool(*result)));
-        case GL_COLOR_WRITEMASK: {
-            auto ret = canvas_native_webgl_result_get_bool_array(*result);
-            auto len = ret.size();
-            auto array = v8::Array::New(isolate, (int) len);
+        case WebGLExtensionType::WEBGL_lose_context: {
+            auto ret = canvas_native_webgl_context_extension_to_lose_context(
+                    std::move(ext));
+            auto ctx = WEBGL_lose_contextImpl::NewInstance(isolate, new WEBGL_lose_contextImpl(
+                    std::move(ret)));
 
-            for (int j = 0; j < len; ++j) {
-                array->Set(context, j, v8::Boolean::New(isolate, ret[j] == 1));
-            }
-            return array;
+            args.GetReturnValue().Set(ctx);
+            return;
         }
-        case GL_COMPRESSED_TEXTURE_FORMATS:
-        case GL_MAX_VIEWPORT_DIMS:
-        case GL_SCISSOR_BOX:
-        case GL_VIEWPORT: {
-            auto ret = canvas_native_webgl_result_get_i32_array(*result);
-            auto buf = new VecMutableBuffer<int32_t>(std::move(ret));
-
-            auto store = v8::ArrayBuffer::NewBackingStore(buf->data(), buf->buffer_size(),
-                                                          [](void *data, size_t length,
-                                                             void *deleter_data) {
-                                                              if (deleter_data != nullptr) {
-                                                                  delete (VecMutableBuffer<int32_t> *) deleter_data;
-                                                              }
-                                                          },
-                                                          buf);
-
-            auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
-
+        case WebGLExtensionType::ANGLE_instanced_arrays: {
+            auto ret = canvas_native_webgl_context_extension_to_angle_instanced_arrays(
+                    std::move(ext));
+            auto instance = ANGLE_instanced_arraysImpl::NewInstance(isolate,
+                                                                    new ANGLE_instanced_arraysImpl(
+                                                                            std::move(ret)));
 
-            return scope.Escape(v8::Int32Array::New(arraybuffer, 0, buf->size()));
+            args.GetReturnValue().Set(instance);
+            return;
         }
-        case GL_DEPTH_CLEAR_VALUE:
-        case GL_LINE_WIDTH:
-        case GL_POLYGON_OFFSET_FACTOR:
-        case GL_POLYGON_OFFSET_UNITS:
-        case GL_SAMPLE_COVERAGE_VALUE: {
-            return scope.Escape(v8::Number::New(isolate,
-                                                static_cast<double>(canvas_native_webgl_result_get_f32(
-                                                        *result))));
+        case WebGLExtensionType::WEBGL_depth_texture: {
+            auto ret = WEBGL_depth_textureImpl::NewInstance(isolate, new WEBGL_depth_textureImpl());
+            args.GetReturnValue().Set(ret);
+            return;
         }
-        case GL_RENDERER:
-        case GL_SHADING_LANGUAGE_VERSION:
-        case GL_VENDOR:
-        case GL_VERSION: {
-            auto ret = canvas_native_webgl_result_get_string(*result);
-
+        case WebGLExtensionType::WEBGL_draw_buffers: {
+            auto ret = canvas_native_webgl_context_extension_to_draw_buffers(
+                    std::move(ext));
 
-            auto value = new OneByteStringResource(std::move(ret));
-            return scope.Escape(v8::String::NewExternalOneByte(isolate, value).ToLocalChecked());
-        }
-        default:
-            return scope.Escape(v8::Null(isolate));
+            auto buffers = WEBGL_draw_buffersImpl::NewInstance(isolate, new WEBGL_draw_buffersImpl(
+                    std::move(ret)));
 
-    }
-}
+            args.GetReturnValue().Set(buffers);
+            return;
 
 
-void
-WebGLRenderingContext::GetDrawingBufferWidth(v8::Local<v8::String> name,
-                                             const v8::PropertyCallbackInfo<v8::Value> &info) {
-    auto ptr = GetPointer(info.This());
-    if (ptr != nullptr) {
-        auto ret = canvas_native_webgl_state_get_drawing_buffer_width(ptr->GetState());
-        info.GetReturnValue().Set(ret);
-        return;
+        }
+        case WebGLExtensionType::None:
+            args.GetReturnValue().SetUndefined();
+            return;
     }
-    info.GetReturnValue().Set(0);
-}
 
-void
-WebGLRenderingContext::GetFlipY(v8::Local<v8::String> name,
-                                const v8::PropertyCallbackInfo<v8::Value> &info) {
-    auto ptr = GetPointer(info.This());
-    if (ptr != nullptr) {
-        auto ret = canvas_native_webgl_state_get_flip_y(ptr->GetState());
-        info.GetReturnValue().Set(ret);
-        return;
-    }
-    info.GetReturnValue().Set(false);
-}
+    args.GetReturnValue().SetUndefined();
 
-void WebGLRenderingContext::GetDrawingBufferHeight(v8::Local<v8::String> name,
-                                                   const v8::PropertyCallbackInfo<v8::Value> &info
-) {
-    auto ptr = GetPointer(info.This());
-    if (ptr != nullptr) {
-        auto ret = canvas_native_webgl_state_get_drawing_buffer_height(ptr->GetState());
-        info.GetReturnValue().Set(ret);
-        return;
-    }
-    info.GetReturnValue().Set(0);
 }
 
-void WebGLRenderingContext::__Resized(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void WebGLRenderingContext::GetFramebufferAttachmentParameter(
+        const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().Set(0);
         return;
     }
 
-    canvas_native_webgl_resized(
-            ptr->GetState());
-
-}
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
 
-void WebGLRenderingContext::__StartRaf(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    WebGLRenderingContext *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
+    auto target = (uint32_t) args[0]->NumberValue(
+            context).ToChecked();
+    auto attachment = (uint32_t) args[1]->NumberValue(
+            context).ToChecked();
+    auto pname = (uint32_t) args[2]->NumberValue(
+            context).ToChecked();
+    auto ret = canvas_native_webgl_get_framebuffer_attachment_parameter(
+            target,
+            attachment,
+            pname,
+            ptr->GetState()
+    );
+    if (canvas_native_webgl_framebuffer_attachment_parameter_get_is_texture(
+            *ret)) {
+        auto value = canvas_native_webgl_framebuffer_attachment_parameter_get_value(
+                *ret);
+        auto texture = WebGLTexture::NewInstance(isolate, new WebGLTexture(
+                value));
+        args.GetReturnValue().Set(texture);
         return;
     }
+    if (canvas_native_webgl_framebuffer_attachment_parameter_get_is_renderbuffer(
+            *ret)) {
+        auto value = canvas_native_webgl_framebuffer_attachment_parameter_get_value(
+                *ret);
+        auto object = WebGLRenderbuffer::NewInstance(isolate, new WebGLRenderbuffer(
+                value));
 
-    ptr->StartRaf();
-
-}
 
-void WebGLRenderingContext::__StopRaf(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    WebGLRenderingContext *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
+        object->Set(context,
+                    ConvertToV8String(isolate, "isRenderbuffer"),
+                    v8::Boolean::New(isolate,
+                                     true));
+        args.GetReturnValue().Set(object);
         return;
-    }
-
-    ptr->StopRaf();
 
-}
-
-void WebGLRenderingContext::ActiveTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    WebGLRenderingContext *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
-        return;
     }
 
-    auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
-    auto texture = (uint32_t) args[0]->NumberValue(context).ToChecked();
-    canvas_native_webgl_active_texture(texture,
-                                       this->GetState());
+    args.GetReturnValue().Set(canvas_native_webgl_framebuffer_attachment_parameter_get_value(
+            *ret));
+
 }
 
-void WebGLRenderingContext::AttachShader(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void WebGLRenderingContext::GetParameter(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().Set(0);
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    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>());
-        }
-
-        if (program == nullptr) {
-            return;
-        }
-
-        if (shader == nullptr) {
-            return;
-        }
-
-        canvas_native_webgl_attach_shader(
-                program->GetProgram(),
-                shader->GetShader(),
-                ptr->GetState()
-        );
+    // 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 ret = ptr->GetParameterInternal(isolate,
+                                             pname,
+                                             std::move(
+                                                     result));
 
+        args.GetReturnValue().Set(ret);
+        return;
     }
+    args.GetReturnValue().SetNull();
 }
 
-void WebGLRenderingContext::BindAttribLocation(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void WebGLRenderingContext::GetProgramInfoLog(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().Set(0);
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 2) {
+    if (args.Length() > 0) {
         auto programValue = args[0];
-
-        if (programValue->IsObject()) {
-            auto type = GetNativeType(isolate, programValue.As<v8::Object>());
-            if (type == NativeType::WebGLProgram && args[1]->IsNumber() &&
-                args[2]->IsString()) {
-                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(
+        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(),
-                        index,
-                        rust::Str(name.c_str()),
-                        this->GetState()
+                        ptr->GetState()
                 );
 
+
+                if (log.empty()) {
+                    args.GetReturnValue().SetEmptyString();
+                    return;
+                }
+
+                args.GetReturnValue().Set(ConvertToV8OneByteString(isolate, std::move(log)));
+                return;
             }
         }
     }
+
+    // todo check return
+    args.GetReturnValue().SetEmptyString();
 }
 
-void WebGLRenderingContext::BindBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void WebGLRenderingContext::GetProgramParameter(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
         return;
     }
 
@@ -403,38 +3140,49 @@ void WebGLRenderingContext::BindBuffer(const v8::FunctionCallbackInfo<v8::Value>
     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,
+        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()
                 );
+
+                if (canvas_native_webgl_result_get_is_none(
+                        *ret)) {
+                    args.GetReturnValue().SetNull();
+                    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));
+                        return;
+                    default:
+                        args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
+                                *ret));
+                        return;
+                }
             }
         }
     }
+
+    // todo check return
+    args.GetReturnValue().SetNull();
 }
 
-void WebGLRenderingContext::BindFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::GetRenderbufferParameter(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
         return;
     }
 
@@ -442,34 +3190,59 @@ void WebGLRenderingContext::BindFramebuffer(const v8::FunctionCallbackInfo<v8::V
     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
-                canvas_native_webgl_bind_frame_buffer(
-                        target,
-                        0,
+        auto target = (uint32_t) args[0]->NumberValue(
+                context).ToChecked();
+        auto pname = (uint32_t) args[1]->NumberValue(
+                context).ToChecked();
+        auto ret = canvas_native_webgl_get_renderbuffer_parameter(
+                target,
+                pname,
+                ptr->GetState()
+        );
+        args.GetReturnValue().Set(ret);
+        return;
+    }
+
+    // todo check return
+    args.GetReturnValue().SetNull();
+}
+
+void WebGLRenderingContext::GetShaderInfoLog(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    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()
                 );
+
+                args.GetReturnValue().Set(ConvertToV8OneByteString(isolate, std::move(log)));
+
+                return;
             }
         }
     }
+
+    // todo check return
+    args.GetReturnValue().SetEmptyString();
 }
 
-void WebGLRenderingContext::BindRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void WebGLRenderingContext::GetShaderParameter(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
         return;
     }
 
@@ -477,35 +3250,51 @@ void WebGLRenderingContext::BindRenderbuffer(const v8::FunctionCallbackInfo<v8::
     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,
+        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();
+                    return;
+                }
+
+                if (pname ==
+                    GL_DELETE_STATUS ||
+                    pname ==
+                    GL_COMPILE_STATUS) {
+                    args.GetReturnValue().Set(canvas_native_webgl_result_get_bool(
+                            *ret));
+                    return;
+                }
+
+                args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
+                        *ret));
+
+                return;
             }
         }
     }
+
+    // todo check return
+    args.GetReturnValue().SetNull();
 }
 
-void WebGLRenderingContext::BindTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::GetShaderPrecisionFormat(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
         return;
     }
 
@@ -513,121 +3302,173 @@ void WebGLRenderingContext::BindTexture(const v8::FunctionCallbackInfo<v8::Value
     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,
+        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(
+                                                                          std::move(ret)));
+        args.GetReturnValue().Set(shader);
+        return;
+    }
+
+    // todo check return
+    args.GetReturnValue().SetNull();
+}
+
+void WebGLRenderingContext::GetShaderSource(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    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()
                 );
+
+                args.GetReturnValue().Set(ConvertToV8OneByteString(isolate, std::move(source)));
+                return;
             }
         }
     }
+
+    // todo check return
+    args.GetReturnValue().SetEmptyString();
 }
 
-void WebGLRenderingContext::BlendColor(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::GetSupportedExtensions(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
+    auto isolate = args.GetIsolate();
     if (ptr == nullptr) {
+        args.GetReturnValue().Set(v8::Array::New(isolate));
         return;
     }
 
-    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 exts = canvas_native_webgl_get_supported_extensions(
+            ptr->GetState());
+    auto len = exts.size();
+    auto array = v8::Array::New(isolate, (int) len);
+    for (int i = 0; i < len; ++i) {
+        auto item = exts[i];
+        array->Set(context, i, ConvertToV8OneByteString(isolate, std::move(item)));
     }
+
+    args.GetReturnValue().Set(array);
 }
 
-void WebGLRenderingContext::BlendEquationSeparate(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::__GetSupportedExtensions(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().SetEmptyString();
         return;
     }
 
     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();
 
-        canvas_native_webgl_blend_equation_separate(
-                modeRGB,
-                modeAlpha,
-                ptr->GetState()
-        );
-    }
+    auto exts = canvas_native_webgl_get_supported_extensions_to_string(
+            ptr->GetState());
+
+    args.GetReturnValue().Set(ConvertToV8OneByteString(isolate, std::move(exts)));
 }
 
-void WebGLRenderingContext::BlendEquation(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::GetTexParameter(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
         return;
     }
 
     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,
+    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();
 }
 
-void WebGLRenderingContext::BlendFuncSeparate(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::GetUniformLocation(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
         return;
     }
 
     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();
+    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]);
 
-        canvas_native_webgl_blend_func_separate(
-                srcRGB,
-                dstRGB,
-                srcAlpha,
-                dstAlpha,
-                ptr->GetState()
-        );
+                auto ret = canvas_native_webgl_get_uniform_location(
+                        program->GetProgram(),
+                        rust::Str(
+                                name.c_str()),
+                        ptr->GetState()
+                );
+
+                auto location = WebGLUniformLocation::NewInstance(isolate, new WebGLUniformLocation(
+                        ret));
+
+                return;
+            }
+        }
     }
+
+    // todo check return
+    args.GetReturnValue().SetNull();
 }
 
-void WebGLRenderingContext::BlendFunc(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::GetUniform(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
         return;
     }
 
@@ -635,210 +3476,332 @@ void WebGLRenderingContext::BlendFunc(const v8::FunctionCallbackInfo<v8::Value>
     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 programValue = args[0];
+        auto programType = GetNativeType(isolate, programValue);
+        auto locationValue = args[1];
+        auto locationType = GetNativeType(isolate, locationValue);
+        if (programType == NativeType::WebGLProgram &&
+            locationType == NativeType::WebGLUniformLocation) {
 
-        canvas_native_webgl_blend_func(
-                sfactor,
-                dfactor,
-                ptr->GetState()
-        );
-    }
-}
+            auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
+            auto location = WebGLUniformLocation::GetPointer(locationValue.As<v8::Object>());
 
-void WebGLRenderingContext::BufferData(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    WebGLRenderingContext *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
-        return;
-    }
 
-    auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
+            if (program != nullptr &&
+                location != nullptr) {
 
-    auto count = args.Length();
+                auto val = canvas_native_webgl_get_uniform(
+                        program->GetProgram(),
+                        location->GetUniformLocation(),
+                        ptr->GetState());
 
-    if (count == 2) {
-        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-        auto usage = (uint32_t) args[1]->NumberValue(context).ToChecked();
+                switch (canvas_native_webgl_result_get_type(
+                        *val)) {
+                    case WebGLResultType::Boolean:
+                        args.GetReturnValue().Set(canvas_native_webgl_result_get_bool(
+                                *val));
+                        return;
+                    case WebGLResultType::None:
+                        args.GetReturnValue().SetNull();
+                        return;
+                    case WebGLResultType::String: {
+                        auto str = canvas_native_webgl_result_get_string(
+                                *val);
 
-        canvas_native_webgl_buffer_data_none(
-                target,
-                0,
-                usage,
-                ptr->GetState()
-        );
-    } else if (count == 3) {
-        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+                        args.GetReturnValue().Set(
+                                ConvertToV8OneByteString(isolate, std::move(str)));
+                        return;
+                    }
+                    case WebGLResultType::BooleanArray: {
+                        auto ret = canvas_native_webgl_result_get_bool_array(
+                                *val);
+                        auto len = ret.size();
+                        auto array = v8::Array::New(
+                                isolate, (int) len);
+                        for (int i = 0;
+                             i < len; ++i) {
+                            auto item = ret[i];
+                            array->Set(
+                                    context, i,
+                                    v8::Boolean::New(isolate,
+                                                     item ==
+                                                     1));
+                        }
+                        args.GetReturnValue().Set(array);
+                        return;
+                    }
+                    case WebGLResultType::F32Array: {
+                        auto ret = canvas_native_webgl_result_get_f32_array(
+                                *val);
 
-        auto usage = (uint32_t) args[2]->NumberValue(context).ToChecked();
+                        auto buf = new VecMutableBuffer<float>(
+                                std::move(
+                                        ret));
 
-        if (args[1]->IsObject()) {
+                        auto store = v8::ArrayBuffer::NewBackingStore(buf->data(),
+                                                                      buf->buffer_size(),
+                                                                      [](void *data, size_t length,
+                                                                         void *deleter_data) {
+                                                                          if (deleter_data !=
+                                                                              nullptr) {
+                                                                              delete (VecMutableBuffer<float> *) deleter_data;
+                                                                          }
+                                                                      },
+                                                                      buf);
 
-            auto sizeOrBuf = args[1];
-            if (sizeOrBuf->IsArrayBufferView()) {
-                if (sizeOrBuf->IsUint16Array()) {
-                    auto array = sizeOrBuf.As<v8::TypedArray>();
-                    auto buf = GetTypedArrayData<const uint16_t>(array);
+                        auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
 
-                    canvas_native_webgl_buffer_data_u16(
-                            target,
-                            buf,
-                            usage,
-                            ptr->GetState()
-                    );
-                } else if (sizeOrBuf->IsFloat32Array()) {
-                    auto array = sizeOrBuf.As<v8::TypedArray>();
-                    auto buf = GetTypedArrayData<const float>(array);
-                    canvas_native_webgl_buffer_data_f32(
-                            target,
-                            buf,
-                            usage,
-                            ptr->GetState()
-                    );
-                } else {
-                    auto array = sizeOrBuf.As<v8::TypedArray>();
-                    auto buf = GetTypedArrayData<const uint8_t>(array);
-                    canvas_native_webgl_buffer_data(
-                            target,
-                            buf,
-                            usage,
-                            ptr->GetState()
-                    );
+
+                        args.GetReturnValue().Set(
+                                v8::Float32Array::New(arraybuffer, 0, buf->size())
+                        );
+
+                        return;
+                    }
+                    case WebGLResultType::I32Array: {
+                        auto ret = canvas_native_webgl_result_get_i32_array(
+                                *val);
+
+                        auto buf = new VecMutableBuffer<int32_t>(
+                                std::move(
+                                        ret));
+
+
+                        auto store = v8::ArrayBuffer::NewBackingStore(buf->data(),
+                                                                      buf->buffer_size(),
+                                                                      [](void *data, size_t length,
+                                                                         void *deleter_data) {
+                                                                          if (deleter_data !=
+                                                                              nullptr) {
+                                                                              delete (VecMutableBuffer<int32_t> *) deleter_data;
+                                                                          }
+                                                                      },
+                                                                      buf);
+
+                        auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
+
+
+                        args.GetReturnValue().Set(
+                                v8::Int32Array::New(arraybuffer, 0, buf->size())
+                        );
+                        return;
+                    }
+                    case WebGLResultType::U32Array: {
+                        auto ret = canvas_native_webgl_result_get_u32_array(
+                                *val);
+
+                        auto buf = new VecMutableBuffer<uint32_t>(
+                                std::move(
+                                        ret));
+
+
+                        auto store = v8::ArrayBuffer::NewBackingStore(buf->data(),
+                                                                      buf->buffer_size(),
+                                                                      [](void *data, size_t length,
+                                                                         void *deleter_data) {
+                                                                          if (deleter_data !=
+                                                                              nullptr) {
+                                                                              delete (VecMutableBuffer<uint32_t> *) deleter_data;
+                                                                          }
+                                                                      },
+                                                                      buf);
+
+                        auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
+
+
+                        args.GetReturnValue().Set(
+                                v8::Uint32Array::New(arraybuffer, 0, buf->size())
+                        );
+                        return;
+
+
+                    }
+                    case WebGLResultType::F32:
+                        args.GetReturnValue().Set((double) canvas_native_webgl_result_get_f32(
+                                *val));
+                        return;
+                    case WebGLResultType::I32:
+                        args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
+                                *val));
+                        return;
+                    case WebGLResultType::U32:
+                        args.GetReturnValue().Set((int32_t) canvas_native_webgl_result_get_u32(
+                                *val));
+                        return;
                 }
-            } else if (sizeOrBuf->IsArrayBuffer()) {
-                auto buffer = sizeOrBuf.As<v8::ArrayBuffer>();
-                auto data = GetArrayBufferData<const uint8_t>(buffer);
-                canvas_native_webgl_buffer_data(
-                        target,
-                        data,
-                        usage,
-                        ptr->GetState()
-                );
             }
-        } else {
-            auto sizeOrBuf = args[1]->NumberValue(context).ToChecked();
-            canvas_native_webgl_buffer_data_none(
-                    target,
-                    static_cast<ssize_t>(sizeOrBuf),
-                    usage,
-                    ptr->GetState()
-            );
         }
     }
+
+    // todo check return
+    args.GetReturnValue().SetNull();
 }
 
-void WebGLRenderingContext::BufferSubData(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::GetVertexAttribOffset(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto count = args.Length();
+    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;
+    }
 
-    if (count == 2) {
-        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-        auto offset = args[1]->NumberValue(context).ToChecked();
+    // todo check return
+    args.GetReturnValue().SetNull();
+}
 
-        canvas_native_webgl_buffer_sub_data_none(
-                target,
-                static_cast<ssize_t>(offset),
-                ptr->GetState()
-        );
-    } else if (count == 3) {
-        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
-        auto offset = args[1]->NumberValue(context).ToChecked();
+void
+WebGLRenderingContext::GetVertexAttrib(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
+        return;
+    }
 
-        if (args[2]->IsObject()) {
-            auto buf = args[2];
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
 
-            if (buf->IsTypedArray()) {
-                auto array = buf.As<v8::TypedArray>();
-                auto buff = GetTypedArrayData<const uint8_t>(array);
-                canvas_native_webgl_buffer_sub_data(
-                        target,
-                        static_cast<ssize_t>(offset),
-                        buff,
-                        ptr->GetState()
-                );
-            } else if (buf->IsArrayBuffer()) {
-                auto arrayBuffer = buf.As<v8::ArrayBuffer>();
 
-                auto data = GetArrayBufferData<const uint8_t>(arrayBuffer);
+    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());
+
+        if (pname ==
+            GL_CURRENT_VERTEX_ATTRIB) {
+            auto val = canvas_native_webgl_result_get_f32_array(
+                    *ret);
+
+            auto buf = new VecMutableBuffer<float>(
+                    std::move(val));
+
+
+            auto store = v8::ArrayBuffer::NewBackingStore(buf->data(), buf->buffer_size(),
+                                                          [](void *data, size_t length,
+                                                             void *deleter_data) {
+                                                              if (deleter_data != nullptr) {
+                                                                  delete (VecMutableBuffer<float> *) deleter_data;
+                                                              }
+                                                          },
+                                                          buf);
+
+            auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
 
-                canvas_native_webgl_buffer_sub_data(
-                        target,
-                        static_cast<rust::isize>(offset),
-                        data,
-                        ptr->GetState()
-                );
-            }
 
-        }
+            args.GetReturnValue().Set(
+                    v8::Float32Array::New(arraybuffer, 0, buf->size())
+            );
 
+            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));
+            return;
+        } else {
+            args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
+                    *ret));
+            return;
+        }
     }
+
+    // todo check return
+    args.GetReturnValue().SetNull();
 }
 
 void
-WebGLRenderingContext::CheckFramebufferStatus(const v8::FunctionCallbackInfo<v8::Value> &args) {
+WebGLRenderingContext::Hint(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto count = args.Length();
-
-    if (count > 0) {
+    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());
+    }
+}
 
-        if (args[0]->IsNumber()) {
-            auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+void
+WebGLRenderingContext::IsBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().Set(false);
+        return;
+    }
 
-            auto ret = canvas_native_webgl_check_frame_buffer_status(
-                    target,
-                    ptr->GetState()
-            );
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
 
-            args.GetReturnValue().Set((int32_t) ret);
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+    if (type == NativeType::WebGLBuffer) {
+        auto buffer = WebGLBuffer::GetPointer(value.As<v8::Object>());
+        if (buffer != nullptr) {
+            auto ret = canvas_native_webgl_is_buffer(
+                    buffer->GetBuffer(),
+                    ptr->GetState());
+            args.GetReturnValue().Set(ret);
             return;
         }
     }
 
-    args.GetReturnValue().Set(0);
+    // todo check return
+    args.GetReturnValue().Set(false);
 }
 
-void WebGLRenderingContext::ClearColor(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::IsContextLost(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().Set(false);
         return;
     }
 
     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 ret = canvas_native_webgl_get_is_context_lost(
+            ptr->GetState());
+    args.GetReturnValue().Set(ret);
 }
 
-void WebGLRenderingContext::ClearDepth(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::IsEnabled(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().Set(false);
         return;
     }
 
@@ -846,106 +3809,160 @@ void WebGLRenderingContext::ClearDepth(const v8::FunctionCallbackInfo<v8::Value>
     auto context = isolate->GetCurrentContext();
 
     if (args.Length() > 0) {
-        auto depth = args[0]->NumberValue(context).ToChecked();
-
-        canvas_native_webgl_clear_depth(
-                static_cast<float>(depth),
-                ptr->GetState()
-        );
+        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);
 }
 
-void WebGLRenderingContext::ClearStencil(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::IsFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().Set(false);
         return;
     }
 
     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 value = args[0];
+    auto type = GetNativeType(isolate, value);
+    if (type == NativeType::WebGLFramebuffer) {
+        auto framebuffer = WebGLFramebuffer::GetPointer(value.As<v8::Object>());
+        if (framebuffer != nullptr) {
+            auto ret = canvas_native_webgl_is_framebuffer(
+                    framebuffer->GetFrameBuffer(),
+                    ptr->GetState());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
     }
+
+    // todo check return
+    args.GetReturnValue().Set(false);
 }
 
-void WebGLRenderingContext::Clear(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::IsProgram(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    //if (count > 0) {
-    auto mask = (uint32_t) args[0]->NumberValue(context).ToChecked();
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+    if (type == NativeType::WebGLProgram) {
+        auto program = WebGLProgram::GetPointer(value.As<v8::Object>());
+        if (program != nullptr) {
+            auto ret = canvas_native_webgl_is_program(
+                    program->GetProgram(),
+                    ptr->GetState());
 
-    canvas_native_webgl_clear(
-            mask,
-            ptr->GetState()
-    );
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
 
-    this->UpdateInvalidateState();
-    // }
+    // todo check return
+    args.GetReturnValue().Set(false);
 }
 
-void WebGLRenderingContext::ColorMask(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::IsRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().Set(false);
         return;
     }
 
     auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
 
-    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 value = args[0];
+    auto type = GetNativeType(isolate, value);
+    if (type == NativeType::WebGLRenderbuffer) {
+        auto renderbuffer = WebGLRenderbuffer::GetPointer(value.As<v8::Object>());
+        if (renderbuffer != nullptr) {
+            auto ret = canvas_native_webgl_is_renderbuffer(
+                    renderbuffer->GetRenderBuffer(),
+                    ptr->GetState());
 
-        canvas_native_webgl_color_mask(
-                red,
-                green,
-                blue,
-                alpha,
-                ptr->GetState()
-        );
+            args.GetReturnValue().Set(ret);
+            return;
+        }
     }
+
+    // todo check return
+    args.GetReturnValue().Set(false);
 }
 
-void WebGLRenderingContext::Commit(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::IsShader(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().Set(false);
         return;
     }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    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 ret = canvas_native_webgl_is_shader(
+                    shader->GetShader(),
+                    ptr->GetState());
+            args.GetReturnValue().Set(ret);
+            return;
+        }
+    }
+
+    // todo check return
+    args.GetReturnValue().Set(false);
 }
 
-void WebGLRenderingContext::CompileShader(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::IsTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
+        args.GetReturnValue().Set(false);
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    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 value = args[0];
+    auto type = GetNativeType(isolate, value);
+    if (type == NativeType::WebGLTexture) {
+        auto texture = WebGLTexture::GetPointer(value.As<v8::Object>());
+        if (texture != nullptr) {
+            auto ret = canvas_native_webgl_is_texture(
+                    texture->GetTexture(),
+                    ptr->GetState());
+            args.GetReturnValue().Set(ret);
+            return;
         }
     }
+
+    // todo check return
+    args.GetReturnValue().Set(false);
 }
 
-void WebGLRenderingContext::CompressedTexImage2D(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::LineWidth(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -954,68 +3971,40 @@ void WebGLRenderingContext::CompressedTexImage2D(const v8::FunctionCallbackInfo<
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto count = args.Length();
+    if (args.Length() > 0) {
+        auto width = args[0]->NumberValue(
+                context).ToChecked();
+        canvas_native_webgl_line_width(
+                static_cast<float>(width),
+                ptr->GetState());
+    }
 
-    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();
+}
 
-        canvas_native_webgl_compressed_tex_image2d_none(
-                target,
-                level,
-                internalformat,
-                width,
-                height,
-                border,
-                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 pixels = args[6];
-        if (pixels->IsObject()) {
-            if (pixels->IsTypedArray()) {
-                auto array = pixels.As<v8::TypedArray>();
-                auto buf = GetTypedArrayData<const uint8_t>(array);
-                canvas_native_webgl_compressed_tex_image2d(
-                        target,
-                        level,
-                        internalformat,
-                        width,
-                        height,
-                        border,
-                        buf,
-                        ptr->GetState()
-                );
-            } else if (pixels->IsArrayBuffer()) {
-                auto ab = pixels.As<v8::ArrayBuffer>();
-                auto buf = GetArrayBufferData<const uint8_t>(ab);
+void
+WebGLRenderingContext::LinkProgram(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
 
-                canvas_native_webgl_compressed_tex_image2d(
-                        target,
-                        level,
-                        internalformat,
-                        width,
-                        height,
-                        border,
-                        buf,
-                        ptr->GetState()
-                );
-            }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+    if (type == NativeType::WebGLProgram) {
+        auto program = WebGLProgram::GetPointer(value.As<v8::Object>());
+        if (program != nullptr) {
+            canvas_native_webgl_link_program(
+                    program->GetProgram(),
+                    ptr->GetState());
         }
     }
 }
 
 void
-WebGLRenderingContext::CompressedTexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &args) {
+WebGLRenderingContext::PixelStorei(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1024,55 +4013,55 @@ WebGLRenderingContext::CompressedTexSubImage2D(const v8::FunctionCallbackInfo<v8
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto count = args.Length();
+    if (args.Length() > 1) {
+        auto pname = (uint32_t) args[0]->NumberValue(
+                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()
+            );
+        }
 
+    }
+}
 
-    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->IsTypedArray()) {
-                auto px = pixels.As<v8::TypedArray>();
-                auto buf = GetTypedArrayData<const uint8_t>(px);
-                canvas_native_webgl_compressed_tex_sub_image2d(
-                        target,
-                        level,
-                        xoffset,
-                        yoffset,
-                        width,
-                        height,
-                        format,
-                        buf,
-                        ptr->GetState()
-                );
-            } else if (pixels->IsArrayBuffer()) {
-                auto buffer = pixels.As<v8::ArrayBuffer>();
-                auto buf = GetArrayBufferData<const uint8_t>(buffer);
+void
+WebGLRenderingContext::PolygonOffset(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
 
-                canvas_native_webgl_compressed_tex_sub_image2d(
-                        target,
-                        level,
-                        xoffset,
-                        yoffset,
-                        width,
-                        height,
-                        format,
-                        buf,
-                        ptr->GetState()
-                );
-            }
-        }
+    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()
+        );
     }
 
 }
 
-void WebGLRenderingContext::CopyTexImage2D(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::ReadPixels(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1081,35 +4070,59 @@ void WebGLRenderingContext::CopyTexImage2D(const v8::FunctionCallbackInfo<v8::Va
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto count = args.Length();
 
+    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();
 
-    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 pixels = args[6];
+        if (pixels->IsTypedArray()) {
+            auto buf = pixels.As<v8::TypedArray>();
+            auto slice = GetTypedArrayData<uint8_t>(buf);
+            canvas_native_webgl_read_pixels_u8(
+                    x,
+                    y,
+                    width,
+                    height,
+                    format,
+                    type,
+                    slice,
+                    ptr->GetState()
+            );
+            return;
+        }
 
-        canvas_native_webgl_copy_tex_image2d(
-                target,
-                level,
-                internalformat,
-                x,
-                y,
-                width,
-                height,
-                border,
-                ptr->GetState()
-        );
+
+        if (pixels->IsArrayBuffer()) {
+            auto buf = pixels.As<v8::ArrayBuffer>();
+            auto slice = GetArrayBufferData<uint8_t>(buf);
+            canvas_native_webgl_read_pixels_u8(
+                    x,
+                    y,
+                    width,
+                    height,
+                    format,
+                    type,
+                    slice,
+                    ptr->GetState()
+            );
+        }
     }
 
 }
 
-void WebGLRenderingContext::CopyTexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::RenderbufferStorage(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1118,26 +4131,18 @@ void WebGLRenderingContext::CopyTexSubImage2D(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 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();
-
-        canvas_native_webgl_copy_tex_sub_image2d(
+    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,
-                level,
-                xoffset,
-                yoffset,
-                x,
-                y,
+                internalFormat,
                 width,
                 height,
                 ptr->GetState()
@@ -1146,136 +4151,192 @@ void WebGLRenderingContext::CopyTexSubImage2D(const v8::FunctionCallbackInfo<v8:
 
 }
 
-void WebGLRenderingContext::CreateBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::SampleCoverage(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().SetNull();
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-
-    auto buffer = canvas_native_webgl_create_buffer(
-            ptr->GetState());
-    if (buffer != 0) {
-        auto ret = WebGLBuffer::NewInstance(isolate, new WebGLBuffer(
-                buffer));
-        args.GetReturnValue().Set(ret);
-        return;
+    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()
+        );
     }
 
-    args.GetReturnValue().SetNull();
-
 }
 
-void WebGLRenderingContext::CreateFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Scissor(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().SetNull();
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-
-    auto buffer = canvas_native_webgl_create_framebuffer(
-            ptr->GetState());
-    if (buffer != 0) {
-        auto ret = WebGLFramebuffer::NewInstance(isolate, new WebGLFramebuffer(
-                buffer));
-        args.GetReturnValue().Set(ret);
-        return;
+    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()
+        );
     }
 
-    args.GetReturnValue().SetNull();
-
 }
 
-void WebGLRenderingContext::CreateProgram(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::ShaderSource(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().SetNull();
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-
-    auto program = canvas_native_webgl_create_program(
-            ptr->GetState());
-    if (program != 0) {
-        auto ret = WebGLProgram::NewInstance(isolate, new WebGLProgram(
-                program));
-        args.GetReturnValue().Set(ret);
-        return;
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+    auto sourceValue = args[1];
+    if (type == NativeType::WebGLShader && sourceValue->IsString()) {
+        auto shader = WebGLShader::GetPointer(value.As<v8::Object>());
+        auto source = ConvertFromV8String(isolate, sourceValue);
+        if (shader != nullptr) {
+            canvas_native_webgl_shader_source(
+                    shader->GetShader(),
+                    rust::Str(
+                            source.c_str()),
+                    ptr->GetState());
+        }
     }
 
-    args.GetReturnValue().SetNull();
-
 }
 
-void WebGLRenderingContext::CreateRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::StencilFuncSeparate(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().SetNull();
         return;
     }
 
     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 buffer = canvas_native_webgl_create_renderbuffer(
-            ptr->GetState());
-    if (buffer != 0) {
-        auto ret = WebGLRenderbuffer::NewInstance(isolate, new WebGLRenderbuffer(
-                buffer));
-        args.GetReturnValue().Set(ret);
+}
+
+void
+WebGLRenderingContext::StencilFunc(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
         return;
     }
 
-    args.GetReturnValue().SetNull();
+    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()
+        );
+    }
 
 }
 
-void WebGLRenderingContext::CreateShader(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::StencilMaskSeparate(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().SetUndefined();
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-
-    if (args.Length() == 0) {
-        args.GetReturnValue().SetUndefined();
-        return;
+    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 type = (uint32_t) args[0]->NumberValue(context).ToChecked();
-    auto shader = canvas_native_webgl_create_shader(
-            type, ptr->GetState());
-    if (shader != 0) {
-        auto ret = WebGLShader::NewInstance(isolate, new WebGLShader(
-                shader));
-        args.GetReturnValue().Set(ret);
+}
+
+void
+WebGLRenderingContext::StencilMask(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
         return;
     }
 
-    args.GetReturnValue().SetUndefined();
+    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()
+        );
+    }
 
 }
 
-void WebGLRenderingContext::CreateTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::StencilOpSeparate(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().SetUndefined();
         return;
     }
 
@@ -1283,20 +4344,28 @@ void WebGLRenderingContext::CreateTexture(const v8::FunctionCallbackInfo<v8::Val
     auto context = isolate->GetCurrentContext();
 
 
-    auto texture = canvas_native_webgl_create_texture(
-            ptr->GetState());
-    if (texture != 0) {
-        auto ret = WebGLTexture::NewInstance(isolate, new WebGLTexture(
-                texture));
-        args.GetReturnValue().Set(ret);
-        return;
+    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()
+        );
     }
 
-    args.GetReturnValue().SetUndefined();
-
 }
 
-void WebGLRenderingContext::CullFace(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::StencilOp(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1305,19 +4374,25 @@ void WebGLRenderingContext::CullFace(const v8::FunctionCallbackInfo<v8::Value> &
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-
-    if (args.Length() > 0) {
-        auto mode = (uint32_t) args[0]->NumberValue(context).ToChecked();
-
-        canvas_native_webgl_cull_face(
-                mode,
+    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()
         );
     }
 
 }
 
-void WebGLRenderingContext::DeleteBuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::TexImage2D(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1326,50 +4401,219 @@ void WebGLRenderingContext::DeleteBuffer(const v8::FunctionCallbackInfo<v8::Valu
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
+    auto count = args.Length();
 
-    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(),
+
+    // TODO tidy
+
+    if (count == 5) {
+        auto target = (int32_t) args[0]->NumberValue(
+                context).ToChecked();
+        auto level = (int32_t) args[1]->NumberValue(
+                context).ToChecked();
+        auto internalformat = (int32_t) args[2]->NumberValue(
+                context).ToChecked();
+        auto format = (int32_t) args[3]->NumberValue(
+                context).ToChecked();
+        auto type = (int32_t) args[4]->NumberValue(
+                context).ToChecked();
+
+        canvas_native_webgl_tex_image2d_image_none(
+                target,
+                level,
+                internalformat,
+                format,
+                type,
+                ptr->GetState()
+        );
+
+    } else if (count == 6) {
+        auto target = (int32_t) args[0]->NumberValue(
+                context).ToChecked();
+        auto level = (int32_t) args[1]->NumberValue(
+                context).ToChecked();
+        auto internalformat = (int32_t) args[2]->NumberValue(
+                context).ToChecked();
+        auto format = (int32_t) args[3]->NumberValue(
+                context).ToChecked();
+        auto type = (int32_t) args[4]->NumberValue(
+                context).ToChecked();
+
+        auto pixels = args[5];
+        auto pixelsType = GetNativeType(isolate, pixels);
+
+        switch (pixelsType) {
+            case NativeType::ImageAsset: {
+                auto image_asset = ImageAssetImpl::GetPointer(pixels.As<v8::Object>());
+
+                if (image_asset !=
+                    nullptr) {
+
+                    canvas_native_webgl_tex_image2d_image_asset(
+                            target,
+                            level,
+                            internalformat,
+                            format,
+                            type,
+                            image_asset->GetImageAsset(),
                             ptr->GetState()
                     );
                 }
+                return;
             }
-        }
-    }
+            case NativeType::ImageBitmap: {
+                auto image_bitmap = ImageBitmapImpl::GetPointer(pixels.As<v8::Object>());
 
-}
+                if (image_bitmap !=
+                    nullptr) {
+                    canvas_native_webgl_tex_image2d_image_asset(
+                            target,
+                            level,
+                            internalformat,
+                            format,
+                            type,
+                            image_bitmap->GetImageAsset(),
+                            ptr->GetState()
+                    );
+                }
+                return;
+            }
+            case NativeType::CanvasRenderingContext2D: {
+                auto canvas_2d = CanvasRenderingContext2DImpl::GetPointer(
+                        pixels.As<v8::Object>());
 
-void WebGLRenderingContext::DeleteFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    WebGLRenderingContext *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
-        return;
-    }
+                if (canvas_2d != nullptr) {
+                    canvas_native_webgl_tex_image2d_canvas2d(
+                            target,
+                            level,
+                            internalformat,
+                            format,
+                            type,
+                            canvas_2d->GetContext(),
+                            ptr->GetState()
+                    );
+                }
 
-    auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
+                return;
+            }
+            case NativeType::WebGLRenderingContext: {
+                auto gl = WebGLRenderingContext::GetPointer(pixels.As<v8::Object>());
+
+                if (gl != nullptr) {
+                    canvas_native_webgl_tex_image2d_webgl(
+                            target,
+                            level,
+                            internalformat,
+                            format,
+                            type,
+                            gl->GetState(),
+                            ptr->GetState()
+                    );
+                }
+                return;
+            }
+            default:
+                break;
+        }
+    } else if (count == 8) {
+        auto target = (int32_t) args[0]->NumberValue(
+                context).ToChecked();
+        auto level = (int32_t) args[1]->NumberValue(
+                context).ToChecked();
+        auto internalformat = (int32_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 format = (int32_t) args[6]->NumberValue(
+                context).ToChecked();
+        auto type = (int32_t) args[7]->NumberValue(
+                context).ToChecked();
+        canvas_native_webgl_tex_image2d_none(
+                target,
+                level,
+                internalformat,
+                width,
+                height,
+                border,
+                format,
+                type,
+                ptr->GetState()
+        );
+    } else if (count == 9) {
+        auto target = (int32_t) args[0]->NumberValue(
+                context).ToChecked();
+        auto level = (int32_t) args[1]->NumberValue(
+                context).ToChecked();
+        auto internalformat = (int32_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 format = (int32_t) args[6]->NumberValue(
+                context).ToChecked();
+        auto type = (int32_t) args[7]->NumberValue(
+                context).ToChecked();
 
 
-    auto value = args[0];
-    auto type = GetNativeType(isolate, value);
-    if (type == NativeType::WebGLFramebuffer) {
-        auto buffer = WebGLFramebuffer::GetPointer(value.As<v8::Object>());
-        if (buffer != nullptr) {
-            canvas_native_webgl_delete_framebuffer(
-                    buffer->GetFrameBuffer(),
-                    this->GetState()
+        auto value = args[8];
+        if (value->IsNullOrUndefined()) {
+            canvas_native_webgl_tex_image2d_none(
+                    target,
+                    level,
+                    internalformat,
+                    width,
+                    height,
+                    border,
+                    format,
+                    type,
+                    ptr->GetState()
+            );
+        } else if (value->IsTypedArray()) {
+            auto typedArray = value.As<v8::TypedArray>();
+            auto buf = GetTypedArrayData<uint8_t>(typedArray);
+            canvas_native_webgl_tex_image2d(
+                    target,
+                    level,
+                    internalformat,
+                    width,
+                    height,
+                    border,
+                    format,
+                    type,
+                    buf,
+                    ptr->GetState()
             );
+            return;
+        } else if (value->IsArrayBuffer()) {
+            auto array = value.As<v8::ArrayBuffer>();
+            auto buf = GetArrayBufferData<uint8_t>(array);
+            canvas_native_webgl_tex_image2d(
+                    target,
+                    level,
+                    internalformat,
+                    width,
+                    height,
+                    border,
+                    format,
+                    type,
+                    buf,
+                    ptr->GetState()
+            );
+            return;
         }
-    }
 
+    }
 }
 
-void WebGLRenderingContext::DeleteProgram(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::TexParameterf(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1378,24 +4622,25 @@ void WebGLRenderingContext::DeleteProgram(const v8::FunctionCallbackInfo<v8::Val
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-
-    auto value = args[0];
-    auto type = GetNativeType(isolate, value);
-
-    if (type == NativeType::WebGLProgram) {
-        auto program = WebGLProgram::GetPointer(value.As<v8::Object>());
-        if (program != nullptr) {
-            canvas_native_webgl_delete_framebuffer(
-                    program->GetProgram(),
-                    ptr->GetState()
-            );
-        }
+    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()
+        );
     }
 
-
 }
 
-void WebGLRenderingContext::DeleteRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::TexParameteri(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1404,24 +4649,25 @@ void WebGLRenderingContext::DeleteRenderbuffer(const v8::FunctionCallbackInfo<v8
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-
-    auto value = args[0];
-    auto type = GetNativeType(isolate, value);
-
-    if (type == NativeType::WebGLProgram) {
-        auto buffer = WebGLRenderbuffer::GetPointer(value.As<v8::Object>());
-        if (buffer != nullptr) {
-            canvas_native_webgl_delete_renderbuffer(
-                    buffer->GetRenderBuffer(),
-                    ptr->GetState()
-            );
-        }
+    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()
+        );
     }
 
-
 }
 
-void WebGLRenderingContext::DeleteShader(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::TexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1430,46 +4676,157 @@ void WebGLRenderingContext::DeleteShader(const v8::FunctionCallbackInfo<v8::Valu
     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 format = (uint32_t) args[4]->NumberValue(
+                context).ToChecked();
+        auto type = (int32_t) args[5]->NumberValue(
+                context).ToChecked();
 
-    auto value = args[0];
-    auto type = GetNativeType(isolate, value);
 
-    if (type == NativeType::WebGLProgram) {
-        auto shader = WebGLShader::GetPointer(value.As<v8::Object>());
-        if (shader != nullptr) {
-            canvas_native_webgl_delete_shader(
-                    shader->GetShader(),
-                    ptr->GetState()
-            );
-        }
-    }
-}
+        auto pixels = args[6];
+        auto pixelsType = GetNativeType(isolate, pixels);
 
-void WebGLRenderingContext::DeleteTexture(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    WebGLRenderingContext *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
-        return;
-    }
+        switch (pixelsType) {
+            case NativeType::ImageAsset: {
+                auto asset = ImageAssetImpl::GetPointer(pixels.As<v8::Object>());
+                if (asset != nullptr) {
+                    canvas_native_webgl_tex_sub_image2d_asset(
+                            target,
+                            level,
+                            xoffset,
+                            yoffset,
+                            format,
+                            type,
+                            asset->GetImageAsset(),
+                            ptr->GetState()
+                    );
+                }
+                return;
+            }
+            case NativeType::ImageBitmap: {
+                auto bitmap = ImageBitmapImpl::GetPointer(pixels.As<v8::Object>());
+
+                if (bitmap != nullptr) {
+                    canvas_native_webgl_tex_sub_image2d_asset(
+                            target,
+                            level,
+                            xoffset,
+                            yoffset,
+                            format,
+                            type,
+                            bitmap->GetImageAsset(),
+                            ptr->GetState()
+                    );
+                }
+                return;
+            }
+            case NativeType::CanvasRenderingContext2D: {
+                auto canvas2d = CanvasRenderingContext2DImpl::GetPointer(pixels.As<v8::Object>());
+
+                if (canvas2d != nullptr) {
+                    canvas_native_webgl_tex_sub_image2d_canvas2d(
+                            target,
+                            level,
+                            xoffset,
+                            yoffset,
+                            format,
+                            type,
+                            canvas2d->GetContext(),
+                            ptr->GetState()
+                    );
+                }
+                return;
+            }
+            case NativeType::WebGLRenderingContext: {
+
+                auto webgl = WebGLRenderingContext::GetPointer(pixels.As<v8::Object>());
+
+                if (webgl != nullptr) {
+                    canvas_native_webgl_tex_sub_image2d_webgl(
+                            target,
+                            level,
+                            xoffset,
+                            yoffset,
+                            format,
+                            type,
+                            webgl->GetState(),
+                            ptr->GetState()
+                    );
+                }
+                return;
+            }
+            default:
+                break;
+        }
 
-    auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
+    } else if (count == 9) {
+        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();
+        auto type = (int32_t) args[7]->NumberValue(
+                context).ToChecked();
 
+        auto pixels = args[8];
 
-    auto value = args[0];
-    auto type = GetNativeType(isolate, value);
 
-    if (type == NativeType::WebGLProgram) {
-        auto texture = WebGLTexture::GetPointer(value.As<v8::Object>());
-        if (texture != nullptr) {
-            canvas_native_webgl_delete_texture(
-                    texture->GetTexture(),
+        if (pixels->IsTypedArray()) {
+            auto array = pixels.As<v8::TypedArray>();
+            auto buf = GetTypedArrayData<const uint8_t>(array);
+            canvas_native_webgl_tex_sub_image2d(
+                    target,
+                    level,
+                    xoffset,
+                    yoffset,
+                    width,
+                    height,
+                    format,
+                    type,
+                    buf,
+                    ptr->GetState()
+            );
+        } else if (pixels->IsArrayBuffer()) {
+            auto array = pixels.As<v8::ArrayBuffer>();
+            auto buf = GetArrayBufferData<const uint8_t>(array);
+            canvas_native_webgl_tex_sub_image2d(
+                    target,
+                    level,
+                    xoffset,
+                    yoffset,
+                    width,
+                    height,
+                    format,
+                    type,
+                    buf,
                     ptr->GetState()
             );
         }
     }
+
 }
 
-void WebGLRenderingContext::DepthFunc(const v8::FunctionCallbackInfo<v8::Value> &args) {
+
+void
+WebGLRenderingContext::VertexAttrib1f(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1478,41 +4835,19 @@ void WebGLRenderingContext::DepthFunc(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-
-    auto value = args[0];
-
-    if (args.Length() > 0) {
-        auto func = (uint32_t) value->NumberValue(context).ToChecked();
-
-        canvas_native_webgl_depth_func(
-                func,
-                ptr->GetState()
-        );
-    }
-}
-
-void WebGLRenderingContext::DepthMask(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    WebGLRenderingContext *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
-        return;
+    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 isolate = args.GetIsolate();
-
-
-    auto value = args[0];
-
-    if (args.Length() > 0) {
-        auto mask = args[0]->BooleanValue(isolate);
-
-        canvas_native_webgl_depth_mask(
-                mask,
-                ptr->GetState()
-        );
-    }
 }
 
-void WebGLRenderingContext::DepthRange(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::VertexAttrib2f(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1521,20 +4856,22 @@ void WebGLRenderingContext::DepthRange(const v8::FunctionCallbackInfo<v8::Value>
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    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()
-        );
+    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());
     }
+
 }
 
-void WebGLRenderingContext::DetachShader(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::VertexAttrib3f(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1543,36 +4880,24 @@ void WebGLRenderingContext::DetachShader(const v8::FunctionCallbackInfo<v8::Valu
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-
-    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>());
-        }
-
-        if (program != nullptr &&
-            shader != nullptr) {
-            canvas_native_webgl_detach_shader(
-                    program->GetProgram(),
-                    shader->GetShader(),
-                    ptr->GetState()
-            );
-        }
+    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());
     }
+
 }
 
 void
-WebGLRenderingContext::DisableVertexAttribArray(const v8::FunctionCallbackInfo<v8::Value> &args) {
+WebGLRenderingContext::VertexAttrib4f(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1581,16 +4906,26 @@ WebGLRenderingContext::DisableVertexAttribArray(const v8::FunctionCallbackInfo<v
     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 = (uint32_t) args[0]->NumberValue(context).ToChecked();
-
-    canvas_native_webgl_disable_vertex_attrib_array(
-            index,
-            ptr->GetState()
-    );
 }
 
-void WebGLRenderingContext::Disable(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::VertexAttrib1fv(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1599,15 +4934,23 @@ 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();
+    if (args.Length() > 1) {
+        auto index = (uint32_t) args[0]->NumberValue(
+                context).ToChecked();
 
-    canvas_native_webgl_disable(
-            cap,
-            ptr->GetState()
-    );
+        auto value = args[1];
+        if (value->IsFloat32Array()) {
+            auto array = value.As<v8::TypedArray>();
+            auto buf = GetTypedArrayData<const float>(array);
+            canvas_native_webgl_vertex_attrib1fv(
+                    index, buf,
+                    ptr->GetState());
+        }
+    }
 }
 
-void WebGLRenderingContext::DrawArrays(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::VertexAttrib2fv(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1616,20 +4959,23 @@ 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();
+    if (args.Length() > 1) {
+        auto index = (uint32_t) args[0]->NumberValue(
+                context).ToChecked();
 
-    canvas_native_webgl_draw_arrays(
-            mode,
-            first,
-            count,
-            ptr->GetState()
-    );
-    this->UpdateInvalidateState();
+        auto value = args[1];
+        if (value->IsFloat32Array()) {
+            auto array = value.As<v8::TypedArray>();
+            auto buf = GetTypedArrayData<const float>(array);
+            canvas_native_webgl_vertex_attrib2fv(
+                    index, buf,
+                    ptr->GetState());
+        }
+    }
 }
 
-void WebGLRenderingContext::DrawElements(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::VertexAttrib3fv(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1638,24 +4984,23 @@ void WebGLRenderingContext::DrawElements(const v8::FunctionCallbackInfo<v8::Valu
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
+    if (args.Length() > 1) {
+        auto index = (uint32_t) args[0]->NumberValue(
+                context).ToChecked();
 
-    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 offset = args[3]->NumberValue(context).ToChecked();
-
-    canvas_native_webgl_draw_elements(
-            mode,
-            count,
-            type,
-            static_cast<ssize_t>(offset),
-            this->GetState()
-    );
-    this->UpdateInvalidateState();
+        auto value = args[1];
+        if (value->IsFloat32Array()) {
+            auto array = value.As<v8::TypedArray>();
+            auto buf = GetTypedArrayData<const float>(array);
+            canvas_native_webgl_vertex_attrib3fv(
+                    index, buf,
+                    ptr->GetState());
+        }
+    }
 }
 
 void
-WebGLRenderingContext::EnableVertexAttribArray(const v8::FunctionCallbackInfo<v8::Value> &args) {
+WebGLRenderingContext::VertexAttrib4fv(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1664,15 +5009,23 @@ WebGLRenderingContext::EnableVertexAttribArray(const v8::FunctionCallbackInfo<v8
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto index = (uint32_t) args[0]->NumberValue(context).ToChecked();
+    if (args.Length() > 1) {
+        auto index = (uint32_t) args[0]->NumberValue(
+                context).ToChecked();
 
-    canvas_native_webgl_enable_vertex_attrib_array(
-            index,
-            ptr->GetState()
-    );
+        auto value = args[1];
+        if (value->IsFloat32Array()) {
+            auto array = value.As<v8::TypedArray>();
+            auto buf = GetTypedArrayData<const float>(array);
+            canvas_native_webgl_vertex_attrib4fv(
+                    index, buf,
+                    ptr->GetState());
+        }
+    }
 }
 
-void WebGLRenderingContext::Enable(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::VertexAttribPointer(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1681,38 +5034,54 @@ 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();
-
-    canvas_native_webgl_enable(
-            cap,
-            ptr->GetState()
-    );
+    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());
+    }
 }
 
-void WebGLRenderingContext::Finish(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Uniform1f(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
     }
 
-    canvas_native_webgl_finish(
-            ptr->GetState()
-    );
-}
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
 
-void WebGLRenderingContext::Flush(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    WebGLRenderingContext *ptr = GetPointer(args.This());
-    if (ptr == nullptr) {
-        return;
+    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();
+    if (location != nullptr) {
+        canvas_native_webgl_uniform1f(
+                location->GetUniformLocation(),
+                static_cast<float>(v0),
+                ptr->GetState()
+        );
     }
-
-    canvas_native_webgl_flush(
-            ptr->GetState()
-    );
+    //   }
+    // }
 }
 
 void
-WebGLRenderingContext::FramebufferRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+WebGLRenderingContext::Uniform2f(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1721,26 +5090,28 @@ 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 renderbufferValue = args[3];
-    auto type = GetNativeType(isolate, renderbufferValue);
-    if (type == NativeType::WebGLRenderbuffer) {
-        auto renderbuffer = WebGLRenderbuffer::GetPointer(renderbufferValue.As<v8::Object>());
-        if (renderbuffer != nullptr) {
-            canvas_native_webgl_framebuffer_renderbuffer(
-                    target,
-                    attachment,
-                    renderbuffertarget,
-                    renderbuffer->GetRenderBuffer(),
-                    ptr->GetState()
-            );
-        }
+    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();
+    auto v1 = args[2]->NumberValue(
+            context).ToChecked();
+    if (location != nullptr) {
+        canvas_native_webgl_uniform2f(
+                location->GetUniformLocation(),
+                static_cast<float>(v0),
+                static_cast<float>(v1),
+                ptr->GetState()
+        );
     }
+    //   }
+    // }
 }
 
-void WebGLRenderingContext::FramebufferTexture2D(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Uniform3f(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1749,28 +5120,31 @@ 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 textureValue = args[3];
-    auto type = GetNativeType(isolate, textureValue);
-    if (type == NativeType::WebGLTexture) {
-        auto texture = WebGLTexture::GetPointer(textureValue.As<v8::Object>());
-        if (texture != nullptr) {
-            canvas_native_webgl_framebuffer_texture2d(
-                    target,
-                    attachment,
-                    textarget,
-                    texture->GetTexture(),
-                    level,
-                    ptr->GetState()
-            );
-        }
+    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();
+    auto v1 = args[2]->NumberValue(
+            context).ToChecked();
+    auto v2 = args[3]->NumberValue(
+            context).ToChecked();
+    if (location != nullptr) {
+        canvas_native_webgl_uniform3f(
+                location->GetUniformLocation(),
+                static_cast<float>(v0),
+                static_cast<float>(v1),
+                static_cast<float>(v2),
+                ptr->GetState()
+        );
     }
+    //   }
+    // }
 }
 
-void WebGLRenderingContext::FrontFace(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Uniform4f(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1779,15 +5153,34 @@ 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();
-
-    canvas_native_webgl_front_face(
-            mode,
-            ptr->GetState()
-    );
+    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();
+    auto v1 = args[2]->NumberValue(
+            context).ToChecked();
+    auto v2 = args[3]->NumberValue(
+            context).ToChecked();
+    auto v3 = args[4]->NumberValue(
+            context).ToChecked();
+    if (location != nullptr) {
+        canvas_native_webgl_uniform4f(
+                location->GetUniformLocation(),
+                static_cast<float>(v0),
+                static_cast<float>(v1),
+                static_cast<float>(v2),
+                static_cast<float>(v3),
+                ptr->GetState()
+        );
+    }
+    //   }
+    // }
 }
 
-void WebGLRenderingContext::GenerateMipmap(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Uniform1fv(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1796,15 +5189,55 @@ 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 locationValue = args[0];
+    auto type = GetNativeType(isolate, locationValue);
+    auto v0Value = args[1];
 
-    canvas_native_webgl_generate_mipmap(
-            target,
-            this->GetState()
-    );
+
+    if (type == NativeType::WebGLUniformLocation) {
+        auto location = WebGLUniformLocation::GetPointer(locationValue.As<v8::Object>());
+
+        if (location != nullptr) {
+            if (v0Value->IsFloat32Array()) {
+                auto array = v0Value.As<v8::TypedArray>();
+                auto buf = GetTypedArrayData<const float>(array);
+                canvas_native_webgl_uniform1fv(
+                        location->GetUniformLocation(),
+                        buf,
+                        ptr->GetState());
+            } else if (v0Value->IsArray()) {
+                auto array = v0Value.As<v8::Array>();
+                auto len = array->Length();
+                std::vector<float> buf;
+                buf.reserve(len);
+                for (int i = 0;
+                     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));
+                    }
+                }
+                rust::Slice<const float> slice(
+                        buf.data(),
+                        buf.size());
+                canvas_native_webgl_uniform1fv(
+                        location->GetUniformLocation(),
+                        slice,
+                        ptr->GetState());
+            }
+        }
+    }
 }
 
-void WebGLRenderingContext::GetActiveAttrib(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Uniform2fv(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1813,29 +5246,55 @@ void WebGLRenderingContext::GetActiveAttrib(const v8::FunctionCallbackInfo<v8::V
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto programValue = args[0];
-    auto type = GetNativeType(isolate, programValue);
-    if (type == NativeType::WebGLProgram) {
-        auto index = (int32_t) args[1]->NumberValue(context).ToChecked();
-        auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
-        if (program != nullptr) {
-            auto info = canvas_native_webgl_get_active_attrib(
-                    program->GetProgram(),
-                    index,
-                    ptr->GetState()
-            );
-            auto ret = WebGLActiveInfoImpl::NewInstance(isolate, new WebGLActiveInfoImpl(
-                    std::move(info)));
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-    }
+    auto locationValue = args[0];
+    auto type = GetNativeType(isolate, locationValue);
+    auto v0Value = args[1];
 
-    args.GetReturnValue().SetUndefined();
 
+    if (type == NativeType::WebGLUniformLocation) {
+        auto location = WebGLUniformLocation::GetPointer(locationValue.As<v8::Object>());
+
+        if (location != nullptr) {
+            if (v0Value->IsFloat32Array()) {
+                auto array = v0Value.As<v8::TypedArray>();
+                auto buf = GetTypedArrayData<const float>(array);
+                canvas_native_webgl_uniform2fv(
+                        location->GetUniformLocation(),
+                        buf,
+                        ptr->GetState());
+            } else if (v0Value->IsArray()) {
+                auto array = v0Value.As<v8::Array>();
+                auto len = array->Length();
+                std::vector<float> buf;
+                buf.reserve(len);
+                for (int i = 0;
+                     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));
+                    }
+                }
+                rust::Slice<const float> slice(
+                        buf.data(),
+                        buf.size());
+                canvas_native_webgl_uniform2fv(
+                        location->GetUniformLocation(),
+                        slice,
+                        ptr->GetState());
+            }
+        }
+    }
 }
 
-void WebGLRenderingContext::GetActiveUniform(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Uniform3fv(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1844,30 +5303,55 @@ void WebGLRenderingContext::GetActiveUniform(const v8::FunctionCallbackInfo<v8::
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto programValue = args[0];
-    auto type = GetNativeType(isolate, programValue);
-    if (type == NativeType::WebGLProgram) {
-        auto index = (int32_t) args[1]->NumberValue(
-                context).ToChecked();
-        auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
-        if (program != nullptr) {
-            auto info = canvas_native_webgl_get_active_uniform(
-                    program->GetProgram(),
-                    index,
-                    this->GetState()
-            );
-            auto ret = WebGLActiveInfoImpl::NewInstance(isolate, new WebGLActiveInfoImpl(
-                    std::move(info)));
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-    }
+    auto locationValue = args[0];
+    auto type = GetNativeType(isolate, locationValue);
+    auto v0Value = args[1];
 
-    args.GetReturnValue().SetUndefined();
 
+    if (type == NativeType::WebGLUniformLocation) {
+        auto location = WebGLUniformLocation::GetPointer(locationValue.As<v8::Object>());
+
+        if (location != nullptr) {
+            if (v0Value->IsFloat32Array()) {
+                auto array = v0Value.As<v8::TypedArray>();
+                auto buf = GetTypedArrayData<const float>(array);
+                canvas_native_webgl_uniform3fv(
+                        location->GetUniformLocation(),
+                        buf,
+                        ptr->GetState());
+            } else if (v0Value->IsArray()) {
+                auto array = v0Value.As<v8::Array>();
+                auto len = array->Length();
+                std::vector<float> buf;
+                buf.reserve(len);
+                for (int i = 0;
+                     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));
+                    }
+                }
+                rust::Slice<const float> slice(
+                        buf.data(),
+                        buf.size());
+                canvas_native_webgl_uniform3fv(
+                        location->GetUniformLocation(),
+                        slice,
+                        ptr->GetState());
+            }
+        }
+    }
 }
 
-void WebGLRenderingContext::GetAttachedShaders(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Uniform4fv(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1876,34 +5360,55 @@ void WebGLRenderingContext::GetAttachedShaders(const v8::FunctionCallbackInfo<v8
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    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 info = canvas_native_webgl_get_attached_shaders(
-                    program->GetProgram(),
-                    ptr->GetState()
-            );
-            auto len = info.size();
-            auto array = v8::Array::New(
-                    isolate, (int) len);
-            for (int i = 0; i < len; ++i) {
-                auto shader = WebGLShader::NewInstance(isolate, new WebGLShader(
-                        info[i]));
-                array->Set(context, i, shader);
-            }
-            args.GetReturnValue().Set(array);
-            return;
-        }
-    }
+    auto locationValue = args[0];
+    auto type = GetNativeType(isolate, locationValue);
+    auto v0Value = args[1];
 
 
-    args.GetReturnValue().Set(v8::Array::New(isolate));
+    if (type == NativeType::WebGLUniformLocation) {
+        auto location = WebGLUniformLocation::GetPointer(locationValue.As<v8::Object>());
 
+        if (location != nullptr) {
+            if (v0Value->IsFloat32Array()) {
+                auto array = v0Value.As<v8::TypedArray>();
+                auto buf = GetTypedArrayData<const float>(array);
+                canvas_native_webgl_uniform4fv(
+                        location->GetUniformLocation(),
+                        buf,
+                        ptr->GetState());
+            } else if (v0Value->IsArray()) {
+                auto array = v0Value.As<v8::Array>();
+                auto len = array->Length();
+                std::vector<float> buf;
+                buf.reserve(len);
+                for (int i = 0;
+                     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));
+                    }
+                }
+                rust::Slice<const float> slice(
+                        buf.data(),
+                        buf.size());
+                canvas_native_webgl_uniform4fv(
+                        location->GetUniformLocation(),
+                        slice,
+                        ptr->GetState());
+            }
+        }
+    }
 }
 
-void WebGLRenderingContext::GetAttribLocation(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Uniform1i(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1912,29 +5417,25 @@ void WebGLRenderingContext::GetAttribLocation(const v8::FunctionCallbackInfo<v8:
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto programValue = args[0];
-    auto type = GetNativeType(isolate, programValue);
-
-    if (type == NativeType::WebGLProgram) {
-        auto name = ConvertFromV8String(isolate, args[1]);
-        auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
-        if (program != nullptr) {
-            auto location = canvas_native_webgl_get_attrib_location(
-                    program->GetProgram(),
-                    rust::Str(
-                            name.c_str()),
-                    ptr->GetState()
-            );
-            args.GetReturnValue().Set(location);
-            return;
-        }
+    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();
+    if (location != nullptr) {
+        canvas_native_webgl_uniform1i(
+                location->GetUniformLocation(),
+                static_cast<int32_t>(v0),
+                ptr->GetState()
+        );
     }
-
-    args.GetReturnValue().Set(-1);
-
+    //   }
+    // }
 }
 
-void WebGLRenderingContext::GetBufferParameter(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Uniform2i(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1943,27 +5444,28 @@ 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,
+    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();
+    auto v1 = args[2]->NumberValue(
+            context).ToChecked();
+    if (location != nullptr) {
+        canvas_native_webgl_uniform2i(
+                location->GetUniformLocation(),
+                static_cast<int32_t>(v0),
+                static_cast<int32_t>(v1),
                 ptr->GetState()
         );
-
-        args.GetReturnValue().Set(param);
-        return;
     }
-
-    args.GetReturnValue().SetUndefined();
-
+    //   }
+    // }
 }
 
-void WebGLRenderingContext::GetBufferParameter(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Uniform3i(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
         return;
@@ -1972,4178 +5474,1009 @@ 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,
+    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();
+    auto v1 = args[2]->NumberValue(
+            context).ToChecked();
+    auto v2 = args[3]->NumberValue(
+            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),
                 ptr->GetState()
         );
-
-        args.GetReturnValue().Set(param);
-        return;
     }
-
-    args.GetReturnValue().SetUndefined();
-
+    //   }
+    // }
 }
 
-void WebGLRenderingContext::GetContextAttributes(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Uniform4i(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().SetUndefined();
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto attr = canvas_native_webgl_get_context_attributes(
-            this->GetState());
-
-    auto ret = v8::Object::New(isolate);
-
-    auto alpha = canvas_native_webgl_context_attribute_get_get_alpha(
-            *attr);
-
-    ret->Set(context, ConvertToV8String(isolate, "alpha"), v8::Boolean::New(isolate, alpha));
-
-    auto antialias = canvas_native_webgl_context_attribute_get_get_antialias(
-            *attr);
-
-    ret->Set(context, ConvertToV8String(isolate, "antialias"),
-             v8::Boolean::New(isolate, antialias));
-
-    auto depth = canvas_native_webgl_context_attribute_get_get_depth(
-            *attr);
-
-    ret->Set(context, ConvertToV8String(isolate, "depth"), v8::Boolean::New(isolate, depth));
-
-    auto fail_if_major_performance_caveat = canvas_native_webgl_context_attribute_get_get_fail_if_major_performance_caveat(
-            *attr);
-
-    ret->Set(context,
-             ConvertToV8String(isolate, "failIfMajorPerformanceCaveat"),
-             v8::Boolean::New(isolate, fail_if_major_performance_caveat));
-
-    auto power_preference = canvas_native_webgl_context_attribute_get_get_power_preference(
-            *attr);
-
-    ret->Set(context, ConvertToV8String(isolate, "powerPreference"),
-             ConvertToV8OneByteString(isolate, std::move(power_preference)));
-
-    auto premultiplied_alpha = canvas_native_webgl_context_attribute_get_get_premultiplied_alpha(
-            *attr);
-
-    ret->Set(context,
-             ConvertToV8String(isolate, "premultipliedAlpha"),
-             v8::Boolean::New(isolate, premultiplied_alpha));
-
-    auto preserve_drawing_buffer = canvas_native_webgl_context_attribute_get_get_preserve_drawing_buffer(
-            *attr);
-
-    ret->Set(context,
-             ConvertToV8String(isolate, "preserveDrawingBuffer"),
-             v8::Boolean::New(isolate, preserve_drawing_buffer));
-
-    auto stencil = canvas_native_webgl_context_attribute_get_get_stencil(
-            *attr);
-
-    ret->Set(context, ConvertToV8String(isolate, "stencil"),
-             v8::Boolean::New(isolate, stencil));
-
-    auto desynchronized = canvas_native_webgl_context_attribute_get_get_desynchronized(
-            *attr);
-
-    ret->Set(context, ConvertToV8String(isolate, "desynchronized"),
-             v8::Boolean::New(isolate, desynchronized));
-
-    auto xr_compatible = canvas_native_webgl_context_attribute_get_get_xr_compatible(
-            *attr);
-
-    ret->Set(context, ConvertToV8String(isolate, "xrCompatible"),
-             v8::Boolean::New(isolate, xr_compatible));
-
-    args.GetReturnValue().Set(ret);
-
+    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();
+    auto v1 = args[2]->NumberValue(
+            context).ToChecked();
+    auto v2 = args[3]->NumberValue(
+            context).ToChecked();
+    auto v3 = args[4]->NumberValue(
+            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),
+                ptr->GetState()
+        );
+    }
+    //   }
+    // }
 }
 
-void WebGLRenderingContext::GetError(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Uniform1iv(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().Set(0);
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto ret = canvas_native_webgl_get_error(
-            this->GetState());
+    auto locationValue = args[0];
+    auto type = GetNativeType(isolate, locationValue);
+    auto v0Value = args[1];
 
-    args.GetReturnValue().Set((int32_t) ret);
 
+    if (type == NativeType::WebGLUniformLocation) {
+        auto location = WebGLUniformLocation::GetPointer(locationValue.As<v8::Object>());
+
+        if (location != nullptr) {
+            if (v0Value->IsInt32Array()) {
+                auto array = v0Value.As<v8::TypedArray>();
+                auto buf = GetTypedArrayData<const int32_t>(array);
+                canvas_native_webgl_uniform1iv(
+                        location->GetUniformLocation(),
+                        buf,
+                        ptr->GetState());
+            } else if (v0Value->IsArray()) {
+                auto array = v0Value.As<v8::Array>();
+                auto len = array->Length();
+                std::vector<int32_t> buf;
+                buf.reserve(len);
+                for (int i = 0;
+                     i < len; ++i) {
+                    auto item = array->Get(
+                            context, i).ToLocalChecked();
+
+                    auto value = item->NumberValue(
+                            context).ToChecked();
+                    buf.push_back(
+                            static_cast<int32_t>(value));
+                }
+                rust::Slice<const int32_t> slice(
+                        buf.data(),
+                        buf.size());
+                canvas_native_webgl_uniform1iv(
+                        location->GetUniformLocation(),
+                        slice,
+                        ptr->GetState());
+            }
+        }
+    }
 }
 
-void WebGLRenderingContext::GetExtension(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Uniform2iv(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().SetNull();
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    auto nameValue = args[0];
-
-    if (!nameValue->IsString()) {
-        args.GetReturnValue().SetNull();
-        return;
-    }
-
-    auto name = ConvertFromV8String(isolate, nameValue);
-
-    auto ext = canvas_native_webgl_get_extension(
-            rust::Str(name.c_str()),
-            ptr->GetState());
+    auto locationValue = args[0];
+    auto type = GetNativeType(isolate, locationValue);
+    auto v0Value = args[1];
 
-    if (canvas_native_webgl_context_extension_is_none(
-            *ext)) {
-        args.GetReturnValue().SetNull();
-        return;
-    }
 
-    auto type = canvas_native_webgl_context_extension_get_type(
-            *ext);
-    switch (type) {
-        case WebGLExtensionType::OES_fbo_render_mipmap: {
-            auto ret = OES_fbo_render_mipmapImpl::NewInstance(isolate,
-                                                              new OES_fbo_render_mipmapImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::EXT_blend_minmax: {
-            auto ret = EXT_blend_minmaxImpl::NewInstance(isolate, new EXT_blend_minmaxImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::EXT_color_buffer_half_float: {
-            auto ret = EXT_color_buffer_half_floatImpl::NewInstance(isolate,
-                                                                    new EXT_color_buffer_half_floatImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::EXT_disjoint_timer_query: {
-            auto ret = canvas_native_webgl_context_extension_to_ext_disjoint_timer_query(
-                    std::move(ext));
-            auto query = EXT_disjoint_timer_queryImpl::NewInstance(isolate,
-                                                                   new EXT_disjoint_timer_queryImpl(
-                                                                           std::move(ret)));
+    if (type == NativeType::WebGLUniformLocation) {
+        auto location = WebGLUniformLocation::GetPointer(locationValue.As<v8::Object>());
 
-            args.GetReturnValue().Set(query);
-            return;
-        }
-        case WebGLExtensionType::EXT_sRGB: {
-            auto ret = EXT_sRGBImpl::NewInstance(isolate, new EXT_sRGBImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::EXT_shader_texture_lod: {
-            auto ret = EXT_shader_texture_lodImpl::NewInstance(isolate,
-                                                               new EXT_shader_texture_lodImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::EXT_texture_filter_anisotropic: {
-            auto ret = EXT_texture_filter_anisotropicImpl::NewInstance(isolate,
-                                                                       new EXT_texture_filter_anisotropicImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::OES_element_index_uint: {
-            auto ret = OES_element_index_uintImpl::NewInstance(isolate,
-                                                               new OES_element_index_uintImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::OES_standard_derivatives: {
-            auto ret = OES_standard_derivativesImpl::NewInstance(
-                    new OES_standard_derivativesImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::OES_texture_float: {
-            auto ret = OES_texture_floatImpl::NewInstance(isolate, new OES_texture_floatImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::OES_texture_float_linear: {
-            auto ret = OES_texture_float_linearImpl::NewInstance(isolate,
-                                                                 new OES_texture_float_linearImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::OES_texture_half_float: {
-            auto ret = OES_texture_half_floatImpl::NewInstance(isolate,
-                                                               new OES_texture_half_floatImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::OES_texture_half_float_linear: {
-            auto ret = OES_texture_half_float_linearImpl::NewInstance(isolate,
-                                                                      new OES_texture_half_float_linearImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::OES_vertex_array_object: {
-            auto ret = canvas_native_webgl_context_extension_to_oes_vertex_array_object(
-                    std::move(ext));
-            auto array = OES_vertex_array_objectImpl::NewInstance(isolate,
-                                                                  new OES_vertex_array_objectImpl(
-                                                                          std::move(ret)));
-            args.GetReturnValue().Set(array);
-            return;
-        }
-        case WebGLExtensionType::WEBGL_color_buffer_float: {
-            auto ret = WEBGL_color_buffer_floatImpl::NewInstance(isolate,
-                                                                 new WEBGL_color_buffer_floatImpl());
-            if (this->GetVersion() ==
-                WebGLRenderingVersion::V2) {
-                ret->Set(context, ConvertToV8String(isolate, "ext_name"),
-                         ConvertToV8String(isolate, "EXT_color_buffer_float"));
+        if (location != nullptr) {
+            if (v0Value->IsInt32Array()) {
+                auto array = v0Value.As<v8::TypedArray>();
+                auto buf = GetTypedArrayData<const int32_t>(array);
+                canvas_native_webgl_uniform2iv(
+                        location->GetUniformLocation(),
+                        buf,
+                        ptr->GetState());
+            } else if (v0Value->IsArray()) {
+                auto array = v0Value.As<v8::Array>();
+                auto len = array->Length();
+                std::vector<int32_t> buf;
+                buf.reserve(len);
+                for (int i = 0;
+                     i < len; ++i) {
+                    auto item = array->Get(
+                            context, i).ToLocalChecked();
+
+                    auto value = item->NumberValue(
+                            context).ToChecked();
+                    buf.push_back(
+                            static_cast<int32_t>(value));
+                }
+                rust::Slice<const int32_t> slice(
+                        buf.data(),
+                        buf.size());
+                canvas_native_webgl_uniform2iv(
+                        location->GetUniformLocation(),
+                        slice,
+                        ptr->GetState());
             }
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::WEBGL_compressed_texture_atc: {
-            auto ret = WEBGL_compressed_texture_atcImpl::NewInstance(isolate,
-                                                                     new WEBGL_compressed_texture_atcImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::WEBGL_compressed_texture_etc1: {
-            auto ret = WEBGL_compressed_texture_etc1Impl::NewInstance(isolate,
-                                                                      new WEBGL_compressed_texture_etc1Impl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::WEBGL_compressed_texture_s3tc: {
-            auto ret = WEBGL_compressed_texture_s3tcImpl::NewInstance(isolate,
-                                                                      new WEBGL_compressed_texture_s3tcImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::WEBGL_compressed_texture_s3tc_srgb: {
-            auto ret = WEBGL_compressed_texture_s3tc_srgbImpl::NewInstance(isolate,
-                                                                           new WEBGL_compressed_texture_s3tc_srgbImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::WEBGL_compressed_texture_etc: {
-            auto ret = WEBGL_compressed_texture_etcImpl::NewInstance(isolate,
-                                                                     new WEBGL_compressed_texture_etcImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::WEBGL_compressed_texture_pvrtc: {
-            auto ret = WEBGL_compressed_texture_pvrtcImpl::NewInstance(isolate,
-                                                                       new WEBGL_compressed_texture_pvrtcImpl());
-            args.GetReturnValue().Set(ret);
-            return;
         }
-        case WebGLExtensionType::WEBGL_lose_context: {
-            auto ret = canvas_native_webgl_context_extension_to_lose_context(
-                    std::move(ext));
-            auto ctx = WEBGL_lose_contextImpl::NewInstance(isolate, new WEBGL_lose_contextImpl(
-                    std::move(ret)));
+    }
+}
 
-            args.GetReturnValue().Set(ctx);
-            return;
-        }
-        case WebGLExtensionType::ANGLE_instanced_arrays: {
-            auto ret = canvas_native_webgl_context_extension_to_angle_instanced_arrays(
-                    std::move(ext));
-            auto instance = ANGLE_instanced_arraysImpl::NewInstance(isolate,
-                                                                    new ANGLE_instanced_arraysImpl(
-                                                                            std::move(ret)));
+void
+WebGLRenderingContext::Uniform3iv(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
 
-            args.GetReturnValue().Set(instance);
-            return;
-        }
-        case WebGLExtensionType::WEBGL_depth_texture: {
-            auto ret = WEBGL_depth_textureImpl::NewInstance(isolate, new WEBGL_depth_textureImpl());
-            args.GetReturnValue().Set(ret);
-            return;
-        }
-        case WebGLExtensionType::WEBGL_draw_buffers: {
-            auto ret = canvas_native_webgl_context_extension_to_draw_buffers(
-                    std::move(ext));
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
 
-            auto buffers = WEBGL_draw_buffersImpl::NewInstance(isolate, new WEBGL_draw_buffersImpl(
-                    std::move(ret)));
+    auto locationValue = args[0];
+    auto type = GetNativeType(isolate, locationValue);
+    auto v0Value = args[1];
 
-            args.GetReturnValue().Set(buffers);
-            return;
 
+    if (type == NativeType::WebGLUniformLocation) {
+        auto location = WebGLUniformLocation::GetPointer(locationValue.As<v8::Object>());
 
+        if (location != nullptr) {
+            if (v0Value->IsInt32Array()) {
+                auto array = v0Value.As<v8::TypedArray>();
+                auto buf = GetTypedArrayData<const int32_t>(array);
+                canvas_native_webgl_uniform3iv(
+                        location->GetUniformLocation(),
+                        buf,
+                        ptr->GetState());
+            } else if (v0Value->IsArray()) {
+                auto array = v0Value.As<v8::Array>();
+                auto len = array->Length();
+                std::vector<int32_t> buf;
+                buf.reserve(len);
+                for (int i = 0;
+                     i < len; ++i) {
+                    auto item = array->Get(
+                            context, i).ToLocalChecked();
+
+                    auto value = item->NumberValue(
+                            context).ToChecked();
+                    buf.push_back(
+                            static_cast<int32_t>(value));
+                }
+                rust::Slice<const int32_t> slice(
+                        buf.data(),
+                        buf.size());
+                canvas_native_webgl_uniform3iv(
+                        location->GetUniformLocation(),
+                        slice,
+                        ptr->GetState());
+            }
         }
-        case WebGLExtensionType::None:
-            args.GetReturnValue().SetUndefined();
-            return;
     }
-
-    args.GetReturnValue().SetUndefined();
-
 }
 
-void WebGLRenderingContext::GetFramebufferAttachmentParameter(
-        const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Uniform4iv(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().Set(0);
         return;
     }
 
     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 pname = (uint32_t) args[2]->NumberValue(
-            context).ToChecked();
-    auto ret = canvas_native_webgl_get_framebuffer_attachment_parameter(
-            target,
-            attachment,
-            pname,
-            ptr->GetState()
-    );
-    if (canvas_native_webgl_framebuffer_attachment_parameter_get_is_texture(
-            *ret)) {
-        auto value = canvas_native_webgl_framebuffer_attachment_parameter_get_value(
-                *ret);
-        auto texture = WebGLTexture::NewInstance(isolate, new WebGLTexture(
-                value));
-        args.GetReturnValue().Set(texture);
-        return;
-    }
-    if (canvas_native_webgl_framebuffer_attachment_parameter_get_is_renderbuffer(
-            *ret)) {
-        auto value = canvas_native_webgl_framebuffer_attachment_parameter_get_value(
-                *ret);
-        auto object = WebGLRenderbuffer::NewInstance(isolate, new WebGLRenderbuffer(
-                value));
+    auto locationValue = args[0];
+    auto type = GetNativeType(isolate, locationValue);
+    auto v0Value = args[1];
+
 
+    if (type == NativeType::WebGLUniformLocation) {
+        auto location = WebGLUniformLocation::GetPointer(locationValue.As<v8::Object>());
+
+        if (location != nullptr) {
+            if (v0Value->IsInt32Array()) {
+                auto array = v0Value.As<v8::TypedArray>();
+                auto buf = GetTypedArrayData<const int32_t>(array);
+                canvas_native_webgl_uniform4iv(
+                        location->GetUniformLocation(),
+                        buf,
+                        ptr->GetState());
+            } else if (v0Value->IsArray()) {
+                auto array = v0Value.As<v8::Array>();
+                auto len = array->Length();
+                std::vector<int32_t> buf;
+                buf.reserve(len);
+                for (int i = 0;
+                     i < len; ++i) {
+                    auto item = array->Get(
+                            context, i).ToLocalChecked();
+
+                    auto value = item->NumberValue(
+                            context).ToChecked();
+                    buf.push_back(
+                            static_cast<int32_t>(value));
+                }
+                rust::Slice<const int32_t> slice(
+                        buf.data(),
+                        buf.size());
+                canvas_native_webgl_uniform4iv(
+                        location->GetUniformLocation(),
+                        slice,
+                        ptr->GetState());
+            }
+        }
+    }
+}
 
-        object->Set(context,
-                    ConvertToV8String(isolate, "isRenderbuffer"),
-                    v8::Boolean::New(isolate,
-                                     true));
-        args.GetReturnValue().Set(object);
+void
+WebGLRenderingContext::UniformMatrix2fv(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGLRenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
         return;
-
     }
 
-    args.GetReturnValue().Set(canvas_native_webgl_framebuffer_attachment_parameter_get_value(
-            *ret));
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto locationValue = args[0];
+    auto locationType = GetNativeType(isolate, locationValue);
+    auto value = args[2];
+    if (locationType == NativeType::WebGLUniformLocation) {
+
+        auto location = WebGLUniformLocation::GetPointer(locationValue.As<v8::Object>());
+        auto transpose = args[1]->BooleanValue(isolate);
+
+        if (location != nullptr) {
+            if (value->IsFloat32Array()) {
+                auto array = value.As<v8::TypedArray>();
+                auto buf = GetTypedArrayData<const float>(array);
+                canvas_native_webgl_uniform_matrix2fv(
+                        location->GetUniformLocation(),
+                        transpose, buf,
+                        ptr->GetState());
+            } else if (value->IsArray()) {
+                auto array = value.As<v8::Array>();
+                auto len = array->Length();
+                std::vector<float> buf;
+                buf.reserve(len);
+
+                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(
+                                        ""));
+                    }
+                }
 
+                rust::Slice<const float> slice(
+                        buf.data(),
+                        buf.size());
+                canvas_native_webgl_uniform_matrix2fv(
+                        location->GetUniformLocation(),
+                        transpose, slice,
+                        ptr->GetState());
+            }
+        }
+    }
 }
 
-void WebGLRenderingContext::GetParameter(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::UniformMatrix3fv(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().Set(0);
         return;
     }
 
     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 ret = GetParameterInternal(isolate,
-                                        pname,
-                                        std::move(
-                                                result));
+    auto locationValue = args[0];
+    auto locationType = GetNativeType(isolate, locationValue);
+    auto value = args[2];
+    if (locationType == NativeType::WebGLUniformLocation) {
+
+        auto location = WebGLUniformLocation::GetPointer(locationValue.As<v8::Object>());
+        auto transpose = args[1]->BooleanValue(isolate);
+
+        if (location != nullptr) {
+            if (value->IsFloat32Array()) {
+                auto array = value.As<v8::TypedArray>();
+                auto buf = GetTypedArrayData<const float>(array);
+                canvas_native_webgl_uniform_matrix3fv(
+                        location->GetUniformLocation(),
+                        transpose, buf,
+                        ptr->GetState());
+            } else if (value->IsArray()) {
+                auto array = value.As<v8::Array>();
+                auto len = array->Length();
+                std::vector<float> buf;
+                buf.reserve(len);
+
+                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(
+                                        ""));
+                    }
+                }
 
-        args.GetReturnValue().Set(ret);
-        return;
+                rust::Slice<const float> slice(
+                        buf.data(),
+                        buf.size());
+                canvas_native_webgl_uniform_matrix3fv(
+                        location->GetUniformLocation(),
+                        transpose, slice,
+                        ptr->GetState());
+            }
+        }
     }
-    args.GetReturnValue().SetNull();
 }
 
-void WebGLRenderingContext::GetProgramInfoLog(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::UniformMatrix4fv(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().Set(0);
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    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()
-                );
-
-
-                if (log.empty()) {
-                    args.GetReturnValue().SetEmptyString();
-                    return;
+    auto locationValue = args[0];
+    auto locationType = GetNativeType(isolate, locationValue);
+    auto value = args[2];
+    if (locationType == NativeType::WebGLUniformLocation) {
+
+        auto location = WebGLUniformLocation::GetPointer(locationValue.As<v8::Object>());
+        auto transpose = args[1]->BooleanValue(isolate);
+
+        if (location != nullptr) {
+            if (value->IsFloat32Array()) {
+                auto array = value.As<v8::TypedArray>();
+                auto buf = GetTypedArrayData<const float>(array);
+                canvas_native_webgl_uniform_matrix4fv(
+                        location->GetUniformLocation(),
+                        transpose, buf,
+                        ptr->GetState());
+            } else if (value->IsArray()) {
+                auto array = value.As<v8::Array>();
+                auto len = array->Length();
+                std::vector<float> buf;
+                buf.reserve(len);
+
+                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(
+                                        ""));
+                    }
                 }
 
-                args.GetReturnValue().Set(ConvertToV8OneByteString(isolate, std::move(log)));
-                return;
+                rust::Slice<const float> slice(
+                        buf.data(),
+                        buf.size());
+                canvas_native_webgl_uniform_matrix4fv(
+                        location->GetUniformLocation(),
+                        transpose, slice,
+                        ptr->GetState());
             }
         }
     }
-
-    // todo check return
-    args.GetReturnValue().SetEmptyString();
 }
 
-void WebGLRenderingContext::GetProgramParameter(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::UseProgram(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().SetNull();
         return;
     }
 
     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 (args.Length() > 0) {
+        auto value = args[0];
+        if (value->IsNull()) {
+            canvas_native_webgl_use_program(0,
+                                            ptr->GetState());
+
+            return;
+        }
+
+        auto type = GetNativeType(isolate, value);
         if (type == NativeType::WebGLProgram) {
-            auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
+            auto program = WebGLProgram::GetPointer(value.As<v8::Object>());
             if (program != nullptr) {
-                auto ret = canvas_native_webgl_get_program_parameter(
+                canvas_native_webgl_use_program(
                         program->GetProgram(),
-                        pname,
                         ptr->GetState()
                 );
-
-                if (canvas_native_webgl_result_get_is_none(
-                        *ret)) {
-                    args.GetReturnValue().SetNull();
-                    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));
-                        return;
-                    default:
-                        args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
-                                *ret));
-                        return;
-                }
             }
         }
     }
 
-    // todo check return
-    args.GetReturnValue().SetNull();
 }
 
-void WebGLRenderingContext::GetRenderbufferParameter(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::ValidateProgram(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().SetNull();
         return;
     }
 
     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_renderbuffer_parameter(
-                target,
-                pname,
-                ptr->GetState()
-        );
-        args.GetReturnValue().Set(ret);
-        return;
+    auto value = args[0];
+    auto type = GetNativeType(isolate, value);
+    if (type == NativeType::WebGLProgram) {
+        auto program = WebGLProgram::GetPointer(value.As<v8::Object>());
+        if (program != nullptr) {
+            canvas_native_webgl_validate_program(
+                    program->GetProgram(),
+                    ptr->GetState()
+            );
+        }
     }
 
-    // todo check return
-    args.GetReturnValue().SetNull();
 }
 
-void WebGLRenderingContext::GetRenderbufferParameter(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::Viewport(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().SetNull();
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    if (args.Length() > 1) {
-        auto target = (uint32_t) args[0]->NumberValue(
+    if (args.Length() > 3) {
+        auto x = (int32_t) args[0]->NumberValue(
                 context).ToChecked();
-        auto pname = (uint32_t) args[1]->NumberValue(
+        auto y = (int32_t) args[1]->NumberValue(
                 context).ToChecked();
-        auto ret = canvas_native_webgl_get_renderbuffer_parameter(
-                target,
-                pname,
-                ptr->GetState()
-        );
-        args.GetReturnValue().Set(ret);
-        return;
+        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());
     }
 
-    // todo check return
-    args.GetReturnValue().SetNull();
 }
 
-void WebGLRenderingContext::GetShaderInfoLog(const v8::FunctionCallbackInfo<v8::Value> &args) {
+void
+WebGLRenderingContext::__ToDataURL(const v8::FunctionCallbackInfo<v8::Value> &args) {
     WebGLRenderingContext *ptr = GetPointer(args.This());
     if (ptr == nullptr) {
-        args.GetReturnValue().SetNull();
+        args.GetReturnValue().SetEmptyString();
         return;
     }
 
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
 
-    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()
-                );
+    std::string type("image/png");
+    int quality = 92;
+    if (args[0]->IsString()) {
+        type = ConvertFromV8String(isolate, args[0]);
+    }
 
-                 args.GetReturnValue().Set(ConvertToV8OneByteString(isolate, std::move(log)));
 
-                 return;
-            }
-        }
+    if (args[1]->IsNumber()) {
+        quality = (int) args[1]->NumberValue(
+                context).ToChecked();
     }
 
-    // todo check return
-    args.GetReturnValue().SetEmptyString();
+
+    auto data = canvas_native_webgl_to_data_url(
+            ptr->GetState(),
+            rust::Str(type.c_str()),
+            quality);
+    args.GetReturnValue().Set(ConvertToV8OneByteString(isolate, std::move(data)));
+
 }
 
+void WebGLRenderingContext::SetConstants(v8::Isolate *isolate, const v8::Local<v8::ObjectTemplate>& tmpl) {
+    tmpl->Set(isolate, "DEPTH_BUFFER_BIT", v8::Uint32::New(isolate, 0x00000100));
 
-std::vector<jsi::PropNameID> WebGLRenderingContext::getPropertyNames(jsi::Runtime &rt) {
-    std::vector<jsi::PropNameID> ret;
-    ret.reserve(436);
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "__resized"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "__startRaf"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "__stopRaf"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("activeTexture")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("attachShader")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("bindAttribLocation")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("bindBuffer")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("bindFramebuffer")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("bindRenderbuffer")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("bindTexture")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("blendColor")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("blendEquationSeparate")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("blendEquation")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("blendFuncSeparate")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("blendFunc")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("bufferData")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("bufferSubData")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("checkFramebufferStatus")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("clearColor")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("clearDepth")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("clearStencil")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("clear")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("colorMask")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("commit")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("compileShader")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("compressedTexImage2D")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("compressedTexSubImage2D")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("copyTexImage2D")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("copyTexSubImage2D")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("createBuffer")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("createFramebuffer")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("createProgram")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("createRenderbuffer")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("createShader")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("createTexture")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("cullFace")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("deleteBuffer")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("deleteFramebuffer")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("deleteProgram")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("deleteRenderbuffer")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("deleteShader")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("deleteTexture")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("depthFunc")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("depthMask")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("depthRange")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("detachShader")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("disableVertexAttribArray")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("disable")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("drawArrays")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("drawElements")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("enableVertexAttribArray")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("enable")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("finish")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("flush")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("framebufferRenderbuffer")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("framebufferTexture2D")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("frontFace")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("generateMipmap")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getActiveAttrib")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getActiveUniform")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getAttachedShaders")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getAttribLocation")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getBufferParameter")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getContextAttributes")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getError")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getExtension")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getFramebufferAttachmentParameter")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getParameter")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getProgramInfoLog")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getProgramParameter")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getRenderbufferParameter")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getShaderInfoLog")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getShaderParameter")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getShaderPrecisionFormat")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getShaderSource")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getSupportedExtensions")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getTexParameter")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getUniformLocation")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getUniform")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getVertexAttribOffset")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("getVertexAttrib")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("hint")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("isBuffer")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("isContextLost")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("isEnabled")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("isFramebuffer")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("isProgram")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("isRenderbuffer")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("isShader")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("isTexture")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("lineWidth")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("linkProgram")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("pixelStorei")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("polygonOffset")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("readPixels")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("renderbufferStorage")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("sampleCoverage")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("scissor")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("shaderSource")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("stencilFuncSeparate")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("stencilFunc")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("stencilMaskSeparate")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("stencilMask")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("stencilOpSeparate")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("stencilOp")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("texImage2D")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("texParameterf")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("texParameteri")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("texSubImage2D")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform1f")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform1iv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform1fv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform1i")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform2f")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform2iv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform2fv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform2i")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform3f")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform3iv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform3fv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform3i")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform4f")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform4iv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform4fv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniform4i")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniformMatrix2fv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniformMatrix3fv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("uniformMatrix4fv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("useProgram")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("validateProgram")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("vertexAttrib1f")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("vertexAttrib1fv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("vertexAttrib2f")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("vertexAttrib2fv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("vertexAttrib3f")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("vertexAttrib3fv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("vertexAttrib4f")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("vertexAttrib4fv")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("vertexAttribPointer")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("viewport")));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, std::string("__toDataURL")));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_BUFFER_BIT"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_BUFFER_BIT"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "COLOR_BUFFER_BIT"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "POINTS"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "LINES"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "LINE_LOOP"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "LINE_STRIP"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TRIANGLES"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TRIANGLE_STRIP"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TRIANGLE_FAN"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ZERO"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ONE"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SRC_COLOR"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ONE_MINUS_SRC_COLOR"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SRC_ALPHA"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ONE_MINUS_SRC_ALPHA"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DST_ALPHA"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ONE_MINUS_DST_ALPHA"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DST_COLOR"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ONE_MINUS_DST_COLOR"));
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SRC_ALPHA_SATURATE"));
-
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "CONSTANT_COLOR"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ONE_MINUS_CONSTANT_COLOR"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "CONSTANT_ALPHA"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ONE_MINUS_CONSTANT_ALPHA"));
+    tmpl->Set(isolate, "STENCIL_BUFFER_BIT", v8::Uint32::New(isolate, 0x00000400));
+
+    tmpl->Set(isolate, "COLOR_BUFFER_BIT", v8::Uint32::New(isolate, 0x00004000));
+
+    tmpl->Set(isolate, "POINTS", v8::Uint32::New(isolate, 0x0000));
+
+    tmpl->Set(isolate, "LINES", v8::Uint32::New(isolate, 0x0001));
+
+    tmpl->Set(isolate, "LINE_LOOP", v8::Uint32::New(isolate, 0x0002));
+
+    tmpl->Set(isolate, "LINE_STRIP", v8::Uint32::New(isolate, 0x0003));
+
+    tmpl->Set(isolate, "TRIANGLES", v8::Uint32::New(isolate, 0x0004));
+
+    tmpl->Set(isolate, "TRIANGLE_STRIP", v8::Uint32::New(isolate, 0x0005));
+
+    tmpl->Set(isolate, "TRIANGLE_FAN", v8::Uint32::New(isolate, 0x0006));
+
+    tmpl->Set(isolate, "ZERO", v8::Uint32::New(isolate, 0));
+
+    tmpl->Set(isolate, "ONE", v8::Uint32::New(isolate, 1));
+
+    tmpl->Set(isolate, "SRC_COLOR", v8::Uint32::New(isolate, 0x0300));
+
+    tmpl->Set(isolate, "ONE_MINUS_SRC_COLOR", v8::Uint32::New(isolate, 0x0301));
+
+    tmpl->Set(isolate, "SRC_ALPHA", v8::Uint32::New(isolate, 0x0302));
+
+    tmpl->Set(isolate, "ONE_MINUS_SRC_ALPHA", v8::Uint32::New(isolate, 0x0303));
+
+    tmpl->Set(isolate, "DST_ALPHA", v8::Uint32::New(isolate, 0x0304));
+
+    tmpl->Set(isolate, "ONE_MINUS_DST_ALPHA", v8::Uint32::New(isolate, 0x0305));
+
+    tmpl->Set(isolate, "DST_COLOR", v8::Uint32::New(isolate, 0x0306));
+
+    tmpl->Set(isolate, "ONE_MINUS_DST_COLOR", v8::Uint32::New(isolate, 0x0307));
+
+    tmpl->Set(isolate, "SRC_ALPHA_SATURATE", v8::Uint32::New(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));
 
 
     /* Blending equations */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FUNC_ADD"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FUNC_SUBTRACT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FUNC_REVERSE_SUBTRACT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BLEND_EQUATION"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BLEND_EQUATION_RGB"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BLEND_EQUATION_ALPHA"));
+    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));
 
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BLEND_DST_RGB"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BLEND_SRC_RGB"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BLEND_DST_ALPHA"));
+    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));
 
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BLEND_SRC_ALPHA"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BLEND_COLOR"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ARRAY_BUFFER_BINDING"));
+    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));
 
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ELEMENT_ARRAY_BUFFER_BINDING"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "LINE_WIDTH"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ALIASED_POINT_SIZE_RANGE"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ALIASED_LINE_WIDTH_RANGE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "CULL_FACE_MODE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRONT_FACE"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_RANGE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_WRITEMASK"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_CLEAR_VALUE"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_FUNC"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_CLEAR_VALUE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_FUNC"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_FAIL"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_PASS_DEPTH_FAIL"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_PASS_DEPTH_PASS"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_REF"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_VALUE_MASK"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_WRITEMASK"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_BACK_FUNC"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_BACK_FAIL"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_BACK_PASS_DEPTH_FAIL"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_BACK_PASS_DEPTH_PASS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_BACK_REF"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_BACK_VALUE_MASK"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_BACK_WRITEMASK"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "VIEWPORT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SCISSOR_BOX"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "COLOR_CLEAR_VALUE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "COLOR_WRITEMASK"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNPACK_ALIGNMENT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "PACK_ALIGNMENT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MAX_TEXTURE_SIZE"));
+    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));
 
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MAX_VIEWPORT_DIMS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SUBPIXEL_BITS"));
+    tmpl->Set(isolate, "MAX_VIEWPORT_DIMS", v8::Uint32::New(isolate, 0x0D3A));
+    tmpl->Set(isolate, "SUBPIXEL_BITS", v8::Uint32::New(isolate, 0x0D50));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RED_BITS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "GREEN_BITS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BLUE_BITS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ALPHA_BITS"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_BITS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "POLYGON_OFFSET_UNITS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "POLYGON_OFFSET_FACTOR"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE_BINDING_2D"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SAMPLE_BUFFERS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SAMPLES"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SAMPLE_COVERAGE_VALUE"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SAMPLE_COVERAGE_INVERT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "COMPRESSED_TEXTURE_FORMATS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "VENDOR"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERER"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "VERSION"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "IMPLEMENTATION_COLOR_READ_TYPE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "IMPLEMENTATION_COLOR_READ_FORMAT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BROWSER_DEFAULT_WEBGL"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STATIC_DRAW"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STREAM_DRAW"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DYNAMIC_DRAW"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ARRAY_BUFFER"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ELEMENT_ARRAY_BUFFER"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BUFFER_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BUFFER_USAGE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "CURRENT_VERTEX_ATTRIB"));
+    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));
 
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "VERTEX_ATTRIB_ARRAY_ENABLED"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "VERTEX_ATTRIB_ARRAY_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "VERTEX_ATTRIB_ARRAY_STRIDE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "VERTEX_ATTRIB_ARRAY_TYPE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "VERTEX_ATTRIB_ARRAY_NORMALIZED"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "VERTEX_ATTRIB_ARRAY_POINTER"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "CULL_FACE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRONT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BACK"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRONT_AND_BACK"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BLEND"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_TEST"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DITHER"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "POLYGON_OFFSET_FILL"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SAMPLE_ALPHA_TO_COVERAGE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SAMPLE_COVERAGE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SCISSOR_TEST"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_TEST"));
+    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));
 
 
     /* Errors */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "NO_ERROR"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "INVALID_ENUM"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "INVALID_VALUE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "INVALID_OPERATION"));
+    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, "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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "OUT_OF_MEMORY"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "CONTEXT_LOST_WEBGL"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "CW"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "CCW"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DONT_CARE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FASTEST"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "NICEST"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "GENERATE_MIPMAP_HINT"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BYTE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNSIGNED_BYTE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SHORT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNSIGNED_SHORT"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "INT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNSIGNED_INT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FLOAT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_COMPONENT"));
+    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));
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ALPHA"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RGB"));
+    tmpl->Set(isolate, "ALPHA", v8::Uint32::New(isolate, 0x1906));
+    tmpl->Set(isolate, "RGB", v8::Uint32::New(isolate, 0x1907));
 
     /* Clearing buffers */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RGBA"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "LUMINANCE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "LUMINANCE_ALPHA"));
+    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));
 
     /* Clearing buffers */
 
     /* Rendering primitives */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNSIGNED_SHORT_4_4_4_4"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNSIGNED_SHORT_5_5_5_1"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNSIGNED_SHORT_5_6_5"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAGMENT_SHADER"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "VERTEX_SHADER"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "COMPILE_STATUS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DELETE_STATUS"));
+    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));
 
     /* Rendering primitives */
 
     /* Blending modes */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "LINK_STATUS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "VALIDATE_STATUS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ATTACHED_SHADERS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ACTIVE_ATTRIBUTES"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ACTIVE_UNIFORMS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MAX_VERTEX_ATTRIBS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MAX_VERTEX_UNIFORM_VECTORS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MAX_VARYING_VECTORS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MAX_COMBINED_TEXTURE_IMAGE_UNITS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MAX_VERTEX_TEXTURE_IMAGE_UNITS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MAX_TEXTURE_IMAGE_UNITS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MAX_FRAGMENT_UNIFORM_VECTORS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SHADER_TYPE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SHADING_LANGUAGE_VERSION"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "CURRENT_PROGRAM"));
+    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));
 
     /* Blending modes */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "NEVER"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "LESS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "EQUAL"));
+    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));
 
     /* Blending equations */
 
     /* Getting GL parameter information */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "LEQUAL"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "GREATER"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "NOTEQUAL"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "GEQUAL"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ALWAYS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "KEEP"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "REPLACE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "INCR"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DECR"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "INVERT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "INCR_WRAP"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DECR_WRAP"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "NEAREST"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "LINEAR"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "NEAREST_MIPMAP_NEAREST"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "LINEAR_MIPMAP_NEAREST"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "NEAREST_MIPMAP_LINEAR"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "LINEAR_MIPMAP_LINEAR"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE_MAG_FILTER"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE_MIN_FILTER"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE_WRAP_S"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE_WRAP_T"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE_2D"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE_CUBE_MAP"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE_BINDING_CUBE_MAP"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE_CUBE_MAP_POSITIVE_X"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE_CUBE_MAP_NEGATIVE_X"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE_CUBE_MAP_POSITIVE_Y"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE_CUBE_MAP_NEGATIVE_Y"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE_CUBE_MAP_POSITIVE_Z"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE_CUBE_MAP_NEGATIVE_Z"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MAX_CUBE_MAP_TEXTURE_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE0"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE1"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE2"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE3"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE4"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE5"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE6"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE7"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE8"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE9"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE10"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE11"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE12"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE13"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE14"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE15"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE16"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE17"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE18"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE19"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE20"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE21"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE22"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE23"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE24"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE25"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE26"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE27"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE28"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE29"));
+    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));
 
     /* Getting GL parameter information */
 
     /* Buffers */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE30"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "TEXTURE31"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "ACTIVE_TEXTURE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "REPEAT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "CLAMP_TO_EDGE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MIRRORED_REPEAT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FLOAT_VEC2"));
+    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));
 
     /* Buffers */
 
     /* Vertex attributes */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FLOAT_VEC3"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FLOAT_VEC4"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "INT_VEC2"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "INT_VEC3"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "INT_VEC4"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BOOL"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BOOL_VEC2"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BOOL_VEC3"));
+    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));
 
     /* Vertex attributes */
 
     /* Culling */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "BOOL_VEC4"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FLOAT_MAT2"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FLOAT_MAT3"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FLOAT_MAT4"));
+    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));
 
     /* Culling */
 
     /* Enabling and disabling */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SAMPLER_2D"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "SAMPLER_CUBE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "LOW_FLOAT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MEDIUM_FLOAT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "HIGH_FLOAT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "LOW_INT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MEDIUM_INT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "HIGH_INT"));
+    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));
 
     /* Enabling and disabling */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RGBA4"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RGB5_A1"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RGB565"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_COMPONENT16"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_INDEX8"));
+    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));
 
     /* Errors */
 
     /* Front face directions */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_STENCIL"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_WIDTH"));
+    tmpl->Set(isolate, "DEPTH_STENCIL", v8::Uint32::New(isolate, 0x84F9));
+    tmpl->Set(isolate, "RENDERBUFFER_WIDTH", v8::Uint32::New(isolate, 0x8D42));
 
     /* Front face directions */
 
     /* Hints */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_HEIGHT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_INTERNAL_FORMAT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_RED_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_GREEN_SIZE"));
+    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));
 
     /* Hints */
 
     /* Data types */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_BLUE_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_ALPHA_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_DEPTH_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_STENCIL_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"));
+    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));
 
     /* Data types */
 
     /* Pixel formats */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "COLOR_ATTACHMENT0"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_ATTACHMENT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_ATTACHMENT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_STENCIL_ATTACHMENT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "NONE"));
+    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));
 
     /* Pixel formats */
 
     /* Pixel types */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_COMPLETE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_INCOMPLETE_ATTACHMENT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"));
+    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_INCOMPLETE_MISSING_ATTACHMENT",
+              v8::Uint32::New(isolate, 0x8CD7));
 
     /* Pixel types */
 
     /* Shaders */
 
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_INCOMPLETE_DIMENSIONS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_UNSUPPORTED"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_BINDING"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_BINDING"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MAX_RENDERBUFFER_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "INVALID_FRAMEBUFFER_OPERATION"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNPACK_FLIP_Y_WEBGL"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNPACK_PREMULTIPLY_ALPHA_WEBGL"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNPACK_COLORSPACE_CONVERSION_WEBGL"));
-
-    return ret;
-}
-
-jsi::Value WebGLRenderingContext::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
-    auto methodName = name.utf8(runtime);
-
-    auto prop_return = GetProperty(methodName);
-
-    if (!prop_return.isUndefined()) {
-        return prop_return;
-    }
-
-
-    if (methodName == "getShaderParameter") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1) {
-                                                             auto pname = (uint32_t) args[1]->NumberValue(
-                                                                     context).ToChecked();
-                                                             if (args[0].isObject()) {
-                                                                 auto shader = args[0].asObject(
-                                                                         runtime).asHostObject<WebGLShader>(
-                                                                         runtime);
-                                                                 if (shader != nullptr) {
-                                                                     auto ret = canvas_native_webgl_get_shader_parameter(
-                                                                             shader->GetShader(),
-                                                                             pname,
-                                                                             this->GetState()
-                                                                     );
-
-                                                                     if (canvas_native_webgl_result_get_is_none(
-                                                                             *ret)) {
-                                                                         return jsi::Value::null();
-                                                                     }
-
-                                                                     if (pname ==
-                                                                         GL_DELETE_STATUS ||
-                                                                         pname ==
-                                                                         GL_COMPILE_STATUS) {
-                                                                         return {canvas_native_webgl_result_get_bool(
-                                                                                 *ret)};
-                                                                     }
-
-                                                                     return {canvas_native_webgl_result_get_i32(
-                                                                             *ret)};
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         // todo check return
-                                                         return jsi::Value::null();
-                                                     }
-        );
-    } else if (methodName == "getShaderPrecisionFormat") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-
-                                                         if (count > 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,
-                                                                     this->GetState()
-                                                             );
-                                                             auto shader = std::make_shared<WebGLShaderPrecisionFormatImpl>(
-                                                                     std::move(ret));
-                                                             return jsi::Object::createFromHostObject(
-                                                                     runtime, shader);
-                                                         }
-
-                                                         // todo check return
-                                                         return jsi::Value::null();
-                                                     }
-        );
-    } else if (methodName == "getShaderSource") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-
-                                                         if (count > 0) {
-                                                             if (args[0].isObject()) {
-                                                                 auto shader = args[0].asObject(
-                                                                         runtime).asHostObject<WebGLShader>(
-                                                                         runtime);
-
-                                                                 if (shader != nullptr) {
-                                                                     auto source = canvas_native_webgl_get_shader_source(
-                                                                             shader->GetShader(),
-                                                                             this->GetState()
-                                                                     );
-
-                                                                     return jsi::String::createFromAscii(
-                                                                             runtime, source.data(),
-                                                                             source.size());
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         // todo check return
-                                                         return jsi::String::createFromAscii(
-                                                                 runtime, "");
-                                                     }
-        );
-    } else if (methodName == "getSupportedExtensions") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     0,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         auto exts = canvas_native_webgl_get_supported_extensions(
-                                                                 this->GetState());
-                                                         auto len = exts.size();
-                                                         auto array = jsi::Array(runtime, len);
-                                                         for (int i = 0; i < len; ++i) {
-                                                             auto item = exts[i];
-                                                             array.setValueAtIndex(runtime, i,
-                                                                                   jsi::String::createFromAscii(
-                                                                                           runtime,
-                                                                                           item.data(),
-                                                                                           item.size()));
-                                                         }
-                                                         return array;
-                                                     }
-        );
-    } else if (methodName == "__getSupportedExtensions") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     0,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         auto exts = canvas_native_webgl_get_supported_extensions_to_string(
-                                                                 this->GetState());
-
-                                                         return jsi::String::createFromAscii(
-                                                                 runtime, exts.data(), exts.size());
-                                                     }
-        );
-    } else if (methodName == "getTexParameter") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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,
-                                                                     this->GetState()
-                                                             );
-                                                             return {ret};
-                                                         }
-
-                                                         // todo check return
-                                                         return jsi::Value::null();
-                                                     }
-        );
-    } else if (methodName == "getUniformLocation") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1) {
-                                                             if (args[0].isObject() &&
-                                                                 args[1].isString()) {
-                                                                 auto program = args[0].asObject(
-                                                                         runtime).asHostObject<WebGLProgram>(
-                                                                         runtime);
-                                                                 if (program != nullptr) {
-                                                                     auto name = args[1].asString(
-                                                                             runtime).utf8(runtime);
-
-                                                                     auto ret = canvas_native_webgl_get_uniform_location(
-                                                                             program->GetProgram(),
-                                                                             rust::Str(
-                                                                                     name.c_str()),
-                                                                             this->GetState()
-                                                                     );
-
-                                                                     auto location = std::make_shared<WebGLUniformLocation>(
-                                                                             ret);
-
-                                                                     return jsi::Object::createFromHostObject(
-                                                                             runtime, location);
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         // todo check return
-                                                         return jsi::Value::null();
-                                                     }
-        );
-    } else if (methodName == "getUniform") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1) {
-                                                             if (args[0].isObject() &&
-                                                                 args[1].isObject()) {
-
-                                                                 auto program = args[0].asObject(
-                                                                         runtime).asHostObject<WebGLProgram>(
-                                                                         runtime);
-                                                                 auto location = args[1].asObject(
-                                                                         runtime).asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-
-
-                                                                 if (program != nullptr &&
-                                                                     location != nullptr) {
-
-                                                                     auto val = canvas_native_webgl_get_uniform(
-                                                                             program->GetProgram(),
-                                                                             location->GetUniformLocation(),
-                                                                             this->GetState());
-
-                                                                     switch (canvas_native_webgl_result_get_type(
-                                                                             *val)) {
-                                                                         case WebGLResultType::Boolean:
-                                                                             return {canvas_native_webgl_result_get_bool(
-                                                                                     *val)};
-                                                                         case WebGLResultType::None:
-                                                                             return jsi::Value::null();
-                                                                         case WebGLResultType::String: {
-                                                                             auto str = canvas_native_webgl_result_get_string(
-                                                                                     *val);
-                                                                             return jsi::String::createFromAscii(
-                                                                                     runtime,
-                                                                                     str.data(),
-                                                                                     str.size());
-                                                                         }
-                                                                             break;
-                                                                         case WebGLResultType::BooleanArray: {
-                                                                             auto ret = canvas_native_webgl_result_get_bool_array(
-                                                                                     *val);
-                                                                             auto len = ret.size();
-                                                                             auto array = jsi::Array(
-                                                                                     runtime, len);
-                                                                             for (int i = 0;
-                                                                                  i < len; ++i) {
-                                                                                 auto item = ret[i];
-                                                                                 array.setValueAtIndex(
-                                                                                         runtime, i,
-                                                                                         jsi::Value(
-                                                                                                 item ==
-                                                                                                 1));
-                                                                             }
-                                                                             return array;
-                                                                         }
-                                                                             break;
-                                                                         case WebGLResultType::F32Array: {
-                                                                             auto ret = canvas_native_webgl_result_get_f32_array(
-                                                                                     *val);
-
-                                                                             auto buf = std::make_shared<VecMutableBuffer<float>>(
-                                                                                     std::move(
-                                                                                             ret));
-                                                                             auto array = jsi::ArrayBuffer(
-                                                                                     runtime, buf);
-
-                                                                             auto Float32Array = runtime.global()
-                                                                                     .getProperty(
-                                                                                             runtime,
-                                                                                             "Float32Array")
-                                                                                     .asObject(
-                                                                                             runtime)
-                                                                                     .asFunction(
-                                                                                             runtime);
-
-
-                                                                             return Float32Array.callAsConstructor(
-                                                                                     runtime,
-                                                                                     array);
-                                                                         }
-                                                                             break;
-                                                                         case WebGLResultType::I32Array: {
-                                                                             auto ret = canvas_native_webgl_result_get_i32_array(
-                                                                                     *val);
-
-                                                                             auto buf = std::make_shared<VecMutableBuffer<int32_t>>(
-                                                                                     std::move(
-                                                                                             ret));
-                                                                             auto array = jsi::ArrayBuffer(
-                                                                                     runtime, buf);
-
-                                                                             auto Int32Array = runtime.global()
-                                                                                     .getProperty(
-                                                                                             runtime,
-                                                                                             "Int32Array")
-                                                                                     .asObject(
-                                                                                             runtime)
-                                                                                     .asFunction(
-                                                                                             runtime);
-
-
-                                                                             return Int32Array.callAsConstructor(
-                                                                                     runtime,
-                                                                                     array);
-                                                                         }
-                                                                             break;
-                                                                         case WebGLResultType::U32Array: {
-                                                                             auto ret = canvas_native_webgl_result_get_u32_array(
-                                                                                     *val);
-
-                                                                             auto buf = std::make_shared<VecMutableBuffer<uint32_t>>(
-                                                                                     std::move(
-                                                                                             ret));
-                                                                             auto array = jsi::ArrayBuffer(
-                                                                                     runtime, buf);
-
-                                                                             auto Uint32Array = runtime.global()
-                                                                                     .getProperty(
-                                                                                             runtime,
-                                                                                             "Uint32Array")
-                                                                                     .asObject(
-                                                                                             runtime)
-                                                                                     .asFunction(
-                                                                                             runtime);
-
-
-                                                                             return Uint32Array.callAsConstructor(
-                                                                                     runtime,
-                                                                                     array);
-                                                                         }
-                                                                             break;
-                                                                         case WebGLResultType::F32:
-                                                                             return {(double) canvas_native_webgl_result_get_f32(
-                                                                                     *val)};
-                                                                         case WebGLResultType::I32:
-                                                                             return {canvas_native_webgl_result_get_i32(
-                                                                                     *val)};
-                                                                         case WebGLResultType::U32:
-                                                                             return {(int32_t) canvas_native_webgl_result_get_u32(
-                                                                                     *val)};
-                                                                     }
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         // todo check return
-                                                         return jsi::Value::null();
-                                                     }
-        );
-    } else if (methodName == "getVertexAttribOffset") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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,
-                                                                     this->GetState());
-                                                             return {static_cast<double>(ret)};
-                                                         }
-
-                                                         // todo check return
-                                                         return jsi::Value::null();
-                                                     }
-        );
-    } else if (methodName == "getVertexAttrib") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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,
-                                                                     this->GetState());
-
-                                                             if (pname ==
-                                                                 GL_CURRENT_VERTEX_ATTRIB) {
-                                                                 auto val = canvas_native_webgl_result_get_f32_array(
-                                                                         *ret);
-
-                                                                 auto buf = std::make_shared<VecMutableBuffer<float>>(
-                                                                         std::move(val));
-                                                                 auto array = jsi::ArrayBuffer(
-                                                                         runtime, buf);
-
-                                                                 auto Float32Array = runtime.global()
-                                                                         .getProperty(runtime,
-                                                                                      "Float32Array")
-                                                                         .asObject(runtime)
-                                                                         .asFunction(runtime);
-
-
-                                                                 return Float32Array.callAsConstructor(
-                                                                         runtime, array);
-                                                             } else if (pname ==
-                                                                        GL_VERTEX_ATTRIB_ARRAY_ENABLED ||
-                                                                        pname ==
-                                                                        GL_VERTEX_ATTRIB_ARRAY_NORMALIZED) {
-                                                                 return {canvas_native_webgl_result_get_bool(
-                                                                         *ret)};
-                                                             } else {
-                                                                 return {canvas_native_webgl_result_get_i32(
-                                                                         *ret)};
-                                                             }
-                                                         }
-
-                                                         // todo check return
-                                                         return jsi::Value::null();
-                                                     }
-        );
-    } else if (methodName == "hint") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-
-                                                         if (count > 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,
-                                                                                      this->GetState());
-                                                         }
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "isBuffer") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 0) {
-                                                             if (args[0].isObject()) {
-                                                                 auto buffer = args[0].asObject(
-                                                                         runtime).asHostObject<WebGLBuffer>(
-                                                                         runtime);
-                                                                 if (buffer != nullptr) {
-                                                                     auto ret = canvas_native_webgl_is_buffer(
-                                                                             buffer->GetBuffer(),
-                                                                             this->GetState());
-
-                                                                     return {ret};
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         // todo check return
-                                                         return {false};
-                                                     }
-        );
-    } else if (methodName == "isContextLost") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     0,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-                                                         auto ret = canvas_native_webgl_get_is_context_lost(
-                                                                 this->GetState());
-                                                         return {ret};
-                                                     }
-        );
-    } else if (methodName == "isEnabled") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 0) {
-                                                             auto cap = (uint32_t) args[0]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto ret = canvas_native_webgl_is_enabled(
-                                                                     cap, this->GetState());
-                                                             return {ret};
-                                                         }
-                                                         return {false};
-                                                     }
-        );
-    } else if (methodName == "isFramebuffer") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 0) {
-                                                             if (args[0].isObject()) {
-                                                                 auto framebuffer = args[0].asObject(
-                                                                         runtime).asHostObject<WebGLFramebuffer>(
-                                                                         runtime);
-                                                                 if (framebuffer != nullptr) {
-                                                                     auto ret = canvas_native_webgl_is_framebuffer(
-                                                                             framebuffer->GetFrameBuffer(),
-                                                                             this->GetState());
-
-                                                                     return {ret};
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         // todo check return
-                                                         return {false};
-                                                     }
-        );
-    } else if (methodName == "isProgram") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 0) {
-                                                             if (args[0].isObject()) {
-                                                                 auto program = args[0].asObject(
-                                                                         runtime).asHostObject<WebGLProgram>(
-                                                                         runtime);
-                                                                 if (program != nullptr) {
-                                                                     auto ret = canvas_native_webgl_is_program(
-                                                                             program->GetProgram(),
-                                                                             this->GetState());
-
-                                                                     return {ret};
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         // todo check return
-                                                         return {false};
-                                                     }
-        );
-    } else if (methodName == "isRenderbuffer") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 0) {
-                                                             if (args[0].isObject()) {
-                                                                 auto renderbuffer = args[0].asObject(
-                                                                         runtime).asHostObject<WebGLRenderbuffer>(
-                                                                         runtime);
-                                                                 if (renderbuffer != nullptr) {
-                                                                     auto ret = canvas_native_webgl_is_renderbuffer(
-                                                                             renderbuffer->GetRenderBuffer(),
-                                                                             this->GetState());
-
-                                                                     return {ret};
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         // todo check return
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "isShader") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-                                                         if (count > 0) {
-                                                             if (args[0].isObject()) {
-                                                                 auto shader = args[0].asObject(
-                                                                         runtime).asHostObject<WebGLShader>(
-                                                                         runtime);
-                                                                 if (shader != nullptr) {
-                                                                     auto ret = canvas_native_webgl_is_shader(
-                                                                             shader->GetShader(),
-                                                                             this->GetState());
-                                                                     return {ret};
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         // todo check return
-                                                         return {false};
-                                                     }
-        );
-    } else if (methodName == "isTexture") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 0) {
-                                                             if (args[0].isObject()) {
-                                                                 auto texture = args[0].asObject(
-                                                                         runtime).asHostObject<WebGLTexture>(
-                                                                         runtime);
-                                                                 if (texture != nullptr) {
-                                                                     auto ret = canvas_native_webgl_is_texture(
-                                                                             texture->GetTexture(),
-                                                                             this->GetState());
-                                                                     return {ret};
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         // todo check return
-                                                         return {false};
-                                                     }
-        );
-    } else if (methodName == "lineWidth") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 0) {
-                                                             auto width = args[0]->NumberValue(
-                                                                     context).ToChecked();
-                                                             canvas_native_webgl_line_width(
-                                                                     static_cast<float>(width),
-                                                                     this->GetState());
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "linkProgram") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 0) {
-                                                             if (args[0].isObject()) {
-                                                                 auto program = args[0].asObject(
-                                                                         runtime).asHostObject<WebGLProgram>(
-                                                                         runtime);
-                                                                 if (program != nullptr) {
-                                                                     canvas_native_webgl_link_program(
-                                                                             program->GetProgram(),
-                                                                             this->GetState());
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "pixelStorei") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1) {
-                                                             auto pname = (uint32_t) args[0]->NumberValue(
-                                                                     context).ToChecked();
-                                                             if (args[1].isBool()) {
-                                                                 auto param = args[1].asBool();
-                                                                 canvas_native_webgl_pixel_storei(
-                                                                         pname,
-                                                                         param ? 1 : 0,
-                                                                         this->GetState()
-                                                                 );
-                                                             } else {
-                                                                 auto param = (int32_t) args[1]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 canvas_native_webgl_pixel_storei(
-                                                                         pname,
-                                                                         param,
-                                                                         this->GetState()
-                                                                 );
-                                                             }
-
-                                                         }
-
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "polygonOffset") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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),
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "readPixels") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     7,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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();
-
-                                                             if (args[6].isObject()) {
-                                                                 auto pixels = args[6].asObject(
-                                                                         runtime);
-                                                                 if (pixels.isTypedArray(runtime)) {
-                                                                     auto buf = pixels.getTypedArray(
-                                                                             runtime);
-                                                                     auto slice = GetTypedArrayData<uint8_t>(
-                                                                             runtime, buf);
-                                                                     canvas_native_webgl_read_pixels_u8(
-                                                                             x,
-                                                                             y,
-                                                                             width,
-                                                                             height,
-                                                                             format,
-                                                                             type,
-                                                                             slice,
-                                                                             this->GetState()
-                                                                     );
-                                                                     return jsi::Value::undefined();
-                                                                 }
-
-
-                                                                 if (pixels.isArrayBuffer(
-                                                                         runtime)) {
-                                                                     auto buf = pixels.getArrayBuffer(
-                                                                             runtime);
-                                                                     auto size = buf.size(runtime);
-                                                                     auto data = buf.data(runtime);
-                                                                     auto slice = rust::Slice<uint8_t>(
-                                                                             data, size);
-                                                                     canvas_native_webgl_read_pixels_u8(
-                                                                             x,
-                                                                             y,
-                                                                             width,
-                                                                             height,
-                                                                             format,
-                                                                             type,
-                                                                             slice,
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
-                                                         }
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "renderbufferStorage") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     4,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-                                                         if (count > 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,
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "sampleCoverage") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1) {
-                                                             auto value = args[0]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto invert = args[1].asBool();
-                                                             canvas_native_webgl_sample_coverage(
-                                                                     static_cast<float>(value),
-                                                                     invert,
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "scissor") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     4,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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,
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "shaderSource") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1) {
-                                                             if (args[0].isObject() &&
-                                                                 args[1].isString()) {
-                                                                 auto shader = args[0].asObject(
-                                                                         runtime).asHostObject<WebGLShader>(
-                                                                         runtime);
-                                                                 auto source = args[1].asString(
-                                                                         runtime).utf8(runtime);
-                                                                 if (shader != nullptr) {
-                                                                     canvas_native_webgl_shader_source(
-                                                                             shader->GetShader(),
-                                                                             rust::Str(
-                                                                                     source.c_str()),
-                                                                             this->GetState());
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "stencilFuncSeparate") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     4,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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,
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "stencilFunc") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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,
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "stencilMaskSeparate") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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,
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "stencilMask") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 0) {
-                                                             auto mask = (uint32_t) args[0]->NumberValue(
-                                                                     context).ToChecked();
-                                                             canvas_native_webgl_stencil_mask(
-                                                                     mask,
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "stencilOpSeparate") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     4,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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,
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "stencilOp") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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,
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "texImage2D") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     9,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         // TODO tidy
-
-                                                         if (count == 5) {
-                                                             auto target = (int32_t) args[0]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto level = (int32_t) args[1]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto internalformat = (int32_t) args[2]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto format = (int32_t) args[3]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto type = (int32_t) args[4]->NumberValue(
-                                                                     context).ToChecked();
-
-                                                             canvas_native_webgl_tex_image2d_image_none(
-                                                                     target,
-                                                                     level,
-                                                                     internalformat,
-                                                                     format,
-                                                                     type,
-                                                                     this->GetState()
-                                                             );
-
-                                                         } else if (count == 6) {
-                                                             auto target = (int32_t) args[0]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto level = (int32_t) args[1]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto internalformat = (int32_t) args[2]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto format = (int32_t) args[3]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto type = (int32_t) args[4]->NumberValue(
-                                                                     context).ToChecked();
-
-                                                             if (args[5].isObject()) {
-                                                                 auto pixels = args[5].asObject(
-                                                                         runtime);
-
-
-                                                                 if (pixels.isHostObject(runtime)) {
-                                                                     /*
-                                                                     try {
-                                                                         auto image_asset = pixels.asHostObject<ImageAssetImpl>(
-                                                                                 runtime);
-
-                                                                         if (image_asset !=
-                                                                             nullptr) {
-
-                                                                             canvas_native_webgl_tex_image2d_image_asset(
-                                                                                     target,
-                                                                                     level,
-                                                                                     internalformat,
-                                                                                     format,
-                                                                                     type,
-                                                                                     image_asset->GetImageAsset(),
-                                                                                     this->GetState()
-                                                                             );
-
-
-                                                                             return jsi::Value::undefined();
-                                                                         }
-                                                                     } catch (...) {}
-
-
-                                                                     try {
-                                                                         // try ImageBitmapImpl
-                                                                         auto image_bitmap = pixels.asHostObject<ImageBitmapImpl>(
-                                                                                 runtime);
-
-                                                                         if (image_bitmap !=
-                                                                             nullptr) {
-                                                                             canvas_native_webgl_tex_image2d_image_asset(
-                                                                                     target,
-                                                                                     level,
-                                                                                     internalformat,
-                                                                                     format,
-                                                                                     type,
-                                                                                     image_bitmap->GetImageAsset(),
-                                                                                     this->GetState()
-                                                                             );
-                                                                         }
-
-                                                                     } catch (...) {}
-
-
-                                                                     try {
-                                                                         auto canvas_2d = pixels.asHostObject<CanvasRenderingContext2DImpl>(
-                                                                                 runtime);
-
-                                                                         if (canvas_2d != nullptr) {
-                                                                             canvas_native_webgl_tex_image2d_canvas2d(
-                                                                                     target,
-                                                                                     level,
-                                                                                     internalformat,
-                                                                                     format,
-                                                                                     type,
-                                                                                     canvas_2d->GetContext(),
-                                                                                     this->GetState()
-                                                                             );
-                                                                             return jsi::Value::undefined();
-                                                                         }
-                                                                     } catch (...) {}
-                                                                      */
-
-
-                                                                     try {
-                                                                         auto gl = pixels.asHostObject<WebGLRenderingContext>(
-                                                                                 runtime);
-
-                                                                         if (gl != nullptr) {
-                                                                             canvas_native_webgl_tex_image2d_webgl(
-                                                                                     target,
-                                                                                     level,
-                                                                                     internalformat,
-                                                                                     format,
-                                                                                     type,
-                                                                                     gl->GetState(),
-                                                                                     this->GetState()
-                                                                             );
-
-                                                                             return jsi::Value::undefined();
-                                                                         }
-                                                                     } catch (...) {}
-
-
-                                                                 }
-
-                                                             }
-                                                         } else if (count == 8) {
-                                                             auto target = (int32_t) args[0]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto level = (int32_t) args[1]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto internalformat = (int32_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 format = (int32_t) args[6]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto type = (int32_t) args[7]->NumberValue(
-                                                                     context).ToChecked();
-                                                             canvas_native_webgl_tex_image2d_none(
-                                                                     target,
-                                                                     level,
-                                                                     internalformat,
-                                                                     width,
-                                                                     height,
-                                                                     border,
-                                                                     format,
-                                                                     type,
-                                                                     this->GetState()
-                                                             );
-                                                         } else if (count == 9) {
-                                                             auto target = (int32_t) args[0]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto level = (int32_t) args[1]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto internalformat = (int32_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 format = (int32_t) args[6]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto type = (int32_t) args[7]->NumberValue(
-                                                                     context).ToChecked();
-
-
-                                                             if (args[8].isObject()) {
-                                                                 auto pixels = args[8].asObject(
-                                                                         runtime);
-                                                                 if (pixels.isTypedArray(runtime)) {
-                                                                     auto typedArray = pixels.getTypedArray(
-                                                                             runtime);
-                                                                     auto buf = GetTypedArrayData<uint8_t>(
-                                                                             runtime, typedArray);
-                                                                     canvas_native_webgl_tex_image2d(
-                                                                             target,
-                                                                             level,
-                                                                             internalformat,
-                                                                             width,
-                                                                             height,
-                                                                             border,
-                                                                             format,
-                                                                             type,
-                                                                             buf,
-                                                                             this->GetState()
-                                                                     );
-                                                                     return jsi::Value::undefined();
-                                                                 } else if (pixels.isArrayBuffer(
-                                                                         runtime)) {
-                                                                     auto array = pixels.getArrayBuffer(
-                                                                             runtime);
-                                                                     auto data = array.data(
-                                                                             runtime);
-                                                                     auto size = array.size(
-                                                                             runtime);
-                                                                     rust::Slice<uint8_t> buf(data,
-                                                                                              size);
-                                                                     canvas_native_webgl_tex_image2d(
-                                                                             target,
-                                                                             level,
-                                                                             internalformat,
-                                                                             width,
-                                                                             height,
-                                                                             border,
-                                                                             format,
-                                                                             type,
-                                                                             buf,
-                                                                             this->GetState()
-                                                                     );
-                                                                     return jsi::Value::undefined();
-                                                                 }
-                                                             } else if (args[8].isNull() ||
-                                                                        args[8].isUndefined()) {
-                                                                 canvas_native_webgl_tex_image2d_none(
-                                                                         target,
-                                                                         level,
-                                                                         internalformat,
-                                                                         width,
-                                                                         height,
-                                                                         border,
-                                                                         format,
-                                                                         type,
-                                                                         this->GetState()
-                                                                 );
-                                                             }
-
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "texParameterf") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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),
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "texParameteri") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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,
-                                                                     this->GetState()
-                                                             );
-                                                         }
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "texSubImage2D") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     9,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-
-                                                         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 format = (uint32_t) args[4]->NumberValue(
-                                                                     context).ToChecked();
-                                                             auto type = (int32_t) args[5]->NumberValue(
-                                                                     context).ToChecked();
-
-
-                                                             if (args[6].isObject()) {
-                                                                 auto pixels = args[6].asObject(
-                                                                         runtime);
-                                                                 if (pixels.isHostObject(runtime)) {
-                                                                     /*
-                                                                     try {
-                                                                         auto asset = pixels.asHostObject<ImageAssetImpl>(
-                                                                                 runtime);
-                                                                         if (asset != nullptr) {
-                                                                             canvas_native_webgl_tex_sub_image2d_asset(
-                                                                                     target,
-                                                                                     level,
-                                                                                     xoffset,
-                                                                                     yoffset,
-                                                                                     format,
-                                                                                     type,
-                                                                                     asset->GetImageAsset(),
-                                                                                     this->GetState()
-                                                                             );
-                                                                             return jsi::Value::undefined();
-                                                                         }
-                                                                     } catch (...) {}
-
-                                                                     try {
-                                                                         auto bitmap = pixels.asHostObject<ImageBitmapImpl>(
-                                                                                 runtime);
-
-                                                                         if (bitmap != nullptr) {
-                                                                             canvas_native_webgl_tex_sub_image2d_asset(
-                                                                                     target,
-                                                                                     level,
-                                                                                     xoffset,
-                                                                                     yoffset,
-                                                                                     format,
-                                                                                     type,
-                                                                                     bitmap->GetImageAsset(),
-                                                                                     this->GetState()
-                                                                             );
-
-                                                                             return jsi::Value::undefined();
-                                                                         }
-                                                                     } catch (...) {}
-
-
-                                                                     try {
-                                                                         auto canvas2d = pixels.asHostObject<CanvasRenderingContext2DImpl>(
-                                                                                 runtime);
-
-                                                                         if (canvas2d != nullptr) {
-                                                                             canvas_native_webgl_tex_sub_image2d_canvas2d(
-                                                                                     target,
-                                                                                     level,
-                                                                                     xoffset,
-                                                                                     yoffset,
-                                                                                     format,
-                                                                                     type,
-                                                                                     canvas2d->GetContext(),
-                                                                                     this->GetState()
-                                                                             );
-
-                                                                             return jsi::Value::undefined();
-                                                                         }
-                                                                     } catch (...) {}
-
-                                                                      */
-
-                                                                     try {
-                                                                         auto webgl = pixels.asHostObject<WebGLRenderingContext>(
-                                                                                 runtime);
-
-                                                                         if (webgl != nullptr) {
-                                                                             canvas_native_webgl_tex_sub_image2d_webgl(
-                                                                                     target,
-                                                                                     level,
-                                                                                     xoffset,
-                                                                                     yoffset,
-                                                                                     format,
-                                                                                     type,
-                                                                                     webgl->GetState(),
-                                                                                     this->GetState()
-                                                                             );
-
-                                                                             return jsi::Value::undefined();
-                                                                         }
-                                                                     } catch (...) {}
-
-                                                                 }
-                                                             }
-
-                                                         } else if (count == 9) {
-                                                             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();
-                                                             auto type = (int32_t) args[7]->NumberValue(
-                                                                     context).ToChecked();
-
-                                                             if (args[8].isObject()) {
-                                                                 auto pixels = args[8].asObject(
-                                                                         runtime);
-
-                                                                 if (pixels.isTypedArray(runtime)) {
-                                                                     auto array = pixels.getTypedArray(
-                                                                             runtime);
-                                                                     auto buf = GetTypedArrayData<const uint8_t>(
-                                                                             runtime, array);
-                                                                     canvas_native_webgl_tex_sub_image2d(
-                                                                             target,
-                                                                             level,
-                                                                             xoffset,
-                                                                             yoffset,
-                                                                             width,
-                                                                             height,
-                                                                             format,
-                                                                             type,
-                                                                             buf,
-                                                                             this->GetState()
-                                                                     );
-                                                                 } else if (pixels.isArrayBuffer(
-                                                                         runtime)) {
-                                                                     auto array = pixels.getArrayBuffer(
-                                                                             runtime);
-                                                                     auto data = array.data(
-                                                                             runtime);
-                                                                     auto size = array.size(
-                                                                             runtime);
-                                                                     rust::Slice<const uint8_t> buf(
-                                                                             data, size);
-                                                                     canvas_native_webgl_tex_sub_image2d(
-                                                                             target,
-                                                                             level,
-                                                                             xoffset,
-                                                                             yoffset,
-                                                                             width,
-                                                                             height,
-                                                                             format,
-                                                                             type,
-                                                                             buf,
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
-                                                         }
-
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "vertexAttrib1f") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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, this->GetState());
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "vertexAttrib1fv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1) {
-                                                             auto index = (uint32_t) args[0]->NumberValue(
-                                                                     context).ToChecked();
-                                                             if (args[1].isObject()) {
-                                                                 auto v0 = args[1].asObject(
-                                                                         runtime);
-                                                                 if (v0.isFloat32Array(runtime)) {
-                                                                     auto array = v0.getTypedArray(
-                                                                             runtime);
-                                                                     auto buf = GetTypedArrayData<const float>(
-                                                                             runtime, array);
-                                                                     canvas_native_webgl_vertex_attrib1fv(
-                                                                             index, buf,
-                                                                             this->GetState());
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "vertexAttrib2f") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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,
-                                                                     this->GetState());
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "vertexAttrib2fv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1) {
-                                                             auto index = (uint32_t) args[0]->NumberValue(
-                                                                     context).ToChecked();
-                                                             if (args[1].isObject()) {
-                                                                 auto v0 = args[1].asObject(
-                                                                         runtime);
-                                                                 if (v0.isFloat32Array(runtime)) {
-                                                                     auto array = v0.getTypedArray(
-                                                                             runtime);
-                                                                     auto buf = GetTypedArrayData<const float>(
-                                                                             runtime, array);
-                                                                     canvas_native_webgl_vertex_attrib2fv(
-                                                                             index, buf,
-                                                                             this->GetState());
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "vertexAttrib3f") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     4,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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,
-                                                                     this->GetState());
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "vertexAttrib3fv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1) {
-                                                             auto index = (uint32_t) args[0]->NumberValue(
-                                                                     context).ToChecked();
-                                                             if (args[1].isObject()) {
-                                                                 auto v0 = args[1].asObject(
-                                                                         runtime);
-                                                                 if (v0.isFloat32Array(runtime)) {
-                                                                     auto array = v0.getTypedArray(
-                                                                             runtime);
-                                                                     auto buf = GetTypedArrayData<const float>(
-                                                                             runtime, array);
-                                                                     canvas_native_webgl_vertex_attrib3fv(
-                                                                             index, buf,
-                                                                             this->GetState());
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "vertexAttrib4f") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     5,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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,
-                                                                     this->GetState());
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "vertexAttrib4fv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1) {
-                                                             auto index = (uint32_t) args[0]->NumberValue(
-                                                                     context).ToChecked();
-                                                             if (args[1].isObject()) {
-                                                                 auto v0 = args[1].asObject(
-                                                                         runtime);
-                                                                 if (v0.isFloat32Array(runtime)) {
-                                                                     auto array = v0.getTypedArray(
-                                                                             runtime);
-                                                                     auto buf = GetTypedArrayData<const float>(
-                                                                             runtime, array);
-                                                                     canvas_native_webgl_vertex_attrib4fv(
-                                                                             index, buf,
-                                                                             this->GetState());
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "vertexAttribPointer") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     6,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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].asBool();
-                                                             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,
-                                                                     this->GetState());
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform1f") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         //if (count > 1) {
-                                                         //   if (args[0].isObject()) {
-                                                         auto location = args[0].asObject(
-                                                                 runtime).asHostObject<WebGLUniformLocation>(
-                                                                 runtime);
-                                                         auto v0 = args[1]->NumberValue(
-                                                                 context).ToChecked();
-                                                         if (location != nullptr) {
-                                                             canvas_native_webgl_uniform1f(
-                                                                     location->GetUniformLocation(),
-                                                                     static_cast<float>(v0),
-                                                                     this->GetState()
-                                                             );
-                                                         }
-                                                         //   }
-                                                         // }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform1iv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1) {
-                                                             if (args[0].isObject() &&
-                                                                 args[1].isObject()) {
-                                                                 auto locationObject = args[0].asObject(
-                                                                         runtime);
-                                                                 if (locationObject.isHostObject(
-                                                                         runtime)) {
-                                                                     auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                             runtime);
-                                                                     auto v0 = args[1].asObject(
-                                                                             runtime);
-
-                                                                     if (location != nullptr) {
-                                                                         if (v0.isInt32Array(
-                                                                                 runtime)) {
-                                                                             auto array = v0.getTypedArray(
-                                                                                     runtime);
-                                                                             auto buf = GetTypedArrayData<const int32_t>(
-                                                                                     runtime,
-                                                                                     array);
-                                                                             canvas_native_webgl_uniform1iv(
-                                                                                     location->GetUniformLocation(),
-                                                                                     buf,
-                                                                                     this->GetState());
-                                                                         } else if (v0.isArray(
-                                                                                 runtime)) {
-                                                                             auto array = v0.getArray(
-                                                                                     runtime);
-                                                                             auto len = array.size(
-                                                                                     runtime);
-
-                                                                             std::vector<int32_t> buf;
-                                                                             buf.reserve(len);
-                                                                             for (int i = 0;
-                                                                                  i < len; ++i) {
-                                                                                 auto item = array.getValueAtIndex(
-                                                                                         runtime,
-                                                                                         (uint32_t) i)->NumberValue(
-                                                                                         context).ToChecked();
-                                                                                 buf.push_back(
-                                                                                         static_cast<int32_t>(item));
-                                                                             }
-                                                                             rust::Slice<const int32_t> slice(
-                                                                                     buf.data(),
-                                                                                     buf.size());
-                                                                             canvas_native_webgl_uniform1iv(
-                                                                                     location->GetUniformLocation(),
-                                                                                     slice,
-                                                                                     this->GetState());
-                                                                         }
-                                                                     }
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform1fv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1 && args[0].isObject() &&
-                                                             args[1].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             auto v0 = args[1].asObject(
-                                                                     runtime);
-
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-                                                                 if (location != nullptr) {
-                                                                     if (v0.isFloat32Array(
-                                                                             runtime)) {
-                                                                         auto array = v0.getTypedArray(
-                                                                                 runtime);
-                                                                         auto buf = GetTypedArrayData<const float>(
-                                                                                 runtime, array);
-                                                                         canvas_native_webgl_uniform1fv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 buf,
-                                                                                 this->GetState());
-                                                                     } else if (v0.isArray(
-                                                                             runtime)) {
-                                                                         auto array = v0.getArray(
-                                                                                 runtime);
-                                                                         auto len = array.size(
-                                                                                 runtime);
-                                                                         std::vector<float> buf;
-                                                                         buf.reserve(len);
-                                                                         for (int i = 0;
-                                                                              i < len; ++i) {
-                                                                             auto item = array.getValueAtIndex(
-                                                                                     runtime, i);
-                                                                             if (!item.isNumber()) {
-                                                                                 buf.push_back(
-                                                                                         nanf(""));
-                                                                             } else {
-                                                                                 auto value = item->NumberValue(
-                                                                                         context).ToChecked();
-                                                                                 buf.push_back(
-                                                                                         static_cast<float>(value));
-                                                                             }
-                                                                         }
-                                                                         rust::Slice<const float> slice(
-                                                                                 buf.data(),
-                                                                                 buf.size());
-                                                                         canvas_native_webgl_uniform1fv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 slice,
-                                                                                 this->GetState());
-                                                                     }
-                                                                 }
-                                                             }
-                                                         }
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform1i") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1 && args[0].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-                                                                 auto v0 = (int32_t) args[1]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 if (location != nullptr) {
-                                                                     canvas_native_webgl_uniform1i(
-                                                                             location->GetUniformLocation(),
-                                                                             v0,
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform2f") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 2) {
-                                                             if (args[0].isObject()) {
-                                                                 auto locationObject = args[0].asObject(
-                                                                         runtime);
-                                                                 if (locationObject.isHostObject(
-                                                                         runtime)) {
-                                                                     auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                             runtime);
-                                                                     auto v0 = args[1]->NumberValue(
-                                                                             context).ToChecked();
-                                                                     auto v1 = args[2]->NumberValue(
-                                                                             context).ToChecked();
-                                                                     if (location != nullptr) {
-                                                                         canvas_native_webgl_uniform2f(
-                                                                                 location->GetUniformLocation(),
-                                                                                 static_cast<float>(v0),
-                                                                                 static_cast<float>(v1),
-                                                                                 this->GetState()
-                                                                         );
-                                                                     }
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform2iv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1 && args[0].isObject() &&
-                                                             args[1].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-                                                                 auto v0 = args[1].asObject(
-                                                                         runtime);
-                                                                 if (location != nullptr) {
-                                                                     if (v0.isInt32Array(runtime)) {
-                                                                         auto array = v0.getTypedArray(
-                                                                                 runtime);
-                                                                         auto buf = GetTypedArrayData<const int32_t>(
-                                                                                 runtime, array);
-                                                                         canvas_native_webgl_uniform2iv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 buf,
-                                                                                 this->GetState());
-                                                                     } else if (v0.isArray(
-                                                                             runtime)) {
-                                                                         auto array = v0.asArray(
-                                                                                 runtime);
-                                                                         auto len = array.size(
-                                                                                 runtime);
-
-                                                                         std::vector<int32_t> buf;
-                                                                         buf.reserve(len);
-                                                                         for (size_t i = 0;
-                                                                              i < len; ++i) {
-                                                                             auto item = array.getValueAtIndex(
-                                                                                     runtime,
-                                                                                     i)->NumberValue(
-                                                                                     context).ToChecked();
-                                                                             buf.push_back(
-                                                                                     static_cast<int32_t>(item));
-                                                                         }
-                                                                         rust::Slice<const int32_t> slice(
-                                                                                 buf.data(),
-                                                                                 buf.size());
-                                                                         canvas_native_webgl_uniform2iv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 slice,
-                                                                                 this->GetState());
-                                                                     }
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform2fv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1 && args[0].isObject() &&
-                                                             args[1].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-                                                                 auto v0 = args[1].asObject(
-                                                                         runtime);
-                                                                 if (location != nullptr) {
-                                                                     if (v0.isFloat32Array(
-                                                                             runtime)) {
-                                                                         auto array = v0.getTypedArray(
-                                                                                 runtime);
-                                                                         auto buf = GetTypedArrayData<const float>(
-                                                                                 runtime, array);
-                                                                         canvas_native_webgl_uniform2fv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 buf,
-                                                                                 this->GetState());
-                                                                     } else if (v0.isArray(
-                                                                             runtime)) {
-                                                                         auto array = v0.asArray(
-                                                                                 runtime);
-                                                                         auto len = array.size(
-                                                                                 runtime);
-
-                                                                         std::vector<float> buf;
-                                                                         buf.reserve(len);
-                                                                         for (size_t i = 0;
-                                                                              i < len; ++i) {
-                                                                             auto item = array.getValueAtIndex(
-                                                                                     runtime,
-                                                                                     i)->NumberValue(
-                                                                                     context).ToChecked();
-                                                                             buf.push_back(
-                                                                                     static_cast<float>(item));
-                                                                         }
-                                                                         rust::Slice<const float> slice(
-                                                                                 buf.data(),
-                                                                                 buf.size());
-                                                                         canvas_native_webgl_uniform2fv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 slice,
-                                                                                 this->GetState());
-                                                                     }
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform2i") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 2 && args[0].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-                                                                 auto v0 = (int32_t) args[1]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 auto v1 = (int32_t) args[2]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 if (location != nullptr) {
-                                                                     canvas_native_webgl_uniform2i(
-                                                                             location->GetUniformLocation(),
-                                                                             v0,
-                                                                             v1,
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform3f") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     4,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 3 && args[0].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-                                                                 auto v0 = args[1]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 auto v1 = args[2]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 auto v2 = args[3]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 if (location != nullptr) {
-                                                                     canvas_native_webgl_uniform3f(
-                                                                             location->GetUniformLocation(),
-                                                                             static_cast<float>(v0),
-                                                                             static_cast<float>(v1),
-                                                                             static_cast<float>(v2),
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
-                                                         }
-
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform3iv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-
-                                                         if (count > 1 && args[0].isObject() &&
-                                                             args[1].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-                                                                 auto v0 = args[1].asObject(
-                                                                         runtime);
-
-                                                                 if (location != nullptr) {
-                                                                     if (v0.isInt32Array(runtime)) {
-                                                                         auto array = v0.getTypedArray(
-                                                                                 runtime);
-                                                                         auto buf = GetTypedArrayData<const int32_t>(
-                                                                                 runtime, array);
-                                                                         canvas_native_webgl_uniform3iv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 buf,
-                                                                                 this->GetState());
-                                                                     } else if (v0.isArray(
-                                                                             runtime)) {
-                                                                         auto array = v0.asArray(
-                                                                                 runtime);
-                                                                         auto len = array.size(
-                                                                                 runtime);
-
-                                                                         std::vector<int32_t> buf;
-                                                                         buf.reserve(len);
-                                                                         for (int i = 0;
-                                                                              i < len; ++i) {
-                                                                             auto item = array.getValueAtIndex(
-                                                                                     runtime,
-                                                                                     (uint32_t) i)->NumberValue(
-                                                                                     context).ToChecked();
-                                                                             buf.push_back(
-                                                                                     static_cast<int32_t>(item));
-                                                                         }
-                                                                         rust::Slice<const int32_t> slice(
-                                                                                 buf.data(),
-                                                                                 buf.size());
-                                                                         canvas_native_webgl_uniform3iv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 slice,
-                                                                                 this->GetState());
-                                                                     }
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform3fv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1 && args[0].isObject() &&
-                                                             args[1].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             auto v0 = args[1].asObject(
-                                                                     runtime);
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-
-                                                                 if (location != nullptr) {
-
-
-                                                                     if (v0.isFloat32Array(
-                                                                             runtime)) {
-                                                                         auto array = v0.getTypedArray(
-                                                                                 runtime);
-                                                                         auto buf = GetTypedArrayData<const float>(
-                                                                                 runtime, array);
-                                                                         canvas_native_webgl_uniform3fv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 buf,
-                                                                                 this->GetState());
-                                                                     } else if (v0.isArray(
-                                                                             runtime)) {
-                                                                         auto array = v0.getArray(
-                                                                                 runtime);
-                                                                         auto len = array.size(
-                                                                                 runtime);
-                                                                         std::vector<float> buf;
-                                                                         buf.reserve(len);
-                                                                         for (int i = 0;
-                                                                              i < len; ++i) {
-                                                                             auto item = array.getValueAtIndex(
-                                                                                     runtime, i);
-                                                                             if (!item.isNumber()) {
-                                                                                 buf.push_back(
-                                                                                         nanf(""));
-                                                                             } else {
-                                                                                 auto value = item->NumberValue(
-                                                                                         context).ToChecked();
-                                                                                 buf.push_back(
-                                                                                         static_cast<float>(value));
-                                                                             }
-                                                                         }
-                                                                         rust::Slice<const float> slice(
-                                                                                 buf.data(),
-                                                                                 buf.size());
-                                                                         canvas_native_webgl_uniform3fv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 slice,
-                                                                                 this->GetState());
-                                                                     }
-                                                                 }
-
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform3i") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     4,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 3 && args[0].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-                                                                 auto v0 = (int32_t) args[1]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 auto v1 = (int32_t) args[2]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 auto v2 = (int32_t) args[3]->NumberValue(
-                                                                         context).ToChecked();
-
-                                                                 if (location != nullptr) {
-                                                                     canvas_native_webgl_uniform3i(
-                                                                             location->GetUniformLocation(),
-                                                                             v0,
-                                                                             v1,
-                                                                             v2,
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform4f") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     5,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 4 && args[0].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-                                                                 auto v0 = args[1]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 auto v1 = args[2]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 auto v2 = args[3]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 auto v3 = args[4]->NumberValue(
-                                                                         context).ToChecked();
-
-                                                                 if (location != nullptr) {
-                                                                     canvas_native_webgl_uniform4f(
-                                                                             location->GetUniformLocation(),
-                                                                             static_cast<float>(v0),
-                                                                             static_cast<float>(v1),
-                                                                             static_cast<float>(v2),
-                                                                             static_cast<float>(v3),
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform4iv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1 && args[0].isObject() &&
-                                                             args[1].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             auto v0 = args[1].asObject(
-                                                                     runtime);
-
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-                                                                 if (location != nullptr) {}
-                                                                 if (v0.isInt32Array(runtime)) {
-                                                                     auto array = v0.getTypedArray(
-                                                                             runtime);
-                                                                     auto buf = GetTypedArrayData<const int32_t>(
-                                                                             runtime, array);
-                                                                     canvas_native_webgl_uniform4iv(
-                                                                             location->GetUniformLocation(),
-                                                                             buf,
-                                                                             this->GetState());
-                                                                 } else if (v0.isArray(runtime)) {
-                                                                     auto array = v0.getArray(
-                                                                             runtime);
-                                                                     auto len = array.size(runtime);
-
-                                                                     std::vector<int32_t> buf;
-                                                                     buf.reserve(len);
-                                                                     for (int i = 0; i < len; ++i) {
-                                                                         auto item = array.getValueAtIndex(
-                                                                                 runtime,
-                                                                                 (uint32_t) i)->NumberValue(
-                                                                                 context).ToChecked();
-                                                                         buf.push_back(
-                                                                                 static_cast<int32_t>(item));
-                                                                     }
-                                                                     rust::Slice<const int32_t> slice(
-                                                                             buf.data(),
-                                                                             buf.size());
-                                                                     canvas_native_webgl_uniform4iv(
-                                                                             location->GetUniformLocation(),
-                                                                             slice,
-                                                                             this->GetState());
-                                                                 }
-                                                             }
-
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform4fv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1 && args[0].isObject() &&
-                                                             args[1].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             auto v0 = args[1].asObject(
-                                                                     runtime);
-
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-                                                                 if (location != nullptr) {
-                                                                     if (v0.isFloat32Array(
-                                                                             runtime)) {
-                                                                         auto array = v0.getTypedArray(
-                                                                                 runtime);
-                                                                         auto buf = GetTypedArrayData<const float>(
-                                                                                 runtime, array);
-                                                                         canvas_native_webgl_uniform4fv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 buf,
-                                                                                 this->GetState());
-                                                                     } else if (v0.isArray(
-                                                                             runtime)) {
-                                                                         auto array = v0.getArray(
-                                                                                 runtime);
-                                                                         auto len = array.size(
-                                                                                 runtime);
-
-                                                                         std::vector<float> buf;
-                                                                         buf.reserve(len);
-                                                                         for (int i = 0;
-                                                                              i < len; ++i) {
-                                                                             auto item = array.getValueAtIndex(
-                                                                                     runtime,
-                                                                                     (uint32_t) i)->NumberValue(
-                                                                                     context).ToChecked();
-                                                                             buf.push_back(
-                                                                                     static_cast<float>(item));
-                                                                         }
-                                                                         rust::Slice<const float> slice(
-                                                                                 buf.data(),
-                                                                                 buf.size());
-                                                                         canvas_native_webgl_uniform4fv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 slice,
-                                                                                 this->GetState());
-                                                                     }
-                                                                 }
-                                                             }
-
-                                                         }
-
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniform4i") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     5,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 4 && args[0].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-                                                                 auto v0 = (int32_t) args[1]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 auto v1 = (int32_t) args[2]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 auto v2 = (int32_t) args[3]->NumberValue(
-                                                                         context).ToChecked();
-                                                                 auto v3 = (int32_t) args[4]->NumberValue(
-                                                                         context).ToChecked();
-
-                                                                 if (location != nullptr) {
-                                                                     canvas_native_webgl_uniform4i(
-                                                                             location->GetUniformLocation(),
-                                                                             v0,
-                                                                             v1,
-                                                                             v2,
-                                                                             v3,
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniformMatrix2fv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 2 && args[0].isObject() &&
-                                                             args[2].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-                                                                 auto transpose = args[1].asBool();
-                                                                 auto value = args[2].asObject(
-                                                                         runtime);
-
-                                                                 if (location != nullptr) {
-                                                                     if (value.isFloat32Array(
-                                                                             runtime)) {
-                                                                         auto array = value.getTypedArray(
-                                                                                 runtime);
-                                                                         auto buf = GetTypedArrayData<const float>(
-                                                                                 runtime, array);
-                                                                         canvas_native_webgl_uniform_matrix2fv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 transpose, buf,
-                                                                                 this->GetState());
-                                                                     } else if (value.isArray(
-                                                                             runtime)) {
-                                                                         auto array = value.getArray(
-                                                                                 runtime);
-                                                                         auto len = array.size(
-                                                                                 runtime);
-                                                                         std::vector<float> buf;
-                                                                         buf.reserve(len);
-
-                                                                         for (int i = 0;
-                                                                              i < len; i++) {
-                                                                             auto item = array.getValueAtIndex(
-                                                                                     runtime, i);
-                                                                             if (item.isNumber()) {
-                                                                                 buf.push_back(
-                                                                                         static_cast<float>(item->NumberValue(
-                                                                                                 context).ToChecked()));
-                                                                             } else {
-                                                                                 buf.push_back(
-                                                                                         std::nanf(
-                                                                                                 ""));
-                                                                             }
-                                                                         }
-
-                                                                         rust::Slice<const float> slice(
-                                                                                 buf.data(),
-                                                                                 buf.size());
-                                                                         canvas_native_webgl_uniform_matrix2fv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 transpose, slice,
-                                                                                 this->GetState());
-                                                                     }
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniformMatrix3fv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 2 && args[0].isObject() &&
-                                                             args[2].isObject()) {
-                                                             auto locationObject = args[0].asObject(
-                                                                     runtime);
-                                                             if (locationObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto location = locationObject.asHostObject<WebGLUniformLocation>(
-                                                                         runtime);
-                                                                 auto transpose = args[1].asBool();
-                                                                 auto value = args[2].asObject(
-                                                                         runtime);
-
-                                                                 if (location != nullptr) {
-                                                                     if (value.isFloat32Array(
-                                                                             runtime)) {
-                                                                         auto array = value.getTypedArray(
-                                                                                 runtime);
-                                                                         auto buf = GetTypedArrayData<const float>(
-                                                                                 runtime, array);
-                                                                         canvas_native_webgl_uniform_matrix3fv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 transpose, buf,
-                                                                                 this->GetState());
-                                                                     } else if (value.isArray(
-                                                                             runtime)) {
-                                                                         auto array = value.getArray(
-                                                                                 runtime);
-                                                                         auto len = array.size(
-                                                                                 runtime);
-                                                                         std::vector<float> buf;
-                                                                         buf.reserve(len);
-
-                                                                         for (int i = 0;
-                                                                              i < len; i++) {
-                                                                             auto item = array.getValueAtIndex(
-                                                                                     runtime, i);
-                                                                             if (item.isNumber()) {
-                                                                                 buf.push_back(
-                                                                                         static_cast<float>(item->NumberValue(
-                                                                                                 context).ToChecked()));
-                                                                             } else {
-                                                                                 buf.push_back(
-                                                                                         std::nanf(
-                                                                                                 ""));
-                                                                             }
-                                                                         }
-
-                                                                         rust::Slice<const float> slice(
-                                                                                 buf.data(),
-                                                                                 buf.size());
-                                                                         canvas_native_webgl_uniform_matrix3fv(
-                                                                                 location->GetUniformLocation(),
-                                                                                 transpose, slice,
-                                                                                 this->GetState());
-                                                                     }
-                                                                 }
-                                                             }
-                                                         }
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "uniformMatrix4fv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 2 && args[0].isObject() &&
-                                                             args[2].isObject()) {
-                                                             auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, args[0]);
-                                                             if (location != nullptr) {
-                                                                 auto transpose = args[1].asBool();
-                                                                 auto value = args[2].asObject(
-                                                                         runtime);
-
-                                                                 if (value.isFloat32Array(
-                                                                         runtime)) {
-                                                                     auto array = value.getTypedArray(
-                                                                             runtime);
-                                                                     auto buf = GetTypedArrayData<const float>(
-                                                                             runtime, array);
-                                                                     canvas_native_webgl_uniform_matrix4fv(
-                                                                             location->GetUniformLocation(),
-                                                                             transpose, buf,
-                                                                             this->GetState());
-                                                                 } else if (value.isArray(
-                                                                         runtime)) {
-                                                                     auto array = value.getArray(
-                                                                             runtime);
-                                                                     auto len = array.size(
-                                                                             runtime);
-                                                                     std::vector<float> buf;
-                                                                     buf.reserve(len);
-
-                                                                     for (int i = 0;
-                                                                          i < len; i++) {
-                                                                         auto item = array.getValueAtIndex(
-                                                                                 runtime, i);
-                                                                         if (item.isNumber()) {
-                                                                             buf.push_back(
-                                                                                     static_cast<float>(item->NumberValue(
-                                                                                             context).ToChecked()));
-                                                                         } else {
-                                                                             buf.push_back(
-                                                                                     std::nanf(
-                                                                                             ""));
-                                                                         }
-                                                                     }
-
-                                                                     rust::Slice<const float> slice(
-                                                                             buf.data(),
-                                                                             buf.size());
-                                                                     canvas_native_webgl_uniform_matrix4fv(
-                                                                             location->GetUniformLocation(),
-                                                                             transpose, slice,
-                                                                             this->GetState());
-                                                                 }
-                                                             }
-                                                         }
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "useProgram") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 0) {
-                                                             if (args[0].isNull()) {
-                                                                 canvas_native_webgl_use_program(0,
-                                                                                                 this->GetState());
-
-                                                                 return jsi::Value::undefined();
-                                                             }
-
-                                                             if (args[0].isObject()) {
-                                                                 auto programObject = args[0].asObject(
-                                                                         runtime);
-                                                                 if (programObject.isHostObject(
-                                                                         runtime)) {
-                                                                     auto program = programObject.asHostObject<WebGLProgram>(
-                                                                             runtime);
-                                                                     if (program != nullptr) {
-                                                                         canvas_native_webgl_use_program(
-                                                                                 program->GetProgram(),
-                                                                                 this->GetState()
-                                                                         );
-                                                                     }
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "validateProgram") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 0 && args[0].isObject()) {
-                                                             auto programObject = args[0].asObject(
-                                                                     runtime);
-                                                             if (programObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto program = programObject.asHostObject<WebGLProgram>(
-                                                                         runtime);
-                                                                 if (program != nullptr) {
-                                                                     canvas_native_webgl_validate_program(
-                                                                             program->GetProgram(),
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "viewport") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     4,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 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,
-                                                                                          this->GetState());
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "__toDataURL") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         std::string type("image/png");
-                                                         int quality = 92;
-                                                         if (args[0].isString()) {
-                                                             type = args[0].asString(
-                                                                     runtime).utf8(
-                                                                     runtime);
-                                                         }
-
-
-                                                         if (args[1].isNumber()) {
-                                                             quality = (int) args[1]->NumberValue(
-                                                                     context).ToChecked();
-                                                         }
-
-
-                                                         auto data = canvas_native_webgl_to_data_url(
-                                                                 this->GetState(),
-                                                                 rust::Str(type.c_str()),
-                                                                 quality);
-                                                         return jsi::String::createFromAscii(
-                                                                 runtime,
-                                                                 data.data(),
-                                                                 data.size());
-                                                     }
-        );
-    }
-
-
-    return jsi::Value::undefined();
+    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));
 }
 
 
+
diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLRenderingContext.h b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLRenderingContext.h
index 9d8a0957..49f9bbfa 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLRenderingContext.h
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLRenderingContext.h
@@ -71,458 +71,302 @@ class WebGLRenderingContext : public WebGLRenderingContextBase {
 
     static WebGLRenderingContext *GetPointer(const v8::Local<v8::Object> &object);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    v8::Local<v8::Value> GetParameterInternal(v8::Isolate *isolate, uint32_t pnameValue,
+                                              rust::Box<WebGLResult> result);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static void GetDrawingBufferWidth(v8::Local<v8::String> name,
+                                      const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    v8::Local<v8::Value> GetParameterInternal(v8::Isolate * isolate, uint32_t pnameValue,
-                                    rust::Box<WebGLResult> result);
+    static void GetFlipY(v8::Local<v8::String> name,
+                         const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    static void  GetDrawingBufferWidth(v8::Local<v8::String> name,
-                                                 const v8::PropertyCallbackInfo<v8::Value> &info);
-
-    static void  GetFlipY(v8::Local<v8::String> name,
+    static void GetDrawingBufferHeight(v8::Local<v8::String> name,
                                        const v8::PropertyCallbackInfo<v8::Value> &info);
 
-    static void  GetDrawingBufferHeight(v8::Local<v8::String> name,
-                                       const v8::PropertyCallbackInfo<v8::Value> &info);
+    static void __Resized(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __StartRaf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void __StopRaf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ActiveTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void AttachShader(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindAttribLocation(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BlendColor(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BlendEquationSeparate(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BlendEquation(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BlendFuncSeparate(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BlendFunc(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BufferData(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BufferSubData(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CheckFramebufferStatus(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearColor(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearDepth(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearStencil(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Clear(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ColorMask(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Commit(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CompileShader(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CompressedTexImage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CompressedTexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CopyTexImage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CopyTexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateProgram(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateShader(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CullFace(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteProgram(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteShader(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DepthFunc(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DepthMask(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DepthRange(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DetachShader(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DisableVertexAttribArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Disable(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawArrays(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawElements(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void EnableVertexAttribArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Enable(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Finish(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Flush(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FramebufferRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FramebufferTexture2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FrontFace(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GenerateMipmap(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetActiveAttrib(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetActiveUniform(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetAttachedShaders(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetAttribLocation(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetBufferParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetContextAttributes(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetError(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetExtension(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetFramebufferAttachmentParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetProgramInfoLog(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetProgramParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetRenderbufferParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetShaderInfoLog(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetShaderParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetShaderPrecisionFormat(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetShaderSource(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetSupportedExtensions(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetTexParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetUniformLocation(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetUniform(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetVertexAttribOffset(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetVertexAttrib(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    static inline jsi::Value GetProperty(const std::string &methodName) {
-        if (methodName == "DEPTH_BUFFER_BIT") { return {0x00000100}; }
+    static void Hint(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "STENCIL_BUFFER_BIT") { return {0x00000400}; }
+    static void IsBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "COLOR_BUFFER_BIT") { return {0x00004000}; }
+    static void IsContextLost(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "POINTS") { return {0x0000}; }
+    static void IsEnabled(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "LINES") { return {0x0001}; }
+    static void IsFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "LINE_LOOP") { return {0x0002}; }
+    static void IsProgram(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "LINE_STRIP") { return {0x0003}; }
+    static void IsRenderbuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "TRIANGLES") { return {0x0004}; }
+    static void IsShader(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "TRIANGLE_STRIP") { return {0x0005}; }
+    static void IsTexture(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "TRIANGLE_FAN") { return {0x0006}; }
+    static void LineWidth(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "ZERO") { return {0}; }
+    static void LinkProgram(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "ONE") { return {1}; }
+    static void PixelStorei(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "SRC_COLOR") { return {0x0300}; }
+    static void PolygonOffset(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "ONE_MINUS_SRC_COLOR") { return {0x0301}; }
+    static void ReadPixels(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "SRC_ALPHA") { return {0x0302}; }
+    static void RenderbufferStorage(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "ONE_MINUS_SRC_ALPHA") { return {0x0303}; }
+    static void SampleCoverage(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "DST_ALPHA") { return {0x0304}; }
+    static void Scissor(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "ONE_MINUS_DST_ALPHA") { return {0x0305}; }
+    static void ShaderSource(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "DST_COLOR") { return {0x0306}; }
+    static void StencilFuncSeparate(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "ONE_MINUS_DST_COLOR") { return {0x0307}; }
+    static void StencilFunc(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "SRC_ALPHA_SATURATE") { return {0x0308}; }
+    static void StencilMaskSeparate(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void StencilMask(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "CONSTANT_COLOR") { return {0x8001}; }
-        if (methodName == "ONE_MINUS_CONSTANT_COLOR") { return {0x8002}; }
-        if (methodName == "CONSTANT_ALPHA") { return {0x8003}; }
-        if (methodName == "ONE_MINUS_CONSTANT_ALPHA") { return {0x8004}; }
+    static void StencilOpSeparate(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void StencilOp(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        /* Blending equations */
+    static void TexImage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "FUNC_ADD") { return {0x8006}; }
-        if (methodName == "FUNC_SUBTRACT") { return {0x800A}; }
-        if (methodName == "FUNC_REVERSE_SUBTRACT") { return {0x800B}; }
-        if (methodName == "BLEND_EQUATION") { return {0x8009}; }
-        if (methodName == "BLEND_EQUATION_RGB") { return {0x8009}; }
-        if (methodName == "BLEND_EQUATION_ALPHA") { return {0x883D}; }
+    static void TexParameterf(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void TexParameteri(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "BLEND_DST_RGB") { return {0x80C8}; }
-        if (methodName == "BLEND_SRC_RGB") { return {0x80C9}; }
-        if (methodName == "BLEND_DST_ALPHA") { return {0x80CA}; }
+    static void TexSubImage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void Uniform1f(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "BLEND_SRC_ALPHA") { return {0x80CB}; }
-        if (methodName == "BLEND_COLOR") { return {0x8005}; }
-        if (methodName == "ARRAY_BUFFER_BINDING") { return {0x8894}; }
+    static void Uniform1iv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void Uniform1fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "ELEMENT_ARRAY_BUFFER_BINDING") { return {0x8895}; }
-        if (methodName == "LINE_WIDTH") { return {0x0B21}; }
-        if (methodName == "ALIASED_POINT_SIZE_RANGE") { return {0x846D}; }
+    static void Uniform1i(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "ALIASED_LINE_WIDTH_RANGE") { return {0x846E}; }
-        if (methodName == "CULL_FACE_MODE") { return {0x0B45}; }
-        if (methodName == "FRONT_FACE") { return {0x0B46}; }
+    static void Uniform2f(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "DEPTH_RANGE") { return {0x0B70}; }
-        if (methodName == "DEPTH_WRITEMASK") { return {0x0B72}; }
-        if (methodName == "DEPTH_CLEAR_VALUE") { return {0x0B73}; }
+    static void Uniform2iv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "DEPTH_FUNC") { return {0x0B74}; }
-        if (methodName == "STENCIL_CLEAR_VALUE") { return {0x0B91}; }
-        if (methodName == "STENCIL_FUNC") { return {0x0B92}; }
+    static void Uniform2fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "STENCIL_FAIL") { return {0x0B94}; }
-        if (methodName == "STENCIL_PASS_DEPTH_FAIL") { return {0x0B95}; }
-        if (methodName == "STENCIL_PASS_DEPTH_PASS") { return {0x0B96}; }
+    static void Uniform2i(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "STENCIL_REF") { return {0x0B97}; }
-        if (methodName == "STENCIL_VALUE_MASK") { return {0x0B93}; }
-        if (methodName == "STENCIL_WRITEMASK") { return {0x0B98}; }
+    static void Uniform3f(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "STENCIL_BACK_FUNC") { return {0x8800}; }
-        if (methodName == "STENCIL_BACK_FAIL") { return {0x8801}; }
-        if (methodName == "STENCIL_BACK_PASS_DEPTH_FAIL") { return {0x8802}; }
+    static void Uniform3iv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "STENCIL_BACK_PASS_DEPTH_PASS") { return {0x8803}; }
-        if (methodName == "STENCIL_BACK_REF") { return {0x8CA3}; }
-        if (methodName == "STENCIL_BACK_VALUE_MASK") { return {0x8CA4}; }
-        if (methodName == "STENCIL_BACK_WRITEMASK") { return {0x8CA5}; }
+    static void Uniform3fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "VIEWPORT") { return {0x0BA2}; }
-        if (methodName == "SCISSOR_BOX") { return {0x0C10}; }
-        if (methodName == "COLOR_CLEAR_VALUE") { return {0x0C22}; }
-        if (methodName == "COLOR_WRITEMASK") { return {0x0C23}; }
+    static void Uniform3i(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "UNPACK_ALIGNMENT") { return {0x0CF5}; }
-        if (methodName == "PACK_ALIGNMENT") { return {0x0D05}; }
-        if (methodName == "MAX_TEXTURE_SIZE") { return {0x0D33}; }
+    static void Uniform4f(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void Uniform4iv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "MAX_VIEWPORT_DIMS") { return {0x0D3A}; }
-        if (methodName == "SUBPIXEL_BITS") { return {0x0D50}; }
+    static void Uniform4fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "RED_BITS") { return {0x0D52}; }
-        if (methodName == "GREEN_BITS") { return {0x0D53}; }
-        if (methodName == "BLUE_BITS") { return {0x0D54}; }
-        if (methodName == "ALPHA_BITS") { return {0x0D55}; }
+    static void Uniform4i(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "STENCIL_BITS") { return {0x0D57}; }
-        if (methodName == "POLYGON_OFFSET_UNITS") { return {0x2A00}; }
-        if (methodName == "POLYGON_OFFSET_FACTOR") { return {0x8038}; }
+    static void UniformMatrix2fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "TEXTURE_BINDING_2D") { return {0x8069}; }
-        if (methodName == "SAMPLE_BUFFERS") { return {0x80A8}; }
-        if (methodName == "SAMPLES") { return {0x80A9}; }
-        if (methodName == "SAMPLE_COVERAGE_VALUE") { return {0x80AA}; }
+    static void UniformMatrix3fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "SAMPLE_COVERAGE_INVERT") { return {0x80AB}; }
-        if (methodName == "COMPRESSED_TEXTURE_FORMATS") { return {0x86A3}; }
-        if (methodName == "VENDOR") { return {0x1F00}; }
-        if (methodName == "RENDERER") { return {0x1F01}; }
+    static void UniformMatrix4fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "VERSION") { return {0x1F02}; }
-        if (methodName == "IMPLEMENTATION_COLOR_READ_TYPE") { return {0x8B9A}; }
-        if (methodName == "IMPLEMENTATION_COLOR_READ_FORMAT") { return {0x8B9B}; }
-        if (methodName == "BROWSER_DEFAULT_WEBGL") { return {0x9244}; }
+    static void UseProgram(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "STATIC_DRAW") { return {0x88E4}; }
-        if (methodName == "STREAM_DRAW") { return {0x88E0}; }
-        if (methodName == "DYNAMIC_DRAW") { return {0x88E8}; }
-        if (methodName == "ARRAY_BUFFER") { return {0x8892}; }
+    static void ValidateProgram(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "ELEMENT_ARRAY_BUFFER") { return {0x8893}; }
-        if (methodName == "BUFFER_SIZE") { return {0x8764}; }
-        if (methodName == "BUFFER_USAGE") { return {0x8765}; }
-        if (methodName == "CURRENT_VERTEX_ATTRIB") { return {0x8626}; }
+    static void VertexAttrib1f(const v8::FunctionCallbackInfo<v8::Value> &args);
 
+    static void VertexAttrib1fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "VERTEX_ATTRIB_ARRAY_ENABLED") { return {0x8622}; }
-        if (methodName == "VERTEX_ATTRIB_ARRAY_SIZE") { return {0x8623}; }
-        if (methodName == "VERTEX_ATTRIB_ARRAY_STRIDE") { return {0x8624}; }
-        if (methodName == "VERTEX_ATTRIB_ARRAY_TYPE") { return {0x8625}; }
-        if (methodName == "VERTEX_ATTRIB_ARRAY_NORMALIZED") { return {0x886A}; }
-        if (methodName == "VERTEX_ATTRIB_ARRAY_POINTER") { return {0x8645}; }
-        if (methodName == "VERTEX_ATTRIB_ARRAY_BUFFER_BINDING") { return {0x889F}; }
+    static void VertexAttrib2f(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "CULL_FACE") { return {0x0B44}; }
-        if (methodName == "FRONT") { return {0x0404}; }
-        if (methodName == "BACK") { return {0x0405}; }
-        if (methodName == "FRONT_AND_BACK") { return {0x0408}; }
-
-        if (methodName == "BLEND") { return {0x0BE2}; }
-        if (methodName == "DEPTH_TEST") { return {0x0B71}; }
-        if (methodName == "DITHER") { return {0x0BD0}; }
-        if (methodName == "POLYGON_OFFSET_FILL") { return {0x8037}; }
-
-        if (methodName == "SAMPLE_ALPHA_TO_COVERAGE") { return {0x809E}; }
-        if (methodName == "SAMPLE_COVERAGE") { return {0x80A0}; }
-        if (methodName == "SCISSOR_TEST") { return {0x0C11}; }
-        if (methodName == "STENCIL_TEST") { return {0x0B90}; }
-
-
-        /* Errors */
-
-        if (methodName == "NO_ERROR") { return {0}; }
-        if (methodName == "INVALID_ENUM") { return {0x0500}; }
-        if (methodName == "INVALID_VALUE") { return {0x0501}; }
-        if (methodName == "INVALID_OPERATION") { return {0x0502}; }
-
-        if (methodName == "OUT_OF_MEMORY") { return {0x0505}; }
-        if (methodName == "CONTEXT_LOST_WEBGL") { return {0x9242}; }
-        if (methodName == "CW") { return {0x0900}; }
-        if (methodName == "CCW") { return {0x0901}; }
-
-        if (methodName == "DONT_CARE") { return {0x1100}; }
-        if (methodName == "FASTEST") { return {0x1101}; }
-        if (methodName == "NICEST") { return {0x1102}; }
-        if (methodName == "GENERATE_MIPMAP_HINT") { return {0x8192}; }
-
-        if (methodName == "BYTE") { return {0x1400}; }
-        if (methodName == "UNSIGNED_BYTE") { return {0x1401}; }
-        if (methodName == "SHORT") { return {0x1402}; }
-        if (methodName == "UNSIGNED_SHORT") { return {0x1403}; }
-
-        if (methodName == "INT") { return {0x1404}; }
-        if (methodName == "UNSIGNED_INT") { return {0x1405}; }
-        if (methodName == "FLOAT") { return {0x1406}; }
-        if (methodName == "DEPTH_COMPONENT") { return {0x1902}; }
-
-        if (methodName == "ALPHA") { return {0x1906}; }
-        if (methodName == "RGB") { return {0x1907}; }
-
-        /* Clearing buffers */
-
-        if (methodName == "RGBA") { return {0x1908}; }
-        if (methodName == "LUMINANCE") { return {0x1909}; }
-        if (methodName == "LUMINANCE_ALPHA") { return {0x190A}; }
-
-        /* Clearing buffers */
-
-        /* Rendering primitives */
-
-        if (methodName == "UNSIGNED_SHORT_4_4_4_4") { return {0x8033}; }
-        if (methodName == "UNSIGNED_SHORT_5_5_5_1") { return {0x8034}; }
-        if (methodName == "UNSIGNED_SHORT_5_6_5") { return {0x8363}; }
-        if (methodName == "FRAGMENT_SHADER") { return {0x8B30}; }
-        if (methodName == "VERTEX_SHADER") { return {0x8B31}; }
-        if (methodName == "COMPILE_STATUS") { return {0x8B81}; }
-        if (methodName == "DELETE_STATUS") { return {0x8B80}; }
-
-        /* Rendering primitives */
-
-        /* Blending modes */
-
-        if (methodName == "LINK_STATUS") { return {0x8B82}; }
-        if (methodName == "VALIDATE_STATUS") { return {0x8B83}; }
-        if (methodName == "ATTACHED_SHADERS") { return {0x8B85}; }
-        if (methodName == "ACTIVE_ATTRIBUTES") { return {0x8B89}; }
-        if (methodName == "ACTIVE_UNIFORMS") { return {0x8B86}; }
-        if (methodName == "MAX_VERTEX_ATTRIBS") { return {0x8869}; }
-        if (methodName == "MAX_VERTEX_UNIFORM_VECTORS") { return {0x8DFB}; }
-        if (methodName == "MAX_VARYING_VECTORS") { return {0x8DFC}; }
-        if (methodName == "MAX_COMBINED_TEXTURE_IMAGE_UNITS") { return {0x8B4D}; }
-        if (methodName == "MAX_VERTEX_TEXTURE_IMAGE_UNITS") { return {0x8B4C}; }
-        if (methodName == "MAX_TEXTURE_IMAGE_UNITS") { return {0x8872}; }
-        if (methodName == "MAX_FRAGMENT_UNIFORM_VECTORS") { return {0x8DFD}; }
-        if (methodName == "SHADER_TYPE") { return {0x8B4F}; }
-        if (methodName == "SHADING_LANGUAGE_VERSION") { return {0x8B8C}; }
-        if (methodName == "CURRENT_PROGRAM") { return {0x8B8D}; }
-
-        /* Blending modes */
-
-        if (methodName == "NEVER") { return {0x0200}; }
-        if (methodName == "LESS") { return {0x0201}; }
-        if (methodName == "EQUAL") { return {0x0202}; }
-
-        /* Blending equations */
-
-        /* Getting GL parameter information */
-
-        if (methodName == "LEQUAL") { return {0x0203}; }
-        if (methodName == "GREATER") { return {0x0204}; }
-        if (methodName == "NOTEQUAL") { return {0x0205}; }
-        if (methodName == "GEQUAL") { return {0x0206}; }
-        if (methodName == "ALWAYS") { return {0x0207}; }
-        if (methodName == "KEEP") { return {0x1E00}; }
-        if (methodName == "REPLACE") { return {0x1E01}; }
-        if (methodName == "INCR") { return {0x1E02}; }
-        if (methodName == "DECR") { return {0x1E03}; }
-        if (methodName == "INVERT") { return {0x150A}; }
-        if (methodName == "INCR_WRAP") { return {0x8507}; }
-        if (methodName == "DECR_WRAP") { return {0x8508}; }
-        if (methodName == "NEAREST") { return {0x2600}; }
-        if (methodName == "LINEAR") { return {0x2601}; }
-        if (methodName == "NEAREST_MIPMAP_NEAREST") { return {0x2700}; }
-        if (methodName == "LINEAR_MIPMAP_NEAREST") { return {0x2701}; }
-        if (methodName == "NEAREST_MIPMAP_LINEAR") { return {0x2702}; }
-        if (methodName == "LINEAR_MIPMAP_LINEAR") { return {0x2703}; }
-        if (methodName == "TEXTURE_MAG_FILTER") { return {0x2800}; }
-        if (methodName == "TEXTURE_MIN_FILTER") { return {0x2801}; }
-        if (methodName == "TEXTURE_WRAP_S") { return {0x2802}; }
-        if (methodName == "TEXTURE_WRAP_T") { return {0x2803}; }
-        if (methodName == "TEXTURE_2D") { return {0x0DE1}; }
-        if (methodName == "TEXTURE") { return {0x1702}; }
-        if (methodName == "TEXTURE_CUBE_MAP") { return {0x8513}; }
-        if (methodName == "TEXTURE_BINDING_CUBE_MAP") { return {0x8514}; }
-        if (methodName == "TEXTURE_CUBE_MAP_POSITIVE_X") { return {0x8515}; }
-        if (methodName == "TEXTURE_CUBE_MAP_NEGATIVE_X") { return {0x8516}; }
-        if (methodName == "TEXTURE_CUBE_MAP_POSITIVE_Y") { return {0x8517}; }
-        if (methodName == "TEXTURE_CUBE_MAP_NEGATIVE_Y") { return {0x8518}; }
-        if (methodName == "TEXTURE_CUBE_MAP_POSITIVE_Z") { return {0x8519}; }
-        if (methodName == "TEXTURE_CUBE_MAP_NEGATIVE_Z") { return {0x851A}; }
-        if (methodName == "MAX_CUBE_MAP_TEXTURE_SIZE") { return {0x851C}; }
-        if (methodName == "TEXTURE0") { return {0x84C0}; }
-        if (methodName == "TEXTURE1") { return {0x84C1}; }
-        if (methodName == "TEXTURE2") { return {0x84C2}; }
-        if (methodName == "TEXTURE3") { return {0x84C3}; }
-        if (methodName == "TEXTURE4") { return {0x84C4}; }
-        if (methodName == "TEXTURE5") { return {0x84C5}; }
-        if (methodName == "TEXTURE6") { return {0x84C6}; }
-        if (methodName == "TEXTURE7") { return {0x84C7}; }
-        if (methodName == "TEXTURE8") { return {0x84C8}; }
-        if (methodName == "TEXTURE9") { return {0x84C9}; }
-        if (methodName == "TEXTURE10") { return {0x84CA}; }
-        if (methodName == "TEXTURE11") { return {0x84CB}; }
-        if (methodName == "TEXTURE12") { return {0x84CC}; }
-        if (methodName == "TEXTURE13") { return {0x84CD}; }
-        if (methodName == "TEXTURE14") { return {0x84CE}; }
-        if (methodName == "TEXTURE15") { return {0x84CF}; }
-        if (methodName == "TEXTURE16") { return {0x84D0}; }
-        if (methodName == "TEXTURE17") { return {0x84D1}; }
-        if (methodName == "TEXTURE18") { return {0x84D2}; }
-        if (methodName == "TEXTURE19") { return {0x84D3}; }
-        if (methodName == "TEXTURE20") { return {0x84D4}; }
-        if (methodName == "TEXTURE21") { return {0x84D5}; }
-        if (methodName == "TEXTURE22") { return {0x84D6}; }
-        if (methodName == "TEXTURE23") { return {0x84D7}; }
-        if (methodName == "TEXTURE24") { return {0x84D8}; }
-        if (methodName == "TEXTURE25") { return {0x84D9}; }
-        if (methodName == "TEXTURE26") { return {0x84DA}; }
-        if (methodName == "TEXTURE27") { return {0x84DB}; }
-        if (methodName == "TEXTURE28") { return {0x84DC}; }
-        if (methodName == "TEXTURE29") { return {0x84DD}; }
-
-        /* Getting GL parameter information */
-
-        /* Buffers */
-
-        if (methodName == "TEXTURE30") { return {0x84DE}; }
-        if (methodName == "TEXTURE31") { return {0x84DF}; }
-        if (methodName == "ACTIVE_TEXTURE") { return {0x84E0}; }
-        if (methodName == "REPEAT") { return {0x2901}; }
-        if (methodName == "CLAMP_TO_EDGE") { return {0x812F}; }
-        if (methodName == "MIRRORED_REPEAT") { return {0x8370}; }
-        if (methodName == "FLOAT_VEC2") { return {0x8B50}; }
-
-        /* Buffers */
-
-        /* Vertex attributes */
-
-        if (methodName == "FLOAT_VEC3") { return {0x8B51}; }
-        if (methodName == "FLOAT_VEC4") { return {0x8B52}; }
-        if (methodName == "INT_VEC2") { return {0x8B53}; }
-        if (methodName == "INT_VEC3") { return {0x8B54}; }
-        if (methodName == "INT_VEC4") { return {0x8B55}; }
-        if (methodName == "BOOL") { return {0x8B56}; }
-        if (methodName == "BOOL_VEC2") { return {0x8B57}; }
-        if (methodName == "BOOL_VEC3") { return {0x8B58}; }
-
-        /* Vertex attributes */
-
-        /* Culling */
-
-        if (methodName == "BOOL_VEC4") { return {0x8B59}; }
-        if (methodName == "FLOAT_MAT2") { return {0x8B5A}; }
-        if (methodName == "FLOAT_MAT3") { return {0x8B5B}; }
-        if (methodName == "FLOAT_MAT4") { return {0x8B5C}; }
-
-        /* Culling */
-
-        /* Enabling and disabling */
-
-        if (methodName == "SAMPLER_2D") { return {0x8B5E}; }
-        if (methodName == "SAMPLER_CUBE") { return {0x8B60}; }
-        if (methodName == "LOW_FLOAT") { return {0x8DF0}; }
-        if (methodName == "MEDIUM_FLOAT") { return {0x8DF1}; }
-        if (methodName == "HIGH_FLOAT") { return {0x8DF2}; }
-        if (methodName == "LOW_INT") { return {0x8DF3}; }
-        if (methodName == "MEDIUM_INT") { return {0x8DF4}; }
-        if (methodName == "HIGH_INT") { return {0x8DF5}; }
-
-        /* Enabling and disabling */
-
-        if (methodName == "FRAMEBUFFER") { return {0x8D40}; }
-        if (methodName == "RENDERBUFFER") { return {0x8D41}; }
-        if (methodName == "RGBA4") { return {0x8056}; }
-        if (methodName == "RGB5_A1") { return {0x8057}; }
-        if (methodName == "RGB565") { return {0x8D62}; }
-        if (methodName == "DEPTH_COMPONENT16") { return {0x81A5}; }
-        if (methodName == "STENCIL_INDEX8") { return {0x8D48}; }
-
-        /* Errors */
-
-        /* Front face directions */
-
-        if (methodName == "DEPTH_STENCIL") { return {0x84F9}; }
-        if (methodName == "RENDERBUFFER_WIDTH") { return {0x8D42}; }
-
-        /* Front face directions */
-
-        /* Hints */
-
-        if (methodName == "RENDERBUFFER_HEIGHT") { return {0x8D43}; }
-        if (methodName == "RENDERBUFFER_INTERNAL_FORMAT") { return {0x8D44}; }
-        if (methodName == "RENDERBUFFER_RED_SIZE") { return {0x8D50}; }
-        if (methodName == "RENDERBUFFER_GREEN_SIZE") { return {0x8D51}; }
-
-        /* Hints */
-
-        /* Data types */
-
-        if (methodName == "RENDERBUFFER_BLUE_SIZE") { return {0x8D52}; }
-        if (methodName == "RENDERBUFFER_ALPHA_SIZE") { return {0x8D53}; }
-        if (methodName == "RENDERBUFFER_DEPTH_SIZE") { return {0x8D54}; }
-        if (methodName == "RENDERBUFFER_STENCIL_SIZE") { return {0x8D55}; }
-        if (methodName == "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE") { return {0x8CD0}; }
-        if (methodName == "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME") { return {0x8CD1}; }
-        if (methodName == "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL") { return {0x8CD2}; }
-
-        /* Data types */
+    static void VertexAttrib2fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        /* Pixel formats */
+    static void VertexAttrib3f(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE") { return {0x8CD3}; }
-        if (methodName == "COLOR_ATTACHMENT0") { return {0x8CE0}; }
-        if (methodName == "DEPTH_ATTACHMENT") { return {0x8D00}; }
-        if (methodName == "STENCIL_ATTACHMENT") { return {0x8D20}; }
-        if (methodName == "DEPTH_STENCIL_ATTACHMENT") { return {0x821A}; }
-        if (methodName == "NONE") { return {}; }
+    static void VertexAttrib3fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        /* Pixel formats */
+    static void VertexAttrib4f(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        /* Pixel types */
+    static void VertexAttrib4fv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        if (methodName == "FRAMEBUFFER_COMPLETE") { return {0x8CD5}; }
-        if (methodName == "FRAMEBUFFER_INCOMPLETE_ATTACHMENT") { return {0x8CD6}; }
-        if (methodName == "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT") { return {0x8CD7}; }
+    static void VertexAttribPointer(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        /* Pixel types */
+    static void Viewport(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        /* Shaders */
+    static void SetConstants(v8::Isolate *isolate, const v8::Local<v8::ObjectTemplate>& tmpl);
 
-        if (methodName == "FRAMEBUFFER_INCOMPLETE_DIMENSIONS") { return {0x8CD9}; }
-        if (methodName == "FRAMEBUFFER_UNSUPPORTED") { return {0x8CDD}; }
-        if (methodName == "FRAMEBUFFER_BINDING") { return {0x8CA6}; }
-        if (methodName == "RENDERBUFFER_BINDING") { return {0x8CA7}; }
-        if (methodName == "MAX_RENDERBUFFER_SIZE") { return {0x84E8}; }
-        if (methodName == "INVALID_FRAMEBUFFER_OPERATION") { return {0x0506}; }
-        if (methodName == "UNPACK_FLIP_Y_WEBGL") { return {0x9240}; }
-        if (methodName == "UNPACK_PREMULTIPLY_ALPHA_WEBGL") { return {0x9241}; }
-        if (methodName == "UNPACK_COLORSPACE_CONVERSION_WEBGL") { return {0x9243}; }
+    static void __ToDataURL(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-        return jsi::Value::undefined();
-    }
+    static void __GetSupportedExtensions(const v8::FunctionCallbackInfo<v8::Value> &args);
 
 };
diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLShaderPrecisionFormatImpl.cpp b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLShaderPrecisionFormatImpl.cpp
index 7731e6b5..97b425ae 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLShaderPrecisionFormatImpl.cpp
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLShaderPrecisionFormatImpl.cpp
@@ -8,33 +8,44 @@ WebGLShaderPrecisionFormatImpl::WebGLShaderPrecisionFormatImpl(
         rust::Box<WebGLShaderPrecisionFormat> shader) : shader_(
         std::move(shader)) {}
 
-std::vector<jsi::PropNameID> WebGLShaderPrecisionFormatImpl::getPropertyNames(jsi::Runtime &rt) {
-    std::vector<jsi::PropNameID> ret;
-    ret.reserve(3);
-    ret.emplace_back(jsi::PropNameID::forUtf8(rt, std::string("rangeMin")));
-    ret.emplace_back(jsi::PropNameID::forUtf8(rt, std::string("rangeMax")));
-    ret.emplace_back(jsi::PropNameID::forUtf8(rt, std::string("precision")));
-    return ret;
+
+void WebGLShaderPrecisionFormatImpl::GetRangeMin(v8::Local<v8::String> property,
+                                                 const v8::PropertyCallbackInfo<v8::Value> &info) {
+    WebGLShaderPrecisionFormatImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(0);
+        return;
+    }
+
+    info.GetReturnValue().Set((double) canvas_native_webgl_shader_precision_format_get_range_min(
+            ptr->GetShaderPrecisionFormat()));
 }
 
-jsi::Value WebGLShaderPrecisionFormatImpl::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
-    auto methodName = name.utf8(runtime);
-
-    if (methodName == "rangeMin") {
-        return {canvas_native_webgl_shader_precision_format_get_range_min(
-                this->GetShaderPrecisionFormat())};
-    } else if (methodName == "rangeMax") {
-        return {canvas_native_webgl_shader_precision_format_get_range_max(
-                this->GetShaderPrecisionFormat())};
-    } else if (methodName == "precision") {
-        return {canvas_native_webgl_shader_precision_format_get_precision(
-                this->GetShaderPrecisionFormat())};
+void WebGLShaderPrecisionFormatImpl::GetRangeMax(v8::Local<v8::String> property,
+                                                 const v8::PropertyCallbackInfo<v8::Value> &info) {
+    WebGLShaderPrecisionFormatImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(0);
+        return;
     }
 
-    return jsi::Value::undefined();
+    info.GetReturnValue().Set((double) canvas_native_webgl_shader_precision_format_get_range_max(
+            ptr->GetShaderPrecisionFormat()));
 }
 
 
+void WebGLShaderPrecisionFormatImpl::GetPrecision(v8::Local<v8::String> property,
+                                                  const v8::PropertyCallbackInfo<v8::Value> &info) {
+    WebGLShaderPrecisionFormatImpl *ptr = GetPointer(info.This());
+    if (ptr == nullptr) {
+        info.GetReturnValue().Set(0);
+        return;
+    }
+
+    info.GetReturnValue().Set((double) canvas_native_webgl_shader_precision_format_get_precision(
+            ptr->GetShaderPrecisionFormat()));
+}
+
 WebGLShaderPrecisionFormat &WebGLShaderPrecisionFormatImpl::GetShaderPrecisionFormat() {
     return *this->shader_;
 }
diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLShaderPrecisionFormatImpl.h b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLShaderPrecisionFormatImpl.h
index a21274cb..28e03d26 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLShaderPrecisionFormatImpl.h
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLShaderPrecisionFormatImpl.h
@@ -6,19 +6,72 @@
 
 #include "rust/cxx.h"
 #include "canvas-cxx/src/lib.rs.h"
-#include "v8runtime/V8Runtime.h"
 #include <vector>
+#include "Helpers.h"
+#include "Caches.h"
+#include "Common.h"
 
-using namespace facebook;
 using namespace org::nativescript::canvas;
 
-class WebGLShaderPrecisionFormatImpl : public jsi::HostObject {
+class WebGLShaderPrecisionFormatImpl {
 public:
     WebGLShaderPrecisionFormatImpl(rust::Box<WebGLShaderPrecisionFormat> shader);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLShaderPrecisionFormatTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLShaderPrecisionFormat"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        tmpl->SetAccessor(ConvertToV8String(isolate, "rangeMin"), &GetRangeMin);
+        tmpl->SetAccessor(ConvertToV8String(isolate, "rangeMax"), &GetRangeMax);
+        tmpl->SetAccessor(ConvertToV8String(isolate, "precision"), &GetPrecision);
+
+        tmpl->Set(ConvertToV8String(isolate, "ext_name"),
+                  ConvertToV8String(isolate, "WebGLShaderPrecisionFormat"));
+
+        cache->WebGLShaderPrecisionFormatTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WebGLShaderPrecisionFormatImpl *shaderPrecisionFormat) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLShaderPrecisionFormatImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLShaderPrecisionFormat);
+        auto ext = v8::External::New(isolate, shaderPrecisionFormat);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLShaderPrecisionFormatImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLShaderPrecisionFormatImpl *>(ptr);
+    }
+
+
+    static void GetRangeMin(v8::Local<v8::String> property,
+                            const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetRangeMax(v8::Local<v8::String> property,
+                            const v8::PropertyCallbackInfo<v8::Value> &info);
+
+    static void GetPrecision(v8::Local<v8::String> property,
+                             const v8::PropertyCallbackInfo<v8::Value> &info);
 
     WebGLShaderPrecisionFormat &GetShaderPrecisionFormat();
 
diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLUniformLocation.h b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLUniformLocation.h
index 7ce38306..f1ebcc20 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLUniformLocation.h
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl/WebGLUniformLocation.h
@@ -6,19 +6,57 @@
 
 #include "rust/cxx.h"
 #include "canvas-cxx/src/lib.rs.h"
-#include "v8runtime/V8Runtime.h"
+#include "Helpers.h"
+#include "Common.h"
+#include "Caches.h"
 
-using namespace facebook;
 
-
-class JSI_EXPORT WebGLUniformLocation
-
-        : public jsi::HostObject {
+class WebGLUniformLocation {
 public:
     WebGLUniformLocation(int32_t
                          uniformLocation) :
             uniformLocation_(uniformLocation) {}
 
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLUniformLocationTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLUniformLocation"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        cache->WebGLUniformLocationTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WebGLUniformLocation *uniformLocation) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLRenderbuffer::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLUniformLocation);
+        auto ext = v8::External::New(isolate, uniformLocation);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLUniformLocation *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLUniformLocation *>(ptr);
+    }
+
     int32_t GetUniformLocation() {
         return this->uniformLocation_;
     }
diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGL2RenderingContext.cpp b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGL2RenderingContext.cpp
index a75d76b0..5a07012a 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGL2RenderingContext.cpp
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGL2RenderingContext.cpp
@@ -12,9 +12,1196 @@ WebGL2RenderingContext::WebGL2RenderingContext(rust::Box<WebGLState> state) : We
 WebGL2RenderingContext::WebGL2RenderingContext(rust::Box<WebGLState> state,
                                                WebGLRenderingVersion version)
         : WebGLRenderingContext(std::move(state), version) {
+}
+
+
+v8::Local<v8::FunctionTemplate> WebGL2RenderingContext::GetCtor(v8::Isolate *isolate) {
+    auto cache = Caches::Get(isolate);
+    auto ctor = cache->WebGL2RenderingContextTmpl.get();
+    if (ctor != nullptr) {
+        return ctor->Get(isolate);
+    }
+
+    v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+    ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+    ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGL2RenderingContext"));
+
+    auto tmpl = ctorTmpl->InstanceTemplate();
+    tmpl->SetInternalFieldCount(1);
+    WebGLRenderingContext::SetConstants(isolate, tmpl);
+    SetConstants(isolate, tmpl);
+    cache->WebGL2RenderingContextTmpl =
+            std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+    return ctorTmpl;
+}
+
+WebGL2RenderingContext *WebGL2RenderingContext::GetPointer(const v8::Local<v8::Object> &object) {
+    auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+    if (ptr == nullptr) {
+        return nullptr;
+    }
+    return static_cast<WebGL2RenderingContext *>(ptr);
+}
+
+void WebGL2RenderingContext::BeginQuery(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto value = args[1];
+    auto type = GetNativeType(isolate, value);
+    if (type == NativeType::WebGLQuery) {
+        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        auto query = WebGLQuery::GetPointer(value.As<v8::Object>());
+
+        if(query != nullptr){
+            canvas_native_webgl2_begin_query(
+                    target,
+                    query->GetQuery(),
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGL2RenderingContext::BeginTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto value = args[0];
+    if (value->IsNumber()) {
+        canvas_native_webgl2_begin_transform_feedback(
+                (uint32_t) args[0]->NumberValue(context).ToChecked(),
+                ptr->GetState()
+        );
+    }
+}
+
+void WebGL2RenderingContext::BindBufferBase(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto bufferValue = args[2];
+    auto type = GetNativeType(isolate, bufferValue);
+
+    if (type == NativeType::WebGLBuffer) {
+        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        auto index = (uint32_t) args[1]->NumberValue(context).ToChecked();
+
+        auto buffer = WebGLBuffer::GetPointer(bufferValue.As<v8::Object>());
+
+        canvas_native_webgl2_bind_buffer_base(
+                target,
+                index,
+                buffer->GetBuffer(),
+                ptr->GetState()
+        );
+    }
+}
+
+void WebGL2RenderingContext::BindBufferRange(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto bufferValue = args[2];
+    auto type = GetNativeType(isolate, bufferValue);
+    if (args.Length() > 4 && type == NativeType::WebGLBuffer) {
+        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        auto index = (uint32_t) args[1]->NumberValue(context).ToChecked();
+        auto offset = args[3]->NumberValue(context).ToChecked();
+        auto size = args[4]->NumberValue(context).ToChecked();
+        auto buffer = WebGLBuffer::GetPointer(bufferValue.As<v8::Object>());
+        canvas_native_webgl2_bind_buffer_range(
+                target,
+                index,
+                buffer->GetBuffer(),
+                static_cast<ssize_t>(offset),
+                static_cast<ssize_t>(size),
+                ptr->GetState()
+        );
+    }
+}
+
+void WebGL2RenderingContext::BindSampler(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto samplerValue = args[1];
+    auto type = GetNativeType(isolate, samplerValue);
+    if (type == NativeType::WebGLSampler) {
+        auto unit = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        auto sampler = WebGLSampler::GetPointer(samplerValue.As<v8::Object>());
+
+        canvas_native_webgl2_bind_sampler(
+                unit,
+                sampler->GetSampler(),
+                ptr->GetState()
+        );
+    }
+}
+
+void WebGL2RenderingContext::BindTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto transformFeedbackValue = args[1];
+    auto type = GetNativeType(isolate, transformFeedbackValue);
+
+    if (type == NativeType::WebGLTransformFeedback) {
+        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        auto transformFeedback = WebGLTransformFeedback::GetPointer(transformFeedbackValue.As<v8::Object>());
+
+        canvas_native_webgl2_bind_transform_feedback(
+                target,
+                transformFeedback->GetFeedback(),
+                ptr->GetState()
+        );
+    }
+}
+
+void WebGL2RenderingContext::BindVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto value = args[0];
+    if (value->IsNull()) {
+        canvas_native_webgl2_bind_vertex_array(
+                0,
+                ptr->GetState()
+        );
+        return;
+    }
+
+    auto type = GetNativeType(isolate, value);
+    if (type == NativeType::WebGLVertexArrayObject) {
+        auto vertexArray = WebGLVertexArrayObject::GetPointer(value.As<v8::Object>());
+
+        if (vertexArray != nullptr) {
+            canvas_native_webgl2_bind_vertex_array(
+                    vertexArray->GetVertexArrayObject(),
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGL2RenderingContext::BlitFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    if (args.Length() > 9) {
+        auto srcX0 = (int32_t) args[0]->NumberValue(context).ToChecked();
+        auto srcY0 = (int32_t) args[1]->NumberValue(context).ToChecked();
+
+        auto srcX1 = (int32_t) args[2]->NumberValue(context).ToChecked();
+        auto srcY1 = (int32_t) args[3]->NumberValue(context).ToChecked();
+
+        auto dstX0 = (int32_t) args[4]->NumberValue(context).ToChecked();
+        auto dstY0 = (int32_t) args[5]->NumberValue(context).ToChecked();
+
+        auto dstX1 = (int32_t) args[6]->NumberValue(context).ToChecked();
+        auto dstY1 = (int32_t) args[7]->NumberValue(context).ToChecked();
+
+        auto mask = (uint32_t) args[8]->NumberValue(context).ToChecked();
+        auto filter = (uint32_t) args[9]->NumberValue(context).ToChecked();
+        canvas_native_webgl2_blit_framebuffer(
+                srcX0,
+                srcY0,
+                srcX1,
+                srcY1,
+                dstX0,
+                dstY0,
+                dstX1,
+                dstY1,
+                mask,
+                filter,
+                ptr->GetState()
+        );
+    }
+}
+
+void WebGL2RenderingContext::ClearBufferfv(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto bufferValue = args[0];
+    auto type = GetNativeType(isolate, bufferValue);
+    auto values = args[2];
+    if (args.Length() > 2 && type == NativeType::WebGLBuffer &&
+        args[1]->IsObject()) {
+        auto drawbuffer = (int32_t) args[1]->NumberValue(context).ToChecked();
+        auto buffer = WebGLBuffer::GetPointer(bufferValue.As<v8::Object>());
+        if (values->IsArray()) {
+            auto array = values.As<v8::Array>();
+            auto len = array->Length();
+            rust::Vec<float> buf;
+            buf.reserve(len);
+            for (int j = 0; j < len; ++j) {
+                auto item = array->Get(
+                        context, j).ToLocalChecked();
+                if (!item->IsNumber()) {
+                    buf.push_back(
+                            std::nanf(""));
+                } else {
+                    buf.push_back(
+                            static_cast<float>(item->NumberValue(context).ToChecked())
+                    );
+                }
+            }
+
+            rust::Slice<const float> slice(
+                    buf.data(),
+                    buf.size());
+            canvas_native_webgl2_clear_bufferfv(
+                    buffer->GetBuffer(),
+                    drawbuffer,
+                    slice,
+                    ptr->GetState()
+            );
+
+        } else if (values->IsFloat32Array()) {
+            auto buff = values.As<v8::TypedArray>();
+            auto slice = GetTypedArrayData<const float>(buff);
+            canvas_native_webgl2_clear_bufferfv(
+                    buffer->GetBuffer(),
+                    drawbuffer,
+                    slice,
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGL2RenderingContext::ClearBufferiv(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto bufferValue = args[0];
+    auto type = GetNativeType(isolate, bufferValue);
+    auto values = args[2];
+    if (args.Length() > 2 && type == NativeType::WebGLBuffer &&
+        args[1]->IsObject()) {
+        auto drawbuffer = (int32_t) args[1]->NumberValue(context).ToChecked();
+        auto buffer = WebGLBuffer::GetPointer(bufferValue.As<v8::Object>());
+        if (values->IsArray()) {
+            auto array = values.As<v8::Array>();
+            auto len = array->Length();
+            rust::Vec<int32_t> buf;
+            buf.reserve(len);
+            for (int j = 0; j < len; ++j) {
+                auto item = array->Get(
+                        context, j).ToLocalChecked();
+                buf.push_back(
+                        static_cast<int32_t>(item->NumberValue(context).ToChecked())
+                );
+            }
+
+            rust::Slice<const int32_t> slice(
+                    buf.data(),
+                    buf.size());
+            canvas_native_webgl2_clear_bufferiv(
+                    buffer->GetBuffer(),
+                    drawbuffer,
+                    slice,
+                    ptr->GetState()
+            );
+
+        } else if (values->IsInt32Array()) {
+            auto buff = values.As<v8::TypedArray>();
+            auto slice = GetTypedArrayData<const int32_t>(buff);
+            canvas_native_webgl2_clear_bufferiv(
+                    buffer->GetBuffer(),
+                    drawbuffer,
+                    slice,
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGL2RenderingContext::ClearBufferfi(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto bufferValue = args[0];
+    auto type = GetNativeType(isolate, bufferValue);
+    if (args.Length() > 3 && type == NativeType::WebGLBuffer) {
+        auto buffer = WebGLBuffer::GetPointer(bufferValue.As<v8::Object>());
+        if (buffer != nullptr) {
+            auto drawbuffer = (int32_t) args[1]->NumberValue(context).ToChecked();
+            auto depth = args[2]->NumberValue(context).ToChecked();
+            auto stencil = (int32_t) args[3]->NumberValue(context).ToChecked();
+            canvas_native_webgl2_clear_bufferfi(
+                    buffer->GetBuffer(),
+                    drawbuffer,
+                    static_cast<float>(depth),
+                    stencil,
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGL2RenderingContext::ClearBufferuiv(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto bufferValue = args[0];
+    auto type = GetNativeType(isolate, bufferValue);
+    auto values = args[2];
+    if (args.Length() > 2 && type == NativeType::WebGLBuffer &&
+        args[1]->IsObject()) {
+        auto drawbuffer = (int32_t) args[1]->NumberValue(context).ToChecked();
+        auto buffer = WebGLBuffer::GetPointer(bufferValue.As<v8::Object>());
+        if (values->IsArray()) {
+            auto array = values.As<v8::Array>();
+            auto len = array->Length();
+            rust::Vec<uint32_t> buf;
+            buf.reserve(len);
+            for (int j = 0; j < len; ++j) {
+                auto item = array->Get(
+                        context, j).ToLocalChecked();
+                buf.push_back(
+                        static_cast<uint32_t>(item->NumberValue(context).ToChecked())
+                );
+            }
+
+            rust::Slice<const uint32_t> slice(
+                    buf.data(),
+                    buf.size());
+            canvas_native_webgl2_clear_bufferuiv(
+                    buffer->GetBuffer(),
+                    drawbuffer,
+                    slice,
+                    ptr->GetState()
+            );
+
+        } else if (values->IsUint32Array()) {
+            auto buff = values.As<v8::TypedArray>();
+            auto slice = GetTypedArrayData<const uint32_t>(buff);
+            canvas_native_webgl2_clear_bufferuiv(
+                    buffer->GetBuffer(),
+                    drawbuffer,
+                    slice,
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGL2RenderingContext::ClientWaitSync(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto syncValue = args[0];
+    auto type = GetNativeType(isolate, syncValue);
+    if (args.Length() > 2 && type == NativeType::WebGLSync ) {
+        auto sync = WebGLSyncImpl::GetPointer(syncValue.As<v8::Object>());
+        if (sync != nullptr) {
+            auto flags = (uint32_t) args[1]->NumberValue(context).ToChecked();
+            auto timeout = args[2]->NumberValue(context).ToChecked();
+            auto ret = canvas_native_webgl2_client_wait_sync(
+                    sync->GetSync(),
+                    flags,
+                    static_cast<ssize_t>(timeout),
+                    ptr->GetState()
+            );
+
+            args.GetReturnValue().Set((int32_t) ret);
+            return;
+        }
+    }
+    // todo decide if WAIT_FAILED should be returned here
+    args.GetReturnValue().SetUndefined();
+}
+
+void WebGL2RenderingContext::CompressedTexSubImage3D(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    if (args.Length() > 8) {
+        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 zoffset = (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 depth = (int32_t) args[7]->NumberValue(context).ToChecked();
+        auto format = (uint32_t) args[8]->NumberValue(context).ToChecked();
+
+        auto imageSizeOrBufValue = args[0];
+        if (args[9]->IsObject()) {
+            if (imageSizeOrBufValue->IsTypedArray()) {
+                auto array = imageSizeOrBufValue.As<v8::TypedArray>();
+                auto slice = GetTypedArrayData<const uint8_t>(array);
+
+                size_t srcOffset = 0;
+                if (args[10]->IsNumber()) {
+                    srcOffset = static_cast<size_t>(args[10]->NumberValue(context).ToChecked());
+                }
+                size_t srcLengthOverride = 0;
+                if (args[11]->IsNumber()) {
+                    srcLengthOverride = static_cast<size_t>(args[11]->NumberValue(context).ToChecked());
+                }
+
+
+                canvas_native_webgl2_compressed_tex_sub_image3d(
+                        target,
+                        level,
+                        xoffset,
+                        yoffset,
+                        zoffset,
+                        width,
+                        height,
+                        depth,
+                        format,
+                        slice,
+                        srcOffset,
+                        srcLengthOverride,
+                        ptr->GetState()
+                );
+            }
+        } else {
+            auto imageSizeOrBuf = (int32_t) imageSizeOrBufValue->NumberValue(context).ToChecked();
+            auto offset = 0;
+            if (args[10]->IsNumber()) {
+                offset = (int32_t) args[10]->NumberValue(context).ToChecked();
+            }
+            canvas_native_webgl2_compressed_tex_sub_image3d_none(
+                    target,
+                    level,
+                    xoffset,
+                    yoffset,
+                    zoffset,
+                    width,
+                    height,
+                    depth,
+                    format,
+                    imageSizeOrBuf,
+                    offset,
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGL2RenderingContext::CopyBufferSubData(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    if (args.Length() > 4) {
+        auto readTarget = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        auto writeTarget = (uint32_t) args[1]->NumberValue(context).ToChecked();
+        auto readOffset = args[2]->NumberValue(context).ToChecked();
+        auto writeOffset = args[3]->NumberValue(context).ToChecked();
+        auto size = args[4]->NumberValue(context).ToChecked();
+        canvas_native_webgl2_copy_buffer_sub_data(
+                readTarget,
+                writeTarget,
+                static_cast<ssize_t>(readOffset),
+                static_cast<ssize_t>(writeOffset),
+                static_cast<ssize_t>(size),
+                ptr->GetState()
+        );
+    }
+}
+
+void WebGL2RenderingContext::CopyTexSubImage3D(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    if (args.Length() > 8) {
+        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 zoffset = (int32_t) args[4]->NumberValue(context).ToChecked();
+        auto x = (int32_t) args[5]->NumberValue(context).ToChecked();
+        auto y = (int32_t) args[6]->NumberValue(context).ToChecked();
+        auto width = (int32_t) args[7]->NumberValue(context).ToChecked();
+        auto height = (int32_t) args[8]->NumberValue(context).ToChecked();
+        canvas_native_webgl2_copy_tex_sub_image3d(
+                target,
+                level,
+                xoffset,
+                yoffset,
+                zoffset,
+                x,
+                y,
+                width,
+                height,
+                ptr->GetState()
+        );
+    }
+}
+
+void WebGL2RenderingContext::CreateQuery(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto ret = canvas_native_webgl2_create_query(
+            ptr->GetState());
+    auto query = WebGLQuery::NewInstance(isolate, new WebGLQuery(ret));
+
+    args.GetReturnValue().Set(query);
+}
+
+void WebGL2RenderingContext::CreateSampler(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto ret = canvas_native_webgl2_create_sampler(
+            ptr->GetState());
+    auto sampler = WebGLSampler::NewInstance(isolate, new WebGLSampler(ret));
+
+    args.GetReturnValue().Set(sampler);
+}
+
+void WebGL2RenderingContext::CreateTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto ret = canvas_native_webgl2_create_transform_feedback(
+            ptr->GetState());
 
+    auto feedback = WebGLTransformFeedback::NewInstance(isolate, new WebGLTransformFeedback(
+            ret));
+
+    args.GetReturnValue().Set(feedback);
+}
+
+void WebGL2RenderingContext::CreateVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto ret = canvas_native_webgl2_create_vertex_array(
+            ptr->GetState());
+
+    auto vertexArrayObject = WebGLVertexArrayObject::NewInstance(isolate, new WebGLVertexArrayObject(ret));
+
+    args.GetReturnValue().Set(vertexArrayObject);
+}
+
+void WebGL2RenderingContext::DeleteQuery(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto queryValue = args[0];
+    auto type = GetNativeType(isolate, queryValue);
+    if (type == NativeType::WebGLQuery) {
+        auto query = WebGLQuery::GetPointer(queryValue.As<v8::Object>());
+
+        if (query != nullptr) {
+            canvas_native_webgl2_delete_query_with_query(
+                    query->GetQuery(),
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGL2RenderingContext::DeleteSampler(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto samplerValue = args[0];
+    auto type = GetNativeType(isolate, samplerValue);
+
+    if (type == NativeType::WebGLSampler) {
+        auto sampler = WebGLSampler::GetPointer(samplerValue.As<v8::Object>());
+
+        if (sampler != nullptr) {
+            canvas_native_webgl2_delete_sampler_with_sampler(
+                    sampler->GetSampler(),
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGL2RenderingContext::DeleteSync(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto syncValue = args[0];
+    auto type = GetNativeType(isolate, syncValue);
+    if (type == NativeType::WebGLSync) {
+        auto sync = WebGLSyncImpl::GetPointer(syncValue.As<v8::Object>());
+
+        if (sync != nullptr) {
+            canvas_native_webgl2_delete_sync_with_sync(
+                    sync->GetSync(),
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGL2RenderingContext::DeleteTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto transformFeedbackValue = args[0];
+    auto type = GetNativeType(isolate, transformFeedbackValue);
+    if (type == NativeType::WebGLTransformFeedback) {
+        auto transformFeedback = WebGLTransformFeedback::GetPointer(transformFeedbackValue.As<v8::Object>());
+
+        if (transformFeedback != nullptr) {
+            canvas_native_webgl2_delete_transform_feedback(
+                    transformFeedback->GetFeedback(),
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGL2RenderingContext::DeleteVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto vertexArrayValue = args[0];
+    auto type = GetNativeType(isolate, vertexArrayValue);
+    if (type == NativeType::WebGLVertexArrayObject) {
+
+        auto vertexArray = WebGLVertexArrayObject::GetPointer(vertexArrayValue.As<v8::Object>());
+        if (vertexArray != nullptr) {
+            canvas_native_webgl2_delete_vertex_array_with_vertex_array(
+                    vertexArray->GetVertexArrayObject(),
+                    ptr->GetState()
+            );
+        }
+    }
+}
+
+void WebGL2RenderingContext::DrawArraysInstanced(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    if (args.Length() > 3) {
+        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 instanceCount = (int32_t) args[3]->NumberValue(context).ToChecked();
+        canvas_native_webgl2_draw_arrays_instanced(
+                mode,
+                first,
+                count_,
+                instanceCount,
+                ptr->GetState()
+        );
+
+        ptr->UpdateInvalidateState();
+    }
+}
+
+void WebGL2RenderingContext::DrawBuffers(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto buffersObject = args[0];
+    if (buffersObject->IsArray()) {
+        auto array = buffersObject.As<v8::Array>();
+        auto len = array->Length();
+        rust::Vec<uint32_t> buf;
+        buf.reserve(len);
+        for (int j = 0; j < len; ++j) {
+            auto item = array->Get(
+                    context, j).ToLocalChecked();
+            buf.emplace_back(
+                    (uint32_t) item->NumberValue(context).ToChecked());
+        }
+        rust::Slice<const uint32_t> slice(
+                buf.data(), buf.size());
+        canvas_native_webgl2_draw_buffers(
+                slice,
+                ptr->GetState());
+    }
+}
+
+void WebGL2RenderingContext::DrawElementsInstanced(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    if (args.Length() > 4) {
+        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 offset = args[3]->NumberValue(context).ToChecked();
+        auto instanceCount = (int32_t) args[4]->NumberValue(context).ToChecked();
+        canvas_native_webgl2_draw_elements_instanced(
+                mode,
+                count_,
+                type,
+                static_cast<ssize_t>(offset),
+                instanceCount,
+                ptr->GetState()
+        );
+
+        ptr->UpdateInvalidateState();
+    }
+}
+
+void WebGL2RenderingContext::DrawRangeElements(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    if (args.Length() > 5) {
+        auto mode = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        auto start = (uint32_t) args[1]->NumberValue(context).ToChecked();
+        auto end = (uint32_t) args[2]->NumberValue(context).ToChecked();
+        auto count_ = (int32_t) args[3]->NumberValue(context).ToChecked();
+        auto type = (uint32_t) args[4]->NumberValue(context).ToChecked();
+        auto offset = args[5]->NumberValue(context).ToChecked();
+        canvas_native_webgl2_draw_range_elements(
+                mode,
+                start,
+                end,
+                count_,
+                type,
+                static_cast<ssize_t>(offset),
+                ptr->GetState()
+        );
+
+        ptr->UpdateInvalidateState();
+    }
+}
+
+void WebGL2RenderingContext::EndQuery(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    if (args[0]->IsNumber()) {
+        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        canvas_native_webgl2_end_query(target,
+                                       ptr->GetState());
+    }
+}
+
+void WebGL2RenderingContext::EndTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    canvas_native_webgl2_end_transform_feedback(
+            ptr->GetState());
+}
+
+void WebGL2RenderingContext::FenceSync(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    if (args.Length() > 1) {
+        auto condition = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        auto flags = (uint32_t) args[1]->NumberValue(context).ToChecked();
+        auto sync = canvas_native_webgl2_fence_sync(
+                condition,
+                flags,
+                ptr->GetState()
+        );
+        auto ret = WebGLSyncImpl::NewInstance(isolate, new WebGLSyncImpl(std::move(sync)));
+
+        args.GetReturnValue().Set(ret);
+    }
+}
+
+void WebGL2RenderingContext::FramebufferTextureLayer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetUndefined();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+
+    auto textureValue = args[2];
+    auto type = GetNativeType(isolate, textureValue);
+    if (args.Length() > 4 && type == NativeType::WebGLTexture) {
+        auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+        auto attachment = (uint32_t) args[1]->NumberValue(context).ToChecked();
+        auto texture = WebGLTexture::GetPointer(textureValue.As<v8::Object>());
+        auto level = (int32_t) args[3]->NumberValue(context).ToChecked();
+        auto layer = (int32_t) args[4]->NumberValue(context).ToChecked();
+        if (texture != nullptr) {
+            canvas_native_webgl2_framebuffer_texture_layer(
+                    target,
+                    attachment,
+                    texture->GetTexture(),
+                    level,
+                    layer,
+                    ptr->GetState()
+            );
+        }
+
+    }
+}
+
+void WebGL2RenderingContext::GetActiveUniformBlockName(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetEmptyString();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    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 uniformBlockIndex = (uint32_t) args[1]->NumberValue(context).ToChecked();
+            auto name = canvas_native_webgl2_get_active_uniform_block_name(
+                    program->GetProgram(),
+                    uniformBlockIndex,
+                    ptr->GetState()
+            );
+            args.GetReturnValue().Set(ConvertToV8OneByteString(isolate, std::move(name)));
+            return;
+        }
+
+    }
+
+    args.GetReturnValue().SetEmptyString();
+}
+
+void WebGL2RenderingContext::GetActiveUniformBlockParameter(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto programValue = args[0];
+    auto type = GetNativeType(isolate, programValue);
+
+    if (args.Length() > 2 && type == NativeType::WebGLProgram) {
+        auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
+
+        if (program != nullptr) {
+            auto uniformBlockIndex = (uint32_t) args[1]->NumberValue(context).ToChecked();
+            auto pname = (uint32_t) args[2]->NumberValue(context).ToChecked();
+            auto ret = canvas_native_webgl2_get_active_uniform_block_parameter(
+                    program->GetProgram(),
+                    uniformBlockIndex,
+                    pname,
+                    ptr->GetState()
+            );
+
+            switch (pname) {
+                case GL_UNIFORM_BLOCK_BINDING:
+                case GL_UNIFORM_BLOCK_DATA_SIZE:
+                case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
+                    args.GetReturnValue().Set(canvas_native_webgl_result_get_i32(
+                            *ret));
+                    return;
+                case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: {
+                    auto value = canvas_native_webgl_result_get_u32_array(
+                            *ret);
+
+                    auto buf = new VecMutableBuffer<uint32_t>(
+                            std::move(value));
+
+
+
+                    auto store = v8::ArrayBuffer::NewBackingStore(buf->data(), buf->buffer_size(),
+                                                                  [](void *data, size_t length,
+                                                                     void *deleter_data) {
+                                                                      if (deleter_data != nullptr) {
+                                                                          delete (VecMutableBuffer<float> *) deleter_data;
+                                                                      }
+                                                                  },
+                                                                  buf);
+
+                    auto arraybuffer = v8::ArrayBuffer::New(isolate, std::move(store));
+                    args.GetReturnValue().Set(v8::Uint32Array::New(arraybuffer, 0, buf->size()));
+                    return;
+                }
+                case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
+                case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
+                    args.GetReturnValue().Set(canvas_native_webgl_result_get_bool(
+                            *ret));
+                    return;
+                default:
+                    args.GetReturnValue().SetNull();
+                    return;
+            }
+        }
+    }
 }
 
+void WebGL2RenderingContext::GetActiveUniforms(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    WebGL2RenderingContext *ptr = GetPointer(args.This());
+    if (ptr == nullptr) {
+        args.GetReturnValue().SetNull();
+        return;
+    }
+
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+
+    auto programValue = args[0];
+    auto type = GetNativeType(isolate, programValue);
+    if (args.Length() > 2 && type == NativeType::WebGLProgram) {
+
+        auto program = WebGLProgram::GetPointer(programValue.As<v8::Object>());
+        auto uniformIndicesObject = args[1];
+        auto pname = (uint32_t) args[2]->NumberValue(context).ToChecked();
+
+        if (uniformIndicesObject->IsArray()) {
+            auto uniformIndices = uniformIndicesObject.As<v8::Array>();
+            auto size = uniformIndices->Length();
+            rust::Vec<uint32_t> buf;
+            buf.reserve(size);
+            for (int j = 0; j < size; j++) {
+                auto item = (uint32_t) uniformIndices->Get(
+                        context, j).ToLocalChecked()->NumberValue(context).ToChecked();
+                buf.emplace_back(item);
+            }
+            rust::Slice<const uint32_t> slice(
+                    buf.data(), buf.size());
+            auto ret = canvas_native_webgl2_get_active_uniforms(
+                    program->GetProgram(),
+                    slice,
+                    pname,
+                    ptr->GetState()
+            );
+
+            switch (pname) {
+                case GL_UNIFORM_TYPE:
+                case GL_UNIFORM_SIZE: {
+                    auto value = canvas_native_webgl_result_get_u32_array(
+                            *ret);
+                    auto len = value.size();
+                    auto array = v8::Array::New(
+                            isolate, (int)len);
+
+                    for (int j = 0;
+                         j < len; ++j) {
+                        auto item = value[j];
+                        array->Set(
+                                context, j,
+                                v8::Number::New(isolate, (double) item));
+                    }
+                    args.GetReturnValue().Set(array);
+                    return;
+                }
+                case GL_UNIFORM_BLOCK_INDEX:
+                case GL_UNIFORM_OFFSET:
+                case GL_UNIFORM_ARRAY_STRIDE:
+                case GL_UNIFORM_MATRIX_STRIDE: {
+                    auto value = canvas_native_webgl_result_get_i32_array(
+                            *ret);
+                    auto len = value.size();
+                    auto array = v8::Array::New(
+                            isolate, (int) len);
+                    for (int j = 0;
+                         j < len; ++j) {
+                        auto item = value[j];
+                        array->Set(
+                                context, j,
+                                v8::Number::New(isolate,
+                                                (double )item));
+                    }
+                    args.GetReturnValue().Set(array);
+                    return;
+                }
+                case GL_UNIFORM_IS_ROW_MAJOR: {
+                    auto value = canvas_native_webgl_result_get_bool_array(
+                            *ret);
+                    auto len = value.size();
+                    auto array = v8::Array::New(
+                            isolate,
+                            (int)len);
+                    for (int j = 0;
+                         j < len; ++j) {
+                        bool item =
+                                value[j] == 1;
+                        array->Set(
+                                context, j,
+                                v8::Boolean::New(isolate, item));
+                    }
+                    args.GetReturnValue().Set(array);
+                    return;
+                }
+                default:
+                    args.GetReturnValue().SetNull();
+                    return;
+            }
+        }
+
+
+    }
+}
 
 std::vector<jsi::PropNameID> WebGL2RenderingContext::getPropertyNames(jsi::Runtime &rt) {
     std::vector<jsi::PropNameID> ret;
@@ -1015,1372 +2202,79 @@ std::vector<jsi::PropNameID> WebGL2RenderingContext::getPropertyNames(jsi::Runti
 
     /* Errors */
 
-    /* Front face directions */
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_STENCIL"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_WIDTH"));
-
-    /* Front face directions */
-
-    /* Hints */
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_HEIGHT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_INTERNAL_FORMAT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_RED_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_GREEN_SIZE"));
-
-    /* Hints */
-
-    /* Data types */
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_BLUE_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_ALPHA_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_DEPTH_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_STENCIL_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"));
-
-    /* Data types */
-
-    /* Pixel formats */
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "COLOR_ATTACHMENT0"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_ATTACHMENT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_ATTACHMENT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_STENCIL_ATTACHMENT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "NONE"));
-
-    /* Pixel formats */
-
-    /* Pixel types */
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_COMPLETE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_INCOMPLETE_ATTACHMENT"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"));
-
-    /* Pixel types */
-
-    /* Shaders */
-
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_INCOMPLETE_DIMENSIONS"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_UNSUPPORTED"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_BINDING"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_BINDING"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "MAX_RENDERBUFFER_SIZE"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "INVALID_FRAMEBUFFER_OPERATION"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNPACK_FLIP_Y_WEBGL"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNPACK_PREMULTIPLY_ALPHA_WEBGL"));
-    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNPACK_COLORSPACE_CONVERSION_WEBGL"));
-
-
-    /* GL 1 */
-
-
-    return ret;
-}
-
-jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
-    auto methodName = name.utf8(runtime);
-
-    auto prop = GetProperty(methodName);
-
-
-    if (methodName == "beginQuery") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1 && arguments[0].isNumber() &&
-                                                             arguments[1].isObject()) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto queryObject = arguments[1].asObject(
-                                                                     runtime);
-
-                                                             if (queryObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto query = queryObject.asHostObject<WebGLQuery>(
-                                                                         runtime);
-                                                                 canvas_native_webgl2_begin_query(
-                                                                         target,
-                                                                         query->GetQuery(),
-                                                                         this->GetState()
-                                                                 );
-                                                             }
-                                                         }
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "beginTransformFeedback") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 0 && arguments[0].isNumber()) {
-                                                             canvas_native_webgl2_begin_transform_feedback(
-                                                                     (uint32_t) arguments[0].asNumber(),
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "bindBufferBase") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 2 && arguments[2].isObject()) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto index = (uint32_t) arguments[1].asNumber();
-                                                             auto bufferObject = arguments[2].asObject(
-                                                                     runtime);
-                                                             if (bufferObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto buffer = bufferObject.asHostObject<WebGLBuffer>(
-                                                                         runtime);
-
-                                                                 canvas_native_webgl2_bind_buffer_base(
-                                                                         target,
-                                                                         index,
-                                                                         buffer->GetBuffer(),
-                                                                         this->GetState()
-                                                                 );
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "bindBufferRange") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     5,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 4 && arguments[2].isObject()) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto index = (uint32_t) arguments[1].asNumber();
-                                                             auto offset = arguments[3].asNumber();
-                                                             auto size = arguments[4].asNumber();
-                                                             auto bufferObject = arguments[2].asObject(
-                                                                     runtime);
-                                                             if (bufferObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto buffer = bufferObject.asHostObject<WebGLBuffer>(
-                                                                         runtime);
-                                                                 canvas_native_webgl2_bind_buffer_range(
-                                                                         target,
-                                                                         index,
-                                                                         buffer->GetBuffer(),
-                                                                         static_cast<ssize_t>(offset),
-                                                                         static_cast<ssize_t>(size),
-                                                                         this->GetState()
-                                                                 );
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-
-                                                     }
-        );
-    } else if (methodName == "bindSampler") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1 && arguments[1].isObject()) {
-                                                             auto samplerObject = arguments[1].asObject(
-                                                                     runtime);
-                                                             if (samplerObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto unit = (uint32_t) arguments[0].asNumber();
-                                                                 auto sampler = samplerObject.asHostObject<WebGLSampler>(
-                                                                         runtime);
-
-                                                                 canvas_native_webgl2_bind_sampler(
-                                                                         unit,
-                                                                         sampler->GetSampler(),
-                                                                         this->GetState()
-                                                                 );
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-
-                                                     }
-        );
-    } else if (methodName == "bindTransformFeedback") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1 && arguments[1].isObject()) {
-                                                             auto transformFeedbackObject = arguments[1].asObject(
-                                                                     runtime);
-                                                             if (transformFeedbackObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto target = (uint32_t) arguments[0].asNumber();
-                                                                 auto transformFeedback = transformFeedbackObject.asHostObject<WebGLTransformFeedback>(
-                                                                         runtime);
-
-                                                                 canvas_native_webgl2_bind_transform_feedback(
-                                                                         target,
-                                                                         transformFeedback->GetFeedback(),
-                                                                         this->GetState()
-                                                                 );
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "bindVertexArray") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 0) {
-                                                             if (arguments[0].isNull()) {
-                                                                 canvas_native_webgl2_bind_vertex_array(
-                                                                         0,
-                                                                         this->GetState()
-                                                                 );
-                                                                 return jsi::Value::undefined();
-                                                             }
-
-                                                             if (arguments[0].isObject()) {
-                                                                 auto vertexArrayObject = arguments[0].asObject(
-                                                                         runtime);
-                                                                 if (vertexArrayObject.isHostObject(
-                                                                         runtime)) {
-                                                                     auto vertexArray = vertexArrayObject.asHostObject<WebGLVertexArrayObject>(
-                                                                             runtime);
-
-                                                                     if (vertexArray != nullptr) {
-
-                                                                         canvas_native_webgl2_bind_vertex_array(
-                                                                                 vertexArray->GetVertexArrayObject(),
-                                                                                 this->GetState()
-                                                                         );
-                                                                     }
-                                                                 }
-                                                             }
-
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "blitFramebuffer") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     10,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 9) {
-                                                             auto srcX0 = (int32_t) arguments[0].asNumber();
-                                                             auto srcY0 = (int32_t) arguments[1].asNumber();
-
-                                                             auto srcX1 = (int32_t) arguments[2].asNumber();
-                                                             auto srcY1 = (int32_t) arguments[3].asNumber();
-
-                                                             auto dstX0 = (int32_t) arguments[4].asNumber();
-                                                             auto dstY0 = (int32_t) arguments[5].asNumber();
-
-                                                             auto dstX1 = (int32_t) arguments[6].asNumber();
-                                                             auto dstY1 = (int32_t) arguments[7].asNumber();
-
-                                                             auto mask = (uint32_t) arguments[8].asNumber();
-                                                             auto filter = (uint32_t) arguments[9].asNumber();
-                                                             canvas_native_webgl2_blit_framebuffer(
-                                                                     srcX0,
-                                                                     srcY0,
-                                                                     srcX1,
-                                                                     srcY1,
-                                                                     dstX0,
-                                                                     dstY0,
-                                                                     dstX1,
-                                                                     dstY1,
-                                                                     mask,
-                                                                     filter,
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-
-                                                     }
-        );
-    } else if (methodName == "clearBufferfv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 2 && arguments[0].isObject() &&
-                                                             arguments[1].isObject()) {
-                                                             auto bufferObject = arguments[0].asObject(
-                                                                     runtime);
-                                                             auto drawbuffer = (int32_t) arguments[1].asNumber();
-                                                             auto values = arguments[2].asObject(
-                                                                     runtime);
-                                                             if (bufferObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto buffer = bufferObject.asHostObject<WebGLBuffer>(
-                                                                         runtime);
-                                                                 if (values.isArray(runtime)) {
-                                                                     auto array = values.getArray(
-                                                                             runtime);
-                                                                     auto len = array.size(runtime);
-                                                                     rust::Vec<float> buf;
-                                                                     buf.reserve(len);
-                                                                     for (int j = 0; j < len; ++j) {
-                                                                         auto item = array.getValueAtIndex(
-                                                                                 runtime, j);
-                                                                         if (!item.isNumber()) {
-                                                                             buf.push_back(
-                                                                                     std::nanf(""));
-                                                                         } else {
-                                                                             buf.push_back(
-                                                                                     static_cast<float>(item.asNumber())
-                                                                             );
-                                                                         }
-                                                                     }
-
-                                                                     rust::Slice<const float> slice(
-                                                                             buf.data(),
-                                                                             buf.size());
-                                                                     canvas_native_webgl2_clear_bufferfv(
-                                                                             buffer->GetBuffer(),
-                                                                             drawbuffer,
-                                                                             slice,
-                                                                             this->GetState()
-                                                                     );
-
-                                                                 } else if (values.isFloat32Array(
-                                                                         runtime)) {
-                                                                     auto buff = values.getTypedArray(
-                                                                             runtime);
-                                                                     auto slice = GetTypedArrayData<const float>(
-                                                                             runtime, buff);
-                                                                     canvas_native_webgl2_clear_bufferfv(
-                                                                             buffer->GetBuffer(),
-                                                                             drawbuffer,
-                                                                             slice,
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "clearBufferiv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 2 && arguments[0].isObject() &&
-                                                             arguments[1].isObject()) {
-                                                             auto bufferObject = arguments[0].asObject(
-                                                                     runtime);
-                                                             auto drawbuffer = (int32_t) arguments[1].asNumber();
-                                                             auto values = arguments[2].asObject(
-                                                                     runtime);
-                                                             if (bufferObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto buffer = bufferObject.asHostObject<WebGLBuffer>(
-                                                                         runtime);
-                                                                 if (values.isArray(runtime)) {
-                                                                     auto array = values.getArray(
-                                                                             runtime);
-                                                                     auto len = array.size(runtime);
-                                                                     rust::Vec<int32_t> buf;
-                                                                     buf.reserve(len);
-                                                                     for (int j = 0; j < len; ++j) {
-                                                                         auto item = array.getValueAtIndex(
-                                                                                 runtime, j);
-                                                                         buf.push_back(
-                                                                                 static_cast<int32_t>(item.asNumber())
-                                                                         );
-                                                                     }
-                                                                     rust::Slice<const int32_t> slice(
-                                                                             buf.data(),
-                                                                             buf.size());
-
-                                                                     canvas_native_webgl2_clear_bufferiv(
-                                                                             buffer->GetBuffer(),
-                                                                             drawbuffer,
-                                                                             slice,
-                                                                             this->GetState()
-                                                                     );
-
-                                                                 } else if (values.isInt32Array(
-                                                                         runtime)) {
-                                                                     auto buff = values.getTypedArray(
-                                                                             runtime);
-                                                                     auto slice = GetTypedArrayData<const int32_t>(
-                                                                             runtime, buff);
-                                                                     canvas_native_webgl2_clear_bufferiv(
-                                                                             buffer->GetBuffer(),
-                                                                             drawbuffer,
-                                                                             slice,
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "clearBufferuiv") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-                                                         if (count > 2 && arguments[0].isObject() &&
-                                                             arguments[1].isObject()) {
-                                                             auto bufferObject = arguments[0].asObject(
-                                                                     runtime);
-                                                             auto drawbuffer = (int32_t) arguments[1].asNumber();
-                                                             auto values = arguments[2].asObject(
-                                                                     runtime);
-                                                             if (bufferObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto buffer = bufferObject.asHostObject<WebGLBuffer>(
-                                                                         runtime);
-                                                                 if (values.isArray(runtime)) {
-                                                                     auto array = values.getArray(
-                                                                             runtime);
-                                                                     auto len = array.size(runtime);
-                                                                     rust::Vec<uint32_t> buf;
-                                                                     buf.reserve(len);
-                                                                     for (int j = 0; j < len; ++j) {
-                                                                         auto item = array.getValueAtIndex(
-                                                                                 runtime, j);
-                                                                         buf.push_back(
-                                                                                 static_cast<uint32_t>(item.asNumber())
-                                                                         );
-                                                                     }
-
-                                                                     rust::Slice<const uint32_t> slice(
-                                                                             buf.data(),
-                                                                             buf.size());
-
-                                                                     canvas_native_webgl2_clear_bufferuiv(
-                                                                             buffer->GetBuffer(),
-                                                                             drawbuffer,
-                                                                             slice,
-                                                                             this->GetState()
-                                                                     );
-
-                                                                 } else if (values.isUint32Array(
-                                                                         runtime)) {
-                                                                     auto buff = values.getTypedArray(
-                                                                             runtime);
-                                                                     auto slice = GetTypedArrayData<const uint32_t>(
-                                                                             runtime, buff);
-                                                                     canvas_native_webgl2_clear_bufferuiv(
-                                                                             buffer->GetBuffer(),
-                                                                             drawbuffer,
-                                                                             slice,
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
-                                                         }
-                                                         return jsi::Value::undefined();
-
-                                                     }
-        );
-    } else if (methodName == "clientWaitSync") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-
-                                                         if (count > 2 && arguments[0].isObject()) {
-                                                             auto syncObject = arguments[0].asObject(
-                                                                     runtime);
-
-                                                             if (syncObject.isHostObject(runtime)) {
-                                                                 auto sync = syncObject.asHostObject<WebGLSyncImpl>(
-                                                                         runtime);
-                                                                 if (sync != nullptr) {
-                                                                     auto flags = (uint32_t) arguments[1].asNumber();
-                                                                     auto timeout = arguments[2].asNumber();
-                                                                     auto ret = canvas_native_webgl2_client_wait_sync(
-                                                                             sync->GetSync(),
-                                                                             flags,
-                                                                             static_cast<ssize_t>(timeout),
-                                                                             this->GetState()
-                                                                     );
-                                                                     return {(int32_t) ret};
-                                                                 }
-                                                             }
-                                                         }
-                                                         // todo decide if WAIT_FAILED should be returned here
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "compressedTexSubImage3D") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     12,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-                                                         if (count > 8) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto level = (int32_t) arguments[1].asNumber();
-                                                             auto xoffset = (int32_t) arguments[2].asNumber();
-                                                             auto yoffset = (int32_t) arguments[3].asNumber();
-                                                             auto zoffset = (int32_t) arguments[4].asNumber();
-                                                             auto width = (int32_t) arguments[5].asNumber();
-                                                             auto height = (int32_t) arguments[6].asNumber();
-                                                             auto depth = (int32_t) arguments[7].asNumber();
-                                                             auto format = (uint32_t) arguments[8].asNumber();
-
-                                                             if (arguments[9].isObject()) {
-                                                                 auto imageSizeOrBuf = arguments[9].asObject(
-                                                                         runtime);
-                                                                 if (imageSizeOrBuf.isTypedArray(
-                                                                         runtime)) {
-                                                                     auto array = imageSizeOrBuf.getTypedArray(
-                                                                             runtime);
-                                                                     auto slice = GetTypedArrayData<const uint8_t>(
-                                                                             runtime, array);
-
-                                                                     size_t srcOffset = 0;
-                                                                     if (arguments[10].isNumber()) {
-                                                                         srcOffset = static_cast<size_t>(arguments[10].asNumber());
-                                                                     }
-                                                                     size_t srcLengthOverride = 0;
-                                                                     if (arguments[11].isNumber()) {
-                                                                         srcLengthOverride = static_cast<size_t>(arguments[11].asNumber());
-                                                                     }
-
-
-                                                                     canvas_native_webgl2_compressed_tex_sub_image3d(
-                                                                             target,
-                                                                             level,
-                                                                             xoffset,
-                                                                             yoffset,
-                                                                             zoffset,
-                                                                             width,
-                                                                             height,
-                                                                             depth,
-                                                                             format,
-                                                                             slice,
-                                                                             srcOffset,
-                                                                             srcLengthOverride,
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             } else {
-                                                                 auto imageSizeOrBuf = (int32_t) arguments[0].asNumber();
-                                                                 auto offset = 0;
-                                                                 if (arguments[10].isNumber()) {
-                                                                     offset = (int32_t) arguments[10].asNumber();
-                                                                 }
-                                                                 canvas_native_webgl2_compressed_tex_sub_image3d_none(
-                                                                         target,
-                                                                         level,
-                                                                         xoffset,
-                                                                         yoffset,
-                                                                         zoffset,
-                                                                         width,
-                                                                         height,
-                                                                         depth,
-                                                                         format,
-                                                                         imageSizeOrBuf,
-                                                                         offset,
-                                                                         this->GetState()
-                                                                 );
-                                                             }
-                                                         }
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "copyBufferSubData") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     5,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-                                                         if (count > 4) {
-                                                             auto readTarget = (uint32_t) arguments[0].asNumber();
-                                                             auto writeTarget = (uint32_t) arguments[1].asNumber();
-                                                             auto readOffset = arguments[2].asNumber();
-                                                             auto writeOffset = arguments[3].asNumber();
-                                                             auto size = arguments[4].asNumber();
-                                                             canvas_native_webgl2_copy_buffer_sub_data(
-                                                                     readTarget,
-                                                                     writeTarget,
-                                                                     static_cast<ssize_t>(readOffset),
-                                                                     static_cast<ssize_t>(writeOffset),
-                                                                     static_cast<ssize_t>(size),
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "copyTexSubImage3D") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     9,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 8) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto level = (int32_t) arguments[1].asNumber();
-                                                             auto xoffset = (int32_t) arguments[2].asNumber();
-                                                             auto yoffset = (int32_t) arguments[3].asNumber();
-                                                             auto zoffset = (int32_t) arguments[4].asNumber();
-                                                             auto x = (int32_t) arguments[5].asNumber();
-                                                             auto y = (int32_t) arguments[6].asNumber();
-                                                             auto width = (int32_t) arguments[7].asNumber();
-                                                             auto height = (int32_t) arguments[8].asNumber();
-                                                             canvas_native_webgl2_copy_tex_sub_image3d(
-                                                                     target,
-                                                                     level,
-                                                                     xoffset,
-                                                                     yoffset,
-                                                                     zoffset,
-                                                                     x,
-                                                                     y,
-                                                                     width,
-                                                                     height,
-                                                                     this->GetState()
-                                                             );
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "createQuery") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     0,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         auto ret = canvas_native_webgl2_create_query(
-                                                                 this->GetState());
-                                                         auto query = std::make_shared<WebGLQuery>(
-                                                                 ret);
-                                                         return jsi::Object::createFromHostObject(
-                                                                 runtime, query);
-                                                     }
-        );
-    } else if (methodName == "createSampler") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     0,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-                                                         auto ret = canvas_native_webgl2_create_sampler(
-                                                                 this->GetState());
-                                                         auto sampler = std::make_shared<WebGLSampler>(
-                                                                 ret);
-                                                         return jsi::Object::createFromHostObject(
-                                                                 runtime, sampler);
-                                                     }
-        );
-    } else if (methodName == "createTransformFeedback") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     0,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-                                                         auto ret = canvas_native_webgl2_create_transform_feedback(
-                                                                 this->GetState());
-
-                                                         auto feedback = std::make_shared<WebGLTransformFeedback>(
-                                                                 ret);
-                                                         return jsi::Object::createFromHostObject(
-                                                                 runtime, feedback);
-                                                     }
-        );
-    } else if (methodName == "createVertexArray") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     0,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-                                                         auto ret = canvas_native_webgl2_create_vertex_array(
-                                                                 this->GetState());
-
-                                                         auto vertexArrayObject = std::make_shared<WebGLVertexArrayObject>(
-                                                                 ret);
-                                                         return jsi::Object::createFromHostObject(
-                                                                 runtime, vertexArrayObject);
-                                                     }
-        );
-    } else if (methodName == "clearBufferfi") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     4,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-
-                                                         if (count > 3 && arguments[0].isObject()) {
-                                                             auto bufferObject = arguments[0].asObject(
-                                                                     runtime);
-                                                             if (bufferObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto buffer = bufferObject.asHostObject<WebGLBuffer>(
-                                                                         runtime);
-                                                                 if (buffer != nullptr) {
-                                                                     auto drawbuffer = (int32_t) arguments[1].asNumber();
-                                                                     auto depth = arguments[2].asNumber();
-                                                                     auto stencil = (int32_t) arguments[3].asNumber();
-                                                                     canvas_native_webgl2_clear_bufferfi(
-                                                                             buffer->GetBuffer(),
-                                                                             drawbuffer,
-                                                                             static_cast<float>(depth),
-                                                                             stencil,
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-
-                                                     }
-        );
-    } else if (methodName == "deleteQuery") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (arguments[0].isObject()) {
-                                                             auto queryObject = arguments[0].asObject(
-                                                                     runtime);
-                                                             if (queryObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto query = queryObject.asHostObject<WebGLQuery>(
-                                                                         runtime);
-
-                                                                 if (query != nullptr) {
-                                                                     canvas_native_webgl2_delete_query_with_query(
-                                                                             query->GetQuery(),
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "deleteSampler") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (arguments[0].isObject()) {
-                                                             auto samplerObject = arguments[0].asObject(
-                                                                     runtime);
-                                                             if (samplerObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto sampler = samplerObject.asHostObject<WebGLSampler>(
-                                                                         runtime);
-
-                                                                 if (sampler != nullptr) {
-                                                                     canvas_native_webgl2_delete_sampler_with_sampler(
-                                                                             sampler->GetSampler(),
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "deleteSync") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (arguments[0].isObject()) {
-                                                             auto syncObject = arguments[0].asObject(
-                                                                     runtime);
-                                                             if (syncObject.isHostObject(runtime)) {
-                                                                 auto sync = syncObject.asHostObject<WebGLSyncImpl>(
-                                                                         runtime);
-
-                                                                 if (sync != nullptr) {
-                                                                     canvas_native_webgl2_delete_sync_with_sync(
-                                                                             sync->GetSync(),
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
-                                                         }
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "deleteTransformFeedback") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (arguments[0].isObject()) {
-                                                             auto transformFeedbackObject = arguments[0].asObject(
-                                                                     runtime);
-                                                             if (transformFeedbackObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto transformFeedback = transformFeedbackObject.asHostObject<WebGLTransformFeedback>(
-                                                                         runtime);
-
-                                                                 if (transformFeedback != nullptr) {
-                                                                     canvas_native_webgl2_delete_transform_feedback(
-                                                                             transformFeedback->GetFeedback(),
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "deleteVertexArray") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (arguments[0].isObject()) {
-                                                             auto vertexArrayObject = arguments[0].asObject(
-                                                                     runtime);
-                                                             if (vertexArrayObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto vertexArray = vertexArrayObject.asHostObject<WebGLVertexArrayObject>(
-                                                                         runtime);
-                                                                 if (vertexArray != nullptr) {
-                                                                     canvas_native_webgl2_delete_vertex_array_with_vertex_array(
-                                                                             vertexArray->GetVertexArrayObject(),
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "drawArraysInstanced") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     4,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 3) {
-                                                             auto mode = (uint32_t) arguments[0].asNumber();
-                                                             auto first = (int32_t) arguments[1].asNumber();
-                                                             auto count_ = (int32_t) arguments[2].asNumber();
-                                                             auto instanceCount = (int32_t) arguments[3].asNumber();
-                                                             canvas_native_webgl2_draw_arrays_instanced(
-                                                                     mode,
-                                                                     first,
-                                                                     count_,
-                                                                     instanceCount,
-                                                                     this->GetState()
-                                                             );
-
-                                                             this->UpdateInvalidateState();
-                                                         }
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "drawBuffers") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-
-                                                         if (arguments[0].isObject()) {
-                                                             auto buffersObject = arguments[0].asObject(
-                                                                     runtime);
-                                                             if (buffersObject.isArray(runtime)) {
-                                                                 auto array = buffersObject.getArray(
-                                                                         runtime);
-                                                                 auto len = array.size(runtime);
-                                                                 rust::Vec<uint32_t> buf;
-                                                                 buf.reserve(len);
-                                                                 for (int j = 0; j < len; ++j) {
-                                                                     auto item = array.getValueAtIndex(
-                                                                             runtime, j);
-                                                                     buf.emplace_back(
-                                                                             (uint32_t) item.asNumber());
-                                                                 }
-                                                                 rust::Slice<const uint32_t> slice(
-                                                                         buf.data(), buf.size());
-                                                                 canvas_native_webgl2_draw_buffers(
-                                                                         slice,
-                                                                         this->GetState());
-                                                             }
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "drawElementsInstanced") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     5,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-                                                         if (count > 4) {
-                                                             auto mode = (uint32_t) arguments[0].asNumber();
-                                                             auto count_ = (int32_t) arguments[1].asNumber();
-                                                             auto type = (uint32_t) arguments[2].asNumber();
-                                                             auto offset = arguments[3].asNumber();
-                                                             auto instanceCount = (int32_t) arguments[4].asNumber();
-                                                             canvas_native_webgl2_draw_elements_instanced(
-                                                                     mode,
-                                                                     count_,
-                                                                     type,
-                                                                     static_cast<ssize_t>(offset),
-                                                                     instanceCount,
-                                                                     this->GetState()
-                                                             );
-
-                                                             this->UpdateInvalidateState();
-                                                         }
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "drawRangeElements") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     6,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-                                                         if (count > 5) {
-                                                             auto mode = (uint32_t) arguments[0].asNumber();
-                                                             auto start = (uint32_t) arguments[1].asNumber();
-                                                             auto end = (uint32_t) arguments[2].asNumber();
-                                                             auto count_ = (int32_t) arguments[3].asNumber();
-                                                             auto type = (uint32_t) arguments[4].asNumber();
-                                                             auto offset = arguments[5].asNumber();
-                                                             canvas_native_webgl2_draw_range_elements(
-                                                                     mode,
-                                                                     start,
-                                                                     end,
-                                                                     count_,
-                                                                     type,
-                                                                     static_cast<ssize_t>(offset),
-                                                                     this->GetState()
-                                                             );
-
-                                                             this->UpdateInvalidateState();
-                                                         }
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "endQuery") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     1,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-
-                                                         if (arguments[0].isNumber()) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             canvas_native_webgl2_end_query(target,
-                                                                                            this->GetState());
-                                                         }
-
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "endTransformFeedback") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     03,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-                                                         canvas_native_webgl2_end_transform_feedback(
-                                                                 this->GetState());
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "fenceSync") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
-
-                                                         if (count > 1) {
-                                                             auto condition = (uint32_t) arguments[0].asNumber();
-                                                             auto flags = (uint32_t) arguments[1].asNumber();
-                                                             auto sync = canvas_native_webgl2_fence_sync(
-                                                                     condition,
-                                                                     flags,
-                                                                     this->GetState()
-                                                             );
-                                                             return jsi::Object::createFromHostObject(runtime, std::make_shared<WebGLSyncImpl>(std::move(sync)));
-                                                         }
+    /* Front face directions */
 
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "framebufferTextureLayer") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     5,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_STENCIL"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_WIDTH"));
 
+    /* Front face directions */
 
-                                                         if (count > 4 && arguments[2].isObject()) {
-                                                             auto textureObject = arguments[2].asObject(
-                                                                     runtime);
-                                                             if (textureObject.isHostObject(
-                                                                     runtime)) {
-                                                                 auto target = (uint32_t) arguments[0].asNumber();
-                                                                 auto attachment = (uint32_t) arguments[1].asNumber();
-                                                                 auto texture = textureObject.asHostObject<WebGLTexture>(
-                                                                         runtime);
-                                                                 auto level = (int32_t) arguments[3].asNumber();
-                                                                 auto layer = (int32_t) arguments[4].asNumber();
-                                                                 if (texture != nullptr) {
-                                                                     canvas_native_webgl2_framebuffer_texture_layer(
-                                                                             target,
-                                                                             attachment,
-                                                                             texture->GetTexture(),
-                                                                             level,
-                                                                             layer,
-                                                                             this->GetState()
-                                                                     );
-                                                                 }
-                                                             }
+    /* Hints */
 
-                                                         }
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_HEIGHT"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_INTERNAL_FORMAT"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_RED_SIZE"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_GREEN_SIZE"));
 
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "getActiveUniformBlockName") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     2,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
+    /* Hints */
 
+    /* Data types */
 
-                                                         if (count > 1) {
-                                                             auto program = getHostObject<WebGLProgram>(
-                                                                     runtime, arguments[0]);
-                                                             if (program != nullptr) {
-                                                                 auto uniformBlockIndex = (uint32_t) arguments[1].asNumber();
-                                                                 auto name = canvas_native_webgl2_get_active_uniform_block_name(
-                                                                         program->GetProgram(),
-                                                                         uniformBlockIndex,
-                                                                         this->GetState()
-                                                                 );
-                                                                 return jsi::String::createFromAscii(
-                                                                         runtime, name.data(),
-                                                                         name.size());
-                                                             }
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_BLUE_SIZE"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_ALPHA_SIZE"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_DEPTH_SIZE"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_STENCIL_SIZE"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"));
 
-                                                         }
+    /* Data types */
 
-                                                         return jsi::Value::undefined();
-                                                     }
-        );
-    } else if (methodName == "getActiveUniformBlockParameter") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
+    /* Pixel formats */
 
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "COLOR_ATTACHMENT0"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_ATTACHMENT"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "STENCIL_ATTACHMENT"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "DEPTH_STENCIL_ATTACHMENT"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "NONE"));
 
-                                                         if (count > 2) {
+    /* Pixel formats */
 
-                                                             auto program = getHostObject<WebGLProgram>(
-                                                                     runtime, arguments[0]);
+    /* Pixel types */
 
-                                                             if (program != nullptr) {
-                                                                 auto uniformBlockIndex = (uint32_t) arguments[1].asNumber();
-                                                                 auto pname = (uint32_t) arguments[2].asNumber();
-                                                                 auto ret = canvas_native_webgl2_get_active_uniform_block_parameter(
-                                                                         program->GetProgram(),
-                                                                         uniformBlockIndex,
-                                                                         pname,
-                                                                         this->GetState()
-                                                                 );
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_COMPLETE"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_INCOMPLETE_ATTACHMENT"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"));
 
-                                                                 switch (pname) {
-                                                                     case GL_UNIFORM_BLOCK_BINDING:
-                                                                     case GL_UNIFORM_BLOCK_DATA_SIZE:
-                                                                     case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
-                                                                         return {canvas_native_webgl_result_get_i32(
-                                                                                 *ret)};
-                                                                     case GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: {
-                                                                         auto value = canvas_native_webgl_result_get_u32_array(
-                                                                                 *ret);
-                                                                         auto buffer = std::make_shared<VecMutableBuffer<uint32_t>>(
-                                                                                 std::move(value));
-                                                                         auto array = jsi::ArrayBuffer(
-                                                                                 runtime, buffer);
-
-                                                                         auto Uint32Array = runtime.global()
-                                                                                 .getProperty(
-                                                                                         runtime,
-                                                                                         "Uint32Array")
-                                                                                 .asObject(runtime)
-                                                                                 .asFunction(
-                                                                                         runtime);
-
-
-                                                                         return Uint32Array.callAsConstructor(
-                                                                                 runtime, array);
-                                                                     }
-                                                                     case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
-                                                                     case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
-                                                                         return {canvas_native_webgl_result_get_bool(
-                                                                                 *ret)};
-                                                                     default:
-                                                                         return jsi::Value::null();
-                                                                 }
-                                                             }
-                                                         }
+    /* Pixel types */
 
-                                                         return jsi::Value::null();
-                                                     }
-        );
-    } else if (methodName == "getActiveUniforms") {
-        return jsi::Function::createFromHostFunction(runtime,
-                                                     jsi::PropNameID::forAscii(runtime, methodName),
-                                                     3,
-                                                     [this](jsi::Runtime &runtime,
-                                                            const jsi::Value &thisValue,
-                                                            const jsi::Value *arguments,
-                                                            size_t count) -> jsi::Value {
+    /* Shaders */
 
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_INCOMPLETE_DIMENSIONS"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_UNSUPPORTED"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "FRAMEBUFFER_BINDING"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "RENDERBUFFER_BINDING"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "MAX_RENDERBUFFER_SIZE"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "INVALID_FRAMEBUFFER_OPERATION"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNPACK_FLIP_Y_WEBGL"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNPACK_PREMULTIPLY_ALPHA_WEBGL"));
+    ret.push_back(jsi::PropNameID::forUtf8(rt, "UNPACK_COLORSPACE_CONVERSION_WEBGL"));
 
-                                                         if (count > 2 && arguments[1].isObject()) {
 
-                                                             auto program = getHostObject<WebGLProgram>(
-                                                                     runtime, arguments[0]);
-                                                             auto uniformIndicesObject = arguments[1].asObject(
-                                                                     runtime);
-                                                             auto pname = (uint32_t) arguments[2].asNumber();
+    /* GL 1 */
 
-                                                             if (uniformIndicesObject.isArray(
-                                                                     runtime)) {
-                                                                 auto uniformIndices = uniformIndicesObject.asArray(
-                                                                         runtime);
-                                                                 auto size = uniformIndices.size(
-                                                                         runtime);
-                                                                 rust::Vec<uint32_t> buf;
-                                                                 buf.reserve(size);
-                                                                 for (int j = 0; j < size; j++) {
-                                                                     auto item = (uint32_t) uniformIndices.getValueAtIndex(
-                                                                             runtime, j).asNumber();
-                                                                     buf.emplace_back(item);
-                                                                 }
-                                                                 rust::Slice<const uint32_t> slice(
-                                                                         buf.data(), buf.size());
-                                                                 auto ret = canvas_native_webgl2_get_active_uniforms(
-                                                                         program->GetProgram(),
-                                                                         slice,
-                                                                         pname,
-                                                                         this->GetState()
-                                                                 );
 
-                                                                 switch (pname) {
-                                                                     case GL_UNIFORM_TYPE:
-                                                                     case GL_UNIFORM_SIZE: {
-                                                                         auto value = canvas_native_webgl_result_get_u32_array(
-                                                                                 *ret);
-                                                                         auto array = jsi::Array(
-                                                                                 runtime,
-                                                                                 value.size());
-                                                                         auto len = value.size();
-                                                                         for (int j = 0;
-                                                                              j < len; ++j) {
-                                                                             auto item = value[j];
-                                                                             array.setValueAtIndex(
-                                                                                     runtime, j,
-                                                                                     jsi::Value(
-                                                                                             (int32_t) item));
-                                                                         }
-                                                                         return array;
-                                                                     }
-                                                                         break;
-                                                                     case GL_UNIFORM_BLOCK_INDEX:
-                                                                     case GL_UNIFORM_OFFSET:
-                                                                     case GL_UNIFORM_ARRAY_STRIDE:
-                                                                     case GL_UNIFORM_MATRIX_STRIDE: {
-                                                                         auto value = canvas_native_webgl_result_get_i32_array(
-                                                                                 *ret);
-                                                                         auto array = jsi::Array(
-                                                                                 runtime,
-                                                                                 value.size());
-                                                                         auto len = value.size();
-                                                                         for (int j = 0;
-                                                                              j < len; ++j) {
-                                                                             auto item = value[j];
-                                                                             array.setValueAtIndex(
-                                                                                     runtime, j,
-                                                                                     jsi::Value(
-                                                                                             item));
-                                                                         }
-                                                                         return array;
-                                                                     }
-                                                                     case GL_UNIFORM_IS_ROW_MAJOR: {
-                                                                         auto value = canvas_native_webgl_result_get_bool_array(
-                                                                                 *ret);
-                                                                         auto len = value.size();
-                                                                         auto array = jsi::Array(
-                                                                                 runtime,
-                                                                                 len);
-                                                                         for (int j = 0;
-                                                                              j < len; ++j) {
-                                                                             bool item =
-                                                                                     value[j] == 1;
-                                                                             array.setValueAtIndex(
-                                                                                     runtime, j,
-                                                                                     jsi::Value(
-                                                                                             item));
-                                                                         }
-                                                                         return array;
-                                                                     }
-                                                                     default:
-                                                                         return jsi::Value::null();
-                                                                 }
-                                                             }
+    return ret;
+}
 
+jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNameID &name) {
+    auto methodName = name.utf8(runtime);
 
-                                                         }
-                                                         return jsi::Value::null();
-                                                     }
-        );
-    } else if (methodName == "getBufferSubData") {
+    auto prop = GetProperty(methodName);
+
+
+   if (methodName == "getBufferSubData") {
         return jsi::Function::createFromHostFunction(runtime,
                                                      jsi::PropNameID::forAscii(runtime, methodName),
                                                      4,
@@ -2391,10 +2285,10 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
 
 
                                                          if (count >= 3 &&
-                                                             arguments[2].isObject()) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto srcByteOffset = arguments[1].asNumber();
-                                                             auto dstDataObject = arguments[2].asObject(
+                                                             args[2]->IsObject()) {
+                                                             auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+                                                             auto srcByteOffset = args[1]->NumberValue(context).ToChecked();
+                                                             auto dstDataObject = args[2].asObject(
                                                                      runtime);
 
                                                              if (dstDataObject.isTypedArray(
@@ -2405,16 +2299,22 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  auto slice = GetTypedArrayData<uint8_t>(
                                                                          runtime, array);
 
-                                                                 auto BYTES_PER_ELEMENT = (ssize_t)array.getProperty(runtime, "BYTES_PER_ELEMENT").asNumber();
+                                                                 auto BYTES_PER_ELEMENT = (ssize_t) array.getProperty(
+                                                                         runtime,
+                                                                         "BYTES_PER_ELEMENT")->NumberValue(context).ToChecked();
 
                                                                  ssize_t dstOffsetValue = 0;
-                                                                 if (arguments[3].isNumber()) {
-                                                                     dstOffsetValue = static_cast<ssize_t>(arguments[3].asNumber()) * BYTES_PER_ELEMENT;
+                                                                 if (args[3]->IsNumber()) {
+                                                                     dstOffsetValue =
+                                                                             static_cast<ssize_t>(args[3]->NumberValue(context).ToChecked()) *
+                                                                             BYTES_PER_ELEMENT;
                                                                  }
 
                                                                  ssize_t lengthValue = 0;
-                                                                 if (arguments[4].isNumber()) {
-                                                                     lengthValue = static_cast<ssize_t>(arguments[4].asNumber()) * BYTES_PER_ELEMENT;
+                                                                 if (args[4]->IsNumber()) {
+                                                                     lengthValue =
+                                                                             static_cast<ssize_t>(args[4]->NumberValue(context).ToChecked()) *
+                                                                             BYTES_PER_ELEMENT;
                                                                  }
 
                                                                  canvas_native_webgl2_get_buffer_sub_data(
@@ -2423,7 +2323,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          slice,
                                                                          dstOffsetValue,
                                                                          lengthValue,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -2441,18 +2341,18 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
 
 
-                                                         if (count > 1 && arguments[1].isString()) {
+                                                         if (count > 1 && args[1].isString()) {
                                                              auto program = getHostObject<WebGLProgram>(
-                                                                     runtime, arguments[0]);
+                                                                     runtime, args[0]);
 
                                                              if (program != nullptr) {
-                                                                 auto name = arguments[1].asString(
+                                                                 auto name = args[1].asString(
                                                                          runtime).utf8(runtime);
 
                                                                  auto ret = canvas_native_webgl2_get_frag_data_location(
                                                                          program->GetProgram(),
                                                                          rust::Str(name.c_str()),
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
 
                                                                  return {ret};
@@ -2472,12 +2372,12 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
 
                                                          if (count > 1) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto index = (uint32_t) arguments[1].asNumber();
+                                                             auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+                                                             auto index = (uint32_t) args[1]->NumberValue(context).ToChecked();
                                                              auto ret = canvas_native_webgl2_get_indexed_parameter(
                                                                      target,
                                                                      index,
-                                                                     this->GetState()
+                                                                     ptr->GetState()
                                                              );
 
                                                              switch (target) {
@@ -2517,9 +2417,9 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
                                                          if (count > 2) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto internalformat = (uint32_t) arguments[1].asNumber();
-                                                             auto pname = (uint32_t) arguments[2].asNumber();
+                                                             auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+                                                             auto internalformat = (uint32_t) args[1]->NumberValue(context).ToChecked();
+                                                             auto pname = (uint32_t) args[2]->NumberValue(context).ToChecked();
                                                              switch (internalformat) {
                                                                  case GL_RGB:
                                                                  case GL_RGBA:
@@ -2593,7 +2493,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                      target,
                                                                      internalformat,
                                                                      pname,
-                                                                     this->GetState()
+                                                                     ptr->GetState()
                                                              );
 
                                                              if (pname == GL_SAMPLES) {
@@ -2633,10 +2533,10 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
 
                                                          if (count > 0) {
-                                                             auto pname = (uint32_t) arguments[0].asNumber();
+                                                             auto pname = (uint32_t) args[0]->NumberValue(context).ToChecked();
                                                              auto result = canvas_native_webgl2_get_parameter(
                                                                      pname,
-                                                                     this->GetState());
+                                                                     ptr->GetState());
                                                              switch (pname) {
                                                                  case GL_COPY_READ_BUFFER_BINDING:
                                                                  case GL_COPY_WRITE_BUFFER_BINDING:
@@ -2665,15 +2565,15 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
 
                                                          if (count > 1) {
                                                              auto query = getHostObject<WebGLQuery>(
-                                                                     runtime, arguments[0]);
+                                                                     runtime, args[0]);
                                                              if (query != nullptr) {
-                                                                 auto pname = (uint32_t) arguments[1].asNumber();
+                                                                 auto pname = (uint32_t) args[1]->NumberValue(context).ToChecked();
 
 
                                                                  auto ret = canvas_native_webgl2_get_query_parameter(
                                                                          query->GetQuery(),
                                                                          pname,
-                                                                         this->GetState());
+                                                                         ptr->GetState());
                                                                  if (pname == GL_QUERY_RESULT) {
                                                                      return {canvas_native_webgl_result_get_bool(
                                                                              *ret)};
@@ -2698,12 +2598,12 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
 
                                                          if (count > 1) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto pname = (uint32_t) arguments[1].asNumber();
+                                                             auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+                                                             auto pname = (uint32_t) args[1]->NumberValue(context).ToChecked();
                                                              auto ret = canvas_native_webgl2_get_query(
                                                                      target,
                                                                      pname,
-                                                                     this->GetState());
+                                                                     ptr->GetState());
                                                              if (pname == GL_CURRENT_QUERY) {
                                                                  return {canvas_native_webgl_result_get_i32(
                                                                          *ret)};
@@ -2724,13 +2624,13 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
 
                                                          if (count > 1) {
                                                              auto sampler = getHostObject<WebGLSampler>(
-                                                                     runtime, arguments[0]);
+                                                                     runtime, args[0]);
                                                              if (sampler != nullptr) {
-                                                                 auto pname = (uint32_t) arguments[1].asNumber();
+                                                                 auto pname = (uint32_t) args[1]->NumberValue(context).ToChecked();
                                                                  auto ret = canvas_native_webgl2_get_sampler_parameter(
                                                                          sampler->GetSampler(),
                                                                          pname,
-                                                                         this->GetState());
+                                                                         ptr->GetState());
 
                                                                  switch (pname) {
                                                                      case GL_TEXTURE_MAX_LOD:
@@ -2766,13 +2666,13 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
 
                                                          if (count > 1) {
                                                              auto sync = getHostObject<WebGLSyncImpl>(
-                                                                     runtime, arguments[0]);
+                                                                     runtime, args[0]);
                                                              if (sync != nullptr) {
-                                                                 auto pname = (uint32_t) arguments[1].asNumber();
+                                                                 auto pname = (uint32_t) args[1]->NumberValue(context).ToChecked();
                                                                  auto ret = canvas_native_webgl2_get_sync_parameter(
                                                                          sync->GetSync(),
                                                                          pname,
-                                                                         this->GetState());
+                                                                         ptr->GetState());
 
                                                                  switch (pname) {
                                                                      case GL_OBJECT_TYPE:
@@ -2799,13 +2699,13 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
                                                          if (count > 1) {
                                                              auto program = getHostObject<WebGLProgram>(
-                                                                     runtime, arguments[0]);
-                                                             auto index = (uint32_t) arguments[1].asNumber();
+                                                                     runtime, args[0]);
+                                                             auto index = (uint32_t) args[1]->NumberValue(context).ToChecked();
                                                              if (program != nullptr) {
                                                                  auto ret = canvas_native_webgl2_get_transform_feedback_varying(
                                                                          program->GetProgram(),
                                                                          index,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
 
                                                                  if (canvas_native_webgl_active_info_get_is_empty(
@@ -2834,14 +2734,14 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
                                                          if (count > 1) {
                                                              auto program = getHostObject<WebGLProgram>(
-                                                                     runtime, arguments[0]);
-                                                             auto index = arguments[1].asString(
+                                                                     runtime, args[0]);
+                                                             auto index = args[1].asString(
                                                                      runtime).utf8(runtime);
                                                              if (program != nullptr) {
                                                                  auto ret = canvas_native_webgl2_get_uniform_block_index(
                                                                          program->GetProgram(),
                                                                          rust::Str(index.c_str()),
-                                                                         this->GetState());
+                                                                         ptr->GetState());
 
                                                                  return {(int) ret};
                                                              }
@@ -2859,10 +2759,10 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
 
-                                                         if (count > 1 && arguments[1].isObject()) {
+                                                         if (count > 1 && args[1]->IsObject()) {
                                                              auto program = getHostObject<WebGLProgram>(
-                                                                     runtime, arguments[0]);
-                                                             auto uniformNamesObject = arguments[1].asObject(
+                                                                     runtime, args[0]);
+                                                             auto uniformNamesObject = args[1].asObject(
                                                                      runtime);
                                                              if (program != nullptr &&
                                                                  uniformNamesObject.isArray(
@@ -2887,7 +2787,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  auto ret = canvas_native_webgl2_get_uniform_indices(
                                                                          program->GetProgram(),
                                                                          slice,
-                                                                         this->GetState());
+                                                                         ptr->GetState());
 
                                                                  auto retSize = ret.size();
                                                                  auto result = jsi::Array(runtime,
@@ -2917,9 +2817,9 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
 
 
-                                                         if (count > 1 && arguments[1].isObject()) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto attachments = arguments[1].asObject(
+                                                         if (count > 1 && args[1]->IsObject()) {
+                                                             auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+                                                             auto attachments = args[1].asObject(
                                                                      runtime);
 
                                                              if (attachments.isArray(runtime)) {
@@ -2930,7 +2830,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  buf.reserve(len);
                                                                  for (int j = 0; j < len; ++j) {
                                                                      auto item = (uint32_t) array.getValueAtIndex(
-                                                                             runtime, j).asNumber();
+                                                                             runtime, j)->NumberValue(context).ToChecked();
                                                                      buf.push_back(item);
                                                                  }
 
@@ -2938,7 +2838,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          buf.data(), buf.size());
                                                                  canvas_native_webgl2_invalidate_framebuffer(
                                                                          target, slice,
-                                                                         this->GetState());
+                                                                         ptr->GetState());
                                                              }
                                                          }
 
@@ -2955,15 +2855,15 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
 
 
-                                                         if (count > 5 && arguments[1].isObject()) {
-                                                             auto attachments = arguments[1].asObject(
+                                                         if (count > 5 && args[1]->IsObject()) {
+                                                             auto attachments = args[1].asObject(
                                                                      runtime);
                                                              if (attachments.isArray(runtime)) {
-                                                                 auto target = (uint32_t) arguments[0].asNumber();
-                                                                 auto x = (int32_t) arguments[2].asNumber();
-                                                                 auto y = (int32_t) arguments[3].asNumber();
-                                                                 auto width = (int32_t) arguments[4].asNumber();
-                                                                 auto height = (int32_t) arguments[5].asNumber();
+                                                                 auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+                                                                 auto x = (int32_t) args[2]->NumberValue(context).ToChecked();
+                                                                 auto y = (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 array = attachments.getArray(
                                                                          runtime);
@@ -2972,7 +2872,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  buf.reserve(len);
                                                                  for (int j = 0; j < len; ++j) {
                                                                      auto item = (uint) array.getValueAtIndex(
-                                                                             runtime, j).asNumber();
+                                                                             runtime, j)->NumberValue(context).ToChecked();
                                                                      buf.push_back(item);
                                                                  }
                                                                  rust::Slice<const uint32_t> slice(
@@ -2985,7 +2885,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          y,
                                                                          width,
                                                                          height,
-                                                                         this->GetState());
+                                                                         ptr->GetState());
                                                              }
 
 
@@ -3004,11 +2904,11 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
                                                          if (count > 0) {
                                                              auto query = getHostObject<WebGLQuery>(
-                                                                     runtime, arguments[0]);
+                                                                     runtime, args[0]);
                                                              if (query != nullptr) {
                                                                  auto ret = canvas_native_webgl2_is_query(
                                                                          query->GetQuery(),
-                                                                         this->GetState());
+                                                                         ptr->GetState());
                                                                  return {ret};
                                                              }
                                                          }
@@ -3026,11 +2926,11 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
                                                          if (count > 0) {
                                                              auto sampler = getHostObject<WebGLSampler>(
-                                                                     runtime, arguments[0]);
+                                                                     runtime, args[0]);
                                                              if (sampler != nullptr) {
                                                                  auto ret = canvas_native_webgl2_is_sampler(
                                                                          sampler->GetSampler(),
-                                                                         this->GetState());
+                                                                         ptr->GetState());
                                                                  return {ret};
                                                              }
                                                          }
@@ -3048,11 +2948,11 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
                                                          if (count > 0) {
                                                              auto sync = getHostObject<WebGLSyncImpl>(
-                                                                     runtime, arguments[0]);
+                                                                     runtime, args[0]);
                                                              if (sync != nullptr) {
                                                                  auto ret = canvas_native_webgl2_is_sync(
                                                                          sync->GetSync(),
-                                                                         this->GetState());
+                                                                         ptr->GetState());
                                                                  return {ret};
                                                              }
                                                          }
@@ -3070,11 +2970,11 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
                                                          if (count > 0) {
                                                              auto transformFeedback = getHostObject<WebGLTransformFeedback>(
-                                                                     runtime, arguments[0]);
+                                                                     runtime, args[0]);
                                                              if (transformFeedback != nullptr) {
                                                                  auto ret = canvas_native_webgl2_is_transform_feedback(
                                                                          transformFeedback->GetFeedback(),
-                                                                         this->GetState());
+                                                                         ptr->GetState());
                                                                  return {ret};
                                                              }
                                                          }
@@ -3092,11 +2992,11 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
                                                          if (count > 0) {
                                                              auto vertexArray = getHostObject<WebGLVertexArrayObject>(
-                                                                     runtime, arguments[0]);
+                                                                     runtime, args[0]);
                                                              if (vertexArray != nullptr) {
                                                                  auto ret = canvas_native_webgl2_is_vertex_array(
                                                                          vertexArray->GetVertexArrayObject(),
-                                                                         this->GetState());
+                                                                         ptr->GetState());
                                                                  return {ret};
                                                              }
                                                          }
@@ -3116,7 +3016,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
 
                                                          canvas_native_webgl2_pause_transform_feedback(
-                                                                 this->GetState());
+                                                                 ptr->GetState());
 
                                                          return jsi::Value::undefined();
                                                      }
@@ -3130,10 +3030,10 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
                                                          if (count > 0) {
-                                                             auto src = (uint32_t) arguments[0].asNumber();
+                                                             auto src = (uint32_t) args[0]->NumberValue(context).ToChecked();
                                                              canvas_native_webgl2_read_buffer(
                                                                      src,
-                                                                     this->GetState()
+                                                                     ptr->GetState()
                                                              );
                                                          }
 
@@ -3150,18 +3050,18 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
 
                                                          if (count > 4) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto samples = (int32_t) arguments[1].asNumber();
-                                                             auto internalFormat = (uint32_t) arguments[2].asNumber();
-                                                             auto width = (int32_t) arguments[3].asNumber();
-                                                             auto height = (int32_t) arguments[4].asNumber();
+                                                             auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+                                                             auto samples = (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();
                                                              canvas_native_webgl2_renderbuffer_storage_multisample(
                                                                      target,
                                                                      samples,
                                                                      internalFormat,
                                                                      width,
                                                                      height,
-                                                                     this->GetState()
+                                                                     ptr->GetState()
                                                              );
                                                          }
 
@@ -3177,7 +3077,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
                                                          canvas_native_webgl2_resume_transform_feedback(
-                                                                 this->GetState());
+                                                                 ptr->GetState());
                                                          return jsi::Value::undefined();
                                                      }
         );
@@ -3192,15 +3092,15 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
 
                                                          if (count > 2) {
                                                              auto sampler = getHostObject<WebGLSampler>(
-                                                                     runtime, arguments[0]);
-                                                             auto pname = (uint32_t) arguments[1].asNumber();
-                                                             auto param = arguments[2].asNumber();
+                                                                     runtime, args[0]);
+                                                             auto pname = (uint32_t) args[1]->NumberValue(context).ToChecked();
+                                                             auto param = args[2]->NumberValue(context).ToChecked();
                                                              if (sampler != nullptr) {
                                                                  canvas_native_webgl2_sampler_parameterf(
                                                                          sampler->GetSampler(),
                                                                          pname,
                                                                          static_cast<float>(param),
-                                                                         this->GetState());
+                                                                         ptr->GetState());
                                                              }
                                                          }
 
@@ -3218,15 +3118,15 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
 
                                                          if (count > 2) {
                                                              auto sampler = getHostObject<WebGLSampler>(
-                                                                     runtime, arguments[0]);
-                                                             auto pname = (uint32_t) arguments[1].asNumber();
-                                                             auto param = (int32_t) arguments[2].asNumber();
+                                                                     runtime, args[0]);
+                                                             auto pname = (uint32_t) args[1]->NumberValue(context).ToChecked();
+                                                             auto param = (int32_t) args[2]->NumberValue(context).ToChecked();
                                                              if (sampler != nullptr) {
                                                                  canvas_native_webgl2_sampler_parameteri(
                                                                          sampler->GetSampler(),
                                                                          pname,
                                                                          param,
-                                                                         this->GetState());
+                                                                         ptr->GetState());
                                                              }
                                                          }
 
@@ -3243,19 +3143,19 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
 
                                                          if (count == 10) {
-                                                             auto target = (int32_t) arguments[0].asNumber();
-                                                             auto level = (int32_t) arguments[1].asNumber();
-                                                             auto internalformat = (int32_t) arguments[2].asNumber();
-                                                             auto width = (int32_t) arguments[3].asNumber();
-                                                             auto height = (int32_t) arguments[4].asNumber();
-                                                             auto depth = (int32_t) arguments[5].asNumber();
-                                                             auto border = (int32_t) arguments[6].asNumber();
-                                                             auto format = (int32_t) arguments[7].asNumber();
-                                                             auto type = (uint32_t) arguments[8].asNumber();
-
-
-                                                             if (arguments[9].isNumber()) {
-                                                                 auto imageOrPixelsOrOffset = arguments[9].asNumber();
+                                                             auto target = (int32_t) args[0]->NumberValue(context).ToChecked();
+                                                             auto level = (int32_t) args[1]->NumberValue(context).ToChecked();
+                                                             auto internalformat = (int32_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 depth = (int32_t) args[5]->NumberValue(context).ToChecked();
+                                                             auto border = (int32_t) args[6]->NumberValue(context).ToChecked();
+                                                             auto format = (int32_t) args[7]->NumberValue(context).ToChecked();
+                                                             auto type = (uint32_t) args[8]->NumberValue(context).ToChecked();
+
+
+                                                             if (args[9]->IsNumber()) {
+                                                                 auto imageOrPixelsOrOffset = args[9]->NumberValue(context).ToChecked();
                                                                  canvas_native_webgl2_tex_image3d_none(
                                                                          target,
                                                                          level,
@@ -3267,13 +3167,13 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          format,
                                                                          type,
                                                                          static_cast<ssize_t>(imageOrPixelsOrOffset),
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                                  return jsi::Value::undefined();
                                                              }
 
-                                                             if (arguments[9].isObject()) {
-                                                                 auto imageOrPixelsOrOffsetObject = arguments[9].asObject(
+                                                             if (args[9]->IsObject()) {
+                                                                 auto imageOrPixelsOrOffsetObject = args[9].asObject(
                                                                          runtime);
 
                                                                  if (imageOrPixelsOrOffsetObject.isTypedArray(
@@ -3295,7 +3195,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                              format,
                                                                              type,
                                                                              slice,
-                                                                             this->GetState()
+                                                                             ptr->GetState()
                                                                      );
                                                                      return jsi::Value::undefined();
                                                                  }
@@ -3303,7 +3203,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  /*
                                                                  try {
                                                                      auto image_asset = getHostObject<ImageAssetImpl>(
-                                                                             runtime, arguments[9]);
+                                                                             runtime, args[9]);
                                                                      if (image_asset != nullptr) {
                                                                          canvas_native_webgl2_tex_image3d_asset(
                                                                                  target,
@@ -3316,7 +3216,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                                  format,
                                                                                  type,
                                                                                  image_asset->GetImageAsset(),
-                                                                                 this->GetState()
+                                                                                 ptr->GetState()
                                                                          );
 
                                                                          return jsi::Value::undefined();
@@ -3325,7 +3225,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
 
                                                                  try {
                                                                      auto image_bitmap = getHostObject<ImageBitmapImpl>(
-                                                                             runtime, arguments[9]);
+                                                                             runtime, args[9]);
                                                                      if (image_bitmap != nullptr) {
                                                                          canvas_native_webgl2_tex_image3d_asset(
                                                                                  target,
@@ -3338,7 +3238,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                                  format,
                                                                                  type,
                                                                                  image_bitmap->GetImageAsset(),
-                                                                                 this->GetState()
+                                                                                 ptr->GetState()
                                                                          );
 
                                                                          return jsi::Value::undefined();
@@ -3349,21 +3249,21 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                              }
                                                          } else if (count > 10) {
 
-                                                             auto target = (int32_t) arguments[0].asNumber();
-                                                             auto level = (int32_t) arguments[1].asNumber();
-                                                             auto internalformat = (int32_t) arguments[2].asNumber();
-                                                             auto width = (int32_t) arguments[3].asNumber();
-                                                             auto height = (int32_t) arguments[4].asNumber();
-                                                             auto depth = (int32_t) arguments[5].asNumber();
-                                                             auto border = (int32_t) arguments[6].asNumber();
-                                                             auto format = (int32_t) arguments[7].asNumber();
-                                                             auto type = (uint32_t) arguments[8].asNumber();
-                                                             if (arguments[9].isObject()) {
-                                                                 auto imageOrPixelsOrOffset = arguments[9].asObject(
+                                                             auto target = (int32_t) args[0]->NumberValue(context).ToChecked();
+                                                             auto level = (int32_t) args[1]->NumberValue(context).ToChecked();
+                                                             auto internalformat = (int32_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 depth = (int32_t) args[5]->NumberValue(context).ToChecked();
+                                                             auto border = (int32_t) args[6]->NumberValue(context).ToChecked();
+                                                             auto format = (int32_t) args[7]->NumberValue(context).ToChecked();
+                                                             auto type = (uint32_t) args[8]->NumberValue(context).ToChecked();
+                                                             if (args[9]->IsObject()) {
+                                                                 auto imageOrPixelsOrOffset = args[9].asObject(
                                                                          runtime);
                                                                  size_t srcOffsetValue = 0;
-                                                                 if (arguments[9].isNumber()) {
-                                                                     srcOffsetValue = static_cast<size_t>(arguments[9].asNumber());
+                                                                 if (args[9]->IsNumber()) {
+                                                                     srcOffsetValue = static_cast<size_t>(args[9]->NumberValue(context).ToChecked());
                                                                  }
 
                                                                  if (imageOrPixelsOrOffset.isTypedArray(
@@ -3393,7 +3293,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                              type,
                                                                              array,
                                                                              srcOffsetValue,
-                                                                             this->GetState()
+                                                                             ptr->GetState()
                                                                      );
                                                                      return jsi::Value::undefined();
                                                                  }
@@ -3413,18 +3313,18 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
                                                          if (count > 4) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto levels = (int32_t) arguments[1].asNumber();
-                                                             auto internalFormat = (uint32_t) arguments[2].asNumber();
-                                                             auto width = (int32_t) arguments[3].asNumber();
-                                                             auto height = (int32_t) arguments[4].asNumber();
+                                                             auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+                                                             auto levels = (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();
                                                              canvas_native_webgl2_tex_storage2d(
                                                                      target,
                                                                      levels,
                                                                      internalFormat,
                                                                      width,
                                                                      height,
-                                                                     this->GetState()
+                                                                     ptr->GetState()
                                                              );
                                                          }
 
@@ -3442,12 +3342,12 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
 
                                                          if (count > 5) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto levels = (int32_t) arguments[1].asNumber();
-                                                             auto internalFormat = (uint32_t) arguments[2].asNumber();
-                                                             auto width = (int32_t) arguments[3].asNumber();
-                                                             auto height = (int32_t) arguments[4].asNumber();
-                                                             auto depth = (int32_t) arguments[5].asNumber();
+                                                             auto target = (uint32_t) args[0]->NumberValue(context).ToChecked();
+                                                             auto levels = (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 depth = (int32_t) args[5]->NumberValue(context).ToChecked();
                                                              canvas_native_webgl2_tex_storage3d(
                                                                      target,
                                                                      levels,
@@ -3455,7 +3355,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                      width,
                                                                      height,
                                                                      depth,
-                                                                     this->GetState()
+                                                                     ptr->GetState()
                                                              );
                                                          }
 
@@ -3472,19 +3372,19 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
                                                          if (count == 11) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto level = (int32_t) arguments[1].asNumber();
-                                                             auto xoffset = (int32_t) arguments[2].asNumber();
-                                                             auto yoffset = (int32_t) arguments[3].asNumber();
-                                                             auto zoffset = (int32_t) arguments[4].asNumber();
-                                                             auto width = (int32_t) arguments[5].asNumber();
-                                                             auto height = (int32_t) arguments[6].asNumber();
-                                                             auto depth = (int32_t) arguments[7].asNumber();
-                                                             auto format = (uint32_t) arguments[8].asNumber();
-                                                             auto type = (int32_t) arguments[9].asNumber();
-
-                                                             if (arguments[10].isNumber()) {
-                                                                 auto imageOrPixelsOrOffset = arguments[10].asNumber();
+                                                             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 zoffset = (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 depth = (int32_t) args[7]->NumberValue(context).ToChecked();
+                                                             auto format = (uint32_t) args[8]->NumberValue(context).ToChecked();
+                                                             auto type = (int32_t) args[9]->NumberValue(context).ToChecked();
+
+                                                             if (args[10]->IsNumber()) {
+                                                                 auto imageOrPixelsOrOffset = args[10]->NumberValue(context).ToChecked();
                                                                  canvas_native_webgl2_tex_sub_image3d_none(
                                                                          target,
                                                                          level,
@@ -3497,13 +3397,13 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          format,
                                                                          type,
                                                                          static_cast<ssize_t>(imageOrPixelsOrOffset),
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                                  return jsi::Value::undefined();
                                                              }
 
-                                                             if (arguments[10].isObject()) {
-                                                                 auto imageOrPixelsOrOffsetObject = arguments[10].asObject(
+                                                             if (args[10]->IsObject()) {
+                                                                 auto imageOrPixelsOrOffsetObject = args[10].asObject(
                                                                          runtime);
                                                                  if (imageOrPixelsOrOffsetObject.isTypedArray(
                                                                          runtime)) {
@@ -3524,7 +3424,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                              format,
                                                                              type,
                                                                              slice,
-                                                                             this->GetState()
+                                                                             ptr->GetState()
                                                                      );
 
                                                                      return jsi::Value::undefined();
@@ -3532,7 +3432,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
 
                                                                  /*
                                                                  auto asset = getHostObject<ImageAssetImpl>(
-                                                                         runtime, arguments[10]);
+                                                                         runtime, args[10]);
                                                                  if (asset != nullptr) {
 
                                                                      canvas_native_webgl2_tex_sub_image3d_asset(
@@ -3547,7 +3447,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                              format,
                                                                              type,
                                                                              asset->GetImageAsset(),
-                                                                             this->GetState()
+                                                                             ptr->GetState()
                                                                      );
                                                                  }
 
@@ -3555,24 +3455,24 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                              }
 
                                                          } else if (count > 11) {
-                                                             auto target = (uint32_t) arguments[0].asNumber();
-                                                             auto level = (int32_t) arguments[1].asNumber();
-                                                             auto xoffset = (int32_t) arguments[2].asNumber();
-                                                             auto yoffset = (int32_t) arguments[3].asNumber();
-                                                             auto zoffset = (int32_t) arguments[4].asNumber();
-                                                             auto width = (int32_t) arguments[5].asNumber();
-                                                             auto height = (int32_t) arguments[6].asNumber();
-                                                             auto depth = (int32_t) arguments[7].asNumber();
-                                                             auto format = (uint32_t) arguments[8].asNumber();
-                                                             auto type = (uint32_t) arguments[9].asNumber();
+                                                             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 zoffset = (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 depth = (int32_t) args[7]->NumberValue(context).ToChecked();
+                                                             auto format = (uint32_t) args[8]->NumberValue(context).ToChecked();
+                                                             auto type = (uint32_t) args[9]->NumberValue(context).ToChecked();
 
                                                              size_t srcOffsetValue = 0;
-                                                             if (arguments[11].isNumber()) {
-                                                                 srcOffsetValue = static_cast<size_t>(arguments[11].asNumber());
+                                                             if (args[11]->IsNumber()) {
+                                                                 srcOffsetValue = static_cast<size_t>(args[11]->NumberValue(context).ToChecked());
                                                              }
 
-                                                             if (arguments[10].isObject()) {
-                                                                 auto imageOrPixelsOrOffsetObject = arguments[10].asObject(
+                                                             if (args[10]->IsObject()) {
+                                                                 auto imageOrPixelsOrOffsetObject = args[10].asObject(
                                                                          runtime);
 
                                                                  if (imageOrPixelsOrOffsetObject.isTypedArray(
@@ -3606,7 +3506,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                              type,
                                                                              slice,
                                                                              srcOffsetValue,
-                                                                             this->GetState()
+                                                                             ptr->GetState()
                                                                      );
                                                                  }
 
@@ -3625,12 +3525,12 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value &thisValue,
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
-                                                         if (count > 2 && arguments[1].isObject()) {
+                                                         if (count > 2 && args[1]->IsObject()) {
                                                              auto program = getHostObject<WebGLProgram>(
-                                                                     runtime, arguments[0]);
-                                                             auto varyingsObject = arguments[1].asObject(
+                                                                     runtime, args[0]);
+                                                             auto varyingsObject = args[1].asObject(
                                                                      runtime);
-                                                             auto bufferMode = (uint32_t) arguments[2].asNumber();
+                                                             auto bufferMode = (uint32_t) args[2]->NumberValue(context).ToChecked();
 
                                                              if (program != nullptr &&
                                                                  varyingsObject.isArray(runtime)) {
@@ -3655,7 +3555,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          program->GetProgram(),
                                                                          slice,
                                                                          bufferMode,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -3671,17 +3571,17 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
 
-                                                         if (count > 1 && arguments[1].isNumber()) {
+                                                         if (count > 1 && args[1]->IsNumber()) {
 
                                                              auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, arguments[0]);
-                                                             auto v0 = (uint32_t) arguments[1].asNumber();
+                                                                     runtime, args[0]);
+                                                             auto v0 = (uint32_t) args[1]->NumberValue(context).ToChecked();
 
                                                              if (location != nullptr) {
                                                                  canvas_native_webgl2_uniform1ui(
                                                                          location->GetUniformLocation(),
                                                                          v0,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -3697,10 +3597,10 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
 
-                                                         if (count > 1 && arguments[1].isObject()) {
+                                                         if (count > 1 && args[1]->IsObject()) {
                                                              auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, arguments[0]);
-                                                             auto data = arguments[1].asObject(
+                                                                     runtime, args[0]);
+                                                             auto data = args[1].asObject(
                                                                      runtime);
                                                              if (location != nullptr &&
                                                                  data.isUint32Array(runtime)) {
@@ -3711,7 +3611,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  canvas_native_webgl2_uniform1uiv(
                                                                          location->GetUniformLocation(),
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              } else {
                                                                  rust::Vec<uint32_t> buf;
@@ -3721,7 +3621,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  buf.reserve(len);
                                                                  for (int i = 0; i < len; i++) {
                                                                      auto item = (uint32_t) array.getValueAtIndex(
-                                                                             runtime, i).asNumber();
+                                                                             runtime, i)->NumberValue(context).ToChecked();
                                                                      buf.push_back(item);
                                                                  }
                                                                  rust::Slice<const uint32_t> slice(
@@ -3729,7 +3629,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  canvas_native_webgl2_uniform1uiv(
                                                                          location->GetUniformLocation(),
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
 
@@ -3750,16 +3650,16 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
 
                                                          if (count > 2) {
                                                              auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, arguments[0]);
-                                                             auto v0 = (uint32_t) arguments[1].asNumber();
-                                                             auto v1 = (uint32_t) arguments[2].asNumber();
+                                                                     runtime, args[0]);
+                                                             auto v0 = (uint32_t) args[1]->NumberValue(context).ToChecked();
+                                                             auto v1 = (uint32_t) args[2]->NumberValue(context).ToChecked();
 
                                                              if (location != nullptr) {
                                                                  canvas_native_webgl2_uniform2ui(
                                                                          location->GetUniformLocation(),
                                                                          v0,
                                                                          v1,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
 
@@ -3777,11 +3677,11 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
 
-                                                         if (count > 1 && arguments[1].isObject()) {
+                                                         if (count > 1 && args[1]->IsObject()) {
 
                                                              auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, arguments[0]);
-                                                             auto data = arguments[1].asObject(
+                                                                     runtime, args[0]);
+                                                             auto data = args[1].asObject(
                                                                      runtime);
 
                                                              if (data.isUint32Array(runtime)) {
@@ -3792,7 +3692,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  canvas_native_webgl2_uniform2uiv(
                                                                          location->GetUniformLocation(),
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              } else {
                                                                  rust::Vec<uint32_t> buf;
@@ -3802,7 +3702,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  buf.reserve(len);
                                                                  for (int i = 0; i < len; i++) {
                                                                      auto item = (uint32_t) array.getValueAtIndex(
-                                                                             runtime, i).asNumber();
+                                                                             runtime, i)->NumberValue(context).ToChecked();
                                                                      buf.push_back(item);
                                                                  }
 
@@ -3811,7 +3711,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  canvas_native_webgl2_uniform2uiv(
                                                                          location->GetUniformLocation(),
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -3829,17 +3729,17 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
                                                          if (count > 3) {
                                                              auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, arguments[0]);
-                                                             auto v0 = (uint32_t) arguments[1].asNumber();
-                                                             auto v1 = (uint32_t) arguments[2].asNumber();
-                                                             auto v2 = (uint32_t) arguments[3].asNumber();
+                                                                     runtime, args[0]);
+                                                             auto v0 = (uint32_t) args[1]->NumberValue(context).ToChecked();
+                                                             auto v1 = (uint32_t) args[2]->NumberValue(context).ToChecked();
+                                                             auto v2 = (uint32_t) args[3]->NumberValue(context).ToChecked();
                                                              if (location != nullptr) {
                                                                  canvas_native_webgl2_uniform3ui(
                                                                          location->GetUniformLocation(),
                                                                          v0,
                                                                          v1,
                                                                          v2,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -3856,10 +3756,10 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
 
-                                                         if (count > 1 && arguments[1].isObject()) {
+                                                         if (count > 1 && args[1]->IsObject()) {
                                                              auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, arguments[0]);
-                                                             auto data = arguments[1].asObject(
+                                                                     runtime, args[0]);
+                                                             auto data = args[1].asObject(
                                                                      runtime);
 
                                                              if (data.isUint32Array(runtime)) {
@@ -3870,7 +3770,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  canvas_native_webgl2_uniform3uiv(
                                                                          location->GetUniformLocation(),
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              } else {
                                                                  rust::Vec<uint32_t> buf;
@@ -3880,7 +3780,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  buf.reserve(len);
                                                                  for (int i = 0; i < len; i++) {
                                                                      auto item = array.getValueAtIndex(
-                                                                             runtime, i).asNumber();
+                                                                             runtime, i)->NumberValue(context).ToChecked();
                                                                      buf.push_back((uint32_t) item);
                                                                  }
 
@@ -3890,7 +3790,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  canvas_native_webgl2_uniform3uiv(
                                                                          location->GetUniformLocation(),
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -3910,11 +3810,11 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                          if (count > 4) {
 
                                                              auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, arguments[0]);
-                                                             auto v0 = (uint32_t) arguments[1].asNumber();
-                                                             auto v1 = (uint32_t) arguments[2].asNumber();
-                                                             auto v2 = (uint32_t) arguments[3].asNumber();
-                                                             auto v3 = (uint32_t) arguments[4].asNumber();
+                                                                     runtime, args[0]);
+                                                             auto v0 = (uint32_t) args[1]->NumberValue(context).ToChecked();
+                                                             auto v1 = (uint32_t) args[2]->NumberValue(context).ToChecked();
+                                                             auto v2 = (uint32_t) args[3]->NumberValue(context).ToChecked();
+                                                             auto v3 = (uint32_t) args[4]->NumberValue(context).ToChecked();
                                                              if (location != nullptr) {
                                                                  canvas_native_webgl2_uniform4ui(
                                                                          location->GetUniformLocation(),
@@ -3922,7 +3822,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          v1,
                                                                          v2,
                                                                          v3,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -3940,11 +3840,11 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
 
 
-                                                         if (count > 1 && arguments[1].isObject()) {
+                                                         if (count > 1 && args[1]->IsObject()) {
 
                                                              auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, arguments[0]);
-                                                             auto data = arguments[1].asObject(
+                                                                     runtime, args[0]);
+                                                             auto data = args[1].asObject(
                                                                      runtime);
 
                                                              if (data.isUint32Array(runtime)) {
@@ -3955,7 +3855,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  canvas_native_webgl2_uniform4uiv(
                                                                          location->GetUniformLocation(),
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              } else {
                                                                  rust::Vec<uint32_t> buf;
@@ -3965,7 +3865,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  buf.reserve(len);
                                                                  for (int i = 0; i < len; i++) {
                                                                      auto item = array.getValueAtIndex(
-                                                                             runtime, i).asNumber();
+                                                                             runtime, i)->NumberValue(context).ToChecked();
                                                                      buf.push_back((uint32_t) item);
                                                                  }
 
@@ -3975,7 +3875,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  canvas_native_webgl2_uniform4uiv(
                                                                          location->GetUniformLocation(),
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -3995,16 +3895,16 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                          if (count > 2) {
 
                                                              auto program = getHostObject<WebGLProgram>(
-                                                                     runtime, arguments[0]);
-                                                             auto uniformBlockIndex = arguments[1].asNumber();
-                                                             auto uniformBlockBinding = arguments[2].asNumber();
+                                                                     runtime, args[0]);
+                                                             auto uniformBlockIndex = args[1]->NumberValue(context).ToChecked();
+                                                             auto uniformBlockBinding = args[2]->NumberValue(context).ToChecked();
 
                                                              if (program != nullptr) {
                                                                  canvas_native_webgl2_uniform_block_binding(
                                                                          program->GetProgram(),
                                                                          (uint32_t) uniformBlockIndex,
                                                                          (uint32_t) uniformBlockBinding,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
 
@@ -4021,12 +3921,12 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
 
-                                                         if (count > 2 && arguments[2].isObject()) {
+                                                         if (count > 2 && args[2]->IsObject()) {
 
                                                              auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, arguments[0]);
-                                                             auto transpose = arguments[1].asBool();
-                                                             auto data = arguments[2].asObject(
+                                                                     runtime, args[0]);
+                                                             auto transpose = args[1].asBool();
+                                                             auto data = args[2].asObject(
                                                                      runtime);
 
                                                              if (data.isFloat32Array(runtime)) {
@@ -4038,7 +3938,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          location->GetUniformLocation(),
                                                                          transpose,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              } else if (data.isArray(runtime)) {
                                                                  rust::Vec<float> buf;
@@ -4048,9 +3948,9 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  for (int i = 0; i < len; i++) {
                                                                      auto item = array.getValueAtIndex(
                                                                              runtime, i);
-                                                                     if (item.isNumber()) {
+                                                                     if (item->IsNumber()) {
                                                                          buf.push_back(
-                                                                                 static_cast<float>(item.asNumber()));
+                                                                                 static_cast<float>(item->NumberValue(context).ToChecked()));
                                                                      } else {
                                                                          buf.push_back(
                                                                                  std::nanf(""));
@@ -4064,7 +3964,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          location->GetUniformLocation(),
                                                                          transpose,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -4081,12 +3981,12 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
 
-                                                         if (count > 2 && arguments[2].isObject()) {
+                                                         if (count > 2 && args[2]->IsObject()) {
 
                                                              auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, arguments[0]);
-                                                             auto transpose = arguments[1].asBool();
-                                                             auto data = arguments[2].asObject(
+                                                                     runtime, args[0]);
+                                                             auto transpose = args[1].asBool();
+                                                             auto data = args[2].asObject(
                                                                      runtime);
 
                                                              if (data.isFloat32Array(runtime)) {
@@ -4098,7 +3998,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          location->GetUniformLocation(),
                                                                          transpose,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              } else if (data.isArray(runtime)) {
                                                                  rust::Vec<float> buf;
@@ -4108,9 +4008,9 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  for (int i = 0; i < len; i++) {
                                                                      auto item = array.getValueAtIndex(
                                                                              runtime, i);
-                                                                     if (item.isNumber()) {
+                                                                     if (item->IsNumber()) {
                                                                          buf.push_back(
-                                                                                 static_cast<float>(item.asNumber()));
+                                                                                 static_cast<float>(item->NumberValue(context).ToChecked()));
                                                                      } else {
                                                                          buf.push_back(
                                                                                  std::nanf(""));
@@ -4123,7 +4023,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          location->GetUniformLocation(),
                                                                          transpose,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -4140,12 +4040,12 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
 
-                                                         if (count > 2 && arguments[2].isObject()) {
+                                                         if (count > 2 && args[2]->IsObject()) {
 
                                                              auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, arguments[0]);
-                                                             auto transpose = arguments[1].asBool();
-                                                             auto data = arguments[2].asObject(
+                                                                     runtime, args[0]);
+                                                             auto transpose = args[1].asBool();
+                                                             auto data = args[2].asObject(
                                                                      runtime);
 
                                                              if (data.isFloat32Array(runtime)) {
@@ -4157,7 +4057,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          location->GetUniformLocation(),
                                                                          transpose,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              } else if (data.isArray(runtime)) {
                                                                  rust::Vec<float> buf;
@@ -4167,9 +4067,9 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  for (int i = 0; i < len; i++) {
                                                                      auto item = array.getValueAtIndex(
                                                                              runtime, i);
-                                                                     if (item.isNumber()) {
+                                                                     if (item->IsNumber()) {
                                                                          buf.push_back(
-                                                                                 static_cast<float>(item.asNumber()));
+                                                                                 static_cast<float>(item->NumberValue(context).ToChecked()));
                                                                      } else {
                                                                          buf.push_back(
                                                                                  std::nanf(""));
@@ -4183,7 +4083,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          location->GetUniformLocation(),
                                                                          transpose,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -4199,12 +4099,12 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value &thisValue,
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
-                                                         if (count > 2 && arguments[2].isObject()) {
+                                                         if (count > 2 && args[2]->IsObject()) {
 
                                                              auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, arguments[0]);
-                                                             auto transpose = arguments[1].asBool();
-                                                             auto data = arguments[2].asObject(
+                                                                     runtime, args[0]);
+                                                             auto transpose = args[1].asBool();
+                                                             auto data = args[2].asObject(
                                                                      runtime);
 
                                                              if (data.isFloat32Array(runtime)) {
@@ -4216,7 +4116,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          location->GetUniformLocation(),
                                                                          transpose,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              } else if (data.isArray(runtime)) {
                                                                  rust::Vec<float> buf;
@@ -4226,9 +4126,9 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  for (int i = 0; i < len; i++) {
                                                                      auto item = array.getValueAtIndex(
                                                                              runtime, i);
-                                                                     if (item.isNumber()) {
+                                                                     if (item->IsNumber()) {
                                                                          buf.push_back(
-                                                                                 static_cast<float>(item.asNumber()));
+                                                                                 static_cast<float>(item->NumberValue(context).ToChecked()));
                                                                      } else {
                                                                          buf.push_back(
                                                                                  std::nanf(""));
@@ -4242,7 +4142,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          location->GetUniformLocation(),
                                                                          transpose,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -4258,12 +4158,12 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value &thisValue,
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
-                                                         if (count > 2 && arguments[2].isObject()) {
+                                                         if (count > 2 && args[2]->IsObject()) {
 
                                                              auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, arguments[0]);
-                                                             auto transpose = arguments[1].asBool();
-                                                             auto data = arguments[2].asObject(
+                                                                     runtime, args[0]);
+                                                             auto transpose = args[1].asBool();
+                                                             auto data = args[2].asObject(
                                                                      runtime);
 
                                                              if (data.isFloat32Array(runtime)) {
@@ -4275,7 +4175,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          location->GetUniformLocation(),
                                                                          transpose,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              } else if (data.isArray(runtime)) {
                                                                  rust::Vec<float> buf;
@@ -4285,9 +4185,9 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  for (int i = 0; i < len; i++) {
                                                                      auto item = array.getValueAtIndex(
                                                                              runtime, i);
-                                                                     if (item.isNumber()) {
+                                                                     if (item->IsNumber()) {
                                                                          buf.push_back(
-                                                                                 static_cast<float>(item.asNumber()));
+                                                                                 static_cast<float>(item->NumberValue(context).ToChecked()));
                                                                      } else {
                                                                          buf.push_back(
                                                                                  std::nanf(""));
@@ -4301,7 +4201,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          location->GetUniformLocation(),
                                                                          transpose,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -4317,12 +4217,12 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value &thisValue,
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
-                                                         if (count > 2 && arguments[2].isObject()) {
+                                                         if (count > 2 && args[2]->IsObject()) {
 
                                                              auto location = getHostObject<WebGLUniformLocation>(
-                                                                     runtime, arguments[0]);
-                                                             auto transpose = arguments[1].asBool();
-                                                             auto data = arguments[2].asObject(
+                                                                     runtime, args[0]);
+                                                             auto transpose = args[1].asBool();
+                                                             auto data = args[2].asObject(
                                                                      runtime);
 
                                                              if (data.isFloat32Array(runtime)) {
@@ -4334,7 +4234,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          location->GetUniformLocation(),
                                                                          transpose,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              } else if (data.isArray(runtime)) {
                                                                  rust::Vec<float> buf;
@@ -4344,9 +4244,9 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  for (int i = 0; i < len; i++) {
                                                                      auto item = array.getValueAtIndex(
                                                                              runtime, i);
-                                                                     if (item.isNumber()) {
+                                                                     if (item->IsNumber()) {
                                                                          buf.push_back(
-                                                                                 static_cast<float>(item.asNumber()));
+                                                                                 static_cast<float>(item->NumberValue(context).ToChecked()));
                                                                      } else {
                                                                          buf.push_back(
                                                                                  std::nanf(""));
@@ -4360,7 +4260,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                          location->GetUniformLocation(),
                                                                          transpose,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -4377,12 +4277,12 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
                                                          if (count > 1) {
-                                                             auto index = arguments[0].asNumber();
-                                                             auto divisor = arguments[1].asNumber();
+                                                             auto index = args[0]->NumberValue(context).ToChecked();
+                                                             auto divisor = args[1]->NumberValue(context).ToChecked();
                                                              canvas_native_webgl2_vertex_attrib_divisor(
                                                                      (uint32_t) index,
                                                                      (uint32_t) divisor,
-                                                                     this->GetState()
+                                                                     ptr->GetState()
                                                              );
                                                          }
                                                          return jsi::Value::undefined();
@@ -4398,18 +4298,18 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
 
                                                          if (count > 4) {
-                                                             auto index = arguments[0].asNumber();
-                                                             auto v0 = arguments[1].asNumber();
-                                                             auto v1 = arguments[2].asNumber();
-                                                             auto v2 = arguments[3].asNumber();
-                                                             auto v3 = arguments[4].asNumber();
+                                                             auto index = args[0]->NumberValue(context).ToChecked();
+                                                             auto v0 = args[1]->NumberValue(context).ToChecked();
+                                                             auto v1 = args[2]->NumberValue(context).ToChecked();
+                                                             auto v2 = args[3]->NumberValue(context).ToChecked();
+                                                             auto v3 = args[4]->NumberValue(context).ToChecked();
                                                              canvas_native_webgl2_vertex_attrib_i4i(
                                                                      (uint32_t) index,
                                                                      (int32_t) v0,
                                                                      (int32_t) v1,
                                                                      (int32_t) v2,
                                                                      (int32_t) v3,
-                                                                     this->GetState()
+                                                                     ptr->GetState()
                                                              );
                                                          }
                                                          return jsi::Value::undefined();
@@ -4424,9 +4324,9 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             const jsi::Value *arguments,
                                                             size_t count) -> jsi::Value {
 
-                                                         if (count > 1 && arguments[1].isObject()) {
-                                                             auto index = (uint32_t) arguments[0].asNumber();
-                                                             auto value = arguments[1].asObject(
+                                                         if (count > 1 && args[1]->IsObject()) {
+                                                             auto index = (uint32_t) args[0]->NumberValue(context).ToChecked();
+                                                             auto value = args[1].asObject(
                                                                      runtime);
                                                              if (value.isInt32Array(runtime)) {
                                                                  auto array = value.getTypedArray(
@@ -4436,7 +4336,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  canvas_native_webgl2_vertex_attrib_i4iv(
                                                                          index,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              } else if (value.isArray(runtime)) {
                                                                  auto array = value.getArray(
@@ -4446,7 +4346,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  buf.reserve(len);
                                                                  for (int i = 0; i < len; i++) {
                                                                      auto item = (int32_t) array.getValueAtIndex(
-                                                                             runtime, i).asNumber();
+                                                                             runtime, i)->NumberValue(context).ToChecked();
                                                                      buf.push_back(item);
                                                                  }
 
@@ -4456,7 +4356,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  canvas_native_webgl2_vertex_attrib_i4iv(
                                                                          index,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -4474,11 +4374,11 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
 
                                                          if (count > 4) {
-                                                             auto index = (uint32_t) arguments[0].asNumber();
-                                                             auto v0 = (uint32_t) arguments[1].asNumber();
-                                                             auto v1 = (uint32_t) arguments[2].asNumber();
-                                                             auto v2 = (uint32_t) arguments[3].asNumber();
-                                                             auto v3 = (uint32_t) arguments[4].asNumber();
+                                                             auto index = (uint32_t) args[0]->NumberValue(context).ToChecked();
+                                                             auto v0 = (uint32_t) args[1]->NumberValue(context).ToChecked();
+                                                             auto v1 = (uint32_t) args[2]->NumberValue(context).ToChecked();
+                                                             auto v2 = (uint32_t) args[3]->NumberValue(context).ToChecked();
+                                                             auto v3 = (uint32_t) args[4]->NumberValue(context).ToChecked();
 
                                                              canvas_native_webgl2_vertex_attrib_i4ui(
                                                                      index,
@@ -4486,7 +4386,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                      v1,
                                                                      v2,
                                                                      v3,
-                                                                     this->GetState()
+                                                                     ptr->GetState()
                                                              );
                                                          }
                                                          return jsi::Value::undefined();
@@ -4502,9 +4402,9 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                             size_t count) -> jsi::Value {
 
 
-                                                         if (count > 1 && arguments[1].isObject()) {
-                                                             auto index = (uint32_t) arguments[0].asNumber();
-                                                             auto value = arguments[1].asObject(
+                                                         if (count > 1 && args[1]->IsObject()) {
+                                                             auto index = (uint32_t) args[0]->NumberValue(context).ToChecked();
+                                                             auto value = args[1].asObject(
                                                                      runtime);
                                                              if (value.isUint32Array(runtime)) {
                                                                  auto array = value.getTypedArray(
@@ -4514,7 +4414,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  canvas_native_webgl2_vertex_attrib_i4uiv(
                                                                          index,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              } else if (value.isArray(runtime)) {
                                                                  auto array = value.getArray(
@@ -4524,7 +4424,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  buf.reserve(len);
                                                                  for (int i = 0; i < len; i++) {
                                                                      auto item = (uint32_t) array.getValueAtIndex(
-                                                                             runtime, i).asNumber();
+                                                                             runtime, i)->NumberValue(context).ToChecked();
                                                                      buf.push_back(item);
                                                                  }
 
@@ -4534,7 +4434,7 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
                                                                  canvas_native_webgl2_vertex_attrib_i4uiv(
                                                                          index,
                                                                          slice,
-                                                                         this->GetState()
+                                                                         ptr->GetState()
                                                                  );
                                                              }
                                                          }
@@ -4552,3 +4452,399 @@ jsi::Value WebGL2RenderingContext::get(jsi::Runtime &runtime, const jsi::PropNam
     }
     return jsi::Value::undefined();
 }
+
+
+void WebGL2RenderingContext::SetConstants(v8::Isolate *isolate,
+                                          const v8::Local<v8::ObjectTemplate> &tmpl) {
+    /* Getting GL parameter information */
+
+    tmpl->Set(isolate, "READ_BUFFER", v8::Uint32::New(isolate, 0x0C02));
+
+    tmpl->Set(isolate, "UNPACK_ROW_LENGTH", v8::Uint32::New(isolate, 0x0CF2));
+
+    tmpl->Set(isolate, "UNPACK_SKIP_ROWS", v8::Uint32::New(isolate, 0x0CF3));
+
+    tmpl->Set(isolate, "UNPACK_SKIP_PIXELS", v8::Uint32::New(isolate, 0x0CF4));
+
+    tmpl->Set(isolate, "PACK_ROW_LENGTH", v8::Uint32::New(isolate, 0x0D02));
+
+    tmpl->Set(isolate, "PACK_SKIP_ROWS", v8::Uint32::New(isolate, 0x0D03));
+
+    tmpl->Set(isolate, "PACK_SKIP_PIXELS", v8::Uint32::New(isolate, 0x0D04));
+
+    tmpl->Set(isolate, "TEXTURE_BINDING_3D", v8::Uint32::New(isolate, 0x806A));
+
+    tmpl->Set(isolate, "UNPACK_SKIP_IMAGES", v8::Uint32::New(isolate, 0x806D));
+
+    tmpl->Set(isolate, "UNPACK_IMAGE_HEIGHT", v8::Uint32::New(isolate, 0x806E));
+
+    tmpl->Set(isolate, "MAX_3D_TEXTURE_SIZE", v8::Uint32::New(isolate, 0x8073));
+
+    tmpl->Set(isolate, "MAX_ELEMENTS_VERTICES", v8::Uint32::New(isolate, 0x80E8));
+
+    tmpl->Set(isolate, "MAX_ELEMENTS_INDICES", v8::Uint32::New(isolate, 0x80E9));
+
+    tmpl->Set(isolate, "MAX_TEXTURE_LOD_BIAS", v8::Uint32::New(isolate, 0x84FD));
+
+    tmpl->Set(isolate, "MAX_FRAGMENT_UNIFORM_COMPONENTS", v8::Uint32::New(isolate, 0x8B49));
+
+    tmpl->Set(isolate, "MAX_VERTEX_UNIFORM_COMPONENTS", v8::Uint32::New(isolate, 0x8B4A));
+
+    tmpl->Set(isolate, "MAX_ARRAY_TEXTURE_LAYERS", v8::Uint32::New(isolate, 0x88FF));
+
+    tmpl->Set(isolate, "MIN_PROGRAM_TEXEL_OFFSET", v8::Uint32::New(isolate, 0x8904));
+
+    tmpl->Set(isolate, "MAX_PROGRAM_TEXEL_OFFSET", v8::Uint32::New(isolate, 0x8905));
+
+    tmpl->Set(isolate, "MAX_VARYING_COMPONENTS", v8::Uint32::New(isolate, 0x8B4B));
+
+    tmpl->Set(isolate, "FRAGMENT_SHADER_DERIVATIVE_HINT", v8::Uint32::New(isolate, 0x8B8B));
+
+    tmpl->Set(isolate, "RASTERIZER_DISCARD", v8::Uint32::New(isolate, 0x8C89));
+
+    tmpl->Set(isolate, "VERTEX_ARRAY_BINDING", v8::Uint32::New(isolate, 0x85B5));
+    tmpl->Set(isolate, "MAX_VERTEX_OUTPUT_COMPONENTS", v8::Uint32::New(isolate, 0x9122));
+    tmpl->Set(isolate, "MAX_FRAGMENT_INPUT_COMPONENTS", v8::Uint32::New(isolate, 0x9125));
+    tmpl->Set(isolate, "MAX_SERVER_WAIT_TIMEOUT", v8::Uint32::New(isolate, 0x9111));
+    tmpl->Set(isolate, "MAX_ELEMENT_INDEX", v8::Uint32::New(isolate, 0x8D6B));
+
+    tmpl->Set(isolate, "RED", v8::Uint32::New(isolate, 0x1903));
+    tmpl->Set(isolate, "RGB8", v8::Uint32::New(isolate, 0x8051));
+    tmpl->Set(isolate, "RGBA8", v8::Uint32::New(isolate, 0x8058));
+    tmpl->Set(isolate, "RGB10_A2", v8::Uint32::New(isolate, 0x8059));
+    tmpl->Set(isolate, "TEXTURE_3D", v8::Uint32::New(isolate, 0x806F));
+
+    tmpl->Set(isolate, "TEXTURE_WRAP_R", v8::Uint32::New(isolate, 0x8072));
+    tmpl->Set(isolate, "TEXTURE_MIN_LOD", v8::Uint32::New(isolate, 0x813A));
+    tmpl->Set(isolate, "TEXTURE_MAX_LOD", v8::Uint32::New(isolate, 0x813B));
+    tmpl->Set(isolate, "TEXTURE_BASE_LEVEL", v8::Uint32::New(isolate, 0x813C));
+    tmpl->Set(isolate, "TEXTURE_MAX_LEVEL", v8::Uint32::New(isolate, 0x813D));
+
+
+    tmpl->Set(isolate, "TEXTURE_COMPARE_MODE", v8::Uint32::New(isolate, 0x884C));
+    tmpl->Set(isolate, "TEXTURE_COMPARE_FUNC", v8::Uint32::New(isolate, 0x884D));
+    tmpl->Set(isolate, "SRGB", v8::Uint32::New(isolate, 0x8C40));
+    tmpl->Set(isolate, "SRGB8", v8::Uint32::New(isolate, 0x8C41));
+    tmpl->Set(isolate, "SRGB8_ALPHA8", v8::Uint32::New(isolate, 0x8C43));
+
+    tmpl->Set(isolate, "COMPARE_REF_TO_TEXTURE", v8::Uint32::New(isolate, 0x884E));
+    tmpl->Set(isolate, "RGBA32F", v8::Uint32::New(isolate, 0x8814));
+    tmpl->Set(isolate, "RGB32F", v8::Uint32::New(isolate, 0x8815));
+    tmpl->Set(isolate, "RGBA16F", v8::Uint32::New(isolate, 0x881A));
+    tmpl->Set(isolate, "RGB16F", v8::Uint32::New(isolate, 0x881B));
+
+    tmpl->Set(isolate, "TEXTURE_2D_ARRAY", v8::Uint32::New(isolate, 0x8C1A));
+    tmpl->Set(isolate, "TEXTURE_BINDING_2D_ARRAY", v8::Uint32::New(isolate, 0x8C1D));
+    tmpl->Set(isolate, "R11F_G11F_B10F", v8::Uint32::New(isolate, 0x8C3A));
+    tmpl->Set(isolate, "RGB9_E5", v8::Uint32::New(isolate, 0x8C3D));
+    tmpl->Set(isolate, "RGBA32UI", v8::Uint32::New(isolate, 0x8D70));
+
+
+    tmpl->Set(isolate, "RGB32UI", v8::Uint32::New(isolate, 0x8D71));
+    tmpl->Set(isolate, "RGBA16UI", v8::Uint32::New(isolate, 0x8D76));
+    tmpl->Set(isolate, "RGB16UI", v8::Uint32::New(isolate, 0x8D77));
+    tmpl->Set(isolate, "RGBA8UI", v8::Uint32::New(isolate, 0x8D7C));
+    tmpl->Set(isolate, "RGB8UI", v8::Uint32::New(isolate, 0x8D7D));
+
+
+    tmpl->Set(isolate, "RGBA32I", v8::Uint32::New(isolate, 0x8D82));
+    tmpl->Set(isolate, "RGB32I", v8::Uint32::New(isolate, 0x8D83));
+    tmpl->Set(isolate, "RGBA16I", v8::Uint32::New(isolate, 0x8D88));
+    tmpl->Set(isolate, "RGB16I", v8::Uint32::New(isolate, 0x8D89));
+    tmpl->Set(isolate, "RGBA8I", v8::Uint32::New(isolate, 0x8D8E));
+
+
+    tmpl->Set(isolate, "RGB8I", v8::Uint32::New(isolate, 0x8D8F));
+    tmpl->Set(isolate, "RED_INTEGER", v8::Uint32::New(isolate, 0x8D94));
+    tmpl->Set(isolate, "RGB_INTEGER", v8::Uint32::New(isolate, 0x8D98));
+    tmpl->Set(isolate, "RGBA_INTEGER", v8::Uint32::New(isolate, 0x8D99));
+    tmpl->Set(isolate, "R8", v8::Uint32::New(isolate, 0x8229));
+
+
+    tmpl->Set(isolate, "RG8", v8::Uint32::New(isolate, 0x822B));
+    tmpl->Set(isolate, "R16F", v8::Uint32::New(isolate, 0x822D));
+    tmpl->Set(isolate, "R32F", v8::Uint32::New(isolate, 0x822E));
+    tmpl->Set(isolate, "RG16F", v8::Uint32::New(isolate, 0x822F));
+    tmpl->Set(isolate, "RG32F", v8::Uint32::New(isolate, 0x8230));
+
+
+    tmpl->Set(isolate, "R8I", v8::Uint32::New(isolate, 0x8231));
+    tmpl->Set(isolate, "R8UI", v8::Uint32::New(isolate, 0x8232));
+    tmpl->Set(isolate, "R16I", v8::Uint32::New(isolate, 0x8233));
+    tmpl->Set(isolate, "R16UI", v8::Uint32::New(isolate, 0x8234));
+    tmpl->Set(isolate, "R32I", v8::Uint32::New(isolate, 0x8235));
+
+
+    tmpl->Set(isolate, "R32UI", v8::Uint32::New(isolate, 0x8236));
+    tmpl->Set(isolate, "RG8I", v8::Uint32::New(isolate, 0x8237));
+    tmpl->Set(isolate, "RG8UI", v8::Uint32::New(isolate, 0x8238));
+    tmpl->Set(isolate, "RG16I", v8::Uint32::New(isolate, 0x8239));
+    tmpl->Set(isolate, "RG16UI", v8::Uint32::New(isolate, 0x823A));
+
+    tmpl->Set(isolate, "RG32I", v8::Uint32::New(isolate, 0x823B));
+    tmpl->Set(isolate, "RG32UI", v8::Uint32::New(isolate, 0x823C));
+    tmpl->Set(isolate, "R8_SNORM", v8::Uint32::New(isolate, 0x8F94));
+    tmpl->Set(isolate, "RG8_SNORM", v8::Uint32::New(isolate, 0x8F95));
+    tmpl->Set(isolate, "RGB8_SNORM", v8::Uint32::New(isolate, 0x8F96));
+
+
+    tmpl->Set(isolate, "RGBA8_SNORM", v8::Uint32::New(isolate, 0x8F97));
+    tmpl->Set(isolate, "RGB10_A2UI", v8::Uint32::New(isolate, 0x906F));
+    tmpl->Set(isolate, "TEXTURE_IMMUTABLE_FORMAT", v8::Uint32::New(isolate, 0x912F));
+    tmpl->Set(isolate, "TEXTURE_IMMUTABLE_LEVELS", v8::Uint32::New(isolate, 0x82DF));
+    tmpl->Set(isolate, "UNSIGNED_INT_2_10_10_10_REV", v8::Uint32::New(isolate, 0x8368));
+
+
+    tmpl->Set(isolate, "UNSIGNED_INT_10F_11F_11F_REV", v8::Uint32::New(isolate, 0x8C3B));
+    tmpl->Set(isolate, "UNSIGNED_INT_5_9_9_9_REV", v8::Uint32::New(isolate, 0x8C3E));
+    tmpl->Set(isolate, "FLOAT_32_UNSIGNED_INT_24_8_REV", v8::Uint32::New(isolate, 0x8DAD));
+    tmpl->Set(isolate, "UNSIGNED_INT_24_8", v8::Uint32::New(isolate, 0x84FA));
+    tmpl->Set(isolate, "HALF_FLOAT", v8::Uint32::New(isolate, 0x140B));
+
+
+    tmpl->Set(isolate, "RG", v8::Uint32::New(isolate, 0x8227));
+    tmpl->Set(isolate, "RG_INTEGER", v8::Uint32::New(isolate, 0x8228));
+    tmpl->Set(isolate, "INT_2_10_10_10_REV", v8::Uint32::New(isolate, 0x8D9F));
+    tmpl->Set(isolate, "QUERY_RESULT_AVAILABLE", v8::Uint32::New(isolate, 0x8865));
+    tmpl->Set(isolate, "QUERY_RESULT", v8::Uint32::New(isolate, 0x8866));
+
+
+    tmpl->Set(isolate, "CURRENT_QUERY", v8::Uint32::New(isolate, 0x8867));
+    tmpl->Set(isolate, "ANY_SAMPLES_PASSED", v8::Uint32::New(isolate, 0x8C2F));
+    tmpl->Set(isolate, "ANY_SAMPLES_PASSED_CONSERVATIVE", v8::Uint32::New(isolate, 0x8D6A));
+    tmpl->Set(isolate, "MAX_DRAW_BUFFERS", v8::Uint32::New(isolate, 0x8824));
+
+    tmpl->Set(isolate, "DRAW_BUFFER0", v8::Uint32::New(isolate, 0x8825));
+    tmpl->Set(isolate, "DRAW_BUFFER1", v8::Uint32::New(isolate, 0x8826));
+    tmpl->Set(isolate, "DRAW_BUFFER2", v8::Uint32::New(isolate, 0x8827));
+    tmpl->Set(isolate, "DRAW_BUFFER3", v8::Uint32::New(isolate, 0x8828));
+    tmpl->Set(isolate, "DRAW_BUFFER4", v8::Uint32::New(isolate, 0x8829));
+    tmpl->Set(isolate, "DRAW_BUFFER5", v8::Uint32::New(isolate, 0x882A));
+    tmpl->Set(isolate, "DRAW_BUFFER6", v8::Uint32::New(isolate, 0x882B));
+    tmpl->Set(isolate, "DRAW_BUFFER7", v8::Uint32::New(isolate, 0x882C));
+    tmpl->Set(isolate, "DRAW_BUFFER8", v8::Uint32::New(isolate, 0x882D));
+    tmpl->Set(isolate, "DRAW_BUFFER9", v8::Uint32::New(isolate, 0x882E));
+    tmpl->Set(isolate, "DRAW_BUFFER10", v8::Uint32::New(isolate, 0x882F));
+
+    /* Getting GL parameter information */
+
+    /* Textures */
+
+    tmpl->Set(isolate, "DRAW_BUFFER11", v8::Uint32::New(isolate, 0x8830));
+    tmpl->Set(isolate, "DRAW_BUFFER12", v8::Uint32::New(isolate, 0x8831));
+    tmpl->Set(isolate, "DRAW_BUFFER13", v8::Uint32::New(isolate, 0x8832));
+    tmpl->Set(isolate, "DRAW_BUFFER14", v8::Uint32::New(isolate, 0x8833));
+    tmpl->Set(isolate, "DRAW_BUFFER15", v8::Uint32::New(isolate, 0x8834));
+
+    tmpl->Set(isolate, "MAX_COLOR_ATTACHMENTS", v8::Uint32::New(isolate, 0x8CDF));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT1", v8::Uint32::New(isolate, 0x8CE1));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT2", v8::Uint32::New(isolate, 0x8CE2));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT3", v8::Uint32::New(isolate, 0x8CE3));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT4", v8::Uint32::New(isolate, 0x8CE4));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT5", v8::Uint32::New(isolate, 0x8CE5));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT6", v8::Uint32::New(isolate, 0x8CE6));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT7", v8::Uint32::New(isolate, 0x8CE7));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT8", v8::Uint32::New(isolate, 0x8CE8));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT9", v8::Uint32::New(isolate, 0x8CE9));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT10", v8::Uint32::New(isolate, 0x8CEA));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT11", v8::Uint32::New(isolate, 0x8CEB));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT12", v8::Uint32::New(isolate, 0x8CEC));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT13", v8::Uint32::New(isolate, 0x8CED));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT14", v8::Uint32::New(isolate, 0x8CEE));
+    tmpl->Set(isolate, "COLOR_ATTACHMENT15", v8::Uint32::New(isolate, 0x8CEF));
+
+    tmpl->Set(isolate, "SAMPLER_3D", v8::Uint32::New(isolate, 0x8B5F));
+    tmpl->Set(isolate, "SAMPLER_2D_SHADOW", v8::Uint32::New(isolate, 0x8B62));
+    tmpl->Set(isolate, "SAMPLER_2D_ARRAY", v8::Uint32::New(isolate, 0x8DC1));
+    tmpl->Set(isolate, "SAMPLER_2D_ARRAY_SHADOW", v8::Uint32::New(isolate, 0x8DC4));
+    tmpl->Set(isolate, "SAMPLER_CUBE_SHADOW", v8::Uint32::New(isolate, 0x8DC5));
+
+    tmpl->Set(isolate, "INT_SAMPLER_2D", v8::Uint32::New(isolate, 0x8DCA));
+    tmpl->Set(isolate, "INT_SAMPLER_3D", v8::Uint32::New(isolate, 0x8DCB));
+    tmpl->Set(isolate, "INT_SAMPLER_CUBE", v8::Uint32::New(isolate, 0x8DCC));
+    tmpl->Set(isolate, "INT_SAMPLER_2D_ARRAY", v8::Uint32::New(isolate, 0x8DCF));
+    tmpl->Set(isolate, "UNSIGNED_INT_SAMPLER_2D", v8::Uint32::New(isolate, 0x8DD2));
+
+    tmpl->Set(isolate, "UNSIGNED_INT_SAMPLER_3D", v8::Uint32::New(isolate, 0x8DD3));
+    tmpl->Set(isolate, "UNSIGNED_INT_SAMPLER_CUBE", v8::Uint32::New(isolate, 0x8DD4));
+    tmpl->Set(isolate, "UNSIGNED_INT_SAMPLER_2D_ARRAY", v8::Uint32::New(isolate, 0x8DD7));
+    tmpl->Set(isolate, "MAX_SAMPLES", v8::Uint32::New(isolate, 0x8D57));
+    tmpl->Set(isolate, "SAMPLER_BINDING", v8::Uint32::New(isolate, 0x8919));
+
+    tmpl->Set(isolate, "PIXEL_PACK_BUFFER", v8::Uint32::New(isolate, 0x88EB));
+    tmpl->Set(isolate, "PIXEL_UNPACK_BUFFER", v8::Uint32::New(isolate, 0x88EC));
+    tmpl->Set(isolate, "PIXEL_PACK_BUFFER_BINDING", v8::Uint32::New(isolate, 0x88ED));
+    tmpl->Set(isolate, "PIXEL_UNPACK_BUFFER_BINDING", v8::Uint32::New(isolate, 0x88EF));
+    tmpl->Set(isolate, "COPY_READ_BUFFER", v8::Uint32::New(isolate, 0x8F36));
+
+    tmpl->Set(isolate, "COPY_WRITE_BUFFER", v8::Uint32::New(isolate, 0x8F37));
+    tmpl->Set(isolate, "COPY_READ_BUFFER_BINDING", v8::Uint32::New(isolate, 0x8F36));
+    tmpl->Set(isolate, "COPY_WRITE_BUFFER_BINDING", v8::Uint32::New(isolate, 0x8F37));
+    tmpl->Set(isolate, "FLOAT_MAT2x3", v8::Uint32::New(isolate, 0x8B65));
+    tmpl->Set(isolate, "FLOAT_MAT2x4", v8::Uint32::New(isolate, 0x8B66));
+
+    tmpl->Set(isolate, "FLOAT_MAT3x2", v8::Uint32::New(isolate, 0x8B67));
+    tmpl->Set(isolate, "FLOAT_MAT3x4", v8::Uint32::New(isolate, 0x8B68));
+    tmpl->Set(isolate, "FLOAT_MAT4x2", v8::Uint32::New(isolate, 0x8B69));
+    tmpl->Set(isolate, "FLOAT_MAT4x3", v8::Uint32::New(isolate, 0x8B6A));
+    tmpl->Set(isolate, "UNSIGNED_INT_VEC2", v8::Uint32::New(isolate, 0x8DC6));
+
+    tmpl->Set(isolate, "UNSIGNED_INT_VEC3", v8::Uint32::New(isolate, 0x8DC7));
+    tmpl->Set(isolate, "UNSIGNED_INT_VEC4", v8::Uint32::New(isolate, 0x8DC8));
+    tmpl->Set(isolate, "UNSIGNED_NORMALIZED", v8::Uint32::New(isolate, 0x8C17));
+    tmpl->Set(isolate, "SIGNED_NORMALIZED", v8::Uint32::New(isolate, 0x8F9C));
+
+    /* Vertex attributes */
+
+    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_INTEGER", v8::Uint32::New(isolate, 0x88FD));
+    tmpl->Set(isolate, "VERTEX_ATTRIB_ARRAY_DIVISOR", v8::Uint32::New(isolate, 0x88FE));
+    tmpl->Set(isolate, "TRANSFORM_FEEDBACK_BUFFER_MODE", v8::Uint32::New(isolate, 0x8C7F));
+    tmpl->Set(isolate, "MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS",
+              v8::Uint32::New(isolate, 0x8C80));
+    tmpl->Set(isolate, "TRANSFORM_FEEDBACK_VARYINGS", v8::Uint32::New(isolate, 0x8C83));
+
+    tmpl->Set(isolate, "TRANSFORM_FEEDBACK_BUFFER_START", v8::Uint32::New(isolate, 0x8C84));
+    tmpl->Set(isolate, "TRANSFORM_FEEDBACK_BUFFER_SIZE", v8::Uint32::New(isolate, 0x8C85));
+    tmpl->Set(isolate, "TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN", v8::Uint32::New(isolate, 0x8C88));
+    tmpl->Set(isolate, "MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS",
+              v8::Uint32::New(isolate, 0x8C8A));
+
+    /* Textures */
+
+    /* Pixel types */
+
+    tmpl->Set(isolate, "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS", v8::Uint32::New(isolate, 0x8C8B));
+    tmpl->Set(isolate, "INTERLEAVED_ATTRIBS", v8::Uint32::New(isolate, 0x8C8C));
+    tmpl->Set(isolate, "SEPARATE_ATTRIBS", v8::Uint32::New(isolate, 0x8C8D));
+    tmpl->Set(isolate, "TRANSFORM_FEEDBACK_BUFFER", v8::Uint32::New(isolate, 0x8C8E));
+    tmpl->Set(isolate, "TRANSFORM_FEEDBACK_BUFFER_BINDING", v8::Uint32::New(isolate, 0x8C8F));
+
+    tmpl->Set(isolate, "TRANSFORM_FEEDBACK", v8::Uint32::New(isolate, 0x8E22));
+    tmpl->Set(isolate, "TRANSFORM_FEEDBACK_PAUSED", v8::Uint32::New(isolate, 0x8E23));
+    tmpl->Set(isolate, "TRANSFORM_FEEDBACK_ACTIVE", v8::Uint32::New(isolate, 0x8E24));
+    tmpl->Set(isolate, "TRANSFORM_FEEDBACK_BINDING", v8::Uint32::New(isolate, 0x8E25));
+
+    /* Pixel types */
+
+    /* Queries */
+
+    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING", v8::Uint32::New(isolate, 0x8210));
+    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE", v8::Uint32::New(isolate, 0x8211));
+    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_RED_SIZE", v8::Uint32::New(isolate, 0x8212));
+    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_GREEN_SIZE", v8::Uint32::New(isolate, 0x8213));
+    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_BLUE_SIZE", v8::Uint32::New(isolate, 0x8214));
+
+    /* Queries */
+
+    /* Draw buffers */
+
+    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE", v8::Uint32::New(isolate, 0x8215));
+    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE", v8::Uint32::New(isolate, 0x8216));
+    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE", v8::Uint32::New(isolate, 0x8217));
+    tmpl->Set(isolate, "FRAMEBUFFER_DEFAULT", v8::Uint32::New(isolate, 0x8218));
+    tmpl->Set(isolate, "DEPTH_STENCIL_ATTACHMENT", v8::Uint32::New(isolate, 0x821A));
+
+    tmpl->Set(isolate, "DEPTH_STENCIL", v8::Uint32::New(isolate, 0x84F9));
+    tmpl->Set(isolate, "DEPTH24_STENCIL8", v8::Uint32::New(isolate, 0x88F0));
+    tmpl->Set(isolate, "DRAW_FRAMEBUFFER_BINDING", v8::Uint32::New(isolate, 0x8CA6));
+    tmpl->Set(isolate, "READ_FRAMEBUFFER", v8::Uint32::New(isolate, 0x8CA8));
+    tmpl->Set(isolate, "DRAW_FRAMEBUFFER", v8::Uint32::New(isolate, 0x8CA9));
+
+    tmpl->Set(isolate, "READ_FRAMEBUFFER_BINDING", v8::Uint32::New(isolate, 0x8CAA));
+    tmpl->Set(isolate, "RENDERBUFFER_SAMPLES", v8::Uint32::New(isolate, 0x8CAB));
+    tmpl->Set(isolate, "FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER", v8::Uint32::New(isolate, 0x8CD4));
+    tmpl->Set(isolate, "FRAMEBUFFER_INCOMPLETE_MULTISAMPLE", v8::Uint32::New(isolate, 0x8D56));
+    tmpl->Set(isolate, "UNIFORM_BUFFER", v8::Uint32::New(isolate, 0x8A11));
+
+    tmpl->Set(isolate, "UNIFORM_BUFFER_BINDING", v8::Uint32::New(isolate, 0x8A28));
+    tmpl->Set(isolate, "UNIFORM_BUFFER_START", v8::Uint32::New(isolate, 0x8A29));
+    tmpl->Set(isolate, "UNIFORM_BUFFER_SIZE", v8::Uint32::New(isolate, 0x8A2A));
+    tmpl->Set(isolate, "MAX_VERTEX_UNIFORM_BLOCKS", v8::Uint32::New(isolate, 0x8A2B));
+    tmpl->Set(isolate, "MAX_FRAGMENT_UNIFORM_BLOCKS", v8::Uint32::New(isolate, 0x8A2D));
+
+    tmpl->Set(isolate, "MAX_COMBINED_UNIFORM_BLOCKS", v8::Uint32::New(isolate, 0x8A2E));
+    tmpl->Set(isolate, "MAX_UNIFORM_BUFFER_BINDINGS", v8::Uint32::New(isolate, 0x8A2F));
+    tmpl->Set(isolate, "MAX_UNIFORM_BLOCK_SIZE", v8::Uint32::New(isolate, 0x8A30));
+    tmpl->Set(isolate, "MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS", v8::Uint32::New(isolate, 0x8A31));
+    tmpl->Set(isolate, "MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS",
+              v8::Uint32::New(isolate, 0x8A33));
+
+    tmpl->Set(isolate, "UNIFORM_BUFFER_OFFSET_ALIGNMENT", v8::Uint32::New(isolate, 0x8A34));
+    tmpl->Set(isolate, "ACTIVE_UNIFORM_BLOCKS", v8::Uint32::New(isolate, 0x8A36));
+    tmpl->Set(isolate, "UNIFORM_TYPE", v8::Uint32::New(isolate, 0x8A37));
+    tmpl->Set(isolate, "UNIFORM_SIZE", v8::Uint32::New(isolate, 0x8A38));
+    tmpl->Set(isolate, "UNIFORM_BLOCK_INDEX", v8::Uint32::New(isolate, 0x8A3A));
+
+    tmpl->Set(isolate, "UNIFORM_OFFSET", v8::Uint32::New(isolate, 0x8A3B));
+    tmpl->Set(isolate, "UNIFORM_ARRAY_STRIDE", v8::Uint32::New(isolate, 0x8A3C));
+    tmpl->Set(isolate, "UNIFORM_MATRIX_STRIDE", v8::Uint32::New(isolate, 0x8A3D));
+
+    /* Draw buffers */
+
+    /* Samplers */
+
+    tmpl->Set(isolate, "UNIFORM_IS_ROW_MAJOR", v8::Uint32::New(isolate, 0x8A3E));
+    tmpl->Set(isolate, "UNIFORM_BLOCK_BINDING", v8::Uint32::New(isolate, 0x8A3F));
+    tmpl->Set(isolate, "UNIFORM_BLOCK_DATA_SIZE", v8::Uint32::New(isolate, 0x8A40));
+    tmpl->Set(isolate, "UNIFORM_BLOCK_ACTIVE_UNIFORMS", v8::Uint32::New(isolate, 0x8A42));
+    tmpl->Set(isolate, "UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES", v8::Uint32::New(isolate, 0x8A43));
+
+    tmpl->Set(isolate, "UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER",
+              v8::Uint32::New(isolate, 0x8A44));
+    tmpl->Set(isolate, "UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER",
+              v8::Uint32::New(isolate, 0x8A46));
+    tmpl->Set(isolate, "OBJECT_TYPE", v8::Uint32::New(isolate, 0x9112));
+    tmpl->Set(isolate, "SYNC_CONDITION", v8::Uint32::New(isolate, 0x9113));
+    tmpl->Set(isolate, "SYNC_STATUS", v8::Uint32::New(isolate, 0x9114));
+
+    tmpl->Set(isolate, "SYNC_FLAGS", v8::Uint32::New(isolate, 0x9115));
+    tmpl->Set(isolate, "SYNC_FENCE", v8::Uint32::New(isolate, 0x9116));
+    tmpl->Set(isolate, "SYNC_GPU_COMMANDS_COMPLETE", v8::Uint32::New(isolate, 0x9117));
+    tmpl->Set(isolate, "UNSIGNALED", v8::Uint32::New(isolate, 0x9118));
+    tmpl->Set(isolate, "SIGNALED", v8::Uint32::New(isolate, 0x9119));
+
+    /* Samplers */
+
+    /* Buffers */
+
+    tmpl->Set(isolate, "ALREADY_SIGNALED", v8::Uint32::New(isolate, 0x911A));
+    tmpl->Set(isolate, "TIMEOUT_EXPIRED", v8::Uint32::New(isolate, 0x911B));
+    tmpl->Set(isolate, "CONDITION_SATISFIED", v8::Uint32::New(isolate, 0x911C));
+    tmpl->Set(isolate, "WAIT_FAILED", v8::Uint32::New(isolate, 0x911D));
+    tmpl->Set(isolate, "SYNC_FLUSH_COMMANDS_BIT", v8::Uint32::New(isolate, 0x00000001));
+
+    tmpl->Set(isolate, "COLOR", v8::Uint32::New(isolate, 0x1800));
+    tmpl->Set(isolate, "DEPTH", v8::Uint32::New(isolate, 0x1801));
+    tmpl->Set(isolate, "STENCIL", v8::Uint32::New(isolate, 0x1802));
+
+    /* Buffers */
+
+    /* Data types */
+
+    tmpl->Set(isolate, "MIN", v8::Uint32::New(isolate, 0x8007));
+    tmpl->Set(isolate, "MAX", v8::Uint32::New(isolate, 0x8008));
+    tmpl->Set(isolate, "DEPTH_COMPONENT24", v8::Uint32::New(isolate, 0x81A6));
+    tmpl->Set(isolate, "STREAM_READ", v8::Uint32::New(isolate, 0x88E1));
+    tmpl->Set(isolate, "STREAM_COPY", v8::Uint32::New(isolate, 0x88E2));
+
+    tmpl->Set(isolate, "STATIC_READ", v8::Uint32::New(isolate, 0x88E5));
+    tmpl->Set(isolate, "STATIC_COPY", v8::Uint32::New(isolate, 0x88E6));
+    tmpl->Set(isolate, "DYNAMIC_READ", v8::Uint32::New(isolate, 0x88E9));
+    tmpl->Set(isolate, "DYNAMIC_COPY", v8::Uint32::New(isolate, 0x88EA));
+    tmpl->Set(isolate, "DEPTH_COMPONENT32F", v8::Uint32::New(isolate, 0x8CAC));
+    tmpl->Set(isolate, "DEPTH32F_STENCIL8", v8::Uint32::New(isolate, 0x8CAD));
+
+    /* Data types */
+
+    tmpl->Set(isolate, "INVALID_INDEX", v8::Number::New(isolate, (double) 0xFFFFFFFF));
+    tmpl->Set(isolate, "TIMEOUT_IGNORED", v8::Int32::New(isolate, -1));
+
+    /* Vertex attributes */
+
+    /* Transform feedback */
+
+    tmpl->Set(isolate, "MAX_CLIENT_WAIT_TIMEOUT_WEBGL", v8::Uint32::New(isolate, 0x9247));
+
+    /* Transform feedback */
+
+}
diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGL2RenderingContext.h b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGL2RenderingContext.h
index 93c8c95e..f4a0c49b 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGL2RenderingContext.h
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGL2RenderingContext.h
@@ -34,9 +34,190 @@ class WebGL2RenderingContext : public WebGLRenderingContext {
 
     WebGL2RenderingContext(rust::Box<WebGLState> state, WebGLRenderingVersion version);
 
-    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static WebGL2RenderingContext *GetPointer(const v8::Local<v8::Object> &object);
+
+    static void SetConstants(v8::Isolate *isolate, const v8::Local<v8::ObjectTemplate> &tmpl);
+
+    static void
+    SetProps(v8::Isolate *isolate, const v8::Local<v8::ObjectTemplate> &webgl2RenderingContextTpl);
+
+    static void SetMethods(v8::Isolate *isolate,
+                           const v8::Local<v8::ObjectTemplate> &webgl2RenderingContextTpl);
+
+    static void BeginQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BeginTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindBufferBase(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindBufferRange(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindSampler(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BlitFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearBufferfi(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearBufferfv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearBufferiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearBufferuiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClientWaitSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CompressedTexSubImage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CopyBufferSubData(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CopyTexSubImage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateSampler(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteSampler(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawArraysInstanced(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawBuffers(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawElementsInstanced(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawRangeElements(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void EndQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void EndTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FenceSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FramebufferTextureLayer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetActiveUniformBlockName(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetActiveUniformBlockParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetActiveUniforms(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetBufferSubData(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetFragDataLocation(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetIndexedParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetInternalformatParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetQueryParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetSamplerParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetSyncParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetTransformFeedbackVarying(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetUniformBlockIndex(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetUniformIndices(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void InvalidateFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void InvalidateSubFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsSampler(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void PauseTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ReadBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void RenderbufferStorageMultisample(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ResumeTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SamplerParameterf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SamplerParameteri(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexImage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexStorage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexStorage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexSubImage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TransformFeedbackVaryings(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform1ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform1uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform2ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform2uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform3ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform3uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform4ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform4uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformBlockBinding(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix2x3fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix2x4fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix3x2fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix3x4fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix4x2fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix4x3fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttribDivisor(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttribI4i(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttribI4iv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttribI4ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttribI4uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
 
-    jsi::Value get(jsi::Runtime &, const jsi::PropNameID &name) override;
 
     static inline jsi::Value GetProperty(const std::string &methodName) {
         if (methodName == "READ_BUFFER") { return {0x0C02}; }
diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLQuery.h b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLQuery.h
index 7c59c0d2..505bc522 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLQuery.h
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLQuery.h
@@ -29,6 +29,17 @@ class WebGLQuery {
         return ctorTmpl;
     }
 
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLQuery *query) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLQuery::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLQuery);
+        auto ext = v8::External::New(isolate, query);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
     static WebGLQuery *GetPointer(const v8::Local<v8::Object> &object) {
         auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
         if (ptr == nullptr) {
diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLSampler.h b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLSampler.h
index 34a6af07..da06d02d 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLSampler.h
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLSampler.h
@@ -31,6 +31,17 @@ class WebGLSampler {
         return ctorTmpl;
     }
 
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLSampler *sampler) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLSampler::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLSampler);
+        auto ext = v8::External::New(isolate, sampler);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
     static WebGLSampler *GetPointer(const v8::Local<v8::Object> &object) {
         auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
         if (ptr == nullptr) {
diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLSyncImpl.h b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLSyncImpl.h
index 67a48909..60342947 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLSyncImpl.h
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLSyncImpl.h
@@ -34,6 +34,17 @@ class WebGLSyncImpl {
         return ctorTmpl;
     }
 
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLSyncImpl *sync) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLSyncImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLSync);
+        auto ext = v8::External::New(isolate, sync);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
     static WebGLSyncImpl *GetPointer(const v8::Local<v8::Object> &object) {
         auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
         if (ptr == nullptr) {
diff --git a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLTransformFeedback.h b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLTransformFeedback.h
index 11f1c44d..8c557da3 100644
--- a/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLTransformFeedback.h
+++ b/packages/canvas/src-native/canvas-android/canvas/src/main/cpp/webgl2/WebGLTransformFeedback.h
@@ -30,6 +30,18 @@ class WebGLTransformFeedback {
         return ctorTmpl;
     }
 
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WebGLTransformFeedback *feedback) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLTransformFeedback::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLTransformFeedback);
+        auto ext = v8::External::New(isolate, feedback);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
     static WebGLTransformFeedback *GetPointer(const v8::Local<v8::Object> &object) {
         auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
         if (ptr == nullptr) {