@nativescript/canvas 2.0.0-beta.9 → 2.0.0-rc.0

package/platforms/ios/src/cpp/CanvasJSIModule.cpp

@@ -7,7 +7,121 @@
 #include "JSIRuntime.h"
 #include "JSIReadFileCallback.h"
 #include "Helpers.h"
-#include "PerIsolateData.h"
+
+struct GLOptions {
+    int32_t version;
+    bool alpha;
+    bool antialias;
+    bool depth;
+    bool failIfMajorPerformanceCaveat;
+    int32_t powerPreference;
+    bool premultipliedAlpha;
+    bool preserveDrawingBuffer;
+    bool stencil;
+    bool desynchronized;
+    bool xrCompatible;
+
+public:
+    GLOptions() {
+        this->version = 0;
+        this->alpha = true;
+        this->antialias = true;
+        this->depth = true;
+        this->failIfMajorPerformanceCaveat = false;
+        this->powerPreference = 0;
+        this->premultipliedAlpha = true;
+        this->preserveDrawingBuffer = false;
+        this->stencil = false;
+        this->desynchronized = false;
+        this->xrCompatible = false;
+    }
+
+    void parseGLOptions(const v8::FunctionCallbackInfo<v8::Value> &args) {
+        auto configValue = args[0];
+
+        if (!(!configValue->IsNullOrUndefined() && configValue->IsObject())) {
+            return;
+        }
+
+        auto isolate = args.GetIsolate();
+        auto context = isolate->GetCurrentContext();
+        auto config = configValue.As<v8::Object>();
+
+        v8::Local<v8::Value> versionValue;
+
+        config->Get(context, ConvertToV8String(isolate, "version")).ToLocal(&versionValue);
+
+        if (!versionValue.IsEmpty() && versionValue->IsInt32()) {
+            versionValue->Int32Value(context).To(&this->version);
+        }
+
+        v8::Local<v8::Value> alphaValue;
+
+        config->Get(context, ConvertToV8String(isolate, "alpha")).ToLocal(&alphaValue);
+        if (!alphaValue.IsEmpty() && alphaValue->IsBoolean()) {
+            this->alpha = alphaValue->BooleanValue(isolate);
+        }
+
+        v8::Local<v8::Value> antialiasValue;
+        config->Get(context, ConvertToV8String(isolate, "antialias")).ToLocal(
+                &antialiasValue);
+        if (!antialiasValue.IsEmpty() && antialiasValue->IsBoolean()) {
+            this->antialias = antialiasValue->BooleanValue(isolate);
+        }
+
+        v8::Local<v8::Value> failIfMajorPerformanceCaveatValue;
+        config->Get(context, ConvertToV8String(isolate, "failIfMajorPerformanceCaveat")).ToLocal(
+                &failIfMajorPerformanceCaveatValue);
+        if (!failIfMajorPerformanceCaveatValue.IsEmpty() &&
+            failIfMajorPerformanceCaveatValue->IsBoolean()) {
+            this->failIfMajorPerformanceCaveat = failIfMajorPerformanceCaveatValue->BooleanValue(
+                    isolate);
+        }
+
+        v8::Local<v8::Value> powerPreferenceValue;
+        config->Get(context, ConvertToV8String(isolate, "powerPreference")).ToLocal(
+                &powerPreferenceValue);
+        if (!powerPreferenceValue.IsEmpty() && powerPreferenceValue->IsInt32()) {
+            powerPreferenceValue->Int32Value(context).To(&this->powerPreference);
+        }
+
+        v8::Local<v8::Value> premultipliedAlphaValue;
+        config->Get(context,
+                    ConvertToV8String(isolate, "premultipliedAlpha")).ToLocal(
+                &premultipliedAlphaValue);
+        if (!premultipliedAlphaValue.IsEmpty() && premultipliedAlphaValue->IsBoolean()) {
+            this->premultipliedAlpha = premultipliedAlphaValue->BooleanValue(isolate);
+        }
+
+        v8::Local<v8::Value> preserveDrawingBufferValue;
+        config->Get(context,
+                    ConvertToV8String(isolate, "preserveDrawingBuffer")).ToLocal(
+                &preserveDrawingBufferValue);
+        if (!preserveDrawingBufferValue.IsEmpty() && preserveDrawingBufferValue->IsBoolean()) {
+            this->preserveDrawingBuffer = preserveDrawingBufferValue->BooleanValue(isolate);
+        }
+
+        v8::Local<v8::Value> stencilValue;
+        config->Get(context, ConvertToV8String(isolate, "stencil")).ToLocal(&stencilValue);
+        if (!stencilValue.IsEmpty() && stencilValue->IsBoolean()) {
+            this->stencil = stencilValue->BooleanValue(isolate);
+        }
+
+        v8::Local<v8::Value> desynchronizedValue;
+        config->Get(context, ConvertToV8String(isolate, "desynchronized")).ToLocal(
+                &desynchronizedValue);
+        if (!desynchronizedValue.IsEmpty() && desynchronizedValue->IsBoolean()) {
+            this->desynchronized = desynchronizedValue->BooleanValue(isolate);
+        }
+
+        v8::Local<v8::Value> xrCompatibleValue;
+        config->Get(context, ConvertToV8String(isolate, "xrCompatible")).ToLocal(
+                &xrCompatibleValue);
+        if (!xrCompatibleValue.IsEmpty() && xrCompatibleValue->IsBoolean()) {
+            this->xrCompatible = xrCompatibleValue->BooleanValue(isolate);
+        }
+    }
+};
 
 void CanvasJSIModule::install(v8::Isolate *isolate) {
 
@@ -31,51 +145,66 @@ void CanvasJSIModule::install(v8::Isolate *isolate) {
         Path2D::Init(canvasMod, isolate);
         ImageDataImpl::Init(canvasMod, isolate);
         ImageAssetImpl::Init(canvasMod, isolate);
+        ImageBitmapImpl::Init(canvasMod, isolate);
         CanvasGradient::Init(canvasMod, isolate);
         CanvasPattern::Init(canvasMod, isolate);
         MatrixImpl::Init(canvasMod, isolate);
         TextMetricsImpl::Init(canvasMod, isolate);
-        URLImpl::Init(canvasMod, isolate);
 
-        // always use the last slot
-        auto lastSlot = isolate->GetNumberOfDataSlots() - 1;
-        auto data = new PerIsolateData(isolate);
-        isolate->SetData(lastSlot, data);
 
-        v8Global->Set(context, ConvertToV8String(isolate, "CanvasModule"), canvasMod);
+        GPUImpl::Init(canvasMod, isolate);
+        GPUSupportedLimitsImpl::Init(canvasMod, isolate);
+        GPUDeviceImpl::Init(canvasMod, isolate);
+        GPUQueueImpl::Init(canvasMod, isolate);
+
+        v8Global->Set(context, ConvertToV8String(isolate, "CanvasModule"), canvasMod).FromJust();
         canvasMod->Set(context, ConvertToV8String(isolate, "create2DContext"),
                        v8::FunctionTemplate::New(isolate, &Create2DContext)->GetFunction(
-                               context).ToLocalChecked());
+                               context).ToLocalChecked()).FromJust();
         canvasMod->Set(context, ConvertToV8String(isolate, "createImageBitmap"),
                        v8::FunctionTemplate::New(isolate, &CreateImageBitmap)->GetFunction(
-                               context).ToLocalChecked());
+                               context).ToLocalChecked()).FromJust();
         canvasMod->Set(context, ConvertToV8String(isolate, "create2DContextWithPointer"),
                        v8::FunctionTemplate::New(isolate, &Create2DContextWithPointer)->GetFunction(
-                               context).ToLocalChecked());
+                               context).ToLocalChecked()).FromJust();
+
+        canvasMod->Set(context, ConvertToV8String(isolate, "createWebGPUContextWithPointer"),
+                       v8::FunctionTemplate::New(isolate,
+                                                 &CreateWebGPUContextWithPointer)->GetFunction(
+                               context).ToLocalChecked()).FromJust();
+
+
         canvasMod->Set(context, ConvertToV8String(isolate, "readFile"),
                        v8::FunctionTemplate::New(isolate, &ReadFile)->GetFunction(
-                               context).ToLocalChecked());
+                               context).ToLocalChecked()).FromJust();
+
+        canvasMod->Set(context, ConvertToV8String(isolate, "getMime"),
+                       v8::FunctionTemplate::New(isolate, &GetMime)->GetFunction(
+                               context).ToLocalChecked()).FromJust();
 
         canvasMod->Set(context, ConvertToV8String(isolate, "createWebGLContext"),
                        v8::FunctionTemplate::New(isolate, &CreateWebGLContext)->GetFunction(
-                               context).ToLocalChecked());
+                               context).ToLocalChecked()).FromJust();
 
         canvasMod->Set(context, ConvertToV8String(isolate, "createWebGL2Context"),
                        v8::FunctionTemplate::New(isolate, &CreateWebGL2Context)->GetFunction(
-                               context).ToLocalChecked());
+                               context).ToLocalChecked()).FromJust();
 
 
         canvasMod->Set(context, ConvertToV8String(isolate, "__addFontFamily"),
                        v8::FunctionTemplate::New(isolate, &AddFontFamily)->GetFunction(
-                               context).ToLocalChecked());
+                               context).ToLocalChecked()).FromJust();
+
+        canvasMod->Set(context, ConvertToV8String(isolate, "__addFontData"),
+                       v8::FunctionTemplate::New(isolate, &AddFontData)->GetFunction(
+                               context).ToLocalChecked()).FromJust();
 
         global->Set(context,
-                    ConvertToV8String(isolate, "CanvasModule"), canvasMod);
+                    ConvertToV8String(isolate, "CanvasModule"), canvasMod).FromJust();
 
     }
 }
 
-
 void CanvasJSIModule::AddFontFamily(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
@@ -107,23 +236,55 @@ void CanvasJSIModule::AddFontFamily(const v8::FunctionCallbackInfo<v8::Value> &a
 
 }
 
+void CanvasJSIModule::AddFontData(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    auto aliasValue = args[0];
+    auto dataValue = args[1];
+
+    // todo improve
+    if (dataValue->IsArrayBuffer()) {
+
+        if (aliasValue->IsString()) {
+            auto alias = ConvertFromV8String(isolate, aliasValue);
+            auto data = dataValue.As<v8::ArrayBuffer>();
+            auto store = data->GetBackingStore();
+            canvas_native_font_add_family_with_bytes(alias.c_str(), (uint8_t *) store->Data(),
+                                                     store->ByteLength());
+        } else {
+            auto data = dataValue.As<v8::ArrayBuffer>();
+            auto store = data->GetBackingStore();
+            canvas_native_font_add_family_with_bytes(nullptr, (uint8_t *) store->Data(),
+                                                     store->ByteLength());
+        }
+
+    } else if (dataValue->IsTypedArray()) {
+
+        if (aliasValue->IsString()) {
+            auto alias = ConvertFromV8String(isolate, aliasValue);
+            auto data = dataValue.As<v8::TypedArray>();
+            auto buffer = data->Buffer();
+            auto store = buffer->GetBackingStore();
+            canvas_native_font_add_family_with_bytes(alias.c_str(), (uint8_t *) store->Data(),
+                                                     store->ByteLength());
+        } else {
+            auto data = dataValue.As<v8::TypedArray>();
+            auto buffer = data->Buffer();
+            auto store = buffer->GetBackingStore();
+            canvas_native_font_add_family_with_bytes(nullptr, (uint8_t *) store->Data(),
+                                                     store->ByteLength());
+        }
+
+    }
+
+}
+
 void CanvasJSIModule::Create2DContext(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
     auto ptr = args[0].As<v8::BigInt>()->Int64Value();
-    auto width = (float) args[1]->NumberValue(context).ToChecked();
-    auto height = (float) args[2]->NumberValue(context).ToChecked();
-    auto density = (float) args[3]->NumberValue(context).ToChecked();
-    auto samples = (int) args[4]->NumberValue(context).ToChecked();
-    auto alpha = (bool) args[5]->BooleanValue(isolate);
-    auto font_color = (int) args[6]->NumberValue(context).ToChecked();
-    auto ppi = (float) args[7]->NumberValue(context).ToChecked();
-    auto direction = (int) args[8]->NumberValue(context).ToChecked();
-
-    auto context_2d = canvas_native_context_create_gl(width, height, density,
-                                                      ptr,
-                                                      samples, alpha,
-                                                      font_color, ppi, direction);
+
+    auto context_2d = static_cast<CanvasRenderingContext2D *>((void *) ptr);
 
     auto ret = CanvasRenderingContext2DImpl::NewInstance(isolate, new CanvasRenderingContext2DImpl(
             context_2d));
@@ -131,6 +292,32 @@ void CanvasJSIModule::Create2DContext(const v8::FunctionCallbackInfo<v8::Value>
     args.GetReturnValue().Set(ret);
 }
 
+
+struct Rect {
+    float x;
+    float y;
+    float width;
+    float height;
+};
+
+struct ImageBitmapData {
+    char *error_;
+    const ImageAsset *asset_;
+    bool done_;
+    v8::Isolate *isolate_;
+    std::shared_ptr<v8::Persistent<v8::ArrayBufferView>> data_;
+
+    ~ImageBitmapData() {
+        if (error_ != nullptr) {
+            canvas_native_string_destroy(error_);
+            error_ = nullptr;
+        }
+
+        data_->Reset();
+    }
+};
+
+
 void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto count = args.Length();
     auto isolate = args.GetIsolate();
@@ -165,7 +352,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
 
     if (image->IsNullOrUndefined()) {
         v8::Local<v8::Value> ret[2] = {ConvertToV8String(isolate, "Failed to load image"),
-                                       v8::Undefined(isolate)};
+                                       v8::Null(isolate)};
 
         cb.As<v8::Function>()->Call(context, context->Global(), 2, ret);
         return;
@@ -175,7 +362,7 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
 
         v8::Local<v8::Value> ret[2] = {ConvertToV8String(isolate,
                                                          "Failed to execute 'createImageBitmap' : The crop rect width is 0"),
-                                       v8::Undefined(isolate)};
+                                       v8::Null(isolate)};
 
         cb.As<v8::Function>()->Call(context, context->Global(), 2, ret);
 
@@ -184,630 +371,140 @@ void CanvasJSIModule::CreateImageBitmap(const v8::FunctionCallbackInfo<v8::Value
     if (len >= 5 && (sh->IsNumber() && sh->IsNumber() == 0)) {
         v8::Local<v8::Value> ret[2] = {ConvertToV8String(isolate,
                                                          "Failed to execute 'createImageBitmap' : The crop rect height is 0"),
-                                       v8::Undefined(isolate)};
+                                       v8::Null(isolate)};
 
         cb.As<v8::Function>()->Call(context, context->Global(), 2, ret);
         return;
     }
 
-
     if (image->IsObject()) {
         auto imageObject = image.As<v8::Object>();
         auto isArrayBuffer = imageObject->IsArrayBuffer();
         auto IsArrayBufferView = imageObject->IsArrayBufferView();
-        if (isArrayBuffer || IsArrayBufferView) {
+        std::optional<Rect> rect = std::nullopt;
 
-            if (len == 1 || len == 2) {
+        if (isArrayBuffer || IsArrayBufferView) {
+            if ((len == 1 || len == 2) || (len == 5 || len == 6)) {
                 if (len == 2) {
                     options = ImageBitmapImpl::HandleOptions(isolate, args[1]);
                 }
 
-                auto asset = canvas_native_image_asset_create();
-
-                auto shared_asset = canvas_native_image_asset_shared_clone(asset);
-
-                auto ret = new ImageBitmapImpl(asset);
-
+                if (len == 6) {
+                    options = ImageBitmapImpl::HandleOptions(isolate, args[5]);
+                }
 
                 auto cbFunc = args[count - 1].As<v8::Function>();
-                auto data = v8::External::New(isolate, ret);
-
-                auto jsi_callback = new JSICallback(isolate, cbFunc, data);
-
-
-#ifdef __ANDROID__
-                ALooper_addFd(jsi_callback->looper_,
-                              jsi_callback->fd_[0],
-                              ALOOPER_POLL_CALLBACK,
-                              ALOOPER_EVENT_INPUT,
-                              [](int fd, int events,
-                                 void *data) {
-                                  auto cb = static_cast<JSICallback *>(data);
-                                  bool done;
-                                  read(fd, &done,
-                                       sizeof(bool));
-
-
-                                  v8::Isolate *isolate = cb->isolate_;
-                                  v8::Locker locker(isolate);
-                                  v8::Isolate::Scope isolate_scope(isolate);
-                                  v8::HandleScope handle_scope(isolate);
-                                  v8::Local<v8::Function> callback = cb->callback_->Get(isolate);
-                                  v8::Local<v8::External> cbData = cb->data_->Get(
-                                          isolate).As<v8::External>();
-                                  v8::Local<v8::Context> context = callback->GetCreationContextChecked();
-                                  v8::Context::Scope context_scope(context);
-
-                                  auto ret = ImageBitmapImpl::NewInstance(isolate, cbData);
-
-                                  v8::Local<v8::Value> args[2];
-
-                                  if (done) {
-                                      args[0] = v8::Null(isolate);
-                                      args[1] = ret;
-
-                                  } else {
-                                      args[0] = v8::Exception::Error(
-                                              ConvertToV8String(isolate, "Failed to load image"));
-                                      args[1] = v8::Null(isolate);
-                                  }
-
-
-                                  callback->Call(context, context->Global(), 2, args);
-
-                                  delete static_cast<JSICallback *>(data);
-                                  return 0;
-                              }, jsi_callback);
-
-                ALooper_wake(jsi_callback->looper_);
 
                 if (isArrayBuffer) {
                     auto arrayBuffer = imageObject.As<v8::ArrayBuffer>();
-                    auto store = arrayBuffer->GetBackingStore();
-                    auto dataBuffer = (uint8_t *) store->Data();
-                    v8::Global<v8::ArrayBuffer> ab(isolate, arrayBuffer);
-                    std::thread thread(
-                            [&dataBuffer, jsi_callback, &options, store, shared_asset](
-                                    v8::Global<v8::ArrayBuffer> ab, size_t size) {
-
-
-                                auto done = canvas_native_image_bitmap_create_from_encoded_bytes_with_output(
-                                        dataBuffer, size,
-                                        options.flipY,
-                                        options.premultiplyAlpha,
-                                        options.colorSpaceConversion,
-                                        options.resizeQuality,
-                                        options.resizeWidth,
-                                        options.resizeHeight,
-                                        shared_asset);
-
-                                canvas_native_image_asset_destroy(shared_asset);
-
-                                write(jsi_callback->fd_[1],
-                                      &done,
-                                      sizeof(bool));
-
-
-                            }, std::move(ab), arrayBuffer->ByteLength());
-
-                    thread.detach();
-                    return;
+                    auto size = arrayBuffer->ByteLength();
+                    imageObject = v8::Uint8Array::New(arrayBuffer, 0, size);
                 }
 
-
                 auto ta = imageObject.As<v8::ArrayBufferView>();
 
+                auto image_bitmap_async_data = new ImageBitmapData();
+                image_bitmap_async_data->isolate_ = isolate;
+                image_bitmap_async_data->data_ = std::make_shared<v8::Persistent<v8::ArrayBufferView>>(
+                        isolate, ta);
 
-                auto array = ta->Buffer();
-                auto offset = ta->ByteOffset();
-                auto size = ta->ByteLength();
-                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
-
-
-                v8::Global<v8::ArrayBufferView> ab(isolate, ta);
-
-                std::thread thread(
-                        [jsi_callback, &options, shared_asset, data_ptr, size](
-                                v8::Global<v8::ArrayBufferView> ab) {
-
-                            auto done = canvas_native_image_bitmap_create_from_encoded_bytes_with_output(
-                                    data_ptr, size,
-                                    options.flipY,
-                                    options.premultiplyAlpha,
-                                    options.colorSpaceConversion,
-                                    options.resizeQuality,
-                                    options.resizeWidth,
-                                    options.resizeHeight,
-                                    shared_asset);
-
-                            canvas_native_image_asset_destroy(shared_asset);
-
-                            write(jsi_callback->fd_[1],
-                                  &done,
-                                  sizeof(bool));
-
-
-                        }, std::move(ab));
-                thread.detach();
-
-#endif
-
-
-#ifdef __APPLE__
-
-                auto current_queue = new NSOperationQueueWrapper(true);
-
-
-                if (isArrayBuffer) {
-                    auto arrayBuffer = imageObject.As<v8::ArrayBuffer>();
-                    auto store = arrayBuffer->GetBackingStore();
-                    auto dataBuffer = (uint8_t *) store->Data();
-                    v8::Global<v8::ArrayBuffer> ab(isolate, arrayBuffer);
-
-                    std::thread thread(
-                            [&dataBuffer, jsi_callback, &options, store, shared_asset, current_queue](
-                                    v8::Global<v8::ArrayBuffer> ab, size_t size
-                            ) {
-
-                                auto done = canvas_native_image_bitmap_create_from_encoded_bytes_with_output(
-                                        dataBuffer, size,
-                                        options.flipY,
-                                        options.premultiplyAlpha,
-                                        options.colorSpaceConversion,
-                                        options.resizeQuality,
-                                        options.resizeWidth,
-                                        options.resizeHeight,
-                                        shared_asset);
-
-                                canvas_native_image_asset_destroy(shared_asset);
-
-
-                                auto main_task = [jsi_callback, current_queue, done]() {
-
+                auto callback = new AsyncCallback(isolate, cbFunc, [](bool done, void *data) {
+                    if (data == nullptr) { return; }
+                    auto async_data = static_cast<AsyncCallback *>(data);
+                    auto func = async_data->inner_.get();
+                    if (func != nullptr && func->isolate_ != nullptr) {
+                        v8::Isolate *isolate = func->isolate_;
+                        v8::Locker locker(isolate);
+                        v8::Isolate::Scope isolate_scope(isolate);
+                        v8::HandleScope handle_scope(isolate);
+                        v8::Local<v8::Function> callback = func->callback_.Get(
+                                isolate);
+                        v8::Local<v8::Context> context = callback->GetCreationContextChecked();
+                        v8::Context::Scope context_scope(context);
 
-                                    v8::Isolate *isolate = jsi_callback->isolate_;
-                                    v8::Locker locker(isolate);
-                                    v8::Isolate::Scope isolate_scope(isolate);
-                                    v8::HandleScope handle_scope(isolate);
-                                    v8::Local<v8::Function> callback = jsi_callback->callback_->Get(isolate);
-                                    v8::Local<v8::External> cbData = jsi_callback->data_->Get(
-                                            isolate).As<v8::External>();
-                                    v8::Local<v8::Context> context = callback->GetCreationContextChecked();
-                                    v8::Context::Scope context_scope(context);
+                        if (func->data != nullptr) {
+                            auto asset_data = static_cast<ImageBitmapData *>(func->data);
 
-                                    auto ret = ImageBitmapImpl::NewInstance(isolate, cbData);
+                            auto bitmap = new ImageBitmapImpl(asset_data->asset_);
+                            auto external = v8::External::New(isolate, bitmap);
 
-                                    v8::Local<v8::Value> args[2];
+                            auto ret = ImageBitmapImpl::NewInstance(isolate, external);
 
-                                    if (done) {
-                                        args[0] = v8::Null(isolate);
-                                        args[1] = ret;
+                            v8::Local<v8::Value> args[2] = {
+                                    v8::Null(isolate), ret};
 
-                                    } else {
-                                        args[0] = v8::Exception::Error(
-                                                ConvertToV8String(isolate, "Failed to load image"));
-                                        args[1] = v8::Null(isolate);
-                                    }
 
+                            callback->Call(context, context->Global(),
+                                           2,
+                                           args);  // ignore JS return value
 
-                                    callback->Call(context, context->Global(), 2, args);
+                            delete asset_data;
 
+                        } else {
+                            v8::Local<v8::Value> args[1] = {
+                                    v8::Null(isolate)};
 
-                                    delete jsi_callback;
-                                    delete current_queue;
-
-                                };
-                                current_queue->addOperation(main_task);
-
-                            }, std::move(ab), arrayBuffer->ByteLength());
-
-                    thread.detach();
-
-                    return;
-                }
-
-                auto ta = imageObject.As<v8::ArrayBufferView>();
+                            callback->Call(context, context->Global(),
+                                           1,
+                                           args);  // ignore JS return value
+                        }
 
+                    }
+                    delete static_cast<AsyncCallback *>(data);
+                });
 
-                auto array = ta->Buffer();
+                callback->inner_->data = image_bitmap_async_data;
+                callback->prepare();
+                auto store = ta->Buffer()->GetBackingStore();
                 auto offset = ta->ByteOffset();
-                auto size = ta->ByteLength();
-                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
-
-
-                v8::Global<v8::ArrayBufferView> ab(isolate, ta);
-
 
                 std::thread thread(
-                        [jsi_callback, &options, shared_asset, data_ptr, size, current_queue](
-                                v8::Global<v8::ArrayBufferView> ab
-                        ) {
-
-                            auto done = canvas_native_image_bitmap_create_from_encoded_bytes_with_output(
-                                    data_ptr, size,
-                                    options.flipY,
-                                    options.premultiplyAlpha,
-                                    options.colorSpaceConversion,
-                                    options.resizeQuality,
-                                    options.resizeWidth,
-                                    options.resizeHeight,
-                                    shared_asset);
-
-                            canvas_native_image_asset_destroy(shared_asset);
-
-                            auto main_task = [jsi_callback, current_queue, done]() {
-
-
-                                v8::Isolate *isolate = jsi_callback->isolate_;
-                                v8::Locker locker(isolate);
-                                v8::Isolate::Scope isolate_scope(isolate);
-                                v8::HandleScope handle_scope(isolate);
-                                v8::Local<v8::Function> callback = jsi_callback->callback_->Get(isolate);
-                                v8::Local<v8::External> cbData = jsi_callback->data_->Get(
-                                        isolate).As<v8::External>();
-                                v8::Local<v8::Context> context = callback->GetCreationContextChecked();
-                                v8::Context::Scope context_scope(context);
-
-                                 auto ret = ImageBitmapImpl::NewInstance(isolate, cbData);
-
-                                v8::Local<v8::Value> args[2];
-
-                                if (done) {
-                                    args[0] = v8::Null(isolate);
-                                    args[1] = ret;
-                                } else {
-                                    args[0] = v8::Exception::Error(
-                                            ConvertToV8String(isolate, "Failed to load image"));
-                                    args[1] = v8::Null(isolate);
-                                }
-
-                                callback->Call(context, context->Global(), 2, args);
-
-
-                                delete jsi_callback;
-                                delete current_queue;
-
-                            };
-                            current_queue->addOperation(main_task);
-
-
-
-                        }, std::move(ab));
-                thread.detach();
-
-#endif
-
-                return;
-            } else if (len == 5 || len == 6) {
-                auto asset = canvas_native_image_asset_create();
-
-                auto shared_asset = canvas_native_image_asset_shared_clone(asset);
-
-                auto ret = new ImageBitmapImpl(asset);
-
-                auto cbFunc = args[count - 1].As<v8::Function>();
-                auto data = v8::External::New(isolate, ret);
-                if (len == 6) {
-                    options = ImageBitmapImpl::HandleOptions(isolate, args[5]);
-                }
-
-                auto jsi_callback = new JSICallback(isolate, cbFunc, data);
-
-
-#ifdef __ANDROID__
-                ALooper_addFd(jsi_callback->looper_,
-                              jsi_callback->fd_[0],
-                              ALOOPER_POLL_CALLBACK,
-                              ALOOPER_EVENT_INPUT,
-                              [](int fd, int events,
-                                 void *data) {
-                                  auto cb = static_cast<JSICallback *>(data);
-                                  bool done;
-                                  read(fd, &done,
-                                       sizeof(bool));
-
-                                  v8::Isolate *isolate = cb->isolate_;
-                                  v8::Locker locker(isolate);
-                                  v8::Isolate::Scope isolate_scope(isolate);
-                                  v8::HandleScope handle_scope(isolate);
-                                  v8::Local<v8::Function> callback = cb->callback_->Get(isolate);
-                                  v8::Local<v8::External> cbData = cb->data_->Get(
-                                          isolate).As<v8::External>();
-                                  v8::Local<v8::Context> context = callback->GetCreationContextChecked();
-                                  v8::Context::Scope context_scope(context);
-
-                                  auto ret = ImageBitmapImpl::NewInstance(isolate, cbData);
-
-                                  v8::Local<v8::Value> args[2];
-
-                                  if (done) {
-                                      args[0] = v8::Null(isolate);
-                                      args[1] = ret;
-                                  } else {
-                                      args[0] = v8::Exception::Error(
-                                              ConvertToV8String(isolate, "Failed to load image"));
-                                      args[1] = v8::Null(isolate);
-                                  }
-
-                                  callback->Call(context, context->Global(), 2, args);
-
-                                  delete static_cast<JSICallback *>(data);
-                                  return 0;
-                              }, jsi_callback);
-
-                ALooper_wake(jsi_callback->looper_);
-
-                auto bufferValue = args[0];
-
-                if (isArrayBuffer) {
-                    auto arrayBuffer = bufferValue.As<v8::ArrayBuffer>();
-                    auto dataBuffer = (uint8_t *) arrayBuffer->GetBackingStore()->Data();
-                    v8::Global<v8::ArrayBuffer> ab(isolate, arrayBuffer);
-                    std::thread thread(
-                            [&dataBuffer, jsi_callback, &options, shared_asset](
-                                    float sx_or_options,
-                                    float sy,
-                                    float sw,
-                                    float sh,
-                                    v8::Global<v8::ArrayBuffer> ab,
-                                    size_t size
-                            ) {
-
-                                auto done = canvas_native_image_bitmap_create_from_encoded_bytes_src_rect_with_output(
-                                        dataBuffer, size,
-                                        sx_or_options,
-                                        sy,
-                                        sw,
-                                        sh,
+                        [callback, image_bitmap_async_data, offset, options, rect](
+                                std::shared_ptr<v8::BackingStore> store) {
+
+                            auto data = static_cast<uint8_t *>(store->Data()) + offset;
+                            auto size = store->ByteLength();
+
+                            auto asset = canvas_native_image_asset_create();
+                            bool done;
+                            if (rect.has_value()) {
+
+                                done = canvas_native_image_bitmap_create_from_encoded_bytes_src_rect_with_output(
+                                        data, size,
+                                        rect.value().x,
+                                        rect.value().y,
+                                        rect.value().width,
+                                        rect.value().height,
                                         options.flipY,
                                         options.premultiplyAlpha,
                                         options.colorSpaceConversion,
                                         options.resizeQuality,
                                         options.resizeWidth,
-                                        options.resizeHeight, shared_asset);
-
-                                canvas_native_image_asset_destroy(shared_asset);
-
-
-                                write(jsi_callback->fd_[1],
-                                      &done,
-                                      sizeof(bool));
-
-                            },
-                            (float) sx_or_options->NumberValue(context).ToChecked(),
-                            (float) sy->NumberValue(context).ToChecked(),
-                            (float) sw->NumberValue(context).ToChecked(),
-                            (float) sh->NumberValue(context).ToChecked(), std::move(ab),
-                            arrayBuffer->ByteLength());
-
-                    thread.detach();
-
-                    return;
-                }
-
-                auto ta = bufferValue.As<v8::ArrayBufferView>();
-
-                auto array = ta->Buffer();
-                auto offset = ta->ByteOffset();
-                auto size = ta->ByteLength();
-                auto data_ptr = static_cast<uint8_t *>(array->GetBackingStore()->Data()) + offset;
-
-
-                v8::Global<v8::ArrayBufferView> ab(isolate, ta);
-                std::thread thread(
-                        [jsi_callback, &options, shared_asset, data_ptr, size](
-                                float sx_or_options,
-                                float sy,
-                                float sw,
-                                float sh,
-                                v8::Global<v8::ArrayBufferView> ab
-                        ) {
-
-                            auto done = canvas_native_image_bitmap_create_from_encoded_bytes_src_rect_with_output(
-                                    data_ptr, size,
-                                    sx_or_options,
-                                    sy,
-                                    sw,
-                                    sh,
-                                    options.flipY,
-                                    options.premultiplyAlpha,
-                                    options.colorSpaceConversion,
-                                    options.resizeQuality,
-                                    options.resizeWidth,
-                                    options.resizeHeight, shared_asset);
-
-                            canvas_native_image_asset_destroy(shared_asset);
-
-
-                            write(jsi_callback->fd_[1],
-                                  &done,
-                                  sizeof(bool));
-
-                        },
-                        (float) sx_or_options->NumberValue(context).ToChecked(),
-                        (float) sy->NumberValue(context).ToChecked(),
-                        (float) sw->NumberValue(context).ToChecked(),
-                        (float) sh->NumberValue(context).ToChecked(), std::move(ab));
-                thread.detach();
-
-#endif
-
-#ifdef __APPLE__
-
-                auto current_queue = new NSOperationQueueWrapper(true);
-
-
-                auto bufferValue = args[0];
-
-                if (isArrayBuffer) {
-                    auto arrayBuffer = bufferValue.As<v8::ArrayBuffer>();
-                    auto dataBuffer = (uint8_t *) arrayBuffer->GetBackingStore()->Data();
-                    v8::Global<v8::ArrayBuffer> ab(isolate, arrayBuffer);
-                    std::thread thread(
-                            [&dataBuffer, jsi_callback, &options, shared_asset, current_queue](
-                                    float sx_or_options,
-                                    float sy,
-                                    float sw,
-                                    float sh,
-                                    v8::Global<v8::ArrayBuffer> ab,
-                                    size_t size
-                            ) {
-
-                                auto done = canvas_native_image_bitmap_create_from_encoded_bytes_src_rect_with_output(
-                                        dataBuffer, size,
-                                        sx_or_options,
-                                        sy,
-                                        sw,
-                                        sh,
+                                        options.resizeHeight, asset);
+                            } else {
+                                done = canvas_native_image_bitmap_create_from_encoded_bytes_with_output(
+                                        data, size,
                                         options.flipY,
                                         options.premultiplyAlpha,
                                         options.colorSpaceConversion,
                                         options.resizeQuality,
                                         options.resizeWidth,
-                                        options.resizeHeight, shared_asset);
-
-                                canvas_native_image_asset_destroy(shared_asset);
-
-
-                                auto main_task = [jsi_callback, current_queue, done]() {
-
-
-                                    v8::Isolate *isolate = jsi_callback->isolate_;
-                                    v8::Locker locker(isolate);
-                                    v8::Isolate::Scope isolate_scope(isolate);
-                                    v8::HandleScope handle_scope(isolate);
-                                    v8::Local<v8::Function> callback = jsi_callback->callback_->Get(isolate);
-                                    v8::Local<v8::External> cbData = jsi_callback->data_->Get(
-                                            isolate).As<v8::External>();
-                                    v8::Local<v8::Context> context = callback->GetCreationContextChecked();
-                                    v8::Context::Scope context_scope(context);
-
-
-
-                                    auto ret = ImageBitmapImpl::NewInstance(isolate, cbData);
-
-                                    v8::Local<v8::Value> args[2];
-
-                                    if (done) {
-                                        args[0] = v8::Null(isolate);
-                                        args[1] = ret;
-                                    } else {
-                                        args[0] = v8::Exception::Error(
-                                                ConvertToV8String(isolate, "Failed to load image"));
-                                        args[1] = v8::Null(isolate);
-                                    }
-
-                                    callback->Call(context, context->Global(), 2, args);
-
-
-                                    delete jsi_callback;
-                                    delete current_queue;
-
-                                };
-                                current_queue->addOperation(main_task);
-
-                            },
-                            (float) sx_or_options->NumberValue(context).ToChecked(),
-                            (float) sy->NumberValue(context).ToChecked(),
-                            (float) sw->NumberValue(context).ToChecked(),
-                            (float) sh->NumberValue(context).ToChecked(),
-                                       std::move(ab),
-                            arrayBuffer->ByteLength());
-
-                    thread.detach();
-
-                    return;
-                }
-
-                auto ta = bufferValue.As<v8::ArrayBufferView>();
-
-                auto array = ta->Buffer();
-                auto offset = ta->ByteOffset();
-                auto size = ta->ByteLength();
-                auto data_ptr = static_cast<uint8_t*>(array->GetBackingStore()->Data()) + offset;
-
-
-
-                v8::Global<v8::ArrayBufferView> ab(isolate, ta);
-                std::thread thread(
-                        [jsi_callback, &options, data_ptr, size, shared_asset, current_queue](
-                                float sx_or_options,
-                                float sy,
-                                float sw,
-                                float sh,
-                                v8::Global<v8::ArrayBufferView> ab
-                        ) {
-
-                            auto done = canvas_native_image_bitmap_create_from_encoded_bytes_src_rect_with_output(
-                                    data_ptr, size,
-                                    sx_or_options,
-                                    sy,
-                                    sw,
-                                    sh,
-                                    options.flipY,
-                                    options.premultiplyAlpha,
-                                    options.colorSpaceConversion,
-                                    options.resizeQuality,
-                                    options.resizeWidth,
-                                    options.resizeHeight, shared_asset);
-
-                            canvas_native_image_asset_destroy(shared_asset);
-
-                            auto main_task = [jsi_callback, current_queue, done]() {
-
-
-                                v8::Isolate *isolate = jsi_callback->isolate_;
-                                v8::Locker locker(isolate);
-                                v8::Isolate::Scope isolate_scope(isolate);
-                                v8::HandleScope handle_scope(isolate);
-                                v8::Local<v8::Function> callback = jsi_callback->callback_->Get(isolate);
-                                v8::Local<v8::External> cbData = jsi_callback->data_->Get(
-                                        isolate).As<v8::External>();
-                                v8::Local<v8::Context> context = callback->GetCreationContextChecked();
-                                v8::Context::Scope context_scope(context);
-
-                                 auto ret = ImageBitmapImpl::NewInstance(isolate, cbData);
-
-                                v8::Local<v8::Value> args[2];
-
-                                if (done) {
-                                    args[0] = v8::Null(isolate);
-                                    args[1] = ret;
-                                } else {
-                                    args[0] = v8::Exception::Error(
-                                            ConvertToV8String(isolate, "Failed to load image"));
-                                    args[1] = v8::Null(isolate);
-                                }
-
-                                callback->Call(context, context->Global(), 2, args);
-
-
-                                delete jsi_callback;
-                                delete current_queue;
-
-                            };
-                            current_queue->addOperation(main_task);
-
-
-
-                        },
-                        (float) sx_or_options->NumberValue(context).ToChecked(),
-                        (float) sy->NumberValue(context).ToChecked(),
-                        (float) sw->NumberValue(context).ToChecked(),
-                        (float) sh->NumberValue(context).ToChecked(), std::move(ab));
+                                        options.resizeHeight, asset);
+                            }
+                            if (callback != nullptr) {
+                                image_bitmap_async_data->asset_ = asset;
+                                callback->execute(done);
+                            }
+
+                        }, std::move(store));
                 thread.detach();
 
-
-
-#endif
-
-
                 return;
             }
         }
     }
 
-    auto type = GetNativeType( image);
+    auto type = ObjectWrapperImpl::GetNativeType(image);
 
     if (len == 1 || len == 2) {
         if (len == 2) {
@@ -950,644 +647,428 @@ void CanvasJSIModule::Create2DContextWithPointer(const v8::FunctionCallbackInfo<
     args.GetReturnValue().Set(ret);
 }
 
+struct FileData {
+    char *error_;
+    U8Buffer *data;
+
+    ~FileData() {
+        if (error_ != nullptr) {
+            canvas_native_string_destroy(error_);
+            error_ = nullptr;
+        }
+    }
+};
+
 void CanvasJSIModule::ReadFile(const v8::FunctionCallbackInfo<v8::Value> &args) {
     auto isolate = args.GetIsolate();
     auto file = ConvertFromV8String(isolate, args[0]);
     auto cbFunc = args[1].As<v8::Function>();
 
-    auto jsi_callback = new JSIReadFileCallback(isolate, cbFunc);
-
-#ifdef __ANDROID__
-    ALooper_addFd(jsi_callback->looper_,
-                  jsi_callback->fd_[0],
-                  ALOOPER_POLL_CALLBACK,
-                  ALOOPER_EVENT_INPUT,
-                  [](int fd, int events,
-                     void *data) {
-
-                      auto cb = static_cast<JSIReadFileCallback *>(data);
-                      bool done;
-                      read(fd, &done,
-                           sizeof(bool));
-
-                      if (cb->data_ == nullptr) {
-                          return 1;
-                      }
-
-                      v8::Isolate *isolate = cb->isolate_;
-                      v8::Locker locker(isolate);
-                      v8::Isolate::Scope isolate_scope(isolate);
-                      v8::HandleScope handle_scope(isolate);
-                      v8::Local<v8::Function> callback = cb->callback_.Get(isolate);
-                      v8::Local<v8::Context> context = callback->GetCreationContextChecked();
-                      v8::Context::Scope context_scope(context);
-
-                      v8::Local<v8::Value> args[2];
-
-                      if (done) {
-                          args[0] = v8::Null(isolate);
-
-                          auto vec = cb->data_;
-
-                          auto buf = (void *) canvas_native_u8_buffer_get_bytes_mut(vec);
-                          auto size = (size_t) canvas_native_u8_buffer_get_length(vec);
-
-                          auto store = v8::ArrayBuffer::NewBackingStore(buf, size,
-                                                                        [](void *data,
-                                                                           size_t length,
-                                                                           void *deleter_data) {
-                                                                            if (deleter_data !=
-                                                                                nullptr) {
-                                                                                // a little extreme :'D
-                                                                                delete static_cast<JSIReadFileCallback *>(deleter_data);
-                                                                            }
-                                                                        },
-                                                                        data);
-
-                          args[1] = v8::ArrayBuffer::New(isolate, std::move(store));
-                      } else {
-                          auto error = cb->error_;
-                          args[0] = v8::Exception::Error(ConvertToV8String(isolate, error));
-                          args[1] = v8::Null(isolate);
-                      }
-
-                      v8::TryCatch tc(isolate);
-                      v8::Local<v8::Value> result;
-                      if (!callback->Call(context, context->Global(), 2, args).ToLocal(
-                              &result)) {
-                          if (tc.HasCaught()) {
-
-                              v8::Local<v8::Value> stack;
-                              bool success = tc.StackTrace(context).ToLocal(&stack);
-                              if (!success || stack.IsEmpty()) {
-                                  if (!done) {
-                                      delete cb;
-                                  }
-                                  return 0;
-                              }
-
-                              v8::Local<v8::String> stackV8Str;
-                              success = stack->ToDetailString(context).ToLocal(&stackV8Str);
-                              if (!success || stackV8Str.IsEmpty()) {
-                                  if (!done) {
-                                      delete cb;
-                                  }
-                                  return 0;
-                              }
-                              LogToConsole(ConvertFromV8String(isolate, stackV8Str));
-
-                          }
-                      }
-
-                      if (!done) {
-                          delete cb;
-                      }
-                      return 0;
-                  }, jsi_callback);
-
-    ALooper_wake(jsi_callback->looper_);
-
-    std::thread thread(
-            [jsi_callback](const std::string &file) {
-                bool done = false;
-                auto ret = canvas_native_helper_read_file(file.c_str());
-
-                if (!canvas_native_helper_read_file_has_error(ret)) {
-                    auto buf = canvas_native_helper_read_file_get_data(ret);
+    auto callback = new AsyncCallback(isolate, cbFunc, [](bool done, void *data) {
+        if (data == nullptr) { return; }
+        auto async_data = static_cast<AsyncCallback *>(data);
+        auto func = async_data->inner_.get();
+        if (func != nullptr && func->isolate_ != nullptr) {
+            v8::Isolate *isolate = func->isolate_;
+            v8::Locker locker(isolate);
+            v8::Isolate::Scope isolate_scope(isolate);
+            v8::HandleScope handle_scope(isolate);
+            v8::Local<v8::Function> callback = func->callback_.Get(
+                    isolate);
+            v8::Local<v8::Context> context = callback->GetCreationContextChecked();
+            v8::Context::Scope context_scope(context);
 
-                    jsi_callback->SetData(buf);
+            if (func->data != nullptr) {
+                auto file_data = static_cast<FileData *>(func->data);
+
+                v8::Local<v8::Value> args[2];
+
+                if (done) {
+                    args[0] = v8::Null(isolate);
+
+                    auto buf = canvas_native_u8_buffer_get_bytes_mut(file_data->data);
+                    auto size = (size_t) canvas_native_u8_buffer_get_length(file_data->data);
+
+                    auto store = v8::ArrayBuffer::NewBackingStore((void *) buf, size,
+                                                                  [](void *data,
+                                                                     size_t length,
+                                                                     void *deleter_data) {
+                                                                      if (deleter_data !=
+                                                                          nullptr) {
+                                                                          delete static_cast<FileData *>(deleter_data);
+
+                                                                      }
+                                                                  },
+                                                                  func->data);
+
+                    auto ret = v8::Object::New(isolate);
+                    auto buffer = v8::ArrayBuffer::New(isolate, std::move(store));
+                    ret->Set(context, ConvertToV8String(isolate, "buffer"), buffer);
+                    auto mime = canvas_native_helper_get_mime(buf, size);
+                    if (mime != nullptr) {
+                        if (mime->mime_type != nullptr) {
+                            ret->Set(context, ConvertToV8String(isolate, "mime"),
+                                     ConvertToV8String(isolate, mime->mime_type));
+                        }
+                        if (mime->extension != nullptr) {
+                            ret->Set(context, ConvertToV8String(isolate, "extension"),
+                                     ConvertToV8String(isolate, mime->extension));
+                        }
+                        canvas_native_helper_release_mime(mime);
+                    }
 
-                    done = true;
+                    args[1] = ret;
                 } else {
-                    auto error = canvas_native_helper_read_file_get_error(ret);
-
-                    jsi_callback->SetError(const_cast<char *>(error));
+                    auto error = file_data->error_;
+                    args[0] = v8::Exception::Error(ConvertToV8String(isolate, error));
+                    args[1] = v8::Null(isolate);
+                    delete file_data;
                 }
-                canvas_native_helper_destroy(ret);
-
-                write(jsi_callback->fd_[1],
-                      &done,
-                      sizeof(bool));
-
-            }, std::move(file));
-
-    thread.detach();
-
-#endif
 
+                v8::TryCatch tc(isolate);
+                v8::Local<v8::Value> result;
+                if (!callback->Call(context, context->Global(), 2, args).ToLocal(
+                        &result)) {
+                    if (tc.HasCaught()) {
+
+//                        v8::Local<v8::Value> stack;
+//                        bool success = tc.StackTrace(context).ToLocal(&stack);
+//                        if (!success || stack.IsEmpty()) {
+//                            if (!done) {
+//                                delete async_data;
+//                            }
+//                            return;
+//                        }
+//
+//                        v8::Local<v8::String> stackV8Str;
+//                        success = stack->ToDetailString(context).ToLocal(&stackV8Str);
+//                        if (!success || stackV8Str.IsEmpty()) {
+//                            if (!done) {
+//                                delete async_data;
+//                            }
+//                            return;
+//                        }
 
-#ifdef __APPLE__
-
-    auto current_queue = new NSOperationQueueWrapper(true);
+                    }
+                }
 
-    auto queue = new NSOperationQueueWrapper(false);
+                delete async_data;
 
-    auto task = [jsi_callback, current_queue, queue, file]() {
+            }
+        }
+    });
 
+    callback->prepare();
 
+    std::thread thread(
+            [callback, file]() {
+                bool done = false;
+                auto ret = canvas_native_helper_read_file(file.c_str());
 
-        bool done = false;
-        auto ret = canvas_native_helper_read_file(file.c_str());
+                if (!canvas_native_helper_read_file_has_error(ret)) {
+                    auto buf = canvas_native_helper_read_file_take_data(ret);
+                    callback->inner_->data = new FileData{nullptr, buf};
+                    done = true;
+                } else {
+                    auto error = canvas_native_helper_read_file_get_error(ret);
+                    callback->inner_->data = new FileData{const_cast<char *>(error), nullptr};
+                }
+                canvas_native_helper_release(ret);
+                callback->execute(done);
+            });
 
-        if (!canvas_native_helper_read_file_has_error(ret)) {
-            auto buf = canvas_native_helper_read_file_get_data(ret);
+    thread.detach();
 
-            jsi_callback->SetData(buf);
 
-            done = true;
-        } else {
-            auto error = canvas_native_helper_read_file_get_error(ret);
+}
 
-            jsi_callback->SetError((char*)error);
-        }
 
-        canvas_native_helper_destroy(ret);
+void CanvasJSIModule::GetMime(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+    auto file = ConvertFromV8String(isolate, args[0]);
+    auto cbFunc = args[1].As<v8::Function>();
 
-        auto main_task = [jsi_callback, current_queue, queue, done]() {
 
-            v8::Isolate *isolate = jsi_callback->isolate_;
+    auto callback = new AsyncCallback(isolate, cbFunc, [](bool done, void *data) {
+        if (data == nullptr) { return; }
+        auto async_data = static_cast<AsyncCallback *>(data);
+        auto func = async_data->inner_.get();
+        if (func != nullptr && func->isolate_ != nullptr) {
+            v8::Isolate *isolate = func->isolate_;
             v8::Locker locker(isolate);
             v8::Isolate::Scope isolate_scope(isolate);
             v8::HandleScope handle_scope(isolate);
-            v8::Local<v8::Function> callback = jsi_callback->callback_.Get(isolate);
+            v8::Local<v8::Function> callback = func->callback_.Get(
+                    isolate);
             v8::Local<v8::Context> context = callback->GetCreationContextChecked();
             v8::Context::Scope context_scope(context);
 
-            v8::Local<v8::Value> args[2];
-
-            if (done) {
-                args[0] = v8::Null(isolate);
+            if (func->data != nullptr) {
+                auto file_data = static_cast<FileData *>(func->data);
 
-                auto vec = jsi_callback->data_;
+                v8::Local<v8::Value> args[2];
 
+                if (done) {
+                    args[0] = v8::Null(isolate);
 
-                auto buf = (void*)canvas_native_u8_buffer_get_bytes_mut(vec);
+                    auto buf = (void *) canvas_native_u8_buffer_get_bytes_mut(file_data->data);
+                    auto size = (size_t) canvas_native_u8_buffer_get_length(file_data->data);
 
-                auto size = (size_t)canvas_native_u8_buffer_get_length(vec);
+                    auto store = v8::ArrayBuffer::NewBackingStore(buf, size,
+                                                                  [](void *data,
+                                                                     size_t length,
+                                                                     void *deleter_data) {
+                                                                      if (deleter_data !=
+                                                                          nullptr) {
+                                                                          delete static_cast<FileData *>(deleter_data);
 
-                auto store = v8::ArrayBuffer::NewBackingStore(buf, size,
-                                                              [](void *data,
-                                                                 size_t length,
-                                                                 void *deleter_data) {
-                                                                  if (deleter_data !=
-                                                                      nullptr) {
-                                                                      // a little extreme :'D
-                                                                      delete static_cast<JSIReadFileCallback *>(deleter_data);
-                                                                  }
-                                                              },
-                                                              jsi_callback);
+                                                                      }
+                                                                  },
+                                                                  func->data);
 
-                args[1] = v8::ArrayBuffer::New(isolate, std::move(store));
-            } else {
-                auto error = jsi_callback->error_;
-                args[0] = v8::Exception::Error(ConvertToV8String(isolate, error));
-                args[1] = v8::Null(isolate);
-            }
+                    args[1] = v8::ArrayBuffer::New(isolate, std::move(store));
+                } else {
+                    auto error = file_data->error_;
+                    args[0] = v8::Exception::Error(ConvertToV8String(isolate, error));
+                    args[1] = v8::Null(isolate);
+                    delete file_data;
+                }
 
-            v8::TryCatch tc(isolate);
-            v8::Local<v8::Value> result;
-            if (!callback->Call(context, context->Global(), 2, args).ToLocal(
-                    &result)) {
-                if (tc.HasCaught()) {
-
-                    v8::Local<v8::Value> stack;
-                    bool success = tc.StackTrace(context).ToLocal(&stack);
-                    if (!success || stack.IsEmpty()) {
-                        if (!done) {
-                delete jsi_callback;
-            }
-                        return;
-                    }
+                v8::TryCatch tc(isolate);
+                v8::Local<v8::Value> result;
+                if (!callback->Call(context, context->Global(), 2, args).ToLocal(
+                        &result)) {
+                    if (tc.HasCaught()) {
+
+//                        v8::Local<v8::Value> stack;
+//                        bool success = tc.StackTrace(context).ToLocal(&stack);
+//                        if (!success || stack.IsEmpty()) {
+//                            if (!done) {
+//                                delete async_data;
+//                            }
+//                            return;
+//                        }
+//
+//                        v8::Local<v8::String> stackV8Str;
+//                        success = stack->ToDetailString(context).ToLocal(&stackV8Str);
+//                        if (!success || stackV8Str.IsEmpty()) {
+//                            if (!done) {
+//                                delete async_data;
+//                            }
+//                            return;
+//                        }
 
-                    v8::Local<v8::String> stackV8Str;
-                    success = stack->ToDetailString(context).ToLocal(&stackV8Str);
-                    if (!success || stackV8Str.IsEmpty()) {
-                        if (!done) {
-                delete jsi_callback;
-            }
-                        return;
                     }
-                    LogToConsole(ConvertFromV8String(isolate, stackV8Str));
-
                 }
-            }
-
-            if (!done) {
-                delete jsi_callback;
-            }
-
-            delete queue;
-            delete current_queue;
-
-        };
-        current_queue->addOperation(main_task);
-    };
-
-    queue->addOperation(task);
-#endif
 
+                delete async_data;
 
-}
-
-void CanvasJSIModule::CreateWebGLContext(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    auto configValue = args[0];
-    auto isolate = args.GetIsolate();
-    auto context = isolate->GetCurrentContext();
-    if (!configValue->IsNullOrUndefined() && configValue->IsObject()) {
-        auto config = configValue.As<v8::Object>();
-        std::string version("none");
-        auto alpha = true;
-        auto antialias = true;
-        auto depth = true;
-        auto fail_if_major_performance_caveat = false;
-        std::string power_preference("default");
-        auto premultiplied_alpha = true;
-        auto preserve_drawing_buffer = false;
-        auto stencil = false;
-        auto desynchronized = false;
-        auto xr_compatible = false;
-
-        auto last = isolate->GetNumberOfDataSlots() - 1;
-        auto data = isolate->GetData(last);
-
-        if (data != nullptr) {
-            auto consts = static_cast<PerIsolateData *>(data);
-
-            v8::Local<v8::Value> versionValue;
-
-            config->Get(context, consts->VERSION_PERSISTENT->Get(isolate)).ToLocal(&versionValue);
-
-            if (!versionValue.IsEmpty() && versionValue->IsString()) {
-                version = ConvertFromV8String(isolate, versionValue);
-            }
-
-            v8::Local<v8::Value> alphaValue;
-
-            config->Get(context, consts->ALPHA_PERSISTENT->Get(isolate)).ToLocal(&alphaValue);
-            if (!alphaValue.IsEmpty() && alphaValue->IsBoolean()) {
-                alpha = alphaValue->BooleanValue(isolate);
-            }
-
-            v8::Local<v8::Value> antialiasValue;
-            config->Get(context, consts->ANTIALIAS_PERSISTENT->Get(isolate)).ToLocal(
-                    &antialiasValue);
-            if (!antialiasValue.IsEmpty() && antialiasValue->IsBoolean()) {
-                antialias = antialiasValue->BooleanValue(isolate);
             }
+        }
+    });
 
-            v8::Local<v8::Value> failIfMajorPerformanceCaveatValue;
-            config->Get(context,
-                        consts->FAIL_IF_MAJOR_PERFORMANCE_CAVEAT_PERSISTENT->Get(isolate)).ToLocal(
-                    &failIfMajorPerformanceCaveatValue);
-            if (!failIfMajorPerformanceCaveatValue.IsEmpty() &&
-                failIfMajorPerformanceCaveatValue->IsBoolean()) {
-                fail_if_major_performance_caveat = failIfMajorPerformanceCaveatValue->BooleanValue(
-                        isolate);
-            }
+    callback->prepare();
 
-            v8::Local<v8::Value> powerPreferenceValue;
-            config->Get(context, consts->POWER_PREFERENCE_PERSISTENT->Get(isolate)).ToLocal(
-                    &powerPreferenceValue);
-            if (!powerPreferenceValue.IsEmpty() && powerPreferenceValue->IsString()) {
-                power_preference = ConvertFromV8String(isolate, powerPreferenceValue);
-            }
+    std::thread thread(
+            [callback, file]() {
+                bool done = false;
+                auto ret = canvas_native_helper_read_file(file.c_str());
 
-            v8::Local<v8::Value> premultipliedAlphaValue;
-            config->Get(context,
-                        consts->PREMULTIPLIED_ALPHA_PERSISTENT->Get(isolate)).ToLocal(
-                    &premultipliedAlphaValue);
-            if (!premultipliedAlphaValue.IsEmpty() && premultipliedAlphaValue->IsBoolean()) {
-                premultiplied_alpha = premultipliedAlphaValue->BooleanValue(isolate);
-            }
+                if (!canvas_native_helper_read_file_has_error(ret)) {
+                    auto buf = canvas_native_helper_read_file_take_data(ret);
+                    callback->inner_->data = new FileData{nullptr, buf};
+                    done = true;
+                } else {
+                    auto error = canvas_native_helper_read_file_get_error(ret);
+                    callback->inner_->data = new FileData{const_cast<char *>(error), nullptr};
+                }
+                canvas_native_helper_release(ret);
+                callback->execute(done);
+            });
 
-            v8::Local<v8::Value> preserveDrawingBufferValue;
-            config->Get(context,
-                        consts->PRESERVE_DRAWING_BUFFER_PERSISTENT->Get(isolate)).ToLocal(
-                    &preserveDrawingBufferValue);
-            if (!preserveDrawingBufferValue.IsEmpty() && preserveDrawingBufferValue->IsBoolean()) {
-                preserve_drawing_buffer = preserveDrawingBufferValue->BooleanValue(isolate);
-            }
+    thread.detach();
 
-            v8::Local<v8::Value> stencilValue;
-            config->Get(context, consts->STENCIL_PERSISTENT->Get(isolate)).ToLocal(&stencilValue);
-            if (!stencilValue.IsEmpty() && stencilValue->IsBoolean()) {
-                stencil = stencilValue->BooleanValue(isolate);
-            }
 
-            v8::Local<v8::Value> desynchronizedValue;
-            config->Get(context, consts->DESYNCHRONIZED_PERSISTENT->Get(isolate)).ToLocal(
-                    &desynchronizedValue);
-            if (!desynchronizedValue.IsEmpty() && desynchronizedValue->IsBoolean()) {
-                desynchronized = desynchronizedValue->BooleanValue(isolate);
-            }
+}
 
-            v8::Local<v8::Value> xrCompatibleValue;
-            config->Get(context,
-                        consts->XR_COMPATIBLE_PERSISTENT->Get(isolate)).ToLocal(&xrCompatibleValue);
-            if (!xrCompatibleValue.IsEmpty() && xrCompatibleValue->IsBoolean()) {
-                xr_compatible = xrCompatibleValue->BooleanValue(isolate);
-            }
-        }
 
+void CanvasJSIModule::CreateWebGLContext(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
-        if (version !=
-            "v1") {
-            args.GetReturnValue().SetNull();
-            return;
-        } else {
-            auto count = args.Length();
-            if (count == 6) {
-                auto ctx = args[1].As<v8::BigInt>()->Int64Value();
-//                auto density = args[2]->NumberValue(context).ToChecked();
-//                auto fontColor = args[3]->NumberValue(context).ToChecked();
-//                auto ppi = args[4]->NumberValue(context).ToChecked();
-//                auto direction = args[5]->NumberValue(context).ToChecked();
-                auto webgl = canvas_native_webgl_create(
-                        ctx,
-                        version.c_str(),
-                        alpha,
-                        antialias,
-                        depth,
-                        fail_if_major_performance_caveat,
-                        power_preference.c_str(),
-                        premultiplied_alpha,
-                        preserve_drawing_buffer,
-                        stencil,
-                        desynchronized,
-                        xr_compatible
-                );
-
-                auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
-                                                                           new WebGLRenderingContext(
-                                                                                   webgl));
-
-                args.GetReturnValue().Set(renderingContext);
-                return;
-            } else if (count == 7) {
-                auto width = args[1]->NumberValue(context).ToChecked();
-                auto height = args[2]->NumberValue(context).ToChecked();
-//                auto density = args[3]->NumberValue(context).ToChecked();
-//                auto fontColor = args[4]->NumberValue(context).ToChecked();
-//                auto ppi = args[5]->NumberValue(context).ToChecked();
-//                auto direction = args[6]->NumberValue(context).ToChecked();
-                auto ctx = canvas_native_webgl_create_no_window(
-                        (int32_t) width,
-                        (int32_t) height,
-                        version.c_str(),
-                        alpha,
-                        antialias,
-                        depth,
-                        fail_if_major_performance_caveat,
-                        power_preference.c_str(),
-                        premultiplied_alpha,
-                        preserve_drawing_buffer,
-                        stencil,
-                        desynchronized,
-                        xr_compatible,
-                        false
-                );
-
-                auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
-                                                                           new WebGLRenderingContext(
-                                                                                   ctx));
-
-                args.GetReturnValue().Set(renderingContext);
-                return;
+    auto options = GLOptions();
+    options.parseGLOptions(args);
 
-            } else {
-                auto width = (int32_t) args[1]->NumberValue(context).ToChecked();
-                auto height = (int32_t) args[2]->NumberValue(context).ToChecked();
-
-                auto ctx = canvas_native_webgl_create_no_window(
-                        width,
-                        height,
-                        version.c_str(),
-                        alpha,
-                        antialias,
-                        depth,
-                        fail_if_major_performance_caveat,
-                        power_preference.c_str(),
-                        premultiplied_alpha,
-                        preserve_drawing_buffer,
-                        stencil,
-                        desynchronized,
-                        xr_compatible,
-                        false
-                );
-
-                auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
-                                                                           new WebGLRenderingContext(
-                                                                                   ctx));
-
-                args.GetReturnValue().Set(renderingContext);
-                return;
-            }
-
-        }
+    if (options.version != 1) {
+        args.GetReturnValue().SetNull();
+        return;
     }
-    args.GetReturnValue().SetNull();
-}
 
-void CanvasJSIModule::CreateWebGL2Context(const v8::FunctionCallbackInfo<v8::Value> &args) {
-    auto configValue = args[0];
     auto isolate = args.GetIsolate();
     auto context = isolate->GetCurrentContext();
-    if (!configValue->IsNullOrUndefined() && configValue->IsObject()) {
-        auto config = configValue.As<v8::Object>();
-        std::string version("none");
-        auto alpha = true;
-        auto antialias = true;
-        auto depth = true;
-        auto fail_if_major_performance_caveat = false;
-        std::string power_preference("default");
-        auto premultiplied_alpha = true;
-        auto preserve_drawing_buffer = false;
-        auto stencil = false;
-        auto desynchronized = false;
-        auto xr_compatible = false;
-
 
-        auto last = isolate->GetNumberOfDataSlots() - 1;
-        auto data = isolate->GetData(last);
 
-        if (data != nullptr) {
-            auto consts = static_cast<PerIsolateData *>(data);
-
-            v8::Local<v8::Value> versionValue;
-
-            config->Get(context, consts->VERSION_PERSISTENT->Get(isolate)).ToLocal(&versionValue);
+    auto count = args.Length();
+    if (count == 6) {
+        auto ctx = args[1].As<v8::BigInt>()->Int64Value();
+        auto webgl = (WebGLState *) ctx;
 
-            if (!versionValue.IsEmpty() && versionValue->IsString()) {
-                version = ConvertFromV8String(isolate, versionValue);
-            }
+        auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
+                                                                   new WebGLRenderingContext(
+                                                                           webgl));
 
-            v8::Local<v8::Value> alphaValue;
+        args.GetReturnValue().Set(renderingContext);
+        return;
+    } else if (count == 7) {
+        auto width = args[1]->NumberValue(context).ToChecked();
+        auto height = args[2]->NumberValue(context).ToChecked();
+        auto ctx = canvas_native_webgl_create_no_window(
+                (int32_t) width,
+                (int32_t) height,
+                options.version,
+                options.alpha,
+                options.antialias,
+                options.depth,
+                options.failIfMajorPerformanceCaveat,
+                options.powerPreference,
+                options.premultipliedAlpha,
+                options.preserveDrawingBuffer,
+                options.stencil,
+                options.desynchronized,
+                options.xrCompatible,
+                false
+        );
+
+        auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
+                                                                   new WebGLRenderingContext(
+                                                                           ctx));
+
+        args.GetReturnValue().Set(renderingContext);
+        return;
 
-            config->Get(context, consts->ALPHA_PERSISTENT->Get(isolate)).ToLocal(&alphaValue);
-            if (!alphaValue.IsEmpty() && alphaValue->IsBoolean()) {
-                alpha = alphaValue->BooleanValue(isolate);
-            }
+    } else {
+        auto width = (int32_t) args[1]->NumberValue(context).ToChecked();
+        auto height = (int32_t) args[2]->NumberValue(context).ToChecked();
+
+        auto ctx = canvas_native_webgl_create_no_window(
+                width,
+                height,
+                options.version,
+                options.alpha,
+                options.antialias,
+                options.depth,
+                options.failIfMajorPerformanceCaveat,
+                options.powerPreference,
+                options.premultipliedAlpha,
+                options.preserveDrawingBuffer,
+                options.stencil,
+                options.desynchronized,
+                options.xrCompatible,
+                false
+        );
+
+        auto renderingContext = WebGLRenderingContext::NewInstance(isolate,
+                                                                   new WebGLRenderingContext(
+                                                                           ctx));
+
+        args.GetReturnValue().Set(renderingContext);
+        return;
+    }
+}
 
-            v8::Local<v8::Value> antialiasValue;
-            config->Get(context, consts->ANTIALIAS_PERSISTENT->Get(isolate)).ToLocal(
-                    &antialiasValue);
-            if (!antialiasValue.IsEmpty() && antialiasValue->IsBoolean()) {
-                antialias = antialiasValue->BooleanValue(isolate);
-            }
+void CanvasJSIModule::CreateWebGL2Context(const v8::FunctionCallbackInfo<v8::Value> &args) {
 
-            v8::Local<v8::Value> failIfMajorPerformanceCaveatValue;
-            config->Get(context,
-                        consts->FAIL_IF_MAJOR_PERFORMANCE_CAVEAT_PERSISTENT->Get(isolate)).ToLocal(
-                    &failIfMajorPerformanceCaveatValue);
-            if (!failIfMajorPerformanceCaveatValue.IsEmpty() &&
-                failIfMajorPerformanceCaveatValue->IsBoolean()) {
-                fail_if_major_performance_caveat = failIfMajorPerformanceCaveatValue->BooleanValue(
-                        isolate);
-            }
 
-            v8::Local<v8::Value> powerPreferenceValue;
-            config->Get(context, consts->POWER_PREFERENCE_PERSISTENT->Get(isolate)).ToLocal(
-                    &powerPreferenceValue);
-            if (!powerPreferenceValue.IsEmpty() && powerPreferenceValue->IsString()) {
-                power_preference = ConvertFromV8String(isolate, powerPreferenceValue);
-            }
+    auto options = GLOptions();
+    options.parseGLOptions(args);
 
-            v8::Local<v8::Value> premultipliedAlphaValue;
-            config->Get(context,
-                        consts->PREMULTIPLIED_ALPHA_PERSISTENT->Get(isolate)).ToLocal(
-                    &premultipliedAlphaValue);
-            if (!premultipliedAlphaValue.IsEmpty() && premultipliedAlphaValue->IsBoolean()) {
-                premultiplied_alpha = premultipliedAlphaValue->BooleanValue(isolate);
-            }
+    if (options.version != 2) {
+        args.GetReturnValue().SetNull();
+        return;
+    }
 
-            v8::Local<v8::Value> preserveDrawingBufferValue;
-            config->Get(context,
-                        consts->PRESERVE_DRAWING_BUFFER_PERSISTENT->Get(isolate)).ToLocal(
-                    &preserveDrawingBufferValue);
-            if (!preserveDrawingBufferValue.IsEmpty() && preserveDrawingBufferValue->IsBoolean()) {
-                preserve_drawing_buffer = preserveDrawingBufferValue->BooleanValue(isolate);
-            }
 
-            v8::Local<v8::Value> stencilValue;
-            config->Get(context, consts->STENCIL_PERSISTENT->Get(isolate)).ToLocal(&stencilValue);
-            if (!stencilValue.IsEmpty() && stencilValue->IsBoolean()) {
-                stencil = stencilValue->BooleanValue(isolate);
-            }
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
 
-            v8::Local<v8::Value> desynchronizedValue;
-            config->Get(context, consts->DESYNCHRONIZED_PERSISTENT->Get(isolate)).ToLocal(
-                    &desynchronizedValue);
-            if (!desynchronizedValue.IsEmpty() && desynchronizedValue->IsBoolean()) {
-                desynchronized = desynchronizedValue->BooleanValue(isolate);
-            }
 
-            v8::Local<v8::Value> xrCompatibleValue;
-            config->Get(context,
-                        consts->XR_COMPATIBLE_PERSISTENT->Get(isolate)).ToLocal(&xrCompatibleValue);
-            if (!xrCompatibleValue.IsEmpty() && xrCompatibleValue->IsBoolean()) {
-                xr_compatible = xrCompatibleValue->BooleanValue(isolate);
-            }
-        }
+    auto count = args.Length();
+    if (count == 6) {
+        auto ctx = args[1].As<v8::BigInt>()->Int64Value();
+        auto webgl = (WebGLState *) ctx;
+        auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
+                                                                    new WebGL2RenderingContext(
+                                                                            webgl,
+                                                                            WebGLRenderingVersion::V2));
+
+        args.GetReturnValue().Set(renderingContext);
+        return;
 
+    } else if (count ==
+               7) {
+        auto width = args[1]->NumberValue(context).ToChecked();
+        auto height = args[2]->NumberValue(context).ToChecked();
+        auto ctx = canvas_native_webgl_create_no_window(
+                (int32_t) width,
+                (int32_t) height,
+                options.version,
+                options.alpha,
+                options.antialias,
+                options.depth,
+                options.failIfMajorPerformanceCaveat,
+                options.powerPreference,
+                options.premultipliedAlpha,
+                options.preserveDrawingBuffer,
+                options.stencil,
+                options.desynchronized,
+                options.xrCompatible,
+                false
+        );
+        auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
+                                                                    new WebGL2RenderingContext(
+                                                                            ctx,
+                                                                            WebGLRenderingVersion::V2));
+
+        args.GetReturnValue().Set(renderingContext);
+        return;
 
-        if (version !=
-            "v2") {
-            args.GetReturnValue().SetNull();
-            return;
-        } else {
-            auto count = args.Length();
-            if (count == 6) {
-                auto ctx = args[1].As<v8::BigInt>()->Int64Value();
-//                auto density = args[2]->NumberValue(context).ToChecked();
-//                auto fontColor = args[3]->NumberValue(context).ToChecked();
-//                auto ppi = args[4]->NumberValue(context).ToChecked();
-//                auto direction = args[5]->NumberValue(context).ToChecked();
-
-                auto webgl = canvas_native_webgl_create(
-                        ctx,
-                        version.c_str(),
-                        alpha,
-                        antialias,
-                        depth,
-                        fail_if_major_performance_caveat,
-                        power_preference.c_str(),
-                        premultiplied_alpha,
-                        preserve_drawing_buffer,
-                        stencil,
-                        desynchronized,
-                        xr_compatible
-                );
-
-                auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
-                                                                            new WebGL2RenderingContext(
-                                                                                    webgl,
-                                                                                    WebGLRenderingVersion::V2));
-
-                args.GetReturnValue().Set(renderingContext);
-                return;
+    } else {
+        auto width = (int32_t) args[1]->NumberValue(context).ToChecked();
+        auto height = (int32_t) args[2]->NumberValue(context).ToChecked();
+        auto ctx = canvas_native_webgl_create_no_window(
+                width,
+                height,
+                options.version,
+                options.alpha,
+                options.antialias,
+                options.depth,
+                options.failIfMajorPerformanceCaveat,
+                options.powerPreference,
+                options.premultipliedAlpha,
+                options.preserveDrawingBuffer,
+                options.stencil,
+                options.desynchronized,
+                options.xrCompatible,
+                false
+        );
+
+        auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
+                                                                    new WebGL2RenderingContext(
+                                                                            ctx,
+                                                                            WebGLRenderingVersion::V2));
+
+        args.GetReturnValue().Set(renderingContext);
+        return;
+    }
+}
 
-            } else if (count ==
-                       7) {
-                auto width = args[1]->NumberValue(context).ToChecked();
-                auto height = args[2]->NumberValue(context).ToChecked();
-//                auto density = args[3]->NumberValue(context).ToChecked();
-//                auto fontColor = args[4]->NumberValue(context).ToChecked();
-//                auto ppi = args[5]->NumberValue(context).ToChecked();
-//                auto direction = args[6]->NumberValue(context).ToChecked();
-                auto ctx = canvas_native_webgl_create_no_window(
-                        (int32_t) width,
-                        (int32_t) height,
-                        version.c_str(),
-                        alpha,
-                        antialias,
-                        depth,
-                        fail_if_major_performance_caveat,
-                        power_preference.c_str(),
-                        premultiplied_alpha,
-                        preserve_drawing_buffer,
-                        stencil,
-                        desynchronized,
-                        xr_compatible,
-                        false
-                );
-                auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
-                                                                            new WebGL2RenderingContext(
-                                                                                    ctx,
-                                                                                    WebGLRenderingVersion::V2));
-
-                args.GetReturnValue().Set(renderingContext);
-                return;
+void
+CanvasJSIModule::CreateWebGPUContextWithPointer(const v8::FunctionCallbackInfo<v8::Value> &args) {
+    auto isolate = args.GetIsolate();
+    auto context = isolate->GetCurrentContext();
+    auto ptr = args[0]->ToBigInt(context).ToLocalChecked()->Int64Value();
 
-            } else {
-                auto width = (int32_t) args[1]->NumberValue(context).ToChecked();
-                auto height = (int32_t) args[2]->NumberValue(context).ToChecked();
-                auto ctx = canvas_native_webgl_create_no_window(
-                        width,
-                        height,
-                        version.c_str(),
-                        alpha,
-                        antialias,
-                        depth,
-                        fail_if_major_performance_caveat,
-                        power_preference.c_str(),
-                        premultiplied_alpha,
-                        preserve_drawing_buffer,
-                        stencil,
-                        desynchronized,
-                        xr_compatible,
-                        false
-                );
-
-                auto renderingContext = WebGL2RenderingContext::NewInstance(isolate,
-                                                                            new WebGL2RenderingContext(
-                                                                                    ctx,
-                                                                                    WebGLRenderingVersion::V2));
-
-                args.GetReturnValue().Set(renderingContext);
-                return;
-            }
-        }
-    }
+    auto wgpu = static_cast<CanvasGPUCanvasContext *>((void *) ptr);
 
-    args.GetReturnValue().SetNull();
+    auto ret = GPUCanvasContextImpl::NewInstance(isolate, new GPUCanvasContextImpl(
+            wgpu));
+    args.GetReturnValue().Set(ret);
 }