uwebsockets 2.0.0 → 2.2.0

package/src/Utilities.h

@@ -0,0 +1,172 @@
+/*
+ * Authored by Alex Hultman, 2018-2021.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ADDON_UTILITIES_H
+#define ADDON_UTILITIES_H
+
+#include <v8.h>
+using namespace v8;
+
+/* Unfortunately we _have_ to depend on Node.js crap */
+#include <node.h>
+
+MaybeLocal<Value> CallJS(Isolate *isolate, Local<Function> f, int argc, Local<Value> *argv) {
+    extern int calledIntoJS;
+    extern thread_local int insideCorkCallback;
+    /* All calls we do into JS are properly corked, except for res.cork, where we increase the counter explicitly */
+    insideCorkCallback++;
+    /* Slow path */
+    auto ret = node::MakeCallback(isolate, isolate->GetCurrentContext()->Global(), f, argc, argv, {0, 0});
+    insideCorkCallback--;
+    return ret;
+}
+
+Local<v8::ArrayBuffer> ArrayBuffer_New(Isolate *isolate, void *data, size_t length) {
+    std::unique_ptr<BackingStore> backingStore = ArrayBuffer::NewBackingStore(data, length, [](void* data, size_t length, void* deleter_data) {}, nullptr);
+    return ArrayBuffer::New(isolate, std::shared_ptr<BackingStore>(backingStore.release()));
+}
+
+Local<v8::ArrayBuffer> ArrayBuffer_NewCopy(Isolate *isolate, void *data, size_t length) {
+    Local<ArrayBuffer> ab = ArrayBuffer::New(isolate, length);
+    memcpy(ab->GetBackingStore()->Data(), data, length);
+    return ab;
+}
+
+struct PerSocketData {
+    UniquePersistent<Object> socketPf;
+};
+
+struct PerContextData {
+    Isolate *isolate;
+    UniquePersistent<Object> reqTemplate[2]; // 0 = non-SSL/SSL, 1 = Http3
+    UniquePersistent<Object> resTemplate[3]; // 0 = non-SSL, 1 = SSL, 2 = Http3
+    UniquePersistent<Object> wsTemplate[2];
+
+    /* We hold all apps until free */
+    std::vector<std::unique_ptr<uWS::App>> apps;
+    std::vector<std::unique_ptr<uWS::SSLApp>> sslApps;
+};
+
+template <class APP>
+static constexpr int getAppTypeIndex() {
+    /* Returns 1 for SSLApp and 0 for App */
+    //return std::is_same<APP, uWS::SSLApp>::value;
+
+    /* Returns 2 for H3App */
+
+    if constexpr (std::is_same<APP, uWS::App>::value) {
+        return 0;
+    } else if constexpr (std::is_same<APP, uWS::SSLApp>::value) {
+        return 1;
+    } else if constexpr (std::is_same<APP, uWS::H3App>::value) {
+        return 2;
+    } else {
+        // why does this fail?
+        //static_assert(false);
+    }
+}
+
+static inline bool missingArguments(int length, const FunctionCallbackInfo<Value> &args) {
+    if (args.Length() < length) {
+        std::string message = "Function requires at least ";
+        message += std::to_string(length);
+        message += " arguments.";
+        args.GetReturnValue().Set(args.GetIsolate()->ThrowException(v8::Exception::Error(String::NewFromUtf8(args.GetIsolate(), message.c_str(), NewStringType::kNormal).ToLocalChecked())));
+        return true;
+    }
+    return false;
+}
+
+struct Callback {
+    bool invalid = false;
+    UniquePersistent<Function> f;
+    Callback(Isolate *isolate, const Local<Value> &value) {
+
+        if (!value->IsFunction()) {
+            invalid = true;
+            return;
+        }
+
+        f.Reset(isolate, Local<Function>::Cast(value));
+    }
+
+    bool isInvalid(const FunctionCallbackInfo<Value> &args) {
+        if (invalid) {
+            args.GetReturnValue().Set(args.GetIsolate()->ThrowException(v8::Exception::Error(String::NewFromUtf8(args.GetIsolate(), "Passed callback is not a valid function.", NewStringType::kNormal).ToLocalChecked())));
+        }
+        return invalid;
+    }
+
+    UniquePersistent<Function> &&getFunction() {
+        return std::move(f);
+    }
+};
+
+class NativeString {
+    char *data;
+    size_t length;
+    char utf8ValueMemory[sizeof(String::Utf8Value)];
+    String::Utf8Value *utf8Value = nullptr;
+    bool invalid = false;
+public:
+    NativeString(Isolate *isolate, const Local<Value> &value) {
+        if (value->IsUndefined()) {
+            data = nullptr;
+            length = 0;
+        } else if (value->IsString()) {
+            utf8Value = new (utf8ValueMemory) String::Utf8Value(isolate, value);
+            data = (**utf8Value);
+            length = utf8Value->length();
+        } else if (value->IsTypedArray()) {
+            Local<ArrayBufferView> arrayBufferView = Local<ArrayBufferView>::Cast(value);
+            auto contents = arrayBufferView->Buffer()->GetBackingStore();
+            length = arrayBufferView->ByteLength();
+            data = (char *) contents->Data() + arrayBufferView->ByteOffset();
+        } else if (value->IsArrayBuffer()) {
+            Local<ArrayBuffer> arrayBuffer = Local<ArrayBuffer>::Cast(value);
+            auto contents = arrayBuffer->GetBackingStore();
+            length = contents->ByteLength();
+            data = (char *) contents->Data();
+        } else if (value->IsSharedArrayBuffer()) {
+            Local<SharedArrayBuffer> arrayBuffer = Local<SharedArrayBuffer>::Cast(value);
+            auto contents = arrayBuffer->GetBackingStore();
+            length = contents->ByteLength();
+            data = (char *) contents->Data();
+        } else {
+            invalid = true;
+        }
+    }
+
+    bool isInvalid(const FunctionCallbackInfo<Value> &args) {
+        if (invalid) {
+            args.GetReturnValue().Set(args.GetIsolate()->ThrowException(v8::Exception::Error(String::NewFromUtf8(args.GetIsolate(), "Text and data can only be passed by String, ArrayBuffer or TypedArray.", NewStringType::kNormal).ToLocalChecked())));
+        }
+        return invalid;
+    }
+
+    std::string_view getString() {
+        return {data, length};
+    }
+
+    ~NativeString() {
+        if (utf8Value) {
+            utf8Value->~Utf8Value();
+        }
+    }
+};
+
+#endif

package/src/WebSocketWrapper.h

@@ -0,0 +1,348 @@
+/*
+ * Authored by Alex Hultman, 2018-2020.
+ * Intellectual property of third-party.
+
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+
+ *     http://www.apache.org/licenses/LICENSE-2.0
+
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "App.h"
+#include "Utilities.h"
+
+#include <v8.h>
+using namespace v8;
+
+/* todo: probably isCorked, cork should be exposed? */
+
+struct WebSocketWrapper {
+
+    template <bool SSL>
+    static inline uWS::WebSocket<SSL, true, PerSocketData> *getWebSocket(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = (uWS::WebSocket<SSL, true, PerSocketData> *) args.Holder()->GetAlignedPointerFromInternalField(0);
+        if (!ws) {
+            args.GetReturnValue().Set(isolate->ThrowException(v8::Exception::Error(String::NewFromUtf8(isolate, "Invalid access of closed uWS.WebSocket/SSLWebSocket.", NewStringType::kNormal).ToLocalChecked())));
+        }
+        return ws;
+    }
+
+    static inline void invalidateWsObject(const FunctionCallbackInfo<Value> &args) {
+        args.Holder()->SetAlignedPointerInInternalField(0, nullptr);
+    }
+
+    /* Takes nothing returns holder (only used to fool TypeScript, as a conversion from WS to UserData) */
+    template <bool SSL>
+    static void uWS_WebSocket_getUserData(const FunctionCallbackInfo<Value> &args) {
+        args.GetReturnValue().Set(args.Holder());
+    }
+
+    /* Takes string topic */
+    template <bool SSL>
+    static void uWS_WebSocket_subscribe(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+            NativeString topic(isolate, args[0]);
+            if (topic.isInvalid(args)) {
+                return;
+            }
+            bool nonStrict = args.Length() > 1 && args[1]->BooleanValue(isolate);
+            bool success = ws->subscribe(topic.getString(), nonStrict);
+            args.GetReturnValue().Set(Boolean::New(isolate, success));
+        }
+    }
+
+    /* Takes string topic, returns boolean success */
+    template <bool SSL>
+    static void uWS_WebSocket_unsubscribe(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+            NativeString topic(isolate, args[0]);
+            if (topic.isInvalid(args)) {
+                return;
+            }
+            bool nonStrict = args.Length() > 1 && args[1]->BooleanValue(isolate);
+            bool success = ws->unsubscribe(topic.getString(), nonStrict);
+            args.GetReturnValue().Set(Boolean::New(isolate, success));
+        }
+    }
+
+    /* Takes string topic, message, returns boolean success */
+    template <bool SSL>
+    static void uWS_WebSocket_publish(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+            if (missingArguments(2, args)) {
+                return;
+            }
+
+            NativeString topic(isolate, args[0]);
+            if (topic.isInvalid(args)) {
+                return;
+            }
+            NativeString message(isolate, args[1]);
+            if (message.isInvalid(args)) {
+                return;
+            }
+
+            bool success = ws->publish(topic.getString(), message.getString(), args[2]->BooleanValue(isolate) ? uWS::OpCode::BINARY : uWS::OpCode::TEXT, args[3]->BooleanValue(isolate));
+            args.GetReturnValue().Set(Boolean::New(isolate, success));
+        }
+    }
+
+    /* It would make sense to call terminate "close" and call close "end" to line up with HTTP */
+    /* That also makes sense seince close takes message and code -> you can end with a string message */
+
+    /* Takes nothing returns nothing */
+    template <bool SSL>
+    static void uWS_WebSocket_close(const FunctionCallbackInfo<Value> &args) {
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+            invalidateWsObject(args);
+            ws->close();
+        }
+    }
+
+    /* Takes code, message, returns undefined */
+    template <bool SSL>
+    static void uWS_WebSocket_end(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+            int code = 0;
+            if (args.Length() >= 1) {
+                code = args[0]->Uint32Value(isolate->GetCurrentContext()).ToChecked();
+            }
+
+            NativeString message(args.GetIsolate(), args[1]);
+            if (message.isInvalid(args)) {
+                return;
+            }
+
+            invalidateWsObject(args);
+            ws->end(code, message.getString());
+        }
+    }
+
+    /* Takes nothing returns arraybuffer */
+    template <bool SSL>
+    static void uWS_WebSocket_getRemoteAddress(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+            std::string_view ip = ws->getRemoteAddress();
+
+            args.GetReturnValue().Set(ArrayBuffer_NewCopy(isolate, (void *) ip.data(), ip.length()));
+        }
+    }
+
+    /* Takes nothing returns arraybuffer */
+    template <bool SSL>
+    static void uWS_WebSocket_getRemoteAddressAsText(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+            std::string_view ip = ws->getRemoteAddressAsText();
+
+            args.GetReturnValue().Set(ArrayBuffer_NewCopy(isolate, (void *) ip.data(), ip.length()));
+        }
+    }
+
+    /* Takes nothing, returns integer */
+    template <bool SSL>
+    static void uWS_WebSocket_getBufferedAmount(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+            unsigned int bufferedAmount = ws->getBufferedAmount();
+            args.GetReturnValue().Set(Integer::NewFromUnsigned(isolate, bufferedAmount));
+        }
+    }
+
+    /* Takes message, isBinary, compressed. Returns true on success, false otherwise */
+    template <bool SSL>
+    static void uWS_WebSocket_sendFirstFragment(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+            NativeString message(args.GetIsolate(), args[0]);
+            if (message.isInvalid(args)) {
+                return;
+            }
+
+            unsigned int sendStatus = ws->sendFirstFragment(message.getString(), args[1]->BooleanValue(isolate) ? uWS::OpCode::BINARY : uWS::OpCode::TEXT, args[2]->BooleanValue(isolate));
+
+            args.GetReturnValue().Set(Integer::NewFromUnsigned(isolate, sendStatus));
+        }
+    }
+
+    /* Takes message, compressed. Returns true on success, false otherwise */
+    template <bool SSL>
+    static void uWS_WebSocket_sendFragment(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+            NativeString message(args.GetIsolate(), args[0]);
+            if (message.isInvalid(args)) {
+                return;
+            }
+
+            unsigned int sendStatus = ws->sendFragment(message.getString(), args[1]->BooleanValue(isolate));
+
+            args.GetReturnValue().Set(Integer::NewFromUnsigned(isolate, sendStatus));
+        }
+    }
+
+    /* Takes message, compressed. Returns true on success, false otherwise */
+    template <bool SSL>
+    static void uWS_WebSocket_sendLastFragment(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+            NativeString message(args.GetIsolate(), args[0]);
+            if (message.isInvalid(args)) {
+                return;
+            }
+
+            unsigned int sendStatus = ws->sendLastFragment(message.getString(), args[1]->BooleanValue(isolate));
+
+            args.GetReturnValue().Set(Integer::NewFromUnsigned(isolate, sendStatus));
+        }
+    }
+
+    /* Takes message, isBinary, compressed. Returns true on success, false otherwise */
+    template <bool SSL>
+    static void uWS_WebSocket_send(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+            NativeString message(args.GetIsolate(), args[0]);
+            if (message.isInvalid(args)) {
+                return;
+            }
+
+            unsigned int sendStatus = ws->send(message.getString(), args[1]->BooleanValue(isolate) ? uWS::OpCode::BINARY : uWS::OpCode::TEXT, args[2]->BooleanValue(isolate));
+
+            args.GetReturnValue().Set(Integer::NewFromUnsigned(isolate, sendStatus));
+        }
+    }
+
+    /* Takes topic string, returns bool */
+    template <bool SSL>
+    static void uWS_WebSocket_isSubscribed(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+            NativeString topic(args.GetIsolate(), args[0]);
+            if (topic.isInvalid(args)) {
+                return;
+            }
+
+            bool subscribed = ws->isSubscribed(topic.getString());
+
+            args.GetReturnValue().Set(Boolean::New(isolate, subscribed));
+        }
+    }
+
+    /* Takes message. Returns true on success, false otherwise */
+    template <bool SSL>
+    static void uWS_WebSocket_ping(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+            NativeString message(args.GetIsolate(), args[0]);
+            if (message.isInvalid(args)) {
+                return;
+            }
+
+            /* This is a wrapper that does not exist in the C++ project */
+            unsigned int sendStatus = ws->send(message.getString(), uWS::OpCode::PING);
+
+            args.GetReturnValue().Set(Integer::NewFromUnsigned(isolate, sendStatus));
+        }
+    }
+
+    /* Takes function, returns this */
+    template <bool SSL>
+    static void uWS_WebSocket_cork(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+
+            ws->cork([cb = Local<Function>::Cast(args[0]), isolate]() {
+                /* No need for CallJS here */
+                cb->Call(isolate->GetCurrentContext(), isolate->GetCurrentContext()->Global(), 0, nullptr).IsEmpty();
+            });
+
+            args.GetReturnValue().Set(args.Holder());
+        }
+    }
+
+    /* This one is wrapped instead of iterateTopics as JS-people will put their hands in wood chipper for sure. */
+    template <bool SSL>
+    static void uWS_WebSocket_getTopics(const FunctionCallbackInfo<Value> &args) {
+        Isolate *isolate = args.GetIsolate();
+        auto *ws = getWebSocket<SSL>(args);
+        if (ws) {
+
+            Local<Array> topicsArray = Array::New(isolate, 0);
+
+            ws->iterateTopics([&topicsArray, isolate](std::string_view topic) {
+                Local<String> topicString = String::NewFromUtf8(isolate, topic.data(), NewStringType::kNormal, topic.length()).ToLocalChecked();
+
+                topicsArray->Set(isolate->GetCurrentContext(), topicsArray->Length(), topicString).IsNothing();
+            });
+
+            args.GetReturnValue().Set(topicsArray);
+        }
+    }
+
+    template <bool SSL>
+    static Local<Object> init(Isolate *isolate) {
+        Local<FunctionTemplate> wsTemplateLocal = FunctionTemplate::New(isolate);
+        if (SSL) {
+            wsTemplateLocal->SetClassName(String::NewFromUtf8(isolate, "uWS.SSLWebSocket", NewStringType::kNormal).ToLocalChecked());
+        } else {
+            wsTemplateLocal->SetClassName(String::NewFromUtf8(isolate, "uWS.WebSocket", NewStringType::kNormal).ToLocalChecked());
+        }
+        wsTemplateLocal->InstanceTemplate()->SetInternalFieldCount(1);
+
+        /* Register our functions */
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "sendFirstFragment", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_sendFirstFragment<SSL>));
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "sendFragment", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_sendFragment<SSL>));
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "sendLastFragment", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_sendLastFragment<SSL>));
+
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "getUserData", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_getUserData<SSL>));
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "send", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_send<SSL>));
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "end", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_end<SSL>));
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "close", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_close<SSL>));
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "getBufferedAmount", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_getBufferedAmount<SSL>));
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "getRemoteAddress", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_getRemoteAddress<SSL>));
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "subscribe", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_subscribe<SSL>));
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "unsubscribe", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_unsubscribe<SSL>));
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "publish", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_publish<SSL>));
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "cork", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_cork<SSL>));
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "ping", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_ping<SSL>));
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "getRemoteAddressAsText", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_getRemoteAddressAsText<SSL>));
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "isSubscribed", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_isSubscribed<SSL>));
+
+        /* This one does not exist in C++ */
+        wsTemplateLocal->PrototypeTemplate()->Set(String::NewFromUtf8(isolate, "getTopics", NewStringType::kNormal).ToLocalChecked(), FunctionTemplate::New(isolate, uWS_WebSocket_getTopics<SSL>));
+
+        /* Create the template */
+        Local<Object> wsObjectLocal = wsTemplateLocal->GetFunction(isolate->GetCurrentContext()).ToLocalChecked()->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
+
+        return wsObjectLocal;
+    }
+};