From 5fd05b61ea792053a0876667f968a4348efcde32 Mon Sep 17 00:00:00 2001
From: Geequlim <geequlim@gmail.com>
Date: Mon, 22 Aug 2022 09:27:08 +0800
Subject: [PATCH 01/71] Starting port to godot 4.0

---
 ecmascript.cpp                       | 118 +++----
 ecmascript.h                         |  42 +--
 ecmascript_binder.h                  |   7 +-
 ecmascript_gc_handler.h              |  70 +++--
 ecmascript_instance.cpp              |  15 +-
 ecmascript_instance.h                |   8 +-
 ecmascript_language.cpp              |  33 +-
 ecmascript_language.h                |  17 +-
 generate_builtin_api.py              |  89 ++++--
 misc/binding_script.js               |   4 +-
 misc/godot.d.ts                      | 106 +++----
 quickjs/builtin_binding_generator.py | 175 ++++++-----
 quickjs/quickjs_binder.cpp           | 444 +++++++++++++--------------
 quickjs/quickjs_binder.h             |  19 +-
 quickjs/quickjs_builtin_binder.cpp   | 436 +++++++++++++-------------
 quickjs/quickjs_builtin_binder.h     |  20 +-
 quickjs/quickjs_debugger.cpp         |  12 +-
 quickjs/quickjs_debugger.h           |  12 +-
 register_types.cpp                   |  31 +-
 register_types.h                     |  10 +-
 tools/editor_tools.cpp               | 116 +++----
 21 files changed, 897 insertions(+), 887 deletions(-)

diff --git a/ecmascript.cpp b/ecmascript.cpp
index af114dbf..8ea7599a 100644
--- a/ecmascript.cpp
+++ b/ecmascript.cpp
@@ -1,5 +1,5 @@
 #include "ecmascript.h"
-#include "core/engine.h"
+#include "core/config/engine.h"
 #include "core/io/file_access_encrypted.h"
 #include "ecmascript_instance.h"
 #include "ecmascript_language.h"
@@ -15,8 +15,7 @@ ECMAScript::ECMAScript() {
 ECMAScript::~ECMAScript() {
 }
 
-bool ECMAScript::can_instance() const {
-
+bool ECMAScript::can_instantiate() const {
 #ifdef TOOLS_ENABLED
 	return is_valid() && (is_tool() || ScriptServer::is_scripting_enabled());
 #else
@@ -37,7 +36,7 @@ ScriptInstance *ECMAScript::instance_create(Object *p_this) {
 	ERR_FAIL_NULL_V_MSG(binder, NULL, "Cannot create instance from this thread");
 	const ECMAClassInfo *cls = NULL;
 	ECMAscriptScriptError ecma_err;
-	if (!bytecode.empty()) {
+	if (!bytecode.is_empty()) {
 		cls = binder->parse_ecma_class(bytecode, script_path, false, &ecma_err);
 	} else {
 		cls = binder->parse_ecma_class(code, script_path, false, &ecma_err);
@@ -88,7 +87,7 @@ Error ECMAScript::reload(bool p_keep_state) {
 	ECMAScriptBinder *binder = ECMAScriptLanguage::get_thread_binder(Thread::get_caller_id());
 	ERR_FAIL_COND_V_MSG(binder == NULL, ERR_INVALID_DATA, "Cannot load script in this thread");
 	ECMAscriptScriptError ecma_err;
-	if (!bytecode.empty()) {
+	if (!bytecode.is_empty()) {
 		ecma_class = binder->parse_ecma_class(bytecode, script_path, true, &ecma_err);
 	} else {
 		ecma_class = binder->parse_ecma_class(code, script_path, true, &ecma_err);
@@ -102,19 +101,15 @@ Error ECMAScript::reload(bool p_keep_state) {
 		set_last_modified_time(FileAccess::get_modified_time(script_path));
 		p_keep_state = true;
 
-		for (Set<Object *>::Element *E = instances.front(); E; E = E->next()) {
-			Object *owner = E->get();
-
-			Map<StringName, Variant> values;
+		for (Object *owner : instances) {
+			HashMap<StringName, Variant> values;
 			if (p_keep_state) {
-				const StringName *p = ecma_class->properties.next(NULL);
-				while (p) {
-					values.insert(*p, owner->get(*p));
-					p = ecma_class->properties.next(p);
+				for (const KeyValue<StringName, ECMAProperyInfo> &pair : ecma_class->properties) {
+					values.insert(pair.key, owner->get(pair.key));
 				}
 			}
 
-			ScriptInstance *si = E->get()->get_script_instance();
+			ScriptInstance *si = owner->get_script_instance();
 			if (si->is_placeholder()) {
 				PlaceHolderScriptInstance *psi = static_cast<PlaceHolderScriptInstance *>(si);
 				if (ecma_class->tool) {
@@ -130,10 +125,10 @@ Error ECMAScript::reload(bool p_keep_state) {
 			}
 
 			if (p_keep_state) {
-				for (Map<StringName, Variant>::Element *E = values.front(); E; E = E->next()) {
-					if (const ECMAProperyInfo *epi = ecma_class->properties.getptr(E->key())) {
-						const Variant &backup = E->value();
-						owner->set(E->key(), backup.get_type() == epi->type ? backup : epi->default_value);
+				for (const KeyValue<StringName, Variant> &pair : values) {
+					if (const ECMAProperyInfo *epi = ecma_class->properties.getptr(pair.key)) {
+						const Variant &backup = pair.value;
+						owner->set(pair.key, backup.get_type() == epi->type ? backup : epi->default_value);
 					}
 				}
 			}
@@ -175,18 +170,15 @@ bool ECMAScript::is_tool() const {
 
 void ECMAScript::get_script_method_list(List<MethodInfo> *p_list) const {
 	if (!ecma_class) return;
-	const StringName *key = ecma_class->methods.next(NULL);
-	while (key) {
-		p_list->push_back(ecma_class->methods.get(*key));
-		key = ecma_class->methods.next(key);
+	for (const KeyValue<StringName, MethodInfo> &pair : ecma_class->methods) {
+		p_list->push_back(pair.value);
 	}
 }
 
 void ECMAScript::get_script_property_list(List<PropertyInfo> *p_list) const {
 	if (!ecma_class) return;
-	for (const StringName *name = ecma_class->properties.next(NULL); name; name = ecma_class->properties.next(name)) {
-		const ECMAProperyInfo &pi = ecma_class->properties.get(*name);
-		p_list->push_back(pi);
+	for (const KeyValue<StringName, ECMAProperyInfo> &pair : ecma_class->properties) {
+		p_list->push_back(pair.value);
 	}
 }
 
@@ -208,15 +200,15 @@ void ECMAScript::update_exports() {
 	if (!ecma_class) return;
 
 	List<PropertyInfo> props;
-	Map<StringName, Variant> values;
-	for (const StringName *name = ecma_class->properties.next(NULL); name; name = ecma_class->properties.next(name)) {
-		const ECMAProperyInfo pi = ecma_class->properties.get(*name);
+	HashMap<StringName, Variant> values;
+	for (const KeyValue<StringName, ECMAProperyInfo> &pair : ecma_class->properties) {
+		const ECMAProperyInfo &pi = pair.value;
 		props.push_back(pi);
-		values[*name] = pi.default_value;
+		values[pair.key] = pi.default_value;
 	}
 
-	for (Set<PlaceHolderScriptInstance *>::Element *E = placeholders.front(); E; E = E->next()) {
-		E->get()->update(props, values);
+	for (PlaceHolderScriptInstance *s : placeholders) {
+		s->update(props, values);
 	}
 #endif
 }
@@ -228,8 +220,8 @@ bool ECMAScript::has_script_signal(const StringName &p_signal) const {
 
 void ECMAScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
 	if (!ecma_class) return;
-	for (const StringName *name = ecma_class->signals.next(NULL); name; name = ecma_class->signals.next(name)) {
-		r_signals->push_back(ecma_class->signals.get(*name));
+	for (const KeyValue<StringName, MethodInfo> &pair : ecma_class->signals) {
+		r_signals->push_back(pair.value);
 	}
 }
 
@@ -240,19 +232,19 @@ bool ECMAScript::is_valid() const {
 void ECMAScript::_bind_methods() {
 }
 
-RES ResourceFormatLoaderECMAScript::load(const String &p_path, const String &p_original_path, Error *r_error) {
+Ref<Resource> ResourceFormatLoaderECMAScript::load(const String &p_path, const String &p_original_path, Error *r_error) {
 	Error err = OK;
 	Ref<ECMAScriptModule> module = ResourceFormatLoaderECMAScriptModule::load_static(p_path, p_original_path, &err);
 	if (r_error) *r_error = err;
-	ERR_FAIL_COND_V_MSG(err != OK, RES(), "Cannot load script file '" + p_path + "'.");
+	ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), "Cannot load script file '" + p_path + "'.");
 	Ref<ECMAScript> script;
-	script.instance();
+	script.instantiate();
 	script->set_script_path(p_path);
 	script->bytecode = module->get_bytecode();
 	script->set_source_code(module->get_source_code());
 	err = script->reload();
 	if (r_error) *r_error = err;
-	ERR_FAIL_COND_V_MSG(err != OK, RES(), "Parse source code from file '" + p_path + "' failed.");
+	ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), "Parse source code from file '" + p_path + "' failed.");
 #ifdef TOOLS_ENABLED
 	ECMAScriptLanguage::get_singleton()->get_scripts().insert(script);
 #endif
@@ -279,7 +271,7 @@ String ResourceFormatLoaderECMAScript::get_resource_type(const String &p_path) c
 	return "";
 }
 
-Error ResourceFormatSaverECMAScript::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
+Error ResourceFormatSaverECMAScript::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
 
 	Ref<ECMAScript> script = p_resource;
 	ERR_FAIL_COND_V(script.is_null(), ERR_INVALID_PARAMETER);
@@ -287,13 +279,12 @@ Error ResourceFormatSaverECMAScript::save(const String &p_path, const RES &p_res
 	String source = script->get_source_code();
 
 	Error err;
-	FileAccessRef file = FileAccess::open(p_path, FileAccess::WRITE, &err);
+	Ref<FileAccess> file = FileAccess::open(p_path, FileAccess::WRITE, &err);
 	ERR_FAIL_COND_V_MSG(err, err, "Cannot save file '" + p_path + "'.");
 	file->store_string(source);
 	if (file->get_error() != OK && file->get_error() != ERR_FILE_EOF) {
 		return ERR_CANT_CREATE;
 	}
-	file->close();
 
 	if (ScriptServer::is_reload_scripts_on_save_enabled()) {
 		script->reload();
@@ -302,14 +293,14 @@ Error ResourceFormatSaverECMAScript::save(const String &p_path, const RES &p_res
 	return OK;
 }
 
-void ResourceFormatSaverECMAScript::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {
+void ResourceFormatSaverECMAScript::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const {
 	if (Object::cast_to<ECMAScript>(*p_resource)) {
 		p_extensions->push_back(EXT_JSCLASS);
 	}
 }
 
-bool ResourceFormatSaverECMAScript::recognize(const RES &p_resource) const {
-	return Object::cast_to<ECMAScript>(*p_resource) != NULL;
+bool ResourceFormatSaverECMAScript::recognize(const Ref<Resource> &p_resource) const {
+	return Object::cast_to<ECMAScript>(*p_resource) != nullptr;
 }
 
 void ECMAScriptModule::_bind_methods() {
@@ -326,8 +317,8 @@ ECMAScriptModule::ECMAScriptModule() {
 	set_source_code("module.exports = {};" ENDL);
 }
 
-RES ResourceFormatLoaderECMAScriptModule::load(const String &p_path, const String &p_original_path, Error *r_error) {
-	return load_static(p_path, p_original_path, r_error);
+Ref<Resource> ResourceFormatLoaderECMAScriptModule::load(const String &p_path, const String &p_original_path, Error *r_error) {
+	Ref<Resource>turn load_static(p_path, p_original_path, r_error);
 }
 
 void ResourceFormatLoaderECMAScriptModule::get_recognized_extensions(List<String> *p_extensions) const {
@@ -350,24 +341,24 @@ String ResourceFormatLoaderECMAScriptModule::get_resource_type(const String &p_p
 	return "";
 }
 
-RES ResourceFormatLoaderECMAScriptModule::load_static(const String &p_path, const String &p_original_path, Error *r_error) {
+Ref<Resource> ResourceFormatLoaderECMAScriptModule::load_static(const String &p_path, const String &p_original_path, Error *r_error) {
 	Error err = ERR_FILE_CANT_OPEN;
 	Ref<ECMAScriptModule> module;
-	module.instance();
+	module.instantiate();
 	module->set_script_path(p_path);
 	if (p_path.ends_with("." EXT_JSMODULE) || p_path.ends_with("." EXT_JSCLASS) || p_path.ends_with("." EXT_JSON)) {
 		String code = FileAccess::get_file_as_string(p_path, &err);
 		if (r_error) *r_error = err;
-		ERR_FAIL_COND_V_MSG(err != OK, RES(), "Cannot load source code from file '" + p_path + "'.");
+		ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), "Cannot load source code from file '" + p_path + "'.");
 		module->set_source_code(code);
 	} else if (p_path.ends_with("." EXT_JSMODULE_BYTECODE) || p_path.ends_with("." EXT_JSCLASS_BYTECODE)) {
 		module->set_bytecode(FileAccess::get_file_as_array(p_path, &err));
 		if (r_error) *r_error = err;
-		ERR_FAIL_COND_V_MSG(err != OK, RES(), "Cannot load bytecode from file '" + p_path + "'.");
+		ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), "Cannot load bytecode from file '" + p_path + "'.");
 	} else if (p_path.ends_with("." EXT_JSMODULE_ENCRYPTED) || p_path.ends_with("." EXT_JSCLASS_ENCRYPTED)) {
-		FileAccess *fa = FileAccess::open(p_path, FileAccess::READ);
-		if (fa->is_open()) {
-			FileAccessEncrypted *fae = memnew(FileAccessEncrypted);
+		Ref<FileAccess> fa = FileAccess::open(p_path, FileAccess::READ);
+		if (fa.is_valid() && fa->is_open()) {
+			Ref<FileAccessEncrypted> fae = memnew(FileAccessEncrypted);
 			Vector<uint8_t> key;
 			key.resize(32);
 			for (int i = 0; i < key.size(); i++) {
@@ -376,7 +367,7 @@ RES ResourceFormatLoaderECMAScriptModule::load_static(const String &p_path, cons
 			err = fae->open_and_parse(fa, key, FileAccessEncrypted::MODE_READ);
 			if (err == OK) {
 				Vector<uint8_t> encrypted_code;
-				encrypted_code.resize(fae->get_len());
+				encrypted_code.resize(fae->get_length());
 				fae->get_buffer(encrypted_code.ptrw(), encrypted_code.size());
 
 				String code;
@@ -385,45 +376,36 @@ RES ResourceFormatLoaderECMAScriptModule::load_static(const String &p_path, cons
 				} else {
 					module->set_source_code(code);
 				}
-				fa->close();
-				fae->close();
-				memdelete(fae);
-			} else {
-				fa->close();
-				fae->close();
-				memdelete(fae);
-				memdelete(fa);
 			}
 		} else {
 			err = ERR_CANT_OPEN;
 		}
 	}
 	if (r_error) *r_error = err;
-	ERR_FAIL_COND_V(err != OK, RES());
+	ERR_FAIL_COND_V(err != OK, Ref<Resource>());
 	return module;
 }
 
-Error ResourceFormatSaverECMAScriptModule::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {
+Error ResourceFormatSaverECMAScriptModule::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
 	Ref<ECMAScriptModule> module = p_resource;
 	ERR_FAIL_COND_V(module.is_null(), ERR_INVALID_PARAMETER);
 	String source = module->get_source_code();
 	Error err;
-	FileAccessRef file = FileAccess::open(p_path, FileAccess::WRITE, &err);
+	Ref<FileAccess> file = FileAccess::open(p_path, FileAccess::WRITE, &err);
 	ERR_FAIL_COND_V_MSG(err, err, "Cannot save file '" + p_path + "'.");
 	file->store_string(source);
 	if (file->get_error() != OK && file->get_error() != ERR_FILE_EOF) {
 		return ERR_CANT_CREATE;
 	}
-	file->close();
 	return OK;
 }
 
-void ResourceFormatSaverECMAScriptModule::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {
+void ResourceFormatSaverECMAScriptModule::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const {
 	if (Object::cast_to<ECMAScriptModule>(*p_resource)) {
 		p_extensions->push_back(EXT_JSMODULE);
 	}
 }
 
-bool ResourceFormatSaverECMAScriptModule::recognize(const RES &p_resource) const {
-	return Object::cast_to<ECMAScriptModule>(*p_resource) != NULL;
+bool ResourceFormatSaverECMAScriptModule::recognize(const Ref<Resource> &p_resource) const {
+	return Object::cast_to<ECMAScriptModule>(*p_resource) != nullptr;
 }
diff --git a/ecmascript.h b/ecmascript.h
index 8217031a..f2202b47 100644
--- a/ecmascript.h
+++ b/ecmascript.h
@@ -3,7 +3,7 @@
 
 #include "core/io/resource_loader.h"
 #include "core/io/resource_saver.h"
-#include "core/script_language.h"
+#include "core/object/script_language.h"
 #include "ecmascript_binder.h"
 #include "scene/resources/text_file.h"
 
@@ -23,7 +23,7 @@ class ECMAScript : public Script {
 	friend class QuickJSBinder;
 	friend class ResourceFormatLoaderECMAScript;
 
-	Set<Object *> instances;
+	HashSet<Object *> instances;
 	StringName class_name;
 	String code;
 	String script_path;
@@ -32,7 +32,7 @@ class ECMAScript : public Script {
 	const BasicECMAClassInfo *ecma_class;
 
 #ifdef TOOLS_ENABLED
-	Set<PlaceHolderScriptInstance *> placeholders;
+	HashSet<PlaceHolderScriptInstance *> placeholders;
 	virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder);
 #endif
 
@@ -41,16 +41,16 @@ class ECMAScript : public Script {
 	static void _bind_methods();
 
 public:
-	virtual bool can_instance() const;
+	virtual bool can_instantiate() const;
 
-	virtual bool inherits_script(const Ref<Script> &p_script) const { return false; }
-	virtual Ref<Script> get_base_script() const { return NULL; } //for script inheritance
-	virtual StringName get_instance_base_type() const;
+	/* TODO */ virtual Ref<Script> get_base_script() const { return nullptr; } //for script inheritance
+	/* TODO */ virtual bool inherits_script(const Ref<Script> &p_script) const { return false; }
 
+	virtual StringName get_instance_base_type() const;
 	virtual ScriptInstance *instance_create(Object *p_this);
 	virtual bool instance_has(const Object *p_this) const;
-
 	virtual PlaceHolderScriptInstance *placeholder_instance_create(Object *p_this);
+
 	virtual bool is_placeholder_fallback_enabled() const;
 
 	virtual bool has_source_code() const { return true; }
@@ -75,14 +75,18 @@ class ECMAScript : public Script {
 	virtual void update_exports(); //editor tool
 
 	/* TODO */ virtual int get_member_line(const StringName &p_member) const { return -1; }
-	/* TODO */ virtual void get_constants(Map<StringName, Variant> *p_constants) {}
-	/* TODO */ virtual void get_members(Set<StringName> *p_constants) {}
+	/* TODO */ virtual void get_constants(HashMap<StringName, Variant> *p_constants) {}
+	/* TODO */ virtual void get_members(HashSet<StringName> *p_constants) {}
 
 	virtual ScriptLanguage *get_language() const;
 
 	_FORCE_INLINE_ String get_script_path() const { return script_path; }
 	_FORCE_INLINE_ void set_script_path(const String &p_path) { script_path = p_path; }
 
+#ifdef TOOLS_ENABLED
+	_FORCE_INLINE_ virtual Vector<DocData::ClassDoc> get_documentation() { return Vector<DocData::ClassDoc>(); }
+#endif // TOOLS_ENABLED
+
 	ECMAScript();
 	virtual ~ECMAScript();
 };
@@ -90,7 +94,7 @@ class ECMAScript : public Script {
 class ResourceFormatLoaderECMAScript : public ResourceFormatLoader {
 	GDCLASS(ResourceFormatLoaderECMAScript, ResourceFormatLoader)
 public:
-	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
+	virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
 	virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const;
 	virtual bool handles_type(const String &p_type) const;
@@ -100,9 +104,9 @@ class ResourceFormatLoaderECMAScript : public ResourceFormatLoader {
 class ResourceFormatSaverECMAScript : public ResourceFormatSaver {
 	GDCLASS(ResourceFormatSaverECMAScript, ResourceFormatSaver)
 public:
-	virtual Error save(const String &p_path, const RES &p_resource, uint32_t p_flags = 0);
-	virtual void get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const;
-	virtual bool recognize(const RES &p_resource) const;
+	virtual Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags = 0);
+	virtual void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const;
+	virtual bool recognize(const Ref<Resource> &p_resource) const;
 };
 
 class ECMAScriptModule : public TextFile {
@@ -125,21 +129,21 @@ class ECMAScriptModule : public TextFile {
 class ResourceFormatLoaderECMAScriptModule : public ResourceFormatLoader {
 	GDCLASS(ResourceFormatLoaderECMAScriptModule, ResourceFormatLoader)
 public:
-	virtual RES load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
+	virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const;
 	virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const;
 	virtual bool handles_type(const String &p_type) const;
 	virtual String get_resource_type(const String &p_path) const;
 
-	static RES load_static(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
+	static Ref<Resource> load_static(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
 };
 
 class ResourceFormatSaverECMAScriptModule : public ResourceFormatSaver {
 	GDCLASS(ResourceFormatSaverECMAScriptModule, ResourceFormatSaver)
 public:
-	virtual Error save(const String &p_path, const RES &p_resource, uint32_t p_flags = 0);
-	virtual void get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const;
-	virtual bool recognize(const RES &p_resource) const;
+	virtual Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags = 0);
+	virtual void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const;
+	virtual bool recognize(const Ref<Resource> &p_resource) const;
 };
 
 #endif // ECMASCRIPT_H
diff --git a/ecmascript_binder.h b/ecmascript_binder.h
index 2ec07560..c31f53b9 100644
--- a/ecmascript_binder.h
+++ b/ecmascript_binder.h
@@ -49,6 +49,7 @@ class ECMAScriptBinder {
 	// Path ==> ECMA Class
 	HashMap<String, ECMAClassInfo> ecma_classes;
 	HashMap<int64_t, ECMAScriptGCHandler> frame_callbacks;
+	HashSet<int64_t> canceled_frame_callbacks;
 	static String BINDING_SCRIPT_CONTENT;
 
 public:
@@ -73,8 +74,8 @@ class ECMAScriptBinder {
 	virtual void *alloc_object_binding_data(Object *p_object) = 0;
 	virtual void free_object_binding_data(void *p_gc_handle) = 0;
 
-	virtual void godot_refcount_incremented(Reference *p_object) = 0;
-	virtual bool godot_refcount_decremented(Reference *p_object) = 0;
+	virtual void godot_refcount_incremented(RefCounted *p_object) = 0;
+	virtual bool godot_refcount_decremented(RefCounted *p_object) = 0;
 
 	virtual Error eval_string(const String &p_source, EvalType type, const String &p_path, ECMAScriptGCHandler &r_ret) = 0;
 	virtual Error safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, ECMAScriptGCHandler &r_ret) = 0;
@@ -88,7 +89,7 @@ class ECMAScriptBinder {
 	virtual const ECMAClassInfo *parse_ecma_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, ECMAscriptScriptError *r_error) = 0;
 
 	virtual ECMAScriptGCHandler create_ecma_instance_for_godot_object(const ECMAClassInfo *p_class, Object *p_object) = 0;
-	virtual Variant call_method(const ECMAScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) = 0;
+	virtual Variant call_method(const ECMAScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) = 0;
 	virtual bool get_instance_property(const ECMAScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) = 0;
 	virtual bool set_instance_property(const ECMAScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) = 0;
 	virtual bool has_method(const ECMAScriptGCHandler &p_object, const StringName &p_name) = 0;
diff --git a/ecmascript_gc_handler.h b/ecmascript_gc_handler.h
index 694c6e32..6ec30e2f 100644
--- a/ecmascript_gc_handler.h
+++ b/ecmascript_gc_handler.h
@@ -1,9 +1,9 @@
 #ifndef ECMASCRIPT_GC_HANDLER_H
 #define ECMASCRIPT_GC_HANDLER_H
 
-#include "core/object.h"
-#include "core/reference.h"
-#include "core/variant.h"
+#include "core/object/object.h"
+#include "core/object/ref_counted.h"
+#include "core/variant/variant.h"
 
 #define PROTOTYPE_LITERAL "prototype"
 #define PROTO_LITERAL "__proto__"
@@ -27,7 +27,7 @@ struct ECMAScriptGCHandler {
 	void *ecma_object;
 	union {
 		Object *godot_object;
-		REF *godot_reference;
+		Ref<RefCounted> *godot_reference;
 		void *godot_builtin_object_ptr;
 		void *native_ptr;
 	};
@@ -45,14 +45,14 @@ struct ECMAScriptGCHandler {
 				return *(static_cast<Vector2 *>(godot_builtin_object_ptr));
 			case Variant::RECT2:
 				return *(static_cast<Rect2 *>(godot_builtin_object_ptr));
-			case Variant::QUAT:
-				return *(static_cast<Quat *>(godot_builtin_object_ptr));
+			case Variant::QUATERNION:
+				return *(static_cast<Quaternion *>(godot_builtin_object_ptr));
 			case Variant::COLOR:
 				return *(static_cast<Color *>(godot_builtin_object_ptr));
-			case Variant::_RID:
+			case Variant::RID:
 				return *(static_cast<RID *>(godot_builtin_object_ptr));
-			case Variant::TRANSFORM:
-				return *(static_cast<Transform *>(godot_builtin_object_ptr));
+			case Variant::TRANSFORM3D:
+				return *(static_cast<Transform3D *>(godot_builtin_object_ptr));
 			case Variant::TRANSFORM2D:
 				return *(static_cast<Transform2D *>(godot_builtin_object_ptr));
 			case Variant::BASIS:
@@ -63,20 +63,24 @@ struct ECMAScriptGCHandler {
 				return *(static_cast<Plane *>(godot_builtin_object_ptr));
 			case Variant::AABB:
 				return *(static_cast<AABB *>(godot_builtin_object_ptr));
-			case Variant::POOL_INT_ARRAY:
-				return *(static_cast<PoolIntArray *>(godot_builtin_object_ptr));
-			case Variant::POOL_BYTE_ARRAY:
-				return *(static_cast<PoolByteArray *>(godot_builtin_object_ptr));
-			case Variant::POOL_REAL_ARRAY:
-				return *(static_cast<PoolRealArray *>(godot_builtin_object_ptr));
-			case Variant::POOL_COLOR_ARRAY:
-				return *(static_cast<PoolColorArray *>(godot_builtin_object_ptr));
-			case Variant::POOL_STRING_ARRAY:
-				return *(static_cast<PoolStringArray *>(godot_builtin_object_ptr));
-			case Variant::POOL_VECTOR2_ARRAY:
-				return *(static_cast<PoolVector2Array *>(godot_builtin_object_ptr));
-			case Variant::POOL_VECTOR3_ARRAY:
-				return *(static_cast<PoolVector3Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_INT32_ARRAY:
+				return *(static_cast<PackedInt32Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_INT64_ARRAY:
+				return *(static_cast<PackedInt64Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_BYTE_ARRAY:
+				return *(static_cast<PackedByteArray *>(godot_builtin_object_ptr));
+			case Variant::PACKED_FLOAT32_ARRAY:
+				return *(static_cast<PackedFloat32Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_FLOAT64_ARRAY:
+				return *(static_cast<PackedFloat64Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_COLOR_ARRAY:
+				return *(static_cast<PackedColorArray *>(godot_builtin_object_ptr));
+			case Variant::PACKED_STRING_ARRAY:
+				return *(static_cast<PackedStringArray *>(godot_builtin_object_ptr));
+			case Variant::PACKED_VECTOR2_ARRAY:
+				return *(static_cast<PackedVector2Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_VECTOR3_ARRAY:
+				return *(static_cast<PackedVector3Array *>(godot_builtin_object_ptr));
 			default:
 				return Variant();
 		}
@@ -98,18 +102,20 @@ struct ECMAScriptGCHandler {
 	_FORCE_INLINE_ AABB *getAABB() const { return static_cast<AABB *>(godot_builtin_object_ptr); }
 	_FORCE_INLINE_ Vector3 *getVector3() const { return static_cast<Vector3 *>(godot_builtin_object_ptr); }
 	_FORCE_INLINE_ Transform2D *getTransform2D() const { return static_cast<Transform2D *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Transform *getTransform() const { return static_cast<Transform *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Transform3D *getTransform3D() const { return static_cast<Transform3D *>(godot_builtin_object_ptr); }
 	_FORCE_INLINE_ Basis *getBasis() const { return static_cast<Basis *>(godot_builtin_object_ptr); }
 	_FORCE_INLINE_ RID *getRID() const { return static_cast<RID *>(godot_builtin_object_ptr); }
 	_FORCE_INLINE_ Plane *getPlane() const { return static_cast<Plane *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Quat *getQuat() const { return static_cast<Quat *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PoolIntArray *getPoolIntArray() const { return static_cast<PoolIntArray *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PoolByteArray *getPoolByteArray() const { return static_cast<PoolByteArray *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PoolRealArray *getPoolRealArray() const { return static_cast<PoolRealArray *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PoolStringArray *getPoolStringArray() const { return static_cast<PoolStringArray *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PoolColorArray *getPoolColorArray() const { return static_cast<PoolColorArray *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PoolVector2Array *getPoolVector2Array() const { return static_cast<PoolVector2Array *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PoolVector3Array *getPoolVector3Array() const { return static_cast<PoolVector3Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Quaternion *getQuaternion() const { return static_cast<Quaternion *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedInt32Array *getPackedInt32Array() const { return static_cast<PackedInt32Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedInt64Array *getPackedInt64Array() const { return static_cast<PackedInt64Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedByteArray *getPackedByteArray() const { return static_cast<PackedByteArray *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedFloat32Array *getPackedFloat32Array() const { return static_cast<PackedFloat32Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedFloat64Array *getPackedFloat64Array() const { return static_cast<PackedFloat64Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedStringArray *getPackedStringArray() const { return static_cast<PackedStringArray *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedColorArray *getPackedColorArray() const { return static_cast<PackedColorArray *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedVector2Array *getPackedVector2Array() const { return static_cast<PackedVector2Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedVector3Array *getPackedVector3Array() const { return static_cast<PackedVector3Array *>(godot_builtin_object_ptr); }
 
 	_FORCE_INLINE_ bool is_object() const {
 		return flags & FLAG_OBJECT && !(flags & FLAG_REFERENCE);
diff --git a/ecmascript_instance.cpp b/ecmascript_instance.cpp
index d2b7fe6e..6c04ae4b 100644
--- a/ecmascript_instance.cpp
+++ b/ecmascript_instance.cpp
@@ -8,10 +8,8 @@ Ref<Script> ECMAScriptInstance::get_script() const {
 
 void ECMAScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
 	if (!ecma_class) return;
-	const StringName *key = ecma_class->methods.next(NULL);
-	while (key) {
-		p_list->push_back(ecma_class->methods.get(*key));
-		key = ecma_class->methods.next(key);
+	for (const KeyValue<StringName, MethodInfo> &i: ecma_class->methods) {
+		p_list->push_back(i.value);
 	}
 }
 
@@ -32,9 +30,8 @@ bool ECMAScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
 
 void ECMAScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const {
 	if (!ecma_class) return;
-	for (const StringName *name = ecma_class->properties.next(NULL); name; name = ecma_class->properties.next(name)) {
-		const ECMAProperyInfo &pi = ecma_class->properties.get(*name);
-		p_properties->push_back(pi);
+	for (const KeyValue<StringName, ECMAProperyInfo> &i: ecma_class->properties) {
+		p_properties->push_back(i.value);
 	}
 }
 
@@ -49,9 +46,9 @@ Variant::Type ECMAScriptInstance::get_property_type(const StringName &p_name, bo
 	return Variant::NIL;
 }
 
-Variant ECMAScriptInstance::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
+Variant ECMAScriptInstance::call(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
 	if (binder == NULL || ecma_object.ecma_object == NULL) {
-		r_error.error = Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL;
+		r_error.error = Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL;
 		ERR_FAIL_V(Variant());
 	}
 	return binder->call_method(ecma_object, p_method, p_args, p_argcount, r_error);
diff --git a/ecmascript_instance.h b/ecmascript_instance.h
index 305f885a..c717fdf9 100644
--- a/ecmascript_instance.h
+++ b/ecmascript_instance.h
@@ -3,7 +3,8 @@
 
 #include "ecmascript.h"
 #include "ecmascript_binder.h"
-#include <core/script_language.h>
+#include "core/object/script_language.h"
+#include "core/variant/callable.h"
 
 class ECMAScriptInstance : public ScriptInstance {
 
@@ -28,7 +29,7 @@ class ECMAScriptInstance : public ScriptInstance {
 	virtual void get_method_list(List<MethodInfo> *p_list) const;
 	virtual bool has_method(const StringName &p_method) const;
 
-	virtual Variant call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error);
+	virtual Variant call(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error);
 
 	/* TODO */ virtual void notification(int p_notification) {}
 
@@ -44,9 +45,6 @@ class ECMAScriptInstance : public ScriptInstance {
 	/* TODO */ virtual void property_set_fallback(const StringName &p_name, const Variant &p_value, bool *r_valid) {}
 	/* TODO */ virtual Variant property_get_fallback(const StringName &p_name, bool *r_valid) { return Variant(); }
 
-	/* TODO */ virtual MultiplayerAPI::RPCMode get_rpc_mode(const StringName &p_method) const { return MultiplayerAPI::RPC_MODE_DISABLED; }
-	/* TODO */ virtual MultiplayerAPI::RPCMode get_rset_mode(const StringName &p_variable) const { return MultiplayerAPI::RPC_MODE_DISABLED; }
-
 	virtual ScriptLanguage *get_language();
 
 	ECMAScriptInstance();
diff --git a/ecmascript_language.cpp b/ecmascript_language.cpp
index db197b82..ca59b275 100644
--- a/ecmascript_language.cpp
+++ b/ecmascript_language.cpp
@@ -1,6 +1,6 @@
 #include "ecmascript_language.h"
-#include "core/class_db.h"
-#include "core/os/file_access.h"
+#include "core/object/class_db.h"
+#include "core/io/file_access.h"
 ECMAScriptLanguage *ECMAScriptLanguage::singleton = NULL;
 
 void ECMAScriptLanguage::init() {
@@ -204,26 +204,31 @@ Ref<Script> ECMAScriptLanguage::get_template(const String &p_class_name, const S
 	script_template = script_template.replace("%BASE%", p_base_class_name).replace("%CLASS%", p_class_name);
 
 	Ref<ECMAScript> script;
-	script.instance();
+	script.instantiate();
 	script->set_source_code(script_template);
 	script->set_name(p_class_name);
 	script->set_script_path(p_class_name);
 	return script;
 }
 
-void ECMAScriptLanguage::make_template(const String &p_class_name, const String &p_base_class_name, Ref<Script> &p_script) {
-	String src = p_script->get_source_code();
+Ref<Script> ECMAScriptLanguage::make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const {
+	Ref<Script> script;
+	script.instantiate();
+	String src = script->get_source_code();
 	src = src.replace("%BASE%", p_base_class_name).replace("%CLASS%", p_class_name);
-	p_script->set_source_code(src);
+	script->set_source_code(src);
+	return script;
 }
 
-bool ECMAScriptLanguage::validate(const String &p_script, int &r_line_error, int &r_col_error, String &r_test_error, const String &p_path, List<String> *r_functions, List<ScriptLanguage::Warning> *r_warnings, Set<int> *r_safe_lines) const {
+bool ECMAScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptError> *r_errors, List<Warning> *r_warnings, HashSet<int> *r_safe_lines) const {
 	ECMAscriptScriptError script_error;
 	bool ret = main_binder->validate(p_script, p_path, &script_error);
 	if (!ret) {
-		r_test_error = main_binder->error_to_string(script_error);
-		r_line_error = script_error.line;
-		r_col_error = script_error.column;
+		ScriptError se;
+		se.line = script_error.line;
+		se.column = script_error.column;
+		se.message = script_error.message;
+		r_errors->push_back(se);
 	}
 	return ret;
 }
@@ -234,8 +239,8 @@ Script *ECMAScriptLanguage::create_script() const {
 
 void ECMAScriptLanguage::reload_all_scripts() {
 #ifdef TOOLS_ENABLED
-	for (Set<Ref<ECMAScript> >::Element *E = scripts.front(); E; E = E->next()) {
-		reload_script(E->get(), true);
+	for (const Ref<ECMAScript> &s : scripts) {
+		reload_script(s, true);
 	}
 #endif
 }
@@ -277,13 +282,13 @@ void ECMAScriptLanguage::free_instance_binding_data(void *p_data) {
 
 void ECMAScriptLanguage::refcount_incremented_instance_binding(Object *p_object) {
 	if (ECMAScriptBinder *binder = get_thread_binder(Thread::get_caller_id())) {
-		binder->godot_refcount_incremented(static_cast<Reference *>(p_object));
+		binder->godot_refcount_incremented(static_cast<RefCounted *>(p_object));
 	}
 }
 
 bool ECMAScriptLanguage::refcount_decremented_instance_binding(Object *p_object) {
 	if (ECMAScriptBinder *binder = get_thread_binder(Thread::get_caller_id())) {
-		return binder->godot_refcount_decremented(static_cast<Reference *>(p_object));
+		return binder->godot_refcount_decremented(static_cast<RefCounted *>(p_object));
 	}
 	return true;
 }
diff --git a/ecmascript_language.h b/ecmascript_language.h
index 5a2a6c96..815bc8ab 100644
--- a/ecmascript_language.h
+++ b/ecmascript_language.h
@@ -1,7 +1,7 @@
 #ifndef ECMASCRIPT_LANGUAGE_H
 #define ECMASCRIPT_LANGUAGE_H
 
-#include "core/script_language.h"
+#include "core/object/script_language.h"
 #include "ecmascript.h"
 #include "quickjs/quickjs_binder.h"
 
@@ -21,7 +21,7 @@ class ECMAScriptLanguage : public ScriptLanguage {
 	int language_index;
 	HashMap<Thread::ID, ECMAScriptBinder *> thread_binder_map;
 #ifdef TOOLS_ENABLED
-	Set<Ref<ECMAScript> > scripts;
+	HashSet<Ref<ECMAScript>> scripts;
 #endif
 
 public:
@@ -39,7 +39,7 @@ class ECMAScriptLanguage : public ScriptLanguage {
 	_FORCE_INLINE_ void set_language_index(int value) { language_index = value; }
 
 #ifdef TOOLS_ENABLED
-	_FORCE_INLINE_ Set<Ref<ECMAScript> > &get_scripts() { return scripts; }
+	_FORCE_INLINE_ HashSet<Ref<ECMAScript> > &get_scripts() { return scripts; }
 #endif
 	/* LANGUAGE FUNCTIONS */
 
@@ -47,13 +47,11 @@ class ECMAScriptLanguage : public ScriptLanguage {
 	_FORCE_INLINE_ virtual String get_extension() const { return EXT_JSCLASS; }
 	_FORCE_INLINE_ virtual bool has_named_classes() const { return true; }
 	_FORCE_INLINE_ virtual bool supports_builtin_mode() const { return false; }
-	_FORCE_INLINE_ virtual bool can_inherit_from_file() { return false; }
 	_FORCE_INLINE_ virtual bool is_using_templates() { return true; }
 	_FORCE_INLINE_ virtual bool overrides_external_editor() { return false; }
 
 	virtual void init();
 	virtual void finish();
-
 	virtual Error execute_file(const String &p_path);
 
 	virtual void get_reserved_words(List<String> *p_words) const;
@@ -62,19 +60,16 @@ class ECMAScriptLanguage : public ScriptLanguage {
 	virtual void get_string_delimiters(List<String> *p_delimiters) const;
 
 	virtual Ref<Script> get_template(const String &p_class_name, const String &p_base_class_name) const;
-	virtual void make_template(const String &p_class_name, const String &p_base_class_name, Ref<Script> &p_script);
+	virtual Ref<Script> make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const;
 
-	virtual bool validate(const String &p_script, int &r_line_error, int &r_col_error, String &r_test_error, const String &p_path = "", List<String> *r_functions = NULL, List<Warning> *r_warnings = NULL, Set<int> *r_safe_lines = NULL) const;
+	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptError> *r_errors = nullptr, List<Warning> *r_warnings = nullptr, HashSet<int> *r_safe_lines = nullptr) const;
 	virtual String validate_path(const String &p_path) const { return ""; }
 	virtual Script *create_script() const;
 
 	/* TODO */ virtual int find_function(const String &p_function, const String &p_code) const { return -1; }
-	/* TODO */ virtual String make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const { return ""; }
+	/* TODO */ virtual String make_function(const String &p_class, const String &p_name, const PackedStringArray &p_args) const { return ""; }
 	/* TODO */ virtual Error open_in_external_editor(const Ref<Script> &p_script, int p_line, int p_col) { return ERR_UNAVAILABLE; }
 
-	/* TODO */ virtual Error complete_code(const String &p_code, const String &p_path, Object *p_owner, List<ScriptCodeCompletionOption> *r_options, bool &r_force, String &r_call_hint) { return ERR_UNAVAILABLE; }
-	/* TODO */ virtual Error lookup_code(const String &p_code, const String &p_symbol, const String &p_base_path, Object *p_owner, LookupResult &r_result) { return ERR_UNAVAILABLE; }
-
 	/* TODO */ virtual void auto_indent_code(String &p_code, int p_from_line, int p_to_line) const {}
 	/* TODO */ virtual void add_global_constant(const StringName &p_variable, const Variant &p_value) {}
 	/* TODO */ virtual void add_named_global_constant(const StringName &p_name, const Variant &p_value) {}
diff --git a/generate_builtin_api.py b/generate_builtin_api.py
index b145fad3..a4d71800 100755
--- a/generate_builtin_api.py
+++ b/generate_builtin_api.py
@@ -8,19 +8,21 @@
 	'Color',
 	'Vector3',
 	'Basis',
-	'Quat',
+	'Quaternion',
 	'RID',
 	'Transform2D',
 	'Plane',
 	'AABB',
-	"Transform",
-	"PoolByteArray",
-	"PoolIntArray",
-	"PoolRealArray",
-	"PoolStringArray",
-	"PoolVector2Array",
-	"PoolVector3Array",
-	"PoolColorArray",
+	"Transform3D",
+	"PackedByteArray",
+	"PackedInt32Array",
+	"PackedInt64Array",
+	"PackedFloat32Array",
+	"PackedFloat64Array",
+	"PackedStringArray",
+	"PackedVector2Array",
+	"PackedVector3Array",
+	"PackedColorArray",
 ]
 
 MAX_CONSTRUCTOR_ARGC = {
@@ -29,19 +31,21 @@
 	'Color': 4,
 	'Vector3': 3,
 	'Basis': 0,
-	'Quat': 0,
+	'Quaternion': 0,
 	'RID': 0,
 	'Transform2D': 0,
 	'Plane': 0,
 	'AABB': 0,
-	"Transform": 0,
-	"PoolByteArray": 0,
-	"PoolIntArray": 0,
-	"PoolRealArray": 0,
-	"PoolStringArray": 0,
-	"PoolVector2Array": 0,
-	"PoolVector3Array": 0,
-	"PoolColorArray": 0,
+	"Transform3D": 0,
+	"PackedByteArray": 0,
+	"PackedInt32Array": 0,
+	"PackedInt64Array": 0,
+	"PackedFloat32Array": 0,
+	"PackedFloat64Array": 0,
+	"PackedStringArray": 0,
+	"PackedVector2Array": 0,
+	"PackedVector3Array": 0,
+	"PackedColorArray": 0,
 }
 
 TYPE_MAP = {
@@ -203,7 +207,7 @@
 	"return": "boolean"
 }
 
-METHOD_POOL_ARRAY_GET = {
+METHOD_PACKED_ARRAY_GET = {
 	"arguments": [
 		{
 			"default_value": None,
@@ -217,26 +221,41 @@
 }
 
 IGNORED_PROPS = {
-	"Rect2": ['end', 'grow_margin'],
+	"Rect2": ['end', 'grow_side'],
 	"Color": ['h', 's', 'v', 'r8', 'g8', 'b8', 'a8'],
 	"Transform2D": ['xform', 'xform_inv'],
-	"Basis": ['is_equal_approx'],
+	"Quaternion": ['get_euler'],
+	"Basis": ['is_equal_approx', 'get_euler', 'from_euler'],
 	"Plane": ['intersects_segment', 'intersects_ray', 'intersect_3'],
 	"AABB": ['end'],
-	"Transform": ['xform', 'xform_inv'],
-	"PoolByteArray": ['compress', 'decompress', 'decompress_dynamic', 'get_string_from_ascii', 'get_string_from_utf8', 'hex_encode'],
+	"Transform3D": ['xform', 'xform_inv'],
+	"PackedByteArray": [
+		'compress',
+		'decompress',
+		'decompress_dynamic',
+		'get_string_from_ascii',
+		'get_string_from_utf8',
+		'get_string_from_utf16',
+		'get_string_from_utf32',
+		'hex_encode',
+		'to_float32_array',
+		'to_float64_array',
+		'to_int32_array',
+		'to_int64_array',
+		'has_encoded_var',
+	],
 }
 
 PROPERTY_REMAP = {
 	"Transform2D": {
-		"x": "elements[0]",
-		"y": "elements[1]",
-		"origin": "elements[2]",
+		"x": "columns[0]",
+		"y": "columns[1]",
+		"origin": "columns[2]",
 	},
 	"Basis": {
-		"x": "elements[0]",
-		"y": "elements[1]",
-		"z": "elements[2]",
+		"x": "rows[0]",
+		"y": "rows[1]",
+		"z": "rows[2]",
 	},
 	"Plane": {
 		"x": "normal.x",
@@ -283,7 +302,7 @@
 		METHOD_OP_MUL,
 		METHOD_OP_MUL_ASSIGN,
 	],
-	"Quat": [
+	"Quaternion": [
 		METHOD_OP_NEG,
 		METHOD_OP_EQUALS,
 		METHOD_OP_ADD,
@@ -324,7 +343,7 @@
 	"AABB": [
 		METHOD_OP_EQUALS,
 	],
-	"Transform": [
+	"Transform3D": [
 		METHOD_OP_EQUALS,
 		METHOD_OP_MUL,
 		METHOD_OP_MUL_ASSIGN,
@@ -370,11 +389,13 @@ def parse_class(cls):
 			continue# ignore constructors
 		if class_name in IGNORED_PROPS and method_name in IGNORED_PROPS[class_name]:
 			continue# ignored methods
+		if class_name == 'PackedByteArray' and method_name.startswith('encode_') or method_name.startswith('decode_'):
+			continue# ignore decode/encode methods
 		return_type = m.find("return").attrib["type"] if m.find("return") != None else "void"
 		if return_type in TYPE_MAP:
 			return_type = TYPE_MAP[return_type]
 		arguments = []
-		for arg in m.iter('argument'):
+		for arg in m.iter('param'):
 			dictArg = dict(arg.attrib)
 			if "dictArg" in dictArg: dictArg.pop("index")
 			dictArg["default_value"] = dictArg["default"] if "default" in dictArg else None
@@ -393,8 +414,8 @@ def parse_class(cls):
 			'return': return_type,
 			'arguments': arguments,
 		})
-	if class_name.startswith("Pool") and class_name.endswith("Array"):
-		methods.append(METHOD_POOL_ARRAY_GET)
+	if class_name.startswith("Packed") and class_name.endswith("Array"):
+		methods.append(METHOD_PACKED_ARRAY_GET)
 	# add operator methods
 	if class_name in OPERATOR_METHODS:
 		for em in OPERATOR_METHODS[class_name]:
diff --git a/misc/binding_script.js b/misc/binding_script.js
index 719d53f7..e4b13ba6 100644
--- a/misc/binding_script.js
+++ b/misc/binding_script.js
@@ -1,6 +1,6 @@
 (function start_script_binding() {
 	
-	const GodotAnonymousConnectionManager = new(class GodotAnonymousConnectionManager extends godot.Reference {
+	const GodotAnonymousConnectionManager = new(class GodotAnonymousConnectionManager extends godot.RefCounted {
 		anonymous_connection_index = 0;
 		
 		get_slot_id(emitter, signal, target) {
@@ -235,7 +235,7 @@
 	});
 
 	// iterator of Pool*Vector
-	const pool_classes = [ godot.PoolByteArray, godot.PoolIntArray, godot.PoolRealArray, godot.PoolStringArray, godot.PoolVector2Array, godot.PoolVector3Array, godot.PoolColorArray ];
+	const pool_classes = [ godot.PackedByteArray, godot.PackedInt32Array, godot.PackedFloat32Array, godot.PackedStringArray, godot.PackedVector2Array, godot.PackedVector3Array, godot.PackedColorArray ];
 	for (const pool_class of pool_classes) {
 		Object.defineProperty(pool_class.prototype, Symbol.iterator, {value: function iterator() {
 			let next_index = 0;
diff --git a/misc/godot.d.ts b/misc/godot.d.ts
index 89c6903c..68d64b50 100644
--- a/misc/godot.d.ts
+++ b/misc/godot.d.ts
@@ -634,7 +634,7 @@ declare module godot {
 
 		constructor();
 		constructor(from: Basis);
-		constructor(from: Quat);
+		constructor(from: Quaternion);
 		constructor(from: Vector3);
 		constructor(axis: Vector3, phi: number);
 		constructor(x_axis: Vector3, y_axis: Vector3, z_axis: Vector3);
@@ -659,7 +659,7 @@ declare module godot {
 		get_orthogonal_index() : number;
 
 		/**  */
-		get_rotation_quat() : Quat;
+		get_rotation_quat() : Quaternion;
 
 		/** Assuming that the matrix is the combination of a rotation and scaling, return the absolute value of scaling factors along each axis. */
 		get_scale() : Vector3;
@@ -722,7 +722,7 @@ declare module godot {
 	 Represents one or many transformations in 3D space such as translation, rotation, or scaling. It consists of a `basis` and an `origin`. It is similar to a 3×4 matrix. */
 	class Transform {
 		constructor(from: Transform);
-		constructor(from: Quat);
+		constructor(from: Quaternion);
 		constructor(from: Basis);
 		constructor(from: Transform2D);
 		constructor(basis: Basis, origin: Vector3);
@@ -766,10 +766,10 @@ declare module godot {
 		/** Translates the transform by the specified offset. */
 		translated(ofs: Vector3) : Transform;
 
-		/** Transforms the given `Vector3`, `Plane`, `AABB`, or `PoolVector3Array` by this transform. */
+		/** Transforms the given `Vector3`, `Plane`, `AABB`, or `PackedVector3Array` by this transform. */
 		xform<T extends Vector3|Plane|AABB >(v: T) : T;
 
-		/** Inverse-transforms the given `Vector3`, `Plane`, `AABB`, or `PoolVector3Array` by this transform. */
+		/** Inverse-transforms the given `Vector3`, `Plane`, `AABB`, or `PackedVector3Array` by this transform. */
 		xform_inv<T extends Vector3|Plane|AABB >(v: T) : T;
 	}
 
@@ -849,10 +849,10 @@ declare module godot {
 		/** Translates the transform by the given offset. */
 		translated(offset: Vector2) : Transform2D;
 
-		/** Transforms the given `Vector2`, `Rect2`, or `PoolVector2Array` by this transform. */
+		/** Transforms the given `Vector2`, `Rect2`, or `PackedVector2Array` by this transform. */
 		xform<T extends Vector2 | Rect2 >(v: T) : T;
 
-		/** Inverse-transforms the given `Vector2`, `Rect2`, or `PoolVector2Array` by this transform. */
+		/** Inverse-transforms the given `Vector2`, `Rect2`, or `PackedVector2Array` by this transform. */
 		xform_inv<T extends Vector2 | Rect2 >(v: T) : T;
 
 	}
@@ -1731,8 +1731,8 @@ declare module godot {
 	 It is similar to `Basis`, which implements matrix representation of rotations, and can be parametrized using both an axis-angle pair or Euler angles. But due to its compactness and the way it is stored in memory, certain operations (obtaining axis-angle and performing SLERP, in particular) are more efficient and robust against floating-point errors.
 
 	 Quaternions need to be (re)normalized. */
-	class Quat {
-		constructor(from: Quat);
+	class Quaternion {
+		constructor(from: Quaternion);
 		constructor(from: Basis);
 		constructor(euler: Vector3);
 		constructor(axis: Vector3, angle: number);
@@ -1752,19 +1752,19 @@ declare module godot {
 
 
 		/** Performs a cubic spherical-linear interpolation with another quaternion. */
-		cubic_slerp(b: Quat, pre_a: Quat, post_b: Quat, t: number) : Quat;
+		cubic_slerp(b: Quaternion, pre_a: Quaternion, post_b: Quaternion, t: number) : Quaternion;
 
 		/** Returns the dot product of two quaternions. */
-		dot(b: Quat) : number;
+		dot(b: Quaternion) : number;
 
 		/** Returns Euler angles (in the YXZ convention: first Z, then X, and Y last) corresponding to the rotation represented by the unit quaternion. Returned vector contains the rotation angles in the format (X angle, Y angle, Z angle). */
 		get_euler() : Vector3;
 
 		/** Returns the inverse of the quaternion. */
-		inverse() : Quat;
+		inverse() : Quaternion;
 
 		/**  */
-		is_equal_approx(quat: Quat) : boolean;
+		is_equal_approx(quat: Quaternion) : boolean;
 
 		/** Returns whether the quaternion is normalized or not. */
 		is_normalized() : boolean;
@@ -1776,7 +1776,7 @@ declare module godot {
 		length_squared() : number;
 
 		/** Returns a copy of the quaternion, normalized to unit length. */
-		normalized() : Quat;
+		normalized() : Quaternion;
 
 		/** Sets the quaternion to a rotation which rotates around axis by the specified angle, in radians. The axis must be a normalized vector. */
 		set_axis_angle(axis: Vector3, angle: number) : void;
@@ -1785,19 +1785,19 @@ declare module godot {
 		set_euler(euler: Vector3) : void;
 
 		/** Performs a spherical-linear interpolation with another quaternion. */
-		slerp(b: Quat, t: number) : Quat;
+		slerp(b: Quaternion, t: number) : Quaternion;
 
 		/** Performs a spherical-linear interpolation with another quaterion without checking if the rotation path is not bigger than 90°. */
-		slerpni(b: Quat, t: number) : Quat;
+		slerpni(b: Quaternion, t: number) : Quaternion;
 
 		/** Transforms the vector `v` by this quaternion. */
 		xform(v: Vector3) : Vector3;
 
 	}
 
-	namespace Quat {
-		/** @value `Quat( 0, 0, 0, 1 )` */
-		const IDENTITY: Readonly<Quat>;
+	namespace Quaternion {
+		/** @value `Quaternion( 0, 0, 0, 1 )` */
+		const IDENTITY: Readonly<Quaternion>;
 	}
 	
 	/** Axis-Aligned Bounding Box.
@@ -1886,10 +1886,10 @@ declare module godot {
 	 An `Array` specifically designed to hold bytes. Optimized for memory usage, does not fragment the memory.
 
 	 **Note:** This type is passed by value and not by reference. */
-	class PoolByteArray {
+	class PackedByteArray {
 		
 		constructor(source?: number[]);
-		constructor(from: PoolByteArray);
+		constructor(from: PackedByteArray);
 		constructor(from: ArrayBuffer);
 		constructor(from: DataView);
 		[Symbol.iterator](): IterableIterator<number>;
@@ -1897,14 +1897,14 @@ declare module godot {
 		/** Appends an element at the end of the array (alias of `push_back`). */
 		append(byte: number) : void;
 
-		/** Appends a `PoolByteArray` at the end of this array. */
-		append_array(array: PoolByteArray) : void;
+		/** Appends a `PackedByteArray` at the end of this array. */
+		append_array(array: PackedByteArray) : void;
 
-		/** Returns a new `PoolByteArray` with the data compressed. Set the compression mode using one of `File.CompressionMode`'s constants. */
-		compress(compression_mode?: number) : PoolByteArray;
+		/** Returns a new `PackedByteArray` with the data compressed. Set the compression mode using one of `File.CompressionMode`'s constants. */
+		compress(compression_mode?: number) : PackedByteArray;
 
-		/** Returns a new `PoolByteArray` with the data decompressed. Set `buffer_size` to the size of the uncompressed data. Set the compression mode using one of `File.CompressionMode`'s constants. */
-		decompress(buffer_size: number, compression_mode?: number) : PoolByteArray;
+		/** Returns a new `PackedByteArray` with the data decompressed. Set `buffer_size` to the size of the uncompressed data. Set the compression mode using one of `File.CompressionMode`'s constants. */
+		decompress(buffer_size: number, compression_mode?: number) : PackedByteArray;
 
 		/** Returns `true` if the array is empty. */
 		empty() : boolean;
@@ -1942,8 +1942,8 @@ declare module godot {
 		/** Returns the size of the array. */
 		size() : number;
 
-		/** Returns the slice of the `PoolByteArray` between indices (inclusive) as a new `PoolByteArray`. Any negative index is considered to be from the end of the array. */
-		subarray(p_from: number, to: number) : PoolByteArray;
+		/** Returns the slice of the `PackedByteArray` between indices (inclusive) as a new `PackedByteArray`. Any negative index is considered to be from the end of the array. */
+		subarray(p_from: number, to: number) : PackedByteArray;
 		
 		/** Returns the content of the array as an `ArrayBuffer` */
 		get_buffer() : ArrayBuffer;
@@ -1953,11 +1953,11 @@ declare module godot {
 	 An `Array` specifically designed to hold `Color`. Optimized for memory usage, does not fragment the memory.
 
 	 **Note:** This type is passed by value and not by reference. */
-	class PoolColorArray {
+	class PackedColorArray {
 
 
 		constructor(source?: Color[]);
-		constructor(from: PoolColorArray);
+		constructor(from: PackedColorArray);
 		constructor(from: ArrayBuffer);
 		constructor(from: DataView);
 		[Symbol.iterator](): IterableIterator<Color>;
@@ -1965,8 +1965,8 @@ declare module godot {
 		/** Appends an element at the end of the array (alias of `push_back`). */
 		append(color: Color) : void;
 
-		/** Appends a `PoolColorArray` at the end of this array. */
-		append_array(array: PoolColorArray) : void;
+		/** Appends a `PackedColorArray` at the end of this array. */
+		append_array(array: PackedColorArray) : void;
 
 		/** Returns `true` if the array is empty. */
 		empty() : boolean;
@@ -2005,11 +2005,11 @@ declare module godot {
 	 **Note:** This type is passed by value and not by reference.
 
 	 **Note:** This type is limited to signed 32-bit integers, which means it can only take values in the interval ``-2^31, 2^31 - 1``, i.e. ``-2147483648, 2147483647``. Exceeding those bounds will wrap around. In comparison, `int` uses signed 64-bit integers which can hold much larger values. */
-	class PoolIntArray {
+	class PackedInt32Array {
 
 
 		constructor(source?: number[]);
-		constructor(from: PoolIntArray);
+		constructor(from: PackedInt32Array);
 		constructor(from: ArrayBuffer);
 		constructor(from: DataView);
 		[Symbol.iterator](): IterableIterator<number>;
@@ -2017,8 +2017,8 @@ declare module godot {
 		/** Appends an element at the end of the array (alias of `push_back`). */
 		append(integer: number) : void;
 
-		/** Appends a `PoolIntArray` at the end of this array. */
-		append_array(array: PoolIntArray) : void;
+		/** Appends a `PackedInt32Array` at the end of this array. */
+		append_array(array: PackedInt32Array) : void;
 
 		/** Returns `true` if the array is empty. */
 		empty() : boolean;
@@ -2055,10 +2055,10 @@ declare module godot {
 	 An `Array` specifically designed to hold floating-point values (`float`). Optimized for memory usage, does not fragment the memory.
 
 	 **Note:** This type is passed by value and not by reference. */
-	class PoolRealArray {
+	class PackedFloat32Array {
 
 		constructor(source?: number[]);
-		constructor(from: PoolRealArray);
+		constructor(from: PackedFloat32Array);
 		constructor(from: ArrayBuffer);
 		constructor(from: DataView);
 		[Symbol.iterator](): IterableIterator<number>;
@@ -2066,8 +2066,8 @@ declare module godot {
 		/** Appends an element at the end of the array (alias of `push_back`). */
 		append(value: number) : void;
 
-		/** Appends a `PoolRealArray` at the end of this array. */
-		append_array(array: PoolRealArray) : void;
+		/** Appends a `PackedFloat32Array` at the end of this array. */
+		append_array(array: PackedFloat32Array) : void;
 
 		/** Returns `true` if the array is empty. */
 		empty() : boolean;
@@ -2104,18 +2104,18 @@ declare module godot {
 	 An `Array` specifically designed to hold `String`s. Optimized for memory usage, does not fragment the memory.
 
 	 **Note:** This type is passed by value and not by reference. */
-	class PoolStringArray {
+	class PackedStringArray {
 
 
 		constructor(source?: string[]);
-		constructor(from: PoolStringArray);
+		constructor(from: PackedStringArray);
 		[Symbol.iterator](): IterableIterator<string>;
 
 		/** Appends an element at the end of the array (alias of `push_back`). */
 		append(p_string: string) : void;
 
-		/** Appends a `PoolStringArray` at the end of this array. */
-		append_array(array: PoolStringArray) : void;
+		/** Appends a `PackedStringArray` at the end of this array. */
+		append_array(array: PackedStringArray) : void;
 
 		/** Returns `true` if the array is empty. */
 		empty() : boolean;
@@ -2152,10 +2152,10 @@ declare module godot {
 	 An `Array` specifically designed to hold `Vector2`. Optimized for memory usage, does not fragment the memory.
 
 	 **Note:** This type is passed by value and not by reference. */
-	class PoolVector2Array {
+	class PackedVector2Array {
 
 		constructor(source?: Vector2[]);
-		constructor(from: PoolVector2Array);
+		constructor(from: PackedVector2Array);
 		constructor(from: ArrayBuffer);
 		constructor(from: DataView);
 		[Symbol.iterator](): IterableIterator<Vector2>;
@@ -2163,8 +2163,8 @@ declare module godot {
 		/** Appends an element at the end of the array (alias of `push_back`). */
 		append(vector2: Vector2) : void;
 
-		/** Appends a `PoolVector2Array` at the end of this array. */
-		append_array(array: PoolVector2Array) : void;
+		/** Appends a `PackedVector2Array` at the end of this array. */
+		append_array(array: PackedVector2Array) : void;
 
 		/** Returns `true` if the array is empty. */
 		empty() : boolean;
@@ -2201,10 +2201,10 @@ declare module godot {
 	 An `Array` specifically designed to hold `Vector3`. Optimized for memory usage, does not fragment the memory.
 
 	 **Note:** This type is passed by value and not by reference. */
-	class PoolVector3Array {
+	class PackedVector3Array {
 
 		constructor(source?: Vector3[]);
-		constructor(from: PoolVector3Array);
+		constructor(from: PackedVector3Array);
 		constructor(from: ArrayBuffer);
 		constructor(from: DataView);
 		[Symbol.iterator](): IterableIterator<Vector3>;
@@ -2212,8 +2212,8 @@ declare module godot {
 		/** Appends an element at the end of the array (alias of `push_back`). */
 		append(vector3: Vector3) : void;
 
-		/** Appends a `PoolVector3Array` at the end of this array. */
-		append_array(array: PoolVector3Array) : void;
+		/** Appends a `PackedVector3Array` at the end of this array. */
+		append_array(array: PackedVector3Array) : void;
 
 		/** Returns `true` if the array is empty. */
 		empty() : boolean;
diff --git a/quickjs/builtin_binding_generator.py b/quickjs/builtin_binding_generator.py
index edf16b0a..33ddca21 100644
--- a/quickjs/builtin_binding_generator.py
+++ b/quickjs/builtin_binding_generator.py
@@ -6,27 +6,30 @@
 API = json.load(open(os.path.join(DIR, '..', 'builtin_api.gen.json'), 'r'))
 
 VariantTypes = {
+	"Variant": "Variant::NIL",
 	"boolean": "Variant::BOOL",
-	"number": "Variant::REAL",
+	"number": "Variant::FLOAT",
 	"string": "Variant::STRING",
 	"Vector2": "Variant::VECTOR2",
 	"Vector3": "Variant::VECTOR3",
 	"Basis": "Variant::BASIS",
-	"Quat": "Variant::QUAT",
+	"Quaternion": "Variant::QUATERNION",
 	"Color": "Variant::COLOR",
 	"Rect2": "Variant::RECT2",
-	"RID": "Variant::_RID",
+	"RID": "Variant::RID",
 	"Transform2D": "Variant::TRANSFORM2D",
 	"Plane": "Variant::PLANE",
 	"AABB": "Variant::AABB",
-	"Transform": "Variant::TRANSFORM",
-	"PoolByteArray": "Variant::POOL_BYTE_ARRAY",
-	"PoolIntArray": "Variant::POOL_INT_ARRAY",
-	"PoolRealArray": "Variant::POOL_REAL_ARRAY",
-	"PoolStringArray": "Variant::POOL_STRING_ARRAY",
-	"PoolVector2Array": "Variant::POOL_VECTOR2_ARRAY",
-	"PoolVector3Array": "Variant::POOL_VECTOR3_ARRAY",
-	"PoolColorArray": "Variant::POOL_COLOR_ARRAY",
+	"Transform3D": "Variant::TRANSFORM3D",
+	"PackedByteArray": "Variant::PACKED_BYTE_ARRAY",
+	"PackedInt32Array": "Variant::PACKED_INT32_ARRAY",
+	"PackedInt64Array": "Variant::PACKED_INT64_ARRAY",
+	"PackedFloat32Array": "Variant::PACKED_FLOAT32_ARRAY",
+	"PackedFloat64Array": "Variant::PACKED_FLOAT64_ARRAY",
+	"PackedStringArray": "Variant::PACKED_STRING_ARRAY",
+	"PackedVector2Array": "Variant::PACKED_VECTOR2_ARRAY",
+	"PackedVector3Array": "Variant::PACKED_VECTOR3_ARRAY",
+	"PackedColorArray": "Variant::PACKED_COLOR_ARRAY",
 }
 
 JSToGodotTemplates = {
@@ -39,18 +42,20 @@
 	"RID": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getRID()',
 	"AABB": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getAABB()',
 	"Plane": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPlane()',
-	"Quat": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getQuat()',
+	"Quaternion": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getQuaternion()',
 	"Transform2D": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getTransform2D()',
 	"Vector3": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getVector3()',
 	"Basis": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getBasis()',
-	"Transform": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getTransform()',
-	"PoolByteArray": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPoolByteArray()',
-	"PoolIntArray": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPoolIntArray()',
-	"PoolRealArray": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPoolRealArray()',
-	"PoolStringArray": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPoolStringArray()',
-	"PoolVector2Array": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPoolVector2Array()',
-	"PoolVector3Array": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPoolVector3Array()',
-	"PoolColorArray": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPoolColorArray()',
+	"Transform3D": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getTransform3D()',
+	"PackedByteArray": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedByteArray()',
+	"PackedInt32Array": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedInt32Array()',
+	"PackedInt64Array": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedInt64Array()',
+	"PackedFloat32Array": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedFloat32Array()',
+	"PackedFloat64Array": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedFloat64Array()',
+	"PackedStringArray": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedStringArray()',
+	"PackedVector2Array": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedVector2Array()',
+	"PackedVector3Array": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedVector3Array()',
+	"PackedColorArray": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedColorArray()',
 	"Variant": '(BINDING_DATA_FROM_JS(ctx, ${arg}))->get_value()',
 }
 
@@ -64,18 +69,20 @@
 	"RID": "RID",
 	"AABB": "AABB",
 	"Plane": "Plane",
-	"Quat": "Quat",
+	"Quaternion": "Quaternion",
 	"Transform2D": "Transform2D",
 	"Vector3": "Vector3",
 	"Basis": "Basis",
-	"Transform": "Transform",
-	"PoolByteArray": "PoolByteArray",
-	"PoolIntArray": "PoolIntArray",
-	"PoolRealArray": "PoolRealArray",
-	"PoolStringArray": "PoolStringArray",
-	"PoolVector2Array": "PoolVector2Array",
-	"PoolVector3Array": "PoolVector3Array",
-	"PoolColorArray": "PoolColorArray",
+	"Transform3D": "Transform3D",
+	"PackedByteArray": "PackedByteArray",
+	"PackedInt32Array": "PackedInt32Array",
+	"PackedInt64Array": "PackedInt64Array",
+	"PackedFloat32Array": "PackedFloat32Array",
+	"PackedFloat64Array": "PackedFloat64Array",
+	"PackedStringArray": "PackedStringArray",
+	"PackedVector2Array": "PackedVector2Array",
+	"PackedVector3Array": "PackedVector3Array",
+	"PackedColorArray": "PackedColorArray",
 	"Variant": "Variant",
 }
 
@@ -89,18 +96,20 @@
 	"RID": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
 	"AABB": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
 	"Plane": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"Quat": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
+	"Quaternion": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
 	"Transform2D": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
 	"Vector3": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
 	"Basis": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"Transform": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PoolByteArray": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PoolIntArray": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PoolRealArray": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PoolStringArray": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PoolVector2Array": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PoolVector3Array": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PoolColorArray": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
+	"Transform3D": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
+	"PackedByteArray": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
+	"PackedInt32Array": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
+	"PackedInt64Array": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
+	"PackedFloat32Array": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
+	"PackedFloat64Array": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
+	"PackedStringArray": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
+	"PackedVector2Array": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
+	"PackedVector3Array": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
+	"PackedColorArray": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
 	"Variant": 'QuickJSBinder::variant_to_var(ctx, ${arg})',
 }
 
@@ -125,7 +134,7 @@ def generate_constructor(cls):
 	// return QuickJSBuiltinBinder::create_builtin_value(ctx, ${type}, &tmp);
 }
 '''
-	TemplateSimplePoolArrays = '''
+	TemplateSimplePackedArrays = '''
 	if (argc == 1) {
 #ifdef DEBUG_METHODS_ENABLED
 		ERR_FAIL_COND_V(!JS_IsArray(ctx, argv[0]), (JS_ThrowTypeError(ctx, "Array expected for argument #0 of ${class}(from)")));
@@ -134,7 +143,7 @@ def generate_constructor(cls):
 		tmp.operator=(arr);
 	}
 	'''
-	TemplatePoolArrays = '''
+	TemplatePackedArrays = '''
 	if (argc == 1) {
 		if (JS_IsArray(ctx, argv[0])) {
 			Variant arr = QuickJSBinder::var_to_variant(ctx, argv[0]);
@@ -147,7 +156,7 @@ def generate_constructor(cls):
 					ERR_PRINT("Length of the ArrayBuffer does not match for ${class}");
 				}
 				tmp.resize(size / sizeof(${element}));
-				memcpy(tmp.write().ptr(), buffer, size / sizeof(${element}) * sizeof(${element}));
+				memcpy(tmp.ptrw(), buffer, size / sizeof(${element}) * sizeof(${element}));
 			}
 		} else if (JS_IsDataView(argv[0])) {
 			JSValue byte_length = JS_GetPropertyStr(ctx, argv[0], "byteLength");
@@ -164,7 +173,7 @@ def generate_constructor(cls):
 			JS_FreeValue(ctx, arraybuffer);
 			if (length) {
 				tmp.resize(length / sizeof(${element}));
-				memcpy(tmp.write().ptr(), buffer + offset, length / sizeof(${element}) * sizeof(${element}));
+				memcpy(tmp.ptrw(), buffer + offset, length / sizeof(${element}) * sizeof(${element}));
 			}
 		} else {
 #ifdef DEBUG_METHODS_ENABLED
@@ -290,7 +299,7 @@ def generate_constructor(cls):
 		}
 	}
 ''',
-		"Quat": '''
+		"Quaternion": '''
 	if (argc == 4) {
 		tmp.x = QuickJSBinder::js_to_number(ctx, argv[0]);
 		tmp.y = QuickJSBinder::js_to_number(ctx, argv[1]);
@@ -298,18 +307,20 @@ def generate_constructor(cls):
 		tmp.w = QuickJSBinder::js_to_number(ctx, argv[3]);
 	} else if (argc == 2) {
 #ifdef DEBUG_METHODS_ENABLED
-		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 0 of Quat(axis, angle)")));
+		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 0 of Quaternion(axis, angle)")));
 #endif
 		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
-		tmp = Quat(*param0->getVector3(), QuickJSBinder::js_to_number(ctx, argv[1]));
+		tmp = Quaternion(*param0->getVector3(), QuickJSBinder::js_to_number(ctx, argv[1]));
 	} else if (argc == 1) {
 		if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
-			if (bind->type == Variant::QUAT) {
-				tmp = *bind->getQuat();
+			if (bind->type == Variant::QUATERNION) {
+				tmp = *bind->getQuaternion();
 			} else if (bind->type == Variant::BASIS) {
 				tmp = *bind->getBasis();
 			} else if (bind->type == Variant::VECTOR3) {
-				tmp.set_euler(*bind->getVector3());
+				Basis basis;
+				basis.from_euler(*bind->getVector3());
+				tmp = basis.get_rotation_quaternion();
 			}
 		}
 	}
@@ -324,9 +335,9 @@ def generate_constructor(cls):
 		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
 		ECMAScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
 		ECMAScriptGCHandler *param2 = BINDING_DATA_FROM_JS(ctx, argv[2]);
-		tmp.elements[0].operator=(*param0->getVector2());
-		tmp.elements[1].operator=(*param1->getVector2());
-		tmp.elements[2].operator=(*param2->getVector2());
+		tmp.columns[0].operator=(*param0->getVector2());
+		tmp.columns[1].operator=(*param1->getVector2());
+		tmp.columns[2].operator=(*param2->getVector2());
 	} else if (argc == 2) {
 #ifdef DEBUG_METHODS_ENABLED
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR2, argv[1]), (JS_ThrowTypeError(ctx, "Vector2 expected for argument 1 of Transform2D(rotation, position)")));
@@ -354,9 +365,9 @@ def generate_constructor(cls):
 		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
 		ECMAScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
 		ECMAScriptGCHandler *param2 = BINDING_DATA_FROM_JS(ctx, argv[2]);
-		tmp.elements[0].operator=(*param0->getVector3());
-		tmp.elements[1].operator=(*param1->getVector3());
-		tmp.elements[2].operator=(*param2->getVector3());
+		tmp.rows[0].operator=(*param0->getVector3());
+		tmp.rows[1].operator=(*param1->getVector3());
+		tmp.rows[2].operator=(*param2->getVector3());
 	} else if (argc == 2) {
 #ifdef DEBUG_METHODS_ENABLED
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 0 of Basis(axis, phi)")));
@@ -367,35 +378,35 @@ def generate_constructor(cls):
 		if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
 			if (bind->type == Variant::VECTOR3) {
 				tmp.set_euler(*bind->getVector3());
-			} else if (bind->type == Variant::QUAT) {
-				tmp.set_quat(*bind->getQuat());
+			} else if (bind->type == Variant::QUATERNION) {
+				tmp.set_quaternion(*bind->getQuaternion());
 			} else if (bind->type == Variant::BASIS) {
 				tmp.operator=(*bind->getBasis());
 			}
 		}
 	}
 ''',
-		"Transform": '''
+		"Transform3D": '''
 	if (argc == 4) {
 #ifdef DEBUG_METHODS_ENABLED
-		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 0 of Transform(x_axis, y_axis, z_axis, origin)")));
-		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[1]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 1 of Transform(x_axis, y_axis, z_axis, origin)")));
-		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[2]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 2 of Transform(x_axis, y_axis, z_axis, origin)")));
-		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[3]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 3 of Transform(x_axis, y_axis, z_axis, origin)")));
+		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 0 of Transform3D(x_axis, y_axis, z_axis, origin)")));
+		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[1]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 1 of Transform3D(x_axis, y_axis, z_axis, origin)")));
+		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[2]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 2 of Transform3D(x_axis, y_axis, z_axis, origin)")));
+		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[3]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 3 of Transform3D(x_axis, y_axis, z_axis, origin)")));
 #endif
 		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
 		ECMAScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
 		ECMAScriptGCHandler *param2 = BINDING_DATA_FROM_JS(ctx, argv[2]);
 		ECMAScriptGCHandler *param3 = BINDING_DATA_FROM_JS(ctx, argv[3]);
 
-		tmp.basis.elements[0].operator=(*param0->getVector3());
-		tmp.basis.elements[1].operator=(*param1->getVector3());
-		tmp.basis.elements[2].operator=(*param2->getVector3());
+		tmp.basis.rows[0].operator=(*param0->getVector3());
+		tmp.basis.rows[1].operator=(*param1->getVector3());
+		tmp.basis.rows[2].operator=(*param2->getVector3());
 		tmp.origin.operator=(*param3->getVector3());
 	} else if (argc == 2) {
 #ifdef DEBUG_METHODS_ENABLED
-		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::BASIS, argv[0]), (JS_ThrowTypeError(ctx, "Basis expected for argument 0 of Transform(basis, origin)")));
-		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[1]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 1 of Transform(basis, origin)")));
+		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::BASIS, argv[0]), (JS_ThrowTypeError(ctx, "Basis expected for argument 0 of Transform3D(basis, origin)")));
+		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[1]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 1 of Transform3D(basis, origin)")));
 #endif
 		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
 		ECMAScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
@@ -403,21 +414,23 @@ def generate_constructor(cls):
 		tmp.origin.operator=(*param1->getVector3());
 	} else if (argc == 1) {
 		if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
-			if (bind->type == Variant::TRANSFORM) {
-				tmp.operator=(*bind->getTransform());
-			} else if (Variant::can_convert(bind->type, Variant::TRANSFORM)) {
+			if (bind->type == Variant::TRANSFORM3D) {
+				tmp.operator=(*bind->getTransform3D());
+			} else if (Variant::can_convert(bind->type, Variant::TRANSFORM3D)) {
 				tmp.operator=(bind->get_value());
 			}
 		}
 	}
 ''',
-		"PoolByteArray": apply_pattern(TemplatePoolArrays, {"class": "PoolByteArray", "type": "Variant::POOL_BYTE_ARRAY", "element": "uint8_t"}),
-		"PoolIntArray": apply_pattern(TemplatePoolArrays, {"class": "PoolIntArray", "type": "Variant::POOL_INT_ARRAY", "element": "int"}),
-		"PoolRealArray": apply_pattern(TemplatePoolArrays, {"class": "PoolRealArray", "type": "Variant::POOL_REAL_ARRAY", "element": "real_t"}),
-		"PoolVector2Array": apply_pattern(TemplatePoolArrays, {"class": "PoolVector2Array", "type": "Variant::POOL_VECTOR2_ARRAY", "element": "Vector2"}),
-		"PoolVector3Array": apply_pattern(TemplatePoolArrays, {"class": "PoolVector3Array", "type": "Variant::POOL_VECTOR3_ARRAY", "element": "Vector3"}),
-		"PoolColorArray": apply_pattern(TemplatePoolArrays, {"class": "PoolColorArray", "type": "Variant::POOL_COLOR_ARRAY", "element": "Color"}),
-		"PoolStringArray": apply_pattern(TemplateSimplePoolArrays,{"class": "PoolStringArray", "type": "Variant::POOL_STRING_ARRAY", "element": "String"}),
+		"PackedByteArray": apply_pattern(TemplatePackedArrays, {"class": "PackedByteArray", "type": "Variant::PACKED_BYTE_ARRAY", "element": "uint8_t"}),
+		"PackedInt32Array": apply_pattern(TemplatePackedArrays, {"class": "PackedInt32Array", "type": "Variant::PACKED_INT32_ARRAY", "element": "int32_t"}),
+		"PackedInt64Array": apply_pattern(TemplatePackedArrays, {"class": "PackedInt64Array", "type": "Variant::PACKED_INT64_ARRAY", "element": "int64_t"}),
+		"PackedFloat32Array": apply_pattern(TemplatePackedArrays, {"class": "PackedFloat32Array", "type": "Variant::PACKED32_FLOAT_ARRAY", "element": "real_t"}),
+		"PackedFloat64Array": apply_pattern(TemplatePackedArrays, {"class": "PackedFloat64Array", "type": "Variant::PACKED64_FLOAT_ARRAY", "element": "real_t"}),
+		"PackedVector2Array": apply_pattern(TemplatePackedArrays, {"class": "PackedVector2Array", "type": "Variant::PACKED_VECTOR2_ARRAY", "element": "Vector2"}),
+		"PackedVector3Array": apply_pattern(TemplatePackedArrays, {"class": "PackedVector3Array", "type": "Variant::PACKED_VECTOR3_ARRAY", "element": "Vector3"}),
+		"PackedColorArray": apply_pattern(TemplatePackedArrays, {"class": "PackedColorArray", "type": "Variant::PACKED_COLOR_ARRAY", "element": "Color"}),
+		"PackedStringArray": apply_pattern(TemplateSimplePackedArrays,{"class": "PackedStringArray", "type": "Variant::PACKED_STRING_ARRAY", "element": "String"}),
 	}
 	class_name = cls['name']
 	constructor_name = apply_pattern(TemplateConstructorName, {"class": class_name})
@@ -426,13 +439,13 @@ def generate_constructor(cls):
 	initializer = ''
 	if class_name in ConstructorInitializers:
 		initializer = ConstructorInitializers[class_name]
-	consturctor = apply_pattern(TemplateConstructor, {
+	constructor = apply_pattern(TemplateConstructor, {
 		'class': class_name,
 		'type': VariantTypes[class_name],
 		'func': constructor_name,
 		'initializer': initializer
 	})
-	return constructor_name, constructor_declare, consturctor
+	return constructor_name, constructor_declare, constructor
 
 def generate_property_bindings(cls):
 	class_name = cls['name']
@@ -671,7 +684,7 @@ def generate_class_bind_action(cls, constructor):
 
 def generate_builtin_bindings():
 	Template = '''\
-#include "core/variant.h"
+#include "core/variant/variant.h"
 #include "quickjs_binder.h"
 #include "quickjs_builtin_binder.h"
 
@@ -693,9 +706,9 @@ def generate_builtin_bindings():
 	definitions = ''
 	bindings = ''
 	for cls in API:
-		constructor_name, constructor_declare, consturctor = generate_constructor(cls)
+		constructor_name, constructor_declare, constructor = generate_constructor(cls)
 		declarations += constructor_declare
-		definitions += consturctor
+		definitions += constructor
 		bindings += generate_class_bind_action(cls, constructor_name)
 		
 		property_declare, property_defines, property_bind= generate_property_bindings(cls)
diff --git a/quickjs/quickjs_binder.cpp b/quickjs/quickjs_binder.cpp
index 1bd0f12d..35b048c7 100644
--- a/quickjs/quickjs_binder.cpp
+++ b/quickjs/quickjs_binder.cpp
@@ -2,25 +2,26 @@
 #include "../ecmascript.h"
 #include "../ecmascript_instance.h"
 #include "../ecmascript_language.h"
-#include "core/bind/core_bind.h"
-#include "core/engine.h"
-#include "core/global_constants.h"
+#include "core/config/engine.h"
+#include "core/config/project_settings.h"
+#include "core/core_bind.h"
+#include "core/core_constants.h"
+#include "core/io/file_access.h"
 #include "core/io/json.h"
 #include "core/math/expression.h"
-#include "core/os/file_access.h"
 #include "core/os/os.h"
-#include "core/project_settings.h"
 #include "quickjs_binder.h"
 #include "quickjs_worker.h"
 #ifdef TOOLS_ENABLED
 #include "editor/editor_settings.h"
 #endif
+#include <cstring>
 
 SafeNumeric<uint32_t> QuickJSBinder::global_context_id;
 SafeNumeric<uint64_t> QuickJSBinder::global_transfer_id;
 
 HashMap<uint64_t, Variant> QuickJSBinder::transfer_deopot;
-Map<String, const char *> QuickJSBinder::class_remap;
+HashMap<String, const char *> QuickJSBinder::class_remap;
 List<String> compiling_modules;
 
 struct GodotMethodArguments {
@@ -65,7 +66,7 @@ _FORCE_INLINE_ static ECMAScriptGCHandler *BINDING_DATA_FROM_GD(JSContext *ctx,
 }
 
 JSValue QuickJSBinder::console_functions(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic) {
-	PoolStringArray args;
+	PackedStringArray args;
 	args.resize(argc);
 
 	QuickJSBinder *binder = get_context_binder(ctx);
@@ -77,19 +78,26 @@ JSValue QuickJSBinder::console_functions(JSContext *ctx, JSValue this_val, int a
 		int32_t tag = JS_VALUE_GET_TAG(argv[i]);
 		if (to_json && tag == JS_TAG_OBJECT && NULL == BINDING_DATA_FROM_JS(ctx, argv[i])) {
 			JSValue str = JS_JSONStringify(ctx, argv[i], JS_UNDEFINED, JS_UNDEFINED);
-			args.write()[i] = js_to_string(ctx, str);
+			args.write[i] = js_to_string(ctx, str);
 			JS_FreeValue(ctx, str);
 		} else {
 			size_t size;
 			const char *utf8 = JS_ToCStringLen(ctx, &size, argv[i]);
-			args.write()[i].parse_utf8(utf8, size);
+			args.write[i].parse_utf8(utf8, size);
 			JS_FreeCString(ctx, utf8);
 		}
 	}
 
 	ECMAScriptStackInfo stack_top;
 	List<ECMAScriptStackInfo> stacks;
-	String message = args.join(" ");
+	String message = "";
+	for (int i = 0; i < argc; ++i) {
+		message += args[i];
+		if (i > 0 && i < argc - 1) {
+			message += " ";
+		}
+	}
+
 	if (magic == CONSOLE_ERROR || magic == CONSOLE_TRACE || magic == CONSOLE_WARN) {
 		if (binder->get_stacks(stacks) == OK) {
 			stack_top = stacks.front()->get();
@@ -156,31 +164,31 @@ JSValue QuickJSBinder::object_method(JSContext *ctx, JSValueConst this_val, int
 		args.arguments[i] = var_to_variant(ctx, argv[i]);
 	}
 
-	Variant::CallError call_err;
+	Callable::CallError call_err;
 	Variant ret_val = mb->call(obj, args.ptr, argc, call_err);
 	JSValue ret = variant_to_var(ctx, ret_val);
 #ifdef DEBUG_METHODS_ENABLED
 	String err_message;
 	switch (call_err.error) {
-		case Variant::CallError::CALL_ERROR_INVALID_ARGUMENT:
-			err_message = vformat("Argument of type '%s' is not assignable to parameter #%d of type '%s'", Variant::get_type_name(args.arguments[call_err.argument].get_type()), call_err.argument, Variant::get_type_name(call_err.expected));
+		case Callable::CallError::CALL_ERROR_INVALID_ARGUMENT:
+			err_message = vformat("Argument of type '%s' is not assignable to parameter #%d of type '%s'", Variant::get_type_name(args.arguments[call_err.argument].get_type()), call_err.argument, Variant::get_type_name((Variant::Type)call_err.expected));
 			break;
-		case Variant::CallError::CALL_ERROR_INVALID_METHOD:
+		case Callable::CallError::CALL_ERROR_INVALID_METHOD:
 			err_message = vformat("Invalid method '%s' for type '%s'", mb->get_name(), obj->get_class_name());
 			break;
-		case Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
+		case Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
 			err_message = vformat("Too few arguments for method '%s'", mb->get_name());
 			break;
-		case Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:
+		case Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:
 			err_message = vformat("Too many arguments for method '%s'", mb->get_name());
 			break;
-		case Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL:
+		case Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL:
 			err_message = vformat("Attempt to call '%s' on a null instance.", mb->get_name());
 			break;
 		default:
 			break;
 	}
-	if (call_err.error != Variant::CallError::CALL_OK) {
+	if (call_err.error != Callable::CallError::CALL_OK) {
 		List<ECMAScriptStackInfo> stacks;
 		String stack_message;
 		if (binder->get_stacks(stacks) == OK) {
@@ -213,7 +221,7 @@ JSValue QuickJSBinder::object_indexed_property(JSContext *ctx, JSValue this_val,
 		args.arguments[1] = var_to_variant(ctx, argv[0]);
 	}
 
-	Variant::CallError call_err;
+	Callable::CallError call_err;
 	Variant ret_val = mb->call(obj, args.ptr, argc + 1, call_err);
 	return variant_to_var(ctx, ret_val);
 }
@@ -224,7 +232,7 @@ JSValue QuickJSBinder::variant_to_var(JSContext *ctx, const Variant p_var) {
 			return ((bool)p_var) ? JS_TRUE : JS_FALSE;
 		case Variant::INT:
 			return JS_NewInt64(ctx, int64_t(p_var));
-		case Variant::REAL:
+		case Variant::FLOAT:
 			return JS_NewFloat64(ctx, (double)(p_var));
 		case Variant::NODE_PATH:
 		case Variant::STRING:
@@ -328,9 +336,9 @@ Variant QuickJSBinder::var_to_variant(JSContext *ctx, JSValue p_val) {
 JSValue QuickJSBinder::godot_builtin_function(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic) {
 
 	Variant ret;
-	Variant::CallError err;
+	Callable::CallError err;
 	String err_msg;
-
+#if 0 // TODO: builtin functions
 	Expression::BuiltinFunc func = (Expression::BuiltinFunc)magic;
 	int arg_required = Expression::get_func_argument_count(func);
 	if (argc < arg_required) {
@@ -373,6 +381,8 @@ JSValue QuickJSBinder::godot_builtin_function(JSContext *ctx, JSValue this_val,
 		return JS_ThrowTypeError(ctx, "Call builtin function error %s: %s", func_name.ascii().get_data(), err_msg.utf8().get_data());
 	}
 
+#endif
+
 	return variant_to_var(ctx, ret);
 }
 
@@ -382,7 +392,7 @@ bool QuickJSBinder::validate_type(JSContext *ctx, Variant::Type p_type, JSValueC
 			return JS_IsNull(p_val) || JS_IsUndefined(p_val);
 		case Variant::BOOL:
 		case Variant::INT:
-		case Variant::REAL:
+		case Variant::FLOAT:
 			return JS_IsNumber(p_val) || JS_IsBool(p_val) || JS_IsNull(p_val) || JS_IsUndefined(p_val);
 		case Variant::STRING:
 			return JS_IsString(p_val);
@@ -435,10 +445,11 @@ Error QuickJSBinder::get_stacks(List<ECMAScriptStackInfo> &r_stacks) {
 	Vector<String> raw_stacks = stack_text.split("\n", false);
 	for (int i = 1; i < raw_stacks.size(); i++) {
 		String line_text = raw_stacks[i].strip_edges();
-		if (line_text.empty()) continue;
+		if (line_text.is_empty())
+			continue;
 		ECMAScriptStackInfo s;
-		int colon = line_text.find_last(":");
-		int bracket = line_text.find_last("(");
+		int colon = line_text.rfind(":");
+		int bracket = line_text.rfind("(");
 		s.line = line_text.substr(colon + 1, line_text.length() - colon - 2).to_int();
 		s.file = line_text.substr(bracket + 1, colon - bracket - 1);
 		s.function = line_text.substr(3, bracket - 4);
@@ -464,11 +475,11 @@ String QuickJSBinder::get_backtrace_message(const List<ECMAScriptStackInfo> &sta
 
 Dictionary QuickJSBinder::js_to_dictionary(JSContext *ctx, const JSValue &p_val, List<void *> &stack) {
 	Dictionary dict;
-	Set<String> keys;
+	HashSet<String> keys;
 	get_own_property_names(ctx, p_val, &keys);
 	stack.push_back(JS_VALUE_GET_PTR(p_val));
-	for (Set<String>::Element *E = keys.front(); E; E = E->next()) {
-		JSValue v = JS_GetPropertyStr(ctx, p_val, E->get().utf8().get_data());
+	for (const String &key : keys) {
+		JSValue v = JS_GetPropertyStr(ctx, p_val, key.utf8().get_data());
 		Variant val;
 		if (JS_IsObject(v)) {
 			void *ptr = JS_VALUE_GET_PTR(v);
@@ -478,7 +489,7 @@ Dictionary QuickJSBinder::js_to_dictionary(JSContext *ctx, const JSValue &p_val,
 					uint64_t i;
 				} u;
 				u.p = ptr;
-				ERR_PRINT(vformat("Property '%s' circular reference to 0x%X", E->get(), u.i));
+				ERR_PRINT(vformat("Property '%s' circular reference to 0x%X", key, u.i));
 				JS_FreeValue(ctx, v);
 				continue;
 			} else {
@@ -489,7 +500,7 @@ Dictionary QuickJSBinder::js_to_dictionary(JSContext *ctx, const JSValue &p_val,
 		} else {
 			val = var_to_variant(ctx, v);
 		}
-		dict[E->get()] = val;
+		dict[key] = val;
 		JS_FreeValue(ctx, v);
 	}
 	stack.pop_back();
@@ -525,7 +536,7 @@ JSValue QuickJSBinder::godot_load(JSContext *ctx, JSValue this_val, int argc, JS
 	ERR_FAIL_COND_V(argc < 1 || !JS_IsString(argv[0]), JS_ThrowTypeError(ctx, "string expected for %s.%s", GODOT_OBJECT_NAME, "load"));
 #endif
 	String path = js_to_string(ctx, argv[0]);
-	RES res = ResourceLoader::load(path);
+	Ref<Resource> res = ResourceLoader::load(path);
 	return variant_to_var(ctx, res);
 }
 
@@ -533,7 +544,7 @@ JSValue QuickJSBinder::godot_instance_from_id(JSContext *ctx, JSValue this_val,
 #ifdef DEBUG_METHODS_ENABLED
 	ERR_FAIL_COND_V(argc < 1 || !JS_IsNumber(argv[0]), JS_ThrowTypeError(ctx, "number expected for %s.%s", GODOT_OBJECT_NAME, "instance_from_id"));
 #endif
-	ObjectID id = js_to_uint64(ctx, argv[0]);
+	ObjectID id(js_to_uint64(ctx, argv[0]));
 	Object *obj = ObjectDB::get_instance(id);
 	return variant_to_var(ctx, obj);
 }
@@ -612,8 +623,8 @@ JSModuleDef *QuickJSBinder::js_module_loader(JSContext *ctx, const char *module_
 	resolving_file.parse_utf8(module_name);
 
 	String file = resolve_module_file(resolving_file);
-	ERR_FAIL_COND_V_MSG(file.empty(), NULL, "Failed to resolve module: '" + resolving_file + "'.");
-	resolve_path_cache.set(resolving_file, file);
+	ERR_FAIL_COND_V_MSG(file.is_empty(), NULL, "Failed to resolve module: '" + resolving_file + "'.");
+	resolve_path_cache.insert(resolving_file, file);
 
 	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
 	if (ModuleCache *ptr = binder->module_cache.getptr(file)) {
@@ -648,7 +659,7 @@ JSModuleDef *QuickJSBinder::js_module_loader(JSContext *ctx, const char *module_
 			}
 
 		} else { // Try load as Resource
-			RES res = ResourceLoader::load(file);
+			Ref<Resource> res = ResourceLoader::load(file);
 			if (res.is_null()) {
 				JS_ThrowReferenceError(ctx, "Could not load module '%s'", file.utf8().get_data());
 				return NULL;
@@ -666,7 +677,7 @@ JSModuleDef *QuickJSBinder::js_module_loader(JSContext *ctx, const char *module_
 			module.res_value = val;
 			module.flags = MODULE_FLAG_RESOURCE;
 			module.module = m;
-			binder->module_cache.set(file, module);
+			binder->module_cache.insert(file, module);
 		}
 	}
 
@@ -750,7 +761,7 @@ QuickJSBinder::ModuleCache *QuickJSBinder::js_compile_and_cache_module(JSContext
 	ModuleCache mc = js_compile_module(ctx, p_code, p_filename, r_error);
 	mc.hash = p_code.hash();
 	if (mc.module) {
-		binder->module_cache.set(p_filename, mc);
+		binder->module_cache.insert(p_filename, mc);
 	}
 	return binder->module_cache.getptr(p_filename);
 }
@@ -797,7 +808,6 @@ int QuickJSBinder::resource_module_initializer(JSContext *ctx, JSModuleDef *m) {
 }
 
 JSClassID QuickJSBinder::register_class(const ClassDB::ClassInfo *p_cls) {
-
 	ClassBindData data;
 	data.class_id = 0;
 	data.base_class = NULL;
@@ -821,22 +831,17 @@ JSClassID QuickJSBinder::register_class(const ClassDB::ClassInfo *p_cls) {
 	data.prototype = JS_NewObject(ctx);
 
 	// methods
-	Map<StringName, JSValue> methods;
+	HashMap<StringName, JSValue> methods;
 	{
 		godot_methods.resize(internal_godot_method_id + p_cls->method_map.size());
-		const StringName *key = p_cls->method_map.next(NULL);
-		while (key) {
-			MethodBind *mb = p_cls->method_map.get(*key);
-			godot_methods.write[internal_godot_method_id] = mb;
-
-			CharString name = String(*key).ascii();
+		for (const KeyValue<StringName, MethodBind *> &pair : p_cls->method_map) {
+			MethodBind *mb = pair.value;
+			godot_methods.set(internal_godot_method_id, mb);
+			CharString name = String(pair.key).ascii();
 			JSValue method = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_method, name.get_data(), mb->get_argument_count(), JS_CFUNC_generic_magic, internal_godot_method_id);
 			JS_DefinePropertyValueStr(ctx, data.prototype, name.get_data(), method, PROP_DEF_DEFAULT);
-
-			methods.insert(*key, method);
-
+			methods.insert(pair.key, method);
 			++internal_godot_method_id;
-			key = p_cls->method_map.next(key);
 		}
 
 		if (p_cls->name == "Object") {
@@ -852,10 +857,9 @@ JSClassID QuickJSBinder::register_class(const ClassDB::ClassInfo *p_cls) {
 
 	// properties
 	{
-		const StringName *key = p_cls->property_setget.next(NULL);
-		while (key) {
-			const StringName &prop_name = *key;
-			const ClassDB::PropertySetGet &prop = p_cls->property_setget[prop_name];
+		for (const KeyValue<StringName, ClassDB::PropertySetGet> &i : p_cls->property_setget) {
+			const StringName &prop_name = i.key;
+			const ClassDB::PropertySetGet &prop = i.value;
 
 			JSValue setter = JS_UNDEFINED;
 			JSValue getter = JS_UNDEFINED;
@@ -866,13 +870,13 @@ JSClassID QuickJSBinder::register_class(const ClassDB::ClassInfo *p_cls) {
 					godot_object_indexed_properties.resize(size + 128);
 				}
 				godot_object_indexed_properties.write[internal_godot_indexed_property_id] = &prop;
-				CharString name = String(*key).ascii();
+				CharString name = String(prop_name).ascii();
 				getter = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_indexed_property, name.get_data(), 0, JS_CFUNC_generic_magic, internal_godot_indexed_property_id);
 				setter = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_indexed_property, name.get_data(), 1, JS_CFUNC_generic_magic, internal_godot_indexed_property_id);
 				++internal_godot_indexed_property_id;
 			} else {
-				if (Map<StringName, JSValue>::Element *E = methods.find(prop.setter)) {
-					setter = E->get();
+				if (HashMap<StringName, JSValue>::ConstIterator it = methods.find(prop.setter)) {
+					setter = it->value;
 					JS_DupValue(ctx, setter);
 				} else if (MethodBind *mb = prop._setptr) {
 					if (godot_methods.size() >= internal_godot_method_id) {
@@ -884,8 +888,8 @@ JSClassID QuickJSBinder::register_class(const ClassDB::ClassInfo *p_cls) {
 					++internal_godot_method_id;
 				}
 
-				if (Map<StringName, JSValue>::Element *E = methods.find(prop.getter)) {
-					getter = E->get();
+				if (HashMap<StringName, JSValue>::ConstIterator it = methods.find(prop.getter)) {
+					getter = it->value;
 					JS_DupValue(ctx, getter);
 				} else if (MethodBind *mb = prop._getptr) {
 					if (godot_methods.size() >= internal_godot_method_id) {
@@ -901,7 +905,6 @@ JSClassID QuickJSBinder::register_class(const ClassDB::ClassInfo *p_cls) {
 			JSAtom atom = get_atom(ctx, prop_name);
 			JS_DefinePropertyGetSet(ctx, data.prototype, atom, getter, setter, PROP_DEF_DEFAULT);
 			JS_FreeAtom(ctx, atom);
-			key = p_cls->property_setget.next(key);
 		}
 	}
 
@@ -915,57 +918,38 @@ JSClassID QuickJSBinder::register_class(const ClassDB::ClassInfo *p_cls) {
 	JS_DefinePropertyValue(ctx, data.constructor, js_key_godot_classid, JS_NewInt32(ctx, data.class_id), PROP_DEF_DEFAULT);
 
 	// constants
-	{
-		const StringName *key = p_cls->constant_map.next(NULL);
-		while (key) {
-
-			int value = p_cls->constant_map.get(*key);
-			JSAtom atom = get_atom(ctx, *key);
-			JS_DefinePropertyValue(ctx, data.constructor, atom, JS_NewInt32(ctx, value), PROP_DEF_DEFAULT);
-			JS_FreeAtom(ctx, atom);
-
-			key = p_cls->constant_map.next(key);
-		}
+	for (const KeyValue<StringName, int64_t> &pair : p_cls->constant_map) {
+		JSAtom atom = get_atom(ctx, pair.key);
+		JS_DefinePropertyValue(ctx, data.constructor, atom, JS_NewInt64(ctx, pair.value), PROP_DEF_DEFAULT);
+		JS_FreeAtom(ctx, atom);
 	}
 
 	// enumeration
-	{
-		const StringName *key = p_cls->enum_map.next(NULL);
-		while (key) {
-
-			JSValue enum_obj = JS_NewObject(ctx);
-			JSAtom atom = get_atom(ctx, *key);
-
-			const List<StringName> &const_keys = p_cls->enum_map.get(*key);
-			for (const List<StringName>::Element *E = const_keys.front(); E; E = E->next()) {
-				int value = p_cls->constant_map.get(E->get());
-				JSAtom atom_key = get_atom(ctx, E->get());
-				JS_DefinePropertyValue(ctx, enum_obj, atom_key, JS_NewInt32(ctx, value), PROP_DEF_DEFAULT);
-				JS_FreeAtom(ctx, atom_key);
-			}
-
-			JS_DefinePropertyValue(ctx, data.constructor, atom, enum_obj, PROP_DEF_DEFAULT);
-			JS_FreeAtom(ctx, atom);
-
-			key = p_cls->enum_map.next(key);
+	for (const KeyValue<StringName, ClassDB::ClassInfo::EnumInfo> &pair : p_cls->enum_map) {
+		JSValue enum_obj = JS_NewObject(ctx);
+		JSAtom atom = get_atom(ctx, pair.key);
+
+		const List<StringName> &const_keys = pair.value.constants;
+		for (const List<StringName>::Element *E = const_keys.front(); E; E = E->next()) {
+			int value = p_cls->constant_map.get(E->get());
+			JSAtom atom_key = get_atom(ctx, E->get());
+			JS_DefinePropertyValue(ctx, enum_obj, atom_key, JS_NewInt32(ctx, value), PROP_DEF_DEFAULT);
+			JS_FreeAtom(ctx, atom_key);
 		}
+
+		JS_DefinePropertyValue(ctx, data.constructor, atom, enum_obj, PROP_DEF_DEFAULT);
+		JS_FreeAtom(ctx, atom);
 	}
 
 	// signals
-	{
-		const StringName *key = p_cls->signal_map.next(NULL);
-		while (key) {
-
-			JSAtom atom = get_atom(ctx, *key);
-			JS_DefinePropertyValue(ctx, data.constructor, atom, to_js_string(ctx, *key), PROP_DEF_DEFAULT);
-			JS_FreeAtom(ctx, atom);
-
-			key = p_cls->signal_map.next(key);
-		}
+	for (const KeyValue<StringName, MethodInfo> &pair : p_cls->signal_map) {
+		JSAtom atom = get_atom(ctx, pair.key);
+		JS_DefinePropertyValue(ctx, data.constructor, atom, to_js_string(ctx, pair.key), PROP_DEF_DEFAULT);
+		JS_FreeAtom(ctx, atom);
 	}
 
-	class_bindings.set(data.class_id, data);
-	classname_bindings.set(p_cls->name, class_bindings.getptr(data.class_id));
+	class_bindings.insert(data.class_id, data);
+	classname_bindings.insert(p_cls->name, class_bindings.getptr(data.class_id));
 
 	return data.class_id;
 }
@@ -990,35 +974,29 @@ void QuickJSBinder::add_godot_origin() {
 }
 
 void QuickJSBinder::add_godot_classes() {
-
-	Map<const ClassDB::ClassInfo *, JSClassID> gdclass_jsmap;
+	HashMap<const ClassDB::ClassInfo *, JSClassID> gdclass_jsmap;
 	// register classes
-	const StringName *key = ClassDB::classes.next(NULL);
-	while (key) {
-		const ClassDB::ClassInfo *cls = ClassDB::classes.getptr(*key);
-		if (JSClassID id = register_class(cls)) {
-			gdclass_jsmap.insert(cls, id);
+	for (const KeyValue<StringName, ClassDB::ClassInfo> &pair : ClassDB::classes) {
+		const ClassDB::ClassInfo &cls = pair.value;
+		if (JSClassID id = register_class(&cls)) {
+			gdclass_jsmap.insert(&cls, id);
 		}
-		key = ClassDB::classes.next(key);
 	}
 
 	// Setup inherits chain
-	for (Map<const ClassDB::ClassInfo *, JSClassID>::Element *E = gdclass_jsmap.front(); E; E = E->next()) {
-		const ClassDB::ClassInfo *gdcls = E->key();
-		ClassBindData &bind = class_bindings.get(E->get());
+	for (const KeyValue<const ClassDB::ClassInfo *, JSClassID> &pair : gdclass_jsmap) {
+		const ClassDB::ClassInfo *gdcls = pair.key;
+		ClassBindData &bind = class_bindings.get(pair.value);
 		if (gdcls->inherits_ptr) {
-			if (Map<const ClassDB::ClassInfo *, JSClassID>::Element *base = gdclass_jsmap.find(gdcls->inherits_ptr)) {
-				bind.base_class = class_bindings.getptr(base->get());
+			if (const HashMap<const ClassDB::ClassInfo *, JSClassID>::ConstIterator &base = gdclass_jsmap.find(gdcls->inherits_ptr)) {
+				bind.base_class = class_bindings.getptr(base->value);
 			}
 		}
 	}
 
 	// Setup the prototype chain
-	const JSClassID *id = class_bindings.next(NULL);
-	while (id) {
-
-		const ClassBindData &data = class_bindings.get(*id);
-
+	for (const KeyValue<JSClassID, ClassBindData> &pair : class_bindings) {
+		const ClassBindData &data = pair.value;
 		int flags = PROP_DEF_DEFAULT;
 		// Allows redefine as to global object
 		if (Engine::get_singleton()->has_singleton(data.gdclass->name)) {
@@ -1030,11 +1008,10 @@ void QuickJSBinder::add_godot_classes() {
 		} else {
 			JS_SetPrototype(ctx, data.prototype, godot_origin_class.prototype);
 		}
-
-		id = class_bindings.next(id);
 	}
+
 	godot_object_class = *classname_bindings.getptr("Object");
-	godot_reference_class = *classname_bindings.getptr("Reference");
+	godot_reference_class = *classname_bindings.getptr("RefCounted");
 }
 
 void QuickJSBinder::add_godot_globals() {
@@ -1074,21 +1051,21 @@ void QuickJSBinder::add_godot_globals() {
 		gdcls = gdcls == NULL ? ClassDB::classes.getptr(s.ptr->get_class_name()) : gdcls;
 		if (gdcls) {
 			// constants
-			for (const StringName *const_key = gdcls->constant_map.next(NULL); const_key; const_key = gdcls->constant_map.next(const_key)) {
-				JSAtom const_name = get_atom(ctx, *const_key);
-				JS_DefinePropertyValue(ctx, obj, const_name, variant_to_var(ctx, gdcls->constant_map.get(*const_key)), QuickJSBinder::PROP_DEF_DEFAULT);
+			for (KeyValue<StringName, int64_t> &pair : gdcls->constant_map) {
+				JSAtom const_name = get_atom(ctx, pair.key);
+				JS_DefinePropertyValue(ctx, obj, const_name, JS_NewInt64(ctx, pair.value), QuickJSBinder::PROP_DEF_DEFAULT);
 				JS_FreeAtom(ctx, const_name);
 			}
 			// enumrations
-			for (const StringName *enum_key = gdcls->enum_map.next(NULL); enum_key; enum_key = gdcls->enum_map.next(enum_key)) {
-				const List<StringName> &consts = gdcls->enum_map.get(*enum_key);
+			for (const KeyValue<StringName, ClassDB::ClassInfo::EnumInfo> &pair : gdcls->enum_map) {
+				const List<StringName> &consts = pair.value.constants;
 				JSValue enum_obj = JS_NewObject(ctx);
 				for (const List<StringName>::Element *E2 = consts.front(); E2; E2 = E2->next()) {
 					JSAtom const_name = get_atom(ctx, E2->get());
 					JS_DefinePropertyValue(ctx, enum_obj, const_name, variant_to_var(ctx, gdcls->constant_map.get(E2->get())), QuickJSBinder::PROP_DEF_DEFAULT);
 					JS_FreeAtom(ctx, const_name);
 				}
-				JSAtom enum_name = get_atom(ctx, *enum_key);
+				JSAtom enum_name = get_atom(ctx, pair.key);
 				JS_DefinePropertyValue(ctx, obj, enum_name, enum_obj, QuickJSBinder::PROP_DEF_DEFAULT);
 				JS_FreeAtom(ctx, enum_name);
 			}
@@ -1096,31 +1073,30 @@ void QuickJSBinder::add_godot_globals() {
 	}
 
 	// global constants
-	HashMap<StringName, HashMap<StringName, int> > global_constants;
-	for (int i = 0; i < GlobalConstants::get_global_constant_count(); ++i) {
-
-		StringName enum_name = GlobalConstants::get_global_constant_enum(i);
-		const char *const_name = GlobalConstants::get_global_constant_name(i);
-		const int value = GlobalConstants::get_global_constant_value(i);
+	HashMap<StringName, HashMap<StringName, int64_t>> global_constants;
+	for (int i = 0; i < CoreConstants::get_global_constant_count(); ++i) {
+		StringName enum_name = CoreConstants::get_global_constant_enum(i);
+		const char *const_name = CoreConstants::get_global_constant_name(i);
+		const int value = CoreConstants::get_global_constant_value(i);
 
 		JSAtom js_const_name = JS_NewAtom(ctx, const_name);
 		JS_DefinePropertyValue(ctx, godot_object, js_const_name, JS_MKVAL(JS_TAG_INT, value), QuickJSBinder::PROP_DEF_DEFAULT);
 		JS_FreeAtom(ctx, js_const_name);
 
-		if (HashMap<StringName, int> *consts = global_constants.getptr(enum_name)) {
-			consts->set(const_name, value);
+		if (HashMap<StringName, int64_t> *consts = global_constants.getptr(enum_name)) {
+			consts->insert(const_name, value);
 		} else {
-			HashMap<StringName, int> enum_;
-			enum_.set(const_name, value);
-			global_constants.set(enum_name, enum_);
+			HashMap<StringName, int64_t> enum_;
+			enum_.insert(const_name, value);
+			global_constants.insert(enum_name, enum_);
 		}
 	}
 	// global numbers
 	GlobalNumberConstant consts[] = {
 		{ "PI", Math_PI },
 		{ "TAU", Math_TAU },
-		{ "NAN", Math_NAN },
-		{ "INF", Math_INF },
+		{ "NAN", NAN },
+		{ "INF", INFINITY },
 		{ "E", Math_E },
 		{ "LN2", Math_LN2 },
 		{ "SQRT2", Math_SQRT2 },
@@ -1134,9 +1110,10 @@ void QuickJSBinder::add_godot_globals() {
 	}
 
 	// global enums
-	for (const StringName *enum_name = global_constants.next(NULL); enum_name; enum_name = global_constants.next(enum_name)) {
-		String enum_name_str = *enum_name;
-		if (enum_name_str.empty()) continue;
+	for (const KeyValue<StringName, HashMap<StringName, int64_t>> &pair : global_constants) {
+		String enum_name_str = pair.key;
+		if (enum_name_str.is_empty())
+			continue;
 		enum_name_str = enum_name_str.replace(".", "");
 
 		JSAtom atom_enum_name = get_atom(ctx, enum_name_str);
@@ -1144,15 +1121,14 @@ void QuickJSBinder::add_godot_globals() {
 		JS_DefinePropertyValue(ctx, godot_object, atom_enum_name, enum_object, QuickJSBinder::PROP_DEF_DEFAULT);
 		JS_FreeAtom(ctx, atom_enum_name);
 
-		const HashMap<StringName, int> &enum_ = global_constants.get(*enum_name);
-		for (const StringName *const_name = enum_.next(NULL); const_name; const_name = enum_.next(const_name)) {
-			JSAtom js_const_name = get_atom(ctx, *const_name);
-			const int value = enum_.get(*const_name);
-			JS_DefinePropertyValue(ctx, enum_object, js_const_name, JS_MKVAL(JS_TAG_INT, value), QuickJSBinder::PROP_DEF_DEFAULT);
+		for (const KeyValue<StringName, int64_t> &c : pair.value) {
+			JSAtom js_const_name = get_atom(ctx, c.key);
+			JS_DefinePropertyValue(ctx, enum_object, js_const_name, JS_NewInt64(ctx, c.value), QuickJSBinder::PROP_DEF_DEFAULT);
 			JS_FreeAtom(ctx, js_const_name);
 		}
 	}
 
+#if 0
 	// builtin functions
 	for (int i = 0; i < Expression::FUNC_MAX; ++i) {
 		Expression::BuiltinFunc func = (Expression::BuiltinFunc)i;
@@ -1162,6 +1138,7 @@ void QuickJSBinder::add_godot_globals() {
 		JS_DefinePropertyValue(ctx, godot_object, atom, js_func, QuickJSBinder::PROP_DEF_DEFAULT);
 		JS_FreeAtom(ctx, atom);
 	}
+#endif
 
 	// godot.register_class
 	JSValue js_func_register_class = JS_NewCFunction(ctx, godot_register_class, "register_class", 2);
@@ -1222,12 +1199,14 @@ QuickJSBinder::QuickJSBinder() {
 	godot_object_class = NULL;
 	godot_reference_class = NULL;
 
-	if (class_remap.empty()) {
-		class_remap.insert(_File::get_class_static(), "File");
+	if (class_remap.is_empty()) {
+#if 0
+		class_remap.insert(File::get_class_static(), "File");
 		class_remap.insert(_Directory::get_class_static(), "Directory");
 		class_remap.insert(_Thread::get_class_static(), "");
 		class_remap.insert(_Mutex::get_class_static(), "");
 		class_remap.insert(_Semaphore::get_class_static(), "");
+#endif
 	}
 }
 
@@ -1239,7 +1218,7 @@ void QuickJSBinder::initialize() {
 	thread_id = Thread::get_caller_id();
 	{
 		GLOBAL_LOCK_FUNCTION
-		ECMAScriptLanguage::get_singleton()->thread_binder_map.set(thread_id, this);
+		ECMAScriptLanguage::get_singleton()->thread_binder_map.insert(thread_id, this);
 	}
 
 	// create runtime and context for the binder
@@ -1293,7 +1272,7 @@ void QuickJSBinder::initialize() {
 	}
 
 #ifdef QUICKJS_WITH_DEBUGGER
-	debugger.instance();
+	debugger.instantiate();
 	bool is_editor_hint = false;
 	bool default_server_enabled = GLOBAL_DEF("JavaScript/debugger/enabled", false);
 	int default_port = GLOBAL_DEF("JavaScript/debugger/port", 5556);
@@ -1359,29 +1338,24 @@ void QuickJSBinder::uninitialize() {
 	}
 
 	// Free registered js classes
-	const String *key = ecma_classes.next(NULL);
-	while (key) {
-		const ECMAClassInfo &ecma_class = ecma_classes.get(*key);
+	for (const KeyValue<String, ECMAClassInfo> &pair : ecma_classes) {
+		const ECMAClassInfo &ecma_class = pair.value;
 		free_ecmas_class(ecma_class);
-		key = ecma_classes.next(key);
 	}
 	ecma_classes.clear();
 
 	// Free frame callbacks
-	const int64_t *id = frame_callbacks.next(NULL);
-	while (id) {
-		const ECMAScriptGCHandler &func = frame_callbacks.get(*id);
+	for (const KeyValue<int64_t, ECMAScriptGCHandler> &pair : frame_callbacks) {
+		const ECMAScriptGCHandler &func = pair.value;
 		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.ecma_object);
 		JS_FreeValue(ctx, js_func);
-		id = frame_callbacks.next(id);
 	}
 	frame_callbacks.clear();
 
-	List<RES> module_resources;
-	{ // modules
-		const String *file = module_cache.next(NULL);
-		while (file) {
-			ModuleCache &m = module_cache.get(*file);
+	// modules
+	List<Ref<Resource>> module_resources;
+	for (KeyValue<String, ModuleCache> &pair : module_cache) {
+		ModuleCache &m = pair.value;
 #if MODULE_HAS_REFCOUNT
 			if (m.module) {
 				JSValue val = JS_MKPTR(JS_TAG_MODULE, m.module);
@@ -1391,23 +1365,18 @@ void QuickJSBinder::uninitialize() {
 			if (m.res.is_valid()) {
 				JS_FreeValue(ctx, m.res_value);
 				module_resources.push_back(m.res);
-				m.res = RES();
+				m.res = Ref<Resource>();
 			}
-			file = module_cache.next(file);
-		}
-		module_cache.clear();
 	}
+	module_cache.clear();
 
-	{ // commonjs modules
-		const String *file = commonjs_module_cache.next(NULL);
-		while (file) {
-			CommonJSModule &m = commonjs_module_cache.get(*file);
-			JS_FreeValue(ctx, m.exports);
-			m.res = RES();
-			file = commonjs_module_cache.next(file);
-		}
-		commonjs_module_cache.clear();
+	// commonjs modules
+	for (KeyValue<String, CommonJSModule> &pair : commonjs_module_cache) {
+		CommonJSModule &m = pair.value;
+		JS_FreeValue(ctx, m.exports);
+		m.res = Ref<Resource>();
 	}
+	commonjs_module_cache.clear();
 
 	JS_FreeAtom(ctx, js_key_godot_classid);
 	JS_FreeAtom(ctx, js_key_godot_classname);
@@ -1425,7 +1394,7 @@ void QuickJSBinder::uninitialize() {
 	JS_FreeContext(ctx);
 	JS_FreeRuntime(runtime);
 
-	for (List<RES>::Element *E = module_resources.front(); E; E = E->next()) {
+	for (List<Ref<Resource>>::Element *E = module_resources.front(); E; E = E->next()) {
 		E->get()->unreference(); // Avoid imported resource leaking
 	}
 
@@ -1471,9 +1440,10 @@ void QuickJSBinder::frame() {
 		worker->frame_of_host(this, object);
 	}
 
-	const int64_t *id = frame_callbacks.next(NULL);
-	while (id) {
-		const ECMAScriptGCHandler &func = frame_callbacks.get(*id);
+	for (const KeyValue<int64_t, ECMAScriptGCHandler> &pair : frame_callbacks) {
+		if (canceled_frame_callbacks.has(pair.key))
+			continue;
+		const ECMAScriptGCHandler &func = pair.value;
 		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.ecma_object);
 		double timestamp = OS::get_singleton()->get_ticks_usec() / 1000.0;
 		JSValue argv[] = { JS_NewFloat64(ctx, timestamp) };
@@ -1486,8 +1456,14 @@ void QuickJSBinder::frame() {
 			ERR_PRINT("Error in requestAnimationFrame:" ENDL + error_to_string(err));
 			JS_FreeValue(ctx, e);
 		}
-		id = frame_callbacks.next(id);
 	}
+	for (const KeyValue<int64_t, ECMAScriptGCHandler> &pair : frame_callbacks) {
+		const ECMAScriptGCHandler &func = pair.value;
+		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.ecma_object);
+		JS_FreeValue(ctx, js_func);
+	}
+	frame_callbacks.clear();
+	canceled_frame_callbacks.clear();
 
 #ifdef QUICKJS_WITH_DEBUGGER
 	debugger->poll();
@@ -1497,14 +1473,14 @@ void QuickJSBinder::frame() {
 Error QuickJSBinder::eval_string(const String &p_source, EvalType type, const String &p_path, ECMAScriptGCHandler &r_ret) {
 	String error;
 	Error err = safe_eval_text(p_source, type, p_path, error, r_ret);
-	if (err != OK && !error.empty()) {
+	if (err != OK && !error.is_empty()) {
 		ERR_PRINT(error);
 	}
 	return err;
 }
 
 Error QuickJSBinder::safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, ECMAScriptGCHandler &r_ret) {
-	ERR_FAIL_COND_V(p_source.empty(), FAILED);
+	ERR_FAIL_COND_V(p_source.is_empty(), FAILED);
 	CharString utf8_str = p_source.utf8();
 	const char *filename = p_path.utf8().get_data();
 	const char *code = utf8_str.get_data();
@@ -1566,7 +1542,7 @@ Error QuickJSBinder::load_bytecode(const Vector<uint8_t> &p_bytecode, const Stri
 	mc.flags = MODULE_FLAG_SCRIPT;
 	mc.hash = bytes.hash();
 	mc.module = static_cast<JSModuleDef *>(ptr);
-	module_cache.set(p_file, mc);
+	module_cache.insert(p_file, mc);
 
 	if (JS_ResolveModule(ctx, value) < 0) {
 		JSValue e = JS_GetException(ctx);
@@ -1602,7 +1578,7 @@ Error QuickJSBinder::bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, O
 	if (!bind_ptr)
 		bind_ptr = binder->classname_bindings.getptr(p_object->get_parent_class_static());
 	if (!bind_ptr) {
-		bind_ptr = Object::cast_to<Reference>(p_object) == NULL ? &binder->godot_object_class : &binder->godot_reference_class;
+		bind_ptr = Object::cast_to<RefCounted>(p_object) == NULL ? &binder->godot_object_class : &binder->godot_reference_class;
 #ifdef DEBUG_ENABLED
 		WARN_PRINT("Class " + p_object->get_class_name() + " is not registed to ClassDB");
 #endif
@@ -1614,30 +1590,30 @@ Error QuickJSBinder::bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, O
 		data->godot_object = p_object;
 		data->type = Variant::OBJECT;
 		data->flags = ECMAScriptGCHandler::FLAG_OBJECT;
-		if (Reference *ref = Object::cast_to<Reference>(p_object)) {
+		if (RefCounted *ref = Object::cast_to<RefCounted>(p_object)) {
 			ref->reference();
 			data->flags |= ECMAScriptGCHandler::FLAG_REFERENCE;
 			union {
-				REF *ref;
+				Ref<RefCounted> *ref;
 				struct {
-					Reference *ref;
+					RefCounted *ref;
 				} * r;
 			} u;
-			u.ref = memnew(REF);
+			u.ref = memnew(Ref<RefCounted>);
 			u.r->ref = ref;
 			data->godot_reference = u.ref;
 		}
 		JS_SetOpaque(obj, data);
 #ifdef DUMP_LEAKS
 		add_debug_binding_info(ctx, obj, data);
-		JS_DefinePropertyValueStr(ctx, obj, "__id__", to_js_number(ctx, p_object->get_instance_id()), PROP_DEF_DEFAULT);
+		JS_DefinePropertyValueStr(ctx, obj, "__id__", to_js_number(ctx, static_cast<uint64_t>(p_object->get_instance_id())), PROP_DEF_DEFAULT);
 #endif
 		return OK;
 	}
 	return FAILED;
 }
 
-void QuickJSBinder::godot_refcount_incremented(Reference *p_object) {
+void QuickJSBinder::godot_refcount_incremented(RefCounted *p_object) {
 	ECMAScriptGCHandler *bind = BINDING_DATA_FROM_GD(p_object);
 	if (bind->is_valid_ecma_object() && bind->is_reference()) {
 		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
@@ -1645,7 +1621,7 @@ void QuickJSBinder::godot_refcount_incremented(Reference *p_object) {
 	}
 }
 
-bool QuickJSBinder::godot_refcount_decremented(Reference *p_object) {
+bool QuickJSBinder::godot_refcount_decremented(RefCounted *p_object) {
 	ECMAScriptGCHandler *bind = BINDING_DATA_FROM_GD(p_object);
 	if (bind->is_valid_ecma_object() && bind->is_reference()) {
 		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
@@ -1682,7 +1658,7 @@ JSValue QuickJSBinder::object_constructor(JSContext *ctx, JSValueConst new_targe
 		JSValue es_class_name = JS_GetProperty(ctx, js_obj, binder->js_key_godot_classname);
 		if (JS_IsString(es_class_name)) {
 			if (ECMAClassInfo *es_class = binder->ecma_classes.getptr(js_to_string(ctx, es_class_name))) {
-				si->script.instance();
+				si->script.instantiate();
 				si->script->ecma_class = es_class;
 				si->script->instances.insert(gd_obj);
 				si->script->ecma_class = es_class;
@@ -1706,20 +1682,18 @@ JSValue QuickJSBinder::object_constructor(JSContext *ctx, JSValueConst new_targe
 }
 
 void QuickJSBinder::initialize_properties(JSContext *ctx, const ECMAClassInfo *p_class, JSValue p_object) {
-	const StringName *prop_name = p_class->properties.next(NULL);
 	QuickJSBinder *binder = get_context_binder(ctx);
-	while (prop_name) {
-		JSAtom pname = get_atom(ctx, *prop_name);
-		int ret = JS_SetProperty(ctx, p_object, pname, variant_to_var(ctx, p_class->properties.getptr(*prop_name)->default_value));
+	for (const KeyValue<StringName, ECMAProperyInfo> &pair : p_class->properties) {
+		JSAtom pname = get_atom(ctx, pair.key);
+		int ret = JS_SetProperty(ctx, p_object, pname, variant_to_var(ctx, pair.value.default_value));
 		if (ret < 0) {
 			JSValue e = JS_GetException(ctx);
 			ECMAscriptScriptError error;
 			dump_exception(ctx, e, &error);
 			JS_FreeValue(ctx, e);
-			ERR_PRINT(vformat("Cannot initialize property '%s' of class '%s'\n%s", *prop_name, p_class->class_name, binder->error_to_string(error)));
+			ERR_PRINT(vformat("Cannot initialize property '%s' of class '%s'\n%s", pair.key, p_class->class_name, binder->error_to_string(error)));
 		}
 		JS_FreeAtom(ctx, pname);
-		prop_name = p_class->properties.next(prop_name);
 	}
 }
 
@@ -1750,7 +1724,7 @@ JSValue QuickJSBinder::object_free(JSContext *ctx, JSValue this_val, int argc, J
 	ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 	ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "The object already be freed"));
 	ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "The object already be freed"));
-	ERR_FAIL_COND_V((bind->is_reference()), JS_ThrowReferenceError(ctx, "Call free to Reference object is not allowed"));
+	ERR_FAIL_COND_V((bind->is_reference()), JS_ThrowReferenceError(ctx, "Call free to RefCounted object is not allowed"));
 
 	memdelete(bind->godot_object);
 	JS_SetOpaque(this_val, NULL);
@@ -1767,7 +1741,7 @@ JSValue QuickJSBinder::godot_register_class(JSContext *ctx, JSValueConst this_va
 #if NO_MODULE_EXPORT_SUPPORT
 	class_name = binder->parsing_script_file;
 #endif
-	if (class_name.empty()) {
+	if (class_name.is_empty()) {
 		if (argc > 1 && JS_IsString(argv[1])) {
 			class_name = js_to_string(ctx, argv[1]);
 		} else {
@@ -1830,12 +1804,12 @@ const ECMAClassInfo *QuickJSBinder::register_ecma_class(const JSValue &p_constru
 		// signals
 		JSValue signals = JS_GetProperty(ctx, prototype, js_key_godot_signals);
 		if (JS_IsObject(signals)) {
-			Set<String> keys;
+			HashSet<String> keys;
 			get_own_property_names(ctx, signals, &keys);
-			for (Set<String>::Element *E = keys.front(); E; E = E->next()) {
+			for (const String &key : keys) {
 				MethodInfo mi;
-				mi.name = E->get();
-				ecma_class.signals.set(mi.name, mi);
+				mi.name = key;
+				ecma_class.signals.insert(mi.name, mi);
 			}
 		}
 		JS_FreeValue(ctx, signals);
@@ -1843,17 +1817,16 @@ const ECMAClassInfo *QuickJSBinder::register_ecma_class(const JSValue &p_constru
 		// properties
 		JSValue props = JS_GetProperty(ctx, prototype, js_key_godot_exports);
 		if (JS_IsObject(props)) {
-			Set<String> keys;
+			HashSet<String> keys;
 			get_own_property_names(ctx, props, &keys);
-			for (Set<String>::Element *E = keys.front(); E; E = E->next()) {
-
+			for (const String &key : keys) {
 				ECMAProperyInfo ei;
-				ei.name = E->get();
+				ei.name = key;
 				ei.type = Variant::NIL;
 				ei.hint = PropertyHint::PROPERTY_HINT_NONE;
 				ei.usage = PropertyUsageFlags::PROPERTY_USAGE_DEFAULT;
 
-				JSAtom pname = get_atom(ctx, E->get());
+				JSAtom pname = get_atom(ctx, key);
 				JSValue js_prop = JS_GetProperty(ctx, props, pname);
 				Variant prop = var_to_variant(ctx, js_prop);
 
@@ -1899,23 +1872,22 @@ const ECMAClassInfo *QuickJSBinder::register_ecma_class(const JSValue &p_constru
 					ei.type = ei.default_value.get_type();
 				}
 				JS_FreeAtom(ctx, pname);
-				ecma_class.properties.set(E->get(), ei);
+				ecma_class.properties.insert(key, ei);
 				JS_FreeValue(ctx, js_prop);
 			}
 		}
 		JS_FreeValue(ctx, props);
 
 		// methods
-		Set<String> keys;
+		HashSet<String> keys;
 		get_own_property_names(ctx, prototype, &keys);
-		for (Set<String>::Element *E = keys.front(); E; E = E->next()) {
-			StringName method_name = E->get();
-			JSAtom key = get_atom(ctx, method_name);
+		for (const String &E : keys) {
+			JSAtom key = get_atom(ctx, E);
 			JSValue value = JS_GetProperty(ctx, prototype, key);
 			if (JS_IsFunction(ctx, value)) {
 				MethodInfo mi;
-				mi.name = E->get();
-				ecma_class.methods.set(method_name, mi);
+				mi.name = E;
+				ecma_class.methods.insert(E, mi);
 			}
 			JS_FreeValue(ctx, value);
 			JS_FreeAtom(ctx, key);
@@ -1925,7 +1897,7 @@ const ECMAClassInfo *QuickJSBinder::register_ecma_class(const JSValue &p_constru
 		if (const ECMAClassInfo *ptr = binder->ecma_classes.getptr(p_path)) {
 			binder->free_ecmas_class(*ptr);
 		}
-		binder->ecma_classes.set(p_path, ecma_class);
+		binder->ecma_classes.insert(p_path, ecma_class);
 		JS_DefinePropertyValue(ctx, prototype, js_key_godot_classname, to_js_string(ctx, p_path), PROP_DEF_DEFAULT);
 	}
 fail:
@@ -2029,24 +2001,20 @@ JSValue QuickJSBinder::godot_set_script_meta(JSContext *ctx, JSValue this_val, i
 
 JSValue QuickJSBinder::global_request_animation_frame(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
 	ERR_FAIL_COND_V(argc < 1 || !JS_IsFunction(ctx, argv[0]), JS_ThrowTypeError(ctx, "Function expected for argument #0"));
-	static int64_t id = 0;
+	static SafeNumeric<int64_t> id;
 	JSValue js_func = JS_DupValue(ctx, argv[0]);
 	ECMAScriptGCHandler func;
 	func.ecma_object = JS_VALUE_GET_PTR(js_func);
 	QuickJSBinder *binder = get_context_binder(ctx);
-	binder->frame_callbacks.set(++id, func);
-	return JS_NewInt64(ctx, id);
+	int64_t value = id.increment();
+	binder->frame_callbacks.insert(value, func);
+	return JS_NewInt64(ctx, value);
 }
 
 JSValue QuickJSBinder::global_cancel_animation_frame(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
 	ERR_FAIL_COND_V(argc < 1 || !JS_IsNumber(argv[0]), JS_ThrowTypeError(ctx, "Request ID expected for argument #0"));
-	int32_t id = js_to_int(ctx, argv[0]);
 	QuickJSBinder *binder = get_context_binder(ctx);
-	if (ECMAScriptGCHandler *callback = binder->frame_callbacks.getptr(id)) {
-		JSValue func = JS_MKPTR(JS_TAG_OBJECT, callback->ecma_object);
-		JS_FreeValue(ctx, func);
-		binder->frame_callbacks.erase(id);
-	}
+	binder->canceled_frame_callbacks.insert(js_to_int64(ctx, argv[0]));
 	return JS_UNDEFINED;
 }
 
@@ -2058,7 +2026,7 @@ int QuickJSBinder::get_js_array_length(JSContext *ctx, JSValue p_val) {
 	return length;
 }
 
-void QuickJSBinder::get_own_property_names(JSContext *ctx, JSValue p_object, Set<String> *r_list) {
+void QuickJSBinder::get_own_property_names(JSContext *ctx, JSValue p_object, HashSet<String> *r_list) {
 	ERR_FAIL_COND(!JS_IsObject(p_object));
 	JSPropertyEnum *props = NULL;
 	uint32_t tab_atom_count;
@@ -2096,7 +2064,7 @@ ECMAScriptGCHandler QuickJSBinder::create_ecma_instance_for_godot_object(const E
 	return *bind;
 }
 
-Variant QuickJSBinder::call_method(const ECMAScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {
+Variant QuickJSBinder::call_method(const ECMAScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
 
 	JSValue object = GET_JSVALUE(p_object);
 	JSAtom atom = get_atom(ctx, p_method);
@@ -2107,7 +2075,7 @@ Variant QuickJSBinder::call_method(const ECMAScriptGCHandler &p_object, const St
 	JSValue *argv = NULL;
 
 	if (!JS_IsFunction(ctx, method) || JS_IsPureCFunction(ctx, method)) {
-		r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+		r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
 		goto finish;
 	}
 
@@ -2118,14 +2086,14 @@ Variant QuickJSBinder::call_method(const ECMAScriptGCHandler &p_object, const St
 	return_val = JS_Call(ctx, method, object, p_argcount, argv);
 
 	if (JS_IsException(return_val)) {
-		r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
+		r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
 		JSValue exception = JS_GetException(ctx);
 		ECMAscriptScriptError err;
 		dump_exception(ctx, exception, &err);
 		ERR_PRINT(error_to_string(err));
 		JS_Throw(ctx, exception);
 	} else {
-		r_error.error = Variant::CallError::CALL_OK;
+		r_error.error = Callable::CallError::CALL_OK;
 	}
 finish:
 	Variant ret = var_to_variant(ctx, return_val);
@@ -2322,7 +2290,7 @@ JSValue QuickJSBinder::godot_abandon_value(JSContext *ctx, JSValue this_val, int
 	if (valid) {
 		id = QuickJSBinder::global_transfer_id.increment();
 		GLOBAL_LOCK_FUNCTION
-		transfer_deopot.set(id, gd_value);
+		transfer_deopot.insert(id, gd_value);
 	}
 	return JS_NewInt64(ctx, id);
 }
@@ -2340,7 +2308,7 @@ JSValue QuickJSBinder::godot_adopt_value(JSContext *ctx, JSValue this_val, int a
 			transfer_deopot.erase(id);
 		}
 	}
-	ERR_FAIL_NULL_V(value, JS_UNDEFINED);
+	ERR_FAIL_NULL_V(static_cast<Object *>(value), JS_UNDEFINED);
 	return variant_to_var(ctx, value);
 }
 
diff --git a/quickjs/quickjs_binder.h b/quickjs/quickjs_binder.h
index 6835e0ed..bc32c71e 100644
--- a/quickjs/quickjs_binder.h
+++ b/quickjs/quickjs_binder.h
@@ -7,10 +7,10 @@
 #ifdef QUICKJS_WITH_DEBUGGER
 #include "quickjs_debugger.h"
 #endif
-
 #include "core/os/memory.h"
 #include "core/os/thread.h"
-#include "core/resource.h"
+#include "core/io/resource.h"
+#include "core/variant/callable.h"
 #include "quickjs_builtin_binder.h"
 #define JS_HIDDEN_SYMBOL(x) ("\xFF" x)
 #define BINDING_DATA_FROM_JS(ctx, p_val) (ECMAScriptGCHandler *)JS_GetOpaque((p_val), QuickJSBinder::get_origin_class_id((ctx)))
@@ -22,7 +22,6 @@
 #define ENDL "\r\n"
 
 class QuickJSWorker;
-
 class QuickJSBinder : public ECMAScriptBinder {
 
 	friend class QuickJSBuiltinBinder;
@@ -65,14 +64,14 @@ class QuickJSBinder : public ECMAScriptBinder {
 		JSModuleDef *module = NULL;
 		uint32_t hash = 0;
 		JSValue res_value;
-		RES res;
+		Ref<Resource> res;
 	};
 
 	struct CommonJSModule {
 		int flags;
 		JSValue exports;
 		String md5;
-		RES res;
+		Ref<Resource> res;
 	};
 
 	enum {
@@ -211,11 +210,11 @@ class QuickJSBinder : public ECMAScriptBinder {
 	static JSValue godot_builtin_function(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic);
 
 	static int get_js_array_length(JSContext *ctx, JSValue p_val);
-	static void get_own_property_names(JSContext *ctx, JSValue p_object, Set<String> *r_list);
+	static void get_own_property_names(JSContext *ctx, JSValue p_object, HashSet<String> *r_list);
 
 	static JSAtom get_atom(JSContext *ctx, const StringName &p_key);
 	static HashMap<uint64_t, Variant> transfer_deopot;
-	static Map<String, const char *> class_remap;
+	static HashMap<String, const char *> class_remap;
 #ifdef TOOLS_ENABLED
 	Dictionary modified_api;
 #endif
@@ -319,8 +318,8 @@ class QuickJSBinder : public ECMAScriptBinder {
 	virtual void free_object_binding_data(void *p_gc_handle);
 	static Error bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, Object *p_object);
 
-	virtual void godot_refcount_incremented(Reference *p_object);
-	virtual bool godot_refcount_decremented(Reference *p_object);
+	virtual void godot_refcount_incremented(RefCounted *p_object);
+	virtual bool godot_refcount_decremented(RefCounted *p_object);
 
 	virtual Error eval_string(const String &p_source, EvalType type, const String &p_path, ECMAScriptGCHandler &r_ret);
 	virtual Error safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, ECMAScriptGCHandler &r_ret);
@@ -333,7 +332,7 @@ class QuickJSBinder : public ECMAScriptBinder {
 	const ECMAClassInfo *parse_ecma_class_from_module(ModuleCache *p_module, const String &p_path, ECMAscriptScriptError *r_error);
 
 	virtual ECMAScriptGCHandler create_ecma_instance_for_godot_object(const ECMAClassInfo *p_class, Object *p_object);
-	virtual Variant call_method(const ECMAScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error);
+	virtual Variant call_method(const ECMAScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error);
 	virtual bool get_instance_property(const ECMAScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret);
 	virtual bool set_instance_property(const ECMAScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value);
 	virtual bool has_method(const ECMAScriptGCHandler &p_object, const StringName &p_name);
diff --git a/quickjs/quickjs_builtin_binder.cpp b/quickjs/quickjs_builtin_binder.cpp
index 46ffcc76..14a70913 100644
--- a/quickjs/quickjs_builtin_binder.cpp
+++ b/quickjs/quickjs_builtin_binder.cpp
@@ -1,9 +1,10 @@
 #include "quickjs_builtin_binder.h"
-#include "core/color.h"
-#include "core/variant.h"
+#include "core/math/color.h"
+#include "core/variant/variant.h"
 #include "quickjs_binder.h"
 #include <core/io/compression.h>
 #include <core/os/memory.h>
+#include <cstring>
 
 QuickJSBuiltinBinder::QuickJSBuiltinBinder() {
 	ctx = NULL;
@@ -44,10 +45,10 @@ void QuickJSBuiltinBinder::bind_builtin_object(JSContext *ctx, JSValue target, V
 			bind = memnew_placement(ptr, ECMAScriptGCHandler);
 			memnew_placement(bind + 1, Basis(*static_cast<const Basis *>(p_object)));
 			break;
-		case Variant::QUAT:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(Quat));
+		case Variant::QUATERNION:
+			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(Quaternion));
 			bind = memnew_placement(ptr, ECMAScriptGCHandler);
-			memnew_placement(bind + 1, Quat(*static_cast<const Quat *>(p_object)));
+			memnew_placement(bind + 1, Quaternion(*static_cast<const Quaternion *>(p_object)));
 			break;
 		case Variant::PLANE:
 			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(Plane));
@@ -59,55 +60,55 @@ void QuickJSBuiltinBinder::bind_builtin_object(JSContext *ctx, JSValue target, V
 			bind = memnew_placement(ptr, ECMAScriptGCHandler);
 			memnew_placement(bind + 1, Transform2D(*static_cast<const Transform2D *>(p_object)));
 			break;
-		case Variant::_RID:
+		case Variant::RID:
 			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(RID));
 			bind = memnew_placement(ptr, ECMAScriptGCHandler);
 			memnew_placement(bind + 1, RID(*static_cast<const RID *>(p_object)));
 			break;
-		case Variant::TRANSFORM:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(Transform));
+		case Variant::TRANSFORM3D:
+			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(Transform3D));
 			bind = memnew_placement(ptr, ECMAScriptGCHandler);
-			memnew_placement(bind + 1, Transform(*static_cast<const Transform *>(p_object)));
+			memnew_placement(bind + 1, Transform3D(*static_cast<const Transform3D *>(p_object)));
 			break;
 		case Variant::AABB:
 			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(AABB));
 			bind = memnew_placement(ptr, ECMAScriptGCHandler);
 			memnew_placement(bind + 1, AABB(*static_cast<const AABB *>(p_object)));
 			break;
-		case Variant::POOL_INT_ARRAY:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PoolIntArray));
+		case Variant::PACKED_INT32_ARRAY:
+			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PackedInt32Array));
 			bind = memnew_placement(ptr, ECMAScriptGCHandler);
-			memnew_placement(bind + 1, PoolIntArray(*static_cast<const PoolIntArray *>(p_object)));
+			memnew_placement(bind + 1, PackedInt32Array(*static_cast<const PackedInt32Array *>(p_object)));
 			break;
-		case Variant::POOL_BYTE_ARRAY:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PoolByteArray));
+		case Variant::PACKED_BYTE_ARRAY:
+			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PackedByteArray));
 			bind = memnew_placement(ptr, ECMAScriptGCHandler);
-			memnew_placement(bind + 1, PoolByteArray(*static_cast<const PoolByteArray *>(p_object)));
+			memnew_placement(bind + 1, PackedByteArray(*static_cast<const PackedByteArray *>(p_object)));
 			break;
-		case Variant::POOL_REAL_ARRAY:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PoolRealArray));
+		case Variant::PACKED_FLOAT32_ARRAY:
+			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PackedFloat32Array));
 			bind = memnew_placement(ptr, ECMAScriptGCHandler);
-			memnew_placement(bind + 1, PoolRealArray(*static_cast<const PoolRealArray *>(p_object)));
+			memnew_placement(bind + 1, PackedFloat32Array(*static_cast<const PackedFloat32Array *>(p_object)));
 			break;
-		case Variant::POOL_COLOR_ARRAY:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PoolColorArray));
+		case Variant::PACKED_COLOR_ARRAY:
+			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PackedColorArray));
 			bind = memnew_placement(ptr, ECMAScriptGCHandler);
-			memnew_placement(bind + 1, PoolColorArray(*static_cast<const PoolColorArray *>(p_object)));
+			memnew_placement(bind + 1, PackedColorArray(*static_cast<const PackedColorArray *>(p_object)));
 			break;
-		case Variant::POOL_STRING_ARRAY:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PoolStringArray));
+		case Variant::PACKED_STRING_ARRAY:
+			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PackedStringArray));
 			bind = memnew_placement(ptr, ECMAScriptGCHandler);
-			memnew_placement(bind + 1, PoolStringArray(*static_cast<const PoolStringArray *>(p_object)));
+			memnew_placement(bind + 1, PackedStringArray(*static_cast<const PackedStringArray *>(p_object)));
 			break;
-		case Variant::POOL_VECTOR2_ARRAY:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PoolVector2Array));
+		case Variant::PACKED_VECTOR2_ARRAY:
+			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PackedVector2Array));
 			bind = memnew_placement(ptr, ECMAScriptGCHandler);
-			memnew_placement(bind + 1, PoolVector2Array(*static_cast<const PoolVector2Array *>(p_object)));
+			memnew_placement(bind + 1, PackedVector2Array(*static_cast<const PackedVector2Array *>(p_object)));
 			break;
-		case Variant::POOL_VECTOR3_ARRAY:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PoolVector3Array));
+		case Variant::PACKED_VECTOR3_ARRAY:
+			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PackedVector3Array));
 			bind = memnew_placement(ptr, ECMAScriptGCHandler);
-			memnew_placement(bind + 1, PoolVector3Array(*static_cast<const PoolVector3Array *>(p_object)));
+			memnew_placement(bind + 1, PackedVector3Array(*static_cast<const PackedVector3Array *>(p_object)));
 			break;
 		default:
 			break;
@@ -135,26 +136,32 @@ JSValue QuickJSBuiltinBinder::create_builtin_value(JSContext *ctx, Variant::Type
 
 void QuickJSBuiltinBinder::builtin_finalizer(ECMAScriptGCHandler *p_bind) {
 	switch (p_bind->type) {
-		case Variant::POOL_BYTE_ARRAY:
-			p_bind->getPoolByteArray()->~PoolVector<uint8_t>();
+		case Variant::PACKED_BYTE_ARRAY:
+			p_bind->getPackedByteArray()->~PackedByteArray();
 			break;
-		case Variant::POOL_INT_ARRAY:
-			p_bind->getPoolIntArray()->~PoolVector<int>();
+		case Variant::PACKED_INT32_ARRAY:
+			p_bind->getPackedInt32Array()->~PackedInt32Array();
 			break;
-		case Variant::POOL_REAL_ARRAY:
-			p_bind->getPoolRealArray()->~PoolVector<real_t>();
+		case Variant::PACKED_INT64_ARRAY:
+			p_bind->getPackedInt64Array()->~PackedInt64Array();
 			break;
-		case Variant::POOL_STRING_ARRAY:
-			p_bind->getPoolStringArray()->~PoolVector<String>();
+		case Variant::PACKED_FLOAT32_ARRAY:
+			p_bind->getPackedFloat32Array()->~PackedFloat32Array();
 			break;
-		case Variant::POOL_VECTOR2_ARRAY:
-			p_bind->getPoolVector2Array()->~PoolVector<Vector2>();
+		case Variant::PACKED_FLOAT64_ARRAY:
+			p_bind->getPackedFloat64Array()->~PackedFloat64Array();
 			break;
-		case Variant::POOL_VECTOR3_ARRAY:
-			p_bind->getPoolVector3Array()->~PoolVector<Vector3>();
+		case Variant::PACKED_STRING_ARRAY:
+			p_bind->getPackedStringArray()->~PackedStringArray();
 			break;
-		case Variant::POOL_COLOR_ARRAY:
-			p_bind->getPoolColorArray()->~PoolVector<Color>();
+		case Variant::PACKED_VECTOR2_ARRAY:
+			p_bind->getPackedVector2Array()->~PackedVector2Array();
+			break;
+		case Variant::PACKED_VECTOR3_ARRAY:
+			p_bind->getPackedVector3Array()->~PackedVector3Array();
+			break;
+		case Variant::PACKED_COLOR_ARRAY:
+			p_bind->getPackedColorArray()->~PackedColorArray();
 			break;
 		default:
 			break;
@@ -370,7 +377,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 							"divide_number_right", 2),
 					QuickJSBinder::PROP_DEF_DEFAULT);
 		} break;
-		case Variant::QUAT: {
+		case Variant::QUATERNION: {
 			JSValue number_left = JS_NewObject(ctx);
 			JS_DefinePropertyValueStr(ctx, number_left, "left", JS_DupValue(ctx, Number), QuickJSBinder::PROP_DEF_DEFAULT);
 			r_operators.push_back(number_left);
@@ -379,40 +386,40 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 			JS_DefinePropertyValueStr(ctx, number_right, "right", JS_DupValue(ctx, Number), QuickJSBinder::PROP_DEF_DEFAULT);
 			r_operators.push_back(number_right);
 
-			// 2 * new godot.Quat(0.5, 0.5, 0.5, 0.5)
+			// 2 * new godot.Quaternion(0.5, 0.5, 0.5, 0.5)
 			JS_DefinePropertyValueStr(ctx, number_left, "*",
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[0]);
 								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
-								Quat *ptr = bind->getQuat();
-								Quat ret = ptr->operator*(scalar);
+								Quaternion *ptr = bind->getQuaternion();
+								Quaternion ret = ptr->operator*(scalar);
 								return QuickJSBuiltinBinder::new_object_from(ctx, ret);
 							},
 							"multiply_number_left", 2),
 					QuickJSBinder::PROP_DEF_DEFAULT);
 
-			// new godot.Quat(0.5, 0.5, 0.5, 0.5) * 2
+			// new godot.Quaternion(0.5, 0.5, 0.5, 0.5) * 2
 			JS_DefinePropertyValueStr(ctx, number_right, "*",
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
 								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
-								Quat *ptr = bind->getQuat();
+								Quaternion *ptr = bind->getQuaternion();
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[1]);
-								Quat ret = ptr->operator*(scalar);
+								Quaternion ret = ptr->operator*(scalar);
 								return QuickJSBuiltinBinder::new_object_from(ctx, ret);
 							},
 							"multiply_number_right", 2),
 					QuickJSBinder::PROP_DEF_DEFAULT);
 
-			// new godot.Quat(0.5, 0.5, 0.5, 0.5) / 2
+			// new godot.Quaternion(0.5, 0.5, 0.5, 0.5) / 2
 			JS_DefinePropertyValueStr(ctx, number_right, "/",
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
 								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
-								Quat *ptr = bind->getQuat();
+								Quaternion *ptr = bind->getQuaternion();
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[1]);
-								Quat ret = ptr->operator/(scalar);
+								Quaternion ret = ptr->operator/(scalar);
 								return QuickJSBuiltinBinder::new_object_from(ctx, ret);
 							},
 							"divide_number_right", 2),
@@ -498,8 +505,8 @@ JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const Variant &p_v
 			Basis tmp = p_val;
 			obj = create_builtin_value(ctx, type, &tmp);
 		} break;
-		case Variant::QUAT: {
-			Quat tmp = p_val;
+		case Variant::QUATERNION: {
+			Quaternion tmp = p_val;
 			obj = create_builtin_value(ctx, type, &tmp);
 		} break;
 		case Variant::PLANE: {
@@ -510,44 +517,44 @@ JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const Variant &p_v
 			Transform2D tmp = p_val;
 			obj = create_builtin_value(ctx, type, &tmp);
 		} break;
-		case Variant::_RID: {
+		case Variant::RID: {
 			RID tmp = p_val;
 			obj = create_builtin_value(ctx, type, &tmp);
 		} break;
-		case Variant::TRANSFORM: {
-			Transform tmp = p_val;
+		case Variant::TRANSFORM3D: {
+			Transform3D tmp = p_val;
 			obj = create_builtin_value(ctx, type, &tmp);
 		} break;
 		case Variant::AABB: {
 			AABB tmp = p_val;
 			obj = create_builtin_value(ctx, type, &tmp);
 		} break;
-		case Variant::POOL_INT_ARRAY: {
-			PoolIntArray tmp = p_val;
+		case Variant::PACKED_INT32_ARRAY: {
+			PackedInt32Array tmp = p_val;
 			obj = create_builtin_value(ctx, type, &tmp);
 		} break;
-		case Variant::POOL_BYTE_ARRAY: {
-			PoolByteArray tmp = p_val;
+		case Variant::PACKED_BYTE_ARRAY: {
+			PackedByteArray tmp = p_val;
 			obj = create_builtin_value(ctx, type, &tmp);
 		} break;
-		case Variant::POOL_REAL_ARRAY: {
-			PoolRealArray tmp = p_val;
+		case Variant::PACKED_FLOAT32_ARRAY: {
+			PackedFloat32Array tmp = p_val;
 			obj = create_builtin_value(ctx, type, &tmp);
 		} break;
-		case Variant::POOL_COLOR_ARRAY: {
-			PoolColorArray tmp = p_val;
+		case Variant::PACKED_COLOR_ARRAY: {
+			PackedColorArray tmp = p_val;
 			obj = create_builtin_value(ctx, type, &tmp);
 		} break;
-		case Variant::POOL_STRING_ARRAY: {
-			PoolStringArray tmp = p_val;
+		case Variant::PACKED_STRING_ARRAY: {
+			PackedStringArray tmp = p_val;
 			obj = create_builtin_value(ctx, type, &tmp);
 		} break;
-		case Variant::POOL_VECTOR2_ARRAY: {
-			PoolVector2Array tmp = p_val;
+		case Variant::PACKED_VECTOR2_ARRAY: {
+			PackedVector2Array tmp = p_val;
 			obj = create_builtin_value(ctx, type, &tmp);
 		} break;
-		case Variant::POOL_VECTOR3_ARRAY: {
-			PoolVector3Array tmp = p_val;
+		case Variant::PACKED_VECTOR3_ARRAY: {
+			PackedVector3Array tmp = p_val;
 			obj = create_builtin_value(ctx, type, &tmp);
 		} break;
 		default:
@@ -576,12 +583,12 @@ JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const Transform2D
 	return create_builtin_value(ctx, Variant::TRANSFORM2D, &p_val);
 }
 
-JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const Transform &p_val) {
-	return create_builtin_value(ctx, Variant::TRANSFORM, &p_val);
+JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const Transform3D &p_val) {
+	return create_builtin_value(ctx, Variant::TRANSFORM3D, &p_val);
 }
 
-JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const Quat &p_val) {
-	return create_builtin_value(ctx, Variant::QUAT, &p_val);
+JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const Quaternion &p_val) {
+	return create_builtin_value(ctx, Variant::QUATERNION, &p_val);
 }
 
 JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const Plane &p_val) {
@@ -589,7 +596,7 @@ JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const Plane &p_val
 }
 
 JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const RID &p_val) {
-	return create_builtin_value(ctx, Variant::_RID, &p_val);
+	return create_builtin_value(ctx, Variant::RID, &p_val);
 }
 
 JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const AABB &p_val) {
@@ -600,32 +607,32 @@ JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const Basis &p_val
 	return create_builtin_value(ctx, Variant::BASIS, &p_val);
 }
 
-JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PoolIntArray &p_val) {
-	return create_builtin_value(ctx, Variant::POOL_INT_ARRAY, &p_val);
+JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PackedInt32Array &p_val) {
+	return create_builtin_value(ctx, Variant::PACKED_INT32_ARRAY, &p_val);
 }
 
-JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PoolByteArray &p_val) {
-	return create_builtin_value(ctx, Variant::POOL_BYTE_ARRAY, &p_val);
+JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PackedByteArray &p_val) {
+	return create_builtin_value(ctx, Variant::PACKED_BYTE_ARRAY, &p_val);
 }
 
-JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PoolRealArray &p_val) {
-	return create_builtin_value(ctx, Variant::POOL_REAL_ARRAY, &p_val);
+JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PackedFloat32Array &p_val) {
+	return create_builtin_value(ctx, Variant::PACKED_FLOAT32_ARRAY, &p_val);
 }
 
-JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PoolColorArray &p_val) {
-	return create_builtin_value(ctx, Variant::POOL_COLOR_ARRAY, &p_val);
+JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PackedColorArray &p_val) {
+	return create_builtin_value(ctx, Variant::PACKED_COLOR_ARRAY, &p_val);
 }
 
-JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PoolStringArray &p_val) {
-	return create_builtin_value(ctx, Variant::POOL_STRING_ARRAY, &p_val);
+JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PackedStringArray &p_val) {
+	return create_builtin_value(ctx, Variant::PACKED_STRING_ARRAY, &p_val);
 }
 
-JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PoolVector2Array &p_val) {
-	return create_builtin_value(ctx, Variant::POOL_VECTOR2_ARRAY, &p_val);
+JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PackedVector2Array &p_val) {
+	return create_builtin_value(ctx, Variant::PACKED_VECTOR2_ARRAY, &p_val);
 }
 
-JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PoolVector3Array &p_val) {
-	return create_builtin_value(ctx, Variant::POOL_VECTOR3_ARRAY, &p_val);
+JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PackedVector3Array &p_val) {
+	return create_builtin_value(ctx, Variant::PACKED_VECTOR3_ARRAY, &p_val);
 }
 
 void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
@@ -657,7 +664,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 			ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 			Color *ptr = bind->getColor();
 #ifdef DEBUG_METHODS_ENABLED
-			ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::REAL, argv[0]), (JS_ThrowTypeError(ctx, "number value expected")));
+			ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::FLOAT, argv[0]), (JS_ThrowTypeError(ctx, "number value expected")));
 #endif
 			real_t value = QuickJSBinder::js_to_number(ctx, argv[0]);
 			switch (magic) {
@@ -720,22 +727,22 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 		binder->get_builtin_binder().register_property(Variant::RECT2, "end", getter, setter, 0);
 
 		binder->get_builtin_binder().register_method(
-				Variant::RECT2,
-				"grow_margin",
-				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
+			Variant::RECT2,
+			"grow_side",
+			[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 #ifdef DEBUG_METHODS_ENABLED
-					ERR_FAIL_COND_V(argc < 2, (JS_ThrowTypeError(ctx, "Two arguments expected for Rect2.grow_margin")));
+				ERR_FAIL_COND_V(argc < 2, (JS_ThrowTypeError(ctx, "Two arguments expected for Rect2.grow_margin")));
 #endif
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-					Rect2 *ptr = bind->getRect2();
+				ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+				Rect2 *ptr = bind->getRect2();
 #ifdef DEBUG_METHODS_ENABLED
-					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::INT, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 0 of Rect2.grow_margin")));
-					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::REAL, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 1 of Rect2.grow_margin")));
+				ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::INT, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 0 of Rect2.grow_margin")));
+				ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::FLOAT, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 1 of Rect2.grow_margin")));
 #endif
-					Rect2 ret = ptr->grow_margin(Margin(QuickJSBinder::js_to_int(ctx, argv[0])), QuickJSBinder::js_to_number(ctx, argv[1]));
-					return QuickJSBinder::variant_to_var(ctx, ret);
-				},
-				2);
+				Rect2 ret = ptr->grow_side(Side(QuickJSBinder::js_to_int(ctx, argv[0])), QuickJSBinder::js_to_number(ctx, argv[1]));
+				return QuickJSBinder::variant_to_var(ctx, ret);
+			},
+			2);
 	}
 
 	{ // Transform2D
@@ -752,11 +759,11 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 					} else if (QuickJSBinder::validate_type(ctx, Variant::RECT2, argv[0])) {
 						Rect2 ret = ptr->xform(Rect2(QuickJSBinder::var_to_variant(ctx, argv[0])));
 						return QuickJSBinder::variant_to_var(ctx, ret);
-					} else if (QuickJSBinder::validate_type(ctx, Variant::POOL_VECTOR2_ARRAY, argv[0])) {
-						PoolVector2Array ret = ptr->xform(PoolVector2Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
+					} else if (QuickJSBinder::validate_type(ctx, Variant::PACKED_VECTOR2_ARRAY, argv[0])) {
+						PackedVector2Array ret = ptr->xform(PackedVector2Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
 						return QuickJSBinder::variant_to_var(ctx, ret);
 					}
-					ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector2, Rect2 or PoolVector2Array expected for argument #0 of Transform2D.xform"));
+					ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector2, Rect2 or PackedVector2Array expected for argument #0 of Transform2D.xform"));
 				},
 				1);
 		binder->get_builtin_binder().register_method(
@@ -772,11 +779,11 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 					} else if (QuickJSBinder::validate_type(ctx, Variant::RECT2, argv[0])) {
 						Rect2 ret = ptr->xform_inv(Rect2(QuickJSBinder::var_to_variant(ctx, argv[0])));
 						return QuickJSBinder::variant_to_var(ctx, ret);
-					} else if (QuickJSBinder::validate_type(ctx, Variant::POOL_VECTOR2_ARRAY, argv[0])) {
-						PoolVector2Array ret = ptr->xform_inv(PoolVector2Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
+					} else if (QuickJSBinder::validate_type(ctx, Variant::PACKED_VECTOR2_ARRAY, argv[0])) {
+						PackedVector2Array ret = ptr->xform_inv(PackedVector2Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
 						return QuickJSBinder::variant_to_var(ctx, ret);
 					}
-					ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector2, Rect2 or PoolVector2Array expected for argument #0 of Transform2D.xform_inv"));
+					ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector2, Rect2 or PackedVector2Array expected for argument #0 of Transform2D.xform_inv"));
 				},
 				1);
 	}
@@ -889,159 +896,156 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 	}
 	{ // Transform
 		binder->get_builtin_binder().register_method(
-				Variant::TRANSFORM,
-				"xform",
-				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-					ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform.xform")));
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-					Transform *ptr = bind->getTransform();
-					if (QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0])) {
-						Vector3 ret = ptr->xform(Vector3(QuickJSBinder::var_to_variant(ctx, argv[0])));
-						return QuickJSBinder::variant_to_var(ctx, ret);
-					} else if (QuickJSBinder::validate_type(ctx, Variant::PLANE, argv[0])) {
-						Plane ret = ptr->xform(Plane(QuickJSBinder::var_to_variant(ctx, argv[0])));
-						return QuickJSBinder::variant_to_var(ctx, ret);
-					} else if (QuickJSBinder::validate_type(ctx, Variant::AABB, argv[0])) {
-						AABB ret = ptr->xform(AABB(QuickJSBinder::var_to_variant(ctx, argv[0])));
-						return QuickJSBinder::variant_to_var(ctx, ret);
-					} else if (QuickJSBinder::validate_type(ctx, Variant::POOL_VECTOR3_ARRAY, argv[0])) {
-						PoolVector3Array ret = ptr->xform(PoolVector3Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
-						return QuickJSBinder::variant_to_var(ctx, ret);
-					}
-					ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector3, Plane, AABB or PoolVector3Array expected for argument #0 of Transform.xform"));
-				},
-				1);
+			Variant::TRANSFORM3D,
+			"xform",
+			[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
+				ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform3D.xform")));
+				ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+				Transform3D *ptr = bind->getTransform3D();
+				if (QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0])) {
+					Vector3 ret = ptr->xform(Vector3(QuickJSBinder::var_to_variant(ctx, argv[0])));
+					return QuickJSBinder::variant_to_var(ctx, ret);
+				} else if (QuickJSBinder::validate_type(ctx, Variant::PLANE, argv[0])) {
+					Plane ret = ptr->xform(Plane(QuickJSBinder::var_to_variant(ctx, argv[0])));
+					return QuickJSBinder::variant_to_var(ctx, ret);
+				} else if (QuickJSBinder::validate_type(ctx, Variant::AABB, argv[0])) {
+					AABB ret = ptr->xform(AABB(QuickJSBinder::var_to_variant(ctx, argv[0])));
+					return QuickJSBinder::variant_to_var(ctx, ret);
+				} else if (QuickJSBinder::validate_type(ctx, Variant::PACKED_VECTOR3_ARRAY, argv[0])) {
+					PackedVector3Array ret = ptr->xform(PackedVector3Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
+					return QuickJSBinder::variant_to_var(ctx, ret);
+				}
+				ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector3, Plane, AABB or PackedVector3Array expected for argument #0 of Transform3D.xform"));
+			},
+			1);
 		binder->get_builtin_binder().register_method(
-				Variant::TRANSFORM,
-				"xform_inv",
-				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-					ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform.xform_inv")));
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-					Transform *ptr = bind->getTransform();
-					if (QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0])) {
-						Vector3 ret = ptr->xform_inv(Vector3(QuickJSBinder::var_to_variant(ctx, argv[0])));
-						return QuickJSBinder::variant_to_var(ctx, ret);
-					} else if (QuickJSBinder::validate_type(ctx, Variant::PLANE, argv[0])) {
-						Plane ret = ptr->xform_inv(Plane(QuickJSBinder::var_to_variant(ctx, argv[0])));
-						return QuickJSBinder::variant_to_var(ctx, ret);
-					} else if (QuickJSBinder::validate_type(ctx, Variant::AABB, argv[0])) {
-						AABB ret = ptr->xform_inv(AABB(QuickJSBinder::var_to_variant(ctx, argv[0])));
-						return QuickJSBinder::variant_to_var(ctx, ret);
-					} else if (QuickJSBinder::validate_type(ctx, Variant::POOL_VECTOR3_ARRAY, argv[0])) {
-						PoolVector3Array ret = ptr->xform_inv(PoolVector3Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
-						return QuickJSBinder::variant_to_var(ctx, ret);
-					}
-					ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector3, Plane, AABB or PoolVector3Array expected for argument #0 of Transform.xform_inv"));
-				},
-				1);
+			Variant::TRANSFORM3D,
+			"xform_inv",
+			[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
+				ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform3D.xform_inv")));
+				ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+				Transform3D *ptr = bind->getTransform3D();
+				if (QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0])) {
+					Vector3 ret = ptr->xform_inv(Vector3(QuickJSBinder::var_to_variant(ctx, argv[0])));
+					return QuickJSBinder::variant_to_var(ctx, ret);
+				} else if (QuickJSBinder::validate_type(ctx, Variant::PLANE, argv[0])) {
+					Plane ret = ptr->xform_inv(Plane(QuickJSBinder::var_to_variant(ctx, argv[0])));
+					return QuickJSBinder::variant_to_var(ctx, ret);
+				} else if (QuickJSBinder::validate_type(ctx, Variant::AABB, argv[0])) {
+					AABB ret = ptr->xform_inv(AABB(QuickJSBinder::var_to_variant(ctx, argv[0])));
+					return QuickJSBinder::variant_to_var(ctx, ret);
+				} else if (QuickJSBinder::validate_type(ctx, Variant::PACKED_VECTOR3_ARRAY, argv[0])) {
+					PackedVector3Array ret = ptr->xform_inv(PackedVector3Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
+					return QuickJSBinder::variant_to_var(ctx, ret);
+				}
+				ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector3, Plane, AABB or PackedVector3Array expected for argument #0 of Transform3D.xform_inv"));
+			},
+			1);
 	}
 
-	{ // PoolByteArray
-		// PoolByteArray.prototype.compress
+	{ // PackedByteArray
+		// PackedByteArray.prototype.compress
 		binder->get_builtin_binder().register_method(
-				Variant::POOL_BYTE_ARRAY,
+				Variant::PACKED_BYTE_ARRAY,
 				"compress",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-					PoolByteArray *ptr = bind->getPoolByteArray();
-					PoolByteArray compressed;
+					PackedByteArray *ptr = bind->getPackedByteArray();
+					PackedByteArray compressed;
 					if (ptr->size() > 0) {
 #ifdef DEBUG_METHODS_ENABLED
-						ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::INT, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 0 of PoolByteArray.compress")));
+						ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::INT, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 0 of PackedByteArray.compress")));
 #endif
 						Compression::Mode mode = (Compression::Mode)(QuickJSBinder::js_to_int(ctx, argv[0]));
 						compressed.resize(Compression::get_max_compressed_buffer_size(ptr->size(), mode));
-						int result = Compression::compress(compressed.write().ptr(), ptr->read().ptr(), ptr->size(), mode);
+						int result = Compression::compress(compressed.ptrw(), ptr->ptr(), ptr->size(), mode);
 						result = result >= 0 ? result : 0;
 						compressed.resize(result);
 					}
 					return QuickJSBinder::variant_to_var(ctx, compressed);
 				},
 				1);
-		// PoolByteArray.prototype.decompress
+		// PackedByteArray.prototype.decompress
 		binder->get_builtin_binder().register_method(
-				Variant::POOL_BYTE_ARRAY,
+				Variant::PACKED_BYTE_ARRAY,
 				"decompress",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-					PoolByteArray *ptr = bind->getPoolByteArray();
-					PoolByteArray decompressed;
+					PackedByteArray *ptr = bind->getPackedByteArray();
+					PackedByteArray decompressed;
 #ifdef DEBUG_METHODS_ENABLED
-					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::INT, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 0 of PoolByteArray.decompress")));
+					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::INT, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 0 of PackedByteArray.decompress")));
 #endif
 					int buffer_size = QuickJSBinder::js_to_int(ctx, argv[0]);
 					ERR_FAIL_COND_V(buffer_size <= 0, (JS_ThrowTypeError(ctx, "Decompression buffer size must be greater than zero.")));
 
 #ifdef DEBUG_METHODS_ENABLED
-					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::INT, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 1 of PoolByteArray.decompress")));
+					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::INT, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 1 of PackedByteArray.decompress")));
 #endif
 					Compression::Mode mode = (Compression::Mode)(QuickJSBinder::js_to_int(ctx, argv[1]));
 					decompressed.resize(buffer_size);
-					int result = Compression::decompress(decompressed.write().ptr(), buffer_size, ptr->read().ptr(), ptr->size(), mode);
+					int result = Compression::decompress(decompressed.ptrw(), buffer_size, ptr->ptr(), ptr->size(), mode);
 					result = result >= 0 ? result : 0;
 					decompressed.resize(result);
 					return QuickJSBinder::variant_to_var(ctx, decompressed);
 				},
 				1);
-		// PoolByteArray.prototype.get_string_from_utf8
+		// PackedByteArray.prototype.get_string_from_utf8
 		binder->get_builtin_binder().register_method(
-				Variant::POOL_BYTE_ARRAY,
+				Variant::PACKED_BYTE_ARRAY,
 				"get_string_from_utf8",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-					PoolByteArray *ptr = bind->getPoolByteArray();
+					PackedByteArray *ptr = bind->getPackedByteArray();
 					String ret;
 					if (ptr->size() > 0) {
-						PoolByteArray::Read r = ptr->read();
-						ret.parse_utf8((const char *)r.ptr(), ptr->size());
+						ret.parse_utf8((const char *)ptr->ptr(), ptr->size());
 					}
 					return QuickJSBinder::to_js_string(ctx, ret);
 				},
 				0);
-		// PoolByteArray.prototype.get_string_from_ascii
+		// PackedByteArray.prototype.get_string_from_ascii
 		binder->get_builtin_binder().register_method(
-				Variant::POOL_BYTE_ARRAY,
+				Variant::PACKED_BYTE_ARRAY,
 				"get_string_from_ascii",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-					PoolByteArray *ptr = bind->getPoolByteArray();
+					PackedByteArray *ptr = bind->getPackedByteArray();
 					String ret;
 					if (ptr->size() > 0) {
-						PoolByteArray::Read r = ptr->read();
 						CharString cs;
 						cs.resize(ptr->size() + 1);
-						memcpy(cs.ptrw(), r.ptr(), ptr->size());
+						memcpy(cs.ptrw(), ptr->ptr(), ptr->size());
 						cs[ptr->size()] = 0;
 						ret = cs.get_data();
 					}
 					return QuickJSBinder::to_js_string(ctx, ret);
 				},
 				0);
-		// PoolByteArray.prototype.hex_encode
+		// PackedByteArray.prototype.hex_encode
 		binder->get_builtin_binder().register_method(
-				Variant::POOL_BYTE_ARRAY,
+				Variant::PACKED_BYTE_ARRAY,
 				"hex_encode",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-					PoolByteArray *ptr = bind->getPoolByteArray();
+					PackedByteArray *ptr = bind->getPackedByteArray();
 					String ret;
 					if (ptr->size() > 0) {
-						PoolByteArray::Read r = ptr->read();
-						ret = String::hex_encode_buffer(&r[0], ptr->size());
+						ret = String::hex_encode_buffer(ptr->ptr(), ptr->size());
 					}
 					return QuickJSBinder::to_js_string(ctx, ret);
 				},
 				0);
-		// PoolByteArray.prototype.get_buffer
+		// PackedByteArray.prototype.get_buffer
 		binder->get_builtin_binder().register_method(
-				Variant::POOL_BYTE_ARRAY,
+				Variant::PACKED_BYTE_ARRAY,
 				"get_buffer",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-					PoolByteArray *array = memnew(PoolByteArray(*bind->getPoolByteArray()));
+					PackedByteArray *array = memnew(PackedByteArray(*bind->getPackedByteArray()));
 					JSValue ret = JS_NewArrayBuffer(
-							ctx, const_cast<uint8_t *>(array->read().ptr()), array->size(), [](JSRuntime *rt, void *opaque, void *ptr) {
-								memdelete(static_cast<PoolByteArray *>(opaque));
+							ctx, const_cast<uint8_t *>(array->ptr()), array->size(), [](JSRuntime *rt, void *opaque, void *ptr) {
+								memdelete(static_cast<PackedByteArray *>(opaque));
 							},
 							array, false);
 					return ret;
@@ -1049,16 +1053,16 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				0);
 	}
 	{
-		// PoolIntArray.prototype.get_buffer
+		// PackedInt32Array.prototype.get_buffer
 		binder->get_builtin_binder().register_method(
-				Variant::POOL_INT_ARRAY,
+				Variant::PACKED_INT32_ARRAY,
 				"get_buffer",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-					PoolIntArray *array = memnew(PoolIntArray(*bind->getPoolIntArray()));
+					PackedInt32Array *array = memnew(PackedInt32Array(*bind->getPackedInt32Array()));
 					JSValue ret = JS_NewArrayBuffer(
-							ctx, (uint8_t *)(array->read().ptr()), array->size() * sizeof(int), [](JSRuntime *rt, void *opaque, void *ptr) {
-								memdelete(static_cast<PoolIntArray *>(opaque));
+							ctx, (uint8_t *)(array->ptr()), array->size() * sizeof(int), [](JSRuntime *rt, void *opaque, void *ptr) {
+								memdelete(static_cast<PackedInt32Array *>(opaque));
 							},
 							array, false);
 					return ret;
@@ -1066,16 +1070,16 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				0);
 	}
 	{
-		// PoolRealArray.prototype.get_buffer
+		// PackedFloat32Array.prototype.get_buffer
 		binder->get_builtin_binder().register_method(
-				Variant::POOL_REAL_ARRAY,
+				Variant::PACKED_FLOAT32_ARRAY,
 				"get_buffer",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-					PoolRealArray *array = memnew(PoolRealArray(*bind->getPoolRealArray()));
+					PackedFloat32Array *array = memnew(PackedFloat32Array(*bind->getPackedFloat32Array()));
 					JSValue ret = JS_NewArrayBuffer(
-							ctx, (uint8_t *)(array->read().ptr()), array->size() * sizeof(real_t), [](JSRuntime *rt, void *opaque, void *ptr) {
-								memdelete(static_cast<PoolRealArray *>(opaque));
+							ctx, (uint8_t *)(array->ptr()), array->size() * sizeof(real_t), [](JSRuntime *rt, void *opaque, void *ptr) {
+								memdelete(static_cast<PackedFloat32Array *>(opaque));
 							},
 							array, false);
 					return ret;
@@ -1083,16 +1087,16 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				0);
 	}
 	{
-		// PoolVector2Array.prototype.get_buffer
+		// PackedVector2Array.prototype.get_buffer
 		binder->get_builtin_binder().register_method(
-				Variant::POOL_VECTOR2_ARRAY,
+				Variant::PACKED_VECTOR2_ARRAY,
 				"get_buffer",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-					PoolVector2Array *array = memnew(PoolVector2Array(*bind->getPoolVector2Array()));
+					PackedVector2Array *array = memnew(PackedVector2Array(*bind->getPackedVector2Array()));
 					JSValue ret = JS_NewArrayBuffer(
-							ctx, (uint8_t *)(array->read().ptr()), array->size() * sizeof(Vector2), [](JSRuntime *rt, void *opaque, void *ptr) {
-								memdelete(static_cast<PoolVector2Array *>(opaque));
+							ctx, (uint8_t *)(array->ptr()), array->size() * sizeof(Vector2), [](JSRuntime *rt, void *opaque, void *ptr) {
+								memdelete(static_cast<PackedVector2Array *>(opaque));
 							},
 							array, false);
 					return ret;
@@ -1101,16 +1105,16 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 	}
 
 	{
-		// PoolVector3Array.prototype.get_buffer
+		// PackedVector3Array.prototype.get_buffer
 		binder->get_builtin_binder().register_method(
-				Variant::POOL_VECTOR3_ARRAY,
+				Variant::PACKED_VECTOR3_ARRAY,
 				"get_buffer",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-					PoolVector3Array *array = memnew(PoolVector3Array(*bind->getPoolVector3Array()));
+					PackedVector3Array *array = memnew(PackedVector3Array(*bind->getPackedVector3Array()));
 					JSValue ret = JS_NewArrayBuffer(
-							ctx, (uint8_t *)(array->read().ptr()), array->size() * sizeof(Vector3), [](JSRuntime *rt, void *opaque, void *ptr) {
-								memdelete(static_cast<PoolVector3Array *>(opaque));
+							ctx, (uint8_t *)(array->ptr()), array->size() * sizeof(Vector3), [](JSRuntime *rt, void *opaque, void *ptr) {
+								memdelete(static_cast<PackedVector3Array *>(opaque));
 							},
 							array, false);
 					return ret;
@@ -1119,18 +1123,18 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 	}
 
 	{
-		// PoolColorArray.prototype.get_buffer
+		// PackedColorArray.prototype.get_buffer
 		binder->get_builtin_binder().register_method(
-				Variant::POOL_COLOR_ARRAY,
+				Variant::PACKED_COLOR_ARRAY,
 				"get_buffer",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-					PoolColorArray *array = memnew(PoolColorArray(*bind->getPoolColorArray()));
+					PackedColorArray *array = memnew(PackedColorArray(*bind->getPackedColorArray()));
 					JSValue ret = JS_NewArrayBuffer(
-							ctx, (uint8_t *)(array->read().ptr()), array->size() * sizeof(Color), [](JSRuntime *rt, void *opaque, void *ptr) {
-								memdelete(static_cast<PoolColorArray *>(opaque));
-							},
-							array, false);
+						ctx, (uint8_t *)(array->ptr()), array->size() * sizeof(Color), [](JSRuntime *rt, void *opaque, void *ptr) {
+							memdelete(static_cast<PackedColorArray *>(opaque));
+						},
+						array, false);
 					return ret;
 				},
 				0);
diff --git a/quickjs/quickjs_builtin_binder.h b/quickjs/quickjs_builtin_binder.h
index 33121044..2c7a4d49 100644
--- a/quickjs/quickjs_builtin_binder.h
+++ b/quickjs/quickjs_builtin_binder.h
@@ -2,7 +2,7 @@
 #define QUICKJS_BUILTIN_BINDER_H
 
 #include "quickjs/quickjs.h"
-#include <core/variant.h>
+#include "core/variant/variant.h"
 struct ECMAScriptGCHandler;
 class QuickJSBinder;
 
@@ -57,19 +57,19 @@ class QuickJSBuiltinBinder {
 	static JSValue new_object_from(JSContext *ctx, const Rect2 &p_val);
 	static JSValue new_object_from(JSContext *ctx, const Color &p_val);
 	static JSValue new_object_from(JSContext *ctx, const Transform2D &p_val);
-	static JSValue new_object_from(JSContext *ctx, const Transform &p_val);
-	static JSValue new_object_from(JSContext *ctx, const Quat &p_val);
+	static JSValue new_object_from(JSContext *ctx, const Transform3D &p_val);
+	static JSValue new_object_from(JSContext *ctx, const Quaternion &p_val);
 	static JSValue new_object_from(JSContext *ctx, const Plane &p_val);
 	static JSValue new_object_from(JSContext *ctx, const RID &p_val);
 	static JSValue new_object_from(JSContext *ctx, const AABB &p_val);
 	static JSValue new_object_from(JSContext *ctx, const Basis &p_val);
-	static JSValue new_object_from(JSContext *ctx, const PoolIntArray &p_val);
-	static JSValue new_object_from(JSContext *ctx, const PoolByteArray &p_val);
-	static JSValue new_object_from(JSContext *ctx, const PoolRealArray &p_val);
-	static JSValue new_object_from(JSContext *ctx, const PoolColorArray &p_val);
-	static JSValue new_object_from(JSContext *ctx, const PoolStringArray &p_val);
-	static JSValue new_object_from(JSContext *ctx, const PoolVector2Array &p_val);
-	static JSValue new_object_from(JSContext *ctx, const PoolVector3Array &p_val);
+	static JSValue new_object_from(JSContext *ctx, const PackedInt32Array &p_val);
+	static JSValue new_object_from(JSContext *ctx, const PackedByteArray &p_val);
+	static JSValue new_object_from(JSContext *ctx, const PackedFloat32Array &p_val);
+	static JSValue new_object_from(JSContext *ctx, const PackedColorArray &p_val);
+	static JSValue new_object_from(JSContext *ctx, const PackedStringArray &p_val);
+	static JSValue new_object_from(JSContext *ctx, const PackedVector2Array &p_val);
+	static JSValue new_object_from(JSContext *ctx, const PackedVector3Array &p_val);
 };
 
 #endif // QUICKJS_BUILTIN_BINDER_H
diff --git a/quickjs/quickjs_debugger.cpp b/quickjs/quickjs_debugger.cpp
index 73425e48..31016cde 100644
--- a/quickjs/quickjs_debugger.cpp
+++ b/quickjs/quickjs_debugger.cpp
@@ -3,20 +3,20 @@
 #define QJS_DEBUGGER_DEBUG_LOG 0
 
 QuickJSDebugger::ConnectionConfig QuickJSDebugger::parse_address(const String &address) {
-	int idx = address.find_last(":");
+	int idx = address.rfind(":");
 	String address_str = address.substr(0, idx);
 	if (address_str == "localhost") {
 		address_str = "127.0.0.1";
 	}
 	ConnectionConfig connect;
 	connect.port = address.substr(idx + 1).to_int();
-	connect.address = IP_Address(address_str);
+	connect.address = IPAddress(address_str);
 	return connect;
 }
 
 size_t QuickJSDebugger::transport_read(void *udata, char *buffer, size_t length) {
 	QuickJSDebugger *debugger = static_cast<QuickJSDebugger *>(udata);
-	ERR_FAIL_COND_V(debugger == NULL || debugger->peer.is_null() || !debugger->peer->is_connected_to_host(), -1);
+	ERR_FAIL_COND_V(debugger == NULL || debugger->peer.is_null() || debugger->peer->get_status() != StreamPeerTCP::STATUS_CONNECTED, -1);
 	ERR_FAIL_COND_V(length == 0, -2);
 	ERR_FAIL_NULL_V(buffer, -3);
 	int ret = length;
@@ -32,7 +32,7 @@ size_t QuickJSDebugger::transport_read(void *udata, char *buffer, size_t length)
 
 size_t QuickJSDebugger::transport_write(void *udata, const char *buffer, size_t length) {
 	QuickJSDebugger *debugger = static_cast<QuickJSDebugger *>(udata);
-	ERR_FAIL_COND_V(debugger == NULL || debugger->peer.is_null() || !debugger->peer->is_connected_to_host(), -1);
+	ERR_FAIL_COND_V(debugger == NULL || debugger->peer.is_null() || debugger->peer->get_status() != StreamPeerTCP::STATUS_CONNECTED, -1);
 	ERR_FAIL_COND_V(length == 0, -2);
 	ERR_FAIL_NULL_V(buffer, -3);
 	int ret = length;
@@ -47,7 +47,7 @@ size_t QuickJSDebugger::transport_write(void *udata, const char *buffer, size_t
 
 size_t QuickJSDebugger::transport_peek(void *udata) {
 	QuickJSDebugger *debugger = static_cast<QuickJSDebugger *>(udata);
-	ERR_FAIL_COND_V(debugger == NULL || debugger->peer.is_null() || !debugger->peer->is_connected_to_host(), -1);
+	ERR_FAIL_COND_V(debugger == NULL || debugger->peer.is_null() || debugger->peer->get_status() != StreamPeerTCP::STATUS_CONNECTED, -1);
 	StreamPeerTCP::Status status = debugger->peer->get_status();
 #if QJS_DEBUGGER_DEBUG_LOG
 	print_line(vformat("[peek] %d", debugger->peer->get_available_bytes()));
@@ -99,7 +99,7 @@ Error QuickJSDebugger::listen(JSContext *ctx, const String &address) {
 	if (server.is_valid() && server->is_listening()) {
 		server->stop();
 	}
-	server.instance();
+	server.instantiate();
 	ConnectionConfig c = parse_address(address);
 	Error err = server->listen(c.port, c.address);
 	return err;
diff --git a/quickjs/quickjs_debugger.h b/quickjs/quickjs_debugger.h
index 85118446..e509a0b7 100644
--- a/quickjs/quickjs_debugger.h
+++ b/quickjs/quickjs_debugger.h
@@ -1,23 +1,25 @@
 #ifndef QUICKJSDEBUGGER_H
 #define QUICKJSDEBUGGER_H
 
+#include "core/object/ref_counted.h"
 #include "core/io/stream_peer_tcp.h"
 #include "core/io/tcp_server.h"
-#include "core/reference.h"
+#include "core/io/ip_address.h"
+#include "core/object/ref_counted.h"
 #include "quickjs/quickjs-debugger.h"
 #define QJS_DEBUGGER_MAX_BUFFER_SIZE 4194304
 
-class QuickJSDebugger : public Reference {
-	GDCLASS(QuickJSDebugger, Reference)
+class QuickJSDebugger : public RefCounted {
+	GDCLASS(QuickJSDebugger, RefCounted)
 
 	Ref<StreamPeerTCP> peer;
-	Ref<TCP_Server> server;
+	Ref<TCPServer> server;
 	JSRuntime *runtime;
 	JSContext *ctx;
 	uint8_t request_buffer[QJS_DEBUGGER_MAX_BUFFER_SIZE];
 
 	struct ConnectionConfig {
-		IP_Address address;
+		IPAddress address;
 		uint16_t port;
 	};
 
diff --git a/register_types.cpp b/register_types.cpp
index 97fef877..e572dd45 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -34,7 +34,7 @@
 
 #ifdef TOOLS_ENABLED
 #include "core/io/file_access_encrypted.h"
-#include "editor/editor_export.h"
+#include "editor/export/editor_export.h"
 #include "editor/editor_node.h"
 #include "tools/editor_tools.h"
 void editor_init_callback();
@@ -44,7 +44,7 @@ class EditorExportECMAScript : public EditorExportPlugin {
 	GDCLASS(EditorExportECMAScript, EditorExportPlugin);
 
 public:
-	virtual void _export_file(const String &p_path, const String &p_type, const Set<String> &p_features) {
+	virtual void _export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features) {
 		int script_mode = EditorExportPreset::MODE_SCRIPT_COMPILED;
 		const Ref<EditorExportPreset> &preset = get_export_preset();
 
@@ -126,20 +126,20 @@ Ref<ResourceFormatLoaderECMAScript> resource_loader_ecmascript;
 Ref<ResourceFormatSaverECMAScript> resource_saver_ecmascript;
 Ref<ResourceFormatLoaderECMAScriptModule> resource_loader_ecmascript_module;
 Ref<ResourceFormatSaverECMAScriptModule> resource_saver_ecmascript_module;
-static ECMAScriptLanguage *script_language_js = NULL;
-
-void register_ECMAScript_types() {
+static ECMAScriptLanguage *script_language_js = nullptr;
 
+void initialize_ECMAScript_module(ModuleInitializationLevel p_level) {
+	if (p_level != ModuleInitializationLevel::MODULE_INITIALIZATION_LEVEL_CORE) return;
 	ClassDB::register_class<ECMAScript>();
 	ClassDB::register_class<ECMAScriptModule>();
 
-	resource_loader_ecmascript.instance();
-	resource_saver_ecmascript.instance();
+	resource_loader_ecmascript.instantiate();
+	resource_saver_ecmascript.instantiate();
 	ResourceLoader::add_resource_format_loader(resource_loader_ecmascript, true);
 	ResourceSaver::add_resource_format_saver(resource_saver_ecmascript, true);
 
-	resource_loader_ecmascript_module.instance();
-	resource_saver_ecmascript_module.instance();
+	resource_loader_ecmascript_module.instantiate();
+	resource_saver_ecmascript_module.instantiate();
 	ResourceLoader::add_resource_format_loader(resource_loader_ecmascript_module, true);
 	ResourceSaver::add_resource_format_saver(resource_saver_ecmascript_module, true);
 
@@ -152,7 +152,8 @@ void register_ECMAScript_types() {
 #endif
 }
 
-void unregister_ECMAScript_types() {
+void uninitialize_ECMAScript_module(ModuleInitializationLevel p_level) {
+	if (p_level != ModuleInitializationLevel::MODULE_INITIALIZATION_LEVEL_CORE) return;
 	ScriptServer::unregister_language(script_language_js);
 	memdelete(script_language_js);
 
@@ -169,11 +170,11 @@ void unregister_ECMAScript_types() {
 
 #ifdef TOOLS_ENABLED
 void editor_init_callback() {
-	ECMAScriptPlugin *plugin = memnew(ECMAScriptPlugin(EditorNode::get_singleton()));
-	EditorNode::get_singleton()->add_editor_plugin(plugin);
+	// ECMAScriptPlugin *plugin = memnew(ECMAScriptPlugin(EditorNode::get_singleton()));
+	// EditorNode::get_singleton()->add_editor_plugin(plugin);
 
-	Ref<EditorExportECMAScript> js_export;
-	js_export.instance();
-	EditorExport::get_singleton()->add_export_plugin(js_export);
+	// Ref<EditorExportECMAScript> js_export;
+	// js_export.instance();
+	// EditorExport::get_singleton()->add_export_plugin(js_export);
 }
 #endif
diff --git a/register_types.h b/register_types.h
index 8754281b..c489d1d8 100644
--- a/register_types.h
+++ b/register_types.h
@@ -28,5 +28,11 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-void register_ECMAScript_types();
-void unregister_ECMAScript_types();
+#ifndef ECMASCRIPT_MODULE_H
+#define ECMASCRIPT_MODULE_H
+
+#include "modules/register_module_types.h"
+void initialize_ECMAScript_module(ModuleInitializationLevel p_level);
+void uninitialize_ECMAScript_module(ModuleInitializationLevel p_level);
+
+#endif
diff --git a/tools/editor_tools.cpp b/tools/editor_tools.cpp
index dda98e1e..b7ef7700 100644
--- a/tools/editor_tools.cpp
+++ b/tools/editor_tools.cpp
@@ -5,11 +5,11 @@
 #include "editor/filesystem_dock.h"
 
 #define TS_IGNORE "//@ts-ignore\n"
-static Map<String, Set<String> > ts_ignore_errors;
-static Map<String, Set<String> > removed_members;
-static Map<String, List<String> > added_apis;
-typedef Map<String, Vector<const DocData::ConstantDoc *> > ClassEnumerations;
-static Map<String, ClassEnumerations> class_enumerations;
+static RBMap<String, HashSet<String> > ts_ignore_errors;
+static RBMap<String, HashSet<String> > removed_members;
+static RBMap<String, List<String> > added_apis;
+typedef HashMap<String, Vector<const DocData::ConstantDoc *>> ClassEnumerations;
+static RBMap<String, ClassEnumerations> class_enumerations;
 
 struct ECMAScriptAlphCompare {
 	_FORCE_INLINE_ bool operator()(const Ref<ECMAScript> &l, const Ref<ECMAScript> &r) const {
@@ -18,10 +18,9 @@ struct ECMAScriptAlphCompare {
 };
 
 static Error dump_to_file(const String &p_path, const String &p_content) {
-	FileAccessRef tsconfig = FileAccess::open(p_path, FileAccess::WRITE);
-	if (tsconfig.f && tsconfig->is_open()) {
+	Ref<FileAccess> tsconfig = FileAccess::open(p_path, FileAccess::WRITE);
+	if (tsconfig.is_valid() && tsconfig->is_open()) {
 		tsconfig->store_string(p_content);
-		tsconfig->close();
 		return OK;
 	}
 	return FAILED;
@@ -35,13 +34,13 @@ void ECMAScriptPlugin::_bind_methods() {
 
 void ECMAScriptPlugin::_notification(int p_what) {
 	switch (p_what) {
-		case MainLoop::NOTIFICATION_WM_FOCUS_IN: {
-			Set<Ref<ECMAScript> > &scripts = ECMAScriptLanguage::get_singleton()->get_scripts();
-			for (Set<Ref<ECMAScript> >::Element *E = scripts.front(); E; E = E->next()) {
-				uint64_t last_time = E->get()->get_last_modified_time();
-				uint64_t time = FileAccess::get_modified_time(E->get()->get_script_path());
+		case MainLoop::NOTIFICATION_APPLICATION_FOCUS_IN: {
+			const HashSet<Ref<ECMAScript>> &scripts = ECMAScriptLanguage::get_singleton()->get_scripts();
+			for (const Ref<ECMAScript> &s : scripts) {
+				uint64_t last_time = s->get_last_modified_time();
+				uint64_t time = FileAccess::get_modified_time(s->get_script_path());
 				if (last_time != time) {
-					ECMAScriptLanguage::get_singleton()->reload_tool_script(E->get(), true);
+					ECMAScriptLanguage::get_singleton()->reload_tool_script(s, true);
 				}
 			}
 		} break;
@@ -69,28 +68,28 @@ ECMAScriptPlugin::ECMAScriptPlugin(EditorNode *p_node) {
 	menu->add_item(TTR("Generate TypeScript Declaration File"), ITEM_GEN_DECLARE_FILE);
 	menu->add_item(TTR("Generate Enumeration Binding Script"), ITEM_GEN_ENUM_BINDING_SCRIPT);
 	menu->add_item(TTR("Generate TypeScript Project"), ITEM_GEN_TYPESCRIPT_PROJECT);
-	menu->connect("id_pressed", this, "_on_menu_item_pressed");
+	menu->connect("id_pressed", callable_mp(this, &ECMAScriptPlugin::_on_menu_item_pressed));
 
 	declaration_file_dialog = memnew(EditorFileDialog);
 	declaration_file_dialog->set_title(TTR("Generate TypeScript Declaration File"));
-	declaration_file_dialog->set_mode(EditorFileDialog::MODE_SAVE_FILE);
+	declaration_file_dialog->set_file_mode(EditorFileDialog::FILE_MODE_SAVE_FILE);
 	declaration_file_dialog->set_access(EditorFileDialog::ACCESS_FILESYSTEM);
 	declaration_file_dialog->add_filter(TTR("*.d.ts;TypeScript Declaration file"));
 	declaration_file_dialog->set_current_file("godot.d.ts");
-	declaration_file_dialog->connect("file_selected", this, "_export_typescript_declare_file");
+	declaration_file_dialog->connect("file_selected", callable_mp(this, &ECMAScriptPlugin::_export_typescript_declare_file));
 	EditorNode::get_singleton()->get_gui_base()->add_child(declaration_file_dialog);
 
 	enumberation_file_dialog = memnew(EditorFileDialog);
 	enumberation_file_dialog->set_title(TTR("Generate Enumeration Binding Script"));
-	enumberation_file_dialog->set_mode(EditorFileDialog::MODE_SAVE_FILE);
+	enumberation_file_dialog->set_file_mode(EditorFileDialog::FILE_MODE_SAVE_FILE);
 	enumberation_file_dialog->set_access(EditorFileDialog::ACCESS_FILESYSTEM);
 	enumberation_file_dialog->add_filter(TTR("*.jsx;JavaScript file"));
 	enumberation_file_dialog->set_current_file("enumerations.jsx");
-	enumberation_file_dialog->connect("file_selected", this, "_export_enumeration_binding_file");
+	enumberation_file_dialog->connect("file_selected", callable_mp(this, &ECMAScriptPlugin::_export_enumeration_binding_file));
 	EditorNode::get_singleton()->get_gui_base()->add_child(enumberation_file_dialog);
 
 	ts_ignore_errors.clear();
-	Set<String> ts_ignore_error_members;
+	HashSet<String> ts_ignore_error_members;
 	ts_ignore_errors.insert("ArrayMesh", ts_ignore_error_members);
 	ts_ignore_error_members.clear();
 	ts_ignore_error_members.insert("FLAG_MAX");
@@ -196,7 +195,7 @@ static String format_enum_name(const String &enum_name) {
 }
 
 static String get_type_name(const String &p_type) {
-	if (p_type.empty())
+	if (p_type.is_empty())
 		return "void";
 	if (p_type == "int" || p_type == "float")
 		return "number";
@@ -214,6 +213,7 @@ static String get_type_name(const String &p_type) {
 }
 
 String _export_method(const DocData::MethodDoc &p_method, bool is_function = false, bool is_static = false, bool ts_ignore_error = false) {
+#if 0
 	Dictionary dict;
 	dict["description"] = format_doc_text(p_method.description, "\t\t ");
 	dict["name"] = format_property_name(p_method.name);
@@ -280,9 +280,13 @@ String _export_method(const DocData::MethodDoc &p_method, bool is_function = fal
 		}
 	}
 	return apply_pattern(method_template, dict);
+#else
+	return "";
+#endif
 }
 
 String _export_class(const DocData::ClassDoc &class_doc) {
+#if 0
 	String class_template = "\n"
 							"\t/** ${brief_description}\n"
 							"\t ${description} */\n"
@@ -311,15 +315,14 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 		dict["description"] = description;
 	}
 
-	Set<String> ignore_members;
+	HashSet<String> ignore_members;
 	if (removed_members.has(class_doc.name)) {
 		ignore_members = removed_members[class_doc.name];
 	}
 
 	String constants = "";
-	Map<String, Vector<const DocData::ConstantDoc *> > enumerations;
-	for (int i = 0; i < class_doc.constants.size(); i++) {
-		const DocData::ConstantDoc &const_doc = class_doc.constants[i];
+	RBMap<String, Vector<const DocData::ConstantDoc *> > enumerations;
+	for (const DocData::ConstantDoc &const_doc : class_doc.constants) {
 		if (ignore_members.has(const_doc.name)) continue;
 
 		Dictionary dict;
@@ -361,11 +364,11 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 
 	dict["constants"] = constants;
 	String enumerations_str = "";
-	for (auto E = enumerations.front(); E; E = E->next()) {
-		if (ignore_members.has(E->key())) {
+	for (const KeyValue<String, Vector<const DocData::ConstantDoc *>> &E : enumerations) {
+		if (ignore_members.has(E.key) {
 			continue;
 		}
-		String enum_str = "\t\tenum " + E->key() + " {\n";
+		String enum_str = "\t\tenum " + E.key + " {\n";
 		const Vector<const DocData::ConstantDoc *> &enums = E->get();
 		for (int i = 0; i < enums.size(); i++) {
 			String const_str = "\t\t\t/** ${description} */\n"
@@ -383,8 +386,7 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 
 	Vector<DocData::MethodDoc> method_list = class_doc.methods;
 	String properties = "";
-	for (int i = 0; i < class_doc.properties.size(); i++) {
-		const DocData::PropertyDoc &prop_doc = class_doc.properties[i];
+	for (const DocData::PropertyDoc &prop_doc : class_doc.properties) {
 		if (ignore_members.has(prop_doc.name)) continue;
 
 		String prop_str = "\n"
@@ -404,7 +406,7 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 		dict["static"] = Engine::get_singleton()->has_singleton(class_doc.name) ? "static " : "";
 		properties += apply_pattern(prop_str, dict);
 
-		if (!prop_doc.getter.empty()) {
+		if (!prop_doc.getter.is_empty()) {
 			DocData::MethodDoc md;
 			md.name = prop_doc.getter;
 			md.return_type = get_type_name(prop_doc.type);
@@ -412,7 +414,7 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 			method_list.push_back(md);
 		}
 
-		if (!prop_doc.setter.empty()) {
+		if (!prop_doc.setter.is_empty()) {
 			DocData::MethodDoc md;
 			md.name = prop_doc.setter;
 			DocData::ArgumentDoc arg;
@@ -470,9 +472,13 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 	dict["extrals"] = extrals;
 
 	return apply_pattern(class_template, dict);
+#else
+	return "";
+#endif
 }
 
 void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
+#if 0
 	modified_api = &ECMAScriptLanguage::get_singleton()->get_main_binder()->get_modified_api();
 
 	removed_members.clear();
@@ -482,7 +488,7 @@ void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 		while (class_key) {
 			String class_name = *class_key;
 			Array arr = removed[*class_key];
-			Set<String> members;
+			HashSet<String> members;
 			for (int i = 0; i < arr.size(); i++) {
 				members.insert(arr[i]);
 			}
@@ -506,7 +512,7 @@ void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 		}
 	}
 
-	DocData *doc = EditorHelp::get_doc_data();
+	const DocTools *doc = EditorHelp::get_doc_data();
 	Dictionary dict;
 
 	const String godot_module = "// This file is generated by godot editor\n"
@@ -520,7 +526,7 @@ void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 								"}\n"
 								"\n";
 
-	Set<String> ignored_classes;
+	HashSet<String> ignored_classes;
 	ignored_classes.insert("int");
 	ignored_classes.insert("float");
 	ignored_classes.insert("bool");
@@ -539,16 +545,16 @@ void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 	ignored_classes.insert("Transform2D");
 	ignored_classes.insert("Transform");
 	ignored_classes.insert("Basis");
-	ignored_classes.insert("Quat");
+	ignored_classes.insert("Quaternion");
 	ignored_classes.insert("Plane");
 	ignored_classes.insert("AABB");
-	ignored_classes.insert("PoolByteArray");
-	ignored_classes.insert("PoolIntArray");
-	ignored_classes.insert("PoolRealArray");
-	ignored_classes.insert("PoolStringArray");
-	ignored_classes.insert("PoolVector2Array");
-	ignored_classes.insert("PoolVector3Array");
-	ignored_classes.insert("PoolColorArray");
+	ignored_classes.insert("PackedByteArray");
+	ignored_classes.insert("PackedInt32Array");
+	ignored_classes.insert("PackedFloat32Array");
+	ignored_classes.insert("PackedStringArray");
+	ignored_classes.insert("PackedVector2Array");
+	ignored_classes.insert("PackedVector3Array");
+	ignored_classes.insert("PackedColorArray");
 #endif
 	ignored_classes.insert("Semaphore");
 	ignored_classes.insert("Thread");
@@ -559,14 +565,14 @@ void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 	String enumerations_str = "";
 	String functions = "";
 
-	for (Map<String, DocData::ClassDoc>::Element *E = doc->class_list.front(); E; E = E->next()) {
-		DocData::ClassDoc class_doc = E->get();
+	for (const KeyValue<String, DocData::ClassDoc> &E : doc->class_list) {
+		DocData::ClassDoc class_doc = E.value;
 		if (ignored_classes.has(class_doc.name)) {
 			continue;
 		}
 		class_doc.name = get_type_name(class_doc.name);
 		if (class_doc.name.begins_with("@")) {
-			Map<String, Vector<const DocData::ConstantDoc *> > enumerations;
+			HashMap<String, Vector<const DocData::ConstantDoc *>> enumerations;
 			if (class_doc.name == "@GlobalScope" || class_doc.name == "@GDScript") {
 				String const_str = "\n"
 								   "\t/** ${description} */\n"
@@ -579,14 +585,14 @@ void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 					dict["value"] = const_doc.value;
 					if (const_doc.name == "NAN" || const_doc.name == "INF") {
 						dict["type"] = "number";
-					} else if (!const_doc.enumeration.empty()) {
+					} else if (!const_doc.enumeration.is_empty()) {
 						dict["type"] = format_enum_name(const_doc.enumeration) + "." + const_doc.name;
 					} else {
 						dict["type"] = dict["value"];
 					}
 					constants += apply_pattern(const_str, dict);
 
-					if (!const_doc.enumeration.empty()) {
+					if (!const_doc.enumeration.is_empty()) {
 						if (!enumerations.has(const_doc.enumeration)) {
 							Vector<const DocData::ConstantDoc *> e;
 							e.push_back(&const_doc);
@@ -612,9 +618,9 @@ void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 						// Exceptions
 
 						/**
-						 * KEY_MASK_CMD docs has value listed as "platform-dependent",
-						 * so we have to retreive the actual value manually
-						 */
+							 * KEY_MASK_CMD docs has value listed as "platform-dependent",
+							 * so we have to retreive the actual value manually
+							 */
 						if (dict["name"] == "KEY_MASK_CMD") {
 							dict["value"] = KEY_MASK_CMD;
 						}
@@ -647,14 +653,15 @@ void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 	dict["builtins"] = BUILTIN_DECLARATION_TEXT;
 
 	String text = apply_pattern(godot_module, dict);
-	FileAccessRef f = FileAccess::open(p_path, FileAccess::WRITE);
-	if (f.f && f->is_open()) {
+	Ref<FileAccess> f = FileAccess::open(p_path, FileAccess::WRITE);
+	if (f.is_valid() && f->is_open()) {
 		f->store_string(text);
-		f->close();
 	}
+#endif
 }
 
 void ECMAScriptPlugin::_export_enumeration_binding_file(const String &p_path) {
+#if 0
 	_export_typescript_declare_file("");
 	String file_content = "// Tool generated file DO NOT modify mannually\n"
 						  "// Add this script as first autoload to your project to bind enumerations for release build of godot engine\n"
@@ -709,6 +716,7 @@ void ECMAScriptPlugin::_export_enumeration_binding_file(const String &p_path) {
 	file_content = apply_pattern(file_content, dict);
 
 	dump_to_file(p_path, file_content);
+#endif
 }
 
 void ECMAScriptPlugin::_generate_typescript_project() {

From 254fe19b091ba3fb7064cf789f85648fce1b9a43 Mon Sep 17 00:00:00 2001
From: Geequlim <geequlim@gmail.com>
Date: Tue, 23 Aug 2022 17:07:25 +0800
Subject: [PATCH 02/71] Fix compile error for godot 4.0

---
 ecmascript.cpp             |  10 +-
 ecmascript.h               |  86 +++---
 ecmascript_binder.h        |   9 +-
 ecmascript_instance.cpp    |   2 +-
 ecmascript_instance.h      |  35 +--
 ecmascript_language.cpp    |  82 +++---
 ecmascript_language.h      | 113 ++++----
 misc/binding_script.js     | 536 ++++++++++++++++++-------------------
 quickjs/quickjs_binder.cpp |  98 +++----
 quickjs/quickjs_binder.h   |  20 +-
 register_types.cpp         |  73 +----
 tools/editor_tools.cpp     |  79 +++---
 tools/editor_tools.h       |   2 +-
 13 files changed, 519 insertions(+), 626 deletions(-)

diff --git a/ecmascript.cpp b/ecmascript.cpp
index 8ea7599a..1260e72a 100644
--- a/ecmascript.cpp
+++ b/ecmascript.cpp
@@ -73,14 +73,6 @@ PlaceHolderScriptInstance *ECMAScript::placeholder_instance_create(Object *p_thi
 #endif
 }
 
-bool ECMAScript::is_placeholder_fallback_enabled() const {
-#ifdef TOOLS_ENABLED
-	return Engine::get_singleton()->is_editor_hint() && false;
-#else
-	return false;
-#endif
-}
-
 Error ECMAScript::reload(bool p_keep_state) {
 	ecma_class = NULL;
 	Error err = OK;
@@ -318,7 +310,7 @@ ECMAScriptModule::ECMAScriptModule() {
 }
 
 Ref<Resource> ResourceFormatLoaderECMAScriptModule::load(const String &p_path, const String &p_original_path, Error *r_error) {
-	Ref<Resource>turn load_static(p_path, p_original_path, r_error);
+	return load_static(p_path, p_original_path, r_error);
 }
 
 void ResourceFormatLoaderECMAScriptModule::get_recognized_extensions(List<String> *p_extensions) const {
diff --git a/ecmascript.h b/ecmascript.h
index f2202b47..2f88e605 100644
--- a/ecmascript.h
+++ b/ecmascript.h
@@ -28,64 +28,60 @@ class ECMAScript : public Script {
 	String code;
 	String script_path;
 	Vector<uint8_t> bytecode;
-
 	const BasicECMAClassInfo *ecma_class;
 
 #ifdef TOOLS_ENABLED
 	HashSet<PlaceHolderScriptInstance *> placeholders;
-	virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder);
+	virtual void _placeholder_erased(PlaceHolderScriptInstance *p_placeholder) override;
 #endif
 
+	Dictionary rpc_config;
+
 protected:
 	void _notification(int p_what) {}
 	static void _bind_methods();
 
 public:
-	virtual bool can_instantiate() const;
-
-	/* TODO */ virtual Ref<Script> get_base_script() const { return nullptr; } //for script inheritance
-	/* TODO */ virtual bool inherits_script(const Ref<Script> &p_script) const { return false; }
-
-	virtual StringName get_instance_base_type() const;
-	virtual ScriptInstance *instance_create(Object *p_this);
-	virtual bool instance_has(const Object *p_this) const;
-	virtual PlaceHolderScriptInstance *placeholder_instance_create(Object *p_this);
+	virtual bool can_instantiate() const override;
 
-	virtual bool is_placeholder_fallback_enabled() const;
+	virtual Ref<Script> get_base_script() const override { return nullptr; }
+	virtual bool inherits_script(const Ref<Script> &p_script) const override { return false; }
 
-	virtual bool has_source_code() const { return true; }
-	virtual String get_source_code() const { return code; }
+	virtual StringName get_instance_base_type() const override;
+	virtual ScriptInstance *instance_create(Object *p_this) override;
+	virtual PlaceHolderScriptInstance *placeholder_instance_create(Object *p_this) override;
+	virtual bool instance_has(const Object *p_this) const override;
 
-	virtual void set_source_code(const String &p_code) { code = p_code; }
-	virtual Error reload(bool p_keep_state = true);
+	virtual bool has_source_code() const override { return true; }
+	virtual String get_source_code() const override { return code; }
+	virtual void set_source_code(const String &p_code) override { code = p_code; }
+	virtual Error reload(bool p_keep_state = true) override;
 
-	virtual bool has_method(const StringName &p_method) const;
-	virtual MethodInfo get_method_info(const StringName &p_method) const;
+#ifdef TOOLS_ENABLED
+	_FORCE_INLINE_ virtual Vector<DocData::ClassDoc> get_documentation() const override { return Vector<DocData::ClassDoc>(); }
+#endif
 
-	virtual bool is_tool() const;
-	virtual bool is_valid() const;
+	virtual bool has_method(const StringName &p_method) const override;
+	virtual MethodInfo get_method_info(const StringName &p_method) const override;
 
-	virtual void get_script_method_list(List<MethodInfo> *p_list) const;
-	virtual void get_script_property_list(List<PropertyInfo> *p_list) const;
-	virtual bool get_property_default_value(const StringName &p_property, Variant &r_value) const;
+	virtual bool is_tool() const override;
+	virtual bool is_valid() const override;
 
-	virtual bool has_script_signal(const StringName &p_signal) const;
-	virtual void get_script_signal_list(List<MethodInfo> *r_signals) const;
+	virtual ScriptLanguage *get_language() const override;
 
-	virtual void update_exports(); //editor tool
+	virtual bool has_script_signal(const StringName &p_signal) const override;
+	virtual void get_script_signal_list(List<MethodInfo> *r_signals) const override;
 
-	/* TODO */ virtual int get_member_line(const StringName &p_member) const { return -1; }
-	/* TODO */ virtual void get_constants(HashMap<StringName, Variant> *p_constants) {}
-	/* TODO */ virtual void get_members(HashSet<StringName> *p_constants) {}
+	virtual bool get_property_default_value(const StringName &p_property, Variant &r_value) const override;
 
-	virtual ScriptLanguage *get_language() const;
+	virtual void update_exports() override;
+	virtual void get_script_method_list(List<MethodInfo> *p_list) const override;
+	virtual void get_script_property_list(List<PropertyInfo> *p_list) const override;
 
 	_FORCE_INLINE_ String get_script_path() const { return script_path; }
 	_FORCE_INLINE_ void set_script_path(const String &p_path) { script_path = p_path; }
 
-#ifdef TOOLS_ENABLED
-	_FORCE_INLINE_ virtual Vector<DocData::ClassDoc> get_documentation() { return Vector<DocData::ClassDoc>(); }
-#endif // TOOLS_ENABLED
+	virtual const Variant get_rpc_config() const override { return rpc_config; }
 
 	ECMAScript();
 	virtual ~ECMAScript();
@@ -95,18 +91,18 @@ class ResourceFormatLoaderECMAScript : public ResourceFormatLoader {
 	GDCLASS(ResourceFormatLoaderECMAScript, ResourceFormatLoader)
 public:
 	virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
-	virtual void get_recognized_extensions(List<String> *p_extensions) const;
-	virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const;
-	virtual bool handles_type(const String &p_type) const;
-	virtual String get_resource_type(const String &p_path) const;
+	virtual void get_recognized_extensions(List<String> *p_extensions) const override;
+	virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const override;
+	virtual bool handles_type(const String &p_type) const override;
+	virtual String get_resource_type(const String &p_path) const override;
 };
 
 class ResourceFormatSaverECMAScript : public ResourceFormatSaver {
 	GDCLASS(ResourceFormatSaverECMAScript, ResourceFormatSaver)
 public:
 	virtual Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags = 0);
-	virtual void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const;
-	virtual bool recognize(const Ref<Resource> &p_resource) const;
+	virtual void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const override;
+	virtual bool recognize(const Ref<Resource> &p_resource) const override;
 };
 
 class ECMAScriptModule : public TextFile {
@@ -130,10 +126,10 @@ class ResourceFormatLoaderECMAScriptModule : public ResourceFormatLoader {
 	GDCLASS(ResourceFormatLoaderECMAScriptModule, ResourceFormatLoader)
 public:
 	virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
-	virtual void get_recognized_extensions(List<String> *p_extensions) const;
-	virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const;
-	virtual bool handles_type(const String &p_type) const;
-	virtual String get_resource_type(const String &p_path) const;
+	virtual void get_recognized_extensions(List<String> *p_extensions) const override;
+	virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const override;
+	virtual bool handles_type(const String &p_type) const override;
+	virtual String get_resource_type(const String &p_path) const override;
 
 	static Ref<Resource> load_static(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
 };
@@ -142,8 +138,8 @@ class ResourceFormatSaverECMAScriptModule : public ResourceFormatSaver {
 	GDCLASS(ResourceFormatSaverECMAScriptModule, ResourceFormatSaver)
 public:
 	virtual Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags = 0);
-	virtual void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const;
-	virtual bool recognize(const Ref<Resource> &p_resource) const;
+	virtual void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const override;
+	virtual bool recognize(const Ref<Resource> &p_resource) const override;
 };
 
 #endif // ECMASCRIPT_H
diff --git a/ecmascript_binder.h b/ecmascript_binder.h
index c31f53b9..3c2b00ac6 100644
--- a/ecmascript_binder.h
+++ b/ecmascript_binder.h
@@ -71,11 +71,10 @@ class ECMAScriptBinder {
 	virtual void language_finalize() = 0;
 	virtual void frame() = 0;
 
-	virtual void *alloc_object_binding_data(Object *p_object) = 0;
-	virtual void free_object_binding_data(void *p_gc_handle) = 0;
-
-	virtual void godot_refcount_incremented(RefCounted *p_object) = 0;
-	virtual bool godot_refcount_decremented(RefCounted *p_object) = 0;
+	virtual ECMAScriptGCHandler *alloc_object_binding_data(Object *p_object) = 0;
+	virtual void free_object_binding_data(ECMAScriptGCHandler *p_gc_handle) = 0;
+	virtual void godot_refcount_incremented(ECMAScriptGCHandler *p_gc_handle) = 0;
+	virtual bool godot_refcount_decremented(ECMAScriptGCHandler *p_gc_handle) = 0;
 
 	virtual Error eval_string(const String &p_source, EvalType type, const String &p_path, ECMAScriptGCHandler &r_ret) = 0;
 	virtual Error safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, ECMAScriptGCHandler &r_ret) = 0;
diff --git a/ecmascript_instance.cpp b/ecmascript_instance.cpp
index 6c04ae4b..e90cb66b 100644
--- a/ecmascript_instance.cpp
+++ b/ecmascript_instance.cpp
@@ -46,7 +46,7 @@ Variant::Type ECMAScriptInstance::get_property_type(const StringName &p_name, bo
 	return Variant::NIL;
 }
 
-Variant ECMAScriptInstance::call(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
+Variant ECMAScriptInstance::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
 	if (binder == NULL || ecma_object.ecma_object == NULL) {
 		r_error.error = Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL;
 		ERR_FAIL_V(Variant());
diff --git a/ecmascript_instance.h b/ecmascript_instance.h
index c717fdf9..a730a6ee 100644
--- a/ecmascript_instance.h
+++ b/ecmascript_instance.h
@@ -18,34 +18,21 @@ class ECMAScriptInstance : public ScriptInstance {
 	const ECMAClassInfo *ecma_class;
 
 public:
-	virtual bool set(const StringName &p_name, const Variant &p_value);
-	virtual bool get(const StringName &p_name, Variant &r_ret) const;
-	virtual void get_property_list(List<PropertyInfo> *p_properties) const;
-	virtual Variant::Type get_property_type(const StringName &p_name, bool *r_is_valid = NULL) const;
+	virtual bool set(const StringName &p_name, const Variant &p_value) override;
+	virtual bool get(const StringName &p_name, Variant &r_ret) const override;
+	virtual void get_property_list(List<PropertyInfo> *p_properties) const override;
+	virtual Variant::Type get_property_type(const StringName &p_name, bool *r_is_valid = nullptr) const override;
 
-	virtual Object *get_owner() { return owner; }
-	virtual Ref<Script> get_script() const;
+	virtual void get_method_list(List<MethodInfo> *p_list) const override;
+	virtual bool has_method(const StringName &p_method) const override;
 
-	virtual void get_method_list(List<MethodInfo> *p_list) const;
-	virtual bool has_method(const StringName &p_method) const;
+	virtual Variant callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override;
 
-	virtual Variant call(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error);
+	virtual Object *get_owner() override { return owner; }
+	virtual Ref<Script> get_script() const override;
+	virtual ScriptLanguage *get_language() override;
 
-	/* TODO */ virtual void notification(int p_notification) {}
-
-	//this is used by script languages that keep a reference counter of their own
-	//you can make make Ref<> not die when it reaches zero, so deleting the reference
-	//depends entirely from the script
-
-	/* TODO */ virtual void refcount_incremented() {}
-	/* TODO */ virtual bool refcount_decremented() { return true; } //return true if it can die
-
-	/* TODO */ virtual bool is_placeholder() const { return false; }
-
-	/* TODO */ virtual void property_set_fallback(const StringName &p_name, const Variant &p_value, bool *r_valid) {}
-	/* TODO */ virtual Variant property_get_fallback(const StringName &p_name, bool *r_valid) { return Variant(); }
-
-	virtual ScriptLanguage *get_language();
+	virtual void notification(int p_notification) override{};
 
 	ECMAScriptInstance();
 	~ECMAScriptInstance();
diff --git a/ecmascript_language.cpp b/ecmascript_language.cpp
index ca59b275..39427248 100644
--- a/ecmascript_language.cpp
+++ b/ecmascript_language.cpp
@@ -3,9 +3,52 @@
 #include "core/io/file_access.h"
 ECMAScriptLanguage *ECMAScriptLanguage::singleton = NULL;
 
+namespace ECMAScriptInstanceBindingCallbacks {
+
+static void *create_callback(void *p_token, void *p_instance) {
+	if (ECMAScriptBinder *binder = ECMAScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+		return binder->alloc_object_binding_data(static_cast<Object *>(p_instance));
+	}
+	return nullptr;
+}
+
+static void free_callback(void *p_token, void *p_instance, void *p_binding) {
+	if (ECMAScriptBinder *binder = ECMAScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+		return binder->free_object_binding_data(static_cast<ECMAScriptGCHandler *>(p_binding));
+	}
+}
+
+static GDNativeBool reference_callback(void *p_token, void *p_binding, GDNativeBool p_reference) {
+	if (ECMAScriptBinder *binder = ECMAScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+		if (p_reference) {
+			binder->godot_refcount_incremented(static_cast<ECMAScriptGCHandler *>(p_binding));
+			return false;
+		} else {
+			return binder->godot_refcount_decremented(static_cast<ECMAScriptGCHandler *>(p_binding));
+		}
+	}
+	return true;
+}
+
+} // namespace ECMAScriptInstanceBindingCallbacks
+
+ECMAScriptLanguage::ECMAScriptLanguage() {
+	ERR_FAIL_COND(singleton);
+	singleton = this;
+	main_binder = memnew(QuickJSBinder);
+	instance_binding_callbacks.create_callback = ECMAScriptInstanceBindingCallbacks::create_callback;
+	instance_binding_callbacks.free_callback = ECMAScriptInstanceBindingCallbacks::free_callback;
+	instance_binding_callbacks.reference_callback = ECMAScriptInstanceBindingCallbacks::reference_callback;
+}
+
+ECMAScriptLanguage::~ECMAScriptLanguage() {
+	memdelete(main_binder);
+}
+
 void ECMAScriptLanguage::init() {
 	ERR_FAIL_NULL(main_binder);
 	main_binder->initialize();
+	execute_file("bin/test.js");
 }
 
 void ECMAScriptLanguage::finish() {
@@ -212,7 +255,7 @@ Ref<Script> ECMAScriptLanguage::get_template(const String &p_class_name, const S
 }
 
 Ref<Script> ECMAScriptLanguage::make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const {
-	Ref<Script> script;
+	Ref<ECMAScript> script;
 	script.instantiate();
 	String src = script->get_source_code();
 	src = src.replace("%BASE%", p_base_class_name).replace("%CLASS%", p_class_name);
@@ -267,32 +310,6 @@ void ECMAScriptLanguage::get_recognized_extensions(List<String> *p_extensions) c
 	p_extensions->push_back(EXT_JSCLASS_BYTECODE);
 }
 
-void *ECMAScriptLanguage::alloc_instance_binding_data(Object *p_object) {
-	if (ECMAScriptBinder *binder = get_thread_binder(Thread::get_caller_id())) {
-		return binder->alloc_object_binding_data(p_object);
-	}
-	return NULL;
-}
-
-void ECMAScriptLanguage::free_instance_binding_data(void *p_data) {
-	if (ECMAScriptBinder *binder = get_thread_binder(Thread::get_caller_id())) {
-		return binder->free_object_binding_data(p_data);
-	}
-}
-
-void ECMAScriptLanguage::refcount_incremented_instance_binding(Object *p_object) {
-	if (ECMAScriptBinder *binder = get_thread_binder(Thread::get_caller_id())) {
-		binder->godot_refcount_incremented(static_cast<RefCounted *>(p_object));
-	}
-}
-
-bool ECMAScriptLanguage::refcount_decremented_instance_binding(Object *p_object) {
-	if (ECMAScriptBinder *binder = get_thread_binder(Thread::get_caller_id())) {
-		return binder->godot_refcount_decremented(static_cast<RefCounted *>(p_object));
-	}
-	return true;
-}
-
 void ECMAScriptLanguage::frame() {
 	main_binder->frame();
 }
@@ -325,14 +342,3 @@ String ECMAScriptLanguage::globalize_relative_path(const String &p_relative, con
 	}
 	return file;
 }
-
-ECMAScriptLanguage::ECMAScriptLanguage() {
-
-	ERR_FAIL_COND(singleton);
-	singleton = this;
-	main_binder = memnew(QuickJSBinder);
-}
-
-ECMAScriptLanguage::~ECMAScriptLanguage() {
-	memdelete(main_binder);
-}
diff --git a/ecmascript_language.h b/ecmascript_language.h
index 815bc8ab..67f96067 100644
--- a/ecmascript_language.h
+++ b/ecmascript_language.h
@@ -5,7 +5,6 @@
 #include "ecmascript.h"
 #include "quickjs/quickjs_binder.h"
 
-/*********************** ECMAScriptLanguage ***********************/
 class ECMAScriptBinder;
 class ECMAScriptLanguage : public ScriptLanguage {
 
@@ -18,8 +17,8 @@ class ECMAScriptLanguage : public ScriptLanguage {
 private:
 	static ECMAScriptLanguage *singleton;
 	ECMAScriptBinder *main_binder;
-	int language_index;
 	HashMap<Thread::ID, ECMAScriptBinder *> thread_binder_map;
+	GDNativeInstanceBindingCallbacks instance_binding_callbacks;
 #ifdef TOOLS_ENABLED
 	HashSet<Ref<ECMAScript>> scripts;
 #endif
@@ -31,94 +30,82 @@ class ECMAScriptLanguage : public ScriptLanguage {
 		if (ECMAScriptBinder **ptr = singleton->thread_binder_map.getptr(p_id)) {
 			return *ptr;
 		}
-		return NULL;
+		return nullptr;
 	}
 
-	_FORCE_INLINE_ virtual String get_name() const { return "JavaScript"; }
-	_FORCE_INLINE_ int get_language_index() const { return language_index; }
-	_FORCE_INLINE_ void set_language_index(int value) { language_index = value; }
-
+	_FORCE_INLINE_ virtual String get_name() const override { return "JavaScript"; }
+	const GDNativeInstanceBindingCallbacks *getInstanceBindingCallbacks() const { return &instance_binding_callbacks; }
 #ifdef TOOLS_ENABLED
 	_FORCE_INLINE_ HashSet<Ref<ECMAScript> > &get_scripts() { return scripts; }
 #endif
 	/* LANGUAGE FUNCTIONS */
 
-	_FORCE_INLINE_ virtual String get_type() const { return "JavaScript"; }
-	_FORCE_INLINE_ virtual String get_extension() const { return EXT_JSCLASS; }
-	_FORCE_INLINE_ virtual bool has_named_classes() const { return true; }
-	_FORCE_INLINE_ virtual bool supports_builtin_mode() const { return false; }
-	_FORCE_INLINE_ virtual bool is_using_templates() { return true; }
-	_FORCE_INLINE_ virtual bool overrides_external_editor() { return false; }
+	_FORCE_INLINE_ virtual String get_type() const override { return "JavaScript"; }
+	_FORCE_INLINE_ virtual String get_extension() const override { return EXT_JSCLASS; }
 
-	virtual void init();
-	virtual void finish();
-	virtual Error execute_file(const String &p_path);
+	virtual void init() override;
+	virtual void finish() override;
+	virtual Error execute_file(const String &p_path) override;
 
-	virtual void get_reserved_words(List<String> *p_words) const;
-	virtual bool is_control_flow_keyword(String p_keywords) const;
-	virtual void get_comment_delimiters(List<String> *p_delimiters) const;
-	virtual void get_string_delimiters(List<String> *p_delimiters) const;
+	virtual void get_reserved_words(List<String> *p_words) const override;
+	virtual bool is_control_flow_keyword(String p_keywords) const override;
+	virtual void get_comment_delimiters(List<String> *p_delimiters) const override;
+	virtual void get_string_delimiters(List<String> *p_delimiters) const override;
 
-	virtual Ref<Script> get_template(const String &p_class_name, const String &p_base_class_name) const;
-	virtual Ref<Script> make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const;
+	Ref<Script> get_template(const String &p_class_name, const String &p_base_class_name) const;
+	virtual Ref<Script> make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const override;
 
-	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptError> *r_errors = nullptr, List<Warning> *r_warnings = nullptr, HashSet<int> *r_safe_lines = nullptr) const;
-	virtual String validate_path(const String &p_path) const { return ""; }
-	virtual Script *create_script() const;
+	virtual Script *create_script() const override;
+	_FORCE_INLINE_ virtual bool has_named_classes() const override { return true; }
+	_FORCE_INLINE_ virtual bool supports_builtin_mode() const override { return false; }
+	_FORCE_INLINE_ virtual bool is_using_templates() override { return true; }
 
-	/* TODO */ virtual int find_function(const String &p_function, const String &p_code) const { return -1; }
-	/* TODO */ virtual String make_function(const String &p_class, const String &p_name, const PackedStringArray &p_args) const { return ""; }
-	/* TODO */ virtual Error open_in_external_editor(const Ref<Script> &p_script, int p_line, int p_col) { return ERR_UNAVAILABLE; }
+	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptError> *r_errors = nullptr, List<Warning> *r_warnings = nullptr, HashSet<int> *r_safe_lines = nullptr) const override;
 
-	/* TODO */ virtual void auto_indent_code(String &p_code, int p_from_line, int p_to_line) const {}
-	/* TODO */ virtual void add_global_constant(const StringName &p_variable, const Variant &p_value) {}
-	/* TODO */ virtual void add_named_global_constant(const StringName &p_name, const Variant &p_value) {}
-	/* TODO */ virtual void remove_named_global_constant(const StringName &p_name) {}
+	virtual int find_function(const String &p_function, const String &p_code) const override { return -1; }
+	virtual String make_function(const String &p_class, const String &p_name, const PackedStringArray &p_args) const override { return ""; }
 
-	/* MULTITHREAD FUNCTIONS */
+	virtual void auto_indent_code(String &p_code, int p_from_line, int p_to_line) const override {}
+	virtual void add_global_constant(const StringName &p_variable, const Variant &p_value) override {}
 
-	//some VMs need to be notified of thread creation/exiting to allocate a stack
-	/* TODO */ virtual void thread_enter() {}
-	/* TODO */ virtual void thread_exit() {}
+	virtual void thread_enter() override {}
+	virtual void thread_exit() override {}
 
 	/* DEBUGGER FUNCTIONS */
 
 	/* DEBUGGER FUNCTIONS */
-	/* TODO */ virtual String debug_get_error() const { return ""; }
-	/* TODO */ virtual int debug_get_stack_level_count() const { return 1; }
-	/* TODO */ virtual int debug_get_stack_level_line(int p_level) const { return 1; }
-	/* TODO */ virtual String debug_get_stack_level_function(int p_level) const { return ""; }
-	/* TODO */ virtual String debug_get_stack_level_source(int p_level) const { return ""; }
-	/* TODO */ virtual void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {}
-	/* TODO */ virtual void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {}
-	/* TODO */ virtual void debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) {}
-	/* TODO */ virtual String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) { return ""; }
-	/* TODO */ virtual Vector<StackInfo> debug_get_current_stack_info() { return Vector<StackInfo>(); }
+	virtual String debug_get_error() const override { return ""; }
+	virtual int debug_get_stack_level_count() const override { return 1; }
+	virtual int debug_get_stack_level_line(int p_level) const override { return 1; }
+	virtual String debug_get_stack_level_function(int p_level) const override { return ""; }
+	virtual String debug_get_stack_level_source(int p_level) const override { return ""; }
+	virtual void debug_get_stack_level_locals(int p_level, List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override {}
+	virtual void debug_get_stack_level_members(int p_level, List<String> *p_members, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override {}
+	virtual void debug_get_globals(List<String> *p_locals, List<Variant> *p_values, int p_max_subitems, int p_max_depth) override {}
+	virtual String debug_parse_stack_level_expression(int p_level, const String &p_expression, int p_max_subitems, int p_max_depth) override { return ""; }
+	virtual Vector<StackInfo> debug_get_current_stack_info() override { return Vector<StackInfo>(); }
 
 	void reload_script(const Ref<Script> &p_script, bool p_soft_reload);
-	virtual void reload_all_scripts();
-	virtual void reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) { reload_script(p_script, p_soft_reload); }
 
-	/* LOADER FUNCTIONS */
-	virtual void get_recognized_extensions(List<String> *p_extensions) const;
-	/* TODO */ virtual void get_public_functions(List<MethodInfo> *p_functions) const {}
-	/* TODO */ virtual void get_public_constants(List<Pair<String, Variant> > *p_constants) const {}
+	virtual void reload_all_scripts() override;
+	virtual void reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) override { reload_script(p_script, p_soft_reload); }
 
-	/* TODO */ virtual void profiling_start() {}
-	/* TODO */ virtual void profiling_stop() {}
+	/* LOADER FUNCTIONS */
+	virtual void get_recognized_extensions(List<String> *p_extensions) const override;
+	virtual void get_public_functions(List<MethodInfo> *p_functions) const override {}
+	virtual void get_public_constants(List<Pair<String, Variant>> *p_constants) const override {}
+	virtual void get_public_annotations(List<MethodInfo> *p_annotations) const override{};
 
-	/* TODO */ virtual int profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) { return -1; }
-	/* TODO */ virtual int profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) { return -1; }
+	virtual void profiling_start() override {}
+	virtual void profiling_stop() override {}
 
-	virtual void *alloc_instance_binding_data(Object *p_object); //optional, not used by all languages
-	virtual void free_instance_binding_data(void *p_data); //optional, not used by all languages
-	virtual void refcount_incremented_instance_binding(Object *p_object); //optional, not used by all languages
-	virtual bool refcount_decremented_instance_binding(Object *p_object); //return true if it can die //optional, not used by all languages
+	virtual int profiling_get_accumulated_data(ProfilingInfo *p_info_arr, int p_info_max) override { return -1; }
+	virtual int profiling_get_frame_data(ProfilingInfo *p_info_arr, int p_info_max) override { return -1; }
 
-	virtual void frame();
+	virtual void frame() override;
 
-	/* TODO */ virtual bool handles_global_class_type(const String &p_type) const { return false; }
-	/* TODO */ virtual String get_global_class_name(const String &p_path, String *r_base_type = NULL, String *r_icon_path = NULL) const { return String(); }
+	virtual bool handles_global_class_type(const String &p_type) const override { return false; }
+	virtual String get_global_class_name(const String &p_path, String *r_base_type = NULL, String *r_icon_path = NULL) const override { return String(); }
 
 	static String globalize_relative_path(const String &p_relative, const String &p_base_dir);
 
diff --git a/misc/binding_script.js b/misc/binding_script.js
index e4b13ba6..ea58b032 100644
--- a/misc/binding_script.js
+++ b/misc/binding_script.js
@@ -1,295 +1,295 @@
-(function start_script_binding() {
+// (function start_script_binding() {
 	
-	const GodotAnonymousConnectionManager = new(class GodotAnonymousConnectionManager extends godot.RefCounted {
-		anonymous_connection_index = 0;
+// 	const GodotAnonymousConnectionManager = new(class GodotAnonymousConnectionManager extends godot.RefCounted {
+// 		anonymous_connection_index = 0;
 		
-		get_slot_id(emitter, signal, target) {
-			return `__${emitter.get_instance_id()}:${signal}:${target.get_instance_id()}__`;
-		}
+// 		get_slot_id(emitter, signal, target) {
+// 			return `__${emitter.get_instance_id()}:${signal}:${target.get_instance_id()}__`;
+// 		}
 
-		get_anonymous_method_name() {
-			return `__anonymous_slot:${this.anonymous_connection_index++}`;
-		}
-	})();
+// 		get_anonymous_method_name() {
+// 			return `__anonymous_slot:${this.anonymous_connection_index++}`;
+// 		}
+// 	})();
 	
-	const godot_object_connect = godot.Object.prototype.connect;
-	Object.defineProperty(godot.Object.prototype, 'connect', {
-		// Object.prototype.connect(signal_name, target, method, params, flags)
-		value: function connect(...args) {
-			if (args.length < 2) throw new Error('2 or more arguments expected');
-			let signal = args[0];
-			if (typeof signal !== 'string' || !signal) throw new Error('signal name expected for argument #0');
+// 	const godot_object_connect = godot.Object.prototype.connect;
+// 	Object.defineProperty(godot.Object.prototype, 'connect', {
+// 		// Object.prototype.connect(signal_name, target, method, params, flags)
+// 		value: function connect(...args) {
+// 			if (args.length < 2) throw new Error('2 or more arguments expected');
+// 			let signal = args[0];
+// 			if (typeof signal !== 'string' || !signal) throw new Error('signal name expected for argument #0');
 			
-			let offset = 0;
-			let target = null;
-			let method = null;
-			let method_name = null;
-			let target_caller = null;
-			let params = [];
-			let flags = 0;
+// 			let offset = 0;
+// 			let target = null;
+// 			let method = null;
+// 			let method_name = null;
+// 			let target_caller = null;
+// 			let params = [];
+// 			let flags = 0;
 			
-			if (typeof args[1] === 'function') {
-				offset = -1;
-				target = GodotAnonymousConnectionManager;
-				method = args[1];
-			} else if (args.length >= 3) {
-				target_caller = args[1];
-				target = target_caller || GodotAnonymousConnectionManager;
-				if (!(target instanceof godot.Object)) {
-					new Error('godot.Object expected for signal target');
-				}
-				method = args[2];
-			} else {
-				throw new Error('method name or function expected for signal method');
-			}
-			if (args.length > 3 + offset) {
-				let p = args[3 + offset];
-				if (p && p.length)
-					params = p;
-			}
-			if (args.length > 4 + offset) {
-				let p = args[4 + offset];
-				if (typeof p === 'number')
-					flags = p;
-			}
+// 			if (typeof args[1] === 'function') {
+// 				offset = -1;
+// 				target = GodotAnonymousConnectionManager;
+// 				method = args[1];
+// 			} else if (args.length >= 3) {
+// 				target_caller = args[1];
+// 				target = target_caller || GodotAnonymousConnectionManager;
+// 				if (!(target instanceof godot.Object)) {
+// 					new Error('godot.Object expected for signal target');
+// 				}
+// 				method = args[2];
+// 			} else {
+// 				throw new Error('method name or function expected for signal method');
+// 			}
+// 			if (args.length > 3 + offset) {
+// 				let p = args[3 + offset];
+// 				if (p && p.length)
+// 					params = p;
+// 			}
+// 			if (args.length > 4 + offset) {
+// 				let p = args[4 + offset];
+// 				if (typeof p === 'number')
+// 					flags = p;
+// 			}
 			
-			if (typeof method === 'string' && method.length) {
-				method_name = method;
-			} else if (typeof method === 'function') {
-				const slot_id = GodotAnonymousConnectionManager.get_slot_id(this, signal, target);
-				if (target[method.name] === method) {
-					method_name = method.name;
-				} else {
-					method_name = GodotAnonymousConnectionManager.get_anonymous_method_name();
-					function callback(...args) { method.apply(target_caller, args); };
-					target[method_name] = callback;
-					callback[slot_id] = method_name;
-				}
-				method[slot_id] = method_name;
-			} else {
-				throw new Error('method name or function expected for signal method');
-			}
+// 			if (typeof method === 'string' && method.length) {
+// 				method_name = method;
+// 			} else if (typeof method === 'function') {
+// 				const slot_id = GodotAnonymousConnectionManager.get_slot_id(this, signal, target);
+// 				if (target[method.name] === method) {
+// 					method_name = method.name;
+// 				} else {
+// 					method_name = GodotAnonymousConnectionManager.get_anonymous_method_name();
+// 					function callback(...args) { method.apply(target_caller, args); };
+// 					target[method_name] = callback;
+// 					callback[slot_id] = method_name;
+// 				}
+// 				method[slot_id] = method_name;
+// 			} else {
+// 				throw new Error('method name or function expected for signal method');
+// 			}
 			
-			// console.log("connect", this, signal, target, method_name, params, flags);
-			return godot_object_connect.apply(this, [signal, target, method_name, params, flags]);
-		},
-		writable: false,
-		configurable: true
-	});
+// 			// console.log("connect", this, signal, target, method_name, params, flags);
+// 			return godot_object_connect.apply(this, [signal, target, method_name, params, flags]);
+// 		},
+// 		writable: false,
+// 		configurable: true
+// 	});
 	
-	const godot_object_disconnect = godot.Object.prototype.disconnect;
-	Object.defineProperty(godot.Object.prototype, 'disconnect', {
-		// Object.prototype.disconnect(signal_name, target, method)
-		value: function disconnect(...args) {
-			if (args.length < 2) throw new Error('2 or more arguments expected');
-			let signal = args[0];
-			if (typeof signal !== 'string' || !signal) throw new Error('signal name expected for argument #0');
+// 	const godot_object_disconnect = godot.Object.prototype.disconnect;
+// 	Object.defineProperty(godot.Object.prototype, 'disconnect', {
+// 		// Object.prototype.disconnect(signal_name, target, method)
+// 		value: function disconnect(...args) {
+// 			if (args.length < 2) throw new Error('2 or more arguments expected');
+// 			let signal = args[0];
+// 			if (typeof signal !== 'string' || !signal) throw new Error('signal name expected for argument #0');
 			
-			let target = null;
-			let method_name = null;
-			let method = null;
-			let slot_id = undefined;
+// 			let target = null;
+// 			let method_name = null;
+// 			let method = null;
+// 			let slot_id = undefined;
 			
-			if (typeof args[1] === 'function') {
-				target = GodotAnonymousConnectionManager;
-				method = args[1];
-			} else if (args.length >= 3) {
-				target = args[1] || GodotAnonymousConnectionManager;
-				if (!(target instanceof godot.Object)) {
-					new Error('godot.Object expected for signal target');
-				}
-				method = args[2];
-			} else {
-				throw new Error('method name or function expected');
-			}
+// 			if (typeof args[1] === 'function') {
+// 				target = GodotAnonymousConnectionManager;
+// 				method = args[1];
+// 			} else if (args.length >= 3) {
+// 				target = args[1] || GodotAnonymousConnectionManager;
+// 				if (!(target instanceof godot.Object)) {
+// 					new Error('godot.Object expected for signal target');
+// 				}
+// 				method = args[2];
+// 			} else {
+// 				throw new Error('method name or function expected');
+// 			}
 			
-			if (typeof method === 'string' && method) {
-				method_name = method;
-			} else if (typeof method === 'function') {
-				slot_id = GodotAnonymousConnectionManager.get_slot_id(this, signal, target);
-				method_name = method[slot_id];
-				method[slot_id] = undefined;
-			} else {
-				throw new Error('method name or function expected');
-			}
+// 			if (typeof method === 'string' && method) {
+// 				method_name = method;
+// 			} else if (typeof method === 'function') {
+// 				slot_id = GodotAnonymousConnectionManager.get_slot_id(this, signal, target);
+// 				method_name = method[slot_id];
+// 				method[slot_id] = undefined;
+// 			} else {
+// 				throw new Error('method name or function expected');
+// 			}
 			
-			if (slot_id) {
-				if (typeof target[method_name] !== 'undefined') {
-					target[method_name] = undefined;
-					delete target[method_name];
-				}
-				delete method[slot_id];
-			}
-			// console.log("disconnect", this, signal, target, method_name);
-			godot_object_disconnect.apply(this, [signal, target, method_name]);
-		},
-		writable: false,
-		configurable: true
-	});
+// 			if (slot_id) {
+// 				if (typeof target[method_name] !== 'undefined') {
+// 					target[method_name] = undefined;
+// 					delete target[method_name];
+// 				}
+// 				delete method[slot_id];
+// 			}
+// 			// console.log("disconnect", this, signal, target, method_name);
+// 			godot_object_disconnect.apply(this, [signal, target, method_name]);
+// 		},
+// 		writable: false,
+// 		configurable: true
+// 	});
 	
-	const godot_object_is_connected = godot.Object.prototype.is_connected;
-	Object.defineProperty(godot.Object.prototype, 'is_connected', {
-		// Object.prototype.is_connected(signal_name, target, method)
-		value: function godot_is_connected_override(...args) {
-			if (args.length < 3) throw new Error('3 arguments expected');
-			let signal = args[0];
-			if (typeof signal !== 'string' || !signal) throw new Error('signal name expected for argument #1');
+// 	const godot_object_is_connected = godot.Object.prototype.is_connected;
+// 	Object.defineProperty(godot.Object.prototype, 'is_connected', {
+// 		// Object.prototype.is_connected(signal_name, target, method)
+// 		value: function godot_is_connected_override(...args) {
+// 			if (args.length < 3) throw new Error('3 arguments expected');
+// 			let signal = args[0];
+// 			if (typeof signal !== 'string' || !signal) throw new Error('signal name expected for argument #1');
 			
-			let target = null;
-			let method = null;
-			let method_name = null;
-			let slot_id = undefined;
+// 			let target = null;
+// 			let method = null;
+// 			let method_name = null;
+// 			let slot_id = undefined;
 			
-			if (typeof args[1] === 'function') {
-				target = GodotAnonymousConnectionManager;
-				method = args[1];
-			} else if (args.length >= 3) {
-				target = args[1] || GodotAnonymousConnectionManager;
-				if (!(target instanceof godot.Object)) {
-					new Error('godot.Object expected for signal target');
-				}
-				method = args[2];
-			} else {
-				throw new Error('method name or function expected for argument #2');
-			}
+// 			if (typeof args[1] === 'function') {
+// 				target = GodotAnonymousConnectionManager;
+// 				method = args[1];
+// 			} else if (args.length >= 3) {
+// 				target = args[1] || GodotAnonymousConnectionManager;
+// 				if (!(target instanceof godot.Object)) {
+// 					new Error('godot.Object expected for signal target');
+// 				}
+// 				method = args[2];
+// 			} else {
+// 				throw new Error('method name or function expected for argument #2');
+// 			}
 			
-			if (typeof method === 'string') {
-				method_name = method;
-			} else if (typeof method === 'function') {
-				slot_id = GodotAnonymousConnectionManager.get_slot_id(this, signal, target);
-				method_name = method[slot_id];
-			} else {
-				throw new Error('method name or function expected');
-			}
+// 			if (typeof method === 'string') {
+// 				method_name = method;
+// 			} else if (typeof method === 'function') {
+// 				slot_id = GodotAnonymousConnectionManager.get_slot_id(this, signal, target);
+// 				method_name = method[slot_id];
+// 			} else {
+// 				throw new Error('method name or function expected');
+// 			}
 			
-			return godot_object_is_connected.apply(this, [signal, target, method_name]);
-		},
-		writable: false,
-		configurable: true
-	});
+// 			return godot_object_is_connected.apply(this, [signal, target, method_name]);
+// 		},
+// 		writable: false,
+// 		configurable: true
+// 	});
 	
-	function godot_yield(target, signal) {
-		return new Promise(function(resolve, reject) {
-			function callback(...args) {
-				const slot_id = GodotAnonymousConnectionManager.get_slot_id(target, signal, GodotAnonymousConnectionManager);
-				const method_name = callback[slot_id];
-				GodotAnonymousConnectionManager[method_name] = undefined;
-				delete GodotAnonymousConnectionManager[method_name];
-				delete callback[slot_id];
-				resolve(args);
-			};
-			target.connect(signal, GodotAnonymousConnectionManager, callback, [], godot.Object.CONNECT_ONESHOT);
-		});
-	}
+// 	function godot_yield(target, signal) {
+// 		return new Promise(function(resolve, reject) {
+// 			function callback(...args) {
+// 				const slot_id = GodotAnonymousConnectionManager.get_slot_id(target, signal, GodotAnonymousConnectionManager);
+// 				const method_name = callback[slot_id];
+// 				GodotAnonymousConnectionManager[method_name] = undefined;
+// 				delete GodotAnonymousConnectionManager[method_name];
+// 				delete callback[slot_id];
+// 				resolve(args);
+// 			};
+// 			target.connect(signal, GodotAnonymousConnectionManager, callback, [], godot.Object.CONNECT_ONESHOT);
+// 		});
+// 	}
 	
-	Object.defineProperty(godot, 'yield', {
-		value: godot_yield,
-		writable: false,
-		configurable: true
-	});
+// 	Object.defineProperty(godot, 'yield', {
+// 		value: godot_yield,
+// 		writable: false,
+// 		configurable: true
+// 	});
 
 
-	const godot_node_get_node = godot.Node.prototype.get_node;
-	Object.defineProperty(godot.Node.prototype, 'get_node', {
-		value: function(arg) {
-			if (typeof arg === 'string') {
-				return godot_node_get_node.call(this, arg);
-			} else if (typeof arg === 'function') {
-				for (let n of this.get_children()) {
-					if (n instanceof arg) {
-						return n;
-					}
-				}
-			}
-			return null;
-		},
-		writable: false,
-		configurable: true
-	});
+// 	const godot_node_get_node = godot.Node.prototype.get_node;
+// 	Object.defineProperty(godot.Node.prototype, 'get_node', {
+// 		value: function(arg) {
+// 			if (typeof arg === 'string') {
+// 				return godot_node_get_node.call(this, arg);
+// 			} else if (typeof arg === 'function') {
+// 				for (let n of this.get_children()) {
+// 					if (n instanceof arg) {
+// 						return n;
+// 					}
+// 				}
+// 			}
+// 			return null;
+// 		},
+// 		writable: false,
+// 		configurable: true
+// 	});
 
-	Object.defineProperty(godot.Node.prototype, '$', {
-		value: godot.Node.prototype.get_node,
-		writable: false,
-		configurable: true
-	});
+// 	Object.defineProperty(godot.Node.prototype, '$', {
+// 		value: godot.Node.prototype.get_node,
+// 		writable: false,
+// 		configurable: true
+// 	});
 
-	const godot_vector2 = godot.Vector2;
-	Object.defineProperty(godot_vector2, "Axis", {
-		value: {
-			AXIS_X: 0,
-			AXIS_Y: 1,
-		},
-		writable: false,
-		configurable: false,
-	});
+// 	const godot_vector2 = godot.Vector2;
+// 	Object.defineProperty(godot_vector2, "Axis", {
+// 		value: {
+// 			AXIS_X: 0,
+// 			AXIS_Y: 1,
+// 		},
+// 		writable: false,
+// 		configurable: false,
+// 	});
 
-	const godot_vector3 = godot.Vector3;
-	Object.defineProperty(godot_vector3, "Axis", {
-		value: {
-			AXIS_X: 0,
-			AXIS_Y: 1,
-			AXIS_Z: 2,
-		},
-		writable: false,
-		configurable: false,
-	});
+// 	const godot_vector3 = godot.Vector3;
+// 	Object.defineProperty(godot_vector3, "Axis", {
+// 		value: {
+// 			AXIS_X: 0,
+// 			AXIS_Y: 1,
+// 			AXIS_Z: 2,
+// 		},
+// 		writable: false,
+// 		configurable: false,
+// 	});
 
-	// iterator of Pool*Vector
-	const pool_classes = [ godot.PackedByteArray, godot.PackedInt32Array, godot.PackedFloat32Array, godot.PackedStringArray, godot.PackedVector2Array, godot.PackedVector3Array, godot.PackedColorArray ];
-	for (const pool_class of pool_classes) {
-		Object.defineProperty(pool_class.prototype, Symbol.iterator, {value: function iterator() {
-			let next_index = 0;
-			return {
-				next: ()=> {
-					if (next_index < this.size()) {
-						return { value: this.get(next_index++), done: false }
-					} else {
-						return { done: true };
-					}
-				},
-			};
-		}});
-	}
+// 	// iterator of Pool*Vector
+// 	const pool_classes = [ godot.PackedByteArray, godot.PackedInt32Array, godot.PackedFloat32Array, godot.PackedStringArray, godot.PackedVector2Array, godot.PackedVector3Array, godot.PackedColorArray ];
+// 	for (const pool_class of pool_classes) {
+// 		Object.defineProperty(pool_class.prototype, Symbol.iterator, {value: function iterator() {
+// 			let next_index = 0;
+// 			return {
+// 				next: ()=> {
+// 					if (next_index < this.size()) {
+// 						return { value: this.get(next_index++), done: false }
+// 					} else {
+// 						return { done: true };
+// 					}
+// 				},
+// 			};
+// 		}});
+// 	}
 
-	return godot.TOOLS_ENABLED ? {
-		"removed": {
-			"Rect2": ["end", "grow_margin"],
-			"Color": ["h", "s", "v", "r8", "g8", "b8", "a8"],
-			"Transform2D": ["xform", "xform_inv"],
-			"Basis": ["is_equal_approx"],
-			"Plane": ["intersects_segment", "intersects_ray", "intersect_3"],
-			"AABB": ["end"],
-			"Transform": ["xform", "xform_inv"],
-		},
-		"added": {
-			"Object": [
-				"/** Connect the `method` of `target` to the `signal`*/",
-				"//@ts-ignore",
-				"connect(signal: string, target: Object, method: Function, binds: any[] = [], flags: number = 0) : number;",
-				"",
-				"/** Connect the `method` to the `signal`. The caller of the method will be `null` */",
-				"//@ts-ignore",
-				"connect(signal: string, method: Function, binds: any[] = [], flags: number = 0) : number;",
-				"",
-				"/** Returns `true` if a connection exists for a given `signal`, `target`, and `method`. */",
-				"is_connected(signal: string, target: Object, method: Function) : boolean;",
-				"/** Returns `true` if a connection exists for a given `signal` and `method`. */",
-				"is_connected(signal: string, method: Function) : boolean;",
-				"",
-				"/** Disconnects a `signal` from the `method` on the given `target`. */",
-				"disconnect(signal: string, target: Object, method: Function) : void;",
-				"/** Disconnects a `signal` from the `method` */",
-				"disconnect(signal: string, method: Function) : void;"
-			],
-			"Node": [
-				"/** Get first node with the class `cls` */",
-				"get_node<T extends godot.Node>(cls: new()=>T): T;",
-				"",
-				"/** Get node with the path */",
-				"$(path: string): godot.Node;",
-				"/** Get first node with the class `cls` */",
-				"$<T extends godot.Node>(cls: new()=>T): T;",
-			]
-		},
-	} : undefined;
-})();
+// 	return godot.TOOLS_ENABLED ? {
+// 		"removed": {
+// 			"Rect2": ["end", "grow_margin"],
+// 			"Color": ["h", "s", "v", "r8", "g8", "b8", "a8"],
+// 			"Transform2D": ["xform", "xform_inv"],
+// 			"Basis": ["is_equal_approx"],
+// 			"Plane": ["intersects_segment", "intersects_ray", "intersect_3"],
+// 			"AABB": ["end"],
+// 			"Transform": ["xform", "xform_inv"],
+// 		},
+// 		"added": {
+// 			"Object": [
+// 				"/** Connect the `method` of `target` to the `signal`*/",
+// 				"//@ts-ignore",
+// 				"connect(signal: string, target: Object, method: Function, binds: any[] = [], flags: number = 0) : number;",
+// 				"",
+// 				"/** Connect the `method` to the `signal`. The caller of the method will be `null` */",
+// 				"//@ts-ignore",
+// 				"connect(signal: string, method: Function, binds: any[] = [], flags: number = 0) : number;",
+// 				"",
+// 				"/** Returns `true` if a connection exists for a given `signal`, `target`, and `method`. */",
+// 				"is_connected(signal: string, target: Object, method: Function) : boolean;",
+// 				"/** Returns `true` if a connection exists for a given `signal` and `method`. */",
+// 				"is_connected(signal: string, method: Function) : boolean;",
+// 				"",
+// 				"/** Disconnects a `signal` from the `method` on the given `target`. */",
+// 				"disconnect(signal: string, target: Object, method: Function) : void;",
+// 				"/** Disconnects a `signal` from the `method` */",
+// 				"disconnect(signal: string, method: Function) : void;"
+// 			],
+// 			"Node": [
+// 				"/** Get first node with the class `cls` */",
+// 				"get_node<T extends godot.Node>(cls: new()=>T): T;",
+// 				"",
+// 				"/** Get node with the path */",
+// 				"$(path: string): godot.Node;",
+// 				"/** Get first node with the class `cls` */",
+// 				"$<T extends godot.Node>(cls: new()=>T): T;",
+// 			]
+// 		},
+// 	} : undefined;
+// })();
diff --git a/quickjs/quickjs_binder.cpp b/quickjs/quickjs_binder.cpp
index 35b048c7..ec71d9b5 100644
--- a/quickjs/quickjs_binder.cpp
+++ b/quickjs/quickjs_binder.cpp
@@ -40,14 +40,17 @@ struct GodotMethodArguments {
 		}
 	}
 	~GodotMethodArguments() {
-		if (ptr) memdelete_arr(ptr);
-		if (arguments) memdelete_arr(arguments);
+		if (ptr)
+			memdelete_arr(ptr);
+		if (arguments)
+			memdelete_arr(arguments);
 	}
 };
 
 _FORCE_INLINE_ static ECMAScriptGCHandler *BINDING_DATA_FROM_GD(Object *p_object) {
 	ERR_FAIL_COND_V(p_object == NULL, NULL);
-	ECMAScriptGCHandler *bind = (ECMAScriptGCHandler *)(p_object)->get_script_instance_binding(ECMAScriptLanguage::get_singleton()->get_language_index());
+	ECMAScriptLanguage *lang = ECMAScriptLanguage::get_singleton();
+	ECMAScriptGCHandler *bind = (ECMAScriptGCHandler *)(p_object)->get_instance_binding(lang, lang->getInstanceBindingCallbacks());
 	return bind;
 }
 
@@ -146,7 +149,6 @@ void QuickJSBinder::add_global_properties() {
 }
 
 JSValue QuickJSBinder::object_method(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int method_id) {
-
 	ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 	ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "Call native method without native binding data"));
 	ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "Call native method without native object caller"));
@@ -239,16 +241,14 @@ JSValue QuickJSBinder::variant_to_var(JSContext *ctx, const Variant p_var) {
 			return to_js_string(ctx, p_var);
 		case Variant::OBJECT: {
 			Object *obj = p_var;
-			if (obj == NULL) return JS_NULL;
+			if (obj == NULL)
+				return JS_NULL;
 			ECMAScriptGCHandler *data = BINDING_DATA_FROM_GD(ctx, obj);
 			ERR_FAIL_NULL_V(data, JS_UNDEFINED);
 			ERR_FAIL_NULL_V(data->ecma_object, JS_UNDEFINED);
 			ERR_FAIL_COND_V(data->context != ctx, (JS_UNDEFINED));
 			QuickJSBinder *binder = get_context_binder(ctx);
 			JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, data->ecma_object);
-			if (binder->lastest_allocated_object == data) {
-				binder->lastest_allocated_object = NULL;
-			}
 			JS_DupValue(ctx, js_obj);
 
 			return js_obj;
@@ -334,7 +334,6 @@ Variant QuickJSBinder::var_to_variant(JSContext *ctx, JSValue p_val) {
 }
 
 JSValue QuickJSBinder::godot_builtin_function(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic) {
-
 	Variant ret;
 	Callable::CallError err;
 	String err_msg;
@@ -550,7 +549,8 @@ JSValue QuickJSBinder::godot_instance_from_id(JSContext *ctx, JSValue this_val,
 }
 
 void QuickJSBinder::add_debug_binding_info(JSContext *ctx, JSValueConst p_obj, const ECMAScriptGCHandler *p_bind) {
-	if (!p_bind) return;
+	if (!p_bind)
+		return;
 	JSValue classname = JS_UNDEFINED;
 	if (p_bind->type != Variant::OBJECT) {
 		classname = to_js_string(ctx, Variant::get_type_name(p_bind->type));
@@ -592,7 +592,8 @@ String QuickJSBinder::resolve_module_file(const String &file) {
 		return *ptr;
 	}
 	String path = file;
-	if (FileAccess::exists(path)) return path;
+	if (FileAccess::exists(path))
+		return path;
 	// add extensions to try
 	String extension = file.get_extension();
 	List<String> extensions;
@@ -695,7 +696,6 @@ JSModuleDef *QuickJSBinder::js_make_module(JSContext *ctx, const String &p_id, c
 }
 
 QuickJSBinder::ModuleCache QuickJSBinder::js_compile_module(JSContext *ctx, const String &p_code, const String &p_filename, ECMAscriptScriptError *r_error) {
-
 	if (NULL != compiling_modules.find(p_filename)) {
 		String chain;
 		for (List<String>::Element *E = compiling_modules.front(); E; E = E->next()) {
@@ -735,7 +735,6 @@ QuickJSBinder::ModuleCache QuickJSBinder::js_compile_module(JSContext *ctx, cons
 }
 
 QuickJSBinder::ModuleCache *QuickJSBinder::js_compile_and_cache_module(JSContext *ctx, const String &p_code, const String &p_filename, ECMAscriptScriptError *r_error) {
-
 	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
 	ModuleCache *last_module = binder->module_cache.getptr(p_filename);
 	if (last_module) {
@@ -1214,7 +1213,6 @@ QuickJSBinder::~QuickJSBinder() {
 }
 
 void QuickJSBinder::initialize() {
-
 	thread_id = Thread::get_caller_id();
 	{
 		GLOBAL_LOCK_FUNCTION
@@ -1262,11 +1260,11 @@ void QuickJSBinder::initialize() {
 	String script_binding_error;
 	ECMAScriptGCHandler eval_ret;
 	if (OK == safe_eval_text(ECMAScriptBinder::BINDING_SCRIPT_CONTENT, ECMAScriptBinder::EVAL_TYPE_GLOBAL, "<internal: binding_script.js>", script_binding_error, eval_ret)) {
-#ifdef TOOLS_ENABLED
-		JSValue ret = JS_MKPTR(JS_TAG_OBJECT, eval_ret.ecma_object);
-		modified_api = var_to_variant(ctx, ret);
-		JS_FreeValue(ctx, ret);
-#endif
+		if (eval_ret.ecma_object) {
+			JSValue ret = JS_MKPTR(JS_TAG_OBJECT, eval_ret.ecma_object);
+			modified_api = var_to_variant(ctx, ret);
+			JS_FreeValue(ctx, ret);
+		}
 	} else {
 		CRASH_NOW_MSG("Execute script binding failed:" ENDL + script_binding_error);
 	}
@@ -1317,12 +1315,10 @@ void QuickJSBinder::initialize() {
 		// TODO: debug editor plugin support
 #endif
 	}
-
 #endif
 }
 
 void QuickJSBinder::uninitialize() {
-
 	godot_object_class = NULL;
 	godot_reference_class = NULL;
 	builtin_binder.uninitialize();
@@ -1357,16 +1353,16 @@ void QuickJSBinder::uninitialize() {
 	for (KeyValue<String, ModuleCache> &pair : module_cache) {
 		ModuleCache &m = pair.value;
 #if MODULE_HAS_REFCOUNT
-			if (m.module) {
-				JSValue val = JS_MKPTR(JS_TAG_MODULE, m.module);
-				JS_FreeValue(ctx, val);
-			}
+		if (m.module) {
+			JSValue val = JS_MKPTR(JS_TAG_MODULE, m.module);
+			JS_FreeValue(ctx, val);
+		}
 #endif
-			if (m.res.is_valid()) {
-				JS_FreeValue(ctx, m.res_value);
-				module_resources.push_back(m.res);
-				m.res = Ref<Resource>();
-			}
+		if (m.res.is_valid()) {
+			JS_FreeValue(ctx, m.res_value);
+			module_resources.push_back(m.res);
+			m.res = Ref<Resource>();
+		}
 	}
 	module_cache.clear();
 
@@ -1412,7 +1408,6 @@ void QuickJSBinder::uninitialize() {
 }
 
 void QuickJSBinder::language_finalize() {
-
 	GLOBAL_LOCK_FUNCTION
 	transfer_deopot.clear();
 }
@@ -1524,7 +1519,6 @@ Error QuickJSBinder::compile_to_bytecode(const String &p_code, const String &p_f
 }
 
 Error QuickJSBinder::load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, ECMAScriptGCHandler *r_module) {
-
 	Variant bytes = p_bytecode;
 	if (ModuleCache *ptr = module_cache.getptr(p_file)) {
 		if (bytes.hash() == ptr->hash) {
@@ -1556,13 +1550,13 @@ Error QuickJSBinder::load_bytecode(const Vector<uint8_t> &p_bytecode, const Stri
 
 /************************* Memory Management ******************************/
 
-void *QuickJSBinder::alloc_object_binding_data(Object *p_object) {
-	ECMAScriptGCHandler *data = new_gc_handler(NULL); // pasa null context as all thread allocate from here
-	lastest_allocated_object = data;
+ECMAScriptGCHandler *QuickJSBinder::alloc_object_binding_data(Object *p_object) {
+	ECMAScriptGCHandler *data = new_gc_handler(nullptr);
+	bind_gc_object(ctx, data, p_object);
 	return data;
 }
 
-void QuickJSBinder::free_object_binding_data(void *p_gc_handle) {
+void QuickJSBinder::free_object_binding_data(ECMAScriptGCHandler *p_gc_handle) {
 	ECMAScriptGCHandler *bind = (ECMAScriptGCHandler *)p_gc_handle;
 	if (bind->is_object()) {
 		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
@@ -1590,8 +1584,8 @@ Error QuickJSBinder::bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, O
 		data->godot_object = p_object;
 		data->type = Variant::OBJECT;
 		data->flags = ECMAScriptGCHandler::FLAG_OBJECT;
-		if (RefCounted *ref = Object::cast_to<RefCounted>(p_object)) {
-			ref->reference();
+		if (p_object->is_ref_counted()) {
+			RefCounted *ref = Object::cast_to<RefCounted>(p_object);
 			data->flags |= ECMAScriptGCHandler::FLAG_REFERENCE;
 			union {
 				Ref<RefCounted> *ref;
@@ -1613,19 +1607,17 @@ Error QuickJSBinder::bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, O
 	return FAILED;
 }
 
-void QuickJSBinder::godot_refcount_incremented(RefCounted *p_object) {
-	ECMAScriptGCHandler *bind = BINDING_DATA_FROM_GD(p_object);
+void QuickJSBinder::godot_refcount_incremented(ECMAScriptGCHandler *bind) {
 	if (bind->is_valid_ecma_object() && bind->is_reference()) {
 		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
-		JS_DupValue((JSContext *)bind->context, js_obj); // JS ref_count ++
+		JS_DupValue((JSContext *)bind->context, js_obj);
 	}
 }
 
-bool QuickJSBinder::godot_refcount_decremented(RefCounted *p_object) {
-	ECMAScriptGCHandler *bind = BINDING_DATA_FROM_GD(p_object);
+bool QuickJSBinder::godot_refcount_decremented(ECMAScriptGCHandler *bind) {
 	if (bind->is_valid_ecma_object() && bind->is_reference()) {
 		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
-		JS_FreeValue((JSContext *)bind->context, js_obj); // JS ref_count --
+		JS_FreeValue((JSContext *)bind->context, js_obj);
 		return bind->is_finalized();
 	} else {
 		return true;
@@ -1650,6 +1642,7 @@ JSValue QuickJSBinder::object_constructor(JSContext *ctx, JSValueConst new_targe
 			JS_FreeValue(ctx, prototype);
 		}
 
+#if 0
 		// Make script and script instance for the object
 		ECMAScriptInstance *si = memnew(ECMAScriptInstance);
 		si->ecma_object = *bind;
@@ -1668,16 +1661,13 @@ JSValue QuickJSBinder::object_constructor(JSContext *ctx, JSValueConst new_targe
 		}
 		JS_FreeValue(ctx, es_class_name);
 		gd_obj->set_script_instance(si);
-
-		if (bind->is_reference()) { // restore the ref count added in bind_gc_object
-			bind->flags ^= ECMAScriptGCHandler::FLAG_REFERENCE; // Diable the flag to avoid affects to js ref count by unreference call
-			bind->godot_reference->ptr()->unreference();
+#endif
+		if (bind->is_reference()) {
 			bind->flags |= ECMAScriptGCHandler::FLAG_REFERENCE;
 		} else if (bind->is_object()) {
 			JS_DupValue(ctx, js_obj);
 		}
 	}
-
 	return js_obj;
 }
 
@@ -1720,7 +1710,6 @@ void QuickJSBinder::origin_finalizer(JSRuntime *rt, JSValue val) {
 }
 
 JSValue QuickJSBinder::object_free(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-
 	ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 	ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "The object already be freed"));
 	ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "The object already be freed"));
@@ -1755,7 +1744,6 @@ JSValue QuickJSBinder::godot_register_class(JSContext *ctx, JSValueConst this_va
 }
 
 const ECMAClassInfo *QuickJSBinder::register_ecma_class(const JSValue &p_constructor, const String &p_path) {
-
 	QuickJSBinder *binder = get_context_binder(ctx);
 	JSValue prototype = JS_UNDEFINED;
 	JSValue classid = JS_UNDEFINED;
@@ -2019,10 +2007,12 @@ JSValue QuickJSBinder::global_cancel_animation_frame(JSContext *ctx, JSValue thi
 }
 
 int QuickJSBinder::get_js_array_length(JSContext *ctx, JSValue p_val) {
-	if (!JS_IsArray(ctx, p_val)) return -1;
+	if (!JS_IsArray(ctx, p_val))
+		return -1;
 	JSValue ret = JS_GetProperty(ctx, p_val, JS_ATOM_length);
 	int32_t length = -1;
-	if (JS_ToInt32(ctx, &length, ret)) return -1;
+	if (JS_ToInt32(ctx, &length, ret))
+		return -1;
 	return length;
 }
 
@@ -2042,7 +2032,6 @@ void QuickJSBinder::get_own_property_names(JSContext *ctx, JSValue p_object, Has
 }
 
 ECMAScriptGCHandler QuickJSBinder::create_ecma_instance_for_godot_object(const ECMAClassInfo *p_class, Object *p_object) {
-
 	ERR_FAIL_NULL_V(p_object, ECMAScriptGCHandler());
 	ERR_FAIL_NULL_V(p_class, ECMAScriptGCHandler());
 
@@ -2065,7 +2054,6 @@ ECMAScriptGCHandler QuickJSBinder::create_ecma_instance_for_godot_object(const E
 }
 
 Variant QuickJSBinder::call_method(const ECMAScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
-
 	JSValue object = GET_JSVALUE(p_object);
 	JSAtom atom = get_atom(ctx, p_method);
 	JSValue method = JS_GetProperty(ctx, object, atom);
diff --git a/quickjs/quickjs_binder.h b/quickjs/quickjs_binder.h
index bc32c71e..eb9d4a99 100644
--- a/quickjs/quickjs_binder.h
+++ b/quickjs/quickjs_binder.h
@@ -152,8 +152,6 @@ class QuickJSBinder : public ECMAScriptBinder {
 	int internal_godot_method_id;
 	Vector<const ClassDB::PropertySetGet *> godot_object_indexed_properties;
 	int internal_godot_indexed_property_id;
-	const ECMAScriptGCHandler *lastest_allocated_object = NULL;
-
 #if NO_MODULE_EXPORT_SUPPORT
 	String parsing_script_file;
 #endif
@@ -309,17 +307,17 @@ class QuickJSBinder : public ECMAScriptBinder {
 	_FORCE_INLINE_ const ClassBindData get_origin_class() const { return godot_origin_class; }
 	_FORCE_INLINE_ static JSClassID get_origin_class_id(JSContext *ctx) { return get_context_binder(ctx)->godot_origin_class.class_id; }
 
-	virtual void initialize();
-	virtual void uninitialize();
-	virtual void language_finalize();
-	virtual void frame();
+	virtual void initialize() override;
+	virtual void uninitialize() override;
+	virtual void language_finalize() override;
+	virtual void frame() override;
 
-	virtual void *alloc_object_binding_data(Object *p_object);
-	virtual void free_object_binding_data(void *p_gc_handle);
-	static Error bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, Object *p_object);
+	virtual ECMAScriptGCHandler *alloc_object_binding_data(Object *p_object) override;
+	virtual void free_object_binding_data(ECMAScriptGCHandler *p_gc_handle) override;
+	virtual void godot_refcount_incremented(ECMAScriptGCHandler *p_gc_handle) override;
+	virtual bool godot_refcount_decremented(ECMAScriptGCHandler *p_gc_handle) override;
 
-	virtual void godot_refcount_incremented(RefCounted *p_object);
-	virtual bool godot_refcount_decremented(RefCounted *p_object);
+	static Error bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, Object *p_object);
 
 	virtual Error eval_string(const String &p_source, EvalType type, const String &p_path, ECMAScriptGCHandler &r_ret);
 	virtual Error safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, ECMAScriptGCHandler &r_ret);
diff --git a/register_types.cpp b/register_types.cpp
index e572dd45..996d3058 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -34,17 +34,16 @@
 
 #ifdef TOOLS_ENABLED
 #include "core/io/file_access_encrypted.h"
-#include "editor/export/editor_export.h"
 #include "editor/editor_node.h"
+#include "editor/export/editor_export.h"
 #include "tools/editor_tools.h"
 void editor_init_callback();
 
 class EditorExportECMAScript : public EditorExportPlugin {
-
 	GDCLASS(EditorExportECMAScript, EditorExportPlugin);
 
 public:
-	virtual void _export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features) {
+	virtual void _export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features) override {
 		int script_mode = EditorExportPreset::MODE_SCRIPT_COMPILED;
 		const Ref<EditorExportPreset> &preset = get_export_preset();
 
@@ -59,54 +58,7 @@ class EditorExportECMAScript : public EditorExportPlugin {
 		if (extension != EXT_JSCLASS && extension != EXT_JSMODULE)
 			return;
 
-		if (script_mode == EditorExportPreset::MODE_SCRIPT_ENCRYPTED) {
-			Vector<uint8_t> file = FileAccess::get_file_as_array(p_path);
-			if (file.empty())
-				return;
-
-			String script_key = preset->get_script_encryption_key().to_lower();
-			String tmp_path = EditorSettings::get_singleton()->get_cache_dir().plus_file("script." + extension + "e");
-			FileAccess *fa = FileAccess::open(tmp_path, FileAccess::WRITE);
-
-			Vector<uint8_t> key;
-			key.resize(32);
-			for (int i = 0; i < 32; i++) {
-				int v = 0;
-				if (i * 2 < script_key.length()) {
-					CharType ct = script_key[i * 2];
-					if (ct >= '0' && ct <= '9')
-						ct = ct - '0';
-					else if (ct >= 'a' && ct <= 'f')
-						ct = 10 + ct - 'a';
-					v |= ct << 4;
-				}
-
-				if (i * 2 + 1 < script_key.length()) {
-					CharType ct = script_key[i * 2 + 1];
-					if (ct >= '0' && ct <= '9')
-						ct = ct - '0';
-					else if (ct >= 'a' && ct <= 'f')
-						ct = 10 + ct - 'a';
-					v |= ct;
-				}
-				key.write[i] = v;
-			}
-			FileAccessEncrypted *fae = memnew(FileAccessEncrypted);
-			Error err = fae->open_and_parse(fa, key, FileAccessEncrypted::MODE_WRITE_AES256);
-
-			if (err == OK) {
-				fae->store_buffer(file.ptr(), file.size());
-			}
-
-			memdelete(fae);
-
-			file = FileAccess::get_file_as_array(tmp_path);
-			add_file(p_path.get_basename() + "." + extension + "e", file, true);
-
-			// Clean up temporary file.
-			DirAccess::remove_file_or_error(tmp_path);
-
-		} else {
+		if (script_mode == EditorExportPreset::ScriptExportMode::MODE_SCRIPT_COMPILED) {
 #if 0 // Disable compile to bytecode as it is not battle tested on all platform
 			Error err;
 			String code = FileAccess::get_file_as_string(p_path, &err);
@@ -129,7 +81,9 @@ Ref<ResourceFormatSaverECMAScriptModule> resource_saver_ecmascript_module;
 static ECMAScriptLanguage *script_language_js = nullptr;
 
 void initialize_ECMAScript_module(ModuleInitializationLevel p_level) {
-	if (p_level != ModuleInitializationLevel::MODULE_INITIALIZATION_LEVEL_CORE) return;
+	if (p_level != ModuleInitializationLevel::MODULE_INITIALIZATION_LEVEL_CORE)
+		return;
+
 	ClassDB::register_class<ECMAScript>();
 	ClassDB::register_class<ECMAScriptModule>();
 
@@ -144,7 +98,6 @@ void initialize_ECMAScript_module(ModuleInitializationLevel p_level) {
 	ResourceSaver::add_resource_format_saver(resource_saver_ecmascript_module, true);
 
 	script_language_js = memnew(ECMAScriptLanguage);
-	script_language_js->set_language_index(ScriptServer::get_language_count());
 	ScriptServer::register_language(script_language_js);
 
 #ifdef TOOLS_ENABLED
@@ -153,7 +106,9 @@ void initialize_ECMAScript_module(ModuleInitializationLevel p_level) {
 }
 
 void uninitialize_ECMAScript_module(ModuleInitializationLevel p_level) {
-	if (p_level != ModuleInitializationLevel::MODULE_INITIALIZATION_LEVEL_CORE) return;
+	if (p_level != ModuleInitializationLevel::MODULE_INITIALIZATION_LEVEL_CORE)
+		return;
+
 	ScriptServer::unregister_language(script_language_js);
 	memdelete(script_language_js);
 
@@ -170,11 +125,11 @@ void uninitialize_ECMAScript_module(ModuleInitializationLevel p_level) {
 
 #ifdef TOOLS_ENABLED
 void editor_init_callback() {
-	// ECMAScriptPlugin *plugin = memnew(ECMAScriptPlugin(EditorNode::get_singleton()));
-	// EditorNode::get_singleton()->add_editor_plugin(plugin);
+	ECMAScriptPlugin *plugin = memnew(ECMAScriptPlugin(EditorNode::get_singleton()));
+	EditorNode::get_singleton()->add_editor_plugin(plugin);
 
-	// Ref<EditorExportECMAScript> js_export;
-	// js_export.instance();
-	// EditorExport::get_singleton()->add_export_plugin(js_export);
+	Ref<EditorExportECMAScript> js_export;
+	js_export.instantiate();
+	EditorExport::get_singleton()->add_export_plugin(js_export);
 }
 #endif
diff --git a/tools/editor_tools.cpp b/tools/editor_tools.cpp
index b7ef7700..61972461 100644
--- a/tools/editor_tools.cpp
+++ b/tools/editor_tools.cpp
@@ -5,11 +5,11 @@
 #include "editor/filesystem_dock.h"
 
 #define TS_IGNORE "//@ts-ignore\n"
-static RBMap<String, HashSet<String> > ts_ignore_errors;
-static RBMap<String, HashSet<String> > removed_members;
-static RBMap<String, List<String> > added_apis;
+static HashMap<String, HashSet<String>> ts_ignore_errors;
+static HashMap<String, HashSet<String>> removed_members;
+static HashMap<String, List<String>> added_apis;
 typedef HashMap<String, Vector<const DocData::ConstantDoc *>> ClassEnumerations;
-static RBMap<String, ClassEnumerations> class_enumerations;
+static HashMap<String, ClassEnumerations> class_enumerations;
 
 struct ECMAScriptAlphCompare {
 	_FORCE_INLINE_ bool operator()(const Ref<ECMAScript> &l, const Ref<ECMAScript> &r) const {
@@ -213,7 +213,6 @@ static String get_type_name(const String &p_type) {
 }
 
 String _export_method(const DocData::MethodDoc &p_method, bool is_function = false, bool is_static = false, bool ts_ignore_error = false) {
-#if 0
 	Dictionary dict;
 	dict["description"] = format_doc_text(p_method.description, "\t\t ");
 	dict["name"] = format_property_name(p_method.name);
@@ -223,18 +222,18 @@ String _export_method(const DocData::MethodDoc &p_method, bool is_function = fal
 	bool arg_default_value_started = false;
 	for (int i = 0; i < p_method.arguments.size(); i++) {
 		const DocData::ArgumentDoc &arg = p_method.arguments[i];
-		if (!arg_default_value_started && !arg.default_value.empty()) {
+		if (!arg_default_value_started && !arg.default_value.is_empty()) {
 			arg_default_value_started = true;
 		}
 		String arg_type = get_type_name(arg.type);
-		if (!arg.enumeration.empty()) {
+		if (!arg.enumeration.is_empty()) {
 			arg_type = format_enum_name(arg.enumeration);
 		}
 
 		String default_value;
 		if (arg_default_value_started) {
 			default_value += " = ";
-			if (arg.default_value.empty()) {
+			if (arg.default_value.is_empty()) {
 				if (arg.type == "string") {
 					default_value += "''";
 				} else {
@@ -253,7 +252,7 @@ String _export_method(const DocData::MethodDoc &p_method, bool is_function = fal
 	}
 
 	if (p_method.qualifiers.find("vararg") != -1) {
-		params += params.empty() ? "...args" : ", ...args";
+		params += params.is_empty() ? "...args" : ", ...args";
 	}
 	dict["params"] = params;
 
@@ -280,13 +279,9 @@ String _export_method(const DocData::MethodDoc &p_method, bool is_function = fal
 		}
 	}
 	return apply_pattern(method_template, dict);
-#else
-	return "";
-#endif
 }
 
 String _export_class(const DocData::ClassDoc &class_doc) {
-#if 0
 	String class_template = "\n"
 							"\t/** ${brief_description}\n"
 							"\t ${description} */\n"
@@ -304,8 +299,8 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 	class_template = class_template.replace("${TS_IGNORE}", ts_ignore_errors.has(class_doc.name) ? "\t" TS_IGNORE : "");
 	Dictionary dict;
 	dict["name"] = class_doc.name;
-	dict["inherits"] = class_doc.inherits.empty() ? "" : get_type_name(class_doc.inherits);
-	dict["extends"] = class_doc.inherits.empty() ? "" : " extends ";
+	dict["inherits"] = class_doc.inherits.is_empty() ? "" : get_type_name(class_doc.inherits);
+	dict["extends"] = class_doc.inherits.is_empty() ? "" : " extends ";
 	String brief_description = format_doc_text(class_doc.brief_description, "\t ");
 	dict["brief_description"] = brief_description;
 	String description = format_doc_text(class_doc.description, "\t ");
@@ -321,7 +316,7 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 	}
 
 	String constants = "";
-	RBMap<String, Vector<const DocData::ConstantDoc *> > enumerations;
+	HashMap<String, Vector<const DocData::ConstantDoc *>> enumerations;
 	for (const DocData::ConstantDoc &const_doc : class_doc.constants) {
 		if (ignore_members.has(const_doc.name)) continue;
 
@@ -330,11 +325,11 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 		dict["name"] = format_property_name(const_doc.name);
 		dict["value"] = const_doc.value;
 		String type = "number";
-		if (!const_doc.enumeration.empty()) {
+		if (!const_doc.enumeration.is_empty()) {
 			type = const_doc.enumeration + "." + const_doc.name;
 		} else if (const_doc.value.find("(") != -1) {
 			type = const_doc.value.split("(")[0];
-		} else if (const_doc.value.is_valid_integer()) {
+		} else if (const_doc.value.is_valid_int()) {
 			type = dict["value"];
 		}
 		dict["type"] = type;
@@ -350,7 +345,7 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 		}
 		constants += apply_pattern(const_str, dict);
 
-		if (!const_doc.enumeration.empty()) {
+		if (!const_doc.enumeration.is_empty()) {
 			if (!enumerations.has(const_doc.enumeration)) {
 				Vector<const DocData::ConstantDoc *> e;
 				e.push_back(&const_doc);
@@ -365,11 +360,11 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 	dict["constants"] = constants;
 	String enumerations_str = "";
 	for (const KeyValue<String, Vector<const DocData::ConstantDoc *>> &E : enumerations) {
-		if (ignore_members.has(E.key) {
+		if (ignore_members.has(E.key)) {
 			continue;
 		}
 		String enum_str = "\t\tenum " + E.key + " {\n";
-		const Vector<const DocData::ConstantDoc *> &enums = E->get();
+		const Vector<const DocData::ConstantDoc *> &enums = E.value;
 		for (int i = 0; i < enums.size(); i++) {
 			String const_str = "\t\t\t/** ${description} */\n"
 							   "\t\t\t${name} = ${value},\n";
@@ -472,13 +467,9 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 	dict["extrals"] = extrals;
 
 	return apply_pattern(class_template, dict);
-#else
-	return "";
-#endif
 }
 
 void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
-#if 0
 	modified_api = &ECMAScriptLanguage::get_singleton()->get_main_binder()->get_modified_api();
 
 	removed_members.clear();
@@ -543,7 +534,7 @@ void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 	ignored_classes.insert("RID");
 	ignored_classes.insert("NodePath");
 	ignored_classes.insert("Transform2D");
-	ignored_classes.insert("Transform");
+	ignored_classes.insert("Transform3D");
 	ignored_classes.insert("Basis");
 	ignored_classes.insert("Quaternion");
 	ignored_classes.insert("Plane");
@@ -604,9 +595,9 @@ void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 				}
 				class_enumerations.insert(GODOT_OBJECT_NAME, enumerations);
 
-				for (auto E = enumerations.front(); E; E = E->next()) {
-					String enum_str = "\tenum " + format_enum_name(E->key()) + " {\n";
-					const Vector<const DocData::ConstantDoc *> &enums = E->value();
+				for (auto E : enumerations) {
+					String enum_str = "\tenum " + format_enum_name(E.key) + " {\n";
+					const Vector<const DocData::ConstantDoc *> &enums = E.value;
 					for (int i = 0; i < enums.size(); i++) {
 						String const_str = "\t\t/** ${description} */\n"
 										   "\t\t${name} = ${value},\n";
@@ -616,21 +607,15 @@ void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 						dict["value"] = enums[i]->value;
 
 						// Exceptions
-
-						/**
-							 * KEY_MASK_CMD docs has value listed as "platform-dependent",
-							 * so we have to retreive the actual value manually
-							 */
 						if (dict["name"] == "KEY_MASK_CMD") {
-							dict["value"] = KEY_MASK_CMD;
+							dict["value"] = (uint64_t)KeyModifierMask::CMD;
 						}
-
 						enum_str += apply_pattern(const_str, dict);
 					}
 					enum_str += "\t}\n";
 					enumerations_str += enum_str;
 				}
-
+#if 0
 				for (int i = 0; i < class_doc.methods.size(); i++) {
 					const DocData::MethodDoc &method_doc = class_doc.methods[i];
 					if (Expression::find_function(method_doc.name) == Expression::FUNC_MAX) {
@@ -641,6 +626,7 @@ void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 					}
 					functions += _export_method(method_doc, true, false, ts_ignore_errors.has(class_doc.name) && ts_ignore_errors[class_doc.name].has(method_doc.name));
 				}
+#endif
 			}
 			continue;
 		}
@@ -657,11 +643,9 @@ void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 	if (f.is_valid() && f->is_open()) {
 		f->store_string(text);
 	}
-#endif
 }
 
 void ECMAScriptPlugin::_export_enumeration_binding_file(const String &p_path) {
-#if 0
 	_export_typescript_declare_file("");
 	String file_content = "// Tool generated file DO NOT modify mannually\n"
 						  "// Add this script as first autoload to your project to bind enumerations for release build of godot engine\n"
@@ -676,17 +660,18 @@ void ECMAScriptPlugin::_export_enumeration_binding_file(const String &p_path) {
 						  "export default class extends godot.Node {};\n";
 
 	String enumerations = "";
-	for (auto cls = class_enumerations.front(); cls; cls = cls->next()) {
-		const ClassEnumerations &enumeration = cls->value();
-		const String &name = cls->key();
+	for (const auto &cls : class_enumerations) {
+		const ClassEnumerations &enumeration = cls.value;
+		const String &name = cls.key;
 		String class_name = name;
 		if (class_name != "godot") {
 			class_name = "godot." + class_name;
 		}
 		String class_enums = "";
-		for (auto E = enumeration.front(); E; E = E->next()) {
+		uint32_t idx = 0;
+		for (const auto &E : enumeration) {
 			String enum_items_text = "{";
-			const Vector<const DocData::ConstantDoc *> &consts = E->value();
+			const Vector<const DocData::ConstantDoc *> &consts = E.value;
 			for (int i = 0; i < consts.size(); ++i) {
 				const DocData::ConstantDoc *c = consts[i];
 				enum_items_text += c->name + ": " + c->value;
@@ -696,14 +681,15 @@ void ECMAScriptPlugin::_export_enumeration_binding_file(const String &p_path) {
 			}
 			enum_items_text += " }";
 			Dictionary dict;
-			dict["name"] = format_enum_name(E->key());
+			dict["name"] = format_enum_name(E.key);
 			dict["values"] = enum_items_text;
 			class_enums += apply_pattern("\n\t\t${name}: { value: ${values} }", dict);
-			if (E->next()) {
+			if (idx < enumeration.size() - 1) {
 				class_enums += ", ";
 			} else {
 				class_enums += "\n\t";
 			}
+			idx++;
 		}
 		static String class_template = "\tbind(${class}, {${enumerations}});\n";
 		Dictionary dict;
@@ -716,7 +702,6 @@ void ECMAScriptPlugin::_export_enumeration_binding_file(const String &p_path) {
 	file_content = apply_pattern(file_content, dict);
 
 	dump_to_file(p_path, file_content);
-#endif
 }
 
 void ECMAScriptPlugin::_generate_typescript_project() {
diff --git a/tools/editor_tools.h b/tools/editor_tools.h
index ade484b8..3c19d499 100644
--- a/tools/editor_tools.h
+++ b/tools/editor_tools.h
@@ -32,7 +32,7 @@ class ECMAScriptPlugin : public EditorPlugin {
 	void _generate_typescript_project();
 
 public:
-	virtual String get_name() const { return "ECMAScriptPlugin"; }
+	virtual String get_name() const override { return "ECMAScriptPlugin"; }
 	ECMAScriptPlugin(EditorNode *p_node);
 };
 

From 56016ee50e8c83beef5a0426afd327c7061f450a Mon Sep 17 00:00:00 2001
From: Geequlim <geequlim@gmail.com>
Date: Wed, 24 Aug 2022 23:42:56 +0800
Subject: [PATCH 03/71] Fix reference object constructor

---
 ecmascript_instance.h      |  2 +
 ecmascript_language.cpp    |  2 +-
 ecmascript_language.h      |  2 +-
 quickjs/quickjs_binder.cpp | 11 +++++-
 tests/UnitTest.js          | 79 ++++++++++++++++++++++++++++++++++++++
 5 files changed, 92 insertions(+), 4 deletions(-)
 create mode 100644 tests/UnitTest.js

diff --git a/ecmascript_instance.h b/ecmascript_instance.h
index a730a6ee..cff531aa 100644
--- a/ecmascript_instance.h
+++ b/ecmascript_instance.h
@@ -22,6 +22,8 @@ class ECMAScriptInstance : public ScriptInstance {
 	virtual bool get(const StringName &p_name, Variant &r_ret) const override;
 	virtual void get_property_list(List<PropertyInfo> *p_properties) const override;
 	virtual Variant::Type get_property_type(const StringName &p_name, bool *r_is_valid = nullptr) const override;
+	virtual bool property_can_revert(const StringName &p_name) const override { return false; };
+	virtual bool property_get_revert(const StringName &p_name, Variant &r_ret) const override { return false; };
 
 	virtual void get_method_list(List<MethodInfo> *p_list) const override;
 	virtual bool has_method(const StringName &p_method) const override;
diff --git a/ecmascript_language.cpp b/ecmascript_language.cpp
index 39427248..649b5296 100644
--- a/ecmascript_language.cpp
+++ b/ecmascript_language.cpp
@@ -48,7 +48,7 @@ ECMAScriptLanguage::~ECMAScriptLanguage() {
 void ECMAScriptLanguage::init() {
 	ERR_FAIL_NULL(main_binder);
 	main_binder->initialize();
-	execute_file("bin/test.js");
+	execute_file("modules/ECMAScript/tests/UnitTest.js");
 }
 
 void ECMAScriptLanguage::finish() {
diff --git a/ecmascript_language.h b/ecmascript_language.h
index 67f96067..4d1d5fb8 100644
--- a/ecmascript_language.h
+++ b/ecmascript_language.h
@@ -34,7 +34,7 @@ class ECMAScriptLanguage : public ScriptLanguage {
 	}
 
 	_FORCE_INLINE_ virtual String get_name() const override { return "JavaScript"; }
-	const GDNativeInstanceBindingCallbacks *getInstanceBindingCallbacks() const { return &instance_binding_callbacks; }
+	const GDNativeInstanceBindingCallbacks *get_instance_binding_callbacks() const { return &instance_binding_callbacks; }
 #ifdef TOOLS_ENABLED
 	_FORCE_INLINE_ HashSet<Ref<ECMAScript> > &get_scripts() { return scripts; }
 #endif
diff --git a/quickjs/quickjs_binder.cpp b/quickjs/quickjs_binder.cpp
index ec71d9b5..a043e0f4 100644
--- a/quickjs/quickjs_binder.cpp
+++ b/quickjs/quickjs_binder.cpp
@@ -50,7 +50,7 @@ struct GodotMethodArguments {
 _FORCE_INLINE_ static ECMAScriptGCHandler *BINDING_DATA_FROM_GD(Object *p_object) {
 	ERR_FAIL_COND_V(p_object == NULL, NULL);
 	ECMAScriptLanguage *lang = ECMAScriptLanguage::get_singleton();
-	ECMAScriptGCHandler *bind = (ECMAScriptGCHandler *)(p_object)->get_instance_binding(lang, lang->getInstanceBindingCallbacks());
+	ECMAScriptGCHandler *bind = (ECMAScriptGCHandler *)(p_object)->get_instance_binding(lang, lang->get_instance_binding_callbacks());
 	return bind;
 }
 
@@ -1587,6 +1587,7 @@ Error QuickJSBinder::bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, O
 		if (p_object->is_ref_counted()) {
 			RefCounted *ref = Object::cast_to<RefCounted>(p_object);
 			data->flags |= ECMAScriptGCHandler::FLAG_REFERENCE;
+#if 0
 			union {
 				Ref<RefCounted> *ref;
 				struct {
@@ -1596,6 +1597,9 @@ Error QuickJSBinder::bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, O
 			u.ref = memnew(Ref<RefCounted>);
 			u.r->ref = ref;
 			data->godot_reference = u.ref;
+#else
+			data->godot_reference = memnew(Ref<RefCounted>(ref));
+#endif
 		}
 		JS_SetOpaque(obj, data);
 #ifdef DUMP_LEAKS
@@ -1633,7 +1637,10 @@ JSValue QuickJSBinder::object_constructor(JSContext *ctx, JSValueConst new_targe
 		js_obj = new_target;
 	} else {
 		Object *gd_obj = cls.gdclass->creation_func();
-		bind = BINDING_DATA_FROM_GD(ctx, gd_obj);
+		ECMAScriptLanguage *lang = ECMAScriptLanguage::get_singleton();
+		bind = new_gc_handler(ctx);
+		bind_gc_object(ctx, bind, gd_obj);
+		gd_obj->set_instance_binding(lang, bind, lang->get_instance_binding_callbacks());
 		js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
 
 		if (JS_IsFunction(ctx, new_target)) {
diff --git a/tests/UnitTest.js b/tests/UnitTest.js
new file mode 100644
index 00000000..4f1f76ff
--- /dev/null
+++ b/tests/UnitTest.js
@@ -0,0 +1,79 @@
+// @ts-nocheck
+const TEST_ENTRIES = new Map();
+
+
+test('godot', typeof godot === 'object', 'core');
+test('new Object', () => {
+	let obj = new godot.Object();
+	let ok = obj && obj instanceof godot.Object;
+	obj.free();
+	return ok;
+}, 'core');
+
+test('new Resource', () => {
+	let obj = new godot.Resource();
+	let ok = obj && obj.get_class() === 'Resource';
+	return ok;
+}, 'core');
+
+
+// --------------------------- Unit Test Implementation ------------------------
+function test(description, blcok, group = 'default') {
+	const entries = TEST_ENTRIES.get(group) || [];
+	entries.push({ description, blcok });
+	TEST_ENTRIES.set(group, entries);
+}
+function runEntry(entry) {
+	return new Promise((resolve, reject) => {
+		switch (typeof (entry.blcok)) {
+			case 'boolean':
+				return resolve(entry.blcok);
+			case 'function': {
+				try {
+					resolve(entry.blcok());
+				} catch (error) {
+					console.error(error);
+					resolve(false);
+				}
+			}
+			break;
+			case 'object':
+				if (entry.blcok instanceof Promise) {
+					entry.blcok.then(() => {
+						resolve(true);
+					}).catch(err => {
+						resolve(false);
+					});
+				}
+				break;
+			default:
+				return resolve(false);
+		}
+	});
+}
+async function run() {
+	let count = 0;
+	let passed = 0;
+	for (const [group, entries] of TEST_ENTRIES) {
+		console.log(`Start test ${group}`);
+		count += entries.length;
+		let groupCount = 0;
+		for (let i = 0; i < entries.length; i++) {
+			const entry = entries[i];
+			const ret = await runEntry(entry);
+			if (ret) {
+				passed++;
+				groupCount++;
+				console.log(`\t[${i + 1}/${entries.length}][ √ ] ${entry.description}`);
+			}
+			else {
+				console.error(`\t[${i + 1}/${entries.length}][ X ] ${entry.description}`);
+			}
+		}
+		const logFunc2 = groupCount == entries.length ? console.log : console.warn;
+		logFunc2(`\tTest ${group} finished: ${groupCount}/${entries.length} passed`);
+	}
+	const logFunc = passed == count ? console.log : console.warn;
+	logFunc(`Test complete: ${passed}/${count} passed`);
+}
+const _ = run(); // QuickJS BUG ? 返回的是一个 Promise 对象，不赋给临时变量，会导致 Promise 对象无法被 GC 

From bb7a34420cb94f6d8db7de20be6c99dd3ff3a6e3 Mon Sep 17 00:00:00 2001
From: Geequlim <geequlim@gmail.com>
Date: Thu, 25 Aug 2022 13:47:59 +0800
Subject: [PATCH 04/71] Improve RefCounted binding [ci skip]

---
 ecmascript_gc_handler.h    | 32 +++++++++-------------
 quickjs/quickjs_binder.cpp | 54 ++++++++++++++------------------------
 2 files changed, 31 insertions(+), 55 deletions(-)

diff --git a/ecmascript_gc_handler.h b/ecmascript_gc_handler.h
index 6ec30e2f..c53232ad 100644
--- a/ecmascript_gc_handler.h
+++ b/ecmascript_gc_handler.h
@@ -17,9 +17,9 @@ struct ECMAScriptGCHandler {
 		FLAG_ATOMIC_VALUE = 1 << 1,
 		FLAG_BUILTIN_CLASS = 1 << 2,
 		FLAG_OBJECT = 1 << 3,
-		FLAG_REFERENCE = 1 << 4,
-		FLAG_SCRIPT_FINALIZED = 1 << 5,
-		FLAG_CONTEXT_TRANSFERABLE = 1 << 6,
+		FLAG_REF_COUNTED = 1 << 4,
+		FLAG_FINALIZED = 1 << 5,
+		FLAG_TRANSFERABLE = 1 << 6,
 	};
 	Variant::Type type;
 	uint8_t flags;
@@ -27,20 +27,14 @@ struct ECMAScriptGCHandler {
 	void *ecma_object;
 	union {
 		Object *godot_object;
-		Ref<RefCounted> *godot_reference;
 		void *godot_builtin_object_ptr;
 		void *native_ptr;
 	};
 
 	_FORCE_INLINE_ Variant get_value() const {
 		switch (type) {
-			case Variant::OBJECT: {
-				if (flags & FLAG_REFERENCE) {
-					return *godot_reference;
-				} else if (flags & FLAG_OBJECT) {
-					return godot_object;
-				}
-			} break;
+			case Variant::OBJECT:
+				return godot_object;
 			case Variant::VECTOR2:
 				return *(static_cast<Vector2 *>(godot_builtin_object_ptr));
 			case Variant::RECT2:
@@ -88,12 +82,10 @@ struct ECMAScriptGCHandler {
 	}
 
 	_FORCE_INLINE_ Object *get_godot_object() {
-		if (flags & FLAG_REFERENCE && godot_reference) {
-			return godot_reference->ptr();
-		} else if (flags & FLAG_OBJECT) {
+		if (flags & FLAG_OBJECT) {
 			return godot_object;
 		}
-		return NULL;
+		return nullptr;
 	}
 
 	_FORCE_INLINE_ Vector2 *getVector2() const { return static_cast<Vector2 *>(godot_builtin_object_ptr); }
@@ -118,15 +110,15 @@ struct ECMAScriptGCHandler {
 	_FORCE_INLINE_ PackedVector3Array *getPackedVector3Array() const { return static_cast<PackedVector3Array *>(godot_builtin_object_ptr); }
 
 	_FORCE_INLINE_ bool is_object() const {
-		return flags & FLAG_OBJECT && !(flags & FLAG_REFERENCE);
+		return flags & FLAG_OBJECT;
 	}
 
-	_FORCE_INLINE_ bool is_reference() const {
-		return flags & FLAG_REFERENCE;
+	_FORCE_INLINE_ bool is_ref_counted() const {
+		return flags & FLAG_REF_COUNTED;
 	}
 
 	_FORCE_INLINE_ bool is_transferable() const {
-		return flags & FLAG_CONTEXT_TRANSFERABLE;
+		return flags & FLAG_TRANSFERABLE;
 	}
 
 	_FORCE_INLINE_ bool is_atomic_type() const {
@@ -134,7 +126,7 @@ struct ECMAScriptGCHandler {
 	}
 
 	_FORCE_INLINE_ bool is_finalized() const {
-		return flags & FLAG_SCRIPT_FINALIZED;
+		return flags & FLAG_FINALIZED;
 	}
 	_FORCE_INLINE_ bool is_valid_ecma_object() const {
 		return context != NULL && ecma_object != NULL && !is_finalized();
diff --git a/quickjs/quickjs_binder.cpp b/quickjs/quickjs_binder.cpp
index a043e0f4..ae95eb8a 100644
--- a/quickjs/quickjs_binder.cpp
+++ b/quickjs/quickjs_binder.cpp
@@ -247,7 +247,6 @@ JSValue QuickJSBinder::variant_to_var(JSContext *ctx, const Variant p_var) {
 			ERR_FAIL_NULL_V(data, JS_UNDEFINED);
 			ERR_FAIL_NULL_V(data->ecma_object, JS_UNDEFINED);
 			ERR_FAIL_COND_V(data->context != ctx, (JS_UNDEFINED));
-			QuickJSBinder *binder = get_context_binder(ctx);
 			JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, data->ecma_object);
 			JS_DupValue(ctx, js_obj);
 
@@ -555,9 +554,7 @@ void QuickJSBinder::add_debug_binding_info(JSContext *ctx, JSValueConst p_obj, c
 	if (p_bind->type != Variant::OBJECT) {
 		classname = to_js_string(ctx, Variant::get_type_name(p_bind->type));
 	} else {
-		if (p_bind->is_reference()) {
-			classname = to_js_string(ctx, (*p_bind->godot_reference)->get_class_name());
-		} else if (p_bind->is_object()) {
+		if (p_bind->is_object()) {
 			classname = to_js_string(ctx, p_bind->godot_object->get_class_name());
 		}
 	}
@@ -1558,7 +1555,7 @@ ECMAScriptGCHandler *QuickJSBinder::alloc_object_binding_data(Object *p_object)
 
 void QuickJSBinder::free_object_binding_data(ECMAScriptGCHandler *p_gc_handle) {
 	ECMAScriptGCHandler *bind = (ECMAScriptGCHandler *)p_gc_handle;
-	if (bind->is_object()) {
+	if (!bind->is_ref_counted()) {
 		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
 		JS_SetOpaque(js_obj, NULL);
 		JS_FreeValue((JSContext *)bind->context, js_obj);
@@ -1585,21 +1582,9 @@ Error QuickJSBinder::bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, O
 		data->type = Variant::OBJECT;
 		data->flags = ECMAScriptGCHandler::FLAG_OBJECT;
 		if (p_object->is_ref_counted()) {
-			RefCounted *ref = Object::cast_to<RefCounted>(p_object);
-			data->flags |= ECMAScriptGCHandler::FLAG_REFERENCE;
-#if 0
-			union {
-				Ref<RefCounted> *ref;
-				struct {
-					RefCounted *ref;
-				} * r;
-			} u;
-			u.ref = memnew(Ref<RefCounted>);
-			u.r->ref = ref;
-			data->godot_reference = u.ref;
-#else
-			data->godot_reference = memnew(Ref<RefCounted>(ref));
-#endif
+			if (static_cast<RefCounted *>(p_object)->init_ref()) {
+				data->flags |= ECMAScriptGCHandler::FLAG_REF_COUNTED;
+			}
 		}
 		JS_SetOpaque(obj, data);
 #ifdef DUMP_LEAKS
@@ -1612,14 +1597,14 @@ Error QuickJSBinder::bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, O
 }
 
 void QuickJSBinder::godot_refcount_incremented(ECMAScriptGCHandler *bind) {
-	if (bind->is_valid_ecma_object() && bind->is_reference()) {
+	if (bind->is_valid_ecma_object()) {
 		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
 		JS_DupValue((JSContext *)bind->context, js_obj);
 	}
 }
 
 bool QuickJSBinder::godot_refcount_decremented(ECMAScriptGCHandler *bind) {
-	if (bind->is_valid_ecma_object() && bind->is_reference()) {
+	if (bind->is_valid_ecma_object()) {
 		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
 		JS_FreeValue((JSContext *)bind->context, js_obj);
 		return bind->is_finalized();
@@ -1669,9 +1654,7 @@ JSValue QuickJSBinder::object_constructor(JSContext *ctx, JSValueConst new_targe
 		JS_FreeValue(ctx, es_class_name);
 		gd_obj->set_script_instance(si);
 #endif
-		if (bind->is_reference()) {
-			bind->flags |= ECMAScriptGCHandler::FLAG_REFERENCE;
-		} else if (bind->is_object()) {
+		if (!bind->is_ref_counted()) { // Object need to be freed manually
 			JS_DupValue(ctx, js_obj);
 		}
 	}
@@ -1696,9 +1679,11 @@ void QuickJSBinder::initialize_properties(JSContext *ctx, const ECMAClassInfo *p
 
 void QuickJSBinder::object_finalizer(ECMAScriptGCHandler *p_bind) {
 	p_bind->flags ^= ECMAScriptGCHandler::FLAG_OBJECT;
-	if (p_bind->is_reference()) {
-		p_bind->flags ^= ECMAScriptGCHandler::FLAG_REFERENCE;
-		memdelete(p_bind->godot_reference);
+	if (p_bind->godot_object->is_ref_counted()) {
+		RefCounted *ref = static_cast<RefCounted *>(p_bind->godot_object);
+		if (ref->unreference()) {
+			memdelete(ref);
+		}
 	}
 }
 
@@ -1706,7 +1691,7 @@ void QuickJSBinder::origin_finalizer(JSRuntime *rt, JSValue val) {
 	QuickJSBinder *binder = get_runtime_binder(rt);
 	ECMAScriptGCHandler *bind = static_cast<ECMAScriptGCHandler *>(JS_GetOpaque(val, binder->godot_origin_class.class_id));
 	if (bind) {
-		bind->flags |= ECMAScriptGCHandler::FLAG_SCRIPT_FINALIZED;
+		bind->flags |= ECMAScriptGCHandler::FLAG_FINALIZED;
 		if (bind->type == Variant::OBJECT) {
 			object_finalizer(bind);
 		} else {
@@ -1720,7 +1705,7 @@ JSValue QuickJSBinder::object_free(JSContext *ctx, JSValue this_val, int argc, J
 	ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 	ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "The object already be freed"));
 	ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "The object already be freed"));
-	ERR_FAIL_COND_V((bind->is_reference()), JS_ThrowReferenceError(ctx, "Call free to RefCounted object is not allowed"));
+	ERR_FAIL_COND_V(bind->godot_object->is_ref_counted(), JS_ThrowReferenceError(ctx, "Call free to RefCounted object is not allowed"));
 
 	memdelete(bind->godot_object);
 	JS_SetOpaque(this_val, NULL);
@@ -2266,16 +2251,15 @@ JSValue QuickJSBinder::godot_abandon_value(JSContext *ctx, JSValue this_val, int
 		ECMAScriptGCHandler *data = BINDING_DATA_FROM_JS(ctx, value);
 		if (data) {
 			JS_SetOpaque(value, NULL);
-			if (data->type == Variant::OBJECT) {
+			if (data->is_ref_counted()) {
+				static_cast<RefCounted *>(data->godot_object)->unreference();
+			} else if (data->is_object()) {
 				JS_FreeValue(ctx, value);
-				if (data->is_reference()) {
-					memdelete(data->godot_reference);
-				}
 			}
 			data->godot_object = NULL;
 			data->ecma_object = NULL;
 			data->context = NULL;
-			data->flags |= ECMAScriptGCHandler::FLAG_CONTEXT_TRANSFERABLE;
+			data->flags |= ECMAScriptGCHandler::FLAG_TRANSFERABLE;
 		} else {
 			valid = false;
 		}

From 39421baee3340fdf3002cdebd89d6275eff7d4fd Mon Sep 17 00:00:00 2001
From: Geequlim <geequlim@gmail.com>
Date: Fri, 2 Sep 2022 18:13:43 +0800
Subject: [PATCH 05/71] Rename ECMAScript to JavaScript for godot 4

---
 README.md                                     |  16 +-
 SCsub                                         |  12 +-
 build_github_actions.py                       |  36 +-
 ecmascript_binder.h                           | 102 -----
 ecmascript_instance.cpp                       |  71 ----
 ecmascript.cpp => javascript.cpp              | 231 +++++------
 ecmascript.h => javascript.h                  |  45 +--
 javascript_binder.h                           | 102 +++++
 ...pt_gc_handler.h => javascript_gc_handler.h |  21 +-
 javascript_instance.cpp                       |  76 ++++
 ...script_instance.h => javascript_instance.h |  27 +-
 ...pt_language.cpp => javascript_language.cpp |  85 ++--
 ...script_language.h => javascript_language.h |  41 +-
 misc/decorators.ts                            |   6 +-
 quickjs/builtin_binding_generator.py          |  76 ++--
 quickjs/quickjs_binder.cpp                    | 366 +++++++++---------
 quickjs/quickjs_binder.h                      |  86 ++--
 quickjs/quickjs_builtin_binder.cpp            | 174 ++++-----
 quickjs/quickjs_builtin_binder.h              |   4 +-
 quickjs/quickjs_worker.cpp                    |  12 +-
 register_types.cpp                            |  66 ++--
 register_types.h                              |   8 +-
 tools/editor_tools.cpp                        |  46 +--
 tools/editor_tools.h                          |  15 +-
 24 files changed, 865 insertions(+), 859 deletions(-)
 delete mode 100644 ecmascript_binder.h
 delete mode 100644 ecmascript_instance.cpp
 rename ecmascript.cpp => javascript.cpp (57%)
 rename ecmascript.h => javascript.h (84%)
 create mode 100644 javascript_binder.h
 rename ecmascript_gc_handler.h => javascript_gc_handler.h (93%)
 create mode 100644 javascript_instance.cpp
 rename ecmascript_instance.h => javascript_instance.h (75%)
 rename ecmascript_language.cpp => javascript_language.cpp (75%)
 rename ecmascript_language.h => javascript_language.h (85%)

diff --git a/README.md b/README.md
index 1b371556..16239642 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 ## JavaScript language binding for godot game engine
 
-This module implements JavaScript/TypeScript language support for the godot game engine. [QuickJS](https://bellard.org/quickjs/) is used as the ECMAScript engine.
+This module implements JavaScript/TypeScript language support for the godot game engine. [QuickJS](https://bellard.org/quickjs/) is used as the JavaScript engine.
 
 -----
 
@@ -20,7 +20,7 @@ You can also get the binaries with lastest commits from the [github build action
 
 ### Compilation
 * Clone the source code of [godot](https://github.com/godotengine/godot)
-* Clone this module and put it into `godot/modules/` and make sure the folder name of this module is `ECMAScript`
+* Clone this module and put it into `godot/modules/` and make sure the folder name of this module is `javascript`
 * [Recompile the godot engine](https://docs.godotengine.org/en/3.3/development/compiling/index.html) <b>(Only MinGW is supported on Windows for now!)</b>
 
 ![Build Godot with ECMAScript](https://github.com/GodotExplorer/ECMAScript/workflows/Build%20Godot%20with%20ECMAScript/badge.svg)
@@ -28,7 +28,7 @@ You can also get the binaries with lastest commits from the [github build action
 ### Usage
 
 ##### How to export script class to godot
-1. Define your ECMAScript class and inherit from a godot class then export it as the **default** entry
+1. Define your JavaScript class and inherit from a godot class then export it as the **default** entry
 ```js
 // The default export entry is treated as an exported class to godot
 export default class MySprite extends godot.Sprite {
@@ -94,7 +94,7 @@ godot.register_property(MyClass, 'number_value',  {
 });
 ```
 
-For more detail on how to use it, [click here](https://github.com/GodotExplorer/ECMAScript/issues/24#issuecomment-655584829).
+For more detail on how to use it, [click here](https://github.com/Geequlim/ECMAScript/issues/24#issuecomment-655584829).
 
 #### About the API
 
@@ -102,7 +102,7 @@ All of godots api's are defined within the `godot` namespace.
 
 No API names have been renamed or changed so you shouldn't need to change your habits.
 
-GDScript | ECMAScript
+GDScript | JavaScript
 ---- | ---
 null | null
 int | number
@@ -180,7 +180,7 @@ Label.Align.ALIGN_LEFT | godot.Label.Align.ALIGN_LEFT
 		```
 	
 ### TypeScript support and JSX code completion
-- Run the menu command `Project > Tools > ECMAScript > Generate TypeScript Project` from the godot editor to generate a TypeScript project
+- Run the menu command `Project > Tools > JavaScript > Generate TypeScript Project` from the godot editor to generate a TypeScript project
 - Run `tsc -w -p .` under your project folder in the terminal to compile scripts
 
 #### Code completion
@@ -269,6 +269,6 @@ You can try demos in the [ECMAScriptDemos](https://github.com/Geequlim/ECMAScrip
 * The script also build the `on_tag.yml` script which automates the github release publishing.
 ** The `on_tag.yml` functionality tries to sleep until all jobs with the same `sha` are completed.  It should be fine to run whenever, but depending on how github actions culls long running jobs you might want to make sure that all/(most of) the builds look good before tagging.
 * Linux ubsan asan build woes:
-** The godot repo has ubsan and asan builds that we can't build from.  Currently we skip them (get removed via the `build_github_actions.py` script).
-** They should definitely be fixed & enabled at some point, **so please submit a PR if you have any ideas of how to do that!**
+* The godot repo has ubsan and asan builds that we can't build from.  Currently we skip them (get removed via the `build_github_actions.py` script).
+* They should definitely be fixed & enabled at some point, **so please submit a PR if you have any ideas of how to do that!**
 
diff --git a/SCsub b/SCsub
index b0afd308..b8486b59 100644
--- a/SCsub
+++ b/SCsub
@@ -49,19 +49,19 @@ if JS_ENGINE == 'quickjs':
 
 # Binding script to run at engine initializing
 with open("misc/godot.binding_script.gen.cpp", "w") as f:
-	text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "../ecmascript_binder.h"\nString ECMAScriptBinder::BINDING_SCRIPT_CONTENT = \n${source};'
+	text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "../javascript_binder.h"\nString JavaScriptBinder::BINDING_SCRIPT_CONTENT = \n${source};'
 	f.write(text.replace('${source}', dump_text_file_to_cpp("misc/binding_script.js")))
 
 sources = [
 	'register_types.cpp',
-	'ecmascript_language.cpp',
-	'ecmascript_instance.cpp',
-	'ecmascript.cpp',
+	'javascript_language.cpp',
+	'javascript_instance.cpp',
+	'javascript.cpp',
 	'misc/godot.binding_script.gen.cpp',
 ]
 
 if env['tools']:
-	base_text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString ECMAScriptPlugin::{} = \n{};'
+	base_text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
 	tool_fns = {"tools/godot.d.ts.gen.cpp": ("BUILTIN_DECLARATION_TEXT", dump_text_file_to_cpp("misc/godot.d.ts")),
 		"tools/tsconfig.json.gen.cpp": ("TSCONFIG_CONTENT", dump_text_file_to_cpp("misc/tsconfig.json")),
 		"tools/decorators.ts.gen.cpp": ("TS_DECORATORS_CONTENT", dump_text_file_to_cpp("misc/decorators.ts")),
@@ -73,5 +73,5 @@ if env['tools']:
 		env_module.add_source_files(env.modules_sources, fn)
 
 
-env_module.Append(CPPPATH=["#modules/ECMAScript"])
+env_module.Append(CPPPATH=["#modules/javascript"])
 env_module.add_source_files(env.modules_sources, sources)
diff --git a/build_github_actions.py b/build_github_actions.py
index 6f610467..9b50033f 100644
--- a/build_github_actions.py
+++ b/build_github_actions.py
@@ -4,7 +4,7 @@
 You must be in this directory, and in the modules subfolder of godot (just as if you would install this project into godot)
 
 usage:
-python build_github_actions.py --godot-version "3.5-stable" --godot-github-folder ../../.github --ECMAS-github-folder .github
+python build_github_actions.py --godot-version "3.5-stable" --godot-github-folder ../../.github --js-github-folder .github
 
 """
 
@@ -53,7 +53,7 @@ def parseargs():
     parser = argparse.ArgumentParser()
     parser.add_argument("--godot-version", required=True)
     parser.add_argument("--godot-github-folder", required=True)
-    parser.add_argument("--ECMAS-github-folder", required=True)
+    parser.add_argument("--js-github-folder", required=True)
     return parser.parse_args()
 
 
@@ -83,7 +83,7 @@ def get_windows_mingw_checkout_steps() -> List[Dict[str, Any]]:
     return out
 
 
-def get_ECMAScript_checkout_steps() -> List[Dict[str, Any]]:
+def get_js_checkout_steps() -> List[Dict[str, Any]]:
     out = [
         {
             "name": "Checkout Godot",
@@ -91,9 +91,9 @@ def get_ECMAScript_checkout_steps() -> List[Dict[str, Any]]:
             "with": {"repository": "godotengine/godot", "ref": "${{ env.GODOT_BASE_BRANCH }}"},
         },
         {
-            "name": "Checkout ECMAScript",
+            "name": "Checkout javascript",
             "uses": "actions/checkout@v2",
-            "with": {"path": "${{github.workspace}}/modules/ECMAScript/"},
+            "with": {"path": "${{github.workspace}}/modules/javascript/"},
         },
     ]
     return out
@@ -107,11 +107,11 @@ def get_rid_of_ubsan_asan_linux(matrix_step: Dict[str, Any]) -> Dict[str, Any]:
 
 
 def fix_all_workflows(
-    ECMAS_github_folder: str, workflows: Dict[str, BuildOpts], wf_actions_that_require_shell: List[str]
+    js_github_folder: str, workflows: Dict[str, BuildOpts], wf_actions_that_require_shell: List[str]
 ) -> List[str]:
     wf_names: List[str] = []
     for wf_base_fn, build_opts in workflows.items():
-        full_fn = os.path.join(ECMAS_github_folder, "workflows", wf_base_fn)
+        full_fn = os.path.join(js_github_folder, "workflows", wf_base_fn)
         data = yaml.safe_load(open(full_fn))
         wf_names.append(data["name"])
 
@@ -148,13 +148,13 @@ def fix_all_workflows(
         for step in data["jobs"][only_template_name]["steps"]:
             # replace godot checkout routine with this checkout routine
             if "uses" in step and "checkout" in step["uses"]:
-                new_steps += get_ECMAScript_checkout_steps()
+                new_steps += get_js_checkout_steps()
             elif (
                 "uses" in step
                 and base_github_string in step["uses"]
                 and any(x in step["uses"] for x in wf_actions_that_require_shell)
             ):
-                step["uses"] = step["uses"].replace(base_github_string, "./modules/ECMAScript/.github/")
+                step["uses"] = step["uses"].replace(base_github_string, "./modules/javascript/.github/")
                 to_add = {"shell": "msys2 {0}" if "windows" in wf_base_fn else "sh"}
                 if "with" not in step:
                     step["with"] = to_add
@@ -170,7 +170,7 @@ def fix_all_workflows(
     return wf_names
 
 
-def fix_all_actions(ECMAS_github_folder: str, actions: List[str]) -> List[str]:
+def fix_all_actions(js_github_folder: str, actions: List[str]) -> List[str]:
     """
     This can be simplified once:
     https://github.com/actions/runner/pull/1767
@@ -178,7 +178,7 @@ def fix_all_actions(ECMAS_github_folder: str, actions: List[str]) -> List[str]:
     """
     actions_that_require_shell_set = set()
     for action_base_fn in actions:
-        full_action_fn = os.path.join(ECMAS_github_folder, action_base_fn)
+        full_action_fn = os.path.join(js_github_folder, action_base_fn)
         data = yaml.safe_load(open(full_action_fn))
         new_steps = []
         for step in data["runs"]["steps"]:
@@ -308,13 +308,13 @@ def add_publish_workflow(out_fn: str, wf_name_list: List[str]):
 def main():
     args = parseargs()
     assert os.path.isdir(args.godot_github_folder)
-    assert os.path.isdir(args.ECMAS_github_folder)
+    assert os.path.isdir(args.js_github_folder)
     checkout_local_godot_install(args.godot_version)
 
     for x in ["actions", "workflows"]:
-        subprocess.call(["rm", "-rf", os.path.join(args.ECMAS_github_folder, x)])
+        subprocess.call(["rm", "-rf", os.path.join(args.js_github_folder, x)])
         subprocess.call(
-            ["cp", "-r", os.path.join(args.godot_github_folder, x), os.path.join(args.ECMAS_github_folder, x)]
+            ["cp", "-r", os.path.join(args.godot_github_folder, x), os.path.join(args.js_github_folder, x)]
         )
 
     basic_flags = " "
@@ -324,7 +324,7 @@ def main():
         "actions/godot-deps/action.yml",
         "actions/upload-artifact/action.yml",
     ]
-    wf_actions_that_require_shell = fix_all_actions(args.ECMAS_github_folder, actions)
+    wf_actions_that_require_shell = fix_all_actions(args.js_github_folder, actions)
     workflows = {
         "android_builds.yml": BuildOpts(basic_flags, args.godot_version),
         "ios_builds.yml": BuildOpts(basic_flags, args.godot_version),
@@ -334,10 +334,10 @@ def main():
         "server_builds.yml": BuildOpts(basic_flags, args.godot_version),
         "windows_builds.yml": BuildOpts(f"{basic_flags} use_mingw=yes", args.godot_version),
     }
-    wf_names = fix_all_workflows(args.ECMAS_github_folder, workflows, wf_actions_that_require_shell)
-    subprocess.call(["rm", os.path.join(args.ECMAS_github_folder, "workflows", "static_checks.yml")])
+    wf_names = fix_all_workflows(args.js_github_folder, workflows, wf_actions_that_require_shell)
+    subprocess.call(["rm", os.path.join(args.js_github_folder, "workflows", "static_checks.yml")])
 
-    out_publish_fn = os.path.join(args.ECMAS_github_folder, "workflows", "on_tag.yml")
+    out_publish_fn = os.path.join(args.js_github_folder, "workflows", "on_tag.yml")
     add_publish_workflow(out_publish_fn, wf_names)
 
 
diff --git a/ecmascript_binder.h b/ecmascript_binder.h
deleted file mode 100644
index 3c2b00ac6..00000000
--- a/ecmascript_binder.h
+++ /dev/null
@@ -1,102 +0,0 @@
-#ifndef ECMASCRIPT_BINDING_HELPER_H
-#define ECMASCRIPT_BINDING_HELPER_H
-
-#include "core/os/thread.h"
-#include "ecmascript_gc_handler.h"
-
-typedef ECMAScriptGCHandler ECMAMethodInfo;
-
-struct ECMAProperyInfo : public PropertyInfo {
-	Variant default_value;
-};
-
-struct ECMAscriptScriptError {
-	int line;
-	int column;
-	String message;
-	String file;
-	Vector<String> stack;
-};
-
-struct BasicECMAClassInfo {
-	bool tool;
-	StringName class_name;
-	String icon_path;
-	const ClassDB::ClassInfo *native_class;
-	HashMap<StringName, MethodInfo> signals;
-	HashMap<StringName, MethodInfo> methods;
-	HashMap<StringName, ECMAProperyInfo> properties;
-};
-
-struct ECMAClassInfo : public BasicECMAClassInfo {
-	ECMAScriptGCHandler constructor;
-	ECMAScriptGCHandler prototype;
-};
-
-struct GlobalNumberConstant {
-	StringName name;
-	double_t value;
-};
-
-struct ECMAScriptStackInfo {
-	int line;
-	String file;
-	String function;
-};
-
-class ECMAScriptBinder {
-protected:
-	// Path ==> ECMA Class
-	HashMap<String, ECMAClassInfo> ecma_classes;
-	HashMap<int64_t, ECMAScriptGCHandler> frame_callbacks;
-	HashSet<int64_t> canceled_frame_callbacks;
-	static String BINDING_SCRIPT_CONTENT;
-
-public:
-	enum EvalType {
-		EVAL_TYPE_MODULE,
-		EVAL_TYPE_GLOBAL,
-	};
-
-	ECMAScriptBinder() {}
-	virtual ~ECMAScriptBinder(){};
-
-	virtual ECMAScriptBinder *get_context_binder(void *p_context) = 0;
-	virtual Thread::ID get_thread_id() const = 0;
-
-	virtual void clear_classes() { ecma_classes.clear(); }
-
-	virtual void initialize() = 0;
-	virtual void uninitialize() = 0;
-	virtual void language_finalize() = 0;
-	virtual void frame() = 0;
-
-	virtual ECMAScriptGCHandler *alloc_object_binding_data(Object *p_object) = 0;
-	virtual void free_object_binding_data(ECMAScriptGCHandler *p_gc_handle) = 0;
-	virtual void godot_refcount_incremented(ECMAScriptGCHandler *p_gc_handle) = 0;
-	virtual bool godot_refcount_decremented(ECMAScriptGCHandler *p_gc_handle) = 0;
-
-	virtual Error eval_string(const String &p_source, EvalType type, const String &p_path, ECMAScriptGCHandler &r_ret) = 0;
-	virtual Error safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, ECMAScriptGCHandler &r_ret) = 0;
-	virtual String error_to_string(const ECMAscriptScriptError &p_error) = 0;
-	virtual Error get_stacks(List<ECMAScriptStackInfo> &r_stacks) = 0;
-	virtual String get_backtrace_message(const List<ECMAScriptStackInfo> &stacks) = 0;
-
-	virtual Error compile_to_bytecode(const String &p_code, const String &p_file, Vector<uint8_t> &r_bytecode) = 0;
-	virtual Error load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, ECMAScriptGCHandler *r_module) = 0;
-	virtual const ECMAClassInfo *parse_ecma_class(const String &p_code, const String &p_path, bool ignore_cacehe, ECMAscriptScriptError *r_error) = 0;
-	virtual const ECMAClassInfo *parse_ecma_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, ECMAscriptScriptError *r_error) = 0;
-
-	virtual ECMAScriptGCHandler create_ecma_instance_for_godot_object(const ECMAClassInfo *p_class, Object *p_object) = 0;
-	virtual Variant call_method(const ECMAScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) = 0;
-	virtual bool get_instance_property(const ECMAScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) = 0;
-	virtual bool set_instance_property(const ECMAScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) = 0;
-	virtual bool has_method(const ECMAScriptGCHandler &p_object, const StringName &p_name) = 0;
-	virtual bool has_signal(const ECMAClassInfo *p_class, const StringName &p_signal) = 0;
-	virtual bool validate(const String &p_code, const String &p_path, ECMAscriptScriptError *r_error) = 0;
-#ifdef TOOLS_ENABLED
-	virtual const Dictionary &get_modified_api() const = 0;
-#endif
-};
-
-#endif
diff --git a/ecmascript_instance.cpp b/ecmascript_instance.cpp
deleted file mode 100644
index e90cb66b..00000000
--- a/ecmascript_instance.cpp
+++ /dev/null
@@ -1,71 +0,0 @@
-#include "ecmascript_instance.h"
-#include "ecmascript.h"
-#include "ecmascript_language.h"
-
-Ref<Script> ECMAScriptInstance::get_script() const {
-	return script;
-}
-
-void ECMAScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
-	if (!ecma_class) return;
-	for (const KeyValue<StringName, MethodInfo> &i: ecma_class->methods) {
-		p_list->push_back(i.value);
-	}
-}
-
-bool ECMAScriptInstance::has_method(const StringName &p_method) const {
-	if (!binder || !ecma_object.ecma_object) return false;
-	return binder->has_method(ecma_object, p_method);
-}
-
-bool ECMAScriptInstance::set(const StringName &p_name, const Variant &p_value) {
-	if (!binder || !ecma_object.ecma_object) return false;
-	return binder->set_instance_property(ecma_object, p_name, p_value);
-}
-
-bool ECMAScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
-	if (!binder || !ecma_object.ecma_object) return false;
-	return binder->get_instance_property(this->ecma_object, p_name, r_ret);
-}
-
-void ECMAScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const {
-	if (!ecma_class) return;
-	for (const KeyValue<StringName, ECMAProperyInfo> &i: ecma_class->properties) {
-		p_properties->push_back(i.value);
-	}
-}
-
-Variant::Type ECMAScriptInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const {
-	*r_is_valid = false;
-	if (ecma_class) {
-		if (const ECMAProperyInfo *pi = ecma_class->properties.getptr(p_name)) {
-			*r_is_valid = true;
-			return pi->type;
-		}
-	}
-	return Variant::NIL;
-}
-
-Variant ECMAScriptInstance::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
-	if (binder == NULL || ecma_object.ecma_object == NULL) {
-		r_error.error = Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL;
-		ERR_FAIL_V(Variant());
-	}
-	return binder->call_method(ecma_object, p_method, p_args, p_argcount, r_error);
-}
-
-ScriptLanguage *ECMAScriptInstance::get_language() {
-	return ECMAScriptLanguage::get_singleton();
-}
-
-ECMAScriptInstance::ECMAScriptInstance() {
-	owner = NULL;
-	binder = NULL;
-	ecma_class = NULL;
-}
-
-ECMAScriptInstance::~ECMAScriptInstance() {
-	if (script.is_valid() && owner) {
-		script->instances.erase(owner);
-	}
-}
diff --git a/ecmascript.cpp b/javascript.cpp
similarity index 57%
rename from ecmascript.cpp
rename to javascript.cpp
index 1260e72a..5c9452eb 100644
--- a/ecmascript.cpp
+++ b/javascript.cpp
@@ -1,21 +1,21 @@
-#include "ecmascript.h"
+#include "javascript.h"
 #include "core/config/engine.h"
 #include "core/io/file_access_encrypted.h"
-#include "ecmascript_instance.h"
-#include "ecmascript_language.h"
+#include "javascript_instance.h"
+#include "javascript_language.h"
 #include "scene/resources/resource_format_text.h"
 
-ScriptLanguage *ECMAScript::get_language() const {
-	return ECMAScriptLanguage::get_singleton();
+ScriptLanguage *JavaScript::get_language() const {
+	return JavaScriptLanguage::get_singleton();
 }
 
-ECMAScript::ECMAScript() {
+JavaScript::JavaScript() {
 }
 
-ECMAScript::~ECMAScript() {
+JavaScript::~JavaScript() {
 }
 
-bool ECMAScript::can_instantiate() const {
+bool JavaScript::can_instantiate() const {
 #ifdef TOOLS_ENABLED
 	return is_valid() && (is_tool() || ScriptServer::is_scripting_enabled());
 #else
@@ -23,23 +23,23 @@ bool ECMAScript::can_instantiate() const {
 #endif
 }
 
-StringName ECMAScript::get_instance_base_type() const {
+StringName JavaScript::get_instance_base_type() const {
 	static StringName empty;
-	ERR_FAIL_NULL_V(ecma_class, empty);
-	ERR_FAIL_NULL_V(ecma_class->native_class, empty);
-	return ecma_class->native_class->name;
+	ERR_FAIL_NULL_V(javascript_class, empty);
+	ERR_FAIL_NULL_V(javascript_class->native_class, empty);
+	return javascript_class->native_class->name;
 }
 
-ScriptInstance *ECMAScript::instance_create(Object *p_this) {
+ScriptInstance *JavaScript::instance_create(Object *p_this) {
 
-	ECMAScriptBinder *binder = ECMAScriptLanguage::get_thread_binder(Thread::get_caller_id());
+	JavaScriptBinder *binder = JavaScriptLanguage::get_thread_binder(Thread::get_caller_id());
 	ERR_FAIL_NULL_V_MSG(binder, NULL, "Cannot create instance from this thread");
-	const ECMAClassInfo *cls = NULL;
-	ECMAscriptScriptError ecma_err;
+	const JavaScriptClassInfo *cls = NULL;
+	JavaScriptError js_err;
 	if (!bytecode.is_empty()) {
-		cls = binder->parse_ecma_class(bytecode, script_path, false, &ecma_err);
+		cls = binder->parse_javascript_class(bytecode, script_path, false, &js_err);
 	} else {
-		cls = binder->parse_ecma_class(code, script_path, false, &ecma_err);
+		cls = binder->parse_javascript_class(code, script_path, false, &js_err);
 	}
 	ERR_FAIL_NULL_V_MSG(cls, NULL, vformat("Cannot parse class from %s", get_script_path()));
 
@@ -47,23 +47,23 @@ ScriptInstance *ECMAScript::instance_create(Object *p_this) {
 		ERR_FAIL_V_MSG(NULL, vformat("Script inherits from native type '%s', so it can't be instanced in object of type: '%s'", cls->native_class->name, p_this->get_class()));
 	}
 
-	ECMAScriptGCHandler ecma_instance = binder->create_ecma_instance_for_godot_object(cls, p_this);
-	ERR_FAIL_NULL_V(ecma_instance.ecma_object, NULL);
+	JavaScriptGCHandler js_instance = binder->create_js_instance_for_godot_object(cls, p_this);
+	ERR_FAIL_NULL_V(js_instance.javascript_object, NULL);
 
-	ECMAScriptInstance *instance = memnew(ECMAScriptInstance);
-	instance->script = Ref<ECMAScript>(this);
+	JavaScriptInstance *instance = memnew(JavaScriptInstance);
+	instance->script = Ref<JavaScript>(this);
 	instance->owner = p_this;
 	instance->binder = binder;
-	instance->ecma_object = ecma_instance;
-	instance->ecma_class = cls;
+	instance->javascript_object = js_instance;
+	instance->javascript_class = cls;
 	instance->owner->set_script_instance(instance);
 	instances.insert(p_this);
 	return instance;
 }
 
-PlaceHolderScriptInstance *ECMAScript::placeholder_instance_create(Object *p_this) {
+PlaceHolderScriptInstance *JavaScript::placeholder_instance_create(Object *p_this) {
 #ifdef TOOLS_ENABLED
-	PlaceHolderScriptInstance *si = memnew(PlaceHolderScriptInstance(ECMAScriptLanguage::get_singleton(), Ref<Script>(this), p_this));
+	PlaceHolderScriptInstance *si = memnew(PlaceHolderScriptInstance(JavaScriptLanguage::get_singleton(), Ref<Script>(this), p_this));
 	instances.insert(p_this);
 	placeholders.insert(si);
 	update_exports();
@@ -73,21 +73,21 @@ PlaceHolderScriptInstance *ECMAScript::placeholder_instance_create(Object *p_thi
 #endif
 }
 
-Error ECMAScript::reload(bool p_keep_state) {
-	ecma_class = NULL;
+Error JavaScript::reload(bool p_keep_state) {
+	javascript_class = NULL;
 	Error err = OK;
-	ECMAScriptBinder *binder = ECMAScriptLanguage::get_thread_binder(Thread::get_caller_id());
+	JavaScriptBinder *binder = JavaScriptLanguage::get_thread_binder(Thread::get_caller_id());
 	ERR_FAIL_COND_V_MSG(binder == NULL, ERR_INVALID_DATA, "Cannot load script in this thread");
-	ECMAscriptScriptError ecma_err;
+	JavaScriptError js_err;
 	if (!bytecode.is_empty()) {
-		ecma_class = binder->parse_ecma_class(bytecode, script_path, true, &ecma_err);
+		javascript_class = binder->parse_javascript_class(bytecode, script_path, true, &js_err);
 	} else {
-		ecma_class = binder->parse_ecma_class(code, script_path, true, &ecma_err);
+		javascript_class = binder->parse_javascript_class(code, script_path, true, &js_err);
 	}
 
-	if (!ecma_class) {
+	if (!javascript_class) {
 		err = ERR_PARSE_ERROR;
-		ERR_PRINT(binder->error_to_string(ecma_err));
+		ERR_PRINT(binder->error_to_string(js_err));
 	} else {
 #ifdef TOOLS_ENABLED
 		set_last_modified_time(FileAccess::get_modified_time(script_path));
@@ -96,7 +96,7 @@ Error ECMAScript::reload(bool p_keep_state) {
 		for (Object *owner : instances) {
 			HashMap<StringName, Variant> values;
 			if (p_keep_state) {
-				for (const KeyValue<StringName, ECMAProperyInfo> &pair : ecma_class->properties) {
+				for (const KeyValue<StringName, JavaScriptProperyInfo> &pair : javascript_class->properties) {
 					values.insert(pair.key, owner->get(pair.key));
 				}
 			}
@@ -104,21 +104,21 @@ Error ECMAScript::reload(bool p_keep_state) {
 			ScriptInstance *si = owner->get_script_instance();
 			if (si->is_placeholder()) {
 				PlaceHolderScriptInstance *psi = static_cast<PlaceHolderScriptInstance *>(si);
-				if (ecma_class->tool) {
+				if (javascript_class->tool) {
 					_placeholder_erased(psi);
 				}
-			} else if (!ecma_class->tool) { // from tooled to !tooled
+			} else if (!javascript_class->tool) { // from tooled to !tooled
 				PlaceHolderScriptInstance *psi = placeholder_instance_create(owner);
 				owner->set_script_instance(psi);
 				instances.insert(owner);
 			}
-			if (ecma_class->tool) { // re-create as an instance
+			if (javascript_class->tool) { // re-create as an instance
 				instance_create(owner);
 			}
 
 			if (p_keep_state) {
 				for (const KeyValue<StringName, Variant> &pair : values) {
-					if (const ECMAProperyInfo *epi = ecma_class->properties.getptr(pair.key)) {
+					if (const JavaScriptProperyInfo *epi = javascript_class->properties.getptr(pair.key)) {
 						const Variant &backup = pair.value;
 						owner->set(pair.key, backup.get_type() == epi->type ? backup : epi->default_value);
 					}
@@ -130,55 +130,59 @@ Error ECMAScript::reload(bool p_keep_state) {
 	return err;
 }
 
-bool ECMAScript::instance_has(const Object *p_this) const {
+bool JavaScript::instance_has(const Object *p_this) const {
 	return instances.has(const_cast<Object *>(p_this));
 }
 
 #ifdef TOOLS_ENABLED
-void ECMAScript::_placeholder_erased(PlaceHolderScriptInstance *p_placeholder) {
+void JavaScript::_placeholder_erased(PlaceHolderScriptInstance *p_placeholder) {
 	instances.erase(p_placeholder->get_owner());
 	placeholders.erase(p_placeholder);
 }
 #endif
 
-bool ECMAScript::has_method(const StringName &p_method) const {
-	if (!ecma_class) return false;
-	return ecma_class->methods.getptr(p_method) != NULL;
+bool JavaScript::has_method(const StringName &p_method) const {
+	if (!javascript_class)
+		return false;
+	return javascript_class->methods.getptr(p_method) != NULL;
 }
 
-MethodInfo ECMAScript::get_method_info(const StringName &p_method) const {
+MethodInfo JavaScript::get_method_info(const StringName &p_method) const {
 	MethodInfo mi;
-	ERR_FAIL_NULL_V(ecma_class, mi);
-	if (const MethodInfo *ptr = ecma_class->methods.getptr(p_method)) {
+	ERR_FAIL_NULL_V(javascript_class, mi);
+	if (const MethodInfo *ptr = javascript_class->methods.getptr(p_method)) {
 		mi = *ptr;
 	}
 	return mi;
 }
 
-bool ECMAScript::is_tool() const {
-	if (!ecma_class) return false;
-	return ecma_class->tool;
+bool JavaScript::is_tool() const {
+	if (!javascript_class)
+		return false;
+	return javascript_class->tool;
 }
 
-void ECMAScript::get_script_method_list(List<MethodInfo> *p_list) const {
-	if (!ecma_class) return;
-	for (const KeyValue<StringName, MethodInfo> &pair : ecma_class->methods) {
+void JavaScript::get_script_method_list(List<MethodInfo> *p_list) const {
+	if (!javascript_class)
+		return;
+	for (const KeyValue<StringName, MethodInfo> &pair : javascript_class->methods) {
 		p_list->push_back(pair.value);
 	}
 }
 
-void ECMAScript::get_script_property_list(List<PropertyInfo> *p_list) const {
-	if (!ecma_class) return;
-	for (const KeyValue<StringName, ECMAProperyInfo> &pair : ecma_class->properties) {
+void JavaScript::get_script_property_list(List<PropertyInfo> *p_list) const {
+	if (!javascript_class)
+		return;
+	for (const KeyValue<StringName, JavaScriptProperyInfo> &pair : javascript_class->properties) {
 		p_list->push_back(pair.value);
 	}
 }
 
-bool ECMAScript::get_property_default_value(const StringName &p_property, Variant &r_value) const {
-	if (!ecma_class)
+bool JavaScript::get_property_default_value(const StringName &p_property, Variant &r_value) const {
+	if (!javascript_class)
 		return false;
 
-	if (const ECMAProperyInfo *pi = ecma_class->properties.getptr(p_property)) {
+	if (const JavaScriptProperyInfo *pi = javascript_class->properties.getptr(p_property)) {
 		r_value = pi->default_value;
 		return true;
 	}
@@ -186,15 +190,16 @@ bool ECMAScript::get_property_default_value(const StringName &p_property, Varian
 	return false;
 }
 
-void ECMAScript::update_exports() {
+void JavaScript::update_exports() {
 
 #ifdef TOOLS_ENABLED
-	if (!ecma_class) return;
+	if (!javascript_class)
+		return;
 
 	List<PropertyInfo> props;
 	HashMap<StringName, Variant> values;
-	for (const KeyValue<StringName, ECMAProperyInfo> &pair : ecma_class->properties) {
-		const ECMAProperyInfo &pi = pair.value;
+	for (const KeyValue<StringName, JavaScriptProperyInfo> &pair : javascript_class->properties) {
+		const JavaScriptProperyInfo &pi = pair.value;
 		props.push_back(pi);
 		values[pair.key] = pi.default_value;
 	}
@@ -205,31 +210,33 @@ void ECMAScript::update_exports() {
 #endif
 }
 
-bool ECMAScript::has_script_signal(const StringName &p_signal) const {
-	if (!ecma_class) return false;
-	return ecma_class->signals.has(p_signal);
+bool JavaScript::has_script_signal(const StringName &p_signal) const {
+	if (!javascript_class)
+		return false;
+	return javascript_class->signals.has(p_signal);
 }
 
-void ECMAScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
-	if (!ecma_class) return;
-	for (const KeyValue<StringName, MethodInfo> &pair : ecma_class->signals) {
+void JavaScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
+	if (!javascript_class)
+		return;
+	for (const KeyValue<StringName, MethodInfo> &pair : javascript_class->signals) {
 		r_signals->push_back(pair.value);
 	}
 }
 
-bool ECMAScript::is_valid() const {
-	return ecma_class != NULL;
+bool JavaScript::is_valid() const {
+	return javascript_class != NULL;
 }
 
-void ECMAScript::_bind_methods() {
+void JavaScript::_bind_methods() {
 }
 
-Ref<Resource> ResourceFormatLoaderECMAScript::load(const String &p_path, const String &p_original_path, Error *r_error) {
+Ref<Resource> ResourceFormatLoaderJavaScript::load(const String &p_path, const String &p_original_path, Error *r_error) {
 	Error err = OK;
-	Ref<ECMAScriptModule> module = ResourceFormatLoaderECMAScriptModule::load_static(p_path, p_original_path, &err);
+	Ref<JavaScriptModule> module = ResourceFormatLoaderJavaScriptModule::load_static(p_path, p_original_path, &err);
 	if (r_error) *r_error = err;
 	ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), "Cannot load script file '" + p_path + "'.");
-	Ref<ECMAScript> script;
+	Ref<JavaScript> script;
 	script.instantiate();
 	script->set_script_path(p_path);
 	script->bytecode = module->get_bytecode();
@@ -238,34 +245,33 @@ Ref<Resource> ResourceFormatLoaderECMAScript::load(const String &p_path, const S
 	if (r_error) *r_error = err;
 	ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), "Parse source code from file '" + p_path + "' failed.");
 #ifdef TOOLS_ENABLED
-	ECMAScriptLanguage::get_singleton()->get_scripts().insert(script);
+	JavaScriptLanguage::get_singleton()->get_scripts().insert(script);
 #endif
 	return script;
 }
 
-void ResourceFormatLoaderECMAScript::get_recognized_extensions(List<String> *p_extensions) const {
+void ResourceFormatLoaderJavaScript::get_recognized_extensions(List<String> *p_extensions) const {
 	p_extensions->push_front(EXT_JSCLASS);
 	p_extensions->push_front(EXT_JSCLASS_BYTECODE);
 	p_extensions->push_front(EXT_JSCLASS_ENCRYPTED);
 }
 
-void ResourceFormatLoaderECMAScript::get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const {
+void ResourceFormatLoaderJavaScript::get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const {
 	get_recognized_extensions(p_extensions);
 }
 
-bool ResourceFormatLoaderECMAScript::handles_type(const String &p_type) const {
-	return p_type == ECMAScript::get_class_static();
+bool ResourceFormatLoaderJavaScript::handles_type(const String &p_type) const {
+	return p_type == JavaScript::get_class_static();
 }
 
-String ResourceFormatLoaderECMAScript::get_resource_type(const String &p_path) const {
+String ResourceFormatLoaderJavaScript::get_resource_type(const String &p_path) const {
 	String el = p_path.get_extension().to_lower();
-	if (el == EXT_JSCLASS || el == EXT_JSCLASS_BYTECODE || el == EXT_JSCLASS_ENCRYPTED) return ECMAScript::get_class_static();
+	if (el == EXT_JSCLASS || el == EXT_JSCLASS_BYTECODE || el == EXT_JSCLASS_ENCRYPTED) return JavaScript::get_class_static();
 	return "";
 }
 
-Error ResourceFormatSaverECMAScript::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
-
-	Ref<ECMAScript> script = p_resource;
+Error ResourceFormatSaverJavaScript::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
+	Ref<JavaScript> script = p_resource;
 	ERR_FAIL_COND_V(script.is_null(), ERR_INVALID_PARAMETER);
 
 	String source = script->get_source_code();
@@ -285,57 +291,58 @@ Error ResourceFormatSaverECMAScript::save(const String &p_path, const Ref<Resour
 	return OK;
 }
 
-void ResourceFormatSaverECMAScript::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const {
-	if (Object::cast_to<ECMAScript>(*p_resource)) {
+void ResourceFormatSaverJavaScript::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const {
+	if (Object::cast_to<JavaScript>(*p_resource)) {
 		p_extensions->push_back(EXT_JSCLASS);
 	}
 }
 
-bool ResourceFormatSaverECMAScript::recognize(const Ref<Resource> &p_resource) const {
-	return Object::cast_to<ECMAScript>(*p_resource) != nullptr;
+bool ResourceFormatSaverJavaScript::recognize(const Ref<Resource> &p_resource) const {
+	return Object::cast_to<JavaScript>(*p_resource) != nullptr;
 }
 
-void ECMAScriptModule::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_script_path", "script_path"), &ECMAScriptModule::set_script_path);
-	ClassDB::bind_method(D_METHOD("get_script_path"), &ECMAScriptModule::get_script_path);
-	ClassDB::bind_method(D_METHOD("set_source_code", "source_code"), &ECMAScriptModule::set_source_code);
-	ClassDB::bind_method(D_METHOD("get_source_code"), &ECMAScriptModule::get_source_code);
-	ClassDB::bind_method(D_METHOD("set_bytecode", "bytecode"), &ECMAScriptModule::set_bytecode);
-	ClassDB::bind_method(D_METHOD("get_bytecode"), &ECMAScriptModule::get_bytecode);
+void JavaScriptModule::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_script_path", "script_path"), &JavaScriptModule::set_script_path);
+	ClassDB::bind_method(D_METHOD("get_script_path"), &JavaScriptModule::get_script_path);
+	ClassDB::bind_method(D_METHOD("set_source_code", "source_code"), &JavaScriptModule::set_source_code);
+	ClassDB::bind_method(D_METHOD("get_source_code"), &JavaScriptModule::get_source_code);
+	ClassDB::bind_method(D_METHOD("set_bytecode", "bytecode"), &JavaScriptModule::set_bytecode);
+	ClassDB::bind_method(D_METHOD("get_bytecode"), &JavaScriptModule::get_bytecode);
 	ADD_PROPERTY(PropertyInfo(Variant::STRING, "script_path"), "set_script_path", "get_script_path");
 }
 
-ECMAScriptModule::ECMAScriptModule() {
+JavaScriptModule::JavaScriptModule() {
 	set_source_code("module.exports = {};" ENDL);
 }
 
-Ref<Resource> ResourceFormatLoaderECMAScriptModule::load(const String &p_path, const String &p_original_path, Error *r_error) {
+Ref<Resource> ResourceFormatLoaderJavaScriptModule::load(const String &p_path, const String &p_original_path, Error *r_error) {
 	return load_static(p_path, p_original_path, r_error);
 }
 
-void ResourceFormatLoaderECMAScriptModule::get_recognized_extensions(List<String> *p_extensions) const {
+void ResourceFormatLoaderJavaScriptModule::get_recognized_extensions(List<String> *p_extensions) const {
 	p_extensions->push_front(EXT_JSMODULE);
 	p_extensions->push_front(EXT_JSMODULE_BYTECODE);
 	p_extensions->push_front(EXT_JSMODULE_ENCRYPTED);
 }
 
-void ResourceFormatLoaderECMAScriptModule::get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const {
+void ResourceFormatLoaderJavaScriptModule::get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const {
 	get_recognized_extensions(p_extensions);
 }
 
-bool ResourceFormatLoaderECMAScriptModule::handles_type(const String &p_type) const {
-	return p_type == ECMAScriptModule::get_class_static();
+bool ResourceFormatLoaderJavaScriptModule::handles_type(const String &p_type) const {
+	return p_type == JavaScriptModule::get_class_static();
 }
 
-String ResourceFormatLoaderECMAScriptModule::get_resource_type(const String &p_path) const {
+String ResourceFormatLoaderJavaScriptModule::get_resource_type(const String &p_path) const {
 	String el = p_path.get_extension().to_lower();
-	if (el == EXT_JSMODULE || el == EXT_JSMODULE_BYTECODE || el == EXT_JSMODULE_ENCRYPTED) return ECMAScriptModule::get_class_static();
+	if (el == EXT_JSMODULE || el == EXT_JSMODULE_BYTECODE || el == EXT_JSMODULE_ENCRYPTED)
+		return JavaScriptModule::get_class_static();
 	return "";
 }
 
-Ref<Resource> ResourceFormatLoaderECMAScriptModule::load_static(const String &p_path, const String &p_original_path, Error *r_error) {
+Ref<Resource> ResourceFormatLoaderJavaScriptModule::load_static(const String &p_path, const String &p_original_path, Error *r_error) {
 	Error err = ERR_FILE_CANT_OPEN;
-	Ref<ECMAScriptModule> module;
+	Ref<JavaScriptModule> module;
 	module.instantiate();
 	module->set_script_path(p_path);
 	if (p_path.ends_with("." EXT_JSMODULE) || p_path.ends_with("." EXT_JSCLASS) || p_path.ends_with("." EXT_JSON)) {
@@ -378,8 +385,8 @@ Ref<Resource> ResourceFormatLoaderECMAScriptModule::load_static(const String &p_
 	return module;
 }
 
-Error ResourceFormatSaverECMAScriptModule::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
-	Ref<ECMAScriptModule> module = p_resource;
+Error ResourceFormatSaverJavaScriptModule::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
+	Ref<JavaScriptModule> module = p_resource;
 	ERR_FAIL_COND_V(module.is_null(), ERR_INVALID_PARAMETER);
 	String source = module->get_source_code();
 	Error err;
@@ -392,12 +399,12 @@ Error ResourceFormatSaverECMAScriptModule::save(const String &p_path, const Ref<
 	return OK;
 }
 
-void ResourceFormatSaverECMAScriptModule::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const {
-	if (Object::cast_to<ECMAScriptModule>(*p_resource)) {
+void ResourceFormatSaverJavaScriptModule::get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const {
+	if (Object::cast_to<JavaScriptModule>(*p_resource)) {
 		p_extensions->push_back(EXT_JSMODULE);
 	}
 }
 
-bool ResourceFormatSaverECMAScriptModule::recognize(const Ref<Resource> &p_resource) const {
-	return Object::cast_to<ECMAScriptModule>(*p_resource) != nullptr;
+bool ResourceFormatSaverJavaScriptModule::recognize(const Ref<Resource> &p_resource) const {
+	return Object::cast_to<JavaScriptModule>(*p_resource) != nullptr;
 }
diff --git a/ecmascript.h b/javascript.h
similarity index 84%
rename from ecmascript.h
rename to javascript.h
index 2f88e605..3f37d63d 100644
--- a/ecmascript.h
+++ b/javascript.h
@@ -1,10 +1,10 @@
-#ifndef ECMASCRIPT_H
-#define ECMASCRIPT_H
+#ifndef JAVASCRIPT_H
+#define JAVASCRIPT_H
 
 #include "core/io/resource_loader.h"
 #include "core/io/resource_saver.h"
 #include "core/object/script_language.h"
-#include "ecmascript_binder.h"
+#include "javascript_binder.h"
 #include "scene/resources/text_file.h"
 
 #define EXT_JSCLASS "jsx"
@@ -15,20 +15,20 @@
 #define EXT_JSMODULE_ENCRYPTED EXT_JSMODULE "e"
 #define EXT_JSON "json"
 
-class ECMAScript : public Script {
-	GDCLASS(ECMAScript, Script);
+class JavaScript : public Script {
+	GDCLASS(JavaScript, Script);
 
 private:
-	friend class ECMAScriptInstance;
+	friend class JavaScriptInstance;
 	friend class QuickJSBinder;
-	friend class ResourceFormatLoaderECMAScript;
+	friend class ResourceFormatLoaderJavaScript;
 
 	HashSet<Object *> instances;
 	StringName class_name;
 	String code;
 	String script_path;
 	Vector<uint8_t> bytecode;
-	const BasicECMAClassInfo *ecma_class;
+	const BasicJavaScriptClassInfo *javascript_class;
 
 #ifdef TOOLS_ENABLED
 	HashSet<PlaceHolderScriptInstance *> placeholders;
@@ -83,12 +83,12 @@ class ECMAScript : public Script {
 
 	virtual const Variant get_rpc_config() const override { return rpc_config; }
 
-	ECMAScript();
-	virtual ~ECMAScript();
+	JavaScript();
+	virtual ~JavaScript();
 };
 
-class ResourceFormatLoaderECMAScript : public ResourceFormatLoader {
-	GDCLASS(ResourceFormatLoaderECMAScript, ResourceFormatLoader)
+class ResourceFormatLoaderJavaScript : public ResourceFormatLoader {
+	GDCLASS(ResourceFormatLoaderJavaScript, ResourceFormatLoader)
 public:
 	virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const override;
@@ -97,16 +97,16 @@ class ResourceFormatLoaderECMAScript : public ResourceFormatLoader {
 	virtual String get_resource_type(const String &p_path) const override;
 };
 
-class ResourceFormatSaverECMAScript : public ResourceFormatSaver {
-	GDCLASS(ResourceFormatSaverECMAScript, ResourceFormatSaver)
+class ResourceFormatSaverJavaScript : public ResourceFormatSaver {
+	GDCLASS(ResourceFormatSaverJavaScript, ResourceFormatSaver)
 public:
 	virtual Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags = 0);
 	virtual void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const override;
 	virtual bool recognize(const Ref<Resource> &p_resource) const override;
 };
 
-class ECMAScriptModule : public TextFile {
-	GDCLASS(ECMAScriptModule, Resource)
+class JavaScriptModule : public TextFile {
+	GDCLASS(JavaScriptModule, Resource)
 protected:
 	static void _bind_methods();
 	String script_path;
@@ -119,11 +119,12 @@ class ECMAScriptModule : public TextFile {
 	_FORCE_INLINE_ Vector<uint8_t> get_bytecode() const { return bytecode; }
 	_FORCE_INLINE_ void set_script_path(String p_script_path) { script_path = p_script_path; }
 	_FORCE_INLINE_ String get_script_path() const { return script_path; }
-	ECMAScriptModule();
+
+	JavaScriptModule();
 };
 
-class ResourceFormatLoaderECMAScriptModule : public ResourceFormatLoader {
-	GDCLASS(ResourceFormatLoaderECMAScriptModule, ResourceFormatLoader)
+class ResourceFormatLoaderJavaScriptModule : public ResourceFormatLoader {
+	GDCLASS(ResourceFormatLoaderJavaScriptModule, ResourceFormatLoader)
 public:
 	virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
 	virtual void get_recognized_extensions(List<String> *p_extensions) const override;
@@ -134,12 +135,12 @@ class ResourceFormatLoaderECMAScriptModule : public ResourceFormatLoader {
 	static Ref<Resource> load_static(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
 };
 
-class ResourceFormatSaverECMAScriptModule : public ResourceFormatSaver {
-	GDCLASS(ResourceFormatSaverECMAScriptModule, ResourceFormatSaver)
+class ResourceFormatSaverJavaScriptModule : public ResourceFormatSaver {
+	GDCLASS(ResourceFormatSaverJavaScriptModule, ResourceFormatSaver)
 public:
 	virtual Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags = 0);
 	virtual void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const override;
 	virtual bool recognize(const Ref<Resource> &p_resource) const override;
 };
 
-#endif // ECMASCRIPT_H
+#endif
diff --git a/javascript_binder.h b/javascript_binder.h
new file mode 100644
index 00000000..18fcf320
--- /dev/null
+++ b/javascript_binder.h
@@ -0,0 +1,102 @@
+#ifndef JAVASCRIPT_BINDING_HELPER_H
+#define JAVASCRIPT_BINDING_HELPER_H
+
+#include "core/os/thread.h"
+#include "javascript_gc_handler.h"
+
+typedef JavaScriptGCHandler JSMethodInfo;
+
+struct JavaScriptProperyInfo : public PropertyInfo {
+	Variant default_value;
+};
+
+struct JavaScriptError {
+	int line;
+	int column;
+	String message;
+	String file;
+	Vector<String> stack;
+};
+
+struct BasicJavaScriptClassInfo {
+	bool tool;
+	StringName class_name;
+	String icon_path;
+	const ClassDB::ClassInfo *native_class;
+	HashMap<StringName, MethodInfo> signals;
+	HashMap<StringName, MethodInfo> methods;
+	HashMap<StringName, JavaScriptProperyInfo> properties;
+};
+
+struct JavaScriptClassInfo : public BasicJavaScriptClassInfo {
+	JavaScriptGCHandler constructor;
+	JavaScriptGCHandler prototype;
+};
+
+struct GlobalNumberConstant {
+	StringName name;
+	double_t value;
+};
+
+struct JavaScriptStackInfo {
+	int line;
+	String file;
+	String function;
+};
+
+class JavaScriptBinder {
+protected:
+	// Path ==> JavaScript Class
+	HashMap<String, JavaScriptClassInfo> javascript_classes;
+	HashMap<int64_t, JavaScriptGCHandler> frame_callbacks;
+	HashSet<int64_t> canceled_frame_callbacks;
+	static String BINDING_SCRIPT_CONTENT;
+
+public:
+	enum EvalType {
+		EVAL_TYPE_MODULE,
+		EVAL_TYPE_GLOBAL,
+	};
+
+	JavaScriptBinder() {}
+	virtual ~JavaScriptBinder(){};
+
+	virtual JavaScriptBinder *get_context_binder(void *p_context) = 0;
+	virtual Thread::ID get_thread_id() const = 0;
+
+	virtual void clear_classes() { javascript_classes.clear(); }
+
+	virtual void initialize() = 0;
+	virtual void uninitialize() = 0;
+	virtual void language_finalize() = 0;
+	virtual void frame() = 0;
+
+	virtual JavaScriptGCHandler *alloc_object_binding_data(Object *p_object) = 0;
+	virtual void free_object_binding_data(JavaScriptGCHandler *p_gc_handle) = 0;
+	virtual void godot_refcount_incremented(JavaScriptGCHandler *p_gc_handle) = 0;
+	virtual bool godot_refcount_decremented(JavaScriptGCHandler *p_gc_handle) = 0;
+
+	virtual Error eval_string(const String &p_source, EvalType type, const String &p_path, JavaScriptGCHandler &r_ret) = 0;
+	virtual Error safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, JavaScriptGCHandler &r_ret) = 0;
+	virtual String error_to_string(const JavaScriptError &p_error) = 0;
+	virtual Error get_stacks(List<JavaScriptStackInfo> &r_stacks) = 0;
+	virtual String get_backtrace_message(const List<JavaScriptStackInfo> &stacks) = 0;
+
+	virtual Error compile_to_bytecode(const String &p_code, const String &p_file, Vector<uint8_t> &r_bytecode) = 0;
+	virtual Error load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, JavaScriptGCHandler *r_module) = 0;
+	virtual const JavaScriptClassInfo *parse_javascript_class(const String &p_code, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) = 0;
+	virtual const JavaScriptClassInfo *parse_javascript_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) = 0;
+
+	virtual JavaScriptGCHandler create_js_instance_for_godot_object(const JavaScriptClassInfo *p_class, Object *p_object) = 0;
+	virtual Variant call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) = 0;
+	virtual bool get_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) = 0;
+	virtual bool set_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) = 0;
+	virtual bool has_method(const JavaScriptGCHandler &p_object, const StringName &p_name) = 0;
+	virtual bool has_signal(const JavaScriptClassInfo *p_class, const StringName &p_signal) = 0;
+	virtual bool validate(const String &p_code, const String &p_path, JavaScriptError *r_error) = 0;
+#ifdef TOOLS_ENABLED
+	virtual const Dictionary &get_modified_api() const = 0;
+#endif
+};
+
+#endif
diff --git a/ecmascript_gc_handler.h b/javascript_gc_handler.h
similarity index 93%
rename from ecmascript_gc_handler.h
rename to javascript_gc_handler.h
index c53232ad..f9f4bd3f 100644
--- a/ecmascript_gc_handler.h
+++ b/javascript_gc_handler.h
@@ -1,5 +1,5 @@
-#ifndef ECMASCRIPT_GC_HANDLER_H
-#define ECMASCRIPT_GC_HANDLER_H
+#ifndef JAVASCRIPT_GC_HANDLER_H
+#define JAVASCRIPT_GC_HANDLER_H
 
 #include "core/object/object.h"
 #include "core/object/ref_counted.h"
@@ -8,10 +8,10 @@
 #define PROTOTYPE_LITERAL "prototype"
 #define PROTO_LITERAL "__proto__"
 #define TO_STRING_LITERAL "toString"
-#define ECMA_CLASS_NAME_LITERAL "class_name"
+#define JS_CLASS_NAME_LITERAL "class_name"
 #define GODOT_OBJECT_NAME "godot"
 
-struct ECMAScriptGCHandler {
+struct JavaScriptGCHandler {
 	enum {
 		FLAG_NONE = 0,
 		FLAG_ATOMIC_VALUE = 1 << 1,
@@ -24,7 +24,7 @@ struct ECMAScriptGCHandler {
 	Variant::Type type;
 	uint8_t flags;
 	void *context;
-	void *ecma_object;
+	void *javascript_object;
 	union {
 		Object *godot_object;
 		void *godot_builtin_object_ptr;
@@ -128,23 +128,22 @@ struct ECMAScriptGCHandler {
 	_FORCE_INLINE_ bool is_finalized() const {
 		return flags & FLAG_FINALIZED;
 	}
-	_FORCE_INLINE_ bool is_valid_ecma_object() const {
-		return context != NULL && ecma_object != NULL && !is_finalized();
+	_FORCE_INLINE_ bool is_valid_javascript_object() const {
+		return context != NULL && javascript_object != NULL && !is_finalized();
 	}
 
-
 	_FORCE_INLINE_ void clear() {
 		type = Variant::NIL;
 		godot_object = NULL;
-		ecma_object = NULL;
+		javascript_object = NULL;
 		context = NULL;
 	}
 
-	ECMAScriptGCHandler() {
+	JavaScriptGCHandler() {
 		type = Variant::NIL;
 		flags = FLAG_NONE;
 		godot_object = NULL;
-		ecma_object = NULL;
+		javascript_object = NULL;
 		context = NULL;
 	}
 };
diff --git a/javascript_instance.cpp b/javascript_instance.cpp
new file mode 100644
index 00000000..12d543fe
--- /dev/null
+++ b/javascript_instance.cpp
@@ -0,0 +1,76 @@
+#include "javascript_instance.h"
+#include "javascript.h"
+#include "javascript_language.h"
+
+Ref<Script> JavaScriptInstance::get_script() const {
+	return script;
+}
+
+void JavaScriptInstance::get_method_list(List<MethodInfo> *p_list) const {
+	if (!javascript_class)
+		return;
+	for (const KeyValue<StringName, MethodInfo> &i : javascript_class->methods) {
+		p_list->push_back(i.value);
+	}
+}
+
+bool JavaScriptInstance::has_method(const StringName &p_method) const {
+	if (!binder || !javascript_object.javascript_object)
+		return false;
+	return binder->has_method(javascript_object, p_method);
+}
+
+bool JavaScriptInstance::set(const StringName &p_name, const Variant &p_value) {
+	if (!binder || !javascript_object.javascript_object)
+		return false;
+	return binder->set_instance_property(javascript_object, p_name, p_value);
+}
+
+bool JavaScriptInstance::get(const StringName &p_name, Variant &r_ret) const {
+	if (!binder || !javascript_object.javascript_object)
+		return false;
+	return binder->get_instance_property(this->javascript_object, p_name, r_ret);
+}
+
+void JavaScriptInstance::get_property_list(List<PropertyInfo> *p_properties) const {
+	if (!javascript_class)
+		return;
+	for (const KeyValue<StringName, JavaScriptProperyInfo> &i : javascript_class->properties) {
+		p_properties->push_back(i.value);
+	}
+}
+
+Variant::Type JavaScriptInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const {
+	*r_is_valid = false;
+	if (javascript_class) {
+		if (const JavaScriptProperyInfo *pi = javascript_class->properties.getptr(p_name)) {
+			*r_is_valid = true;
+			return pi->type;
+		}
+	}
+	return Variant::NIL;
+}
+
+Variant JavaScriptInstance::callp(const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
+	if (binder == NULL || javascript_object.javascript_object == NULL) {
+		r_error.error = Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL;
+		ERR_FAIL_V(Variant());
+	}
+	return binder->call_method(javascript_object, p_method, p_args, p_argcount, r_error);
+}
+
+ScriptLanguage *JavaScriptInstance::get_language() {
+	return JavaScriptLanguage::get_singleton();
+}
+
+JavaScriptInstance::JavaScriptInstance() {
+	owner = NULL;
+	binder = NULL;
+	javascript_class = NULL;
+}
+
+JavaScriptInstance::~JavaScriptInstance() {
+	if (script.is_valid() && owner) {
+		script->instances.erase(owner);
+	}
+}
diff --git a/ecmascript_instance.h b/javascript_instance.h
similarity index 75%
rename from ecmascript_instance.h
rename to javascript_instance.h
index cff531aa..01220a47 100644
--- a/ecmascript_instance.h
+++ b/javascript_instance.h
@@ -1,21 +1,20 @@
-#ifndef ECMASCRIPT_INSTANCE_H
-#define ECMASCRIPT_INSTANCE_H
+#ifndef JAVASCRIPT_INSTANCE_H
+#define JAVASCRIPT_INSTANCE_H
 
-#include "ecmascript.h"
-#include "ecmascript_binder.h"
+#include "javascript.h"
+#include "javascript_binder.h"
 #include "core/object/script_language.h"
 #include "core/variant/callable.h"
 
-class ECMAScriptInstance : public ScriptInstance {
-
-	friend class ECMAScript;
+class JavaScriptInstance : public ScriptInstance {
+	friend class JavaScript;
 	friend class QuickJSBinder;
 
 	Object *owner;
-	Ref<ECMAScript> script;
-	ECMAScriptGCHandler ecma_object;
-	ECMAScriptBinder *binder;
-	const ECMAClassInfo *ecma_class;
+	Ref<JavaScript> script;
+	JavaScriptGCHandler javascript_object;
+	JavaScriptBinder *binder;
+	const JavaScriptClassInfo *javascript_class;
 
 public:
 	virtual bool set(const StringName &p_name, const Variant &p_value) override;
@@ -36,8 +35,8 @@ class ECMAScriptInstance : public ScriptInstance {
 
 	virtual void notification(int p_notification) override{};
 
-	ECMAScriptInstance();
-	~ECMAScriptInstance();
+	JavaScriptInstance();
+	~JavaScriptInstance();
 };
 
-#endif // ECMASCRIPT_INSTANCE_H
+#endif
diff --git a/ecmascript_language.cpp b/javascript_language.cpp
similarity index 75%
rename from ecmascript_language.cpp
rename to javascript_language.cpp
index 649b5296..e73381dc 100644
--- a/ecmascript_language.cpp
+++ b/javascript_language.cpp
@@ -1,75 +1,74 @@
-#include "ecmascript_language.h"
+#include "javascript_language.h"
 #include "core/object/class_db.h"
 #include "core/io/file_access.h"
-ECMAScriptLanguage *ECMAScriptLanguage::singleton = NULL;
+JavaScriptLanguage *JavaScriptLanguage::singleton = NULL;
 
-namespace ECMAScriptInstanceBindingCallbacks {
+namespace JavaScriptInstanceBindingCallbacks {
 
 static void *create_callback(void *p_token, void *p_instance) {
-	if (ECMAScriptBinder *binder = ECMAScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
 		return binder->alloc_object_binding_data(static_cast<Object *>(p_instance));
 	}
 	return nullptr;
 }
 
 static void free_callback(void *p_token, void *p_instance, void *p_binding) {
-	if (ECMAScriptBinder *binder = ECMAScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
-		return binder->free_object_binding_data(static_cast<ECMAScriptGCHandler *>(p_binding));
+	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+		return binder->free_object_binding_data(static_cast<JavaScriptGCHandler *>(p_binding));
 	}
 }
 
 static GDNativeBool reference_callback(void *p_token, void *p_binding, GDNativeBool p_reference) {
-	if (ECMAScriptBinder *binder = ECMAScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
 		if (p_reference) {
-			binder->godot_refcount_incremented(static_cast<ECMAScriptGCHandler *>(p_binding));
+			binder->godot_refcount_incremented(static_cast<JavaScriptGCHandler *>(p_binding));
 			return false;
 		} else {
-			return binder->godot_refcount_decremented(static_cast<ECMAScriptGCHandler *>(p_binding));
+			return binder->godot_refcount_decremented(static_cast<JavaScriptGCHandler *>(p_binding));
 		}
 	}
 	return true;
 }
 
-} // namespace ECMAScriptInstanceBindingCallbacks
+} // namespace JavaScriptInstanceBindingCallbacks
 
-ECMAScriptLanguage::ECMAScriptLanguage() {
+JavaScriptLanguage::JavaScriptLanguage() {
 	ERR_FAIL_COND(singleton);
 	singleton = this;
 	main_binder = memnew(QuickJSBinder);
-	instance_binding_callbacks.create_callback = ECMAScriptInstanceBindingCallbacks::create_callback;
-	instance_binding_callbacks.free_callback = ECMAScriptInstanceBindingCallbacks::free_callback;
-	instance_binding_callbacks.reference_callback = ECMAScriptInstanceBindingCallbacks::reference_callback;
+	instance_binding_callbacks.create_callback = JavaScriptInstanceBindingCallbacks::create_callback;
+	instance_binding_callbacks.free_callback = JavaScriptInstanceBindingCallbacks::free_callback;
+	instance_binding_callbacks.reference_callback = JavaScriptInstanceBindingCallbacks::reference_callback;
 }
 
-ECMAScriptLanguage::~ECMAScriptLanguage() {
+JavaScriptLanguage::~JavaScriptLanguage() {
 	memdelete(main_binder);
 }
 
-void ECMAScriptLanguage::init() {
+void JavaScriptLanguage::init() {
 	ERR_FAIL_NULL(main_binder);
 	main_binder->initialize();
-	execute_file("modules/ECMAScript/tests/UnitTest.js");
+	execute_file("modules/javascript/tests/UnitTest.js");
 }
 
-void ECMAScriptLanguage::finish() {
+void JavaScriptLanguage::finish() {
 	ERR_FAIL_NULL(main_binder);
 	main_binder->uninitialize();
 	main_binder->language_finalize();
 }
 
-Error ECMAScriptLanguage::execute_file(const String &p_path) {
+Error JavaScriptLanguage::execute_file(const String &p_path) {
 	ERR_FAIL_NULL_V(main_binder, ERR_BUG);
 	Error err;
 	String code = FileAccess::get_file_as_string(p_path, &err);
 	if (err == OK) {
-		ECMAScriptGCHandler eval_ret;
-		err = main_binder->eval_string(code, ECMAScriptBinder::EVAL_TYPE_GLOBAL, p_path, eval_ret);
+		JavaScriptGCHandler eval_ret;
+		err = main_binder->eval_string(code, JavaScriptBinder::EVAL_TYPE_GLOBAL, p_path, eval_ret);
 	}
 	return err;
 }
 
-void ECMAScriptLanguage::get_reserved_words(List<String> *p_words) const {
-
+void JavaScriptLanguage::get_reserved_words(List<String> *p_words) const {
 	static const char *_reserved_words[] = {
 		"null",
 		"false",
@@ -192,7 +191,7 @@ void ECMAScriptLanguage::get_reserved_words(List<String> *p_words) const {
 	}
 }
 
-bool ECMAScriptLanguage::is_control_flow_keyword(String p_keyword) const {
+bool JavaScriptLanguage::is_control_flow_keyword(String p_keyword) const {
 	return p_keyword == "if" ||
 		   p_keyword == "else" ||
 		   p_keyword == "return" ||
@@ -210,20 +209,18 @@ bool ECMAScriptLanguage::is_control_flow_keyword(String p_keyword) const {
 		   p_keyword == "finally";
 }
 
-
-void ECMAScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
+void JavaScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
 	p_delimiters->push_back("//"); // single-line comment
 	p_delimiters->push_back("/* */"); // delimited comment
 }
 
-void ECMAScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
+void JavaScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
 	p_delimiters->push_back("' '");
 	p_delimiters->push_back("\" \"");
 	p_delimiters->push_back("` `");
 }
 
-Ref<Script> ECMAScriptLanguage::get_template(const String &p_class_name, const String &p_base_class_name) const {
-
+Ref<Script> JavaScriptLanguage::get_template(const String &p_class_name, const String &p_base_class_name) const {
 	String script_template = "export default class %CLASS% extends " GODOT_OBJECT_NAME ".%BASE% {\n"
 							 "    \n"
 							 "    // Declare member variables here. Examples:\n"
@@ -246,7 +243,7 @@ Ref<Script> ECMAScriptLanguage::get_template(const String &p_class_name, const S
 							 "}\n";
 	script_template = script_template.replace("%BASE%", p_base_class_name).replace("%CLASS%", p_class_name);
 
-	Ref<ECMAScript> script;
+	Ref<JavaScript> script;
 	script.instantiate();
 	script->set_source_code(script_template);
 	script->set_name(p_class_name);
@@ -254,8 +251,8 @@ Ref<Script> ECMAScriptLanguage::get_template(const String &p_class_name, const S
 	return script;
 }
 
-Ref<Script> ECMAScriptLanguage::make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const {
-	Ref<ECMAScript> script;
+Ref<Script> JavaScriptLanguage::make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const {
+	Ref<JavaScript> script;
 	script.instantiate();
 	String src = script->get_source_code();
 	src = src.replace("%BASE%", p_base_class_name).replace("%CLASS%", p_class_name);
@@ -263,8 +260,8 @@ Ref<Script> ECMAScriptLanguage::make_template(const String &p_template, const St
 	return script;
 }
 
-bool ECMAScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptError> *r_errors, List<Warning> *r_warnings, HashSet<int> *r_safe_lines) const {
-	ECMAscriptScriptError script_error;
+bool JavaScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptError> *r_errors, List<Warning> *r_warnings, HashSet<int> *r_safe_lines) const {
+	JavaScriptError script_error;
 	bool ret = main_binder->validate(p_script, p_path, &script_error);
 	if (!ret) {
 		ScriptError se;
@@ -276,23 +273,23 @@ bool ECMAScriptLanguage::validate(const String &p_script, const String &p_path,
 	return ret;
 }
 
-Script *ECMAScriptLanguage::create_script() const {
-	return memnew(ECMAScript);
+Script *JavaScriptLanguage::create_script() const {
+	return memnew(JavaScript);
 }
 
-void ECMAScriptLanguage::reload_all_scripts() {
+void JavaScriptLanguage::reload_all_scripts() {
 #ifdef TOOLS_ENABLED
-	for (const Ref<ECMAScript> &s : scripts) {
+	for (const Ref<JavaScript> &s : scripts) {
 		reload_script(s, true);
 	}
 #endif
 }
 
-void ECMAScriptLanguage::reload_script(const Ref<Script> &p_script, bool p_soft_reload) {
-	Ref<ECMAScript> s = p_script;
+void JavaScriptLanguage::reload_script(const Ref<Script> &p_script, bool p_soft_reload) {
+	Ref<JavaScript> s = p_script;
 	if (s.is_valid()) {
 		Error err = OK;
-		Ref<ECMAScriptModule> module = ResourceFormatLoaderECMAScriptModule::load_static(s->get_script_path(), "", &err);
+		Ref<JavaScriptModule> module = ResourceFormatLoaderJavaScriptModule::load_static(s->get_script_path(), "", &err);
 		ERR_FAIL_COND_MSG(err != OK, ("Cannot load script file '" + s->get_script_path() + "'."));
 		s->set_source_code(module->get_source_code());
 		err = s->reload(p_soft_reload);
@@ -300,7 +297,7 @@ void ECMAScriptLanguage::reload_script(const Ref<Script> &p_script, bool p_soft_
 	}
 }
 
-void ECMAScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
+void JavaScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
 	p_extensions->push_back(EXT_JSMODULE);
 	p_extensions->push_back(EXT_JSCLASS);
 	p_extensions->push_back(EXT_JSON);
@@ -310,11 +307,11 @@ void ECMAScriptLanguage::get_recognized_extensions(List<String> *p_extensions) c
 	p_extensions->push_back(EXT_JSCLASS_BYTECODE);
 }
 
-void ECMAScriptLanguage::frame() {
+void JavaScriptLanguage::frame() {
 	main_binder->frame();
 }
 
-String ECMAScriptLanguage::globalize_relative_path(const String &p_relative, const String &p_base_dir) {
+String JavaScriptLanguage::globalize_relative_path(const String &p_relative, const String &p_base_dir) {
 	String file = p_relative;
 	if (file.begins_with(".")) {
 		String base_dir = p_base_dir;
diff --git a/ecmascript_language.h b/javascript_language.h
similarity index 85%
rename from ecmascript_language.h
rename to javascript_language.h
index 4d1d5fb8..9a454480 100644
--- a/ecmascript_language.h
+++ b/javascript_language.h
@@ -1,33 +1,32 @@
-#ifndef ECMASCRIPT_LANGUAGE_H
-#define ECMASCRIPT_LANGUAGE_H
+#ifndef JAVASCRIPT_LANGUAGE_H
+#define JAVASCRIPT_LANGUAGE_H
 
 #include "core/object/script_language.h"
-#include "ecmascript.h"
+#include "javascript.h"
 #include "quickjs/quickjs_binder.h"
 
-class ECMAScriptBinder;
-class ECMAScriptLanguage : public ScriptLanguage {
-
-	friend class ECMAScriptBinder;
-	friend class ECMAScript;
-	friend class ECMAScriptInstance;
+class JavaScriptBinder;
+class JavaScriptLanguage : public ScriptLanguage {
+	friend class JavaScriptBinder;
+	friend class JavaScript;
+	friend class JavaScriptInstance;
 	friend class DuktapeBindingHelper;
 	friend class QuickJSBinder;
 
 private:
-	static ECMAScriptLanguage *singleton;
-	ECMAScriptBinder *main_binder;
-	HashMap<Thread::ID, ECMAScriptBinder *> thread_binder_map;
+	static JavaScriptLanguage *singleton;
+	JavaScriptBinder *main_binder;
+	HashMap<Thread::ID, JavaScriptBinder *> thread_binder_map;
 	GDNativeInstanceBindingCallbacks instance_binding_callbacks;
 #ifdef TOOLS_ENABLED
-	HashSet<Ref<ECMAScript>> scripts;
+	HashSet<Ref<JavaScript>> scripts;
 #endif
 
 public:
-	_FORCE_INLINE_ static ECMAScriptLanguage *get_singleton() { return singleton; }
-	_FORCE_INLINE_ static ECMAScriptBinder *get_main_binder() { return singleton->main_binder; }
-	_FORCE_INLINE_ static ECMAScriptBinder *get_thread_binder(Thread::ID p_id) {
-		if (ECMAScriptBinder **ptr = singleton->thread_binder_map.getptr(p_id)) {
+	_FORCE_INLINE_ static JavaScriptLanguage *get_singleton() { return singleton; }
+	_FORCE_INLINE_ static JavaScriptBinder *get_main_binder() { return singleton->main_binder; }
+	_FORCE_INLINE_ static JavaScriptBinder *get_thread_binder(Thread::ID p_id) {
+		if (JavaScriptBinder **ptr = singleton->thread_binder_map.getptr(p_id)) {
 			return *ptr;
 		}
 		return nullptr;
@@ -36,7 +35,7 @@ class ECMAScriptLanguage : public ScriptLanguage {
 	_FORCE_INLINE_ virtual String get_name() const override { return "JavaScript"; }
 	const GDNativeInstanceBindingCallbacks *get_instance_binding_callbacks() const { return &instance_binding_callbacks; }
 #ifdef TOOLS_ENABLED
-	_FORCE_INLINE_ HashSet<Ref<ECMAScript> > &get_scripts() { return scripts; }
+	_FORCE_INLINE_ HashSet<Ref<JavaScript> > &get_scripts() { return scripts; }
 #endif
 	/* LANGUAGE FUNCTIONS */
 
@@ -109,8 +108,8 @@ class ECMAScriptLanguage : public ScriptLanguage {
 
 	static String globalize_relative_path(const String &p_relative, const String &p_base_dir);
 
-	ECMAScriptLanguage();
-	virtual ~ECMAScriptLanguage();
+	JavaScriptLanguage();
+	virtual ~JavaScriptLanguage();
 };
 
-#endif // ECMASCRIPT_LANGUAGE_H
+#endif
diff --git a/misc/decorators.ts b/misc/decorators.ts
index 91d29d00..6fb9ce7d 100644
--- a/misc/decorators.ts
+++ b/misc/decorators.ts
@@ -1,10 +1,10 @@
 /**
- * Expose as an ECMAClass.
- * An ECMAScript object is created and attached automaticly when construct an instance from this class
+ * Expose as a godot class.
+ * An class object is created and attached automaticly when construct an instance from this class
  */
 export function gdclass<T extends godot.Object>(target: new() => T) {
     const id = gdclass['internal_class_id'] = gdclass['internal_class_id'] ? gdclass['internal_class_id'] + 1 : 1;
-	const class_name = `AnonymousECMAClass${id}`;
+	const class_name = `AnonymousJSClass${id}`;
 	godot.register_class(target, class_name);
 }
 
diff --git a/quickjs/builtin_binding_generator.py b/quickjs/builtin_binding_generator.py
index 33ddca21..3d47b953 100644
--- a/quickjs/builtin_binding_generator.py
+++ b/quickjs/builtin_binding_generator.py
@@ -188,7 +188,7 @@ def generate_constructor(cls):
 		tmp.x = QuickJSBinder::js_to_number(ctx, argv[0]);
 		tmp.y = QuickJSBinder::js_to_number(ctx, argv[1]);
 	} else if (argc == 1) {
-		if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
+		if (JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
 			if (bind->type == Variant::VECTOR2) {
 				tmp = *bind->getVector2();
 			}
@@ -200,7 +200,7 @@ def generate_constructor(cls):
 ''',
 		"Vector3": '''
 	if (argc == 1) {
-		if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
+		if (JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
 			if (bind->type == Variant::VECTOR3)
 				tmp = *bind->getVector3();
 		} else {
@@ -224,7 +224,7 @@ def generate_constructor(cls):
 			tmp = Color::hex(QuickJSBinder::js_to_uint(ctx, argv[0]));
 		} else if (JS_IsString(argv[0])) {
 			tmp = Color::html(QuickJSBinder::js_to_string(ctx, argv[0]));
-		} else if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
+		} else if (JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
 			if (bind->type == Variant::COLOR) {
 				tmp = *bind->getColor();
 			}
@@ -242,12 +242,12 @@ def generate_constructor(cls):
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR2, argv[0]), (JS_ThrowTypeError(ctx, "Vector2 expected for argument 0 of Rect2(position, size)")));
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR2, argv[1]), (JS_ThrowTypeError(ctx, "Vector2 expected for argument 1 of Rect2(position, size)")));
 #endif
-		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
-		ECMAScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
+		JavaScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
+		JavaScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
 		tmp.position = *param0->getVector2();
 		tmp.size = *param1->getVector2();
 	} else if (argc == 1) {
-		if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
+		if (JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
 			if (bind->type == Variant::RECT2)
 				tmp = *bind->getRect2();
 		}
@@ -259,12 +259,12 @@ def generate_constructor(cls):
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 0 of AABB(position, size)")));
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[1]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 1 of AABB(position, size)")));
 #endif
-		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
-		ECMAScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
+		JavaScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
+		JavaScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
 		tmp.position = *param0->getVector3();
 		tmp.size = *param1->getVector3();
 	} else if (argc == 1) {
-		if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
+		if (JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
 			if (bind->type == Variant::AABB)
 				tmp = *bind->getAABB();
 		}
@@ -282,18 +282,18 @@ def generate_constructor(cls):
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[1]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 1 of Plane(v1, v2, v3)")));
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[2]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 2 of Plane(v1, v2, v3)")));
 #endif
-		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
-		ECMAScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
-		ECMAScriptGCHandler *param2 = BINDING_DATA_FROM_JS(ctx, argv[2]);
+		JavaScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
+		JavaScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
+		JavaScriptGCHandler *param2 = BINDING_DATA_FROM_JS(ctx, argv[2]);
 		tmp = Plane(*param0->getVector3(), *param1->getVector3(), *param2->getVector3());
 	} else if (argc == 2) {
 #ifdef DEBUG_METHODS_ENABLED
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 0 of Plane(normal, d)")));
 #endif
-		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
+		JavaScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
 		tmp = Plane(*param0->getVector3(), QuickJSBinder::js_to_number(ctx, argv[1]));
 	} else if (argc == 1) {
-		if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
+		if (JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
 			if (bind->type == Variant::PLANE)
 				tmp = *bind->getPlane();
 		}
@@ -309,10 +309,10 @@ def generate_constructor(cls):
 #ifdef DEBUG_METHODS_ENABLED
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 0 of Quaternion(axis, angle)")));
 #endif
-		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
+		JavaScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
 		tmp = Quaternion(*param0->getVector3(), QuickJSBinder::js_to_number(ctx, argv[1]));
 	} else if (argc == 1) {
-		if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
+		if (JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
 			if (bind->type == Variant::QUATERNION) {
 				tmp = *bind->getQuaternion();
 			} else if (bind->type == Variant::BASIS) {
@@ -332,9 +332,9 @@ def generate_constructor(cls):
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR2, argv[1]), (JS_ThrowTypeError(ctx, "Vector2 expected for argument 1 of Transform2D(x_axis, y_axis, origin)")));
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR2, argv[2]), (JS_ThrowTypeError(ctx, "Vector2 expected for argument 2 of Transform2D(x_axis, y_axis, origin)")));
 #endif
-		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
-		ECMAScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
-		ECMAScriptGCHandler *param2 = BINDING_DATA_FROM_JS(ctx, argv[2]);
+		JavaScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
+		JavaScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
+		JavaScriptGCHandler *param2 = BINDING_DATA_FROM_JS(ctx, argv[2]);
 		tmp.columns[0].operator=(*param0->getVector2());
 		tmp.columns[1].operator=(*param1->getVector2());
 		tmp.columns[2].operator=(*param2->getVector2());
@@ -342,11 +342,11 @@ def generate_constructor(cls):
 #ifdef DEBUG_METHODS_ENABLED
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR2, argv[1]), (JS_ThrowTypeError(ctx, "Vector2 expected for argument 1 of Transform2D(rotation, position)")));
 #endif
-		ECMAScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
+		JavaScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
 		tmp.set_origin(*param1->getVector2());
 		tmp.set_rotation(QuickJSBinder::js_to_number(ctx, argv[0]));
 	} else if (argc == 1) {
-		if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
+		if (JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
 			if (bind->type == Variant::TRANSFORM2D)
 				tmp = *bind->getTransform2D();
 			else if (Variant::can_convert(bind->type, Variant::TRANSFORM2D)) {
@@ -362,9 +362,9 @@ def generate_constructor(cls):
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[1]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 1 of Basis(x_axis, y_axis, z_axis)")));
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[2]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 2 of Basis(x_axis, y_axis, z_axis)")));
 #endif
-		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
-		ECMAScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
-		ECMAScriptGCHandler *param2 = BINDING_DATA_FROM_JS(ctx, argv[2]);
+		JavaScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
+		JavaScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
+		JavaScriptGCHandler *param2 = BINDING_DATA_FROM_JS(ctx, argv[2]);
 		tmp.rows[0].operator=(*param0->getVector3());
 		tmp.rows[1].operator=(*param1->getVector3());
 		tmp.rows[2].operator=(*param2->getVector3());
@@ -372,10 +372,10 @@ def generate_constructor(cls):
 #ifdef DEBUG_METHODS_ENABLED
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 0 of Basis(axis, phi)")));
 #endif
-		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
+		JavaScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
 		tmp.set_axis_angle(*param0->getVector3(), QuickJSBinder::js_to_number(ctx, argv[1]));
 	} else if (argc == 1) {
-		if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
+		if (JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
 			if (bind->type == Variant::VECTOR3) {
 				tmp.set_euler(*bind->getVector3());
 			} else if (bind->type == Variant::QUATERNION) {
@@ -394,10 +394,10 @@ def generate_constructor(cls):
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[2]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 2 of Transform3D(x_axis, y_axis, z_axis, origin)")));
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[3]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 3 of Transform3D(x_axis, y_axis, z_axis, origin)")));
 #endif
-		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
-		ECMAScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
-		ECMAScriptGCHandler *param2 = BINDING_DATA_FROM_JS(ctx, argv[2]);
-		ECMAScriptGCHandler *param3 = BINDING_DATA_FROM_JS(ctx, argv[3]);
+		JavaScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
+		JavaScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
+		JavaScriptGCHandler *param2 = BINDING_DATA_FROM_JS(ctx, argv[2]);
+		JavaScriptGCHandler *param3 = BINDING_DATA_FROM_JS(ctx, argv[3]);
 
 		tmp.basis.rows[0].operator=(*param0->getVector3());
 		tmp.basis.rows[1].operator=(*param1->getVector3());
@@ -408,12 +408,12 @@ def generate_constructor(cls):
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::BASIS, argv[0]), (JS_ThrowTypeError(ctx, "Basis expected for argument 0 of Transform3D(basis, origin)")));
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[1]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 1 of Transform3D(basis, origin)")));
 #endif
-		ECMAScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
-		ECMAScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
+		JavaScriptGCHandler *param0 = BINDING_DATA_FROM_JS(ctx, argv[0]);
+		JavaScriptGCHandler *param1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
 		tmp.basis.operator=(*param0->getBasis());
 		tmp.origin.operator=(*param1->getVector3());
 	} else if (argc == 1) {
-		if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
+		if (JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
 			if (bind->type == Variant::TRANSFORM3D) {
 				tmp.operator=(*bind->getTransform3D());
 			} else if (Variant::can_convert(bind->type, Variant::TRANSFORM3D)) {
@@ -454,7 +454,7 @@ def generate_property_bindings(cls):
 	def generate_members(cls):
 		Template = '''
 	JSCFunctionMagic *getter = [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic) -> JSValue {
-		ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+		JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 		const ${class} *ptr = bind->get${class}();
 		switch (magic) {\
 ${getters}
@@ -463,7 +463,7 @@ def generate_members(cls):
 	};
 	
 	JSCFunctionMagic *setter = [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic) -> JSValue {
-		ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+		JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 		${class} *ptr = bind->get${class}();\
 ${validation}
 		switch (magic) {\
@@ -520,7 +520,7 @@ def generate_methods(cls):
 		${type},
 		"${name}",
 		[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-			ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+			JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 			${class} *ptr = bind->get${class}();\
 ${arg_declares}
 			${call}
@@ -589,13 +589,13 @@ def genertate_operators(cls):
 #ifdef DEBUG_METHODS_ENABLED
 			ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, ${type}, argv[1]), (JS_ThrowTypeError(ctx, "${target_class} expected for ${class}.${operator}")));
 #endif
-			ECMAScriptGCHandler *bind1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
+			JavaScriptGCHandler *bind1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
 			${target_class} *target = bind1->get${target_class}();\
 '''
 		OperatorTemplate = '''
 	JS_SetPropertyStr(octx, base_operators, "${js_op}",
 		JS_NewCFunction(octx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-			ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
+			JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
 			${class} *ptr = bind->get${class}();\
 ${target_declare}
 			${call}
diff --git a/quickjs/quickjs_binder.cpp b/quickjs/quickjs_binder.cpp
index ae95eb8a..0a1348cd 100644
--- a/quickjs/quickjs_binder.cpp
+++ b/quickjs/quickjs_binder.cpp
@@ -1,7 +1,7 @@
 #include "quickjs_binder.h"
-#include "../ecmascript.h"
-#include "../ecmascript_instance.h"
-#include "../ecmascript_language.h"
+#include "../javascript.h"
+#include "../javascript_instance.h"
+#include "../javascript_language.h"
 #include "core/config/engine.h"
 #include "core/config/project_settings.h"
 #include "core/core_bind.h"
@@ -47,16 +47,16 @@ struct GodotMethodArguments {
 	}
 };
 
-_FORCE_INLINE_ static ECMAScriptGCHandler *BINDING_DATA_FROM_GD(Object *p_object) {
+_FORCE_INLINE_ static JavaScriptGCHandler *BINDING_DATA_FROM_GD(Object *p_object) {
 	ERR_FAIL_COND_V(p_object == NULL, NULL);
-	ECMAScriptLanguage *lang = ECMAScriptLanguage::get_singleton();
-	ECMAScriptGCHandler *bind = (ECMAScriptGCHandler *)(p_object)->get_instance_binding(lang, lang->get_instance_binding_callbacks());
+	JavaScriptLanguage *lang = JavaScriptLanguage::get_singleton();
+	JavaScriptGCHandler *bind = (JavaScriptGCHandler *)(p_object)->get_instance_binding(lang, lang->get_instance_binding_callbacks());
 	return bind;
 }
 
-_FORCE_INLINE_ static ECMAScriptGCHandler *BINDING_DATA_FROM_GD(JSContext *ctx, Object *p_object) {
+_FORCE_INLINE_ static JavaScriptGCHandler *BINDING_DATA_FROM_GD(JSContext *ctx, Object *p_object) {
 	ERR_FAIL_COND_V(p_object == NULL || ctx == NULL, NULL);
-	ECMAScriptGCHandler *bind = BINDING_DATA_FROM_GD(p_object);
+	JavaScriptGCHandler *bind = BINDING_DATA_FROM_GD(p_object);
 	if (bind) {
 		if (bind->context && bind->context != ctx) {
 			ERR_FAIL_V_MSG(NULL, "The object is not belong to this context");
@@ -91,8 +91,8 @@ JSValue QuickJSBinder::console_functions(JSContext *ctx, JSValue this_val, int a
 		}
 	}
 
-	ECMAScriptStackInfo stack_top;
-	List<ECMAScriptStackInfo> stacks;
+	JavaScriptStackInfo stack_top;
+	List<JavaScriptStackInfo> stacks;
 	String message = "";
 	for (int i = 0; i < argc; ++i) {
 		message += args[i];
@@ -149,7 +149,7 @@ void QuickJSBinder::add_global_properties() {
 }
 
 JSValue QuickJSBinder::object_method(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int method_id) {
-	ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 	ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "Call native method without native binding data"));
 	ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "Call native method without native object caller"));
 
@@ -191,7 +191,7 @@ JSValue QuickJSBinder::object_method(JSContext *ctx, JSValueConst this_val, int
 			break;
 	}
 	if (call_err.error != Callable::CallError::CALL_OK) {
-		List<ECMAScriptStackInfo> stacks;
+		List<JavaScriptStackInfo> stacks;
 		String stack_message;
 		if (binder->get_stacks(stacks) == OK) {
 			stack_message = binder->get_backtrace_message(stacks);
@@ -206,7 +206,7 @@ JSValue QuickJSBinder::object_method(JSContext *ctx, JSValueConst this_val, int
 }
 
 JSValue QuickJSBinder::object_indexed_property(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int property_id) {
-	ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 	ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "Using indexed property without native binding data"));
 	ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "Using indexed property without native object caller"));
 
@@ -243,11 +243,11 @@ JSValue QuickJSBinder::variant_to_var(JSContext *ctx, const Variant p_var) {
 			Object *obj = p_var;
 			if (obj == NULL)
 				return JS_NULL;
-			ECMAScriptGCHandler *data = BINDING_DATA_FROM_GD(ctx, obj);
+			JavaScriptGCHandler *data = BINDING_DATA_FROM_GD(ctx, obj);
 			ERR_FAIL_NULL_V(data, JS_UNDEFINED);
-			ERR_FAIL_NULL_V(data->ecma_object, JS_UNDEFINED);
+			ERR_FAIL_NULL_V(data->javascript_object, JS_UNDEFINED);
 			ERR_FAIL_COND_V(data->context != ctx, (JS_UNDEFINED));
-			JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, data->ecma_object);
+			JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, data->javascript_object);
 			JS_DupValue(ctx, js_obj);
 
 			return js_obj;
@@ -304,7 +304,7 @@ Variant QuickJSBinder::var_to_variant(JSContext *ctx, JSValue p_val) {
 					JS_FreeValue(ctx, val);
 				}
 				return arr;
-			} else if (ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, p_val)) { // Binding object
+			} else if (JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, p_val)) { // Binding object
 				ERR_FAIL_NULL_V(bind, Variant());
 				ERR_FAIL_NULL_V(bind->godot_object, Variant());
 				return bind->get_value();
@@ -399,13 +399,13 @@ bool QuickJSBinder::validate_type(JSContext *ctx, Variant::Type p_type, JSValueC
 		case Variant::ARRAY:
 			return JS_IsArray(ctx, p_val);
 		default: {
-			ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, p_val);
+			JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, p_val);
 			return bind != NULL && bind->type == p_type;
 		}
 	}
 }
 
-void QuickJSBinder::dump_exception(JSContext *ctx, const JSValue &p_exception, ECMAscriptScriptError *r_error) {
+void QuickJSBinder::dump_exception(JSContext *ctx, const JSValue &p_exception, JavaScriptError *r_error) {
 	JSValue err_file = JS_GetProperty(ctx, p_exception, JS_ATOM_fileName);
 	JSValue err_line = JS_GetProperty(ctx, p_exception, JS_ATOM_lineNumber);
 	JSValue err_msg = JS_GetProperty(ctx, p_exception, JS_ATOM_message);
@@ -423,7 +423,7 @@ void QuickJSBinder::dump_exception(JSContext *ctx, const JSValue &p_exception, E
 	JS_FreeValue(ctx, err_stack);
 }
 
-String QuickJSBinder::error_to_string(const ECMAscriptScriptError &p_error) {
+String QuickJSBinder::error_to_string(const JavaScriptError &p_error) {
 	String message = "JavaScript Error";
 	if (p_error.stack.size()) {
 		message += p_error.stack[0];
@@ -435,7 +435,7 @@ String QuickJSBinder::error_to_string(const ECMAscriptScriptError &p_error) {
 	return message;
 }
 
-Error QuickJSBinder::get_stacks(List<ECMAScriptStackInfo> &r_stacks) {
+Error QuickJSBinder::get_stacks(List<JavaScriptStackInfo> &r_stacks) {
 	JSValue error_constructor = JS_GetProperty(ctx, global_object, JS_ATOM_Error);
 	JSValue error = JS_CallConstructor(ctx, error_constructor, 0, NULL);
 	JSValue stack = JS_GetProperty(ctx, error, JS_ATOM_stack);
@@ -445,7 +445,7 @@ Error QuickJSBinder::get_stacks(List<ECMAScriptStackInfo> &r_stacks) {
 		String line_text = raw_stacks[i].strip_edges();
 		if (line_text.is_empty())
 			continue;
-		ECMAScriptStackInfo s;
+		JavaScriptStackInfo s;
 		int colon = line_text.rfind(":");
 		int bracket = line_text.rfind("(");
 		s.line = line_text.substr(colon + 1, line_text.length() - colon - 2).to_int();
@@ -459,9 +459,9 @@ Error QuickJSBinder::get_stacks(List<ECMAScriptStackInfo> &r_stacks) {
 	return OK;
 }
 
-String QuickJSBinder::get_backtrace_message(const List<ECMAScriptStackInfo> &stacks) {
+String QuickJSBinder::get_backtrace_message(const List<JavaScriptStackInfo> &stacks) {
 	String message;
-	for (const List<ECMAScriptStackInfo>::Element *E = stacks.front(); E; E = E->next()) {
+	for (const List<JavaScriptStackInfo>::Element *E = stacks.front(); E; E = E->next()) {
 		message += "  ";
 		message += vformat("at %s (%s:%d)", E->get().function, E->get().file, E->get().line);
 		if (E != stacks.back()) {
@@ -547,7 +547,7 @@ JSValue QuickJSBinder::godot_instance_from_id(JSContext *ctx, JSValue this_val,
 	return variant_to_var(ctx, obj);
 }
 
-void QuickJSBinder::add_debug_binding_info(JSContext *ctx, JSValueConst p_obj, const ECMAScriptGCHandler *p_bind) {
+void QuickJSBinder::add_debug_binding_info(JSContext *ctx, JSValueConst p_obj, const JavaScriptGCHandler *p_bind) {
 	if (!p_bind)
 		return;
 	JSValue classname = JS_UNDEFINED;
@@ -594,7 +594,7 @@ String QuickJSBinder::resolve_module_file(const String &file) {
 	// add extensions to try
 	String extension = file.get_extension();
 	List<String> extensions;
-	ECMAScriptLanguage::get_singleton()->get_recognized_extensions(&extensions);
+	JavaScriptLanguage::get_singleton()->get_recognized_extensions(&extensions);
 	if (extensions.find(extension) == NULL) {
 		for (List<String>::Element *E = extensions.front(); E; E = E->next()) {
 			path = file + "." + E->get();
@@ -631,20 +631,20 @@ JSModuleDef *QuickJSBinder::js_module_loader(JSContext *ctx, const char *module_
 
 	if (!m) {
 		List<String> extensions;
-		ECMAScriptLanguage::get_singleton()->get_recognized_extensions(&extensions);
+		JavaScriptLanguage::get_singleton()->get_recognized_extensions(&extensions);
 		if (extensions.find(file.get_extension()) != NULL) {
-			Ref<ECMAScriptModule> em = ResourceFormatLoaderECMAScriptModule::load_static(file, "", &err);
+			Ref<JavaScriptModule> em = ResourceFormatLoaderJavaScriptModule::load_static(file, "", &err);
 			if (err != OK || !em.is_valid()) {
 				JS_ThrowReferenceError(ctx, "Could not load module '%s'", file.utf8().get_data());
 				return NULL;
 			}
-			ECMAscriptScriptError es_err;
+			JavaScriptError es_err;
 
 			const Vector<uint8_t> &bytecode = em->get_bytecode();
 			if (bytecode.size()) {
-				ECMAScriptGCHandler ecma;
-				if (binder->load_bytecode(bytecode, file, &ecma) == OK) {
-					m = static_cast<JSModuleDef *>(ecma.ecma_object);
+				JavaScriptGCHandler js;
+				if (binder->load_bytecode(bytecode, file, &js) == OK) {
+					m = static_cast<JSModuleDef *>(js.javascript_object);
 				}
 			} else {
 				String code = em->get_source_code();
@@ -692,7 +692,7 @@ JSModuleDef *QuickJSBinder::js_make_module(JSContext *ctx, const String &p_id, c
 	return m;
 }
 
-QuickJSBinder::ModuleCache QuickJSBinder::js_compile_module(JSContext *ctx, const String &p_code, const String &p_filename, ECMAscriptScriptError *r_error) {
+QuickJSBinder::ModuleCache QuickJSBinder::js_compile_module(JSContext *ctx, const String &p_code, const String &p_filename, JavaScriptError *r_error) {
 	if (NULL != compiling_modules.find(p_filename)) {
 		String chain;
 		for (List<String>::Element *E = compiling_modules.front(); E; E = E->next()) {
@@ -731,7 +731,7 @@ QuickJSBinder::ModuleCache QuickJSBinder::js_compile_module(JSContext *ctx, cons
 	return module;
 }
 
-QuickJSBinder::ModuleCache *QuickJSBinder::js_compile_and_cache_module(JSContext *ctx, const String &p_code, const String &p_filename, ECMAscriptScriptError *r_error) {
+QuickJSBinder::ModuleCache *QuickJSBinder::js_compile_and_cache_module(JSContext *ctx, const String &p_code, const String &p_filename, JavaScriptError *r_error) {
 	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
 	ModuleCache *last_module = binder->module_cache.getptr(p_filename);
 	if (last_module) {
@@ -762,16 +762,16 @@ QuickJSBinder::ModuleCache *QuickJSBinder::js_compile_and_cache_module(JSContext
 	return binder->module_cache.getptr(p_filename);
 }
 
-QuickJSBinder::ModuleCache *QuickJSBinder::js_compile_and_cache_module(JSContext *ctx, const Vector<uint8_t> &p_bytecode, const String &p_filename, ECMAscriptScriptError *r_error) {
+QuickJSBinder::ModuleCache *QuickJSBinder::js_compile_and_cache_module(JSContext *ctx, const Vector<uint8_t> &p_bytecode, const String &p_filename, JavaScriptError *r_error) {
 	QuickJSBinder *binder = get_context_binder(ctx);
-	ECMAScriptGCHandler module;
+	JavaScriptGCHandler module;
 	if (OK == binder->load_bytecode(p_bytecode, p_filename, &module)) {
 		return module_cache.getptr(p_filename);
 	}
 	return NULL;
 }
 
-Error QuickJSBinder::js_evalute_module(JSContext *ctx, QuickJSBinder::ModuleCache *p_module, ECMAscriptScriptError *r_error) {
+Error QuickJSBinder::js_evalute_module(JSContext *ctx, QuickJSBinder::ModuleCache *p_module, JavaScriptError *r_error) {
 	if (p_module->flags & MODULE_FLAG_EVALUATED)
 		return OK;
 
@@ -1024,11 +1024,11 @@ void QuickJSBinder::add_godot_globals() {
 		const ClassBindData *cls = *cls_ptr;
 
 		JSValue obj = JS_NewObjectProtoClass(ctx, cls->prototype, get_origin_class_id());
-		ECMAScriptGCHandler *data = new_gc_handler(ctx);
-		data->ecma_object = JS_VALUE_GET_PTR(obj);
+		JavaScriptGCHandler *data = new_gc_handler(ctx);
+		data->javascript_object = JS_VALUE_GET_PTR(obj);
 		data->godot_object = s.ptr;
 		data->type = Variant::OBJECT;
-		data->flags = ECMAScriptGCHandler::FLAG_OBJECT;
+		data->flags = JavaScriptGCHandler::FLAG_OBJECT;
 		JS_SetOpaque(obj, data);
 
 		JSAtom singleton_name = get_atom(ctx, s.name);
@@ -1213,7 +1213,7 @@ void QuickJSBinder::initialize() {
 	thread_id = Thread::get_caller_id();
 	{
 		GLOBAL_LOCK_FUNCTION
-		ECMAScriptLanguage::get_singleton()->thread_binder_map.insert(thread_id, this);
+		JavaScriptLanguage::get_singleton()->thread_binder_map.insert(thread_id, this);
 	}
 
 	// create runtime and context for the binder
@@ -1233,7 +1233,7 @@ void QuickJSBinder::initialize() {
 	// global.godot
 	godot_object = JS_NewObject(ctx);
 	js_key_godot_classid = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("native_class"));
-	js_key_godot_classname = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("ecma_class"));
+	js_key_godot_classname = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("js_class"));
 	js_key_godot_exports = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("exports"));
 	js_key_godot_signals = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("signals"));
 	js_key_godot_tooled = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("tool"));
@@ -1255,10 +1255,10 @@ void QuickJSBinder::initialize() {
 	add_global_console();
 	// binding script
 	String script_binding_error;
-	ECMAScriptGCHandler eval_ret;
-	if (OK == safe_eval_text(ECMAScriptBinder::BINDING_SCRIPT_CONTENT, ECMAScriptBinder::EVAL_TYPE_GLOBAL, "<internal: binding_script.js>", script_binding_error, eval_ret)) {
-		if (eval_ret.ecma_object) {
-			JSValue ret = JS_MKPTR(JS_TAG_OBJECT, eval_ret.ecma_object);
+	JavaScriptGCHandler eval_ret;
+	if (OK == safe_eval_text(JavaScriptBinder::BINDING_SCRIPT_CONTENT, JavaScriptBinder::EVAL_TYPE_GLOBAL, "<internal: binding_script.js>", script_binding_error, eval_ret)) {
+		if (eval_ret.javascript_object) {
+			JSValue ret = JS_MKPTR(JS_TAG_OBJECT, eval_ret.javascript_object);
 			modified_api = var_to_variant(ctx, ret);
 			JS_FreeValue(ctx, ret);
 		}
@@ -1322,7 +1322,7 @@ void QuickJSBinder::uninitialize() {
 
 	// Free singletons
 	for (int i = 0; i < godot_singletons.size(); i++) {
-		ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, godot_singletons[i]);
+		JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, godot_singletons[i]);
 		if (bind) {
 			memdelete(bind);
 			JS_SetOpaque(godot_singletons[i], NULL);
@@ -1331,16 +1331,16 @@ void QuickJSBinder::uninitialize() {
 	}
 
 	// Free registered js classes
-	for (const KeyValue<String, ECMAClassInfo> &pair : ecma_classes) {
-		const ECMAClassInfo &ecma_class = pair.value;
-		free_ecmas_class(ecma_class);
+	for (const KeyValue<String, JavaScriptClassInfo> &pair : javascript_classes) {
+		const JavaScriptClassInfo &js_class = pair.value;
+		free_javascript_class(js_class);
 	}
-	ecma_classes.clear();
+	javascript_classes.clear();
 
 	// Free frame callbacks
-	for (const KeyValue<int64_t, ECMAScriptGCHandler> &pair : frame_callbacks) {
-		const ECMAScriptGCHandler &func = pair.value;
-		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.ecma_object);
+	for (const KeyValue<int64_t, JavaScriptGCHandler> &pair : frame_callbacks) {
+		const JavaScriptGCHandler &func = pair.value;
+		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.javascript_object);
 		JS_FreeValue(ctx, js_func);
 	}
 	frame_callbacks.clear();
@@ -1400,7 +1400,7 @@ void QuickJSBinder::uninitialize() {
 
 	{
 		GLOBAL_LOCK_FUNCTION
-		ECMAScriptLanguage::get_singleton()->thread_binder_map.erase(thread_id);
+		JavaScriptLanguage::get_singleton()->thread_binder_map.erase(thread_id);
 	}
 }
 
@@ -1415,7 +1415,7 @@ void QuickJSBinder::frame() {
 		int err = JS_ExecutePendingJob(JS_GetRuntime(ctx), &ctx1);
 		if (err <= 0) {
 			if (err < 0) {
-				ECMAscriptScriptError script_err;
+				JavaScriptError script_err;
 				JSValue e = JS_GetException(ctx1);
 				dump_exception(ctx1, e, &script_err);
 				ERR_PRINT(error_to_string(script_err));
@@ -1425,33 +1425,33 @@ void QuickJSBinder::frame() {
 		}
 	}
 
-	for (List<ECMAScriptGCHandler *>::Element *E = workers.front(); E; E = E->next()) {
-		ECMAScriptGCHandler *bind = E->get();
+	for (List<JavaScriptGCHandler *>::Element *E = workers.front(); E; E = E->next()) {
+		JavaScriptGCHandler *bind = E->get();
 		QuickJSWorker *worker = static_cast<QuickJSWorker *>(bind->native_ptr);
-		JSValue object = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
+		JSValue object = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
 		worker->frame_of_host(this, object);
 	}
 
-	for (const KeyValue<int64_t, ECMAScriptGCHandler> &pair : frame_callbacks) {
+	for (const KeyValue<int64_t, JavaScriptGCHandler> &pair : frame_callbacks) {
 		if (canceled_frame_callbacks.has(pair.key))
 			continue;
-		const ECMAScriptGCHandler &func = pair.value;
-		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.ecma_object);
+		const JavaScriptGCHandler &func = pair.value;
+		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.javascript_object);
 		double timestamp = OS::get_singleton()->get_ticks_usec() / 1000.0;
 		JSValue argv[] = { JS_NewFloat64(ctx, timestamp) };
 		JSValue ret = JS_Call(ctx, js_func, global_object, 1, argv);
 		JS_FreeValue(ctx, argv[0]);
 		if (JS_IsException(ret)) {
 			JSValue e = JS_GetException(ctx);
-			ECMAscriptScriptError err;
+			JavaScriptError err;
 			dump_exception(ctx, e, &err);
 			ERR_PRINT("Error in requestAnimationFrame:" ENDL + error_to_string(err));
 			JS_FreeValue(ctx, e);
 		}
 	}
-	for (const KeyValue<int64_t, ECMAScriptGCHandler> &pair : frame_callbacks) {
-		const ECMAScriptGCHandler &func = pair.value;
-		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.ecma_object);
+	for (const KeyValue<int64_t, JavaScriptGCHandler> &pair : frame_callbacks) {
+		const JavaScriptGCHandler &func = pair.value;
+		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.javascript_object);
 		JS_FreeValue(ctx, js_func);
 	}
 	frame_callbacks.clear();
@@ -1462,7 +1462,7 @@ void QuickJSBinder::frame() {
 #endif
 }
 
-Error QuickJSBinder::eval_string(const String &p_source, EvalType type, const String &p_path, ECMAScriptGCHandler &r_ret) {
+Error QuickJSBinder::eval_string(const String &p_source, EvalType type, const String &p_path, JavaScriptGCHandler &r_ret) {
 	String error;
 	Error err = safe_eval_text(p_source, type, p_path, error, r_ret);
 	if (err != OK && !error.is_empty()) {
@@ -1471,23 +1471,23 @@ Error QuickJSBinder::eval_string(const String &p_source, EvalType type, const St
 	return err;
 }
 
-Error QuickJSBinder::safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, ECMAScriptGCHandler &r_ret) {
+Error QuickJSBinder::safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, JavaScriptGCHandler &r_ret) {
 	ERR_FAIL_COND_V(p_source.is_empty(), FAILED);
 	CharString utf8_str = p_source.utf8();
 	const char *filename = p_path.utf8().get_data();
 	const char *code = utf8_str.get_data();
 	int flags = JS_EVAL_FLAG_STRICT;
-	if (type == ECMAScriptBinder::EVAL_TYPE_MODULE) {
+	if (type == JavaScriptBinder::EVAL_TYPE_MODULE) {
 		flags |= JS_EVAL_TYPE_MODULE;
 	} else {
 		flags |= JS_EVAL_TYPE_GLOBAL;
 	}
 	JSValue ret = JS_Eval(ctx, code, utf8_str.length(), filename, flags);
 	r_ret.context = ctx;
-	r_ret.ecma_object = JS_VALUE_GET_PTR(ret);
+	r_ret.javascript_object = JS_VALUE_GET_PTR(ret);
 	if (JS_IsException(ret)) {
 		JSValue e = JS_GetException(ctx);
-		ECMAscriptScriptError err;
+		JavaScriptError err;
 		dump_exception(ctx, e, &err);
 		r_error = error_to_string(err);
 		JS_Throw(ctx, e);
@@ -1496,7 +1496,7 @@ Error QuickJSBinder::safe_eval_text(const String &p_source, EvalType type, const
 	return OK;
 }
 Error QuickJSBinder::compile_to_bytecode(const String &p_code, const String &p_file, Vector<uint8_t> &r_bytecode) {
-	ECMAscriptScriptError script_err;
+	JavaScriptError script_err;
 	ModuleCache mc = js_compile_module(ctx, p_code, p_file, &script_err);
 	if (mc.module) {
 		JSValue module = JS_MKPTR(JS_TAG_MODULE, mc.module);
@@ -1515,11 +1515,11 @@ Error QuickJSBinder::compile_to_bytecode(const String &p_code, const String &p_f
 	return OK;
 }
 
-Error QuickJSBinder::load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, ECMAScriptGCHandler *r_module) {
+Error QuickJSBinder::load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, JavaScriptGCHandler *r_module) {
 	Variant bytes = p_bytecode;
 	if (ModuleCache *ptr = module_cache.getptr(p_file)) {
 		if (bytes.hash() == ptr->hash) {
-			r_module->ecma_object = ptr->module;
+			r_module->javascript_object = ptr->module;
 			return OK;
 		}
 	}
@@ -1527,7 +1527,7 @@ Error QuickJSBinder::load_bytecode(const Vector<uint8_t> &p_bytecode, const Stri
 	JSValue value = JS_ReadObject(ctx, p_bytecode.ptr(), p_bytecode.size(), JS_READ_OBJ_BYTECODE | JS_READ_OBJ_REFERENCE | JS_READ_OBJ_SAB | JS_READ_OBJ_ROM_DATA);
 	ERR_FAIL_COND_V(JS_VALUE_GET_TAG(value) != JS_TAG_MODULE, ERR_PARSE_ERROR);
 	void *ptr = JS_VALUE_GET_PTR(value);
-	r_module->ecma_object = ptr;
+	r_module->javascript_object = ptr;
 
 	ModuleCache mc;
 	mc.flags = MODULE_FLAG_SCRIPT;
@@ -1537,7 +1537,7 @@ Error QuickJSBinder::load_bytecode(const Vector<uint8_t> &p_bytecode, const Stri
 
 	if (JS_ResolveModule(ctx, value) < 0) {
 		JSValue e = JS_GetException(ctx);
-		ECMAscriptScriptError err;
+		JavaScriptError err;
 		dump_exception(ctx, e, &err);
 		JS_Throw(ctx, e);
 		ERR_FAIL_V_MSG(ERR_PARSE_ERROR, error_to_string(err));
@@ -1547,23 +1547,23 @@ Error QuickJSBinder::load_bytecode(const Vector<uint8_t> &p_bytecode, const Stri
 
 /************************* Memory Management ******************************/
 
-ECMAScriptGCHandler *QuickJSBinder::alloc_object_binding_data(Object *p_object) {
-	ECMAScriptGCHandler *data = new_gc_handler(nullptr);
+JavaScriptGCHandler *QuickJSBinder::alloc_object_binding_data(Object *p_object) {
+	JavaScriptGCHandler *data = new_gc_handler(nullptr);
 	bind_gc_object(ctx, data, p_object);
 	return data;
 }
 
-void QuickJSBinder::free_object_binding_data(ECMAScriptGCHandler *p_gc_handle) {
-	ECMAScriptGCHandler *bind = (ECMAScriptGCHandler *)p_gc_handle;
+void QuickJSBinder::free_object_binding_data(JavaScriptGCHandler *p_gc_handle) {
+	JavaScriptGCHandler *bind = (JavaScriptGCHandler *)p_gc_handle;
 	if (!bind->is_ref_counted()) {
-		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
+		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
 		JS_SetOpaque(js_obj, NULL);
 		JS_FreeValue((JSContext *)bind->context, js_obj);
 	}
 	memdelete(bind);
 }
 
-Error QuickJSBinder::bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, Object *p_object) {
+Error QuickJSBinder::bind_gc_object(JSContext *ctx, JavaScriptGCHandler *data, Object *p_object) {
 	QuickJSBinder *binder = get_context_binder(ctx);
 	const ClassBindData **bind_ptr = binder->classname_bindings.getptr(p_object->get_class_name());
 	if (!bind_ptr)
@@ -1576,14 +1576,14 @@ Error QuickJSBinder::bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, O
 	}
 	if (bind_ptr) {
 		JSValue obj = JS_NewObjectProtoClass(ctx, (*bind_ptr)->prototype, binder->get_origin_class_id());
-		data->ecma_object = JS_VALUE_GET_PTR(obj);
+		data->javascript_object = JS_VALUE_GET_PTR(obj);
 		data->context = ctx;
 		data->godot_object = p_object;
 		data->type = Variant::OBJECT;
-		data->flags = ECMAScriptGCHandler::FLAG_OBJECT;
+		data->flags = JavaScriptGCHandler::FLAG_OBJECT;
 		if (p_object->is_ref_counted()) {
 			if (static_cast<RefCounted *>(p_object)->init_ref()) {
-				data->flags |= ECMAScriptGCHandler::FLAG_REF_COUNTED;
+				data->flags |= JavaScriptGCHandler::FLAG_REF_COUNTED;
 			}
 		}
 		JS_SetOpaque(obj, data);
@@ -1596,16 +1596,16 @@ Error QuickJSBinder::bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, O
 	return FAILED;
 }
 
-void QuickJSBinder::godot_refcount_incremented(ECMAScriptGCHandler *bind) {
-	if (bind->is_valid_ecma_object()) {
-		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
+void QuickJSBinder::godot_refcount_incremented(JavaScriptGCHandler *bind) {
+	if (bind->is_valid_javascript_object()) {
+		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
 		JS_DupValue((JSContext *)bind->context, js_obj);
 	}
 }
 
-bool QuickJSBinder::godot_refcount_decremented(ECMAScriptGCHandler *bind) {
-	if (bind->is_valid_ecma_object()) {
-		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
+bool QuickJSBinder::godot_refcount_decremented(JavaScriptGCHandler *bind) {
+	if (bind->is_valid_javascript_object()) {
+		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
 		JS_FreeValue((JSContext *)bind->context, js_obj);
 		return bind->is_finalized();
 	} else {
@@ -1616,17 +1616,17 @@ bool QuickJSBinder::godot_refcount_decremented(ECMAScriptGCHandler *bind) {
 JSValue QuickJSBinder::object_constructor(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv, int class_id) {
 	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
 	const ClassBindData &cls = binder->class_bindings.get(class_id);
-	ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, new_target);
+	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, new_target);
 	JSValue js_obj;
 	if (bind) {
 		js_obj = new_target;
 	} else {
 		Object *gd_obj = cls.gdclass->creation_func();
-		ECMAScriptLanguage *lang = ECMAScriptLanguage::get_singleton();
+		JavaScriptLanguage *lang = JavaScriptLanguage::get_singleton();
 		bind = new_gc_handler(ctx);
 		bind_gc_object(ctx, bind, gd_obj);
 		gd_obj->set_instance_binding(lang, bind, lang->get_instance_binding_callbacks());
-		js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
+		js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
 
 		if (JS_IsFunction(ctx, new_target)) {
 			JSValue prototype = JS_GetProperty(ctx, new_target, QuickJSBinder::JS_ATOM_prototype);
@@ -1636,22 +1636,22 @@ JSValue QuickJSBinder::object_constructor(JSContext *ctx, JSValueConst new_targe
 
 #if 0
 		// Make script and script instance for the object
-		ECMAScriptInstance *si = memnew(ECMAScriptInstance);
-		si->ecma_object = *bind;
+		JavaScriptInstance *si = memnew(JavaScriptInstance);
+		si->javascript_object = *bind;
 		si->binder = binder;
 		si->owner = gd_obj;
-		JSValue es_class_name = JS_GetProperty(ctx, js_obj, binder->js_key_godot_classname);
-		if (JS_IsString(es_class_name)) {
-			if (ECMAClassInfo *es_class = binder->ecma_classes.getptr(js_to_string(ctx, es_class_name))) {
+		JSValue js_class_name = JS_GetProperty(ctx, js_obj, binder->js_key_godot_classname);
+		if (JS_IsString(js_class_name)) {
+			if (JavaScriptClassInfo *js_class = binder->javascript_classes.getptr(js_to_string(ctx, js_class_name))) {
 				si->script.instantiate();
-				si->script->ecma_class = es_class;
+				si->script->javascript_class = js_class;
 				si->script->instances.insert(gd_obj);
-				si->script->ecma_class = es_class;
-				si->ecma_class = es_class;
-				initialize_properties(ctx, es_class, js_obj);
+				si->script->javascript_class = js_class;
+				si->javascript_class = js_class;
+				initialize_properties(ctx, js_class, js_obj);
 			}
 		}
-		JS_FreeValue(ctx, es_class_name);
+		JS_FreeValue(ctx, js_class_name);
 		gd_obj->set_script_instance(si);
 #endif
 		if (!bind->is_ref_counted()) { // Object need to be freed manually
@@ -1661,14 +1661,14 @@ JSValue QuickJSBinder::object_constructor(JSContext *ctx, JSValueConst new_targe
 	return js_obj;
 }
 
-void QuickJSBinder::initialize_properties(JSContext *ctx, const ECMAClassInfo *p_class, JSValue p_object) {
+void QuickJSBinder::initialize_properties(JSContext *ctx, const JavaScriptClassInfo *p_class, JSValue p_object) {
 	QuickJSBinder *binder = get_context_binder(ctx);
-	for (const KeyValue<StringName, ECMAProperyInfo> &pair : p_class->properties) {
+	for (const KeyValue<StringName, JavaScriptProperyInfo> &pair : p_class->properties) {
 		JSAtom pname = get_atom(ctx, pair.key);
 		int ret = JS_SetProperty(ctx, p_object, pname, variant_to_var(ctx, pair.value.default_value));
 		if (ret < 0) {
 			JSValue e = JS_GetException(ctx);
-			ECMAscriptScriptError error;
+			JavaScriptError error;
 			dump_exception(ctx, e, &error);
 			JS_FreeValue(ctx, e);
 			ERR_PRINT(vformat("Cannot initialize property '%s' of class '%s'\n%s", pair.key, p_class->class_name, binder->error_to_string(error)));
@@ -1677,8 +1677,8 @@ void QuickJSBinder::initialize_properties(JSContext *ctx, const ECMAClassInfo *p
 	}
 }
 
-void QuickJSBinder::object_finalizer(ECMAScriptGCHandler *p_bind) {
-	p_bind->flags ^= ECMAScriptGCHandler::FLAG_OBJECT;
+void QuickJSBinder::object_finalizer(JavaScriptGCHandler *p_bind) {
+	p_bind->flags ^= JavaScriptGCHandler::FLAG_OBJECT;
 	if (p_bind->godot_object->is_ref_counted()) {
 		RefCounted *ref = static_cast<RefCounted *>(p_bind->godot_object);
 		if (ref->unreference()) {
@@ -1689,9 +1689,9 @@ void QuickJSBinder::object_finalizer(ECMAScriptGCHandler *p_bind) {
 
 void QuickJSBinder::origin_finalizer(JSRuntime *rt, JSValue val) {
 	QuickJSBinder *binder = get_runtime_binder(rt);
-	ECMAScriptGCHandler *bind = static_cast<ECMAScriptGCHandler *>(JS_GetOpaque(val, binder->godot_origin_class.class_id));
+	JavaScriptGCHandler *bind = static_cast<JavaScriptGCHandler *>(JS_GetOpaque(val, binder->godot_origin_class.class_id));
 	if (bind) {
-		bind->flags |= ECMAScriptGCHandler::FLAG_FINALIZED;
+		bind->flags |= JavaScriptGCHandler::FLAG_FINALIZED;
 		if (bind->type == Variant::OBJECT) {
 			object_finalizer(bind);
 		} else {
@@ -1702,7 +1702,7 @@ void QuickJSBinder::origin_finalizer(JSRuntime *rt, JSValue val) {
 }
 
 JSValue QuickJSBinder::object_free(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-	ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 	ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "The object already be freed"));
 	ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "The object already be freed"));
 	ERR_FAIL_COND_V(bind->godot_object->is_ref_counted(), JS_ThrowReferenceError(ctx, "Call free to RefCounted object is not allowed"));
@@ -1716,7 +1716,7 @@ JSValue QuickJSBinder::object_free(JSContext *ctx, JSValue this_val, int argc, J
 
 /********************************* Script --> C++ ****************************/
 JSValue QuickJSBinder::godot_register_class(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-	ERR_FAIL_COND_V(argc < 1 || !JS_IsFunction(ctx, argv[0]), JS_ThrowTypeError(ctx, "ECMAClass class function expected"));
+	ERR_FAIL_COND_V(argc < 1 || !JS_IsFunction(ctx, argv[0]), JS_ThrowTypeError(ctx, "Godot class expected"));
 	QuickJSBinder *binder = get_context_binder(ctx);
 	String class_name;
 #if NO_MODULE_EXPORT_SUPPORT
@@ -1731,11 +1731,11 @@ JSValue QuickJSBinder::godot_register_class(JSContext *ctx, JSValueConst this_va
 			JS_FreeValue(ctx, name);
 		}
 	}
-	binder->register_ecma_class(argv[0], class_name);
+	binder->register_javascript_class(argv[0], class_name);
 	return JS_UNDEFINED;
 }
 
-const ECMAClassInfo *QuickJSBinder::register_ecma_class(const JSValue &p_constructor, const String &p_path) {
+const JavaScriptClassInfo *QuickJSBinder::register_javascript_class(const JSValue &p_constructor, const String &p_path) {
 	QuickJSBinder *binder = get_context_binder(ctx);
 	JSValue prototype = JS_UNDEFINED;
 	JSValue classid = JS_UNDEFINED;
@@ -1744,7 +1744,7 @@ const ECMAClassInfo *QuickJSBinder::register_ecma_class(const JSValue &p_constru
 	JSClassID id = 0;
 
 	if (!JS_IsFunction(ctx, p_constructor)) {
-		JS_ThrowTypeError(ctx, "ECMAClass class expected: %s", p_path.utf8().get_data());
+		JS_ThrowTypeError(ctx, "Godot class expected: %s", p_path.utf8().get_data());
 		goto fail;
 	}
 
@@ -1754,7 +1754,7 @@ const ECMAClassInfo *QuickJSBinder::register_ecma_class(const JSValue &p_constru
 	icon = JS_GetProperty(ctx, p_constructor, js_key_godot_icon_path);
 
 	if (JS_IsUndefined(classid)) {
-		JS_ThrowTypeError(ctx, "ECMAClass class expected: %s", p_path.utf8().get_data());
+		JS_ThrowTypeError(ctx, "Godot class expected: %s", p_path.utf8().get_data());
 		goto fail;
 	}
 
@@ -1767,18 +1767,18 @@ const ECMAClassInfo *QuickJSBinder::register_ecma_class(const JSValue &p_constru
 		StringName class_name = js_to_string(ctx, name);
 		JS_FreeValue(ctx, name);
 
-		ECMAClassInfo ecma_class;
-		ecma_class.icon_path = "";
-		ecma_class.tool = false;
-		ecma_class.native_class = bind->gdclass;
-		ecma_class.class_name = class_name;
-		ecma_class.prototype.context = ctx;
-		ecma_class.prototype.ecma_object = JS_VALUE_GET_PTR(prototype);
-		ecma_class.constructor.context = ctx;
-		ecma_class.constructor.ecma_object = JS_VALUE_GET_PTR(p_constructor);
-		ecma_class.tool = JS_ToBool(ctx, tooled);
+		JavaScriptClassInfo js_class;
+		js_class.icon_path = "";
+		js_class.tool = false;
+		js_class.native_class = bind->gdclass;
+		js_class.class_name = class_name;
+		js_class.prototype.context = ctx;
+		js_class.prototype.javascript_object = JS_VALUE_GET_PTR(prototype);
+		js_class.constructor.context = ctx;
+		js_class.constructor.javascript_object = JS_VALUE_GET_PTR(p_constructor);
+		js_class.tool = JS_ToBool(ctx, tooled);
 		if (JS_IsString(icon)) {
-			ecma_class.icon_path = js_to_string(ctx, icon);
+			js_class.icon_path = js_to_string(ctx, icon);
 		}
 
 		// signals
@@ -1789,7 +1789,7 @@ const ECMAClassInfo *QuickJSBinder::register_ecma_class(const JSValue &p_constru
 			for (const String &key : keys) {
 				MethodInfo mi;
 				mi.name = key;
-				ecma_class.signals.insert(mi.name, mi);
+				js_class.signals.insert(mi.name, mi);
 			}
 		}
 		JS_FreeValue(ctx, signals);
@@ -1800,7 +1800,7 @@ const ECMAClassInfo *QuickJSBinder::register_ecma_class(const JSValue &p_constru
 			HashSet<String> keys;
 			get_own_property_names(ctx, props, &keys);
 			for (const String &key : keys) {
-				ECMAProperyInfo ei;
+				JavaScriptProperyInfo ei;
 				ei.name = key;
 				ei.type = Variant::NIL;
 				ei.hint = PropertyHint::PROPERTY_HINT_NONE;
@@ -1852,7 +1852,7 @@ const ECMAClassInfo *QuickJSBinder::register_ecma_class(const JSValue &p_constru
 					ei.type = ei.default_value.get_type();
 				}
 				JS_FreeAtom(ctx, pname);
-				ecma_class.properties.insert(key, ei);
+				js_class.properties.insert(key, ei);
 				JS_FreeValue(ctx, js_prop);
 			}
 		}
@@ -1867,17 +1867,17 @@ const ECMAClassInfo *QuickJSBinder::register_ecma_class(const JSValue &p_constru
 			if (JS_IsFunction(ctx, value)) {
 				MethodInfo mi;
 				mi.name = E;
-				ecma_class.methods.insert(E, mi);
+				js_class.methods.insert(E, mi);
 			}
 			JS_FreeValue(ctx, value);
 			JS_FreeAtom(ctx, key);
 		}
 
 		// cache the class
-		if (const ECMAClassInfo *ptr = binder->ecma_classes.getptr(p_path)) {
-			binder->free_ecmas_class(*ptr);
+		if (const JavaScriptClassInfo *ptr = binder->javascript_classes.getptr(p_path)) {
+			binder->free_javascript_class(*ptr);
 		}
-		binder->ecma_classes.insert(p_path, ecma_class);
+		binder->javascript_classes.insert(p_path, js_class);
 		JS_DefinePropertyValue(ctx, prototype, js_key_godot_classname, to_js_string(ctx, p_path), PROP_DEF_DEFAULT);
 	}
 fail:
@@ -1885,17 +1885,17 @@ const ECMAClassInfo *QuickJSBinder::register_ecma_class(const JSValue &p_constru
 	JS_FreeValue(ctx, prototype);
 	JS_FreeValue(ctx, icon);
 	JS_FreeValue(ctx, tooled);
-	return binder->ecma_classes.getptr(p_path);
+	return binder->javascript_classes.getptr(p_path);
 }
 
-void QuickJSBinder::free_ecmas_class(const ECMAClassInfo &p_class) {
-	JSValue class_func = JS_MKPTR(JS_TAG_OBJECT, p_class.constructor.ecma_object);
+void QuickJSBinder::free_javascript_class(const JavaScriptClassInfo &p_class) {
+	JSValue class_func = JS_MKPTR(JS_TAG_OBJECT, p_class.constructor.javascript_object);
 	JS_FreeValue(ctx, class_func);
 }
 
 JSValue QuickJSBinder::godot_register_signal(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
 	ERR_FAIL_COND_V(argc < 2, JS_ThrowTypeError(ctx, "Two or more arguments expected"));
-	ERR_FAIL_COND_V(!JS_IsObject(argv[0]), JS_ThrowTypeError(ctx, "protorype of ECMAClass function expected for agurment 0"));
+	ERR_FAIL_COND_V(!JS_IsObject(argv[0]), JS_ThrowTypeError(ctx, "protorype of Godot function expected for agurment 0"));
 	ERR_FAIL_COND_V(!JS_IsString(argv[1]), JS_ThrowTypeError(ctx, "string expected for agurment 1"));
 	QuickJSBinder *binder = get_context_binder(ctx);
 
@@ -1922,7 +1922,7 @@ JSValue QuickJSBinder::godot_register_signal(JSContext *ctx, JSValue this_val, i
 
 JSValue QuickJSBinder::godot_register_property(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
 	ERR_FAIL_COND_V(argc < 3, JS_ThrowTypeError(ctx, "Three or more arguments expected"));
-	ERR_FAIL_COND_V(!JS_IsObject(argv[0]), JS_ThrowTypeError(ctx, "protorype of ECMAClass function expected for agurment 0"));
+	ERR_FAIL_COND_V(!JS_IsObject(argv[0]), JS_ThrowTypeError(ctx, "protorype of Godot class function expected for agurment 0"));
 	ERR_FAIL_COND_V(!JS_IsString(argv[1]), JS_ThrowTypeError(ctx, "string expected for agurment 1"));
 
 	QuickJSBinder *binder = get_context_binder(ctx);
@@ -1952,7 +1952,7 @@ Error QuickJSBinder::define_operators(JSContext *ctx, JSValue p_prototype, JSVal
 	QuickJSBinder *binder = get_context_binder(ctx);
 	JSValue operators = JS_Call(ctx, binder->js_operators_create, binder->js_operators, p_size, p_operators);
 	if (JS_IsException(operators)) {
-		ECMAscriptScriptError error;
+		JavaScriptError error;
 		JSValue e = JS_GetException(ctx);
 		dump_exception(ctx, e, &error);
 		JS_FreeValue(ctx, e);
@@ -1983,8 +1983,8 @@ JSValue QuickJSBinder::global_request_animation_frame(JSContext *ctx, JSValue th
 	ERR_FAIL_COND_V(argc < 1 || !JS_IsFunction(ctx, argv[0]), JS_ThrowTypeError(ctx, "Function expected for argument #0"));
 	static SafeNumeric<int64_t> id;
 	JSValue js_func = JS_DupValue(ctx, argv[0]);
-	ECMAScriptGCHandler func;
-	func.ecma_object = JS_VALUE_GET_PTR(js_func);
+	JavaScriptGCHandler func;
+	func.javascript_object = JS_VALUE_GET_PTR(js_func);
 	QuickJSBinder *binder = get_context_binder(ctx);
 	int64_t value = id.increment();
 	binder->frame_callbacks.insert(value, func);
@@ -2023,29 +2023,29 @@ void QuickJSBinder::get_own_property_names(JSContext *ctx, JSValue p_object, Has
 	js_free_rt(JS_GetRuntime(ctx), props);
 }
 
-ECMAScriptGCHandler QuickJSBinder::create_ecma_instance_for_godot_object(const ECMAClassInfo *p_class, Object *p_object) {
-	ERR_FAIL_NULL_V(p_object, ECMAScriptGCHandler());
-	ERR_FAIL_NULL_V(p_class, ECMAScriptGCHandler());
+JavaScriptGCHandler QuickJSBinder::create_js_instance_for_godot_object(const JavaScriptClassInfo *p_class, Object *p_object) {
+	ERR_FAIL_NULL_V(p_object, JavaScriptGCHandler());
+	ERR_FAIL_NULL_V(p_class, JavaScriptGCHandler());
 
-	ECMAScriptGCHandler *bind = BINDING_DATA_FROM_GD(ctx, p_object);
-	ERR_FAIL_NULL_V(bind, ECMAScriptGCHandler());
+	JavaScriptGCHandler *bind = BINDING_DATA_FROM_GD(ctx, p_object);
+	ERR_FAIL_NULL_V(bind, JavaScriptGCHandler());
 
-	JSValue constructor = JS_MKPTR(JS_TAG_OBJECT, p_class->constructor.ecma_object);
-	JSValue object = JS_MKPTR(JS_TAG_OBJECT, bind->ecma_object);
+	JSValue constructor = JS_MKPTR(JS_TAG_OBJECT, p_class->constructor.javascript_object);
+	JSValue object = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
 	JS_CallConstructor2(ctx, constructor, object, 0, NULL);
-	if (JS_SetPrototype(ctx, object, JS_MKPTR(JS_TAG_OBJECT, p_class->prototype.ecma_object)) < 0) {
+	if (JS_SetPrototype(ctx, object, JS_MKPTR(JS_TAG_OBJECT, p_class->prototype.javascript_object)) < 0) {
 		JSValue e = JS_GetException(ctx);
-		ECMAscriptScriptError error;
+		JavaScriptError error;
 		dump_exception(ctx, e, &error);
 		JS_FreeValue(ctx, e);
-		bind->ecma_object = NULL;
-		ERR_FAIL_V_MSG(*bind, vformat("Cannot create instance from ECMAScript class '%s'\n%s", p_class->class_name, error_to_string(error)));
+		bind->javascript_object = NULL;
+		ERR_FAIL_V_MSG(*bind, vformat("Cannot create instance from Godot class '%s'\n%s", p_class->class_name, error_to_string(error)));
 	}
 	initialize_properties(ctx, p_class, object);
 	return *bind;
 }
 
-Variant QuickJSBinder::call_method(const ECMAScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
+Variant QuickJSBinder::call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
 	JSValue object = GET_JSVALUE(p_object);
 	JSAtom atom = get_atom(ctx, p_method);
 	JSValue method = JS_GetProperty(ctx, object, atom);
@@ -2068,7 +2068,7 @@ Variant QuickJSBinder::call_method(const ECMAScriptGCHandler &p_object, const St
 	if (JS_IsException(return_val)) {
 		r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
 		JSValue exception = JS_GetException(ctx);
-		ECMAscriptScriptError err;
+		JavaScriptError err;
 		dump_exception(ctx, exception, &err);
 		ERR_PRINT(error_to_string(err));
 		JS_Throw(ctx, exception);
@@ -2088,7 +2088,7 @@ Variant QuickJSBinder::call_method(const ECMAScriptGCHandler &p_object, const St
 	return ret;
 }
 
-bool QuickJSBinder::get_instance_property(const ECMAScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) {
+bool QuickJSBinder::get_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) {
 	bool success = false;
 	JSValue obj = GET_JSVALUE(p_object);
 	JSAtom atom = get_atom(ctx, p_name);
@@ -2100,7 +2100,7 @@ bool QuickJSBinder::get_instance_property(const ECMAScriptGCHandler &p_object, c
 	return success;
 }
 
-bool QuickJSBinder::set_instance_property(const ECMAScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) {
+bool QuickJSBinder::set_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) {
 	JSValue obj = GET_JSVALUE(p_object);
 	JSAtom atom = get_atom(ctx, p_name);
 	bool success = JS_SetProperty(ctx, obj, atom, variant_to_var(ctx, p_value));
@@ -2108,7 +2108,7 @@ bool QuickJSBinder::set_instance_property(const ECMAScriptGCHandler &p_object, c
 	return success;
 }
 
-bool QuickJSBinder::has_method(const ECMAScriptGCHandler &p_object, const StringName &p_name) {
+bool QuickJSBinder::has_method(const JavaScriptGCHandler &p_object, const StringName &p_name) {
 	JSValue obj = GET_JSVALUE(p_object);
 	ERR_FAIL_COND_V(!JS_IsObject(obj), false);
 	JSAtom atom = get_atom(ctx, p_name);
@@ -2119,32 +2119,32 @@ bool QuickJSBinder::has_method(const ECMAScriptGCHandler &p_object, const String
 	return success;
 }
 
-const ECMAClassInfo *QuickJSBinder::parse_ecma_class(const String &p_code, const String &p_path, bool ignore_cacehe, ECMAscriptScriptError *r_error) {
+const JavaScriptClassInfo *QuickJSBinder::parse_javascript_class(const String &p_code, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) {
 	if (!ignore_cacehe) {
-		if (const ECMAClassInfo *cls = ecma_classes.getptr(p_path)) {
+		if (const JavaScriptClassInfo *cls = javascript_classes.getptr(p_path)) {
 			return cls;
 		}
 	}
-	ECMAscriptScriptError err;
+	JavaScriptError err;
 	ModuleCache *mc = js_compile_and_cache_module(ctx, p_code, p_path, r_error);
-	return parse_ecma_class_from_module(mc, p_path, r_error);
+	return parse_javascript_class_from_module(mc, p_path, r_error);
 }
 
-const ECMAClassInfo *QuickJSBinder::parse_ecma_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, ECMAscriptScriptError *r_error) {
+const JavaScriptClassInfo *QuickJSBinder::parse_javascript_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) {
 	if (!ignore_cacehe) {
-		if (const ECMAClassInfo *cls = ecma_classes.getptr(p_path)) {
+		if (const JavaScriptClassInfo *cls = javascript_classes.getptr(p_path)) {
 			return cls;
 		}
 	}
 	ModuleCache *mc = js_compile_and_cache_module(ctx, p_bytecode, p_path, r_error);
 	ERR_FAIL_NULL_V(mc, NULL);
-	return parse_ecma_class_from_module(mc, p_path, r_error);
+	return parse_javascript_class_from_module(mc, p_path, r_error);
 }
 
-const ECMAClassInfo *QuickJSBinder::parse_ecma_class_from_module(ModuleCache *p_module, const String &p_path, ECMAscriptScriptError *r_error) {
+const JavaScriptClassInfo *QuickJSBinder::parse_javascript_class_from_module(ModuleCache *p_module, const String &p_path, JavaScriptError *r_error) {
 	ERR_FAIL_COND_V(p_module == NULL || p_module->module == NULL, NULL);
 
-	const ECMAClassInfo *ecma_class = NULL;
+	const JavaScriptClassInfo *js_class = NULL;
 	JSValue default_entry = JS_UNDEFINED;
 	if (OK != js_evalute_module(ctx, p_module, r_error)) {
 		goto fail;
@@ -2160,18 +2160,18 @@ const ECMAClassInfo *QuickJSBinder::parse_ecma_class_from_module(ModuleCache *p_
 		JS_FreeAtom(ctx, name);
 	}
 	if (!JS_IsFunction(ctx, default_entry)) {
-		String err = "Failed parse ECMAClass from script " + p_path + ENDL "\t" + "Default export entry must be a godot class!";
+		String err = "Failed parse Godot class from script " + p_path + ENDL "\t" + "Default export entry must be a godot class!";
 		ERR_PRINT(err);
 		JS_ThrowTypeError(ctx, "%s", err.utf8().get_data());
 		goto fail;
 	}
-	ecma_class = register_ecma_class(default_entry, p_path);
+	js_class = register_javascript_class(default_entry, p_path);
 fail:
 	JS_FreeValue(ctx, default_entry);
-	return ecma_class;
+	return js_class;
 }
 
-bool QuickJSBinder::has_signal(const ECMAClassInfo *p_class, const StringName &p_signal) {
+bool QuickJSBinder::has_signal(const JavaScriptClassInfo *p_class, const StringName &p_signal) {
 	ERR_FAIL_NULL_V(p_class, false);
 	bool found = false;
 	JSValue object = JS_GetProperty(ctx, GET_JSVALUE(p_class->prototype), js_key_godot_signals);
@@ -2198,9 +2198,9 @@ JSValue QuickJSBinder::worker_constructor(JSContext *ctx, JSValue this_val, int
 	worker->start(js_to_string(ctx, argv[0]));
 	JSValue obj = JS_NewObjectProtoClass(ctx, host->worker_class_data.prototype, host->worker_class_data.class_id);
 
-	ECMAScriptGCHandler *data = host->new_gc_handler(ctx);
+	JavaScriptGCHandler *data = host->new_gc_handler(ctx);
 	data->native_ptr = worker;
-	data->ecma_object = JS_VALUE_GET_PTR(obj);
+	data->javascript_object = JS_VALUE_GET_PTR(obj);
 	JS_SetOpaque(obj, data);
 	host->workers.push_back(data);
 
@@ -2209,10 +2209,10 @@ JSValue QuickJSBinder::worker_constructor(JSContext *ctx, JSValue this_val, int
 
 void QuickJSBinder::worker_finializer(JSRuntime *rt, JSValue val) {
 	QuickJSBinder *host = QuickJSBinder::get_runtime_binder(rt);
-	if (ECMAScriptGCHandler *bind = static_cast<ECMAScriptGCHandler *>(JS_GetOpaque(val, host->worker_class_data.class_id))) {
+	if (JavaScriptGCHandler *bind = static_cast<JavaScriptGCHandler *>(JS_GetOpaque(val, host->worker_class_data.class_id))) {
 		QuickJSWorker *worker = static_cast<QuickJSWorker *>(bind->native_ptr);
 		worker->stop();
-		if (List<ECMAScriptGCHandler *>::Element *E = host->workers.find(bind)) {
+		if (List<JavaScriptGCHandler *>::Element *E = host->workers.find(bind)) {
 			host->workers.erase(E);
 		}
 		memdelete(worker);
@@ -2223,7 +2223,7 @@ void QuickJSBinder::worker_finializer(JSRuntime *rt, JSValue val) {
 JSValue QuickJSBinder::worker_post_message(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
 	ERR_FAIL_COND_V(argc < 1, JS_ThrowTypeError(ctx, "message value expected of argument #0"));
 	QuickJSBinder *host = QuickJSBinder::get_context_binder(ctx);
-	if (ECMAScriptGCHandler *bind = static_cast<ECMAScriptGCHandler *>(JS_GetOpaque(this_val, host->worker_class_data.class_id))) {
+	if (JavaScriptGCHandler *bind = static_cast<JavaScriptGCHandler *>(JS_GetOpaque(this_val, host->worker_class_data.class_id))) {
 		QuickJSWorker *worker = static_cast<QuickJSWorker *>(bind->native_ptr);
 		worker->post_message_from_host(var_to_variant(ctx, argv[0]));
 	}
@@ -2232,9 +2232,9 @@ JSValue QuickJSBinder::worker_post_message(JSContext *ctx, JSValue this_val, int
 
 JSValue QuickJSBinder::worker_terminate(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
 	QuickJSBinder *host = QuickJSBinder::get_context_binder(ctx);
-	if (ECMAScriptGCHandler *bind = static_cast<ECMAScriptGCHandler *>(JS_GetOpaque(this_val, host->worker_class_data.class_id))) {
+	if (JavaScriptGCHandler *bind = static_cast<JavaScriptGCHandler *>(JS_GetOpaque(this_val, host->worker_class_data.class_id))) {
 		QuickJSWorker *worker = static_cast<QuickJSWorker *>(bind->native_ptr);
-		if (List<ECMAScriptGCHandler *>::Element *E = host->workers.find(bind)) {
+		if (List<JavaScriptGCHandler *>::Element *E = host->workers.find(bind)) {
 			host->workers.erase(E);
 		}
 		worker->stop();
@@ -2248,7 +2248,7 @@ JSValue QuickJSBinder::godot_abandon_value(JSContext *ctx, JSValue this_val, int
 	bool valid = true;
 	Variant gd_value = var_to_variant(ctx, value);
 	if (gd_value.get_type() == Variant::OBJECT) {
-		ECMAScriptGCHandler *data = BINDING_DATA_FROM_JS(ctx, value);
+		JavaScriptGCHandler *data = BINDING_DATA_FROM_JS(ctx, value);
 		if (data) {
 			JS_SetOpaque(value, NULL);
 			if (data->is_ref_counted()) {
@@ -2257,9 +2257,9 @@ JSValue QuickJSBinder::godot_abandon_value(JSContext *ctx, JSValue this_val, int
 				JS_FreeValue(ctx, value);
 			}
 			data->godot_object = NULL;
-			data->ecma_object = NULL;
+			data->javascript_object = NULL;
 			data->context = NULL;
-			data->flags |= ECMAScriptGCHandler::FLAG_TRANSFERABLE;
+			data->flags |= JavaScriptGCHandler::FLAG_TRANSFERABLE;
 		} else {
 			valid = false;
 		}
@@ -2323,7 +2323,7 @@ void QuickJSBinder::add_global_worker() {
 
 /********************************* END Worker **********************************/
 
-bool QuickJSBinder::validate(const String &p_code, const String &p_path, ECMAscriptScriptError *r_error) {
+bool QuickJSBinder::validate(const String &p_code, const String &p_path, JavaScriptError *r_error) {
 	ModuleCache *module = js_compile_and_cache_module(ctx, p_code, p_path, r_error);
 	return module != NULL;
 }
diff --git a/quickjs/quickjs_binder.h b/quickjs/quickjs_binder.h
index eb9d4a99..3ce58497 100644
--- a/quickjs/quickjs_binder.h
+++ b/quickjs/quickjs_binder.h
@@ -1,7 +1,7 @@
 #ifndef QUICKJS_BINDING_HELPER_H
 #define QUICKJS_BINDING_HELPER_H
 
-#include "../ecmascript_binder.h"
+#include "../javascript_binder.h"
 #include "./quickjs/quickjs.h"
 
 #ifdef QUICKJS_WITH_DEBUGGER
@@ -13,8 +13,8 @@
 #include "core/variant/callable.h"
 #include "quickjs_builtin_binder.h"
 #define JS_HIDDEN_SYMBOL(x) ("\xFF" x)
-#define BINDING_DATA_FROM_JS(ctx, p_val) (ECMAScriptGCHandler *)JS_GetOpaque((p_val), QuickJSBinder::get_origin_class_id((ctx)))
-#define GET_JSVALUE(p_gc_handler) JS_MKPTR(JS_TAG_OBJECT, (p_gc_handler).ecma_object)
+#define BINDING_DATA_FROM_JS(ctx, p_val) (JavaScriptGCHandler *)JS_GetOpaque((p_val), QuickJSBinder::get_origin_class_id((ctx)))
+#define GET_JSVALUE(p_gc_handler) JS_MKPTR(JS_TAG_OBJECT, (p_gc_handler).javascript_object)
 #define NO_MODULE_EXPORT_SUPPORT 0
 #define MODULE_HAS_REFCOUNT 0 // module seems don't follow the refrence count rule in quickjs
 #define MAX_ARGUMENT_COUNT 50
@@ -22,7 +22,7 @@
 #define ENDL "\r\n"
 
 class QuickJSWorker;
-class QuickJSBinder : public ECMAScriptBinder {
+class QuickJSBinder : public JavaScriptBinder {
 
 	friend class QuickJSBuiltinBinder;
 	friend class QuickJSWorker;
@@ -52,7 +52,7 @@ class QuickJSBinder : public ECMAScriptBinder {
 		}
 	};
 
-	enum ECMAScriptModuleFlags {
+	enum JavaScriptModuleFlags {
 		MODULE_FLAG_SCRIPT = 1,
 		MODULE_FLAG_NATIVE = 2,
 		MODULE_FLAG_EVALUATED = 1 << 3,
@@ -124,10 +124,10 @@ class QuickJSBinder : public ECMAScriptBinder {
 	static String resolve_module_file(const String &file);
 	static JSModuleDef *js_module_loader(JSContext *ctx, const char *module_name, void *opaque);
 	static JSModuleDef *js_make_module(JSContext *ctx, const String &p_id, const JSValueConst &p_value);
-	ModuleCache *js_compile_and_cache_module(JSContext *ctx, const String &p_code, const String &p_filename, ECMAscriptScriptError *r_error);
-	ModuleCache *js_compile_and_cache_module(JSContext *ctx, const Vector<uint8_t> &p_bytecode, const String &p_filename, ECMAscriptScriptError *r_error);
-	ModuleCache js_compile_module(JSContext *ctx, const String &p_code, const String &p_filename, ECMAscriptScriptError *r_error);
-	static Error js_evalute_module(JSContext *ctx, ModuleCache *p_module, ECMAscriptScriptError *r_error);
+	ModuleCache *js_compile_and_cache_module(JSContext *ctx, const String &p_code, const String &p_filename, JavaScriptError *r_error);
+	ModuleCache *js_compile_and_cache_module(JSContext *ctx, const Vector<uint8_t> &p_bytecode, const String &p_filename, JavaScriptError *r_error);
+	ModuleCache js_compile_module(JSContext *ctx, const String &p_code, const String &p_filename, JavaScriptError *r_error);
+	static Error js_evalute_module(JSContext *ctx, ModuleCache *p_module, JavaScriptError *r_error);
 	static int resource_module_initializer(JSContext *ctx, JSModuleDef *m);
 
 	struct ClassBindData {
@@ -147,7 +147,7 @@ class QuickJSBinder : public ECMAScriptBinder {
 	HashMap<String, ModuleCache> module_cache;
 	HashMap<String, CommonJSModule> commonjs_module_cache;
 	ClassBindData worker_class_data;
-	List<ECMAScriptGCHandler *> workers;
+	List<JavaScriptGCHandler *> workers;
 	Vector<MethodBind *> godot_methods;
 	int internal_godot_method_id;
 	Vector<const ClassDB::PropertySetGet *> godot_object_indexed_properties;
@@ -165,9 +165,9 @@ class QuickJSBinder : public ECMAScriptBinder {
 	void add_global_worker();
 
 	static JSValue object_constructor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int class_id);
-	static void initialize_properties(JSContext *ctx, const ECMAClassInfo *p_class, JSValue p_object);
+	static void initialize_properties(JSContext *ctx, const JavaScriptClassInfo *p_class, JSValue p_object);
 
-	static void object_finalizer(ECMAScriptGCHandler *p_bind);
+	static void object_finalizer(JavaScriptGCHandler *p_bind);
 	static void origin_finalizer(JSRuntime *rt, JSValue val);
 
 	static JSValue object_free(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
@@ -178,10 +178,10 @@ class QuickJSBinder : public ECMAScriptBinder {
 	static JSValue godot_load(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
 	static JSValue godot_instance_from_id(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
 
-	static void add_debug_binding_info(JSContext *ctx, JSValueConst p_obj, const ECMAScriptGCHandler *p_bind);
+	static void add_debug_binding_info(JSContext *ctx, JSValueConst p_obj, const JavaScriptGCHandler *p_bind);
 
-	const ECMAClassInfo *register_ecma_class(const JSValueConst &p_constructor, const String &p_path);
-	void free_ecmas_class(const ECMAClassInfo &p_class);
+	const JavaScriptClassInfo *register_javascript_class(const JSValueConst &p_constructor, const String &p_path);
+	void free_javascript_class(const JavaScriptClassInfo &p_class);
 	static JSValue godot_register_class(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
 	static JSValue godot_register_signal(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
 	static JSValue godot_register_property(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
@@ -223,10 +223,10 @@ class QuickJSBinder : public ECMAScriptBinder {
 	static JSValue variant_to_var(JSContext *ctx, const Variant p_var);
 	static Variant var_to_variant(JSContext *ctx, JSValue p_val);
 	static bool validate_type(JSContext *ctx, Variant::Type p_type, JSValueConst &p_val);
-	static void dump_exception(JSContext *ctx, const JSValueConst &p_exception, ECMAscriptScriptError *r_error);
-	virtual String error_to_string(const ECMAscriptScriptError &p_error);
-	virtual Error get_stacks(List<ECMAScriptStackInfo> &r_stacks);
-	virtual String get_backtrace_message(const List<ECMAScriptStackInfo> &stacks);
+	static void dump_exception(JSContext *ctx, const JSValueConst &p_exception, JavaScriptError *r_error);
+	virtual String error_to_string(const JavaScriptError &p_error) override;
+	virtual Error get_stacks(List<JavaScriptStackInfo> &r_stacks) override;
+	virtual String get_backtrace_message(const List<JavaScriptStackInfo> &stacks) override;
 
 	static Dictionary js_to_dictionary(JSContext *ctx, const JSValueConst &p_val, List<void *> &stack);
 
@@ -285,18 +285,18 @@ class QuickJSBinder : public ECMAScriptBinder {
 		return static_cast<QuickJSBinder *>(JS_GetContextOpaque(ctx));
 	}
 
-	virtual ECMAScriptBinder *get_context_binder(void *p_context) {
+	virtual JavaScriptBinder *get_context_binder(void *p_context) override {
 		return QuickJSBinder::get_context_binder((JSContext *)p_context);
 	}
 
-	virtual Thread::ID get_thread_id() const { return thread_id; }
+	virtual Thread::ID get_thread_id() const override { return thread_id; }
 
 	_FORCE_INLINE_ static QuickJSBinder *get_runtime_binder(JSRuntime *rt) {
 		return static_cast<QuickJSBinder *>(JS_GetMollocState(rt)->opaque);
 	}
 
-	_FORCE_INLINE_ static ECMAScriptGCHandler *new_gc_handler(JSContext *ctx) {
-		ECMAScriptGCHandler *h = memnew(ECMAScriptGCHandler);
+	_FORCE_INLINE_ static JavaScriptGCHandler *new_gc_handler(JSContext *ctx) {
+		JavaScriptGCHandler *h = memnew(JavaScriptGCHandler);
 		h->context = ctx;
 		return h;
 	}
@@ -312,33 +312,33 @@ class QuickJSBinder : public ECMAScriptBinder {
 	virtual void language_finalize() override;
 	virtual void frame() override;
 
-	virtual ECMAScriptGCHandler *alloc_object_binding_data(Object *p_object) override;
-	virtual void free_object_binding_data(ECMAScriptGCHandler *p_gc_handle) override;
-	virtual void godot_refcount_incremented(ECMAScriptGCHandler *p_gc_handle) override;
-	virtual bool godot_refcount_decremented(ECMAScriptGCHandler *p_gc_handle) override;
+	virtual JavaScriptGCHandler *alloc_object_binding_data(Object *p_object) override;
+	virtual void free_object_binding_data(JavaScriptGCHandler *p_gc_handle) override;
+	virtual void godot_refcount_incremented(JavaScriptGCHandler *p_gc_handle) override;
+	virtual bool godot_refcount_decremented(JavaScriptGCHandler *p_gc_handle) override;
 
-	static Error bind_gc_object(JSContext *ctx, ECMAScriptGCHandler *data, Object *p_object);
+	static Error bind_gc_object(JSContext *ctx, JavaScriptGCHandler *data, Object *p_object);
 
-	virtual Error eval_string(const String &p_source, EvalType type, const String &p_path, ECMAScriptGCHandler &r_ret);
-	virtual Error safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, ECMAScriptGCHandler &r_ret);
+	virtual Error eval_string(const String &p_source, EvalType type, const String &p_path, JavaScriptGCHandler &r_ret) override;
+	virtual Error safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, JavaScriptGCHandler &r_ret) override;
 
-	virtual Error compile_to_bytecode(const String &p_code, const String &p_file, Vector<uint8_t> &r_bytecode);
-	virtual Error load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, ECMAScriptGCHandler *r_module);
+	virtual Error compile_to_bytecode(const String &p_code, const String &p_file, Vector<uint8_t> &r_bytecode) override;
+	virtual Error load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, JavaScriptGCHandler *r_module) override;
 
-	virtual const ECMAClassInfo *parse_ecma_class(const String &p_code, const String &p_path, bool ignore_cacehe, ECMAscriptScriptError *r_error);
-	virtual const ECMAClassInfo *parse_ecma_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, ECMAscriptScriptError *r_error);
-	const ECMAClassInfo *parse_ecma_class_from_module(ModuleCache *p_module, const String &p_path, ECMAscriptScriptError *r_error);
+	virtual const JavaScriptClassInfo *parse_javascript_class(const String &p_code, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) override;
+	virtual const JavaScriptClassInfo *parse_javascript_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) override;
+	const JavaScriptClassInfo *parse_javascript_class_from_module(ModuleCache *p_module, const String &p_path, JavaScriptError *r_error);
 
-	virtual ECMAScriptGCHandler create_ecma_instance_for_godot_object(const ECMAClassInfo *p_class, Object *p_object);
-	virtual Variant call_method(const ECMAScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error);
-	virtual bool get_instance_property(const ECMAScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret);
-	virtual bool set_instance_property(const ECMAScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value);
-	virtual bool has_method(const ECMAScriptGCHandler &p_object, const StringName &p_name);
-	virtual bool has_signal(const ECMAClassInfo *p_class, const StringName &p_signal);
-	virtual bool validate(const String &p_code, const String &p_path, ECMAscriptScriptError *r_error);
+	virtual JavaScriptGCHandler create_js_instance_for_godot_object(const JavaScriptClassInfo *p_class, Object *p_object) override;
+	virtual Variant call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override;
+	virtual bool get_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) override;
+	virtual bool set_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) override;
+	virtual bool has_method(const JavaScriptGCHandler &p_object, const StringName &p_name) override;
+	virtual bool has_signal(const JavaScriptClassInfo *p_class, const StringName &p_signal) override;
+	virtual bool validate(const String &p_code, const String &p_path, JavaScriptError *r_error) override;
 
 #ifdef TOOLS_ENABLED
-	virtual const Dictionary &get_modified_api() const { return modified_api; }
+	virtual const Dictionary &get_modified_api() const override { return modified_api; }
 #endif
 };
 
diff --git a/quickjs/quickjs_builtin_binder.cpp b/quickjs/quickjs_builtin_binder.cpp
index 14a70913..3a6c48fe 100644
--- a/quickjs/quickjs_builtin_binder.cpp
+++ b/quickjs/quickjs_builtin_binder.cpp
@@ -18,96 +18,96 @@ QuickJSBuiltinBinder::~QuickJSBuiltinBinder() {
 void QuickJSBuiltinBinder::bind_builtin_object(JSContext *ctx, JSValue target, Variant::Type p_type, const void *p_object) {
 
 	void *ptr = NULL;
-	ECMAScriptGCHandler *bind = NULL;
+	JavaScriptGCHandler *bind = NULL;
 	switch (p_type) {
 		case Variant::VECTOR2:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(Vector2));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(Vector2));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, Vector2(*static_cast<const Vector2 *>(p_object)));
 			break;
 		case Variant::RECT2:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(Rect2));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(Rect2));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, Rect2(*static_cast<const Rect2 *>(p_object)));
 			break;
 		case Variant::COLOR:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(Color));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(Color));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, Color(*static_cast<const Color *>(p_object)));
 			break;
 		case Variant::VECTOR3:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(Vector3));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(Vector3));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, Vector3(*static_cast<const Vector3 *>(p_object)));
 			break;
 		case Variant::BASIS:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(Basis));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(Basis));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, Basis(*static_cast<const Basis *>(p_object)));
 			break;
 		case Variant::QUATERNION:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(Quaternion));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(Quaternion));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, Quaternion(*static_cast<const Quaternion *>(p_object)));
 			break;
 		case Variant::PLANE:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(Plane));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(Plane));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, Plane(*static_cast<const Plane *>(p_object)));
 			break;
 		case Variant::TRANSFORM2D:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(Transform2D));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(Transform2D));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, Transform2D(*static_cast<const Transform2D *>(p_object)));
 			break;
 		case Variant::RID:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(RID));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(RID));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, RID(*static_cast<const RID *>(p_object)));
 			break;
 		case Variant::TRANSFORM3D:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(Transform3D));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(Transform3D));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, Transform3D(*static_cast<const Transform3D *>(p_object)));
 			break;
 		case Variant::AABB:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(AABB));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(AABB));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, AABB(*static_cast<const AABB *>(p_object)));
 			break;
 		case Variant::PACKED_INT32_ARRAY:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PackedInt32Array));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(PackedInt32Array));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, PackedInt32Array(*static_cast<const PackedInt32Array *>(p_object)));
 			break;
 		case Variant::PACKED_BYTE_ARRAY:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PackedByteArray));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(PackedByteArray));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, PackedByteArray(*static_cast<const PackedByteArray *>(p_object)));
 			break;
 		case Variant::PACKED_FLOAT32_ARRAY:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PackedFloat32Array));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(PackedFloat32Array));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, PackedFloat32Array(*static_cast<const PackedFloat32Array *>(p_object)));
 			break;
 		case Variant::PACKED_COLOR_ARRAY:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PackedColorArray));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(PackedColorArray));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, PackedColorArray(*static_cast<const PackedColorArray *>(p_object)));
 			break;
 		case Variant::PACKED_STRING_ARRAY:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PackedStringArray));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(PackedStringArray));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, PackedStringArray(*static_cast<const PackedStringArray *>(p_object)));
 			break;
 		case Variant::PACKED_VECTOR2_ARRAY:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PackedVector2Array));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(PackedVector2Array));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, PackedVector2Array(*static_cast<const PackedVector2Array *>(p_object)));
 			break;
 		case Variant::PACKED_VECTOR3_ARRAY:
-			ptr = memalloc(sizeof(ECMAScriptGCHandler) + sizeof(PackedVector3Array));
-			bind = memnew_placement(ptr, ECMAScriptGCHandler);
+			ptr = memalloc(sizeof(JavaScriptGCHandler) + sizeof(PackedVector3Array));
+			bind = memnew_placement(ptr, JavaScriptGCHandler);
 			memnew_placement(bind + 1, PackedVector3Array(*static_cast<const PackedVector3Array *>(p_object)));
 			break;
 		default:
@@ -117,9 +117,9 @@ void QuickJSBuiltinBinder::bind_builtin_object(JSContext *ctx, JSValue target, V
 
 	bind->context = ctx;
 	bind->type = p_type;
-	bind->flags |= ECMAScriptGCHandler::FLAG_BUILTIN_CLASS;
+	bind->flags |= JavaScriptGCHandler::FLAG_BUILTIN_CLASS;
 	bind->godot_builtin_object_ptr = bind + 1;
-	bind->ecma_object = JS_VALUE_GET_PTR(target);
+	bind->javascript_object = JS_VALUE_GET_PTR(target);
 	JS_SetOpaque(target, bind);
 #ifdef DUMP_LEAKS
 	QuickJSBinder::add_debug_binding_info(ctx, target, bind);
@@ -134,7 +134,7 @@ JSValue QuickJSBuiltinBinder::create_builtin_value(JSContext *ctx, Variant::Type
 	return obj;
 }
 
-void QuickJSBuiltinBinder::builtin_finalizer(ECMAScriptGCHandler *p_bind) {
+void QuickJSBuiltinBinder::builtin_finalizer(JavaScriptGCHandler *p_bind) {
 	switch (p_bind->type) {
 		case Variant::PACKED_BYTE_ARRAY:
 			p_bind->getPackedByteArray()->~PackedByteArray();
@@ -247,7 +247,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[0]);
-								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
+								JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
 								Vector2 *ptr = bind->getVector2();
 								Vector2 ret = ptr->operator*(scalar);
 								return QuickJSBuiltinBinder::new_object_from(ctx, ret);
@@ -259,7 +259,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 			JS_DefinePropertyValueStr(ctx, number_right, "*",
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
-								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
+								JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
 								Vector2 *ptr = bind->getVector2();
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[1]);
 								Vector2 ret = ptr->operator*(scalar);
@@ -272,7 +272,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 			JS_DefinePropertyValueStr(ctx, number_right, "/",
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
-								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
+								JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
 								Vector2 *ptr = bind->getVector2();
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[1]);
 								Vector2 ret = ptr->operator/(scalar);
@@ -295,7 +295,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[0]);
-								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
+								JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
 								Vector3 *ptr = bind->getVector3();
 								Vector3 ret = ptr->operator*(scalar);
 								return QuickJSBuiltinBinder::new_object_from(ctx, ret);
@@ -307,7 +307,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 			JS_DefinePropertyValueStr(ctx, number_right, "*",
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
-								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
+								JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
 								Vector3 *ptr = bind->getVector3();
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[1]);
 								Vector3 ret = ptr->operator*(scalar);
@@ -320,7 +320,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 			JS_DefinePropertyValueStr(ctx, number_right, "/",
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
-								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
+								JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
 								Vector3 *ptr = bind->getVector3();
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[1]);
 								Vector3 ret = ptr->operator/(scalar);
@@ -343,7 +343,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[0]);
-								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
+								JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
 								Color *ptr = bind->getColor();
 								Color ret = ptr->operator*(scalar);
 								return QuickJSBuiltinBinder::new_object_from(ctx, ret);
@@ -355,7 +355,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 			JS_DefinePropertyValueStr(ctx, number_right, "*",
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
-								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
+								JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
 								Color *ptr = bind->getColor();
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[1]);
 								Color ret = ptr->operator*(scalar);
@@ -368,7 +368,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 			JS_DefinePropertyValueStr(ctx, number_right, "/",
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
-								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
+								JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
 								Color *ptr = bind->getColor();
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[1]);
 								Color ret = ptr->operator/(scalar);
@@ -391,7 +391,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[0]);
-								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
+								JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
 								Quaternion *ptr = bind->getQuaternion();
 								Quaternion ret = ptr->operator*(scalar);
 								return QuickJSBuiltinBinder::new_object_from(ctx, ret);
@@ -403,7 +403,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 			JS_DefinePropertyValueStr(ctx, number_right, "*",
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
-								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
+								JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
 								Quaternion *ptr = bind->getQuaternion();
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[1]);
 								Quaternion ret = ptr->operator*(scalar);
@@ -416,7 +416,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 			JS_DefinePropertyValueStr(ctx, number_right, "/",
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
-								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
+								JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
 								Quaternion *ptr = bind->getQuaternion();
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[1]);
 								Quaternion ret = ptr->operator/(scalar);
@@ -439,7 +439,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[0]);
-								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
+								JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
 								Basis *ptr = bind->getBasis();
 								Basis ret = ptr->operator*(scalar);
 								return QuickJSBuiltinBinder::new_object_from(ctx, ret);
@@ -451,7 +451,7 @@ void QuickJSBuiltinBinder::get_cross_type_operators(Variant::Type p_type, Vector
 			JS_DefinePropertyValueStr(ctx, number_right, "*",
 					JS_NewCFunction(
 							ctx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) -> JSValue {
-								ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
+								JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
 								Basis *ptr = bind->getBasis();
 								real_t scalar = QuickJSBinder::js_to_number(ctx, argv[1]);
 								Basis ret = ptr->operator*(scalar);
@@ -639,7 +639,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 
 	{ // Color
 		JSCFunctionMagic *getter = [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic) -> JSValue {
-			ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+			JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 			const Color *ptr = bind->getColor();
 			switch (magic) {
 				case 0:
@@ -661,7 +661,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 		};
 
 		JSCFunctionMagic *setter = [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic) -> JSValue {
-			ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+			JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 			Color *ptr = bind->getColor();
 #ifdef DEBUG_METHODS_ENABLED
 			ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::FLOAT, argv[0]), (JS_ThrowTypeError(ctx, "number value expected")));
@@ -703,7 +703,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 
 	{ // Rect2
 		JSCFunctionMagic *getter = [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic) -> JSValue {
-			ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+			JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 			const Rect2 *ptr = bind->getRect2();
 			switch (magic) {
 				case 0:
@@ -712,7 +712,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 			return JS_UNDEFINED;
 		};
 		JSCFunctionMagic *setter = [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic) -> JSValue {
-			ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+			JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 			Rect2 *ptr = bind->getRect2();
 			switch (magic) {
 				case 0:
@@ -733,7 +733,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 #ifdef DEBUG_METHODS_ENABLED
 				ERR_FAIL_COND_V(argc < 2, (JS_ThrowTypeError(ctx, "Two arguments expected for Rect2.grow_margin")));
 #endif
-				ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+				JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 				Rect2 *ptr = bind->getRect2();
 #ifdef DEBUG_METHODS_ENABLED
 				ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::INT, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 0 of Rect2.grow_margin")));
@@ -751,7 +751,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				"xform",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform2D.xform")));
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					Transform2D *ptr = bind->getTransform2D();
 					if (QuickJSBinder::validate_type(ctx, Variant::VECTOR2, argv[0])) {
 						Vector2 ret = ptr->xform(Vector2(QuickJSBinder::var_to_variant(ctx, argv[0])));
@@ -771,7 +771,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				"xform_inv",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform2D.xform_inv")));
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					Transform2D *ptr = bind->getTransform2D();
 					if (QuickJSBinder::validate_type(ctx, Variant::VECTOR2, argv[0])) {
 						Vector2 ret = ptr->xform_inv(Vector2(QuickJSBinder::var_to_variant(ctx, argv[0])));
@@ -794,12 +794,12 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				"is_equal_approx",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Basis.is_equal_approx")));
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					Basis *ptr = bind->getBasis();
 #ifdef DEBUG_METHODS_ENABLED
 					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::BASIS, argv[0]), (JS_ThrowTypeError(ctx, "Basis expected for Basis.is_equal_approx")));
 #endif
-					ECMAScriptGCHandler *argv_bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
+					JavaScriptGCHandler *argv_bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
 					bool ret = ptr->is_equal_approx(*argv_bind->getBasis());
 					return QuickJSBinder::to_js_bool(ctx, ret);
 				},
@@ -808,7 +808,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 
 	{ // AABB
 		JSCFunctionMagic *getter = [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic) -> JSValue {
-			ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+			JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 			const AABB *ptr = bind->getAABB();
 			switch (magic) {
 				case 0:
@@ -817,7 +817,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 			return JS_UNDEFINED;
 		};
 		JSCFunctionMagic *setter = [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic) -> JSValue {
-			ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+			JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 			AABB *ptr = bind->getAABB();
 			switch (magic) {
 				case 0:
@@ -838,15 +838,15 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				"intersect_3",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ERR_FAIL_COND_V(argc < 2, (JS_ThrowTypeError(ctx, "Two arguments expected for Plane.intersect_3")));
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					Plane *ptr = bind->getPlane();
 #ifdef DEBUG_METHODS_ENABLED
 					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::PLANE, argv[0]), (JS_ThrowTypeError(ctx, "Plane expected for arguments #0 Plane.intersect_3")));
 					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::PLANE, argv[1]), (JS_ThrowTypeError(ctx, "Plane expected for arguments #1 Plane.intersect_3")));
 #endif
 					Vector3 ret;
-					ECMAScriptGCHandler *argv0_bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
-					ECMAScriptGCHandler *argv1_bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
+					JavaScriptGCHandler *argv0_bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
+					JavaScriptGCHandler *argv1_bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
 					if (ptr->intersect_3(*argv0_bind->getPlane(), *argv1_bind->getPlane(), &ret)) {
 						return QuickJSBinder::variant_to_var(ctx, ret);
 					}
@@ -858,15 +858,15 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				"intersects_ray",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ERR_FAIL_COND_V(argc < 2, (JS_ThrowTypeError(ctx, "Two arguments expected for Plane.intersects_ray")));
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					Plane *ptr = bind->getPlane();
 #ifdef DEBUG_METHODS_ENABLED
 					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for arguments #0 Plane.intersects_ray")));
 					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[1]), (JS_ThrowTypeError(ctx, "Vector3 expected for arguments #1 Plane.intersects_ray")));
 #endif
 					Vector3 ret;
-					ECMAScriptGCHandler *argv0_bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
-					ECMAScriptGCHandler *argv1_bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
+					JavaScriptGCHandler *argv0_bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
+					JavaScriptGCHandler *argv1_bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
 					if (ptr->intersects_ray(*argv0_bind->getVector3(), *argv1_bind->getVector3(), &ret)) {
 						return QuickJSBinder::variant_to_var(ctx, ret);
 					}
@@ -878,15 +878,15 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				"intersects_segment",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 					ERR_FAIL_COND_V(argc < 2, (JS_ThrowTypeError(ctx, "Two arguments expected for Plane.intersects_segment")));
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					Plane *ptr = bind->getPlane();
 #ifdef DEBUG_METHODS_ENABLED
 					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for arguments #0 Plane.intersects_segment")));
 					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[1]), (JS_ThrowTypeError(ctx, "Vector3 expected for arguments #1 Plane.intersects_segment")));
 #endif
 					Vector3 ret;
-					ECMAScriptGCHandler *argv0_bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
-					ECMAScriptGCHandler *argv1_bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
+					JavaScriptGCHandler *argv0_bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
+					JavaScriptGCHandler *argv1_bind = BINDING_DATA_FROM_JS(ctx, argv[1]);
 					if (ptr->intersects_segment(*argv0_bind->getVector3(), *argv1_bind->getVector3(), &ret)) {
 						return QuickJSBinder::variant_to_var(ctx, ret);
 					}
@@ -900,7 +900,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 			"xform",
 			[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 				ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform3D.xform")));
-				ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+				JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 				Transform3D *ptr = bind->getTransform3D();
 				if (QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0])) {
 					Vector3 ret = ptr->xform(Vector3(QuickJSBinder::var_to_variant(ctx, argv[0])));
@@ -923,7 +923,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 			"xform_inv",
 			[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 				ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform3D.xform_inv")));
-				ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+				JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 				Transform3D *ptr = bind->getTransform3D();
 				if (QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0])) {
 					Vector3 ret = ptr->xform_inv(Vector3(QuickJSBinder::var_to_variant(ctx, argv[0])));
@@ -949,7 +949,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				Variant::PACKED_BYTE_ARRAY,
 				"compress",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					PackedByteArray *ptr = bind->getPackedByteArray();
 					PackedByteArray compressed;
 					if (ptr->size() > 0) {
@@ -970,7 +970,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				Variant::PACKED_BYTE_ARRAY,
 				"decompress",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					PackedByteArray *ptr = bind->getPackedByteArray();
 					PackedByteArray decompressed;
 #ifdef DEBUG_METHODS_ENABLED
@@ -995,7 +995,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				Variant::PACKED_BYTE_ARRAY,
 				"get_string_from_utf8",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					PackedByteArray *ptr = bind->getPackedByteArray();
 					String ret;
 					if (ptr->size() > 0) {
@@ -1009,7 +1009,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				Variant::PACKED_BYTE_ARRAY,
 				"get_string_from_ascii",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					PackedByteArray *ptr = bind->getPackedByteArray();
 					String ret;
 					if (ptr->size() > 0) {
@@ -1027,7 +1027,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				Variant::PACKED_BYTE_ARRAY,
 				"hex_encode",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					PackedByteArray *ptr = bind->getPackedByteArray();
 					String ret;
 					if (ptr->size() > 0) {
@@ -1041,7 +1041,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				Variant::PACKED_BYTE_ARRAY,
 				"get_buffer",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					PackedByteArray *array = memnew(PackedByteArray(*bind->getPackedByteArray()));
 					JSValue ret = JS_NewArrayBuffer(
 							ctx, const_cast<uint8_t *>(array->ptr()), array->size(), [](JSRuntime *rt, void *opaque, void *ptr) {
@@ -1058,7 +1058,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				Variant::PACKED_INT32_ARRAY,
 				"get_buffer",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					PackedInt32Array *array = memnew(PackedInt32Array(*bind->getPackedInt32Array()));
 					JSValue ret = JS_NewArrayBuffer(
 							ctx, (uint8_t *)(array->ptr()), array->size() * sizeof(int), [](JSRuntime *rt, void *opaque, void *ptr) {
@@ -1075,7 +1075,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				Variant::PACKED_FLOAT32_ARRAY,
 				"get_buffer",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					PackedFloat32Array *array = memnew(PackedFloat32Array(*bind->getPackedFloat32Array()));
 					JSValue ret = JS_NewArrayBuffer(
 							ctx, (uint8_t *)(array->ptr()), array->size() * sizeof(real_t), [](JSRuntime *rt, void *opaque, void *ptr) {
@@ -1092,7 +1092,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				Variant::PACKED_VECTOR2_ARRAY,
 				"get_buffer",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					PackedVector2Array *array = memnew(PackedVector2Array(*bind->getPackedVector2Array()));
 					JSValue ret = JS_NewArrayBuffer(
 							ctx, (uint8_t *)(array->ptr()), array->size() * sizeof(Vector2), [](JSRuntime *rt, void *opaque, void *ptr) {
@@ -1110,7 +1110,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				Variant::PACKED_VECTOR3_ARRAY,
 				"get_buffer",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					PackedVector3Array *array = memnew(PackedVector3Array(*bind->getPackedVector3Array()));
 					JSValue ret = JS_NewArrayBuffer(
 							ctx, (uint8_t *)(array->ptr()), array->size() * sizeof(Vector3), [](JSRuntime *rt, void *opaque, void *ptr) {
@@ -1128,7 +1128,7 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 				Variant::PACKED_COLOR_ARRAY,
 				"get_buffer",
 				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-					ECMAScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					PackedColorArray *array = memnew(PackedColorArray(*bind->getPackedColorArray()));
 					JSValue ret = JS_NewArrayBuffer(
 						ctx, (uint8_t *)(array->ptr()), array->size() * sizeof(Color), [](JSRuntime *rt, void *opaque, void *ptr) {
diff --git a/quickjs/quickjs_builtin_binder.h b/quickjs/quickjs_builtin_binder.h
index 2c7a4d49..33e90159 100644
--- a/quickjs/quickjs_builtin_binder.h
+++ b/quickjs/quickjs_builtin_binder.h
@@ -3,7 +3,7 @@
 
 #include "quickjs/quickjs.h"
 #include "core/variant/variant.h"
-struct ECMAScriptGCHandler;
+struct JavaScriptGCHandler;
 class QuickJSBinder;
 
 typedef JSValue (*JSConstructorFunc)(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv);
@@ -26,7 +26,7 @@ class QuickJSBuiltinBinder {
 	JSAtom js_key_to_string;
 
 public:
-	void builtin_finalizer(ECMAScriptGCHandler *p_bind);
+	void builtin_finalizer(JavaScriptGCHandler *p_bind);
 
 	void register_builtin_class(Variant::Type p_type, const char *p_name, JSConstructorFunc p_constructor, int argc);
 	void register_property(Variant::Type p_type, const char *p_name, JSCFunctionMagic *p_getter, JSCFunctionMagic *p_setter, int magic);
diff --git a/quickjs/quickjs_worker.cpp b/quickjs/quickjs_worker.cpp
index 142059e0..3a3c20f2 100644
--- a/quickjs/quickjs_worker.cpp
+++ b/quickjs/quickjs_worker.cpp
@@ -12,8 +12,8 @@ void QuickJSWorker::thread_main(void *p_this) {
 
 	if (err == OK) {
 		String err_text;
-		ECMAScriptGCHandler eval_ret;
-		err = self->safe_eval_text(text, ECMAScriptBinder::EVAL_TYPE_MODULE, self->entry_script, err_text, eval_ret);
+		JavaScriptGCHandler eval_ret;
+		err = self->safe_eval_text(text, JavaScriptBinder::EVAL_TYPE_MODULE, self->entry_script, err_text, eval_ret);
 		if (err == OK) {
 			JSValue onmessage_callback = JS_GetPropertyStr(self->ctx, self->global_object, "onmessage");
 			bool onmessage_valid = JS_IsFunction(self->ctx, onmessage_callback);
@@ -34,7 +34,7 @@ void QuickJSWorker::thread_main(void *p_this) {
 						JSValue ret = JS_Call(self->ctx, onmessage_callback, self->global_object, 1, argv);
 						if (JS_IsException(ret)) {
 							JSValue e = JS_GetException(self->ctx);
-							ECMAscriptScriptError err;
+							JavaScriptError err;
 							dump_exception(self->ctx, e, &err);
 							ERR_PRINT(String("Error in worker onmessage callback") + ENDL + self->error_to_string(err));
 							JS_FreeValue(self->ctx, e);
@@ -80,8 +80,8 @@ JSValue QuickJSWorker::global_import_scripts(JSContext *ctx, JSValue this_val, i
 			String path = resolve_module_file(js_to_string(ctx, argv[0]));
 			String source = FileAccess::get_file_as_string(path, &err);
 			QuickJSBinder *bind = get_context_binder(ctx);
-			ECMAScriptGCHandler eval_ret;
-			bind->eval_string(source, ECMAScriptBinder::EVAL_TYPE_GLOBAL, path, eval_ret);
+			JavaScriptGCHandler eval_ret;
+			bind->eval_string(source, JavaScriptBinder::EVAL_TYPE_GLOBAL, path, eval_ret);
 		}
 	}
 	return JS_UNDEFINED;
@@ -136,7 +136,7 @@ bool QuickJSWorker::frame_of_host(QuickJSBinder *host, const JSValueConst &value
 			JSValue ret = JS_Call(host->ctx, onmessage_callback, JS_NULL, 1, argv);
 			if (JS_IsException(ret)) {
 				JSValue e = JS_GetException(host->ctx);
-				ECMAscriptScriptError err;
+				JavaScriptError err;
 				dump_exception(host->ctx, e, &err);
 				ERR_PRINT(String("Error in worker onmessage callback") + ENDL + error_to_string(err));
 				JS_FreeValue(host->ctx, e);
diff --git a/register_types.cpp b/register_types.cpp
index 996d3058..9b68a728 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -29,8 +29,8 @@
 /*************************************************************************/
 
 #include "register_types.h"
-#include "ecmascript.h"
-#include "ecmascript_language.h"
+#include "javascript.h"
+#include "javascript_language.h"
 
 #ifdef TOOLS_ENABLED
 #include "core/io/file_access_encrypted.h"
@@ -39,8 +39,8 @@
 #include "tools/editor_tools.h"
 void editor_init_callback();
 
-class EditorExportECMAScript : public EditorExportPlugin {
-	GDCLASS(EditorExportECMAScript, EditorExportPlugin);
+class EditorExportJavaScript : public EditorExportPlugin {
+	GDCLASS(EditorExportJavaScript, EditorExportPlugin);
 
 public:
 	virtual void _export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features) override {
@@ -65,7 +65,7 @@ class EditorExportECMAScript : public EditorExportPlugin {
 			ERR_FAIL_COND(err != OK);
 
 			Vector<uint8_t> file;
-			ERR_FAIL_COND(ECMAScriptLanguage::get_singleton()->get_main_binder()->compile_to_bytecode(code, p_path, file) != OK);
+			ERR_FAIL_COND(JavaScriptLanguage::get_singleton()->get_main_binder()->compile_to_bytecode(code, p_path, file) != OK);
 			add_file(p_path.get_basename() + "." + extension + "b", file, true);
 #endif
 		}
@@ -74,30 +74,30 @@ class EditorExportECMAScript : public EditorExportPlugin {
 
 #endif
 
-Ref<ResourceFormatLoaderECMAScript> resource_loader_ecmascript;
-Ref<ResourceFormatSaverECMAScript> resource_saver_ecmascript;
-Ref<ResourceFormatLoaderECMAScriptModule> resource_loader_ecmascript_module;
-Ref<ResourceFormatSaverECMAScriptModule> resource_saver_ecmascript_module;
-static ECMAScriptLanguage *script_language_js = nullptr;
+Ref<ResourceFormatLoaderJavaScript> resource_loader_javascript;
+Ref<ResourceFormatSaverJavaScript> resource_saver_javascript;
+Ref<ResourceFormatLoaderJavaScriptModule> resource_loader_javascript_module;
+Ref<ResourceFormatSaverJavaScriptModule> resource_saver_javascript_module;
+static JavaScriptLanguage *script_language_js = nullptr;
 
-void initialize_ECMAScript_module(ModuleInitializationLevel p_level) {
+void initialize_javascript_module(ModuleInitializationLevel p_level) {
 	if (p_level != ModuleInitializationLevel::MODULE_INITIALIZATION_LEVEL_CORE)
 		return;
 
-	ClassDB::register_class<ECMAScript>();
-	ClassDB::register_class<ECMAScriptModule>();
+	ClassDB::register_class<JavaScript>();
+	ClassDB::register_class<JavaScriptModule>();
 
-	resource_loader_ecmascript.instantiate();
-	resource_saver_ecmascript.instantiate();
-	ResourceLoader::add_resource_format_loader(resource_loader_ecmascript, true);
-	ResourceSaver::add_resource_format_saver(resource_saver_ecmascript, true);
+	resource_loader_javascript.instantiate();
+	resource_saver_javascript.instantiate();
+	ResourceLoader::add_resource_format_loader(resource_loader_javascript, true);
+	ResourceSaver::add_resource_format_saver(resource_saver_javascript, true);
 
-	resource_loader_ecmascript_module.instantiate();
-	resource_saver_ecmascript_module.instantiate();
-	ResourceLoader::add_resource_format_loader(resource_loader_ecmascript_module, true);
-	ResourceSaver::add_resource_format_saver(resource_saver_ecmascript_module, true);
+	resource_loader_javascript_module.instantiate();
+	resource_saver_javascript_module.instantiate();
+	ResourceLoader::add_resource_format_loader(resource_loader_javascript_module, true);
+	ResourceSaver::add_resource_format_saver(resource_saver_javascript_module, true);
 
-	script_language_js = memnew(ECMAScriptLanguage);
+	script_language_js = memnew(JavaScriptLanguage);
 	ScriptServer::register_language(script_language_js);
 
 #ifdef TOOLS_ENABLED
@@ -105,30 +105,30 @@ void initialize_ECMAScript_module(ModuleInitializationLevel p_level) {
 #endif
 }
 
-void uninitialize_ECMAScript_module(ModuleInitializationLevel p_level) {
+void uninitialize_javascript_module(ModuleInitializationLevel p_level) {
 	if (p_level != ModuleInitializationLevel::MODULE_INITIALIZATION_LEVEL_CORE)
 		return;
 
 	ScriptServer::unregister_language(script_language_js);
 	memdelete(script_language_js);
 
-	ResourceLoader::remove_resource_format_loader(resource_loader_ecmascript);
-	ResourceSaver::remove_resource_format_saver(resource_saver_ecmascript);
-	resource_loader_ecmascript.unref();
-	resource_saver_ecmascript.unref();
+	ResourceLoader::remove_resource_format_loader(resource_loader_javascript);
+	ResourceSaver::remove_resource_format_saver(resource_saver_javascript);
+	resource_loader_javascript.unref();
+	resource_saver_javascript.unref();
 
-	ResourceLoader::remove_resource_format_loader(resource_loader_ecmascript_module);
-	ResourceSaver::remove_resource_format_saver(resource_saver_ecmascript_module);
-	resource_loader_ecmascript_module.unref();
-	resource_saver_ecmascript_module.unref();
+	ResourceLoader::remove_resource_format_loader(resource_loader_javascript_module);
+	ResourceSaver::remove_resource_format_saver(resource_saver_javascript_module);
+	resource_loader_javascript_module.unref();
+	resource_saver_javascript_module.unref();
 }
 
 #ifdef TOOLS_ENABLED
 void editor_init_callback() {
-	ECMAScriptPlugin *plugin = memnew(ECMAScriptPlugin(EditorNode::get_singleton()));
+	JavaScriptPlugin *plugin = memnew(JavaScriptPlugin(EditorNode::get_singleton()));
 	EditorNode::get_singleton()->add_editor_plugin(plugin);
 
-	Ref<EditorExportECMAScript> js_export;
+	Ref<EditorExportJavaScript> js_export;
 	js_export.instantiate();
 	EditorExport::get_singleton()->add_export_plugin(js_export);
 }
diff --git a/register_types.h b/register_types.h
index c489d1d8..c81b4a71 100644
--- a/register_types.h
+++ b/register_types.h
@@ -28,11 +28,11 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef ECMASCRIPT_MODULE_H
-#define ECMASCRIPT_MODULE_H
+#ifndef JAVASCRIPT_MODULE_H
+#define JAVASCRIPT_MODULE_H
 
 #include "modules/register_module_types.h"
-void initialize_ECMAScript_module(ModuleInitializationLevel p_level);
-void uninitialize_ECMAScript_module(ModuleInitializationLevel p_level);
+void initialize_javascript_module(ModuleInitializationLevel p_level);
+void uninitialize_javascript_module(ModuleInitializationLevel p_level);
 
 #endif
diff --git a/tools/editor_tools.cpp b/tools/editor_tools.cpp
index 61972461..85eb788a 100644
--- a/tools/editor_tools.cpp
+++ b/tools/editor_tools.cpp
@@ -1,5 +1,5 @@
 #include "editor_tools.h"
-#include "../ecmascript_language.h"
+#include "../javascript_language.h"
 #include "core/math/expression.h"
 #include "core/os/keyboard.h"
 #include "editor/filesystem_dock.h"
@@ -11,8 +11,8 @@ static HashMap<String, List<String>> added_apis;
 typedef HashMap<String, Vector<const DocData::ConstantDoc *>> ClassEnumerations;
 static HashMap<String, ClassEnumerations> class_enumerations;
 
-struct ECMAScriptAlphCompare {
-	_FORCE_INLINE_ bool operator()(const Ref<ECMAScript> &l, const Ref<ECMAScript> &r) const {
+struct JavaScriptAlphCompare {
+	_FORCE_INLINE_ bool operator()(const Ref<JavaScript> &l, const Ref<JavaScript> &r) const {
 		return String(l->get_class_name()) < String(r->get_class_name());
 	}
 };
@@ -26,28 +26,28 @@ static Error dump_to_file(const String &p_path, const String &p_content) {
 	return FAILED;
 }
 
-void ECMAScriptPlugin::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("_on_menu_item_pressed"), &ECMAScriptPlugin::_on_menu_item_pressed);
-	ClassDB::bind_method(D_METHOD("_export_typescript_declare_file"), &ECMAScriptPlugin::_export_typescript_declare_file);
-	ClassDB::bind_method(D_METHOD("_export_enumeration_binding_file"), &ECMAScriptPlugin::_export_enumeration_binding_file);
+void JavaScriptPlugin::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("_on_menu_item_pressed"), &JavaScriptPlugin::_on_menu_item_pressed);
+	ClassDB::bind_method(D_METHOD("_export_typescript_declare_file"), &JavaScriptPlugin::_export_typescript_declare_file);
+	ClassDB::bind_method(D_METHOD("_export_enumeration_binding_file"), &JavaScriptPlugin::_export_enumeration_binding_file);
 }
 
-void ECMAScriptPlugin::_notification(int p_what) {
+void JavaScriptPlugin::_notification(int p_what) {
 	switch (p_what) {
 		case MainLoop::NOTIFICATION_APPLICATION_FOCUS_IN: {
-			const HashSet<Ref<ECMAScript>> &scripts = ECMAScriptLanguage::get_singleton()->get_scripts();
-			for (const Ref<ECMAScript> &s : scripts) {
+			const HashSet<Ref<JavaScript>> &scripts = JavaScriptLanguage::get_singleton()->get_scripts();
+			for (const Ref<JavaScript> &s : scripts) {
 				uint64_t last_time = s->get_last_modified_time();
 				uint64_t time = FileAccess::get_modified_time(s->get_script_path());
 				if (last_time != time) {
-					ECMAScriptLanguage::get_singleton()->reload_tool_script(s, true);
+					JavaScriptLanguage::get_singleton()->reload_tool_script(s, true);
 				}
 			}
 		} break;
 	}
 }
 
-void ECMAScriptPlugin::_on_menu_item_pressed(int item) {
+void JavaScriptPlugin::_on_menu_item_pressed(int item) {
 	switch (item) {
 		case MenuItem::ITEM_GEN_DECLARE_FILE:
 			declaration_file_dialog->popup_centered_ratio();
@@ -61,14 +61,14 @@ void ECMAScriptPlugin::_on_menu_item_pressed(int item) {
 	}
 }
 
-ECMAScriptPlugin::ECMAScriptPlugin(EditorNode *p_node) {
+JavaScriptPlugin::JavaScriptPlugin(EditorNode *p_node) {
 
 	PopupMenu *menu = memnew(PopupMenu);
-	add_tool_submenu_item(TTR("ECMAScript"), menu);
+	add_tool_submenu_item(TTR("JavaScript"), menu);
 	menu->add_item(TTR("Generate TypeScript Declaration File"), ITEM_GEN_DECLARE_FILE);
 	menu->add_item(TTR("Generate Enumeration Binding Script"), ITEM_GEN_ENUM_BINDING_SCRIPT);
 	menu->add_item(TTR("Generate TypeScript Project"), ITEM_GEN_TYPESCRIPT_PROJECT);
-	menu->connect("id_pressed", callable_mp(this, &ECMAScriptPlugin::_on_menu_item_pressed));
+	menu->connect("id_pressed", callable_mp(this, &JavaScriptPlugin::_on_menu_item_pressed));
 
 	declaration_file_dialog = memnew(EditorFileDialog);
 	declaration_file_dialog->set_title(TTR("Generate TypeScript Declaration File"));
@@ -76,7 +76,7 @@ ECMAScriptPlugin::ECMAScriptPlugin(EditorNode *p_node) {
 	declaration_file_dialog->set_access(EditorFileDialog::ACCESS_FILESYSTEM);
 	declaration_file_dialog->add_filter(TTR("*.d.ts;TypeScript Declaration file"));
 	declaration_file_dialog->set_current_file("godot.d.ts");
-	declaration_file_dialog->connect("file_selected", callable_mp(this, &ECMAScriptPlugin::_export_typescript_declare_file));
+	declaration_file_dialog->connect("file_selected", callable_mp(this, &JavaScriptPlugin::_export_typescript_declare_file));
 	EditorNode::get_singleton()->get_gui_base()->add_child(declaration_file_dialog);
 
 	enumberation_file_dialog = memnew(EditorFileDialog);
@@ -85,7 +85,7 @@ ECMAScriptPlugin::ECMAScriptPlugin(EditorNode *p_node) {
 	enumberation_file_dialog->set_access(EditorFileDialog::ACCESS_FILESYSTEM);
 	enumberation_file_dialog->add_filter(TTR("*.jsx;JavaScript file"));
 	enumberation_file_dialog->set_current_file("enumerations.jsx");
-	enumberation_file_dialog->connect("file_selected", callable_mp(this, &ECMAScriptPlugin::_export_enumeration_binding_file));
+	enumberation_file_dialog->connect("file_selected", callable_mp(this, &JavaScriptPlugin::_export_enumeration_binding_file));
 	EditorNode::get_singleton()->get_gui_base()->add_child(enumberation_file_dialog);
 
 	ts_ignore_errors.clear();
@@ -171,7 +171,7 @@ static String format_doc_text(const String &p_bbcode, const String &p_indent = "
 
 static String format_identifier(const String &p_ident) {
 	List<String> reserved_words;
-	ECMAScriptLanguage::get_singleton()->get_reserved_words(&reserved_words);
+	JavaScriptLanguage::get_singleton()->get_reserved_words(&reserved_words);
 	if (reserved_words.find(p_ident)) {
 		return String("p_") + p_ident;
 	}
@@ -180,7 +180,7 @@ static String format_identifier(const String &p_ident) {
 
 static String format_property_name(const String &p_ident) {
 	List<String> reserved_words;
-	ECMAScriptLanguage::get_singleton()->get_reserved_words(&reserved_words);
+	JavaScriptLanguage::get_singleton()->get_reserved_words(&reserved_words);
 	if (reserved_words.find(p_ident) || p_ident.find("/") != -1) {
 		return String("'") + p_ident + "'";
 	}
@@ -469,8 +469,8 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 	return apply_pattern(class_template, dict);
 }
 
-void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
-	modified_api = &ECMAScriptLanguage::get_singleton()->get_main_binder()->get_modified_api();
+void JavaScriptPlugin::_export_typescript_declare_file(const String &p_path) {
+	modified_api = &JavaScriptLanguage::get_singleton()->get_main_binder()->get_modified_api();
 
 	removed_members.clear();
 	if (modified_api->has("removed")) {
@@ -645,7 +645,7 @@ void ECMAScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 	}
 }
 
-void ECMAScriptPlugin::_export_enumeration_binding_file(const String &p_path) {
+void JavaScriptPlugin::_export_enumeration_binding_file(const String &p_path) {
 	_export_typescript_declare_file("");
 	String file_content = "// Tool generated file DO NOT modify mannually\n"
 						  "// Add this script as first autoload to your project to bind enumerations for release build of godot engine\n"
@@ -704,7 +704,7 @@ void ECMAScriptPlugin::_export_enumeration_binding_file(const String &p_path) {
 	dump_to_file(p_path, file_content);
 }
 
-void ECMAScriptPlugin::_generate_typescript_project() {
+void JavaScriptPlugin::_generate_typescript_project() {
 	_export_typescript_declare_file("res://godot.d.ts");
 	dump_to_file("res://tsconfig.json", TSCONFIG_CONTENT);
 	dump_to_file("res://decorators.ts", TS_DECORATORS_CONTENT);
diff --git a/tools/editor_tools.h b/tools/editor_tools.h
index 3c19d499..040005ae 100644
--- a/tools/editor_tools.h
+++ b/tools/editor_tools.h
@@ -1,11 +1,10 @@
-#ifndef ECMA_CLASS_BROWSER_H
-#define ECMA_CLASS_BROWSER_H
+#ifndef JAVASCRIPT_PLUGIN_H
+#define JAVASCRIPT_PLUGIN_H
 #include "editor/editor_file_dialog.h"
 #include "editor/editor_node.h"
 
-class ECMAScriptPlugin : public EditorPlugin {
-
-	GDCLASS(ECMAScriptPlugin, EditorPlugin);
+class JavaScriptPlugin : public EditorPlugin {
+	GDCLASS(JavaScriptPlugin, EditorPlugin);
 
 	enum MenuItem {
 		ITEM_GEN_DECLARE_FILE,
@@ -32,8 +31,8 @@ class ECMAScriptPlugin : public EditorPlugin {
 	void _generate_typescript_project();
 
 public:
-	virtual String get_name() const override { return "ECMAScriptPlugin"; }
-	ECMAScriptPlugin(EditorNode *p_node);
+	virtual String get_name() const override { return "JavaScriptPlugin"; }
+	JavaScriptPlugin(EditorNode *p_node);
 };
 
-#endif // ECMA_CLASS_BROWSER_H
+#endif

From 98f6b3b649f2af5db318af08d5664621e25aa132 Mon Sep 17 00:00:00 2001
From: Geequlim <geequlim@gmail.com>
Date: Fri, 2 Sep 2022 20:37:06 +0800
Subject: [PATCH 06/71] Fix compile error with non-editor build

---
 quickjs/quickjs_binder.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/quickjs/quickjs_binder.cpp b/quickjs/quickjs_binder.cpp
index 0a1348cd..e75ac478 100644
--- a/quickjs/quickjs_binder.cpp
+++ b/quickjs/quickjs_binder.cpp
@@ -1257,11 +1257,13 @@ void QuickJSBinder::initialize() {
 	String script_binding_error;
 	JavaScriptGCHandler eval_ret;
 	if (OK == safe_eval_text(JavaScriptBinder::BINDING_SCRIPT_CONTENT, JavaScriptBinder::EVAL_TYPE_GLOBAL, "<internal: binding_script.js>", script_binding_error, eval_ret)) {
+#ifdef TOOLS_ENABLED
 		if (eval_ret.javascript_object) {
 			JSValue ret = JS_MKPTR(JS_TAG_OBJECT, eval_ret.javascript_object);
 			modified_api = var_to_variant(ctx, ret);
 			JS_FreeValue(ctx, ret);
 		}
+#endif
 	} else {
 		CRASH_NOW_MSG("Execute script binding failed:" ENDL + script_binding_error);
 	}

From 7c68bbed8496c998650c77a02616f2c015f5f59c Mon Sep 17 00:00:00 2001
From: Geequlim <geequlim@gmail.com>
Date: Fri, 9 Sep 2022 18:44:02 +0800
Subject: [PATCH 07/71] Implement JavaScriptCallable for Signal & slot

---
 javascript_binder.h          |  5 ++-
 javascript_callable.h        | 17 ++++++++++
 javascript_gc_handler.h      |  1 +
 javascript_language.cpp      |  2 ++
 javascript_language.h        | 10 ++++++
 quickjs/quickjs_binder.cpp   | 33 +++++++++++++++++-
 quickjs/quickjs_binder.h     |  7 +++-
 quickjs/quickjs_callable.cpp | 65 ++++++++++++++++++++++++++++++++++++
 quickjs/quickjs_callable.h   | 26 +++++++++++++++
 tests/UnitTest.js            | 21 ++++++++++++
 tools/editor_tools.cpp       |  4 ---
 11 files changed, 184 insertions(+), 7 deletions(-)
 create mode 100644 javascript_callable.h
 create mode 100644 quickjs/quickjs_callable.cpp
 create mode 100644 quickjs/quickjs_callable.h

diff --git a/javascript_binder.h b/javascript_binder.h
index 18fcf320..ee296bbf 100644
--- a/javascript_binder.h
+++ b/javascript_binder.h
@@ -88,12 +88,15 @@ class JavaScriptBinder {
 	virtual const JavaScriptClassInfo *parse_javascript_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) = 0;
 
 	virtual JavaScriptGCHandler create_js_instance_for_godot_object(const JavaScriptClassInfo *p_class, Object *p_object) = 0;
-	virtual Variant call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) = 0;
 	virtual bool get_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) = 0;
 	virtual bool set_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) = 0;
 	virtual bool has_method(const JavaScriptGCHandler &p_object, const StringName &p_name) = 0;
 	virtual bool has_signal(const JavaScriptClassInfo *p_class, const StringName &p_signal) = 0;
 	virtual bool validate(const String &p_code, const String &p_path, JavaScriptError *r_error) = 0;
+
+	virtual Variant call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) = 0;
+	virtual Variant call(const JavaScriptGCHandler &p_fuction, const JavaScriptGCHandler &p_target, const Variant **p_args, int p_argcount, Callable::CallError &r_error) = 0;
+
 #ifdef TOOLS_ENABLED
 	virtual const Dictionary &get_modified_api() const = 0;
 #endif
diff --git a/javascript_callable.h b/javascript_callable.h
new file mode 100644
index 00000000..e8ceb011
--- /dev/null
+++ b/javascript_callable.h
@@ -0,0 +1,17 @@
+#ifndef JAVASCRIPT_CALLABLE_H
+#define JAVASCRIPT_CALLABLE_H
+
+#include "core/variant/callable.h"
+#include "javascript_gc_handler.h"
+
+class JavaScriptCallable : public CallableCustom {
+protected:
+	JavaScriptGCHandler js_function;
+
+public:
+	JavaScriptCallable() {}
+	JavaScriptCallable(const JavaScriptGCHandler &p_function) : js_function(p_function) {}
+	virtual ~JavaScriptCallable() {}
+};
+
+#endif // JAVASCRIPT_CALLABLE_H
diff --git a/javascript_gc_handler.h b/javascript_gc_handler.h
index f9f4bd3f..0d88ffc4 100644
--- a/javascript_gc_handler.h
+++ b/javascript_gc_handler.h
@@ -128,6 +128,7 @@ struct JavaScriptGCHandler {
 	_FORCE_INLINE_ bool is_finalized() const {
 		return flags & FLAG_FINALIZED;
 	}
+
 	_FORCE_INLINE_ bool is_valid_javascript_object() const {
 		return context != NULL && javascript_object != NULL && !is_finalized();
 	}
diff --git a/javascript_language.cpp b/javascript_language.cpp
index e73381dc..915a4ec3 100644
--- a/javascript_language.cpp
+++ b/javascript_language.cpp
@@ -36,6 +36,7 @@ JavaScriptLanguage::JavaScriptLanguage() {
 	ERR_FAIL_COND(singleton);
 	singleton = this;
 	main_binder = memnew(QuickJSBinder);
+	callable_middleman = memnew(CallableMiddleman);
 	instance_binding_callbacks.create_callback = JavaScriptInstanceBindingCallbacks::create_callback;
 	instance_binding_callbacks.free_callback = JavaScriptInstanceBindingCallbacks::free_callback;
 	instance_binding_callbacks.reference_callback = JavaScriptInstanceBindingCallbacks::reference_callback;
@@ -43,6 +44,7 @@ JavaScriptLanguage::JavaScriptLanguage() {
 
 JavaScriptLanguage::~JavaScriptLanguage() {
 	memdelete(main_binder);
+	memdelete(callable_middleman);
 }
 
 void JavaScriptLanguage::init() {
diff --git a/javascript_language.h b/javascript_language.h
index 9a454480..2b4e2739 100644
--- a/javascript_language.h
+++ b/javascript_language.h
@@ -5,6 +5,10 @@
 #include "javascript.h"
 #include "quickjs/quickjs_binder.h"
 
+class CallableMiddleman : public Object {
+	GDCLASS(CallableMiddleman, Object);
+};
+
 class JavaScriptBinder;
 class JavaScriptLanguage : public ScriptLanguage {
 	friend class JavaScriptBinder;
@@ -18,6 +22,8 @@ class JavaScriptLanguage : public ScriptLanguage {
 	JavaScriptBinder *main_binder;
 	HashMap<Thread::ID, JavaScriptBinder *> thread_binder_map;
 	GDNativeInstanceBindingCallbacks instance_binding_callbacks;
+
+	CallableMiddleman *callable_middleman;
 #ifdef TOOLS_ENABLED
 	HashSet<Ref<JavaScript>> scripts;
 #endif
@@ -32,6 +38,10 @@ class JavaScriptLanguage : public ScriptLanguage {
 		return nullptr;
 	}
 
+	_FORCE_INLINE_ CallableMiddleman *get_callable_middleman() const {
+		return callable_middleman;
+	}
+
 	_FORCE_INLINE_ virtual String get_name() const override { return "JavaScript"; }
 	const GDNativeInstanceBindingCallbacks *get_instance_binding_callbacks() const { return &instance_binding_callbacks; }
 #ifdef TOOLS_ENABLED
diff --git a/quickjs/quickjs_binder.cpp b/quickjs/quickjs_binder.cpp
index e75ac478..6353d2d5 100644
--- a/quickjs/quickjs_binder.cpp
+++ b/quickjs/quickjs_binder.cpp
@@ -15,6 +15,7 @@
 #ifdef TOOLS_ENABLED
 #include "editor/editor_settings.h"
 #endif
+#include "quickjs_callable.h"
 #include <cstring>
 
 SafeNumeric<uint32_t> QuickJSBinder::global_context_id;
@@ -547,6 +548,19 @@ JSValue QuickJSBinder::godot_instance_from_id(JSContext *ctx, JSValue this_val,
 	return variant_to_var(ctx, obj);
 }
 
+JSValue QuickJSBinder::godot_object_method_connect(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+#ifdef DEBUG_METHODS_ENABLED
+	ERR_FAIL_COND_V(argc < 2 || !JS_IsString(argv[0]) || !JS_IsFunction(ctx, argv[1]), JS_ThrowTypeError(ctx, "string and function expected for %s.%s", "Object", "connect"));
+#endif
+	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
+	Object *obj = bind->get_godot_object();
+	StringName signal = binder->js_to_string(ctx, argv[0]);
+	Callable callable = memnew(QuickJSCallable(ctx, argv[1]));
+	obj->connect(signal, callable);
+	return JS_UNDEFINED;
+}
+
 void QuickJSBinder::add_debug_binding_info(JSContext *ctx, JSValueConst p_obj, const JavaScriptGCHandler *p_bind) {
 	if (!p_bind)
 		return;
@@ -831,6 +845,15 @@ JSClassID QuickJSBinder::register_class(const ClassDB::ClassInfo *p_cls) {
 	{
 		godot_methods.resize(internal_godot_method_id + p_cls->method_map.size());
 		for (const KeyValue<StringName, MethodBind *> &pair : p_cls->method_map) {
+			if (p_cls->name == "Object") {
+				const char *connect = "connect";
+				if (pair.key == connect) {
+					JSValue func = JS_NewCFunction(ctx, godot_object_method_connect, connect, 3);
+					JS_DefinePropertyValueStr(ctx, data.prototype, connect, func, PROP_DEF_DEFAULT);
+					continue;
+				}
+			}
+
 			MethodBind *mb = pair.value;
 			godot_methods.set(internal_godot_method_id, mb);
 			CharString name = String(pair.key).ascii();
@@ -2052,9 +2075,18 @@ Variant QuickJSBinder::call_method(const JavaScriptGCHandler &p_object, const St
 	JSAtom atom = get_atom(ctx, p_method);
 	JSValue method = JS_GetProperty(ctx, object, atom);
 	JS_FreeAtom(ctx, atom);
+	JavaScriptGCHandler func;
+	func.javascript_object = JS_VALUE_GET_PTR(method);
+	Variant ret = call(func, p_object, p_args, p_argcount, r_error);
+	JS_FreeValue(ctx, method);
+	return ret;
+}
 
+Variant QuickJSBinder::call(const JavaScriptGCHandler &p_fuction, const JavaScriptGCHandler &p_target, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
 	JSValue return_val = JS_UNDEFINED;
 	JSValue *argv = NULL;
+	JSValue method = JS_MKPTR(JS_TAG_OBJECT, p_fuction.javascript_object);
+	JSValue object = p_target.is_valid_javascript_object() ? JS_MKPTR(JS_TAG_OBJECT, p_target.javascript_object) : JS_UNDEFINED;
 
 	if (!JS_IsFunction(ctx, method) || JS_IsPureCFunction(ctx, method)) {
 		r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
@@ -2086,7 +2118,6 @@ Variant QuickJSBinder::call_method(const JavaScriptGCHandler &p_object, const St
 		memdelete_arr(argv);
 	}
 	JS_FreeValue(ctx, return_val);
-	JS_FreeValue(ctx, method);
 	return ret;
 }
 
diff --git a/quickjs/quickjs_binder.h b/quickjs/quickjs_binder.h
index 3ce58497..1be30191 100644
--- a/quickjs/quickjs_binder.h
+++ b/quickjs/quickjs_binder.h
@@ -178,6 +178,8 @@ class QuickJSBinder : public JavaScriptBinder {
 	static JSValue godot_load(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
 	static JSValue godot_instance_from_id(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
 
+	static JSValue godot_object_method_connect(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+
 	static void add_debug_binding_info(JSContext *ctx, JSValueConst p_obj, const JavaScriptGCHandler *p_bind);
 
 	const JavaScriptClassInfo *register_javascript_class(const JSValueConst &p_constructor, const String &p_path);
@@ -330,13 +332,16 @@ class QuickJSBinder : public JavaScriptBinder {
 	const JavaScriptClassInfo *parse_javascript_class_from_module(ModuleCache *p_module, const String &p_path, JavaScriptError *r_error);
 
 	virtual JavaScriptGCHandler create_js_instance_for_godot_object(const JavaScriptClassInfo *p_class, Object *p_object) override;
-	virtual Variant call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override;
+
 	virtual bool get_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) override;
 	virtual bool set_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) override;
 	virtual bool has_method(const JavaScriptGCHandler &p_object, const StringName &p_name) override;
 	virtual bool has_signal(const JavaScriptClassInfo *p_class, const StringName &p_signal) override;
 	virtual bool validate(const String &p_code, const String &p_path, JavaScriptError *r_error) override;
 
+	virtual Variant call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override;
+	virtual Variant call(const JavaScriptGCHandler &p_fuction, const JavaScriptGCHandler &p_target, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override;
+
 #ifdef TOOLS_ENABLED
 	virtual const Dictionary &get_modified_api() const override { return modified_api; }
 #endif
diff --git a/quickjs/quickjs_callable.cpp b/quickjs/quickjs_callable.cpp
new file mode 100644
index 00000000..fa8384ae
--- /dev/null
+++ b/quickjs/quickjs_callable.cpp
@@ -0,0 +1,65 @@
+#include "quickjs_callable.h"
+#include "../javascript_language.h"
+#include "quickjs/quickjs.h"
+#include "quickjs_binder.h"
+
+bool QuickJSCallable::compare_equal(const CallableCustom *p_a, const CallableCustom *p_b) {
+	const QuickJSCallable *a = static_cast<const QuickJSCallable *>(p_a);
+	const QuickJSCallable *b = static_cast<const QuickJSCallable *>(p_b);
+	return a->js_function.javascript_object == b->js_function.javascript_object;
+}
+
+bool QuickJSCallable::compare_less(const CallableCustom *p_a, const CallableCustom *p_b) {
+	if (compare_equal(p_a, p_b)) {
+		return false;
+	}
+	return p_a < p_b;
+}
+
+QuickJSCallable::QuickJSCallable(JSContext *ctx, const JSValue &p_value) {
+	ERR_FAIL_COND(JS_IsFunction(ctx, p_value));
+	JSValue v = JS_DupValue(ctx, p_value);
+	js_function.context = ctx;
+	js_function.javascript_object = JS_VALUE_GET_PTR(v);
+}
+
+QuickJSCallable::QuickJSCallable(const JavaScriptGCHandler &p_function) : JavaScriptCallable(p_function) {
+	JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, p_function.javascript_object);
+	JSContext *ctx = static_cast<JSContext *>(p_function.context);
+	ERR_FAIL_COND(JS_IsFunction(ctx, js_func));
+	JS_DupValue(ctx, js_func);
+}
+
+QuickJSCallable::~QuickJSCallable() {
+	if (js_function.is_valid_javascript_object()) {
+		JSContext *ctx = static_cast<JSContext *>(js_function.context);
+		JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, js_function.javascript_object);
+		JS_FreeValue(ctx, js_func);
+	}
+}
+
+uint32_t QuickJSCallable::hash() const {
+	JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, js_function.javascript_object);
+	return hash_murmur3_one_64((uint64_t)JS_VALUE_GET_PTR(js_func));
+}
+
+String QuickJSCallable::get_as_text() const {
+	QuickJSBinder *binder = QuickJSBinder::get_context_binder(static_cast<JSContext *>(js_function.context));
+	JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, js_function.javascript_object);
+	JSContext *ctx = static_cast<JSContext *>(js_function.context);
+	String text = binder->js_to_string(ctx, js_func);
+	return text;
+}
+
+ObjectID QuickJSCallable::get_object() const {
+	return JavaScriptLanguage::get_singleton()->get_callable_middleman()->get_instance_id();
+}
+
+void QuickJSCallable::call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, Callable::CallError &r_call_error) const {
+	QuickJSBinder *binder = QuickJSBinder::get_context_binder(static_cast<JSContext *>(js_function.context));
+	JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, js_function.javascript_object);
+	JavaScriptGCHandler func;
+	func.javascript_object = JS_VALUE_GET_PTR(js_func);
+	JavaScriptGCHandler caller;
+	r_return_value = binder->call(func, caller, p_arguments, p_argcount, r_call_error);
+}
diff --git a/quickjs/quickjs_callable.h b/quickjs/quickjs_callable.h
new file mode 100644
index 00000000..05f235d5
--- /dev/null
+++ b/quickjs/quickjs_callable.h
@@ -0,0 +1,26 @@
+#ifndef QUICKJS_CALLABLE_H
+#define QUICKJS_CALLABLE_H
+#include "../javascript_callable.h"
+#include "quickjs/quickjs.h"
+struct JSValue;
+
+class QuickJSCallable : public JavaScriptCallable {
+	static bool compare_equal(const CallableCustom *p_a, const CallableCustom *p_b);
+	static bool compare_less(const CallableCustom *p_a, const CallableCustom *p_b);
+
+public:
+	QuickJSCallable(JSContext *ctx, const JSValue &p_value);
+	QuickJSCallable(const JavaScriptGCHandler &p_function);
+	virtual ~QuickJSCallable();
+
+	virtual uint32_t hash() const override;
+	virtual String get_as_text() const override;
+
+	virtual CompareEqualFunc get_compare_equal_func() const override { return QuickJSCallable::compare_equal; }
+	virtual CompareLessFunc get_compare_less_func() const override { return QuickJSCallable::compare_less; }
+
+	virtual ObjectID get_object() const override;
+	virtual void call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, Callable::CallError &r_call_error) const override;
+};
+
+#endif // QUICKJS_CALLABLE_H
diff --git a/tests/UnitTest.js b/tests/UnitTest.js
index 4f1f76ff..3b64a92f 100644
--- a/tests/UnitTest.js
+++ b/tests/UnitTest.js
@@ -16,6 +16,27 @@ test('new Resource', () => {
 	return ok;
 }, 'core');
 
+test('Object.prototype.get_class', () => {
+	let obj = new godot.Object();
+	let ok = obj.get_class() === 'Object';
+	obj.free();
+	return ok;
+}, 'core')
+
+test('Object.prototype.connect', () => {
+	let ok = typeof godot.Object.prototype.connect === 'function';
+	if (!ok) return ok;
+
+	let obj = new godot.Object();
+	obj.connect('script_changed', (...args)=> {
+		console.log(`signal 'script_changed' emited with:`, ...args);
+		ok = true;
+	});
+	obj.emit_signal('script_changed');
+	obj.free();
+	return ok;
+}, 'core')
+
 
 // --------------------------- Unit Test Implementation ------------------------
 function test(description, blcok, group = 'default') {
diff --git a/tools/editor_tools.cpp b/tools/editor_tools.cpp
index 85eb788a..1c705fa9 100644
--- a/tools/editor_tools.cpp
+++ b/tools/editor_tools.cpp
@@ -606,10 +606,6 @@ void JavaScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 						dict["name"] = format_property_name(enums[i]->name);
 						dict["value"] = enums[i]->value;
 
-						// Exceptions
-						if (dict["name"] == "KEY_MASK_CMD") {
-							dict["value"] = (uint64_t)KeyModifierMask::CMD;
-						}
 						enum_str += apply_pattern(const_str, dict);
 					}
 					enum_str += "\t}\n";

From fbc40b65f9b4085b85171356a7b40ffd1a60f84b Mon Sep 17 00:00:00 2001
From: Geequlim <geequlim@gmail.com>
Date: Fri, 23 Sep 2022 23:18:33 +0800
Subject: [PATCH 08/71] Implement script workflow Godot call javascript is
 working [ci skip]

---
 README.md                    | 10 ++--
 javascript.cpp               | 30 +++++++-----
 javascript.h                 | 14 +++---
 javascript_instance.cpp      |  5 +-
 javascript_language.cpp      | 90 +++++++++++++++++++++---------------
 javascript_language.h        |  4 +-
 quickjs/quickjs_binder.cpp   |  2 +-
 quickjs/quickjs_callable.cpp |  2 +-
 tests/UnitTest.js            |  2 +-
 9 files changed, 91 insertions(+), 68 deletions(-)

diff --git a/README.md b/README.md
index 16239642..3a2c4b8e 100644
--- a/README.md
+++ b/README.md
@@ -47,7 +47,7 @@ export default class MySprite extends godot.Sprite {
 	}
 }
 ```
-2. Save the script with extension `.jsx`
+2. Save the script with extension `.msx`
 3. Attach the script file to the node or resource object like you do with GDScript
 
 ##### How to export signals
@@ -179,17 +179,17 @@ Label.Align.ALIGN_LEFT | godot.Label.Align.ALIGN_LEFT
 		}
 		```
 	
-### TypeScript support and JSX code completion
+### TypeScript support
 - Run the menu command `Project > Tools > JavaScript > Generate TypeScript Project` from the godot editor to generate a TypeScript project
 - Run `tsc -w -p .` under your project folder in the terminal to compile scripts
 
 #### Code completion
-- Code completion in TSX will automatically work once the TypeScript project is generated by the above steps.
-- Code completion in JSX in VS Code is achieved by the property `"types": "./godot.d.ts"` in the generated package.json file of the TypeScript project. The `godot.d.ts` file can be generated alone via the `Project > Tools > ECMAScript > Generate TypeScript Declaration File` editor menu option and added to a `package.json` file manually to achieve this without a full TypeScript project.
+- Code completion in TS will automatically work once the TypeScript project is generated by the above steps.
+- Code completion in VSCode is achieved by the property `"types": "./godot.d.ts"` in the generated package.json file of the TypeScript project. The `godot.d.ts` file can be generated alone via the `Project > Tools > ECMAScript > Generate TypeScript Declaration File` editor menu option and added to a `package.json` file manually to achieve this without a full TypeScript project.
 
 #### Example TypeScript Usage
 
-Make sure the file with extension '.tsx' so it can be compiled to a `.jsx` file then we can attach it to a node in godot editor.
+Compile your `ts` script to a `.mjs` file then we can attach it to a node in godot editor.
 
 Most of the `register` functions are available as various decorators as seen below.
 
diff --git a/javascript.cpp b/javascript.cpp
index 5c9452eb..6445358f 100644
--- a/javascript.cpp
+++ b/javascript.cpp
@@ -231,10 +231,11 @@ bool JavaScript::is_valid() const {
 void JavaScript::_bind_methods() {
 }
 
-Ref<Resource> ResourceFormatLoaderJavaScript::load(const String &p_path, const String &p_original_path, Error *r_error) {
+Ref<Resource> ResourceFormatLoaderJavaScript::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, CacheMode p_cache_mode) {
 	Error err = OK;
 	Ref<JavaScriptModule> module = ResourceFormatLoaderJavaScriptModule::load_static(p_path, p_original_path, &err);
-	if (r_error) *r_error = err;
+	if (r_error)
+		*r_error = err;
 	ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), "Cannot load script file '" + p_path + "'.");
 	Ref<JavaScript> script;
 	script.instantiate();
@@ -242,7 +243,8 @@ Ref<Resource> ResourceFormatLoaderJavaScript::load(const String &p_path, const S
 	script->bytecode = module->get_bytecode();
 	script->set_source_code(module->get_source_code());
 	err = script->reload();
-	if (r_error) *r_error = err;
+	if (r_error)
+		*r_error = err;
 	ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), "Parse source code from file '" + p_path + "' failed.");
 #ifdef TOOLS_ENABLED
 	JavaScriptLanguage::get_singleton()->get_scripts().insert(script);
@@ -252,8 +254,6 @@ Ref<Resource> ResourceFormatLoaderJavaScript::load(const String &p_path, const S
 
 void ResourceFormatLoaderJavaScript::get_recognized_extensions(List<String> *p_extensions) const {
 	p_extensions->push_front(EXT_JSCLASS);
-	p_extensions->push_front(EXT_JSCLASS_BYTECODE);
-	p_extensions->push_front(EXT_JSCLASS_ENCRYPTED);
 }
 
 void ResourceFormatLoaderJavaScript::get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const {
@@ -266,11 +266,16 @@ bool ResourceFormatLoaderJavaScript::handles_type(const String &p_type) const {
 
 String ResourceFormatLoaderJavaScript::get_resource_type(const String &p_path) const {
 	String el = p_path.get_extension().to_lower();
-	if (el == EXT_JSCLASS || el == EXT_JSCLASS_BYTECODE || el == EXT_JSCLASS_ENCRYPTED) return JavaScript::get_class_static();
+	if (el == EXT_JSCLASS)
+		return JavaScript::get_class_static();
 	return "";
 }
 
-Error ResourceFormatSaverJavaScript::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
+bool ResourceFormatLoaderJavaScript::recognize_path(const String &p_path, const String &p_for_type) const {
+	return p_path.get_extension() == EXT_JSCLASS;
+}
+
+Error ResourceFormatSaverJavaScript::save(const Ref<Resource> &p_resource, const String &p_path, uint32_t p_flags) {
 	Ref<JavaScript> script = p_resource;
 	ERR_FAIL_COND_V(script.is_null(), ERR_INVALID_PARAMETER);
 
@@ -321,8 +326,6 @@ Ref<Resource> ResourceFormatLoaderJavaScriptModule::load(const String &p_path, c
 
 void ResourceFormatLoaderJavaScriptModule::get_recognized_extensions(List<String> *p_extensions) const {
 	p_extensions->push_front(EXT_JSMODULE);
-	p_extensions->push_front(EXT_JSMODULE_BYTECODE);
-	p_extensions->push_front(EXT_JSMODULE_ENCRYPTED);
 }
 
 void ResourceFormatLoaderJavaScriptModule::get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const {
@@ -335,7 +338,7 @@ bool ResourceFormatLoaderJavaScriptModule::handles_type(const String &p_type) co
 
 String ResourceFormatLoaderJavaScriptModule::get_resource_type(const String &p_path) const {
 	String el = p_path.get_extension().to_lower();
-	if (el == EXT_JSMODULE || el == EXT_JSMODULE_BYTECODE || el == EXT_JSMODULE_ENCRYPTED)
+	if (el == EXT_JSMODULE)
 		return JavaScriptModule::get_class_static();
 	return "";
 }
@@ -350,7 +353,10 @@ Ref<Resource> ResourceFormatLoaderJavaScriptModule::load_static(const String &p_
 		if (r_error) *r_error = err;
 		ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), "Cannot load source code from file '" + p_path + "'.");
 		module->set_source_code(code);
-	} else if (p_path.ends_with("." EXT_JSMODULE_BYTECODE) || p_path.ends_with("." EXT_JSCLASS_BYTECODE)) {
+	}
+
+#if 0
+	else if (p_path.ends_with("." EXT_JSMODULE_BYTECODE) || p_path.ends_with("." EXT_JSCLASS_BYTECODE)) {
 		module->set_bytecode(FileAccess::get_file_as_array(p_path, &err));
 		if (r_error) *r_error = err;
 		ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), "Cannot load bytecode from file '" + p_path + "'.");
@@ -380,6 +386,8 @@ Ref<Resource> ResourceFormatLoaderJavaScriptModule::load_static(const String &p_
 			err = ERR_CANT_OPEN;
 		}
 	}
+#endif
+
 	if (r_error) *r_error = err;
 	ERR_FAIL_COND_V(err != OK, Ref<Resource>());
 	return module;
diff --git a/javascript.h b/javascript.h
index 3f37d63d..0c499bdd 100644
--- a/javascript.h
+++ b/javascript.h
@@ -7,12 +7,8 @@
 #include "javascript_binder.h"
 #include "scene/resources/text_file.h"
 
-#define EXT_JSCLASS "jsx"
-#define EXT_JSCLASS_BYTECODE EXT_JSCLASS "b"
-#define EXT_JSCLASS_ENCRYPTED EXT_JSCLASS "e"
+#define EXT_JSCLASS "mjs"
 #define EXT_JSMODULE "js"
-#define EXT_JSMODULE_BYTECODE EXT_JSMODULE "b"
-#define EXT_JSMODULE_ENCRYPTED EXT_JSMODULE "e"
 #define EXT_JSON "json"
 
 class JavaScript : public Script {
@@ -90,17 +86,19 @@ class JavaScript : public Script {
 class ResourceFormatLoaderJavaScript : public ResourceFormatLoader {
 	GDCLASS(ResourceFormatLoaderJavaScript, ResourceFormatLoader)
 public:
-	virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
+	virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, CacheMode p_cache_mode = CACHE_MODE_REUSE) override;
 	virtual void get_recognized_extensions(List<String> *p_extensions) const override;
-	virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const override;
 	virtual bool handles_type(const String &p_type) const override;
+	virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const override;
 	virtual String get_resource_type(const String &p_path) const override;
+
+	virtual bool recognize_path(const String &p_path, const String &p_for_type = String()) const override;
 };
 
 class ResourceFormatSaverJavaScript : public ResourceFormatSaver {
 	GDCLASS(ResourceFormatSaverJavaScript, ResourceFormatSaver)
 public:
-	virtual Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags = 0);
+	virtual Error save(const Ref<Resource> &p_resource, const String &p_path, uint32_t p_flags = 0) override;
 	virtual void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const override;
 	virtual bool recognize(const Ref<Resource> &p_resource) const override;
 };
diff --git a/javascript_instance.cpp b/javascript_instance.cpp
index 12d543fe..af0e67b8 100644
--- a/javascript_instance.cpp
+++ b/javascript_instance.cpp
@@ -56,7 +56,10 @@ Variant JavaScriptInstance::callp(const StringName &p_method, const Variant **p_
 		r_error.error = Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL;
 		ERR_FAIL_V(Variant());
 	}
-	return binder->call_method(javascript_object, p_method, p_args, p_argcount, r_error);
+	if (binder->has_method(javascript_object, p_method)) {
+		return binder->call_method(javascript_object, p_method, p_args, p_argcount, r_error);
+	}
+	return Variant();
 }
 
 ScriptLanguage *JavaScriptInstance::get_language() {
diff --git a/javascript_language.cpp b/javascript_language.cpp
index 915a4ec3..58601b2b 100644
--- a/javascript_language.cpp
+++ b/javascript_language.cpp
@@ -105,6 +105,7 @@ void JavaScriptLanguage::get_reserved_words(List<String> *p_words) const {
 		"const",
 		"enum",
 		"export",
+		"default",
 		"extends",
 		"import",
 		"super",
@@ -204,7 +205,6 @@ bool JavaScriptLanguage::is_control_flow_keyword(String p_keyword) const {
 		   p_keyword == "continue" ||
 		   p_keyword == "switch" ||
 		   p_keyword == "case" ||
-		   p_keyword == "default" ||
 		   p_keyword == "throw" ||
 		   p_keyword == "try" ||
 		   p_keyword == "catch" ||
@@ -222,46 +222,64 @@ void JavaScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const
 	p_delimiters->push_back("` `");
 }
 
-Ref<Script> JavaScriptLanguage::get_template(const String &p_class_name, const String &p_base_class_name) const {
-	String script_template = "export default class %CLASS% extends " GODOT_OBJECT_NAME ".%BASE% {\n"
-							 "    \n"
-							 "    // Declare member variables here. Examples:\n"
-							 "    a = 2;\n"
-							 "    b = \"text\";\n"
-							 "    \n"
-							 "    constructor() {\n"
-							 "        super();\n"
-							 "    }\n"
-							 "    \n"
-							 "    // Called when the node enters the scene tree for the first time.\n"
-							 "    _ready() {\n"
-							 "        \n"
-							 "    }\n"
-							 "    \n"
-							 "    // Called every frame. 'delta' is the elapsed time since the previous frame.\n"
-							 "    _process(delta) {\n"
-							 "        \n"
-							 "    }\n"
-							 "}\n";
-	script_template = script_template.replace("%BASE%", p_base_class_name).replace("%CLASS%", p_class_name);
-
-	Ref<JavaScript> script;
-	script.instantiate();
-	script->set_source_code(script_template);
-	script->set_name(p_class_name);
-	script->set_script_path(p_class_name);
-	return script;
-}
-
 Ref<Script> JavaScriptLanguage::make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const {
 	Ref<JavaScript> script;
 	script.instantiate();
-	String src = script->get_source_code();
-	src = src.replace("%BASE%", p_base_class_name).replace("%CLASS%", p_class_name);
+	String src = p_template.replace("%BASE%", p_base_class_name).replace("%CLASS%", p_class_name);
 	script->set_source_code(src);
 	return script;
 }
 
+Vector<ScriptLanguage::ScriptTemplate> JavaScriptLanguage::get_built_in_templates(StringName p_object) {
+	Vector<ScriptLanguage::ScriptTemplate> templates;
+#ifdef TOOLS_ENABLED
+	constexpr size_t len = 2;
+	static const struct ScriptLanguage::ScriptTemplate TEMPLATES[len] = {
+		{ "Node",
+			"Default",
+			"Base template for Node with default Godot cycle methods",
+			"export default class %CLASS% extends " GODOT_OBJECT_NAME ".%BASE% {\n"
+			"    \n"
+			"    constructor() {\n"
+			"        super();\n"
+			"    }\n"
+			"    \n"
+			"    // Called when the node enters the scene tree for the first time.\n"
+			"    _ready() {\n"
+			"        \n"
+			"    }\n"
+			"    \n"
+			"    // Called every frame. 'delta' is the elapsed time since the previous frame.\n"
+			"    _process(delta) {\n"
+			"        \n"
+			"    }\n"
+			"}\n" },
+		{ "Object",
+			"Empty",
+			"Empty template suitable for all Objects",
+			"export default class %CLASS% extends " GODOT_OBJECT_NAME ".%BASE% {\n"
+			"    \n"
+			"    // Declare member variables here. Examples:\n"
+			"    a = 2;\n"
+			"    b = \"text\";\n"
+			"    \n"
+			"    constructor() {\n"
+			"        super();\n"
+			"    }\n"
+			"    \n"
+			"}\n" },
+	};
+
+	for (int i = 0; i < len; i++) {
+		if (TEMPLATES[i].inherit == p_object) {
+			templates.append(TEMPLATES[i]);
+		}
+	}
+#endif
+
+	return templates;
+}
+
 bool JavaScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptError> *r_errors, List<Warning> *r_warnings, HashSet<int> *r_safe_lines) const {
 	JavaScriptError script_error;
 	bool ret = main_binder->validate(p_script, p_path, &script_error);
@@ -303,10 +321,6 @@ void JavaScriptLanguage::get_recognized_extensions(List<String> *p_extensions) c
 	p_extensions->push_back(EXT_JSMODULE);
 	p_extensions->push_back(EXT_JSCLASS);
 	p_extensions->push_back(EXT_JSON);
-	p_extensions->push_back(EXT_JSMODULE_ENCRYPTED);
-	p_extensions->push_back(EXT_JSMODULE_BYTECODE);
-	p_extensions->push_back(EXT_JSCLASS_ENCRYPTED);
-	p_extensions->push_back(EXT_JSCLASS_BYTECODE);
 }
 
 void JavaScriptLanguage::frame() {
diff --git a/javascript_language.h b/javascript_language.h
index 2b4e2739..f7e0fec2 100644
--- a/javascript_language.h
+++ b/javascript_language.h
@@ -61,13 +61,13 @@ class JavaScriptLanguage : public ScriptLanguage {
 	virtual void get_comment_delimiters(List<String> *p_delimiters) const override;
 	virtual void get_string_delimiters(List<String> *p_delimiters) const override;
 
-	Ref<Script> get_template(const String &p_class_name, const String &p_base_class_name) const;
 	virtual Ref<Script> make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const override;
+	virtual Vector<ScriptTemplate> get_built_in_templates(StringName p_object) override;
+	virtual bool is_using_templates() override { return true; }
 
 	virtual Script *create_script() const override;
 	_FORCE_INLINE_ virtual bool has_named_classes() const override { return true; }
 	_FORCE_INLINE_ virtual bool supports_builtin_mode() const override { return false; }
-	_FORCE_INLINE_ virtual bool is_using_templates() override { return true; }
 
 	virtual bool validate(const String &p_script, const String &p_path = "", List<String> *r_functions = nullptr, List<ScriptError> *r_errors = nullptr, List<Warning> *r_warnings = nullptr, HashSet<int> *r_safe_lines = nullptr) const override;
 
diff --git a/quickjs/quickjs_binder.cpp b/quickjs/quickjs_binder.cpp
index 6353d2d5..7af69266 100644
--- a/quickjs/quickjs_binder.cpp
+++ b/quickjs/quickjs_binder.cpp
@@ -97,7 +97,7 @@ JSValue QuickJSBinder::console_functions(JSContext *ctx, JSValue this_val, int a
 	String message = "";
 	for (int i = 0; i < argc; ++i) {
 		message += args[i];
-		if (i > 0 && i < argc - 1) {
+		if (i < argc - 1) {
 			message += " ";
 		}
 	}
diff --git a/quickjs/quickjs_callable.cpp b/quickjs/quickjs_callable.cpp
index fa8384ae..24799d7e 100644
--- a/quickjs/quickjs_callable.cpp
+++ b/quickjs/quickjs_callable.cpp
@@ -17,7 +17,7 @@ bool QuickJSCallable::compare_less(const CallableCustom *p_a, const CallableCust
 }
 
 QuickJSCallable::QuickJSCallable(JSContext *ctx, const JSValue &p_value) {
-	ERR_FAIL_COND(JS_IsFunction(ctx, p_value));
+	ERR_FAIL_COND(!JS_IsFunction(ctx, p_value));
 	JSValue v = JS_DupValue(ctx, p_value);
 	js_function.context = ctx;
 	js_function.javascript_object = JS_VALUE_GET_PTR(v);
diff --git a/tests/UnitTest.js b/tests/UnitTest.js
index 3b64a92f..6954d6e7 100644
--- a/tests/UnitTest.js
+++ b/tests/UnitTest.js
@@ -32,7 +32,7 @@ test('Object.prototype.connect', () => {
 		console.log(`signal 'script_changed' emited with:`, ...args);
 		ok = true;
 	});
-	obj.emit_signal('script_changed');
+	obj.emit_signal('script_changed', 123, 'hello');
 	obj.free();
 	return ok;
 }, 'core')

From 19b54c1a82bcb9132792e120a30c8e22a3a12b01 Mon Sep 17 00:00:00 2001
From: Geequlim <geequlim@gmail.com>
Date: Fri, 23 Sep 2022 23:21:50 +0800
Subject: [PATCH 09/71] fix typo

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 3a2c4b8e..3b3a3b0f 100644
--- a/README.md
+++ b/README.md
@@ -47,7 +47,7 @@ export default class MySprite extends godot.Sprite {
 	}
 }
 ```
-2. Save the script with extension `.msx`
+2. Save the script with extension `.mjs`
 3. Attach the script file to the node or resource object like you do with GDScript
 
 ##### How to export signals

From c21426e74fdb3bb6ac7e6436aed1acae829471ec Mon Sep 17 00:00:00 2001
From: why-try313 <fx.schindel@gmail.com>
Date: Tue, 21 Feb 2023 11:11:49 +0100
Subject: [PATCH 10/71] [FIX] Failsafe env["TOOLS"] variable getter

---
 SCsub | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/SCsub b/SCsub
index b8486b59..aa80b6a1 100644
--- a/SCsub
+++ b/SCsub
@@ -5,6 +5,7 @@ Import('env')
 Import('env_modules')
 env_module = env_modules.Clone()
 JS_ENGINE = 'quickjs'
+TOOLS = env.get('TOOLS');
 
 def open_file(path, mode):
 	if platform.python_version() > '3':
@@ -41,7 +42,7 @@ if JS_ENGINE == 'quickjs':
 	env_module.Append(CPPPATH=["quickjs/quickjs"])
 	# env_module.Append(CXXFLAGS=["-std=c++20"])
 	# env_module.Append(CCFLAGS=["-std=c++20"])
-	if env['tools']:
+	if TOOLS:
 		env_module.add_source_files(env.modules_sources, 'tools/editor_tools.cpp')
 	env_module.add_source_files(env.modules_sources, 'quickjs/quickjs_builtin_binder.gen.cpp')
 	env_module.add_source_files(env.modules_sources, 'quickjs/*.cpp')
@@ -60,7 +61,7 @@ sources = [
 	'misc/godot.binding_script.gen.cpp',
 ]
 
-if env['tools']:
+if TOOLS:
 	base_text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
 	tool_fns = {"tools/godot.d.ts.gen.cpp": ("BUILTIN_DECLARATION_TEXT", dump_text_file_to_cpp("misc/godot.d.ts")),
 		"tools/tsconfig.json.gen.cpp": ("TSCONFIG_CONTENT", dump_text_file_to_cpp("misc/tsconfig.json")),

From 331496370c31eb6452288608e13de8aabe78317c Mon Sep 17 00:00:00 2001
From: why-try313 <fx.schindel@gmail.com>
Date: Tue, 21 Feb 2023 11:13:53 +0100
Subject: [PATCH 11/71] [FIX] Fixed missing comma

---
 javascript_language.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/javascript_language.cpp b/javascript_language.cpp
index 58601b2b..a1d1b919 100644
--- a/javascript_language.cpp
+++ b/javascript_language.cpp
@@ -163,7 +163,7 @@ void JavaScriptLanguage::get_reserved_words(List<String> *p_words) const {
 		"RegExp",
 		"ArrayBuffer",
 		"SharedArrayBuffer",
-		"Uint8ClampedArray"
+		"Uint8ClampedArray",
 		"Int8Array",
 		"Uint8Array",
 		"Int16Array",

From 1216d8dabd9b4caaeda9d69109b44f79d7c6c5f2 Mon Sep 17 00:00:00 2001
From: why-try313 <fx.schindel@gmail.com>
Date: Tue, 21 Feb 2023 11:18:05 +0100
Subject: [PATCH 12/71] [FIX] Adds GDNative to GDExtension migration changes

---
 javascript_language.cpp |  2 +-
 javascript_language.h   |  4 ++--
 register_types.cpp      | 36 +++++++++++++++++++-----------------
 3 files changed, 22 insertions(+), 20 deletions(-)

diff --git a/javascript_language.cpp b/javascript_language.cpp
index a1d1b919..cd2fe07a 100644
--- a/javascript_language.cpp
+++ b/javascript_language.cpp
@@ -18,7 +18,7 @@ static void free_callback(void *p_token, void *p_instance, void *p_binding) {
 	}
 }
 
-static GDNativeBool reference_callback(void *p_token, void *p_binding, GDNativeBool p_reference) {
+static GDExtensionBool reference_callback(void *p_token, void *p_binding, GDExtensionBool p_reference) {
 	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
 		if (p_reference) {
 			binder->godot_refcount_incremented(static_cast<JavaScriptGCHandler *>(p_binding));
diff --git a/javascript_language.h b/javascript_language.h
index f7e0fec2..aaf0ee07 100644
--- a/javascript_language.h
+++ b/javascript_language.h
@@ -21,7 +21,7 @@ class JavaScriptLanguage : public ScriptLanguage {
 	static JavaScriptLanguage *singleton;
 	JavaScriptBinder *main_binder;
 	HashMap<Thread::ID, JavaScriptBinder *> thread_binder_map;
-	GDNativeInstanceBindingCallbacks instance_binding_callbacks;
+	GDExtensionInstanceBindingCallbacks instance_binding_callbacks;
 
 	CallableMiddleman *callable_middleman;
 #ifdef TOOLS_ENABLED
@@ -43,7 +43,7 @@ class JavaScriptLanguage : public ScriptLanguage {
 	}
 
 	_FORCE_INLINE_ virtual String get_name() const override { return "JavaScript"; }
-	const GDNativeInstanceBindingCallbacks *get_instance_binding_callbacks() const { return &instance_binding_callbacks; }
+	const GDExtensionInstanceBindingCallbacks *get_instance_binding_callbacks() const { return &instance_binding_callbacks; }
 #ifdef TOOLS_ENABLED
 	_FORCE_INLINE_ HashSet<Ref<JavaScript> > &get_scripts() { return scripts; }
 #endif
diff --git a/register_types.cpp b/register_types.cpp
index 9b68a728..8b5781f2 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -44,32 +44,34 @@ class EditorExportJavaScript : public EditorExportPlugin {
 
 public:
 	virtual void _export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features) override {
-		int script_mode = EditorExportPreset::MODE_SCRIPT_COMPILED;
+		String script_key;
+		// int script_mode = EditorExportPreset::MODE_SCRIPT_COMPILED;
 		const Ref<EditorExportPreset> &preset = get_export_preset();
 
-		if (preset.is_valid()) {
-			script_mode = preset->get_script_export_mode();
-		}
+		// if (preset.is_valid()) {
+		// 	script_mode = preset->get_file_export_mode(p_path);
+		// }
 
-		if (script_mode == EditorExportPreset::MODE_SCRIPT_TEXT)
-			return;
+		// if (script_mode == EditorExportPreset::MODE_SCRIPT_TEXT)
+		// 	return;
 
 		String extension = p_path.get_extension();
 		if (extension != EXT_JSCLASS && extension != EXT_JSMODULE)
 			return;
 
-		if (script_mode == EditorExportPreset::ScriptExportMode::MODE_SCRIPT_COMPILED) {
-#if 0 // Disable compile to bytecode as it is not battle tested on all platform
-			Error err;
-			String code = FileAccess::get_file_as_string(p_path, &err);
-			ERR_FAIL_COND(err != OK);
-
-			Vector<uint8_t> file;
-			ERR_FAIL_COND(JavaScriptLanguage::get_singleton()->get_main_binder()->compile_to_bytecode(code, p_path, file) != OK);
-			add_file(p_path.get_basename() + "." + extension + "b", file, true);
-#endif
-		}
+// 		if (script_mode == EditorExportPreset::FileExportMode::MODE_SCRIPT_COMPILED) {
+// #if 0 // Disable compile to bytecode as it is not battle tested on all platform
+// 			Error err;
+// 			String code = FileAccess::get_file_as_string(p_path, &err);
+// 			ERR_FAIL_COND(err != OK);
+
+// 			Vector<uint8_t> file;
+// 			ERR_FAIL_COND(JavaScriptLanguage::get_singleton()->get_main_binder()->compile_to_bytecode(code, p_path, file) != OK);
+// 			add_file(p_path.get_basename() + "." + extension + "b", file, true);
+// #endif
+// 		}
 	}
+	virtual String _get_name() const override { return "JavaScript"; }
 };
 
 #endif

From 9b1695391c43aa456e001de517680c45d42ba69d Mon Sep 17 00:00:00 2001
From: why-try313 <fx.schindel@gmail.com>
Date: Tue, 21 Feb 2023 11:18:37 +0100
Subject: [PATCH 13/71] [FIX] Adds missing get_global_name method

---
 javascript.cpp | 4 ++++
 javascript.h   | 1 +
 2 files changed, 5 insertions(+)

diff --git a/javascript.cpp b/javascript.cpp
index 6445358f..411965e3 100644
--- a/javascript.cpp
+++ b/javascript.cpp
@@ -23,6 +23,10 @@ bool JavaScript::can_instantiate() const {
 #endif
 }
 
+StringName JavaScript::get_global_name() const {
+	return StringName();
+}
+
 StringName JavaScript::get_instance_base_type() const {
 	static StringName empty;
 	ERR_FAIL_NULL_V(javascript_class, empty);
diff --git a/javascript.h b/javascript.h
index 0c499bdd..1ffbf1a3 100644
--- a/javascript.h
+++ b/javascript.h
@@ -43,6 +43,7 @@ class JavaScript : public Script {
 	virtual Ref<Script> get_base_script() const override { return nullptr; }
 	virtual bool inherits_script(const Ref<Script> &p_script) const override { return false; }
 
+	StringName get_global_name() const override;
 	virtual StringName get_instance_base_type() const override;
 	virtual ScriptInstance *instance_create(Object *p_this) override;
 	virtual PlaceHolderScriptInstance *placeholder_instance_create(Object *p_this) override;

From 6bcd1fa2b869c45021da14cdc97590b815ba1964 Mon Sep 17 00:00:00 2001
From: Malik Ahmed <animanmaster@gmail.com>
Date: Wed, 15 Mar 2023 20:59:32 +0000
Subject: [PATCH 14/71] Updated JavaScript modules for Godot 4.0 branch The
 commits address various issues, such as non-existent files, editor targets,
 module usage, and compilation errors. The messages also show an effort to
 align the project's GitHub actions with the main Godot repository and tackle
 platform-specific problems. Some commits address challenges related to
 advanced Linux builds and temporarily disable the "-werror" flag due to
 issues with QuickJS.

---
 .github/actions/godot-build/action.yml  |  12 +-
 .github/workflows/android_builds.yml    |  23 +--
 .github/workflows/ios_builds.yml        |  14 +-
 .github/workflows/javascript_builds.yml |  23 +--
 .github/workflows/linux_builds.yml      | 201 +++++++++++++++++-------
 .github/workflows/macos_builds.yml      |  39 +++--
 .github/workflows/server_builds.yml     |  35 +++--
 .github/workflows/windows_builds.yml    |  26 +--
 SCsub                                   |   4 +-
 build_github_actions.py                 |   2 +-
 javascript_language.h                   |   2 +-
 quickjs/quickjs_callable.h              |   4 +
 12 files changed, 263 insertions(+), 122 deletions(-)

diff --git a/.github/actions/godot-build/action.yml b/.github/actions/godot-build/action.yml
index bfb9ca15..564f40d9 100644
--- a/.github/actions/godot-build/action.yml
+++ b/.github/actions/godot-build/action.yml
@@ -2,8 +2,8 @@ name: Build Godot
 description: Build Godot with the provided options.
 inputs:
   target:
-    description: The scons target (debug/release_debug/release).
-    default: debug
+    description: The scons target (debug/editor/release).
+    default: editor
   tools:
     description: If tools are to be built.
     default: false
@@ -20,7 +20,7 @@ inputs:
     default: ${{ github.workspace }}/.scons-cache/
   scons-cache-limit:
     description: The scons cache size limit.
-    default: 4096
+    default: 7168
   shell:
     description: the shell to run this under
     default: sh
@@ -35,7 +35,8 @@ runs:
       SCONS_CACHE_LIMIT: ${{ inputs.scons-cache-limit }}
     run: |
       echo "Building with flags:" ${{ env.SCONSFLAGS }}
-      scons p=${{ inputs.platform }} target=${{ inputs.target }} tools=${{ inputs.tools }} tests=${{ inputs.tests }} --jobs=2 ${{ env.SCONSFLAGS }}
+      if [ "${{ inputs.target }}" != "editor" ]; then rm -rf editor; fi  # Ensure we don't include editor code.
+      scons platform=${{ inputs.platform }} target=${{ inputs.target }} tools=${{ inputs.tools }} tests=${{ inputs.tests }} --jobs=2 ${{ env.SCONSFLAGS }}
       ls -l bin/
     if: inputs.shell == 'sh'
   - name: Scons Build
@@ -46,6 +47,7 @@ runs:
       SCONS_CACHE_LIMIT: ${{ inputs.scons-cache-limit }}
     run: |
       echo "Building with flags:" ${{ env.SCONSFLAGS }}
-      scons p=${{ inputs.platform }} target=${{ inputs.target }} tools=${{ inputs.tools }} tests=${{ inputs.tests }} --jobs=2 ${{ env.SCONSFLAGS }}
+      if [ "${{ inputs.target }}" != "editor" ]; then rm -rf editor; rm -rf tools; fi  # Ensure we don't include editor code.
+      scons platform=${{ inputs.platform }} target=${{ inputs.target }} tools=${{ inputs.tools }} tests=${{ inputs.tests }} --jobs=2 ${{ env.SCONSFLAGS }}
       ls -l bin/
     if: inputs.shell == 'msys2 {0}'
diff --git a/.github/workflows/android_builds.yml b/.github/workflows/android_builds.yml
index de5db1b0..3506752c 100644
--- a/.github/workflows/android_builds.yml
+++ b/.github/workflows/android_builds.yml
@@ -3,8 +3,8 @@ name: 🤖 Android Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: 3.5-stable
-  SCONSFLAGS: '  verbose=yes   debug_symbols=no'
+  GODOT_BASE_BRANCH: "4.0"
+  SCONSFLAGS: verbose=yes warnings=extra debug_symbols=no module_text_server_fb_enabled=yes
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-android
   cancel-in-progress: true
@@ -21,37 +21,38 @@ jobs:
     - name: Checkout ECMAScript
       uses: actions/checkout@v2
       with:
-        path: ${{github.workspace}}/modules/ECMAScript/
+        path: ${{github.workspace}}/modules/javascript/
     - name: Make apt sources.list use the default Ubuntu repositories
       run: |
-        sudo rm -f /etc/apt/sources.list.d/*
-        sudo cp -f misc/ci/sources.list /etc/apt/sources.list
+        # sudo rm -f /etc/apt/sources.list.d/*
+        # sudo cp -f misc/ci/sources.list /etc/apt/sources.list
         sudo apt-get update
     - name: Set up Java 11
-      uses: actions/setup-java@v1
+      uses: actions/setup-java@v3
       with:
+        distribution: temurin
         java-version: 11
     - name: Setup Godot build cache
       uses: ./.github/actions/godot-cache
       continue-on-error: true
     - name: Setup python and scons
-      uses: ./modules/ECMAScript/.github/actions/godot-deps
+      uses: ./modules/javascript/.github/actions/godot-deps
       with:
         shell: sh
     - name: Compilation (armv7)
-      uses: ./modules/ECMAScript/.github/actions/godot-build
+      uses: ./modules/javascript/.github/actions/godot-build
       with:
         sconsflags: ${{ env.SCONSFLAGS }} android_arch=armv7
         platform: android
-        target: release
+        target: template_release
         tools: false
         shell: sh
     - name: Compilation (arm64v8)
-      uses: ./modules/ECMAScript/.github/actions/godot-build
+      uses: ./modules/javascript/.github/actions/godot-build
       with:
         sconsflags: ${{ env.SCONSFLAGS }} android_arch=arm64v8
         platform: android
-        target: release
+        target: template_release
         tools: false
         shell: sh
     - name: Generate Godot templates
diff --git a/.github/workflows/ios_builds.yml b/.github/workflows/ios_builds.yml
index 1f117d20..43a3575f 100644
--- a/.github/workflows/ios_builds.yml
+++ b/.github/workflows/ios_builds.yml
@@ -3,8 +3,8 @@ name: 🍏 iOS Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: 3.5-stable
-  SCONSFLAGS: '  verbose=yes   debug_symbols=no'
+  GODOT_BASE_BRANCH: "4.0"
+  SCONSFLAGS: verbose=yes warnings=extra debug_symbols=no module_text_server_fb_enabled=yes
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-ios
   cancel-in-progress: true
@@ -21,20 +21,20 @@ jobs:
     - name: Checkout ECMAScript
       uses: actions/checkout@v2
       with:
-        path: ${{github.workspace}}/modules/ECMAScript/
+        path: ${{github.workspace}}/modules/javascript/
     - name: Setup Godot build cache
       uses: ./.github/actions/godot-cache
       continue-on-error: true
     - name: Setup python and scons
-      uses: ./modules/ECMAScript/.github/actions/godot-deps
+      uses: ./modules/javascript/.github/actions/godot-deps
       with:
         shell: sh
     - name: Compilation (armv7)
-      uses: ./modules/ECMAScript/.github/actions/godot-build
+      uses: ./modules/javascript/.github/actions/godot-build
       with:
         sconsflags: ${{ env.SCONSFLAGS }}
-        platform: iphone
-        target: release
+        platform: ios
+        target: template_release
         tools: false
         shell: sh
     - name: Upload artifact
diff --git a/.github/workflows/javascript_builds.yml b/.github/workflows/javascript_builds.yml
index 5f1848ea..c7f2af2c 100644
--- a/.github/workflows/javascript_builds.yml
+++ b/.github/workflows/javascript_builds.yml
@@ -3,10 +3,11 @@ name: 🌐 JavaScript Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: 3.5-stable
-  SCONSFLAGS: '  verbose=yes   debug_symbols=no'
-  EM_VERSION: 2.0.25
-  EM_CACHE_FOLDER: emsdk-cache
+  GODOT_BASE_BRANCH: "4.0"
+  SCONSFLAGS: verbose=yes warnings=extra debug_symbols=no
+  EM_VERSION: 3.1.18
+  EM_CACHE_FOLDER: "emsdk-cache"
+
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-javascript
   cancel-in-progress: true
@@ -23,7 +24,7 @@ jobs:
     - name: Checkout ECMAScript
       uses: actions/checkout@v2
       with:
-        path: ${{github.workspace}}/modules/ECMAScript/
+        path: ${{github.workspace}}/modules/javascript/
     - name: Load Emscripten cache
       id: javascript-template-emscripten-cache
       uses: actions/cache@v2
@@ -31,7 +32,7 @@ jobs:
         path: ${{env.EM_CACHE_FOLDER}}
         key: ${{env.EM_VERSION}}-${{github.job}}
     - name: Set up Emscripten latest
-      uses: mymindstorm/setup-emsdk@v10
+      uses: mymindstorm/setup-emsdk@v12
       with:
         version: ${{env.EM_VERSION}}
         actions-cache-folder: ${{env.EM_CACHE_FOLDER}}
@@ -42,16 +43,16 @@ jobs:
       uses: ./.github/actions/godot-cache
       continue-on-error: true
     - name: Setup python and scons
-      uses: ./modules/ECMAScript/.github/actions/godot-deps
+      uses: ./modules/javascript/.github/actions/godot-deps
       with:
         shell: sh
     - name: Compilation
-      uses: ./modules/ECMAScript/.github/actions/godot-build
+      uses: ./modules/javascript/.github/actions/godot-build
       with:
         sconsflags: ${{ env.SCONSFLAGS }}
-        platform: javascript
-        target: release
-        tools: false
+        platform: web
+        target: template_release
+        tools: falsed
         shell: sh
     - name: Upload artifact
       uses: ./.github/actions/upload-artifact
diff --git a/.github/workflows/linux_builds.yml b/.github/workflows/linux_builds.yml
index 67861de0..3b33ad58 100644
--- a/.github/workflows/linux_builds.yml
+++ b/.github/workflows/linux_builds.yml
@@ -3,8 +3,11 @@ name: 🐧 Linux Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: 3.5-stable
-  SCONSFLAGS: '  verbose=yes  '
+  GODOT_BASE_BRANCH: "4.0"
+  SCONSFLAGS: '  verbose=yes warnings=extra module_text_server_fb_enabled=yes  '
+  DOTNET_NOLOGO: true
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
+
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-linux
   cancel-in-progress: true
@@ -16,30 +19,44 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - name: Editor w/ Mono (target=release_debug, tools=yes)
+        - name: Editor w/ Mono (target=editor, tools=yes)
           cache-name: linux-editor-mono
-          target: release_debug
+          target: editor
+          tests: false # Disabled due freeze caused by mix Mono build and CI
           tools: true
-          sconsflags: module_mono_enabled=yes mono_static=yes mono_glue=no
-          bin: ./bin/godot.x11.opt.tools.64.mono
+          sconsflags: module_mono_enabled=yes
+          doc-test: true
+          bin: "./bin/godot.linuxbsd.editor.x86_64.mono"
           build-mono: true
+          proj-conv: true
           artifact: true
-        - name: Editor and sanitizers (target=debug, tools=yes)
-          cache-name: linux-editor-sanitizers
-          target: debug
-          tools: true
-          sconsflags: ' '
-          test: true
-          bin: ./bin/godot.x11.tools.64s
+        - name: Editor with doubles and GCC sanitizers (target=editor, tests=yes, dev_build=yes, precision=double, use_asan=yes, use_ubsan=yes, linker=gold)
+          cache-name: linux-editor-double-sanitizers
+          target: editor
+          tests: true
+          # Debug symbols disabled as they're huge on this build and we hit the 14 GB limit for runners.
+          sconsflags: dev_build=yes debug_symbols=no precision=double use_asan=yes use_ubsan=yes linker=gold
+          proj-test: true
+          # Can be turned off for PRs that intentionally break compat with godot-cpp,
+          # until both the upstream PR and the matching godot-cpp changes are merged.
+          godot-cpp-test: true
+          bin: "./bin/godot.linuxbsd.editor.dev.double.x86_64.san"
           build-mono: false
+          # Skip 2GiB artifact speeding up action.
           artifact: false
-        - name: Template w/ Mono (target=release, tools=no)
+        - name: Template w/ Mono (target=template_release)
           cache-name: linux-template-mono
-          target: release
-          tools: false
-          sconsflags: module_mono_enabled=yes mono_static=yes mono_glue=no debug_symbols=no
+          target: template_release
+          tests: false
+          sconsflags: module_mono_enabled=yes
           build-mono: false
           artifact: true
+
+        - name: Minimal template (target=template_release, everything disabled)
+          cache-name: linux-template-minimal
+          target: template_release
+          tests: false
+          sconsflags: modules_enabled_by_default=no disable_3d=yes disable_advanced_gui=yes deprecated=no 
     steps:
     - name: Checkout Godot
       uses: actions/checkout@v2
@@ -49,13 +66,20 @@ jobs:
     - name: Checkout ECMAScript
       uses: actions/checkout@v2
       with:
-        path: ${{github.workspace}}/modules/ECMAScript/
+        path: ${{github.workspace}}/modules/javascript/
+    # Need newer mesa for lavapipe to work properly.
+    - name: Linux dependencies for tests
+      if: ${{ matrix.proj-test }}
+      run: |
+        sudo rm -f /etc/apt/sources.list.d/microsoft-prod.list
+        sudo add-apt-repository ppa:kisak/kisak-mesa
+        sudo apt-get install -qq mesa-vulkan-drivers
     - name: Linux dependencies
       shell: bash
       run: |
         # Azure repositories are not reliable, we need to prevent azure giving us packages.
-        sudo rm -f /etc/apt/sources.list.d/*
-        sudo cp -f misc/ci/sources.list /etc/apt/sources.list
+        # sudo rm -f /etc/apt/sources.list.d/*
+        # sudo cp -f misc/ci/sources.list /etc/apt/sources.list
         sudo apt-get update
         # The actual dependencies
         sudo apt-get install build-essential pkg-config libx11-dev libxcursor-dev \
@@ -67,59 +91,128 @@ jobs:
         cache-name: ${{ matrix.cache-name }}
       continue-on-error: true
     - name: Setup python and scons
-      uses: ./modules/ECMAScript/.github/actions/godot-deps
+      uses: ./modules/javascript/.github/actions/godot-deps
       with:
         shell: sh
+
+    - name: Set up .NET Sdk
+      uses: actions/setup-dotnet@v2
+      if: ${{ matrix.build-mono }}
+      with:
+        dotnet-version: '6.0.x'
+
+    - name: Setup GCC problem matcher
+      uses: ammaraskar/gcc-problem-matcher@master
+
     - name: Compilation
-      uses: ./modules/ECMAScript/.github/actions/godot-build
+      uses: ./modules/javascript/.github/actions/godot-build
       with:
         sconsflags: ${{ env.SCONSFLAGS }} ${{ matrix.sconsflags }}
         platform: linuxbsd
         target: ${{ matrix.target }}
         tools: ${{ matrix.tools }}
+        tests: ${{ matrix.tests }}
         shell: sh
-    - name: Generate Mono glue code
+
+    - name: Generate C# glue
       if: ${{ matrix.build-mono }}
       run: |
-        DRI_PRIME=0 xvfb-run ${{ matrix.bin }} --generate-mono-glue modules/mono/glue || true
-    - name: Compilation (mono_glue=yes)
-      uses: ./modules/ECMAScript/.github/actions/godot-build
+        ${{ matrix.bin }} --headless --generate-mono-glue ./modules/mono/glue || true
+
+    - name: Build .NET solutions
       if: ${{ matrix.build-mono }}
-      with:
-        sconsflags: ${{ env.SCONSFLAGS }} ${{ matrix.sconsflags }} mono_glue=yes
-        platform: linuxbsd
-        target: ${{ matrix.target }}
-        tools: ${{ matrix.tools }}
-        shell: sh
-    - name: Download test project
-      if: ${{ matrix.test }}
-      run: |
-        wget https://github.com/godotengine/regression-test-project/archive/3.4.zip
-        unzip 3.4.zip
-        mv "regression-test-project-3.4" "test_project"
-    - name: Open and close editor
-      if: ${{ matrix.test }}
-      run: |
-        DRI_PRIME=0 xvfb-run ${{ matrix.bin }} --audio-driver Dummy -e -q --path test_project 2>&1 | tee sanitizers_log.txt || true
-        misc/scripts/check_ci_log.py sanitizers_log.txt
-    - name: Run project
-      if: ${{ matrix.test }}
       run: |
-        DRI_PRIME=0 xvfb-run ${{ matrix.bin }} 30 --video-driver GLES3 --audio-driver Dummy --path test_project 2>&1 | tee sanitizers_log.txt || true
-        misc/scripts/check_ci_log.py sanitizers_log.txt
-    - name: Check for class reference updates
-      if: ${{ matrix.test }}
+        ./modules/mono/build_scripts/build_assemblies.py --godot-output-dir=./bin --godot-platform=linuxbsd
+
+    # Execute unit tests for the editor
+    - name: Unit tests
+      if: ${{ matrix.tests }}
       run: |
-        echo "Running --doctool to see if this changes the public API without updating the documentation."
-        echo -e "If a diff is shown, it means that your code/doc changes are incomplete and you should update the class reference with --doctool.\n\n"
-        DRI_PRIME=0 xvfb-run ${{ matrix.bin }} --doctool . 2>&1 > /dev/null || true
-        git diff --color --exit-code && ! git ls-files --others --exclude-standard | sed -e 's/^/New doc file missing in PR: /' | grep 'xml$'
+        ${{ matrix.bin }} --version
+        ${{ matrix.bin }} --help
+        ${{ matrix.bin }} --test --headless
+
+    # Check class reference
+    # - name: Check for class reference updates
+    #   if: ${{ matrix.doc-test }}
+    #   run: |
+    #     echo "Running --doctool to see if this changes the public API without updating the documentation."
+    #     echo -e "If a diff is shown, it means that your code/doc changes are incomplete and you should update the class reference with --doctool.\n\n"
+    #     ${{ matrix.bin }} --doctool --headless 2>&1 > /dev/null || true
+    #     git diff --color --exit-code && ! git ls-files --others --exclude-standard | sed -e 's/^/New doc file missing in PR: /' | grep 'xml$'
+
+    # Test 3.x -> 4.x project converter
+    # - name: Test project converter
+    #   if: ${{ matrix.proj-conv }}
+    #   run: |
+    #     mkdir converter_test
+    #     cd converter_test
+    #     touch project.godot
+    #     ../${{ matrix.bin }} --headless --validate-conversion-3to4
+    #     cd ..
+    #     rm converter_test -rf
+
+    # # Download and extract zip archive with project, folder is renamed to be able to easy change used project
+    # - name: Download test project
+    #   if: ${{ matrix.proj-test }}
+    #   run: |
+    #     wget https://github.com/godotengine/regression-test-project/archive/4.0.zip
+    #     unzip 4.0.zip
+    #     mv "regression-test-project-4.0" "test_project"
+
+    # # Editor is quite complicated piece of software, so it is easy to introduce bug here
+    # - name: Open and close editor (Vulkan)
+    #   if: ${{ matrix.proj-test }}
+    #   run: |
+    #     xvfb-run ${{ matrix.bin }} --audio-driver Dummy --editor --quit --path test_project 2>&1 | tee sanitizers_log.txt || true
+    #     misc/scripts/check_ci_log.py sanitizers_log.txt
+
+    # - name: Open and close editor (GLES3)
+    #   if: ${{ matrix.proj-test }}
+    #   run: |
+    #     DRI_PRIME=0 xvfb-run ${{ matrix.bin }} --audio-driver Dummy --rendering-driver opengl3 --editor --quit --path test_project 2>&1 | tee sanitizers_log.txt || true
+    #     misc/scripts/check_ci_log.py sanitizers_log.txt
+
+    # # Run test project
+    # - name: Run project
+    #   if: ${{ matrix.proj-test }}
+    #   run: |
+    #     xvfb-run ${{ matrix.bin }} 40 --audio-driver Dummy --path test_project 2>&1 | tee sanitizers_log.txt || true
+    #     misc/scripts/check_ci_log.py sanitizers_log.txt
+
+    # # Checkout godot-cpp
+    # - name: Checkout godot-cpp
+    #   if: ${{ matrix.godot-cpp-test }}
+    #   uses: actions/checkout@v3
+    #   with:
+    #     repository: godotengine/godot-cpp
+    #     submodules: 'recursive'
+    #     path: 'godot-cpp'
+
+    # # Dump GDExtension interface and API
+    # - name: Dump GDExtension interface and API for godot-cpp build
+    #   if: ${{ matrix.godot-cpp-test }}
+    #   run: |
+    #     ${{ matrix.bin }} --headless --dump-gdextension-interface --dump-extension-api
+    #     cp -f gdextension_interface.h godot-cpp/gdextension/
+    #     cp -f extension_api.json godot-cpp/gdextension/
+
+    # # Build godot-cpp test extension
+    # - name: Build godot-cpp test extension
+    #   if: ${{ matrix.godot-cpp-test }}
+    #   run: |
+    #     cd godot-cpp/test
+    #     scons target=template_debug dev_build=yes
+    #     cd ../..
+
     - name: Prepare artifact
       if: ${{ matrix.artifact }}
       run: |
         strip bin/godot.*
+        chmod +x bin/godot.*
+
     - name: Upload artifact
       uses: ./.github/actions/upload-artifact
       if: ${{ matrix.artifact }}
       with:
-        name: ${{ matrix.cache-name }}
+        name: ${{ matrix.cache-name }}
\ No newline at end of file
diff --git a/.github/workflows/macos_builds.yml b/.github/workflows/macos_builds.yml
index 35d3ab03..4ae295a6 100644
--- a/.github/workflows/macos_builds.yml
+++ b/.github/workflows/macos_builds.yml
@@ -3,8 +3,8 @@ name: 🍎 macOS Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: 3.5-stable
-  SCONSFLAGS: '  verbose=yes   debug_symbols=no'
+  GODOT_BASE_BRANCH: "4.0"
+  SCONSFLAGS: verbose=yes warnings=extra module_text_server_fb_enabled=yes
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-macos
   cancel-in-progress: true
@@ -16,14 +16,17 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - name: Editor (target=release_debug, tools=yes)
+        - name: Editor (target=editor, tools=yes)
           cache-name: macos-editor
-          target: release_debug
+          target: editor
           tools: true
+          tests: false
           bin: ./bin/godot.osx.opt.tools.64
         - name: Template (target=release, tools=no)
           cache-name: macos-template
-          target: release
+          target: template_release
+          tests: false
+          sconsflags: debug_symbols=no
           tools: false
     steps:
     - name: Checkout Godot
@@ -34,24 +37,42 @@ jobs:
     - name: Checkout ECMAScript
       uses: actions/checkout@v2
       with:
-        path: ${{github.workspace}}/modules/ECMAScript/
+        path: ${{github.workspace}}/modules/javascript/
     - name: Setup Godot build cache
       uses: ./.github/actions/godot-cache
       with:
         cache-name: ${{ matrix.cache-name }}
       continue-on-error: true
     - name: Setup python and scons
-      uses: ./modules/ECMAScript/.github/actions/godot-deps
+      uses: ./modules/javascript/.github/actions/godot-deps
       with:
         shell: sh
+    - name: Setup Vulkan SDK
+      run: |
+        sh misc/scripts/install_vulkan_sdk_macos.sh
     - name: Compilation
-      uses: ./modules/ECMAScript/.github/actions/godot-build
+      uses: ./modules/javascript/.github/actions/godot-build
       with:
         sconsflags: ${{ env.SCONSFLAGS }}
-        platform: osx
+        platform: macos
         target: ${{ matrix.target }}
+        tests: ${{ matrix.tests }}
         tools: ${{ matrix.tools }}
         shell: sh
+
+    # Execute unit tests for the editor
+    - name: Unit tests
+      if: ${{ matrix.tests }}
+      run: |
+        ${{ matrix.bin }} --version
+        ${{ matrix.bin }} --help
+        ${{ matrix.bin }} --test
+
+    - name: Prepare artifact
+      run: |
+        strip bin/godot.*
+        chmod +x bin/godot.*
+
     - name: Upload artifact
       uses: ./.github/actions/upload-artifact
       with:
diff --git a/.github/workflows/server_builds.yml b/.github/workflows/server_builds.yml
index de2dc19c..04fd1e6d 100644
--- a/.github/workflows/server_builds.yml
+++ b/.github/workflows/server_builds.yml
@@ -3,9 +3,11 @@ name: ☁ Server Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: 3.5-stable
-  SCONSFLAGS: '  verbose=yes   debug_symbols=no module_mono_enabled=yes mono_static=yes
-    mono_glue=no'
+  GODOT_BASE_BRANCH: "4.0"
+  SCONSFLAGS: '  verbose=yes warnings=extra module_text_server_fb_enabled=yes  '
+  DOTNET_NOLOGO: true
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
+
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-server
   cancel-in-progress: true
@@ -17,14 +19,23 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - name: Linux Headless w/ Mono (target=release_debug, tools=yes)
+        - name: Linux Headless w/ Mono (target=editor, tools=yes)
           cache-name: server-editor-mono
-          target: release_debug
+          target: editor
+          tests: false # Disabled due freeze caused by mix Mono build and CI
           tools: true
+          sconsflags: module_mono_enabled=yes mono_static=yes mono_glue=no
+          bin: ./bin/godot.x11.opt.tools.64.mono
+          build-mono: true
+          artifact: true
         - name: Linux Server w/ Mono (target=release, tools=no)
           cache-name: server-template-mono
-          target: release
+          target: template_release
+          tests: false # Disabled due freeze caused by mix Mono build and CI
           tools: false
+          sconsflags: module_mono_enabled=yes mono_static=yes mono_glue=no
+          build-mono: true
+          artifact: true
     steps:
     - name: Checkout Godot
       uses: actions/checkout@v2
@@ -34,13 +45,13 @@ jobs:
     - name: Checkout ECMAScript
       uses: actions/checkout@v2
       with:
-        path: ${{github.workspace}}/modules/ECMAScript/
+        path: ${{github.workspace}}/modules/javascript/
     - name: Linux dependencies
       shell: bash
       run: |
         # Azure repositories are not reliable, we need to prevent azure giving us packages.
-        sudo rm -f /etc/apt/sources.list.d/*
-        sudo cp -f misc/ci/sources.list /etc/apt/sources.list
+        # sudo rm -f /etc/apt/sources.list.d/*
+        # sudo cp -f misc/ci/sources.list /etc/apt/sources.list
         sudo apt-get update
         # The actual dependencies
         sudo apt-get install build-essential pkg-config libx11-dev libxcursor-dev \
@@ -52,14 +63,14 @@ jobs:
         cache-name: ${{ matrix.cache-name }}
       continue-on-error: true
     - name: Setup python and scons
-      uses: ./modules/ECMAScript/.github/actions/godot-deps
+      uses: ./modules/javascript/.github/actions/godot-deps
       with:
         shell: sh
     - name: Compilation
-      uses: ./modules/ECMAScript/.github/actions/godot-build
+      uses: ./modules/javascript/.github/actions/godot-build
       with:
         sconsflags: ${{ env.SCONSFLAGS }} ${{ matrix.sconsflags }}
-        platform: server
+        platform: linuxbsd
         target: ${{ matrix.target }}
         tools: ${{ matrix.tools }}
         shell: sh
diff --git a/.github/workflows/windows_builds.yml b/.github/workflows/windows_builds.yml
index 642871ca..68a7304a 100644
--- a/.github/workflows/windows_builds.yml
+++ b/.github/workflows/windows_builds.yml
@@ -3,8 +3,8 @@ name: 🏁 Windows Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: 3.5-stable
-  SCONSFLAGS: '  use_mingw=yes  verbose=yes   debug_symbols=no'
+  GODOT_BASE_BRANCH: "4.0"
+  SCONSFLAGS: '  use_mingw=yes  debug_symbols=no verbose=yes warnings=extra module_text_server_fb_enabled=yes'
   SCONS_CACHE_MSVC_CONFIG: true
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-windows
@@ -17,15 +17,18 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - name: Editor (target=release_debug, tools=yes)
+        - name: Editor (target=editor, tools=yes)
           cache-name: windows-editor
-          target: release_debug
+          target: editor
+          tests: false
           tools: true
           bin: ./bin/godot.windows.opt.tools.64.exe
         - name: Template (target=release, tools=no)
           cache-name: windows-template
-          target: release
+          target: template_release
           tools: false
+          tests: false
+          sconsflags: debug_symbols=no
     steps:
     - name: setup-msys2
       uses: msys2/setup-msys2@v2
@@ -46,22 +49,27 @@ jobs:
     - name: Checkout ECMAScript
       uses: actions/checkout@v2
       with:
-        path: ${{github.workspace}}/modules/ECMAScript/
+        path: ${{github.workspace}}/modules/javascript/
     - name: Setup Godot build cache
       uses: ./.github/actions/godot-cache
       with:
         cache-name: ${{ matrix.cache-name }}
       continue-on-error: true
     - name: Setup python and scons
-      uses: ./modules/ECMAScript/.github/actions/godot-deps
+      uses: ./modules/javascript/.github/actions/godot-deps
       with:
         shell: msys2 {0}
+
+    - name: Setup MSVC problem matcher
+      uses: ammaraskar/msvc-problem-matcher@master
+
     - name: Compilation
-      uses: ./modules/ECMAScript/.github/actions/godot-build
+      uses: ./modules/javascript/.github/actions/godot-build
       with:
-        sconsflags: ${{ env.SCONSFLAGS }}
+        sconsflags: ${{ env.SCONSFLAGS }} ${{ matrix.sconsflags }}
         platform: windows
         target: ${{ matrix.target }}
+        tests: ${{ matrix.tests }}
         tools: ${{ matrix.tools }}
         scons-cache-limit: 3072
         shell: msys2 {0}
diff --git a/SCsub b/SCsub
index aa80b6a1..795f1df1 100644
--- a/SCsub
+++ b/SCsub
@@ -5,7 +5,7 @@ Import('env')
 Import('env_modules')
 env_module = env_modules.Clone()
 JS_ENGINE = 'quickjs'
-TOOLS = env.get('TOOLS');
+TOOLS = ('editor' == env_module['target']) #env.get('TOOLS');
 
 def open_file(path, mode):
 	if platform.python_version() > '3':
@@ -36,7 +36,7 @@ if JS_ENGINE == 'quickjs':
 	version = open('quickjs/quickjs/VERSION.txt', 'r').read().split('\n')[0]
 	env_module.Append(CPPDEFINES={"QUICKJS_CONFIG_VERSION": '"'+ version +'"'})
 	env_module.Append(CPPDEFINES=["CONFIG_BIGNUM"])
-	if env_module['target'] != 'release':
+	if 'release' not in (env_module['target'] or ''):
 		env_module.Append(CPPDEFINES={"DUMP_LEAKS": 1})
 		env_module.Append(CPPDEFINES={"QUICKJS_WITH_DEBUGGER": 1})
 	env_module.Append(CPPPATH=["quickjs/quickjs"])
diff --git a/build_github_actions.py b/build_github_actions.py
index 9b50033f..bd28f338 100644
--- a/build_github_actions.py
+++ b/build_github_actions.py
@@ -4,7 +4,7 @@
 You must be in this directory, and in the modules subfolder of godot (just as if you would install this project into godot)
 
 usage:
-python build_github_actions.py --godot-version "3.5-stable" --godot-github-folder ../../.github --js-github-folder .github
+python build_github_actions.py --godot-version "4.0" --godot-github-folder ../../.github --js-github-folder .github
 
 """
 
diff --git a/javascript_language.h b/javascript_language.h
index aaf0ee07..8e28fcd9 100644
--- a/javascript_language.h
+++ b/javascript_language.h
@@ -54,7 +54,7 @@ class JavaScriptLanguage : public ScriptLanguage {
 
 	virtual void init() override;
 	virtual void finish() override;
-	virtual Error execute_file(const String &p_path) override;
+	virtual Error execute_file(const String &p_path);
 
 	virtual void get_reserved_words(List<String> *p_words) const override;
 	virtual bool is_control_flow_keyword(String p_keywords) const override;
diff --git a/quickjs/quickjs_callable.h b/quickjs/quickjs_callable.h
index 05f235d5..061a370a 100644
--- a/quickjs/quickjs_callable.h
+++ b/quickjs/quickjs_callable.h
@@ -2,7 +2,11 @@
 #define QUICKJS_CALLABLE_H
 #include "../javascript_callable.h"
 #include "quickjs/quickjs.h"
+
+#if !defined(JS_NAN_BOXING)
+///typedef uint64_t JSValue; defined in quickjs.h if defined(JS_NAN_BOXING)
 struct JSValue;
+#endif
 
 class QuickJSCallable : public JavaScriptCallable {
 	static bool compare_equal(const CallableCustom *p_a, const CallableCustom *p_b);

From 783517ae6de6e8cd8390d81dd7a61c5a67831bed Mon Sep 17 00:00:00 2001
From: Darrin Lowery <ogrotten@users.noreply.github.com>
Date: Thu, 20 Oct 2022 19:47:32 -0500
Subject: [PATCH 15/71] Update README.md

Added a section to make it more clear to new users that this is self contained like vanilla Godot.
---
 README.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/README.md b/README.md
index 3b3a3b0f..35dd2914 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,9 @@ This module implements JavaScript/TypeScript language support for the godot game
 - Full code completion support for all godot APIs including signals and enumerations
 - Debug in Visual Studio Code with the [plugin](https://marketplace.visualstudio.com/items?itemName=geequlim.godot-javascript-debug)
 
+### Installation
+No installation or setup necessary. The binaries for download are the complete, usable Godot editor and engine with Javascript/Typescript language support.
+
 ### Download
 You can try the pre-compiled binaries from the [release page](https://github.com/GodotExplorer/ECMAScript/releases)  
 You can also get the binaries with lastest commits from the [github build action result](https://github.com/GodotExplorer/ECMAScript/actions)

From 01457b93157f8f4a23ab6b2fe2e3dda6057eb0cd Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Sun, 23 Apr 2023 12:34:07 -0700
Subject: [PATCH 16/71] Fix Godot 4.0 compile errors, update JavaScript
 integration, refactor code, and address minor issues

Fixed compilation errors, improved RefCounted bindings, renamed ECMAScript to JavaScript, implemented JavaScriptCallable, fixed typos, updated GDExtension migration, updated JS modules, and refactored code for Godot 4.0.

Co-Authored-By: Malik Ahmed <animanmaster@gmail.com>
---
 .github/workflows/linux_builds.yml            |    2 +-
 .gitignore                                    |    2 +-
 README.md                                     |   22 +-
 SCsub                                         |  122 +-
 build_github_actions.py                       |    7 +-
 config.py                                     |    5 +-
 generate_builtin_api.py                       |  694 +++--
 javascript.cpp                                |   44 +-
 javascript.h                                  |   36 +-
 javascript_binder.h                           |  240 +-
 javascript_callable.h                         |   33 +-
 javascript_gc_handler.h                       |  334 +--
 javascript_instance.cpp                       |   30 +
 javascript_instance.h                         |   36 +-
 javascript_language.cpp                       |  744 +++---
 javascript_language.h                         |   38 +-
 misc/binding_script.js                        |  219 ++
 misc/decorators.ts                            |    2 +-
 misc/godot.d.ts                               |  488 ++--
 quickjs/quickjs_binder.cpp                    | 2362 -----------------
 quickjs/quickjs_binder.h                      |  350 ---
 register_types.cpp                            |   58 +-
 register_types.h                              |   64 +-
 tests/UnitTest.js.disable                     |  100 +
 .../quickjs}/builtin_binding_generator.py     |  760 +++---
 .../quickjs}/quickjs/VERSION.txt              |    0
 .../quickjs}/quickjs/cutils.c                 |    4 +-
 .../quickjs}/quickjs/cutils.h                 |   16 +-
 .../quickjs}/quickjs/libbf.c                  |  534 ++--
 .../quickjs}/quickjs/libbf.h                  |   20 +-
 .../quickjs}/quickjs/libregexp-opcode.h       |    2 +-
 .../quickjs}/quickjs/libregexp.c              |   98 +-
 .../quickjs}/quickjs/libregexp.h              |    4 +-
 .../quickjs}/quickjs/libunicode-table.h       |    0
 .../quickjs}/quickjs/libunicode.c             |   50 +-
 .../quickjs}/quickjs/libunicode.h             |    2 +-
 .../quickjs}/quickjs/list.h                   |    4 +-
 .../quickjs}/quickjs/quickjs-atom.h           |    6 +-
 .../quickjs}/quickjs/quickjs-debugger.c       |    8 +-
 .../quickjs}/quickjs/quickjs-debugger.h       |    4 +-
 .../quickjs}/quickjs/quickjs-opcode.h         |   10 +-
 .../quickjs}/quickjs/quickjs.c                |  536 ++--
 .../quickjs}/quickjs/quickjs.h                |    6 +-
 .../quickjs}/quickjs_builtin_binder.cpp       |    0
 .../quickjs}/quickjs_builtin_binder.h         |    0
 thirdparty/quickjs/quickjs_callable.cpp       |   65 +
 thirdparty/quickjs/quickjs_callable.h         |   30 +
 .../quickjs}/quickjs_debugger.cpp             |    0
 .../quickjs}/quickjs_debugger.h               |    0
 .../quickjs}/quickjs_worker.cpp               |    0
 .../quickjs}/quickjs_worker.h                 |    0
 tools/editor_tools.cpp                        |  160 +-
 tools/editor_tools.h                          |   37 +-
 53 files changed, 3220 insertions(+), 5168 deletions(-)
 delete mode 100644 quickjs/quickjs_binder.cpp
 delete mode 100644 quickjs/quickjs_binder.h
 create mode 100644 tests/UnitTest.js.disable
 rename {quickjs => thirdparty/quickjs}/builtin_binding_generator.py (50%)
 rename {quickjs => thirdparty/quickjs}/quickjs/VERSION.txt (100%)
 rename {quickjs => thirdparty/quickjs}/quickjs/cutils.c (99%)
 rename {quickjs => thirdparty/quickjs}/quickjs/cutils.h (94%)
 rename {quickjs => thirdparty/quickjs}/quickjs/libbf.c (98%)
 rename {quickjs => thirdparty/quickjs}/quickjs/libbf.h (98%)
 rename {quickjs => thirdparty/quickjs}/quickjs/libregexp-opcode.h (99%)
 rename {quickjs => thirdparty/quickjs}/quickjs/libregexp.c (99%)
 rename {quickjs => thirdparty/quickjs}/quickjs/libregexp.h (99%)
 rename {quickjs => thirdparty/quickjs}/quickjs/libunicode-table.h (100%)
 rename {quickjs => thirdparty/quickjs}/quickjs/libunicode.c (99%)
 rename {quickjs => thirdparty/quickjs}/quickjs/libunicode.h (99%)
 rename {quickjs => thirdparty/quickjs}/quickjs/list.h (98%)
 rename {quickjs => thirdparty/quickjs}/quickjs/quickjs-atom.h (99%)
 rename {quickjs => thirdparty/quickjs}/quickjs/quickjs-debugger.c (99%)
 rename {quickjs => thirdparty/quickjs}/quickjs/quickjs-debugger.h (99%)
 rename {quickjs => thirdparty/quickjs}/quickjs/quickjs-opcode.h (99%)
 rename {quickjs => thirdparty/quickjs}/quickjs/quickjs.c (99%)
 rename {quickjs => thirdparty/quickjs}/quickjs/quickjs.h (99%)
 rename {quickjs => thirdparty/quickjs}/quickjs_builtin_binder.cpp (100%)
 rename {quickjs => thirdparty/quickjs}/quickjs_builtin_binder.h (100%)
 create mode 100644 thirdparty/quickjs/quickjs_callable.cpp
 create mode 100644 thirdparty/quickjs/quickjs_callable.h
 rename {quickjs => thirdparty/quickjs}/quickjs_debugger.cpp (100%)
 rename {quickjs => thirdparty/quickjs}/quickjs_debugger.h (100%)
 rename {quickjs => thirdparty/quickjs}/quickjs_worker.cpp (100%)
 rename {quickjs => thirdparty/quickjs}/quickjs_worker.h (100%)

diff --git a/.github/workflows/linux_builds.yml b/.github/workflows/linux_builds.yml
index 3b33ad58..afa4ac04 100644
--- a/.github/workflows/linux_builds.yml
+++ b/.github/workflows/linux_builds.yml
@@ -56,7 +56,7 @@ jobs:
           cache-name: linux-template-minimal
           target: template_release
           tests: false
-          sconsflags: modules_enabled_by_default=no disable_3d=yes disable_advanced_gui=yes deprecated=no 
+          sconsflags: modules_enabled_by_default=no disable_3d=yes disable_advanced_gui=yes deprecated=no
     steps:
     - name: Checkout Godot
       uses: actions/checkout@v2
diff --git a/.gitignore b/.gitignore
index 6a7d3c7d..a3c7a391 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,4 +7,4 @@
 *.os
 *.gen.cpp
 *.gen.json
-.vscode
\ No newline at end of file
+.vscode
diff --git a/README.md b/README.md
index 35dd2914..1562ff78 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ This module implements JavaScript/TypeScript language support for the godot game
 - Almost complete ES2020 support
 - All godot api avaliable
 - Operator overriding for builtin types (Vector3, Color, etc)
-- TypeScript support 
+- TypeScript support
 - [Using thirdpart libraries from npm](https://github.com/GodotExplorer/ECMAScriptDemos/tree/master/npm_module)
 - Multi-thread support with Worker API
 - Full code completion support for all godot APIs including signals and enumerations
@@ -18,7 +18,7 @@ This module implements JavaScript/TypeScript language support for the godot game
 No installation or setup necessary. The binaries for download are the complete, usable Godot editor and engine with Javascript/Typescript language support.
 
 ### Download
-You can try the pre-compiled binaries from the [release page](https://github.com/GodotExplorer/ECMAScript/releases)  
+You can try the pre-compiled binaries from the [release page](https://github.com/GodotExplorer/ECMAScript/releases)
 You can also get the binaries with lastest commits from the [github build action result](https://github.com/GodotExplorer/ECMAScript/actions)
 
 ### Compilation
@@ -35,18 +35,18 @@ You can also get the binaries with lastest commits from the [github build action
 ```js
 // The default export entry is treated as an exported class to godot
 export default class MySprite extends godot.Sprite {
-	
+
 	// this is _init() in GDScript
 	constructor() {
 		super();
 	}
-	
+
 	_ready() {
-		
+
 	}
-	
+
 	_process(delta) {
-		
+
 	}
 }
 ```
@@ -173,7 +173,7 @@ Label.Align.ALIGN_LEFT | godot.Label.Align.ALIGN_LEFT
 		// In worker thread
 		let id = godot.abandon_value(object);
 		postMessage({ type: 'return_value', id: id });
-		
+
 		// In the host thread
 		worker.onmessage = function(msg) {
 			if (typeof msg === 'object' && msg.type === 'return_value') {
@@ -181,7 +181,7 @@ Label.Align.ALIGN_LEFT | godot.Label.Align.ALIGN_LEFT
 			}
 		}
 		```
-	
+
 ### TypeScript support
 - Run the menu command `Project > Tools > JavaScript > Generate TypeScript Project` from the godot editor to generate a TypeScript project
 - Run `tsc -w -p .` under your project folder in the terminal to compile scripts
@@ -213,7 +213,7 @@ export default class InputLine extends godot.HBoxContainer {
 	// register offset property with the godot inspector with default value of Vector2(0, 0)
 	@property({ default: godot.Vector2.ZERO })
 	offset: godot.Vector2;
-	
+
 	// register properties for godot editor inspector
 	@property({ type: godot.VariantType.TYPE_STRING })
 	get title() { return this._title; }
@@ -250,7 +250,7 @@ export default class InputLine extends godot.HBoxContainer {
 	_ready() {
 		// get first child with the type of godot.Label
 		this._label = this.get_node(godot.Label);
-		
+
 		// Apply the inspector filled values with property setters
 		this.title = this.title;
 		this.hint = this.hint;
diff --git a/SCsub b/SCsub
index 795f1df1..d1cef8ad 100644
--- a/SCsub
+++ b/SCsub
@@ -1,77 +1,85 @@
 #!/usr/bin/env python
 import platform, os, sys
 
-Import('env')
-Import('env_modules')
+Import("env")
+Import("env_modules")
 env_module = env_modules.Clone()
-JS_ENGINE = 'quickjs'
-TOOLS = ('editor' == env_module['target']) #env.get('TOOLS');
+JS_ENGINE = "quickjs"
+TOOLS = "editor" == env_module["target"]  # env.get('TOOLS');
+
 
 def open_file(path, mode):
-	if platform.python_version() > '3':
-		return open(path, mode, encoding='utf8')
-	else:
-		return open(path, mode)
+    if platform.python_version() > "3":
+        return open(path, mode, encoding="utf8")
+    else:
+        return open(path, mode)
+
 
 def dump_text_file_to_cpp(file):
-	source = open_file(file, 'r').read()
-	lines = source.split('\n')
-	source = ""
-	length = len(lines)
-	for i in range(length):
-		line = lines[i].replace('"', '\\"')
-		line = '\t"' + line + '\\n"'
-		if i < length -1:
-			line += "\n"
-		source += line
-	return source
+    source = open_file(file, "r").read()
+    lines = source.split("\n")
+    source = ""
+    length = len(lines)
+    for i in range(length):
+        line = lines[i].replace('"', '\\"')
+        line = '\t"' + line + '\\n"'
+        if i < length - 1:
+            line += "\n"
+        source += line
+    return source
+
+
+if JS_ENGINE == "quickjs":
+    # generate builtin binding code
+    import generate_builtin_api
+
+    generate_builtin_api.generate_api_json(os.path.join(GetLaunchDir(), "modules", os.path.basename(os.getcwd())))
+    import thirdparty.quickjs.builtin_binding_generator
 
-if JS_ENGINE == 'quickjs':
-	# generate builtin binding code
-	import generate_builtin_api
-	generate_builtin_api.generate_api_json(os.path.join(GetLaunchDir(), "modules", os.path.basename(os.getcwd())))
-	import quickjs.builtin_binding_generator
-	quickjs.builtin_binding_generator.generate_builtin_bindings()
-	# build quickjs source
-	version = open('quickjs/quickjs/VERSION.txt', 'r').read().split('\n')[0]
-	env_module.Append(CPPDEFINES={"QUICKJS_CONFIG_VERSION": '"'+ version +'"'})
-	env_module.Append(CPPDEFINES=["CONFIG_BIGNUM"])
-	if 'release' not in (env_module['target'] or ''):
-		env_module.Append(CPPDEFINES={"DUMP_LEAKS": 1})
-		env_module.Append(CPPDEFINES={"QUICKJS_WITH_DEBUGGER": 1})
-	env_module.Append(CPPPATH=["quickjs/quickjs"])
-	# env_module.Append(CXXFLAGS=["-std=c++20"])
-	# env_module.Append(CCFLAGS=["-std=c++20"])
-	if TOOLS:
-		env_module.add_source_files(env.modules_sources, 'tools/editor_tools.cpp')
-	env_module.add_source_files(env.modules_sources, 'quickjs/quickjs_builtin_binder.gen.cpp')
-	env_module.add_source_files(env.modules_sources, 'quickjs/*.cpp')
-	env_module.add_source_files(env.modules_sources, 'quickjs/quickjs/*.c')
+    thirdparty.quickjs.builtin_binding_generator.generate_builtin_bindings()
+    # build quickjs source
+    version = open("thirdparty/quickjs/quickjs/VERSION.txt", "r").read().split("\n")[0]
+    env_module.Append(CPPDEFINES={"QUICKJS_CONFIG_VERSION": '"' + version + '"'})
+    env_module.Append(CPPDEFINES=["CONFIG_BIGNUM"])
+    if "release" not in (env_module["target"] or ""):
+        env_module.Append(CPPDEFINES={"DUMP_LEAKS": 1})
+        env_module.Append(CPPDEFINES={"QUICKJS_WITH_DEBUGGER": 1})
+    env_module.Append(CPPPATH=["thirdparty/quickjs/quickjs"])
+    # env_module.Append(CXXFLAGS=["-std=c++20"])
+    # env_module.Append(CCFLAGS=["-std=c++20"])
+    if TOOLS:
+        env_module.add_source_files(env.modules_sources, "tools/editor_tools.cpp")
+    env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp")
+    env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/*.cpp")
+    env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs/*.c")
 
 # Binding script to run at engine initializing
 with open("misc/godot.binding_script.gen.cpp", "w") as f:
-	text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "../javascript_binder.h"\nString JavaScriptBinder::BINDING_SCRIPT_CONTENT = \n${source};'
-	f.write(text.replace('${source}', dump_text_file_to_cpp("misc/binding_script.js")))
+    text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "../javascript_binder.h"\nString JavaScriptBinder::BINDING_SCRIPT_CONTENT = \n${source};'
+    f.write(text.replace("${source}", dump_text_file_to_cpp("misc/binding_script.js")))
 
 sources = [
-	'register_types.cpp',
-	'javascript_language.cpp',
-	'javascript_instance.cpp',
-	'javascript.cpp',
-	'misc/godot.binding_script.gen.cpp',
+    "register_types.cpp",
+    "javascript_language.cpp",
+    "javascript_instance.cpp",
+    "javascript.cpp",
+    "misc/godot.binding_script.gen.cpp",
 ]
 
 if TOOLS:
-	base_text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
-	tool_fns = {"tools/godot.d.ts.gen.cpp": ("BUILTIN_DECLARATION_TEXT", dump_text_file_to_cpp("misc/godot.d.ts")),
-		"tools/tsconfig.json.gen.cpp": ("TSCONFIG_CONTENT", dump_text_file_to_cpp("misc/tsconfig.json")),
-		"tools/decorators.ts.gen.cpp": ("TS_DECORATORS_CONTENT", dump_text_file_to_cpp("misc/decorators.ts")),
-		"tools/package.json.gen.cpp": ("PACKAGE_JSON_CONTENT", dump_text_file_to_cpp("misc/package.json")),
-	}
-	for fn, subs in tool_fns.items():
-		with open_file(fn, "w") as fh:
-			fh.write(base_text.format(*subs))
-		env_module.add_source_files(env.modules_sources, fn)
+    base_text = (
+        '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
+    )
+    tool_fns = {
+        "tools/godot.d.ts.gen.cpp": ("BUILTIN_DECLARATION_TEXT", dump_text_file_to_cpp("misc/godot.d.ts")),
+        "tools/tsconfig.json.gen.cpp": ("TSCONFIG_CONTENT", dump_text_file_to_cpp("misc/tsconfig.json")),
+        "tools/decorators.ts.gen.cpp": ("TS_DECORATORS_CONTENT", dump_text_file_to_cpp("misc/decorators.ts")),
+        "tools/package.json.gen.cpp": ("PACKAGE_JSON_CONTENT", dump_text_file_to_cpp("misc/package.json")),
+    }
+    for fn, subs in tool_fns.items():
+        with open_file(fn, "w") as fh:
+            fh.write(base_text.format(*subs))
+        env_module.add_source_files(env.modules_sources, fn)
 
 
 env_module.Append(CPPPATH=["#modules/javascript"])
diff --git a/build_github_actions.py b/build_github_actions.py
index bd28f338..78bef44b 100644
--- a/build_github_actions.py
+++ b/build_github_actions.py
@@ -16,6 +16,7 @@
 from typing import Dict, List, Any
 import copy
 
+
 # https://stackoverflow.com/a/33300001 + some changes
 def str_presenter(dumper, data):
     if len(data.splitlines()) > 1 or "\n" in data:  # check for multiline string
@@ -64,7 +65,7 @@ def checkout_local_godot_install(tag: str):
         raise RuntimeError(f"godot not setup properly, could not checkout '{' '.join(cmd)}'")
 
 
-def get_windows_mingw_checkout_steps() -> List[Dict[str, Any]]:
+def get_windows_mingw_checkout_steps() -> List[object]:
     out = [
         {
             "name": "setup-msys2",
@@ -313,9 +314,7 @@ def main():
 
     for x in ["actions", "workflows"]:
         subprocess.call(["rm", "-rf", os.path.join(args.js_github_folder, x)])
-        subprocess.call(
-            ["cp", "-r", os.path.join(args.godot_github_folder, x), os.path.join(args.js_github_folder, x)]
-        )
+        subprocess.call(["cp", "-r", os.path.join(args.godot_github_folder, x), os.path.join(args.js_github_folder, x)])
 
     basic_flags = " "
     actions = [
diff --git a/config.py b/config.py
index 53bc8270..d22f9454 100644
--- a/config.py
+++ b/config.py
@@ -1,5 +1,6 @@
 def can_build(env, platform):
-	return True
+    return True
+
 
 def configure(env):
-	pass
+    pass
diff --git a/generate_builtin_api.py b/generate_builtin_api.py
index a4d71800..745226ea 100755
--- a/generate_builtin_api.py
+++ b/generate_builtin_api.py
@@ -3,445 +3,377 @@
 import xml.etree.ElementTree as ET
 
 BUILTIN_CLASSES = [
-	'Vector2',
-	'Rect2',
-	'Color',
-	'Vector3',
-	'Basis',
-	'Quaternion',
-	'RID',
-	'Transform2D',
-	'Plane',
-	'AABB',
-	"Transform3D",
-	"PackedByteArray",
-	"PackedInt32Array",
-	"PackedInt64Array",
-	"PackedFloat32Array",
-	"PackedFloat64Array",
-	"PackedStringArray",
-	"PackedVector2Array",
-	"PackedVector3Array",
-	"PackedColorArray",
+    "Vector2",
+    "Rect2",
+    "Color",
+    "Vector3",
+    "Basis",
+    "Quaternion",
+    "RID",
+    "Transform2D",
+    "Plane",
+    "AABB",
+    "Transform3D",
+    "PackedByteArray",
+    "PackedInt32Array",
+    "PackedInt64Array",
+    "PackedFloat32Array",
+    "PackedFloat64Array",
+    "PackedStringArray",
+    "PackedVector2Array",
+    "PackedVector3Array",
+    "PackedColorArray",
 ]
 
 MAX_CONSTRUCTOR_ARGC = {
-	'Vector2': 2,
-	'Rect2': 4,
-	'Color': 4,
-	'Vector3': 3,
-	'Basis': 0,
-	'Quaternion': 0,
-	'RID': 0,
-	'Transform2D': 0,
-	'Plane': 0,
-	'AABB': 0,
-	"Transform3D": 0,
-	"PackedByteArray": 0,
-	"PackedInt32Array": 0,
-	"PackedInt64Array": 0,
-	"PackedFloat32Array": 0,
-	"PackedFloat64Array": 0,
-	"PackedStringArray": 0,
-	"PackedVector2Array": 0,
-	"PackedVector3Array": 0,
-	"PackedColorArray": 0,
+    "Vector2": 2,
+    "Rect2": 4,
+    "Color": 4,
+    "Vector3": 3,
+    "Basis": 0,
+    "Quaternion": 0,
+    "RID": 0,
+    "Transform2D": 0,
+    "Plane": 0,
+    "AABB": 0,
+    "Transform3D": 0,
+    "PackedByteArray": 0,
+    "PackedInt32Array": 0,
+    "PackedInt64Array": 0,
+    "PackedFloat32Array": 0,
+    "PackedFloat64Array": 0,
+    "PackedStringArray": 0,
+    "PackedVector2Array": 0,
+    "PackedVector3Array": 0,
+    "PackedColorArray": 0,
 }
 
 TYPE_MAP = {
-	'int': 'number',
-	'float': 'number',
-	'bool': 'boolean',
-	'String': 'string',
-	'NodePath': 'string',
+    "int": "number",
+    "float": "number",
+    "bool": "boolean",
+    "String": "string",
+    "NodePath": "string",
 }
 
 METHOD_OP_EQUALS = {
-	"arguments": [
-		{
-			"default_value": None,
-			"has_default_value": False,
-			"type": "${class_name}"
-		}
-	],
-	"name": "equals",
-	"native_method": "operator==",
-	"return": "boolean"
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "name": "equals",
+    "native_method": "operator==",
+    "return": "boolean",
 }
 
 METHOD_OP_ADD = {
-	"arguments": [
-		{
-			"default_value": None,
-			"has_default_value": False,
-			"type": "${class_name}"
-		}
-	],
-	"name": "add",
-	"native_method": "operator+",
-	"return": "${class_name}"
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "name": "add",
+    "native_method": "operator+",
+    "return": "${class_name}",
 }
 
 METHOD_OP_ADD_ASSIGN = {
-	"arguments": [
-		{
-			"default_value": None,
-			"has_default_value": False,
-			"type": "${class_name}"
-		}
-	],
-	"name": "add_assign",
-	"native_method": "operator+=",
-	"return": "this"
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "name": "add_assign",
+    "native_method": "operator+=",
+    "return": "this",
 }
 
 METHOD_OP_SUB = {
-	"arguments": [
-		{
-			"default_value": None,
-			"has_default_value": False,
-			"type": "${class_name}"
-		}
-	],
-	"name": "subtract",
-	"native_method": "operator-",
-	"return": "${class_name}"
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "name": "subtract",
+    "native_method": "operator-",
+    "return": "${class_name}",
 }
 
 METHOD_OP_SUB_ASSIGN = {
-	"arguments": [
-		{
-			"default_value": None,
-			"has_default_value": False,
-			"type": "${class_name}"
-		}
-	],
-	"name": "subtract_assign",
-	"native_method": "operator-=",
-	"return": "this"
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "name": "subtract_assign",
+    "native_method": "operator-=",
+    "return": "this",
 }
 
 METHOD_OP_MUL = {
-	"arguments": [
-		{
-			"default_value": None,
-			"has_default_value": False,
-			"type": "${class_name}"
-		}
-	],
-	"name": "multiply",
-	"native_method": "operator*",
-	"return": "${class_name}"
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "name": "multiply",
+    "native_method": "operator*",
+    "return": "${class_name}",
 }
 
 METHOD_OP_MUL_ASSIGN = {
-	"arguments": [
-		{
-			"default_value": None,
-			"has_default_value": False,
-			"type": "${class_name}"
-		}
-	],
-	"name": "multiply_assign",
-	"native_method": "operator*=",
-	"return": "this"
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "name": "multiply_assign",
+    "native_method": "operator*=",
+    "return": "this",
 }
 
 METHOD_OP_DIV = {
-	"arguments": [
-		{
-			"default_value": None,
-			"has_default_value": False,
-			"type": "${class_name}"
-		}
-	],
-	"name": "multiply",
-	"native_method": "operator/",
-	"return": "${class_name}"
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "name": "multiply",
+    "native_method": "operator/",
+    "return": "${class_name}",
 }
 
 METHOD_OP_DIV_ASSIGN = {
-	"arguments": [
-		{
-			"default_value": None,
-			"has_default_value": False,
-			"type": "${class_name}"
-		}
-	],
-	"name": "multiply_assign",
-	"native_method": "operator/=",
-	"return": "this"
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "name": "multiply_assign",
+    "native_method": "operator/=",
+    "return": "this",
 }
 
-METHOD_OP_NEG = {
-	"arguments": [],
-	"name": "negate",
-	"native_method": "operator-",
-	"return": "${class_name}"
-}
+METHOD_OP_NEG = {"arguments": [], "name": "negate", "native_method": "operator-", "return": "${class_name}"}
 
 METHOD_OP_LESS = {
-	"arguments": [
-		{
-			"default_value": None,
-			"has_default_value": False,
-			"type": "${class_name}"
-		}
-	],
-	"name": "less",
-	"native_method": "operator<",
-	"return": "boolean"
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "name": "less",
+    "native_method": "operator<",
+    "return": "boolean",
 }
 
 
 METHOD_OP_LESS_EQAUL = {
-	"arguments": [
-		{
-			"default_value": None,
-			"has_default_value": False,
-			"type": "${class_name}"
-		}
-	],
-	"name": "less_equal",
-	"native_method": "operator<=",
-	"return": "boolean"
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "name": "less_equal",
+    "native_method": "operator<=",
+    "return": "boolean",
 }
 
 METHOD_PACKED_ARRAY_GET = {
-	"arguments": [
-		{
-			"default_value": None,
-			"has_default_value": False,
-			"type": "number"
-		}
-	],
-	"name": "get",
-	"native_method": "operator[]",
-	"return": "Variant"
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "number"}],
+    "name": "get",
+    "native_method": "operator[]",
+    "return": "Variant",
 }
 
 IGNORED_PROPS = {
-	"Rect2": ['end', 'grow_side'],
-	"Color": ['h', 's', 'v', 'r8', 'g8', 'b8', 'a8'],
-	"Transform2D": ['xform', 'xform_inv'],
-	"Quaternion": ['get_euler'],
-	"Basis": ['is_equal_approx', 'get_euler', 'from_euler'],
-	"Plane": ['intersects_segment', 'intersects_ray', 'intersect_3'],
-	"AABB": ['end'],
-	"Transform3D": ['xform', 'xform_inv'],
-	"PackedByteArray": [
-		'compress',
-		'decompress',
-		'decompress_dynamic',
-		'get_string_from_ascii',
-		'get_string_from_utf8',
-		'get_string_from_utf16',
-		'get_string_from_utf32',
-		'hex_encode',
-		'to_float32_array',
-		'to_float64_array',
-		'to_int32_array',
-		'to_int64_array',
-		'has_encoded_var',
-	],
+    "Rect2": ["end", "grow_side"],
+    "Color": ["h", "s", "v", "r8", "g8", "b8", "a8"],
+    "Transform2D": ["xform", "xform_inv"],
+    "Quaternion": ["get_euler"],
+    "Basis": ["is_equal_approx", "get_euler", "from_euler"],
+    "Plane": ["intersects_segment", "intersects_ray", "intersect_3"],
+    "AABB": ["end"],
+    "Transform3D": ["xform", "xform_inv"],
+    "PackedByteArray": [
+        "compress",
+        "decompress",
+        "decompress_dynamic",
+        "get_string_from_ascii",
+        "get_string_from_utf8",
+        "get_string_from_utf16",
+        "get_string_from_utf32",
+        "hex_encode",
+        "to_float32_array",
+        "to_float64_array",
+        "to_int32_array",
+        "to_int64_array",
+        "has_encoded_var",
+    ],
 }
 
 PROPERTY_REMAP = {
-	"Transform2D": {
-		"x": "columns[0]",
-		"y": "columns[1]",
-		"origin": "columns[2]",
-	},
-	"Basis": {
-		"x": "rows[0]",
-		"y": "rows[1]",
-		"z": "rows[2]",
-	},
-	"Plane": {
-		"x": "normal.x",
-		"y": "normal.y",
-		"z": "normal.z",
-	}
+    "Transform2D": {
+        "x": "columns[0]",
+        "y": "columns[1]",
+        "origin": "columns[2]",
+    },
+    "Basis": {
+        "x": "rows[0]",
+        "y": "rows[1]",
+        "z": "rows[2]",
+    },
+    "Plane": {
+        "x": "normal.x",
+        "y": "normal.y",
+        "z": "normal.z",
+    },
 }
 
 OPERATOR_METHODS = {
-	"Vector2": [
-		METHOD_OP_NEG,
-		METHOD_OP_EQUALS,
-		METHOD_OP_LESS,
-		METHOD_OP_LESS_EQAUL,
-		METHOD_OP_ADD,
-		METHOD_OP_ADD_ASSIGN,
-		METHOD_OP_SUB,
-		METHOD_OP_SUB_ASSIGN,
-		METHOD_OP_MUL,
-		METHOD_OP_MUL_ASSIGN,
-		METHOD_OP_DIV,
-		METHOD_OP_DIV_ASSIGN,
-	],
-	"Vector3": [
-		METHOD_OP_NEG,
-		METHOD_OP_EQUALS,
-		METHOD_OP_LESS,
-		METHOD_OP_LESS_EQAUL,
-		METHOD_OP_ADD,
-		METHOD_OP_ADD_ASSIGN,
-		METHOD_OP_SUB,
-		METHOD_OP_SUB_ASSIGN,
-		METHOD_OP_MUL,
-		METHOD_OP_MUL_ASSIGN,
-		METHOD_OP_DIV,
-		METHOD_OP_DIV_ASSIGN,
-	],
-	"Basis": [
-		METHOD_OP_EQUALS,
-		METHOD_OP_ADD,
-		METHOD_OP_ADD_ASSIGN,
-		METHOD_OP_SUB,
-		METHOD_OP_SUB_ASSIGN,
-		METHOD_OP_MUL,
-		METHOD_OP_MUL_ASSIGN,
-	],
-	"Quaternion": [
-		METHOD_OP_NEG,
-		METHOD_OP_EQUALS,
-		METHOD_OP_ADD,
-		METHOD_OP_ADD_ASSIGN,
-		METHOD_OP_SUB,
-		METHOD_OP_SUB_ASSIGN,
-	],
-	"Rect2": [
-		METHOD_OP_EQUALS
-	],
-	"Transform2D": [
-		METHOD_OP_EQUALS,
-		METHOD_OP_MUL,
-		METHOD_OP_MUL_ASSIGN,
-	],
-	"Color": [
-		METHOD_OP_NEG,
-		METHOD_OP_EQUALS,
-		METHOD_OP_LESS,
-		METHOD_OP_ADD,
-		METHOD_OP_ADD_ASSIGN,
-		METHOD_OP_SUB,
-		METHOD_OP_SUB_ASSIGN,
-		METHOD_OP_MUL,
-		METHOD_OP_MUL_ASSIGN,
-		METHOD_OP_DIV,
-		METHOD_OP_DIV_ASSIGN,
-	],
-	"RID": [
-		METHOD_OP_EQUALS,
-		METHOD_OP_LESS,
-		METHOD_OP_LESS_EQAUL,
-	],
-	"Plane": [
-		METHOD_OP_NEG,
-		METHOD_OP_EQUALS,
-	],
-	"AABB": [
-		METHOD_OP_EQUALS,
-	],
-	"Transform3D": [
-		METHOD_OP_EQUALS,
-		METHOD_OP_MUL,
-		METHOD_OP_MUL_ASSIGN,
-	]
+    "Vector2": [
+        METHOD_OP_NEG,
+        METHOD_OP_EQUALS,
+        METHOD_OP_LESS,
+        METHOD_OP_LESS_EQAUL,
+        METHOD_OP_ADD,
+        METHOD_OP_ADD_ASSIGN,
+        METHOD_OP_SUB,
+        METHOD_OP_SUB_ASSIGN,
+        METHOD_OP_MUL,
+        METHOD_OP_MUL_ASSIGN,
+        METHOD_OP_DIV,
+        METHOD_OP_DIV_ASSIGN,
+    ],
+    "Vector3": [
+        METHOD_OP_NEG,
+        METHOD_OP_EQUALS,
+        METHOD_OP_LESS,
+        METHOD_OP_LESS_EQAUL,
+        METHOD_OP_ADD,
+        METHOD_OP_ADD_ASSIGN,
+        METHOD_OP_SUB,
+        METHOD_OP_SUB_ASSIGN,
+        METHOD_OP_MUL,
+        METHOD_OP_MUL_ASSIGN,
+        METHOD_OP_DIV,
+        METHOD_OP_DIV_ASSIGN,
+    ],
+    "Basis": [
+        METHOD_OP_EQUALS,
+        METHOD_OP_ADD,
+        METHOD_OP_ADD_ASSIGN,
+        METHOD_OP_SUB,
+        METHOD_OP_SUB_ASSIGN,
+        METHOD_OP_MUL,
+        METHOD_OP_MUL_ASSIGN,
+    ],
+    "Quaternion": [
+        METHOD_OP_NEG,
+        METHOD_OP_EQUALS,
+        METHOD_OP_ADD,
+        METHOD_OP_ADD_ASSIGN,
+        METHOD_OP_SUB,
+        METHOD_OP_SUB_ASSIGN,
+    ],
+    "Rect2": [METHOD_OP_EQUALS],
+    "Transform2D": [
+        METHOD_OP_EQUALS,
+        METHOD_OP_MUL,
+        METHOD_OP_MUL_ASSIGN,
+    ],
+    "Color": [
+        METHOD_OP_NEG,
+        METHOD_OP_EQUALS,
+        METHOD_OP_LESS,
+        METHOD_OP_ADD,
+        METHOD_OP_ADD_ASSIGN,
+        METHOD_OP_SUB,
+        METHOD_OP_SUB_ASSIGN,
+        METHOD_OP_MUL,
+        METHOD_OP_MUL_ASSIGN,
+        METHOD_OP_DIV,
+        METHOD_OP_DIV_ASSIGN,
+    ],
+    "RID": [
+        METHOD_OP_EQUALS,
+        METHOD_OP_LESS,
+        METHOD_OP_LESS_EQAUL,
+    ],
+    "Plane": [
+        METHOD_OP_NEG,
+        METHOD_OP_EQUALS,
+    ],
+    "AABB": [
+        METHOD_OP_EQUALS,
+    ],
+    "Transform3D": [
+        METHOD_OP_EQUALS,
+        METHOD_OP_MUL,
+        METHOD_OP_MUL_ASSIGN,
+    ],
 }
 
+
 def apply_pattern(template, values):
-	for key in values:
-		template = template.replace( '${' + key + '}', values[key])
-	return template
+    for key in values:
+        template = template.replace("${" + key + "}", values[key])
+    return template
+
 
 def parse_class(cls):
-	class_name = cls.get('name')
-	ret = {'name': class_name}
-	members = []
-	methods = []
-	operators = []
-	constants = []
-	ret['properties'] = members
-	ret['methods'] = methods
-	ret['operators'] = operators
-	ret['constants'] = constants
-	ret['constructor_argc'] = MAX_CONSTRUCTOR_ARGC[class_name]
-	
-	for m in (cls.find("members") if cls.find("members") is not None else []):
-		m_dict = dict(m.attrib)
-		type = m_dict['type']
-		name = m_dict['name']
-		if (class_name in IGNORED_PROPS) and (name in IGNORED_PROPS[class_name]):
-			continue
-		if type in TYPE_MAP:
-			type = TYPE_MAP[type]
-		native_prop = name
-		if class_name in PROPERTY_REMAP:
-			if name in PROPERTY_REMAP[class_name]:
-				native_prop = PROPERTY_REMAP[class_name][name]
-		members.append({'name': name, 'type': type, 'native': native_prop})
-	
-	for m in (cls.find("methods") if cls.find("methods") is not None else []):
-		m_dict = dict(m.attrib)
-		method_name = m_dict['name']
-		if method_name == class_name:
-			continue# ignore constructors
-		if class_name in IGNORED_PROPS and method_name in IGNORED_PROPS[class_name]:
-			continue# ignored methods
-		if class_name == 'PackedByteArray' and method_name.startswith('encode_') or method_name.startswith('decode_'):
-			continue# ignore decode/encode methods
-		return_type = m.find("return").attrib["type"] if m.find("return") != None else "void"
-		if return_type in TYPE_MAP:
-			return_type = TYPE_MAP[return_type]
-		arguments = []
-		for arg in m.iter('param'):
-			dictArg = dict(arg.attrib)
-			if "dictArg" in dictArg: dictArg.pop("index")
-			dictArg["default_value"] = dictArg["default"] if "default" in dictArg else None
-			if "default" in dictArg: dictArg.pop("default")
-			type = dictArg['type']
-			if type in TYPE_MAP:
-				type = TYPE_MAP[type]
-			arguments.append({
-				'type': type,
-				'default_value': dictArg['default_value'],
-				'has_default_value': "default" in dictArg
-			})
-		methods.append({
-			'name': method_name,
-			'native_method': method_name,
-			'return': return_type,
-			'arguments': arguments,
-		})
-	if class_name.startswith("Packed") and class_name.endswith("Array"):
-		methods.append(METHOD_PACKED_ARRAY_GET)
-	# add operator methods
-	if class_name in OPERATOR_METHODS:
-		for em in OPERATOR_METHODS[class_name]:
-			operators.append(em)
-	
-	for c in (cls.find("constants") if cls.find("constants") is not None else []):
-		const_name = c.get("name")
-		if class_name in IGNORED_PROPS and const_name in IGNORED_PROPS[class_name]:
-			continue
-		constants.append(dict(c.attrib))
-	return json.loads(apply_pattern(json.dumps(ret), {
-		'class_name': class_name,
-	}))
+    class_name = cls.get("name")
+    ret = {"name": class_name}
+    members = []
+    methods = []
+    operators = []
+    constants = []
+    ret["properties"] = members
+    ret["methods"] = methods
+    ret["operators"] = operators
+    ret["constants"] = constants
+    ret["constructor_argc"] = MAX_CONSTRUCTOR_ARGC[class_name]
+
+    for m in cls.find("members") if cls.find("members") is not None else []:
+        m_dict = dict(m.attrib)
+        type = m_dict["type"]
+        name = m_dict["name"]
+        if (class_name in IGNORED_PROPS) and (name in IGNORED_PROPS[class_name]):
+            continue
+        if type in TYPE_MAP:
+            type = TYPE_MAP[type]
+        native_prop = name
+        if class_name in PROPERTY_REMAP:
+            if name in PROPERTY_REMAP[class_name]:
+                native_prop = PROPERTY_REMAP[class_name][name]
+        members.append({"name": name, "type": type, "native": native_prop})
+
+    for m in cls.find("methods") if cls.find("methods") is not None else []:
+        m_dict = dict(m.attrib)
+        method_name = m_dict["name"]
+        if method_name == class_name:
+            continue  # ignore constructors
+        if class_name in IGNORED_PROPS and method_name in IGNORED_PROPS[class_name]:
+            continue  # ignored methods
+        if class_name == "PackedByteArray" and method_name.startswith("encode_") or method_name.startswith("decode_"):
+            continue  # ignore decode/encode methods
+        return_type = m.find("return").attrib["type"] if m.find("return") != None else "void"
+        if return_type in TYPE_MAP:
+            return_type = TYPE_MAP[return_type]
+        arguments = []
+        for arg in m.iter("param"):
+            dictArg = dict(arg.attrib)
+            if "dictArg" in dictArg:
+                dictArg.pop("index")
+            dictArg["default_value"] = dictArg["default"] if "default" in dictArg else None
+            if "default" in dictArg:
+                dictArg.pop("default")
+            type = dictArg["type"]
+            if type in TYPE_MAP:
+                type = TYPE_MAP[type]
+            arguments.append(
+                {"type": type, "default_value": dictArg["default_value"], "has_default_value": "default" in dictArg}
+            )
+        methods.append(
+            {
+                "name": method_name,
+                "native_method": method_name,
+                "return": return_type,
+                "arguments": arguments,
+            }
+        )
+    if class_name.startswith("Packed") and class_name.endswith("Array"):
+        methods.append(METHOD_PACKED_ARRAY_GET)
+    # add operator methods
+    if class_name in OPERATOR_METHODS:
+        for em in OPERATOR_METHODS[class_name]:
+            operators.append(em)
+
+    for c in cls.find("constants") if cls.find("constants") is not None else []:
+        const_name = c.get("name")
+        if class_name in IGNORED_PROPS and const_name in IGNORED_PROPS[class_name]:
+            continue
+        constants.append(dict(c.attrib))
+    return json.loads(
+        apply_pattern(
+            json.dumps(ret),
+            {
+                "class_name": class_name,
+            },
+        )
+    )
+
 
 def generate_api_json(MODULE_DIR):
-	DOCS_DIR = os.path.abspath(os.path.join(MODULE_DIR, "../../doc/classes"))
-	if not os.path.isdir(DOCS_DIR) and len(sys.argv) > 1:
-		DOCS_DIR = sys.argv[-1]
-	OUTPUT_FILE = os.path.join(MODULE_DIR, "builtin_api.gen.json")
-
-	classes = []
-	for cls in BUILTIN_CLASSES:
-		tree = ET.parse(open(os.path.join(DOCS_DIR, cls + '.xml'), 'r'))
-		data = tree.getroot()
-		classes.append(parse_class(data))
-	json.dump(classes, open(OUTPUT_FILE, 'w'), ensure_ascii=False, indent=2, sort_keys=True)
-	
+    DOCS_DIR = os.path.abspath(os.path.join(MODULE_DIR, "../../doc/classes"))
+    if not os.path.isdir(DOCS_DIR) and len(sys.argv) > 1:
+        DOCS_DIR = sys.argv[-1]
+    OUTPUT_FILE = os.path.join(MODULE_DIR, "builtin_api.gen.json")
+
+    classes = []
+    for cls in BUILTIN_CLASSES:
+        tree = ET.parse(open(os.path.join(DOCS_DIR, cls + ".xml"), "r"))
+        data = tree.getroot()
+        classes.append(parse_class(data))
+    json.dump(classes, open(OUTPUT_FILE, "w"), ensure_ascii=False, indent=2, sort_keys=True)
+
+
 if __name__ == "__main__":
-	generate_api_json()
+    generate_api_json(".")
diff --git a/javascript.cpp b/javascript.cpp
index 411965e3..e5f5ea4e 100644
--- a/javascript.cpp
+++ b/javascript.cpp
@@ -1,3 +1,33 @@
+/**************************************************************************/
+/*  javascript.cpp                                                        */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
 #include "javascript.h"
 #include "core/config/engine.h"
 #include "core/io/file_access_encrypted.h"
@@ -35,7 +65,6 @@ StringName JavaScript::get_instance_base_type() const {
 }
 
 ScriptInstance *JavaScript::instance_create(Object *p_this) {
-
 	JavaScriptBinder *binder = JavaScriptLanguage::get_thread_binder(Thread::get_caller_id());
 	ERR_FAIL_NULL_V_MSG(binder, NULL, "Cannot create instance from this thread");
 	const JavaScriptClassInfo *cls = NULL;
@@ -195,7 +224,6 @@ bool JavaScript::get_property_default_value(const StringName &p_property, Varian
 }
 
 void JavaScript::update_exports() {
-
 #ifdef TOOLS_ENABLED
 	if (!javascript_class)
 		return;
@@ -324,8 +352,8 @@ JavaScriptModule::JavaScriptModule() {
 	set_source_code("module.exports = {};" ENDL);
 }
 
-Ref<Resource> ResourceFormatLoaderJavaScriptModule::load(const String &p_path, const String &p_original_path, Error *r_error) {
-	return load_static(p_path, p_original_path, r_error);
+Ref<Resource> ResourceFormatLoaderJavaScriptModule::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, ResourceFormatLoader::CacheMode p_cache_mode) {
+	return ResourceFormatLoaderJavaScriptModule::load_static(p_path, p_original_path, r_error);
 }
 
 void ResourceFormatLoaderJavaScriptModule::get_recognized_extensions(List<String> *p_extensions) const {
@@ -354,7 +382,8 @@ Ref<Resource> ResourceFormatLoaderJavaScriptModule::load_static(const String &p_
 	module->set_script_path(p_path);
 	if (p_path.ends_with("." EXT_JSMODULE) || p_path.ends_with("." EXT_JSCLASS) || p_path.ends_with("." EXT_JSON)) {
 		String code = FileAccess::get_file_as_string(p_path, &err);
-		if (r_error) *r_error = err;
+		if (r_error)
+			*r_error = err;
 		ERR_FAIL_COND_V_MSG(err != OK, Ref<Resource>(), "Cannot load source code from file '" + p_path + "'.");
 		module->set_source_code(code);
 	}
@@ -392,12 +421,13 @@ Ref<Resource> ResourceFormatLoaderJavaScriptModule::load_static(const String &p_
 	}
 #endif
 
-	if (r_error) *r_error = err;
+	if (r_error)
+		*r_error = err;
 	ERR_FAIL_COND_V(err != OK, Ref<Resource>());
 	return module;
 }
 
-Error ResourceFormatSaverJavaScriptModule::save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags) {
+Error ResourceFormatSaverJavaScriptModule::save(const Ref<Resource> &p_resource, const String &p_path, uint32_t p_flags) {
 	Ref<JavaScriptModule> module = p_resource;
 	ERR_FAIL_COND_V(module.is_null(), ERR_INVALID_PARAMETER);
 	String source = module->get_source_code();
diff --git a/javascript.h b/javascript.h
index 1ffbf1a3..51407c47 100644
--- a/javascript.h
+++ b/javascript.h
@@ -1,3 +1,33 @@
+/**************************************************************************/
+/*  javascript.h                                                          */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
 #ifndef JAVASCRIPT_H
 #define JAVASCRIPT_H
 
@@ -125,7 +155,7 @@ class JavaScriptModule : public TextFile {
 class ResourceFormatLoaderJavaScriptModule : public ResourceFormatLoader {
 	GDCLASS(ResourceFormatLoaderJavaScriptModule, ResourceFormatLoader)
 public:
-	virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = NULL);
+	virtual Ref<Resource> load(const String &p_path, const String &p_original_path = "", Error *r_error = nullptr, bool p_use_sub_threads = false, float *r_progress = nullptr, ResourceFormatLoader::CacheMode p_cache_mode = CACHE_MODE_REUSE) override;
 	virtual void get_recognized_extensions(List<String> *p_extensions) const override;
 	virtual void get_recognized_extensions_for_type(const String &p_type, List<String> *p_extensions) const override;
 	virtual bool handles_type(const String &p_type) const override;
@@ -137,9 +167,9 @@ class ResourceFormatLoaderJavaScriptModule : public ResourceFormatLoader {
 class ResourceFormatSaverJavaScriptModule : public ResourceFormatSaver {
 	GDCLASS(ResourceFormatSaverJavaScriptModule, ResourceFormatSaver)
 public:
-	virtual Error save(const String &p_path, const Ref<Resource> &p_resource, uint32_t p_flags = 0);
+	virtual Error save(const Ref<Resource> &p_resource, const String &p_path, uint32_t p_flags = 0) override;
 	virtual void get_recognized_extensions(const Ref<Resource> &p_resource, List<String> *p_extensions) const override;
 	virtual bool recognize(const Ref<Resource> &p_resource) const override;
 };
 
-#endif
+#endif // JAVASCRIPT_H
diff --git a/javascript_binder.h b/javascript_binder.h
index ee296bbf..2d73e054 100644
--- a/javascript_binder.h
+++ b/javascript_binder.h
@@ -1,105 +1,135 @@
-#ifndef JAVASCRIPT_BINDING_HELPER_H
-#define JAVASCRIPT_BINDING_HELPER_H
-
-#include "core/os/thread.h"
-#include "javascript_gc_handler.h"
-
-typedef JavaScriptGCHandler JSMethodInfo;
-
-struct JavaScriptProperyInfo : public PropertyInfo {
-	Variant default_value;
-};
-
-struct JavaScriptError {
-	int line;
-	int column;
-	String message;
-	String file;
-	Vector<String> stack;
-};
-
-struct BasicJavaScriptClassInfo {
-	bool tool;
-	StringName class_name;
-	String icon_path;
-	const ClassDB::ClassInfo *native_class;
-	HashMap<StringName, MethodInfo> signals;
-	HashMap<StringName, MethodInfo> methods;
-	HashMap<StringName, JavaScriptProperyInfo> properties;
-};
-
-struct JavaScriptClassInfo : public BasicJavaScriptClassInfo {
-	JavaScriptGCHandler constructor;
-	JavaScriptGCHandler prototype;
-};
-
-struct GlobalNumberConstant {
-	StringName name;
-	double_t value;
-};
-
-struct JavaScriptStackInfo {
-	int line;
-	String file;
-	String function;
-};
-
-class JavaScriptBinder {
-protected:
-	// Path ==> JavaScript Class
-	HashMap<String, JavaScriptClassInfo> javascript_classes;
-	HashMap<int64_t, JavaScriptGCHandler> frame_callbacks;
-	HashSet<int64_t> canceled_frame_callbacks;
-	static String BINDING_SCRIPT_CONTENT;
-
-public:
-	enum EvalType {
-		EVAL_TYPE_MODULE,
-		EVAL_TYPE_GLOBAL,
-	};
-
-	JavaScriptBinder() {}
-	virtual ~JavaScriptBinder(){};
-
-	virtual JavaScriptBinder *get_context_binder(void *p_context) = 0;
-	virtual Thread::ID get_thread_id() const = 0;
-
-	virtual void clear_classes() { javascript_classes.clear(); }
-
-	virtual void initialize() = 0;
-	virtual void uninitialize() = 0;
-	virtual void language_finalize() = 0;
-	virtual void frame() = 0;
-
-	virtual JavaScriptGCHandler *alloc_object_binding_data(Object *p_object) = 0;
-	virtual void free_object_binding_data(JavaScriptGCHandler *p_gc_handle) = 0;
-	virtual void godot_refcount_incremented(JavaScriptGCHandler *p_gc_handle) = 0;
-	virtual bool godot_refcount_decremented(JavaScriptGCHandler *p_gc_handle) = 0;
-
-	virtual Error eval_string(const String &p_source, EvalType type, const String &p_path, JavaScriptGCHandler &r_ret) = 0;
-	virtual Error safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, JavaScriptGCHandler &r_ret) = 0;
-	virtual String error_to_string(const JavaScriptError &p_error) = 0;
-	virtual Error get_stacks(List<JavaScriptStackInfo> &r_stacks) = 0;
-	virtual String get_backtrace_message(const List<JavaScriptStackInfo> &stacks) = 0;
-
-	virtual Error compile_to_bytecode(const String &p_code, const String &p_file, Vector<uint8_t> &r_bytecode) = 0;
-	virtual Error load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, JavaScriptGCHandler *r_module) = 0;
-	virtual const JavaScriptClassInfo *parse_javascript_class(const String &p_code, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) = 0;
-	virtual const JavaScriptClassInfo *parse_javascript_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) = 0;
-
-	virtual JavaScriptGCHandler create_js_instance_for_godot_object(const JavaScriptClassInfo *p_class, Object *p_object) = 0;
-	virtual bool get_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) = 0;
-	virtual bool set_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) = 0;
-	virtual bool has_method(const JavaScriptGCHandler &p_object, const StringName &p_name) = 0;
-	virtual bool has_signal(const JavaScriptClassInfo *p_class, const StringName &p_signal) = 0;
-	virtual bool validate(const String &p_code, const String &p_path, JavaScriptError *r_error) = 0;
-
-	virtual Variant call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) = 0;
-	virtual Variant call(const JavaScriptGCHandler &p_fuction, const JavaScriptGCHandler &p_target, const Variant **p_args, int p_argcount, Callable::CallError &r_error) = 0;
-
-#ifdef TOOLS_ENABLED
-	virtual const Dictionary &get_modified_api() const = 0;
-#endif
-};
-
-#endif
+/**************************************************************************/
+/*  javascript_binder.h                                                   */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef JAVASCRIPT_BINDER_H
+#define JAVASCRIPT_BINDER_H
+
+#include "core/os/thread.h"
+#include "javascript_gc_handler.h"
+
+typedef JavaScriptGCHandler JSMethodInfo;
+
+struct JavaScriptProperyInfo : public PropertyInfo {
+	Variant default_value;
+};
+
+struct JavaScriptError {
+	int line;
+	int column;
+	String message;
+	String file;
+	Vector<String> stack;
+};
+
+struct BasicJavaScriptClassInfo {
+	bool tool;
+	StringName class_name;
+	String icon_path;
+	const ClassDB::ClassInfo *native_class;
+	HashMap<StringName, MethodInfo> signals;
+	HashMap<StringName, MethodInfo> methods;
+	HashMap<StringName, JavaScriptProperyInfo> properties;
+};
+
+struct JavaScriptClassInfo : public BasicJavaScriptClassInfo {
+	JavaScriptGCHandler constructor;
+	JavaScriptGCHandler prototype;
+};
+
+struct GlobalNumberConstant {
+	StringName name;
+	double_t value;
+};
+
+struct JavaScriptStackInfo {
+	int line;
+	String file;
+	String function;
+};
+
+class JavaScriptBinder {
+protected:
+	// Path ==> JavaScript Class
+	HashMap<String, JavaScriptClassInfo> javascript_classes;
+	HashMap<int64_t, JavaScriptGCHandler> frame_callbacks;
+	HashSet<int64_t> canceled_frame_callbacks;
+	static String BINDING_SCRIPT_CONTENT;
+
+public:
+	enum EvalType {
+		EVAL_TYPE_MODULE,
+		EVAL_TYPE_GLOBAL,
+	};
+
+	JavaScriptBinder() {}
+	virtual ~JavaScriptBinder(){};
+
+	virtual JavaScriptBinder *get_context_binder(void *p_context) = 0;
+	virtual Thread::ID get_thread_id() const = 0;
+
+	virtual void clear_classes() { javascript_classes.clear(); }
+
+	virtual void initialize() = 0;
+	virtual void uninitialize() = 0;
+	virtual void language_finalize() = 0;
+	virtual void frame() = 0;
+
+	virtual JavaScriptGCHandler *alloc_object_binding_data(Object *p_object) = 0;
+	virtual void free_object_binding_data(JavaScriptGCHandler *p_gc_handle) = 0;
+	virtual void godot_refcount_incremented(JavaScriptGCHandler *p_gc_handle) = 0;
+	virtual bool godot_refcount_decremented(JavaScriptGCHandler *p_gc_handle) = 0;
+
+	virtual Error eval_string(const String &p_source, EvalType type, const String &p_path, JavaScriptGCHandler &r_ret) = 0;
+	virtual Error safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, JavaScriptGCHandler &r_ret) = 0;
+	virtual String error_to_string(const JavaScriptError &p_error) = 0;
+	virtual Error get_stacks(List<JavaScriptStackInfo> &r_stacks) = 0;
+	virtual String get_backtrace_message(const List<JavaScriptStackInfo> &stacks) = 0;
+
+	virtual Error compile_to_bytecode(const String &p_code, const String &p_file, Vector<uint8_t> &r_bytecode) = 0;
+	virtual Error load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, JavaScriptGCHandler *r_module) = 0;
+	virtual const JavaScriptClassInfo *parse_javascript_class(const String &p_code, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) = 0;
+	virtual const JavaScriptClassInfo *parse_javascript_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) = 0;
+
+	virtual JavaScriptGCHandler create_js_instance_for_godot_object(const JavaScriptClassInfo *p_class, Object *p_object) = 0;
+	virtual bool get_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) = 0;
+	virtual bool set_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) = 0;
+	virtual bool has_method(const JavaScriptGCHandler &p_object, const StringName &p_name) = 0;
+	virtual bool has_signal(const JavaScriptClassInfo *p_class, const StringName &p_signal) = 0;
+	virtual bool validate(const String &p_code, const String &p_path, JavaScriptError *r_error) = 0;
+
+	virtual Variant call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) = 0;
+	virtual Variant call(const JavaScriptGCHandler &p_fuction, const JavaScriptGCHandler &p_target, const Variant **p_args, int p_argcount, Callable::CallError &r_error) = 0;
+
+#ifdef TOOLS_ENABLED
+	virtual const Dictionary &get_modified_api() const = 0;
+#endif
+};
+
+#endif // JAVASCRIPT_BINDER_H
diff --git a/javascript_callable.h b/javascript_callable.h
index e8ceb011..c2f99b3f 100644
--- a/javascript_callable.h
+++ b/javascript_callable.h
@@ -1,3 +1,33 @@
+/**************************************************************************/
+/*  javascript_callable.h                                                 */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
 #ifndef JAVASCRIPT_CALLABLE_H
 #define JAVASCRIPT_CALLABLE_H
 
@@ -10,7 +40,8 @@ class JavaScriptCallable : public CallableCustom {
 
 public:
 	JavaScriptCallable() {}
-	JavaScriptCallable(const JavaScriptGCHandler &p_function) : js_function(p_function) {}
+	JavaScriptCallable(const JavaScriptGCHandler &p_function) :
+			js_function(p_function) {}
 	virtual ~JavaScriptCallable() {}
 };
 
diff --git a/javascript_gc_handler.h b/javascript_gc_handler.h
index 0d88ffc4..a207d5c7 100644
--- a/javascript_gc_handler.h
+++ b/javascript_gc_handler.h
@@ -1,152 +1,182 @@
-#ifndef JAVASCRIPT_GC_HANDLER_H
-#define JAVASCRIPT_GC_HANDLER_H
-
-#include "core/object/object.h"
-#include "core/object/ref_counted.h"
-#include "core/variant/variant.h"
-
-#define PROTOTYPE_LITERAL "prototype"
-#define PROTO_LITERAL "__proto__"
-#define TO_STRING_LITERAL "toString"
-#define JS_CLASS_NAME_LITERAL "class_name"
-#define GODOT_OBJECT_NAME "godot"
-
-struct JavaScriptGCHandler {
-	enum {
-		FLAG_NONE = 0,
-		FLAG_ATOMIC_VALUE = 1 << 1,
-		FLAG_BUILTIN_CLASS = 1 << 2,
-		FLAG_OBJECT = 1 << 3,
-		FLAG_REF_COUNTED = 1 << 4,
-		FLAG_FINALIZED = 1 << 5,
-		FLAG_TRANSFERABLE = 1 << 6,
-	};
-	Variant::Type type;
-	uint8_t flags;
-	void *context;
-	void *javascript_object;
-	union {
-		Object *godot_object;
-		void *godot_builtin_object_ptr;
-		void *native_ptr;
-	};
-
-	_FORCE_INLINE_ Variant get_value() const {
-		switch (type) {
-			case Variant::OBJECT:
-				return godot_object;
-			case Variant::VECTOR2:
-				return *(static_cast<Vector2 *>(godot_builtin_object_ptr));
-			case Variant::RECT2:
-				return *(static_cast<Rect2 *>(godot_builtin_object_ptr));
-			case Variant::QUATERNION:
-				return *(static_cast<Quaternion *>(godot_builtin_object_ptr));
-			case Variant::COLOR:
-				return *(static_cast<Color *>(godot_builtin_object_ptr));
-			case Variant::RID:
-				return *(static_cast<RID *>(godot_builtin_object_ptr));
-			case Variant::TRANSFORM3D:
-				return *(static_cast<Transform3D *>(godot_builtin_object_ptr));
-			case Variant::TRANSFORM2D:
-				return *(static_cast<Transform2D *>(godot_builtin_object_ptr));
-			case Variant::BASIS:
-				return *(static_cast<Basis *>(godot_builtin_object_ptr));
-			case Variant::VECTOR3:
-				return *(static_cast<Vector3 *>(godot_builtin_object_ptr));
-			case Variant::PLANE:
-				return *(static_cast<Plane *>(godot_builtin_object_ptr));
-			case Variant::AABB:
-				return *(static_cast<AABB *>(godot_builtin_object_ptr));
-			case Variant::PACKED_INT32_ARRAY:
-				return *(static_cast<PackedInt32Array *>(godot_builtin_object_ptr));
-			case Variant::PACKED_INT64_ARRAY:
-				return *(static_cast<PackedInt64Array *>(godot_builtin_object_ptr));
-			case Variant::PACKED_BYTE_ARRAY:
-				return *(static_cast<PackedByteArray *>(godot_builtin_object_ptr));
-			case Variant::PACKED_FLOAT32_ARRAY:
-				return *(static_cast<PackedFloat32Array *>(godot_builtin_object_ptr));
-			case Variant::PACKED_FLOAT64_ARRAY:
-				return *(static_cast<PackedFloat64Array *>(godot_builtin_object_ptr));
-			case Variant::PACKED_COLOR_ARRAY:
-				return *(static_cast<PackedColorArray *>(godot_builtin_object_ptr));
-			case Variant::PACKED_STRING_ARRAY:
-				return *(static_cast<PackedStringArray *>(godot_builtin_object_ptr));
-			case Variant::PACKED_VECTOR2_ARRAY:
-				return *(static_cast<PackedVector2Array *>(godot_builtin_object_ptr));
-			case Variant::PACKED_VECTOR3_ARRAY:
-				return *(static_cast<PackedVector3Array *>(godot_builtin_object_ptr));
-			default:
-				return Variant();
-		}
-		return Variant();
-	}
-
-	_FORCE_INLINE_ Object *get_godot_object() {
-		if (flags & FLAG_OBJECT) {
-			return godot_object;
-		}
-		return nullptr;
-	}
-
-	_FORCE_INLINE_ Vector2 *getVector2() const { return static_cast<Vector2 *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Rect2 *getRect2() const { return static_cast<Rect2 *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Color *getColor() const { return static_cast<Color *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ AABB *getAABB() const { return static_cast<AABB *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Vector3 *getVector3() const { return static_cast<Vector3 *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Transform2D *getTransform2D() const { return static_cast<Transform2D *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Transform3D *getTransform3D() const { return static_cast<Transform3D *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Basis *getBasis() const { return static_cast<Basis *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ RID *getRID() const { return static_cast<RID *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Plane *getPlane() const { return static_cast<Plane *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Quaternion *getQuaternion() const { return static_cast<Quaternion *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedInt32Array *getPackedInt32Array() const { return static_cast<PackedInt32Array *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedInt64Array *getPackedInt64Array() const { return static_cast<PackedInt64Array *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedByteArray *getPackedByteArray() const { return static_cast<PackedByteArray *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedFloat32Array *getPackedFloat32Array() const { return static_cast<PackedFloat32Array *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedFloat64Array *getPackedFloat64Array() const { return static_cast<PackedFloat64Array *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedStringArray *getPackedStringArray() const { return static_cast<PackedStringArray *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedColorArray *getPackedColorArray() const { return static_cast<PackedColorArray *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedVector2Array *getPackedVector2Array() const { return static_cast<PackedVector2Array *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedVector3Array *getPackedVector3Array() const { return static_cast<PackedVector3Array *>(godot_builtin_object_ptr); }
-
-	_FORCE_INLINE_ bool is_object() const {
-		return flags & FLAG_OBJECT;
-	}
-
-	_FORCE_INLINE_ bool is_ref_counted() const {
-		return flags & FLAG_REF_COUNTED;
-	}
-
-	_FORCE_INLINE_ bool is_transferable() const {
-		return flags & FLAG_TRANSFERABLE;
-	}
-
-	_FORCE_INLINE_ bool is_atomic_type() const {
-		return flags & FLAG_ATOMIC_VALUE;
-	}
-
-	_FORCE_INLINE_ bool is_finalized() const {
-		return flags & FLAG_FINALIZED;
-	}
-
-	_FORCE_INLINE_ bool is_valid_javascript_object() const {
-		return context != NULL && javascript_object != NULL && !is_finalized();
-	}
-
-	_FORCE_INLINE_ void clear() {
-		type = Variant::NIL;
-		godot_object = NULL;
-		javascript_object = NULL;
-		context = NULL;
-	}
-
-	JavaScriptGCHandler() {
-		type = Variant::NIL;
-		flags = FLAG_NONE;
-		godot_object = NULL;
-		javascript_object = NULL;
-		context = NULL;
-	}
-};
-
-#endif
+/**************************************************************************/
+/*  javascript_gc_handler.h                                               */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef JAVASCRIPT_GC_HANDLER_H
+#define JAVASCRIPT_GC_HANDLER_H
+
+#include "core/object/object.h"
+#include "core/object/ref_counted.h"
+#include "core/variant/variant.h"
+
+#define PROTOTYPE_LITERAL "prototype"
+#define PROTO_LITERAL "__proto__"
+#define TO_STRING_LITERAL "toString"
+#define JS_CLASS_NAME_LITERAL "class_name"
+#define GODOT_OBJECT_NAME "godot"
+
+struct JavaScriptGCHandler {
+	enum {
+		FLAG_NONE = 0,
+		FLAG_ATOMIC_VALUE = 1 << 1,
+		FLAG_BUILTIN_CLASS = 1 << 2,
+		FLAG_OBJECT = 1 << 3,
+		FLAG_REF_COUNTED = 1 << 4,
+		FLAG_FINALIZED = 1 << 5,
+		FLAG_TRANSFERABLE = 1 << 6,
+	};
+	Variant::Type type;
+	uint8_t flags;
+	void *context;
+	void *javascript_object;
+	union {
+		Object *godot_object;
+		void *godot_builtin_object_ptr;
+		void *native_ptr;
+	};
+
+	_FORCE_INLINE_ Variant get_value() const {
+		switch (type) {
+			case Variant::OBJECT:
+				return godot_object;
+			case Variant::VECTOR2:
+				return *(static_cast<Vector2 *>(godot_builtin_object_ptr));
+			case Variant::RECT2:
+				return *(static_cast<Rect2 *>(godot_builtin_object_ptr));
+			case Variant::QUATERNION:
+				return *(static_cast<Quaternion *>(godot_builtin_object_ptr));
+			case Variant::COLOR:
+				return *(static_cast<Color *>(godot_builtin_object_ptr));
+			case Variant::RID:
+				return *(static_cast<RID *>(godot_builtin_object_ptr));
+			case Variant::TRANSFORM3D:
+				return *(static_cast<Transform3D *>(godot_builtin_object_ptr));
+			case Variant::TRANSFORM2D:
+				return *(static_cast<Transform2D *>(godot_builtin_object_ptr));
+			case Variant::BASIS:
+				return *(static_cast<Basis *>(godot_builtin_object_ptr));
+			case Variant::VECTOR3:
+				return *(static_cast<Vector3 *>(godot_builtin_object_ptr));
+			case Variant::PLANE:
+				return *(static_cast<Plane *>(godot_builtin_object_ptr));
+			case Variant::AABB:
+				return *(static_cast<AABB *>(godot_builtin_object_ptr));
+			case Variant::PACKED_INT32_ARRAY:
+				return *(static_cast<PackedInt32Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_INT64_ARRAY:
+				return *(static_cast<PackedInt64Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_BYTE_ARRAY:
+				return *(static_cast<PackedByteArray *>(godot_builtin_object_ptr));
+			case Variant::PACKED_FLOAT32_ARRAY:
+				return *(static_cast<PackedFloat32Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_FLOAT64_ARRAY:
+				return *(static_cast<PackedFloat64Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_COLOR_ARRAY:
+				return *(static_cast<PackedColorArray *>(godot_builtin_object_ptr));
+			case Variant::PACKED_STRING_ARRAY:
+				return *(static_cast<PackedStringArray *>(godot_builtin_object_ptr));
+			case Variant::PACKED_VECTOR2_ARRAY:
+				return *(static_cast<PackedVector2Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_VECTOR3_ARRAY:
+				return *(static_cast<PackedVector3Array *>(godot_builtin_object_ptr));
+			default:
+				return Variant();
+		}
+		return Variant();
+	}
+
+	_FORCE_INLINE_ Object *get_godot_object() {
+		if (flags & FLAG_OBJECT) {
+			return godot_object;
+		}
+		return nullptr;
+	}
+
+	_FORCE_INLINE_ Vector2 *getVector2() const { return static_cast<Vector2 *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Rect2 *getRect2() const { return static_cast<Rect2 *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Color *getColor() const { return static_cast<Color *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ AABB *getAABB() const { return static_cast<AABB *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Vector3 *getVector3() const { return static_cast<Vector3 *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Transform2D *getTransform2D() const { return static_cast<Transform2D *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Transform3D *getTransform3D() const { return static_cast<Transform3D *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Basis *getBasis() const { return static_cast<Basis *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ RID *getRID() const { return static_cast<RID *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Plane *getPlane() const { return static_cast<Plane *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Quaternion *getQuaternion() const { return static_cast<Quaternion *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedInt32Array *getPackedInt32Array() const { return static_cast<PackedInt32Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedInt64Array *getPackedInt64Array() const { return static_cast<PackedInt64Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedByteArray *getPackedByteArray() const { return static_cast<PackedByteArray *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedFloat32Array *getPackedFloat32Array() const { return static_cast<PackedFloat32Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedFloat64Array *getPackedFloat64Array() const { return static_cast<PackedFloat64Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedStringArray *getPackedStringArray() const { return static_cast<PackedStringArray *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedColorArray *getPackedColorArray() const { return static_cast<PackedColorArray *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedVector2Array *getPackedVector2Array() const { return static_cast<PackedVector2Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedVector3Array *getPackedVector3Array() const { return static_cast<PackedVector3Array *>(godot_builtin_object_ptr); }
+
+	_FORCE_INLINE_ bool is_object() const {
+		return flags & FLAG_OBJECT;
+	}
+
+	_FORCE_INLINE_ bool is_ref_counted() const {
+		return flags & FLAG_REF_COUNTED;
+	}
+
+	_FORCE_INLINE_ bool is_transferable() const {
+		return flags & FLAG_TRANSFERABLE;
+	}
+
+	_FORCE_INLINE_ bool is_atomic_type() const {
+		return flags & FLAG_ATOMIC_VALUE;
+	}
+
+	_FORCE_INLINE_ bool is_finalized() const {
+		return flags & FLAG_FINALIZED;
+	}
+
+	_FORCE_INLINE_ bool is_valid_javascript_object() const {
+		return context != NULL && javascript_object != NULL && !is_finalized();
+	}
+
+	_FORCE_INLINE_ void clear() {
+		type = Variant::NIL;
+		godot_object = NULL;
+		javascript_object = NULL;
+		context = NULL;
+	}
+
+	JavaScriptGCHandler() {
+		type = Variant::NIL;
+		flags = FLAG_NONE;
+		godot_object = NULL;
+		javascript_object = NULL;
+		context = NULL;
+	}
+};
+
+#endif // JAVASCRIPT_GC_HANDLER_H
diff --git a/javascript_instance.cpp b/javascript_instance.cpp
index af0e67b8..6b48beb9 100644
--- a/javascript_instance.cpp
+++ b/javascript_instance.cpp
@@ -1,3 +1,33 @@
+/**************************************************************************/
+/*  javascript_instance.cpp                                               */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
 #include "javascript_instance.h"
 #include "javascript.h"
 #include "javascript_language.h"
diff --git a/javascript_instance.h b/javascript_instance.h
index 01220a47..32320dcd 100644
--- a/javascript_instance.h
+++ b/javascript_instance.h
@@ -1,10 +1,40 @@
+/**************************************************************************/
+/*  javascript_instance.h                                                 */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
 #ifndef JAVASCRIPT_INSTANCE_H
 #define JAVASCRIPT_INSTANCE_H
 
-#include "javascript.h"
-#include "javascript_binder.h"
 #include "core/object/script_language.h"
 #include "core/variant/callable.h"
+#include "javascript.h"
+#include "javascript_binder.h"
 
 class JavaScriptInstance : public ScriptInstance {
 	friend class JavaScript;
@@ -39,4 +69,4 @@ class JavaScriptInstance : public ScriptInstance {
 	~JavaScriptInstance();
 };
 
-#endif
+#endif // JAVASCRIPT_INSTANCE_H
diff --git a/javascript_language.cpp b/javascript_language.cpp
index cd2fe07a..17dd831f 100644
--- a/javascript_language.cpp
+++ b/javascript_language.cpp
@@ -1,357 +1,387 @@
-#include "javascript_language.h"
-#include "core/object/class_db.h"
-#include "core/io/file_access.h"
-JavaScriptLanguage *JavaScriptLanguage::singleton = NULL;
-
-namespace JavaScriptInstanceBindingCallbacks {
-
-static void *create_callback(void *p_token, void *p_instance) {
-	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
-		return binder->alloc_object_binding_data(static_cast<Object *>(p_instance));
-	}
-	return nullptr;
-}
-
-static void free_callback(void *p_token, void *p_instance, void *p_binding) {
-	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
-		return binder->free_object_binding_data(static_cast<JavaScriptGCHandler *>(p_binding));
-	}
-}
-
-static GDExtensionBool reference_callback(void *p_token, void *p_binding, GDExtensionBool p_reference) {
-	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
-		if (p_reference) {
-			binder->godot_refcount_incremented(static_cast<JavaScriptGCHandler *>(p_binding));
-			return false;
-		} else {
-			return binder->godot_refcount_decremented(static_cast<JavaScriptGCHandler *>(p_binding));
-		}
-	}
-	return true;
-}
-
-} // namespace JavaScriptInstanceBindingCallbacks
-
-JavaScriptLanguage::JavaScriptLanguage() {
-	ERR_FAIL_COND(singleton);
-	singleton = this;
-	main_binder = memnew(QuickJSBinder);
-	callable_middleman = memnew(CallableMiddleman);
-	instance_binding_callbacks.create_callback = JavaScriptInstanceBindingCallbacks::create_callback;
-	instance_binding_callbacks.free_callback = JavaScriptInstanceBindingCallbacks::free_callback;
-	instance_binding_callbacks.reference_callback = JavaScriptInstanceBindingCallbacks::reference_callback;
-}
-
-JavaScriptLanguage::~JavaScriptLanguage() {
-	memdelete(main_binder);
-	memdelete(callable_middleman);
-}
-
-void JavaScriptLanguage::init() {
-	ERR_FAIL_NULL(main_binder);
-	main_binder->initialize();
-	execute_file("modules/javascript/tests/UnitTest.js");
-}
-
-void JavaScriptLanguage::finish() {
-	ERR_FAIL_NULL(main_binder);
-	main_binder->uninitialize();
-	main_binder->language_finalize();
-}
-
-Error JavaScriptLanguage::execute_file(const String &p_path) {
-	ERR_FAIL_NULL_V(main_binder, ERR_BUG);
-	Error err;
-	String code = FileAccess::get_file_as_string(p_path, &err);
-	if (err == OK) {
-		JavaScriptGCHandler eval_ret;
-		err = main_binder->eval_string(code, JavaScriptBinder::EVAL_TYPE_GLOBAL, p_path, eval_ret);
-	}
-	return err;
-}
-
-void JavaScriptLanguage::get_reserved_words(List<String> *p_words) const {
-	static const char *_reserved_words[] = {
-		"null",
-		"false",
-		"true",
-		"if",
-		"else",
-		"return",
-		"var",
-		"this",
-		"delete",
-		"void",
-		"typeof",
-		"new",
-		"in",
-		"instanceof",
-		"do",
-		"while",
-		"for",
-		"break",
-		"continue",
-		"switch",
-		"case",
-		"default",
-		"throw",
-		"try",
-		"catch",
-		"finally",
-		"function",
-		"debugger",
-		"with",
-		"class",
-		"const",
-		"enum",
-		"export",
-		"default",
-		"extends",
-		"import",
-		"super",
-		"implements",
-		"interface",
-		"let",
-		"package",
-		"private",
-		"protected",
-		"public",
-		"static",
-		"yield",
-		"await",
-		"prototype",
-		"constructor",
-		"get",
-		"set",
-		"of",
-		"__proto__",
-		"undefined",
-		"number",
-		"boolean",
-		"string",
-		"object",
-		"symbol",
-		"arguments",
-		"join",
-		"global",
-		"as",
-		"from",
-		"default",
-		"*",
-		"then",
-		"resolve",
-		"reject",
-		"promise",
-		"proxy",
-		"revoke",
-		"async",
-		"globalThis",
-		"Object",
-		"Array",
-		"Error",
-		"Number",
-		"String",
-		"Boolean",
-		"Symbol",
-		"Arguments",
-		"Math",
-		"JSON",
-		"Date",
-		"Function",
-		"GeneratorFunction",
-		"ForInIterator",
-		"RegExp",
-		"ArrayBuffer",
-		"SharedArrayBuffer",
-		"Uint8ClampedArray",
-		"Int8Array",
-		"Uint8Array",
-		"Int16Array",
-		"Uint16Array",
-		"Int32Array",
-		"Uint32Array",
-		"BigInt64Array",
-		"BigUint64Array",
-		"Float32Array",
-		"Float64Array",
-		"DataView",
-		"Map",
-		"Set",
-		"WeakMap",
-		"WeakSet",
-		"Generator",
-		"Proxy",
-		"Promise",
-		0
-	};
-
-	const char **w = _reserved_words;
-
-	while (*w) {
-
-		p_words->push_back(*w);
-		w++;
-	}
-}
-
-bool JavaScriptLanguage::is_control_flow_keyword(String p_keyword) const {
-	return p_keyword == "if" ||
-		   p_keyword == "else" ||
-		   p_keyword == "return" ||
-		   p_keyword == "do" ||
-		   p_keyword == "while" ||
-		   p_keyword == "for" ||
-		   p_keyword == "break" ||
-		   p_keyword == "continue" ||
-		   p_keyword == "switch" ||
-		   p_keyword == "case" ||
-		   p_keyword == "throw" ||
-		   p_keyword == "try" ||
-		   p_keyword == "catch" ||
-		   p_keyword == "finally";
-}
-
-void JavaScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
-	p_delimiters->push_back("//"); // single-line comment
-	p_delimiters->push_back("/* */"); // delimited comment
-}
-
-void JavaScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
-	p_delimiters->push_back("' '");
-	p_delimiters->push_back("\" \"");
-	p_delimiters->push_back("` `");
-}
-
-Ref<Script> JavaScriptLanguage::make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const {
-	Ref<JavaScript> script;
-	script.instantiate();
-	String src = p_template.replace("%BASE%", p_base_class_name).replace("%CLASS%", p_class_name);
-	script->set_source_code(src);
-	return script;
-}
-
-Vector<ScriptLanguage::ScriptTemplate> JavaScriptLanguage::get_built_in_templates(StringName p_object) {
-	Vector<ScriptLanguage::ScriptTemplate> templates;
-#ifdef TOOLS_ENABLED
-	constexpr size_t len = 2;
-	static const struct ScriptLanguage::ScriptTemplate TEMPLATES[len] = {
-		{ "Node",
-			"Default",
-			"Base template for Node with default Godot cycle methods",
-			"export default class %CLASS% extends " GODOT_OBJECT_NAME ".%BASE% {\n"
-			"    \n"
-			"    constructor() {\n"
-			"        super();\n"
-			"    }\n"
-			"    \n"
-			"    // Called when the node enters the scene tree for the first time.\n"
-			"    _ready() {\n"
-			"        \n"
-			"    }\n"
-			"    \n"
-			"    // Called every frame. 'delta' is the elapsed time since the previous frame.\n"
-			"    _process(delta) {\n"
-			"        \n"
-			"    }\n"
-			"}\n" },
-		{ "Object",
-			"Empty",
-			"Empty template suitable for all Objects",
-			"export default class %CLASS% extends " GODOT_OBJECT_NAME ".%BASE% {\n"
-			"    \n"
-			"    // Declare member variables here. Examples:\n"
-			"    a = 2;\n"
-			"    b = \"text\";\n"
-			"    \n"
-			"    constructor() {\n"
-			"        super();\n"
-			"    }\n"
-			"    \n"
-			"}\n" },
-	};
-
-	for (int i = 0; i < len; i++) {
-		if (TEMPLATES[i].inherit == p_object) {
-			templates.append(TEMPLATES[i]);
-		}
-	}
-#endif
-
-	return templates;
-}
-
-bool JavaScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptError> *r_errors, List<Warning> *r_warnings, HashSet<int> *r_safe_lines) const {
-	JavaScriptError script_error;
-	bool ret = main_binder->validate(p_script, p_path, &script_error);
-	if (!ret) {
-		ScriptError se;
-		se.line = script_error.line;
-		se.column = script_error.column;
-		se.message = script_error.message;
-		r_errors->push_back(se);
-	}
-	return ret;
-}
-
-Script *JavaScriptLanguage::create_script() const {
-	return memnew(JavaScript);
-}
-
-void JavaScriptLanguage::reload_all_scripts() {
-#ifdef TOOLS_ENABLED
-	for (const Ref<JavaScript> &s : scripts) {
-		reload_script(s, true);
-	}
-#endif
-}
-
-void JavaScriptLanguage::reload_script(const Ref<Script> &p_script, bool p_soft_reload) {
-	Ref<JavaScript> s = p_script;
-	if (s.is_valid()) {
-		Error err = OK;
-		Ref<JavaScriptModule> module = ResourceFormatLoaderJavaScriptModule::load_static(s->get_script_path(), "", &err);
-		ERR_FAIL_COND_MSG(err != OK, ("Cannot load script file '" + s->get_script_path() + "'."));
-		s->set_source_code(module->get_source_code());
-		err = s->reload(p_soft_reload);
-		ERR_FAIL_COND_MSG(err != OK, "Parse source code from file '" + s->get_script_path() + "' failed.");
-	}
-}
-
-void JavaScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
-	p_extensions->push_back(EXT_JSMODULE);
-	p_extensions->push_back(EXT_JSCLASS);
-	p_extensions->push_back(EXT_JSON);
-}
-
-void JavaScriptLanguage::frame() {
-	main_binder->frame();
-}
-
-String JavaScriptLanguage::globalize_relative_path(const String &p_relative, const String &p_base_dir) {
-	String file = p_relative;
-	if (file.begins_with(".")) {
-		String base_dir = p_base_dir;
-		while (base_dir.ends_with(".")) {
-			if (base_dir.ends_with("..")) {
-				base_dir = base_dir.get_base_dir().get_base_dir();
-			} else {
-				base_dir = base_dir.get_base_dir();
-			}
-		}
-		String file_path = file;
-		while (file_path.begins_with(".")) {
-			if (file_path.begins_with("../")) {
-				base_dir = base_dir.get_base_dir();
-				file_path = file_path.substr(3);
-			} else if (file_path.begins_with("./")) {
-				file_path = file_path.substr(2);
-			} else {
-				file_path = file_path.get_basename();
-				break;
-			}
-		}
-		if (!base_dir.ends_with("/")) base_dir += "/";
-		file = base_dir + file_path;
-	}
-	return file;
-}
+/**************************************************************************/
+/*  javascript_language.cpp                                               */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "javascript_language.h"
+#include "core/io/file_access.h"
+#include "core/object/class_db.h"
+JavaScriptLanguage *JavaScriptLanguage::singleton = NULL;
+
+namespace JavaScriptInstanceBindingCallbacks {
+
+static void *create_callback(void *p_token, void *p_instance) {
+	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+		return binder->alloc_object_binding_data(static_cast<Object *>(p_instance));
+	}
+	return nullptr;
+}
+
+static void free_callback(void *p_token, void *p_instance, void *p_binding) {
+	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+		return binder->free_object_binding_data(static_cast<JavaScriptGCHandler *>(p_binding));
+	}
+}
+
+static GDExtensionBool reference_callback(void *p_token, void *p_binding, GDExtensionBool p_reference) {
+	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+		if (p_reference) {
+			binder->godot_refcount_incremented(static_cast<JavaScriptGCHandler *>(p_binding));
+			return false;
+		} else {
+			return binder->godot_refcount_decremented(static_cast<JavaScriptGCHandler *>(p_binding));
+		}
+	}
+	return true;
+}
+
+} // namespace JavaScriptInstanceBindingCallbacks
+
+JavaScriptLanguage::JavaScriptLanguage() {
+	ERR_FAIL_COND(singleton);
+	singleton = this;
+	main_binder = memnew(QuickJSBinder);
+	callable_middleman = memnew(CallableMiddleman);
+	instance_binding_callbacks.create_callback = JavaScriptInstanceBindingCallbacks::create_callback;
+	instance_binding_callbacks.free_callback = JavaScriptInstanceBindingCallbacks::free_callback;
+	instance_binding_callbacks.reference_callback = JavaScriptInstanceBindingCallbacks::reference_callback;
+}
+
+JavaScriptLanguage::~JavaScriptLanguage() {
+	memdelete(main_binder);
+	memdelete(callable_middleman);
+}
+
+void JavaScriptLanguage::init() {
+	ERR_FAIL_NULL(main_binder);
+	main_binder->initialize();
+	execute_file("modules/javascript/tests/UnitTest.js");
+}
+
+void JavaScriptLanguage::finish() {
+	ERR_FAIL_NULL(main_binder);
+	main_binder->uninitialize();
+	main_binder->language_finalize();
+}
+
+Error JavaScriptLanguage::execute_file(const String &p_path) {
+	ERR_FAIL_NULL_V(main_binder, ERR_BUG);
+	Error err;
+	String code = FileAccess::get_file_as_string(p_path, &err);
+	if (err == OK) {
+		JavaScriptGCHandler eval_ret;
+		err = main_binder->eval_string(code, JavaScriptBinder::EVAL_TYPE_GLOBAL, p_path, eval_ret);
+	}
+	return err;
+}
+
+void JavaScriptLanguage::get_reserved_words(List<String> *p_words) const {
+	static const char *_reserved_words[] = {
+		"null",
+		"false",
+		"true",
+		"if",
+		"else",
+		"return",
+		"var",
+		"this",
+		"delete",
+		"void",
+		"typeof",
+		"new",
+		"in",
+		"instanceof",
+		"do",
+		"while",
+		"for",
+		"break",
+		"continue",
+		"switch",
+		"case",
+		"default",
+		"throw",
+		"try",
+		"catch",
+		"finally",
+		"function",
+		"debugger",
+		"with",
+		"class",
+		"const",
+		"enum",
+		"export",
+		"default",
+		"extends",
+		"import",
+		"super",
+		"implements",
+		"interface",
+		"let",
+		"package",
+		"private",
+		"protected",
+		"public",
+		"static",
+		"yield",
+		"await",
+		"prototype",
+		"constructor",
+		"get",
+		"set",
+		"of",
+		"__proto__",
+		"undefined",
+		"number",
+		"boolean",
+		"string",
+		"object",
+		"symbol",
+		"arguments",
+		"join",
+		"global",
+		"as",
+		"from",
+		"default",
+		"*",
+		"then",
+		"resolve",
+		"reject",
+		"promise",
+		"proxy",
+		"revoke",
+		"async",
+		"globalThis",
+		"Object",
+		"Array",
+		"Error",
+		"Number",
+		"String",
+		"Boolean",
+		"Symbol",
+		"Arguments",
+		"Math",
+		"JSON",
+		"Date",
+		"Function",
+		"GeneratorFunction",
+		"ForInIterator",
+		"RegExp",
+		"ArrayBuffer",
+		"SharedArrayBuffer",
+		"Uint8ClampedArray",
+		"Int8Array",
+		"Uint8Array",
+		"Int16Array",
+		"Uint16Array",
+		"Int32Array",
+		"Uint32Array",
+		"BigInt64Array",
+		"BigUint64Array",
+		"Float32Array",
+		"Float64Array",
+		"DataView",
+		"Map",
+		"Set",
+		"WeakMap",
+		"WeakSet",
+		"Generator",
+		"Proxy",
+		"Promise",
+		0
+	};
+
+	const char **w = _reserved_words;
+
+	while (*w) {
+		p_words->push_back(*w);
+		w++;
+	}
+}
+
+bool JavaScriptLanguage::is_control_flow_keyword(String p_keyword) const {
+	return p_keyword == "if" ||
+			p_keyword == "else" ||
+			p_keyword == "return" ||
+			p_keyword == "do" ||
+			p_keyword == "while" ||
+			p_keyword == "for" ||
+			p_keyword == "break" ||
+			p_keyword == "continue" ||
+			p_keyword == "switch" ||
+			p_keyword == "case" ||
+			p_keyword == "throw" ||
+			p_keyword == "try" ||
+			p_keyword == "catch" ||
+			p_keyword == "finally";
+}
+
+void JavaScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
+	p_delimiters->push_back("//"); // single-line comment
+	p_delimiters->push_back("/* */"); // delimited comment
+}
+
+void JavaScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
+	p_delimiters->push_back("' '");
+	p_delimiters->push_back("\" \"");
+	p_delimiters->push_back("` `");
+}
+
+Ref<Script> JavaScriptLanguage::make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const {
+	Ref<JavaScript> script;
+	script.instantiate();
+	String src = p_template.replace("%BASE%", p_base_class_name).replace("%CLASS%", p_class_name);
+	script->set_source_code(src);
+	return script;
+}
+
+Vector<ScriptLanguage::ScriptTemplate> JavaScriptLanguage::get_built_in_templates(StringName p_object) {
+	Vector<ScriptLanguage::ScriptTemplate> templates;
+#ifdef TOOLS_ENABLED
+	constexpr size_t len = 2;
+	static const struct ScriptLanguage::ScriptTemplate TEMPLATES[len] = {
+		{ "Node",
+				"Default",
+				"Base template for Node with default Godot cycle methods",
+				"export default class %CLASS% extends " GODOT_OBJECT_NAME ".%BASE% {\n"
+				"    \n"
+				"    constructor() {\n"
+				"        super();\n"
+				"    }\n"
+				"    \n"
+				"    // Called when the node enters the scene tree for the first time.\n"
+				"    _ready() {\n"
+				"        \n"
+				"    }\n"
+				"    \n"
+				"    // Called every frame. 'delta' is the elapsed time since the previous frame.\n"
+				"    _process(delta) {\n"
+				"        \n"
+				"    }\n"
+				"}\n" },
+		{ "Object",
+				"Empty",
+				"Empty template suitable for all Objects",
+				"export default class %CLASS% extends " GODOT_OBJECT_NAME ".%BASE% {\n"
+				"    \n"
+				"    // Declare member variables here. Examples:\n"
+				"    a = 2;\n"
+				"    b = \"text\";\n"
+				"    \n"
+				"    constructor() {\n"
+				"        super();\n"
+				"    }\n"
+				"    \n"
+				"}\n" },
+	};
+
+	for (int i = 0; i < len; i++) {
+		if (TEMPLATES[i].inherit == p_object) {
+			templates.append(TEMPLATES[i]);
+		}
+	}
+#endif
+
+	return templates;
+}
+
+bool JavaScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptError> *r_errors, List<Warning> *r_warnings, HashSet<int> *r_safe_lines) const {
+	JavaScriptError script_error;
+	bool ret = main_binder->validate(p_script, p_path, &script_error);
+	if (!ret) {
+		ScriptError se;
+		se.line = script_error.line;
+		se.column = script_error.column;
+		se.message = script_error.message;
+		r_errors->push_back(se);
+	}
+	return ret;
+}
+
+Script *JavaScriptLanguage::create_script() const {
+	return memnew(JavaScript);
+}
+
+void JavaScriptLanguage::reload_all_scripts() {
+#ifdef TOOLS_ENABLED
+	for (const Ref<JavaScript> &s : scripts) {
+		reload_script(s, true);
+	}
+#endif
+}
+
+void JavaScriptLanguage::reload_script(const Ref<Script> &p_script, bool p_soft_reload) {
+	Ref<JavaScript> s = p_script;
+	if (s.is_valid()) {
+		Error err = OK;
+		Ref<JavaScriptModule> module = ResourceFormatLoaderJavaScriptModule::load_static(s->get_script_path(), "", &err);
+		ERR_FAIL_COND_MSG(err != OK, ("Cannot load script file '" + s->get_script_path() + "'."));
+		s->set_source_code(module->get_source_code());
+		err = s->reload(p_soft_reload);
+		ERR_FAIL_COND_MSG(err != OK, "Parse source code from file '" + s->get_script_path() + "' failed.");
+	}
+}
+
+void JavaScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
+	p_extensions->push_back(EXT_JSMODULE);
+	p_extensions->push_back(EXT_JSCLASS);
+	p_extensions->push_back(EXT_JSON);
+}
+
+void JavaScriptLanguage::frame() {
+	main_binder->frame();
+}
+
+String JavaScriptLanguage::globalize_relative_path(const String &p_relative, const String &p_base_dir) {
+	String file = p_relative;
+	if (file.begins_with(".")) {
+		String base_dir = p_base_dir;
+		while (base_dir.ends_with(".")) {
+			if (base_dir.ends_with("..")) {
+				base_dir = base_dir.get_base_dir().get_base_dir();
+			} else {
+				base_dir = base_dir.get_base_dir();
+			}
+		}
+		String file_path = file;
+		while (file_path.begins_with(".")) {
+			if (file_path.begins_with("../")) {
+				base_dir = base_dir.get_base_dir();
+				file_path = file_path.substr(3);
+			} else if (file_path.begins_with("./")) {
+				file_path = file_path.substr(2);
+			} else {
+				file_path = file_path.get_basename();
+				break;
+			}
+		}
+		if (!base_dir.ends_with("/"))
+			base_dir += "/";
+		file = base_dir + file_path;
+	}
+	return file;
+}
diff --git a/javascript_language.h b/javascript_language.h
index 8e28fcd9..2721295a 100644
--- a/javascript_language.h
+++ b/javascript_language.h
@@ -1,9 +1,39 @@
-#ifndef JAVASCRIPT_LANGUAGE_H
+/**************************************************************************/
+/*  javascript_language.h                                                 */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef JAVASCRIPT_LANGUAGE_H
 #define JAVASCRIPT_LANGUAGE_H
 
 #include "core/object/script_language.h"
 #include "javascript.h"
-#include "quickjs/quickjs_binder.h"
+#include "thirdparty/quickjs/quickjs_binder.h"
 
 class CallableMiddleman : public Object {
 	GDCLASS(CallableMiddleman, Object);
@@ -45,7 +75,7 @@ class JavaScriptLanguage : public ScriptLanguage {
 	_FORCE_INLINE_ virtual String get_name() const override { return "JavaScript"; }
 	const GDExtensionInstanceBindingCallbacks *get_instance_binding_callbacks() const { return &instance_binding_callbacks; }
 #ifdef TOOLS_ENABLED
-	_FORCE_INLINE_ HashSet<Ref<JavaScript> > &get_scripts() { return scripts; }
+	_FORCE_INLINE_ HashSet<Ref<JavaScript>> &get_scripts() { return scripts; }
 #endif
 	/* LANGUAGE FUNCTIONS */
 
@@ -122,4 +152,4 @@ class JavaScriptLanguage : public ScriptLanguage {
 	virtual ~JavaScriptLanguage();
 };
 
-#endif
+#endif // JAVASCRIPT_LANGUAGE_H
diff --git a/misc/binding_script.js b/misc/binding_script.js
index ea58b032..54bead50 100644
--- a/misc/binding_script.js
+++ b/misc/binding_script.js
@@ -188,6 +188,225 @@
 // 		configurable: true
 // 	});
 
+// 		get_slot_id(emitter, signal, target) {
+// 			return `__${emitter.get_instance_id()}:${signal}:${target.get_instance_id()}__`;
+// 		}
+
+// 	const godot_node_get_node = godot.Node.prototype.get_node;
+// 	Object.defineProperty(godot.Node.prototype, 'get_node', {
+// 		value: function(arg) {
+// 			if (typeof arg === 'string') {
+// 				return godot_node_get_node.call(this, arg);
+// 			} else if (typeof arg === 'function') {
+// 				for (let n of this.get_children()) {
+// 					if (n instanceof arg) {
+// 						return n;
+// 					}
+// 				}
+// 			}
+// 			return null;
+// 		},
+// 		writable: false,
+// 		configurable: true
+// 	});
+
+// 	Object.defineProperty(godot.Node.prototype, '$', {
+// 		value: godot.Node.prototype.get_node,
+// 		writable: false,
+// 		configurable: true
+// 	});
+
+// 	const godot_vector2 = godot.Vector2;
+// 	Object.defineProperty(godot_vector2, "Axis", {
+// 		value: {
+// 			AXIS_X: 0,
+// 			AXIS_Y: 1,
+// 		},
+// 		writable: false,
+// 		configurable: false,
+// 	});
+
+// 	const godot_vector3 = godot.Vector3;
+// 	Object.defineProperty(godot_vector3, "Axis", {
+// 		value: {
+// 			AXIS_X: 0,
+// 			AXIS_Y: 1,
+// 			AXIS_Z: 2,
+// 		},
+// 		writable: false,
+// 		configurable: false,
+// 	});
+
+// 	// iterator of Pool*Vector
+// 	const pool_classes = [ godot.PackedByteArray, godot.PackedInt32Array, godot.PackedFloat32Array, godot.PackedStringArray, godot.PackedVector2Array, godot.PackedVector3Array, godot.PackedColorArray ];
+// 	for (const pool_class of pool_classes) {
+// 		Object.defineProperty(pool_class.prototype, Symbol.iterator, {value: function iterator() {
+// 			let next_index = 0;
+// 			return {
+// 				next: ()=> {
+// 					if (next_index < this.size()) {
+// 						return { value: this.get(next_index++), done: false }
+// 					} else {
+// 						return { done: true };
+// 					}
+// 				},
+// 			};
+// 		}});
+// 	}
+
+// 	return godot.TOOLS_ENABLED ? {
+// 		"removed": {
+// 			"Rect2": ["end", "grow_margin"],
+// 			"Color": ["h", "s", "v", "r8", "g8", "b8", "a8"],
+// 			"Transform2D": ["xform", "xform_inv"],
+// 			"Basis": ["is_equal_approx"],
+// 			"Plane": ["intersects_segment", "intersects_ray", "intersect_3"],
+// 			"AABB": ["end"],
+// 			"Transform": ["xform", "xform_inv"],
+// 		},
+// 		"added": {
+// 			"Object": [
+// 				"/** Connect the `method` of `target` to the `signal`*/",
+// 				"//@ts-ignore",
+// 				"connect(signal: string, target: Object, method: Function, binds: any[] = [], flags: number = 0) : number;",
+// 				"",
+// 				"/** Connect the `method` to the `signal`. The caller of the method will be `null` */",
+// 				"//@ts-ignore",
+// 				"connect(signal: string, method: Function, binds: any[] = [], flags: number = 0) : number;",
+// 				"",
+// 				"/** Returns `true` if a connection exists for a given `signal`, `target`, and `method`. */",
+// 				"is_connected(signal: string, target: Object, method: Function) : boolean;",
+// 				"/** Returns `true` if a connection exists for a given `signal` and `method`. */",
+// 				"is_connected(signal: string, method: Function) : boolean;",
+// 				"",
+// 				"/** Disconnects a `signal` from the `method` on the given `target`. */",
+// 				"disconnect(signal: string, target: Object, method: Function) : void;",
+// 				"/** Disconnects a `signal` from the `method` */",
+// 				"disconnect(signal: string, method: Function) : void;"
+// 			],
+// 			"Node": [
+// 				"/** Get first node with the class `cls` */",
+// 				"get_node<T extends godot.Node>(cls: new()=>T): T;",
+// 				"",
+// 				"/** Get node with the path */",
+// 				"$(path: string): godot.Node;",
+// 				"/** Get first node with the class `cls` */",
+// 				"$<T extends godot.Node>(cls: new()=>T): T;",
+// 			]
+// 		},
+// 	} : undefined;
+// })();
+
+// 	const godot_object_disconnect = godot.Object.prototype.disconnect;
+// 	Object.defineProperty(godot.Object.prototype, 'disconnect', {
+// 		// Object.prototype.disconnect(signal_name, target, method)
+// 		value: function disconnect(...args) {
+// 			if (args.length < 2) throw new Error('2 or more arguments expected');
+// 			let signal = args[0];
+// 			if (typeof signal !== 'string' || !signal) throw new Error('signal name expected for argument #0');
+
+// 			let target = null;
+// 			let method_name = null;
+// 			let method = null;
+// 			let slot_id = undefined;
+
+// 			if (typeof args[1] === 'function') {
+// 				target = GodotAnonymousConnectionManager;
+// 				method = args[1];
+// 			} else if (args.length >= 3) {
+// 				target = args[1] || GodotAnonymousConnectionManager;
+// 				if (!(target instanceof godot.Object)) {
+// 					new Error('godot.Object expected for signal target');
+// 				}
+// 				method = args[2];
+// 			} else {
+// 				throw new Error('method name or function expected');
+// 			}
+
+// 			if (typeof method === 'string' && method) {
+// 				method_name = method;
+// 			} else if (typeof method === 'function') {
+// 				slot_id = GodotAnonymousConnectionManager.get_slot_id(this, signal, target);
+// 				method_name = method[slot_id];
+// 				method[slot_id] = undefined;
+// 			} else {
+// 				throw new Error('method name or function expected');
+// 			}
+
+// 			if (slot_id) {
+// 				if (typeof target[method_name] !== 'undefined') {
+// 					target[method_name] = undefined;
+// 					delete target[method_name];
+// 				}
+// 				delete method[slot_id];
+// 			}
+// 			// console.log("disconnect", this, signal, target, method_name);
+// 			godot_object_disconnect.apply(this, [signal, target, method_name]);
+// 		},
+// 		writable: false,
+// 		configurable: true
+// 	});
+
+// 	const godot_object_is_connected = godot.Object.prototype.is_connected;
+// 	Object.defineProperty(godot.Object.prototype, 'is_connected', {
+// 		// Object.prototype.is_connected(signal_name, target, method)
+// 		value: function godot_is_connected_override(...args) {
+// 			if (args.length < 3) throw new Error('3 arguments expected');
+// 			let signal = args[0];
+// 			if (typeof signal !== 'string' || !signal) throw new Error('signal name expected for argument #1');
+
+// 			let target = null;
+// 			let method = null;
+// 			let method_name = null;
+// 			let slot_id = undefined;
+
+// 			if (typeof args[1] === 'function') {
+// 				target = GodotAnonymousConnectionManager;
+// 				method = args[1];
+// 			} else if (args.length >= 3) {
+// 				target = args[1] || GodotAnonymousConnectionManager;
+// 				if (!(target instanceof godot.Object)) {
+// 					new Error('godot.Object expected for signal target');
+// 				}
+// 				method = args[2];
+// 			} else {
+// 				throw new Error('method name or function expected for argument #2');
+// 			}
+
+// 			if (typeof method === 'string') {
+// 				method_name = method;
+// 			} else if (typeof method === 'function') {
+// 				slot_id = GodotAnonymousConnectionManager.get_slot_id(this, signal, target);
+// 				method_name = method[slot_id];
+// 			} else {
+// 				throw new Error('method name or function expected');
+// 			}
+
+// 			return godot_object_is_connected.apply(this, [signal, target, method_name]);
+// 		},
+// 		writable: false,
+// 		configurable: true
+// 	});
+
+// 	function godot_yield(target, signal) {
+// 		return new Promise(function(resolve, reject) {
+// 			function callback(...args) {
+// 				const slot_id = GodotAnonymousConnectionManager.get_slot_id(target, signal, GodotAnonymousConnectionManager);
+// 				const method_name = callback[slot_id];
+// 				GodotAnonymousConnectionManager[method_name] = undefined;
+// 				delete GodotAnonymousConnectionManager[method_name];
+// 				delete callback[slot_id];
+// 				resolve(args);
+// 			};
+// 			target.connect(signal, GodotAnonymousConnectionManager, callback, [], godot.Object.CONNECT_ONESHOT);
+// 		});
+// 	}
+
+// 	Object.defineProperty(godot, 'yield', {
+// 		value: godot_yield,
+// 		writable: false,
+// 		configurable: true
+// 	});
 
 // 	const godot_node_get_node = godot.Node.prototype.get_node;
 // 	Object.defineProperty(godot.Node.prototype, 'get_node', {
diff --git a/misc/decorators.ts b/misc/decorators.ts
index 6fb9ce7d..560383f9 100644
--- a/misc/decorators.ts
+++ b/misc/decorators.ts
@@ -68,7 +68,7 @@ export function onready<T extends godot.Node>(path: string | (new()=>godot.Node)
 }
 
 /**
- * Register the member as a node property  
+ * Register the member as a node property
  * **Note: The value is null before current node is ready**
  * @param path The default path name of the node
  */
diff --git a/misc/godot.d.ts b/misc/godot.d.ts
index 68d64b50..26a5326c 100644
--- a/misc/godot.d.ts
+++ b/misc/godot.d.ts
@@ -18,7 +18,7 @@ declare module globalThis {
 	 * @param request_id The ID value returned by the call to `godot.requestAnimationFrame()` that requested the callback.
 	 */
 	function cancelAnimationFrame(request_id: FrameRequetID): void;
-	
+
 	/**
 	 * The Console API provides functionality to allow developers to perform debugging tasks, such as logging messages or the values of variables at set points in your code, or timing how long an operation takes to complete.
 	 */
@@ -29,19 +29,19 @@ declare module globalThis {
 		 * @param message A list of JavaScript objects to output. The string representations of each of these objects are appended together in the order listed and output.
 		 */
 		log(...message): void;
-		
+
 		/**
 		 * Outputs a warning message to the console.
 		 * @param message  list of JavaScript objects to output. The string representations of each of these objects are appended together in the order listed and output.
 		 */
 		warn(...message): void;
-		
+
 		/**
 		 * Outputs an error message to the console.
 		 * @param message A list of JavaScript objects to output. The string representations of each of these objects are appended together in the order listed and output.
 		 */
 		error(...message): void;
-		
+
 		/** Outputs a stack trace to the console.
 		 * @param message A list of JavaScript objects to output. The string representations of each of these objects are appended together in the order listed and output.
 		*/
@@ -55,9 +55,9 @@ declare module globalThis {
 	 * A worker is an object created using a constructor of `Worker` that runs a named JavaScript file — this file contains the code that will run in the worker thread;
 	 *
 	 * Workers run in another global context that is different from the current context.
-	 * 
+	 *
 	 * You can run whatever code you like inside the worker thread. All of the godot API are avaliable inside workers.
-	 * 
+	 *
 	 * Data is sent between workers and the main thread via a system of messages — both sides send their messages using the `postMessage()` method, and respond to messages via the `onmessage` event handler (the message is contained within the Message event's data attribute.) The data is copied rather than shared.
 	 *
 	 * You can **transfer** value with `Worker.abandonValue` and `Worker.adoptValue`. After a value is abandoned you cannot using it anymore in the context.
@@ -66,67 +66,67 @@ declare module globalThis {
 	 */
 	//@ts-ignore
 	class Worker {
-		
+
 		/**
 		 * Creates a dedicated worker thread that executes the script at the specified file
 		 */
 		constructor(script: string);
-		
+
 		/**
 		 * The `onmessage` property of the Worker interface represents an event handler, that is a function to be called when the message event occurs.
 		 * It will be called when the worker's parent receives a message from the worker context by `postMessage` method.
 		 */
 		onmessage(message: any): void;
-		
+
 		/**
 		 * Sends a message to the worker's inner scope. This accepts a single parameter, which is the data to send to the worker.
 		 * @param message The object to deliver to the worker; this will be in the data field in the event delivered to the `onmessage` handler.
 		 * @note The data cannot be instance of `godot.Object` or any other JavaScript object conains functions.
 		 */
 		postMessage(message: any): void;
-		
+
 		/**
 		 * Stop the worker thread
 		 */
 		terminate(): void;
 	}
-	
+
 	/** **Worker context only**
-	 * 
+	 *
 	 *  Stop the worker thread of current context
 	 */
 	function close(): void;
-	
+
 	/** **Worker context only**
-	 * 
+	 *
 	 * The message handler to handle messages send from the host context
 	 */
 	//@ts-ignore
 	function onmessage(message: any): void;
-	
+
 	/** **Worker context only**
-	 * 
+	 *
 	 * Sends a message to the host thread context that spawned it.
 	 *
 	 * @param {*} message The message to send
 	 */
 	function postMessage(message: any): void;
-	
+
 	/** **Worker context only**
-	 * 
+	 *
 	 * Synchronously load and run one or more scripts in the worker thread.
 	 */
 	function importScripts(...scripts: string[]): void;
-	
+
 	/** **Worker context only**
-	 * 
+	 *
 	 * The flag is `true` if current context is inside a worker thread.
 	 */
 	const INSIDE_WORKER: true | undefined;
 }
 
 declare module godot {
-	
+
 	type GodotClass = new() => godot.Object;
 
 	interface PropertyInfo {
@@ -140,7 +140,7 @@ declare module godot {
 		/** Default value of the property */
 		default?: any;
 	}
-	
+
 	/**
 	 * Export class to godot
 	 *
@@ -163,77 +163,77 @@ declare module godot {
 	 * @param value The default value of the property
 	 */
 	function register_property(target: GodotClass | godot.Object, name: string, value: any);
-	
+
 	/**
 	 * The meta data of an script
 	 * @param target The script class
 	 * @param tool is tooled of this class
 	 */
 	function set_script_tooled(target: GodotClass, tool: boolean);
-	
+
 	/**
 	 * The meta data of an script
 	 * @param target The script class
 	 * @param icon The icon of the class
 	 */
 	function set_script_icon(target: GodotClass, icon: string);
-	
+
 	/**
 	 * Returns the internal type of the given `Variant` object, using the `godot.TYPE_*`
 	 */
 	function get_type(val: any): number;
-	
+
 	/**
 	 * Loads a resource from the filesystem located at `path`.
-	 * 
+	 *
 	 * **Note:** Resource paths can be obtained by right-clicking on a resource in the FileSystem dock and choosing **Copy Path**.
 	 * ```
 	 * // Load a scene called main located in the root of the project directory
 	 * const main = godot.load("res://main.tscn")
 	 * ```*/
 	function load(path: string): Resource;
-	
+
 	/**
-	 * Returns the Object that corresponds to `instance_id`. All Objects have a unique instance ID. 
+	 * Returns the Object that corresponds to `instance_id`. All Objects have a unique instance ID.
 	 */
 	function instance_from_id(instance_id: number): Object;
 
 	/**
 	 * Drop the `value` in the context. You should never touching an abandoned value anymore before it is adopted.
-	 * 
+	 *
 	 * You can adopt the value in another thread context to transfer the `value` in threads.
-	 * 
+	 *
 	 * A `non zero` ID is return if no error happen.
 	 * @param value The value to abandon in the context
 	 * @note You can only transfer values the godot `Variant` can represent.
 	 * @returns The ID of the abandoned value
 	*/
 	function abandon_value(value: any): number;
-	
+
 	/**
 	* Adopt an abandoned value.
 	* @param value_id The ID of the abandoned value
 	*/
 	function adopt_value(value_id: number): any;
-	
+
 	/**
 	 * Wait a signal of an object
 	 * @param target The owner of the signal to wait
 	 * @param signal The signal to wait
 	 */
 	function yield(target: godot.Object, signal: string): Promise<any[]>;
-	
+
 	const E: 2.7182818284590452353602874714;
 	const LN2: 0.6931471805599453094172321215;
 	const SQRT2: 1.4142135623730950488016887242;
 	const SQRT12: 0.7071067811865475244008443621048490;
-	
+
 	/** The flag is `true` if current binary is compiled with `target=debug` or `target=release_debug` */
 	const DEBUG_ENABLED: boolean;
-	
+
 	/** The flag is `true` if current binary is godot editor which is compiled with `tool=yes` */
 	const TOOLS_ENABLED: boolean;
-	
+
 	/** The flag is `true` if current binary enable debug method information */
 	const DEBUG_METHODS_ENABLED: boolean;
 }
@@ -372,36 +372,36 @@ declare module godot {
 		/** Enumerated value for the Y axis. */
 		const AXIS_Y: Axis.AXIS_Y;
 
-		/** Zero vector. 
+		/** Zero vector.
 		 * @value `Vector2( 0, 0 )` */
 		const ZERO: Readonly<Vector2>;
 
-		/** One vector. 
+		/** One vector.
 		 * @value `Vector2( 1, 1 )` */
 		const ONE: Readonly<Vector2>;
 
-		/** Infinity vector. 
+		/** Infinity vector.
 		 * @value `Vector2( inf, inf )` */
 		const INF: Readonly<Vector2>;
 
-		/** Left unit vector. 
+		/** Left unit vector.
 		 * @value `Vector2( -1, 0 )` */
 		const LEFT: Readonly<Vector2>;
 
-		/** Right unit vector. 
+		/** Right unit vector.
 		 * @value `Vector2( 1, 0 )` */
 		const RIGHT: Readonly<Vector2>;
 
-		/** Up unit vector. 
+		/** Up unit vector.
 		 * @value `Vector2( 0, -1 )` */
 		const UP: Readonly<Vector2>;
 
-		/** Down unit vector. 
+		/** Down unit vector.
 		 * @value `Vector2( 0, 1 )` */
 		const DOWN: Readonly<Vector2>;
 
 	}
-	
+
 	/** 2D axis-aligned bounding box.
 	 Rect2 consists of a position, a size, and several utility functions. It is typically used for fast overlap tests. */
 	class Rect2 {
@@ -414,7 +414,7 @@ declare module godot {
 
 		/** Size from position to end. */
 		size: Vector2;
-		
+
 		/** Ending corner. */
 		end: Vector2;
 
@@ -589,43 +589,43 @@ declare module godot {
 		const AXIS_Y: Axis.AXIS_Y;
 		const AXIS_Z: Axis.AXIS_Z;
 
-		/** Zero vector. 
+		/** Zero vector.
 		 * @value `Vector3( 0, 0, 0 )` */
 		const ZERO: Readonly<Vector3>;
 
-		/** One vector. 
+		/** One vector.
 		 * @value `Vector3( 1, 1, 1 )` */
 		const ONE: Readonly<Vector3>;
 
-		/** Infinity vector. 
+		/** Infinity vector.
 		 * @value `Vector3( inf, inf, inf )` */
 		const INF: Readonly<Vector3>;
 
-		/** Left unit vector. 
+		/** Left unit vector.
 		 * @value `Vector3( -1, 0, 0 )` */
 		const LEFT: Readonly<Vector3>;
 
-		/** Right unit vector. 
+		/** Right unit vector.
 		 * @value `Vector3( 1, 0, 0 )` */
 		const RIGHT: Readonly<Vector3>;
 
-		/** Up unit vector. 
+		/** Up unit vector.
 		 * @value `Vector3( 0, 1, 0 )` */
 		const UP: Readonly<Vector3>;
 
-		/** Down unit vector. 
+		/** Down unit vector.
 		 * @value `Vector3( 0, -1, 0 )` */
 		const DOWN: Readonly<Vector3>;
 
-		/** Forward unit vector. 
+		/** Forward unit vector.
 		 * @value `Vector3( 0, 0, -1 )` */
 		const FORWARD: Readonly<Vector3>;
 
-		/** Back unit vector. 
+		/** Back unit vector.
 		 * @value `Vector3( 0, 0, 1 )` */
 		const BACK: Readonly<Vector3>;
 	}
-	
+
 	/** 3×3 matrix datatype.
 	 3×3 matrix used for 3D rotation and scale. Contains 3 vector fields X, Y and Z as its columns, which can be interpreted as the local basis vectors of a transformation. Can also be accessed as array of 3D vectors. These vectors are orthogonal to each other, but are not necessarily normalized (due to scaling). Almost always used as an orthogonal basis for a `Transform`.
 
@@ -717,7 +717,7 @@ declare module godot {
 		/** @value `Basis( 1, 0, 0, 0, 1, 0, 0, 0, -1 )` */
 		const FLIP_Z: Readonly<Basis>;
 	}
-	
+
 	/** 3D transformation (3×4 matrix).
 	 Represents one or many transformations in 3D space such as translation, rotation, or scaling. It consists of a `basis` and an `origin`. It is similar to a 3×4 matrix. */
 	class Transform {
@@ -774,19 +774,19 @@ declare module godot {
 	}
 
 	namespace Transform {
-		/** `Transform` with no translation, rotation or scaling applied. When applied to other data structures, `IDENTITY` performs no transformation. 
+		/** `Transform` with no translation, rotation or scaling applied. When applied to other data structures, `IDENTITY` performs no transformation.
 		 * @value `Transform( 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 )` */
 		const IDENTITY: Readonly<Transform>;
 
-		/** `Transform` with mirroring applied perpendicular to the YZ plane. 
+		/** `Transform` with mirroring applied perpendicular to the YZ plane.
 		 * @value `Transform( -1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0 )` */
 		const FLIP_X: Readonly<Transform>;
 
-		/** `Transform` with mirroring applied perpendicular to the XZ plane. 
+		/** `Transform` with mirroring applied perpendicular to the XZ plane.
 		 * @value `Transform( 1, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0 )` */
 		const FLIP_Y: Readonly<Transform>;
 
-		/** `Transform` with mirroring applied perpendicular to the XY plane. 
+		/** `Transform` with mirroring applied perpendicular to the XY plane.
 		 * @value `Transform( 1, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 0 )` */
 		const FLIP_Z: Readonly<Transform>;
 	}
@@ -858,19 +858,19 @@ declare module godot {
 	}
 
 	namespace Transform2D {
-		/** `Transform2D` with no translation, rotation or scaling applied. When applied to other data structures, `IDENTITY` performs no transformation. 
+		/** `Transform2D` with no translation, rotation or scaling applied. When applied to other data structures, `IDENTITY` performs no transformation.
 		 * @value `Transform2D( 1, 0, 0, 1, 0, 0 )` */
 		const IDENTITY: Readonly<Transform2D>;
 
-		/** `Transform2D` with mirroring applied parallel to the X axis. 
+		/** `Transform2D` with mirroring applied parallel to the X axis.
 		 * @value `Transform2D( -1, 0, 0, 1, 0, 0 )` */
 		const FLIP_X: Readonly<Transform2D>;
 
-		/** `Transform2D` with mirroring applied parallel to the Y axis. 
+		/** `Transform2D` with mirroring applied parallel to the Y axis.
 		 * @value `Transform2D( 1, 0, 0, -1, 0, 0 )` */
 		const FLIP_Y: Readonly<Transform2D>;
 	}
-	
+
 	/** Color in RGBA format with some support for ARGB format.
 	 A color is represented by red, green, and blue `(r, g, b)` components. Additionally, `a` represents the alpha component, often used for transparency. Values are in floating-point and usually range from 0 to 1. Some properties (such as `CanvasItem.modulate`) may accept values greater than 1.
 
@@ -917,7 +917,7 @@ declare module godot {
 
 		/** Returns a new color resulting from blending this color over another. If the color is opaque, the result is also opaque. The second color may have a range of alpha values.
 
-		 
+
 
 		 	var bg = Color(0.0, 1.0, 0.0, 0.5) # Green with alpha of 50%
 		 	var fg = Color(1.0, 0.0, 0.0, 0.5) # Red with alpha of 50%
@@ -927,7 +927,7 @@ declare module godot {
 
 		/** Returns the most contrasting color.
 
-		 
+
 
 		 	var c = Color(0.3, 0.4, 0.9)
 		 	var contrasted_color = c.contrasted() # Equivalent to RGBA(204, 229, 102, 255)
@@ -936,7 +936,7 @@ declare module godot {
 
 		/** Returns a new color resulting from making this color darker by the specified percentage (ratio from 0 to 1).
 
-		 
+
 
 		 	var green = Color(0.0, 1.0, 0.0)
 		 	var darkgreen = green.darkened(0.2) # 20% darker than regular green
@@ -945,7 +945,7 @@ declare module godot {
 
 		/** Constructs a color from an HSV profile. `h`, `s`, and `v` are values between 0 and 1.
 
-		 
+
 
 		 	var c = Color.from_hsv(0.58, 0.5, 0.79, 0.8) # Equivalent to HSV(210, 50, 79, 0.8) or Color8(100, 151, 201, 0.8)
 		  */
@@ -955,7 +955,7 @@ declare module godot {
 
 		 The gray value is calculated as `(r + g + b) / 3`.
 
-		 
+
 
 		 	var c = Color(0.2, 0.45, 0.82)
 		 	var gray = c.gray() # A value of 0.466667
@@ -964,7 +964,7 @@ declare module godot {
 
 		/** Returns the inverted color `(1 - r, 1 - g, 1 - b, a)`.
 
-		 
+
 
 		 	var c = Color(0.3, 0.4, 0.9)
 		 	var inverted_color = c.inverted() # A color of an RGBA(178, 153, 26, 255)
@@ -976,7 +976,7 @@ declare module godot {
 
 		/** Returns a new color resulting from making this color lighter by the specified percentage (ratio from 0 to 1).
 
-		 
+
 
 		 	var green = Color(0.0, 1.0, 0.0)
 		 	var lightgreen = green.lightened(0.2) # 20% lighter than regular green
@@ -985,7 +985,7 @@ declare module godot {
 
 		/** Returns the linear interpolation with another color. The interpolation factor `t` is between 0 and 1.
 
-		 
+
 
 		 	var c1 = Color(1.0, 0.0, 0.0)
 		 	var c2 = Color(0.0, 1.0, 0.0)
@@ -995,7 +995,7 @@ declare module godot {
 
 		/** Returns the color's 32-bit integer in ABGR format (each byte represents a component of the ABGR profile). ABGR is the reversed version of the default format.
 
-		 
+
 
 		 	var c = Color(1, 0.5, 0.2)
 		 	print(c.to_abgr32()) # Prints 4281565439
@@ -1004,7 +1004,7 @@ declare module godot {
 
 		/** Returns the color's 64-bit integer in ABGR format (each word represents a component of the ABGR profile). ABGR is the reversed version of the default format.
 
-		 
+
 
 		 	var c = Color(1, 0.5, 0.2)
 		 	print(c.to_abgr64()) # Prints -225178692812801
@@ -1013,7 +1013,7 @@ declare module godot {
 
 		/** Returns the color's 32-bit integer in ARGB format (each byte represents a component of the ARGB profile). ARGB is more compatible with DirectX.
 
-		 
+
 
 		 	var c = Color(1, 0.5, 0.2)
 		 	print(c.to_argb32()) # Prints 4294934323
@@ -1022,7 +1022,7 @@ declare module godot {
 
 		/** Returns the color's 64-bit integer in ARGB format (each word represents a component of the ARGB profile). ARGB is more compatible with DirectX.
 
-		 
+
 
 		 	var c = Color(1, 0.5, 0.2)
 		 	print(c.to_argb64()) # Prints -2147470541
@@ -1033,7 +1033,7 @@ declare module godot {
 
 		 Setting `with_alpha` to `false` excludes alpha from the hexadecimal string.
 
-		 
+
 
 		 	var c = Color(1, 1, 1, 0.5)
 		 	var s1 = c.to_html() # Returns "7fffffff"
@@ -1043,7 +1043,7 @@ declare module godot {
 
 		/** Returns the color's 32-bit integer in RGBA format (each byte represents a component of the RGBA profile). RGBA is Godot's default format.
 
-		 
+
 
 		 	var c = Color(1, 0.5, 0.2)
 		 	print(c.to_rgba32()) # Prints 4286526463
@@ -1052,7 +1052,7 @@ declare module godot {
 
 		/** Returns the color's 64-bit integer in RGBA format (each word represents a component of the RGBA profile). RGBA is Godot's default format.
 
-		 
+
 
 		 	var c = Color(1, 0.5, 0.2)
 		 	print(c.to_rgba64()) # Prints -140736629309441
@@ -1062,598 +1062,598 @@ declare module godot {
 	}
 
 	namespace Color {
-		/**  
+		/**
 		 * @value `Color( 0.75, 0.75, 0.75, 1 )` */
 		const gray: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.94, 0.97, 1, 1 )` */
 		const aliceblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.98, 0.92, 0.84, 1 )` */
 		const antiquewhite: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 1, 1, 1 )` */
 		const aqua: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.5, 1, 0.83, 1 )` */
 		const aquamarine: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.94, 1, 1, 1 )` */
 		const azure: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.96, 0.96, 0.86, 1 )` */
 		const beige: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.89, 0.77, 1 )` */
 		const bisque: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 0, 0, 1 )` */
 		const black: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.92, 0.8, 1 )` */
 		const blanchedalmond: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 0, 1, 1 )` */
 		const blue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.54, 0.17, 0.89, 1 )` */
 		const blueviolet: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.65, 0.16, 0.16, 1 )` */
 		const brown: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.87, 0.72, 0.53, 1 )` */
 		const burlywood: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.37, 0.62, 0.63, 1 )` */
 		const cadetblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.5, 1, 0, 1 )` */
 		const chartreuse: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.82, 0.41, 0.12, 1 )` */
 		const chocolate: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.5, 0.31, 1 )` */
 		const coral: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.39, 0.58, 0.93, 1 )` */
 		const cornflower: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.97, 0.86, 1 )` */
 		const cornsilk: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.86, 0.08, 0.24, 1 )` */
 		const crimson: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 1, 1, 1 )` */
 		const cyan: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 0, 0.55, 1 )` */
 		const darkblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 0.55, 0.55, 1 )` */
 		const darkcyan: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.72, 0.53, 0.04, 1 )` */
 		const darkgoldenrod: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.66, 0.66, 0.66, 1 )` */
 		const darkgray: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 0.39, 0, 1 )` */
 		const darkgreen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.74, 0.72, 0.42, 1 )` */
 		const darkkhaki: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.55, 0, 0.55, 1 )` */
 		const darkmagenta: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.33, 0.42, 0.18, 1 )` */
 		const darkolivegreen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.55, 0, 1 )` */
 		const darkorange: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.6, 0.2, 0.8, 1 )` */
 		const darkorchid: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.55, 0, 0, 1 )` */
 		const darkred: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.91, 0.59, 0.48, 1 )` */
 		const darksalmon: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.56, 0.74, 0.56, 1 )` */
 		const darkseagreen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.28, 0.24, 0.55, 1 )` */
 		const darkslateblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.18, 0.31, 0.31, 1 )` */
 		const darkslategray: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 0.81, 0.82, 1 )` */
 		const darkturquoise: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.58, 0, 0.83, 1 )` */
 		const darkviolet: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.08, 0.58, 1 )` */
 		const deeppink: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 0.75, 1, 1 )` */
 		const deepskyblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.41, 0.41, 0.41, 1 )` */
 		const dimgray: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.12, 0.56, 1, 1 )` */
 		const dodgerblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.7, 0.13, 0.13, 1 )` */
 		const firebrick: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.98, 0.94, 1 )` */
 		const floralwhite: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.13, 0.55, 0.13, 1 )` */
 		const forestgreen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0, 1, 1 )` */
 		const fuchsia: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.86, 0.86, 0.86, 1 )` */
 		const gainsboro: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.97, 0.97, 1, 1 )` */
 		const ghostwhite: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.84, 0, 1 )` */
 		const gold: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.85, 0.65, 0.13, 1 )` */
 		const goldenrod: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 1, 0, 1 )` */
 		const green: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.68, 1, 0.18, 1 )` */
 		const greenyellow: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.94, 1, 0.94, 1 )` */
 		const honeydew: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.41, 0.71, 1 )` */
 		const hotpink: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.8, 0.36, 0.36, 1 )` */
 		const indianred: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.29, 0, 0.51, 1 )` */
 		const indigo: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 1, 0.94, 1 )` */
 		const ivory: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.94, 0.9, 0.55, 1 )` */
 		const khaki: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.9, 0.9, 0.98, 1 )` */
 		const lavender: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.94, 0.96, 1 )` */
 		const lavenderblush: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.49, 0.99, 0, 1 )` */
 		const lawngreen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.98, 0.8, 1 )` */
 		const lemonchiffon: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.68, 0.85, 0.9, 1 )` */
 		const lightblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.94, 0.5, 0.5, 1 )` */
 		const lightcoral: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.88, 1, 1, 1 )` */
 		const lightcyan: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.98, 0.98, 0.82, 1 )` */
 		const lightgoldenrod: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.83, 0.83, 0.83, 1 )` */
 		const lightgray: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.56, 0.93, 0.56, 1 )` */
 		const lightgreen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.71, 0.76, 1 )` */
 		const lightpink: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.63, 0.48, 1 )` */
 		const lightsalmon: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.13, 0.7, 0.67, 1 )` */
 		const lightseagreen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.53, 0.81, 0.98, 1 )` */
 		const lightskyblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.47, 0.53, 0.6, 1 )` */
 		const lightslategray: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.69, 0.77, 0.87, 1 )` */
 		const lightsteelblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 1, 0.88, 1 )` */
 		const lightyellow: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 1, 0, 1 )` */
 		const lime: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.2, 0.8, 0.2, 1 )` */
 		const limegreen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.98, 0.94, 0.9, 1 )` */
 		const linen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0, 1, 1 )` */
 		const magenta: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.69, 0.19, 0.38, 1 )` */
 		const maroon: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.4, 0.8, 0.67, 1 )` */
 		const mediumaquamarine: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 0, 0.8, 1 )` */
 		const mediumblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.73, 0.33, 0.83, 1 )` */
 		const mediumorchid: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.58, 0.44, 0.86, 1 )` */
 		const mediumpurple: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.24, 0.7, 0.44, 1 )` */
 		const mediumseagreen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.48, 0.41, 0.93, 1 )` */
 		const mediumslateblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 0.98, 0.6, 1 )` */
 		const mediumspringgreen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.28, 0.82, 0.8, 1 )` */
 		const mediumturquoise: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.78, 0.08, 0.52, 1 )` */
 		const mediumvioletred: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.1, 0.1, 0.44, 1 )` */
 		const midnightblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.96, 1, 0.98, 1 )` */
 		const mintcream: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.89, 0.88, 1 )` */
 		const mistyrose: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.89, 0.71, 1 )` */
 		const moccasin: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.87, 0.68, 1 )` */
 		const navajowhite: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 0, 0.5, 1 )` */
 		const navyblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.99, 0.96, 0.9, 1 )` */
 		const oldlace: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.5, 0.5, 0, 1 )` */
 		const olive: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.42, 0.56, 0.14, 1 )` */
 		const olivedrab: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.65, 0, 1 )` */
 		const orange: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.27, 0, 1 )` */
 		const orangered: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.85, 0.44, 0.84, 1 )` */
 		const orchid: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.93, 0.91, 0.67, 1 )` */
 		const palegoldenrod: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.6, 0.98, 0.6, 1 )` */
 		const palegreen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.69, 0.93, 0.93, 1 )` */
 		const paleturquoise: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.86, 0.44, 0.58, 1 )` */
 		const palevioletred: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.94, 0.84, 1 )` */
 		const papayawhip: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.85, 0.73, 1 )` */
 		const peachpuff: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.8, 0.52, 0.25, 1 )` */
 		const peru: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.75, 0.8, 1 )` */
 		const pink: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.87, 0.63, 0.87, 1 )` */
 		const plum: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.69, 0.88, 0.9, 1 )` */
 		const powderblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.63, 0.13, 0.94, 1 )` */
 		const purple: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.4, 0.2, 0.6, 1 )` */
 		const rebeccapurple: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0, 0, 1 )` */
 		const red: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.74, 0.56, 0.56, 1 )` */
 		const rosybrown: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.25, 0.41, 0.88, 1 )` */
 		const royalblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.55, 0.27, 0.07, 1 )` */
 		const saddlebrown: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.98, 0.5, 0.45, 1 )` */
 		const salmon: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.96, 0.64, 0.38, 1 )` */
 		const sandybrown: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.18, 0.55, 0.34, 1 )` */
 		const seagreen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.96, 0.93, 1 )` */
 		const seashell: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.63, 0.32, 0.18, 1 )` */
 		const sienna: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.75, 0.75, 0.75, 1 )` */
 		const silver: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.53, 0.81, 0.92, 1 )` */
 		const skyblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.42, 0.35, 0.8, 1 )` */
 		const slateblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.44, 0.5, 0.56, 1 )` */
 		const slategray: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.98, 0.98, 1 )` */
 		const snow: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 1, 0.5, 1 )` */
 		const springgreen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.27, 0.51, 0.71, 1 )` */
 		const steelblue: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.82, 0.71, 0.55, 1 )` */
 		const tan: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 0.5, 0.5, 1 )` */
 		const teal: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.85, 0.75, 0.85, 1 )` */
 		const thistle: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 0.39, 0.28, 1 )` */
 		const tomato: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 1, 1, 0 )` */
 		const transparent: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.25, 0.88, 0.82, 1 )` */
 		const turquoise: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.93, 0.51, 0.93, 1 )` */
 		const violet: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.5, 0.5, 0.5, 1 )` */
 		const webgray: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0, 0.5, 0, 1 )` */
 		const webgreen: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.5, 0, 0, 1 )` */
 		const webmaroon: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.5, 0, 0.5, 1 )` */
 		const webpurple: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.96, 0.87, 0.7, 1 )` */
 		const wheat: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 1, 1, 1 )` */
 		const white: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.96, 0.96, 0.96, 1 )` */
 		const whitesmoke: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 1, 1, 0, 1 )` */
 		const yellow: Readonly<Color>
 
-		/**  
+		/**
 		 * @value `Color( 0.6, 0.8, 0.2, 1 )` */
 		const yellowgreen: Readonly<Color>
 	}
-	
+
 	/** Handle for a `Resource`'s unique ID.
 	 The RID type is used to access the unique integer ID of a resource. They are opaque, which means they do not grant access to the associated resource by themselves. They are used by and with the low-level Server classes such as `VisualServer`. */
 	class RID {
 		/** Returns the ID of the referenced resource. */
 		get_id() : number;
 	}
-	
+
 	/** Plane in hessian form.
 	 Plane represents a normalized plane equation. Basically, "normal" is the normal of the plane (a,b,c normalized), and "d" is the distance from the origin to the plane (in the direction of "normal"). "Over" or "Above" the plane is considered the side of the plane towards where the normal is pointing. */
 	class Plane {
@@ -1724,7 +1724,7 @@ declare module godot {
 		/** @value `Plane( 0, 0, 1, 0 )` */
 		const PLANE_XY: Plane;
 	}
-	
+
 	/** Quaternion.
 	 A unit quaternion used for representing 3D rotations.
 
@@ -1799,7 +1799,7 @@ declare module godot {
 		/** @value `Quaternion( 0, 0, 0, 1 )` */
 		const IDENTITY: Readonly<Quaternion>;
 	}
-	
+
 	/** Axis-Aligned Bounding Box.
 	 AABB consists of a position, a size, and several utility functions. It is typically used for fast overlap tests. */
 	class AABB {
@@ -1880,20 +1880,20 @@ declare module godot {
 		merge(p_with: AABB) : AABB;
 
 	}
-	
-	
+
+
 	/** A pooled `Array` of bytes.
 	 An `Array` specifically designed to hold bytes. Optimized for memory usage, does not fragment the memory.
 
 	 **Note:** This type is passed by value and not by reference. */
 	class PackedByteArray {
-		
+
 		constructor(source?: number[]);
 		constructor(from: PackedByteArray);
 		constructor(from: ArrayBuffer);
 		constructor(from: DataView);
 		[Symbol.iterator](): IterableIterator<number>;
-		
+
 		/** Appends an element at the end of the array (alias of `push_back`). */
 		append(byte: number) : void;
 
@@ -1935,7 +1935,7 @@ declare module godot {
 
 		/** Changes the byte at the given index. */
 		set(idx: number, byte: number) : void;
-		
+
 		/** Get the `byte` at the given index */
 		get(idx: number): number;
 
@@ -1944,7 +1944,7 @@ declare module godot {
 
 		/** Returns the slice of the `PackedByteArray` between indices (inclusive) as a new `PackedByteArray`. Any negative index is considered to be from the end of the array. */
 		subarray(p_from: number, to: number) : PackedByteArray;
-		
+
 		/** Returns the content of the array as an `ArrayBuffer` */
 		get_buffer() : ArrayBuffer;
 	}
@@ -1988,7 +1988,7 @@ declare module godot {
 
 		/** Changes the `Color` at the given index. */
 		set(idx: number, color: Color) : void;
-		
+
 		/** Get the `Color` at the given index */
 		get(idx: number): Color;
 
@@ -2040,7 +2040,7 @@ declare module godot {
 
 		/** Changes the int at the given index. */
 		set(idx: number, integer: number) : void;
-		
+
 		/** Get the `int` at the given index */
 		get(idx: number): number;
 
@@ -2089,7 +2089,7 @@ declare module godot {
 
 		/** Changes the float at the given index. */
 		set(idx: number, value: number) : void;
-		
+
 		/** Get the `number` at the given index */
 		get(idx: number): number;
 
@@ -2140,7 +2140,7 @@ declare module godot {
 
 		/** Changes the `String` at the given index. */
 		set(idx: number, p_string: string) : void;
-		
+
 		/** Get the `string` at the given index */
 		get(idx: number): string;
 
@@ -2186,13 +2186,13 @@ declare module godot {
 
 		/** Changes the `Vector2` at the given index. */
 		set(idx: number, vector2: Vector2) : void;
-		
+
 		/** Get the `Vector2` at the given index */
 		get(idx: number): Vector2;
 
 		/** Returns the size of the array. */
 		size() : number;
-		
+
 		/** Returns the content of the array as an `ArrayBuffer` */
 		get_buffer() : ArrayBuffer;
 	}
@@ -2235,13 +2235,13 @@ declare module godot {
 
 		/** Changes the `Vector3` at the given index. */
 		set(idx: number, vector3: Vector3) : void;
-		
+
 		/** Get the `Vector3` at the given index */
 		get(idx: number): Vector3;
 
 		/** Returns the size of the array. */
 		size() : number;
-		
+
 		/** Returns the content of the array as an `ArrayBuffer` */
 		get_buffer() : ArrayBuffer;
 	}
diff --git a/quickjs/quickjs_binder.cpp b/quickjs/quickjs_binder.cpp
deleted file mode 100644
index 7af69266..00000000
--- a/quickjs/quickjs_binder.cpp
+++ /dev/null
@@ -1,2362 +0,0 @@
-#include "quickjs_binder.h"
-#include "../javascript.h"
-#include "../javascript_instance.h"
-#include "../javascript_language.h"
-#include "core/config/engine.h"
-#include "core/config/project_settings.h"
-#include "core/core_bind.h"
-#include "core/core_constants.h"
-#include "core/io/file_access.h"
-#include "core/io/json.h"
-#include "core/math/expression.h"
-#include "core/os/os.h"
-#include "quickjs_binder.h"
-#include "quickjs_worker.h"
-#ifdef TOOLS_ENABLED
-#include "editor/editor_settings.h"
-#endif
-#include "quickjs_callable.h"
-#include <cstring>
-
-SafeNumeric<uint32_t> QuickJSBinder::global_context_id;
-SafeNumeric<uint64_t> QuickJSBinder::global_transfer_id;
-
-HashMap<uint64_t, Variant> QuickJSBinder::transfer_deopot;
-HashMap<String, const char *> QuickJSBinder::class_remap;
-List<String> compiling_modules;
-
-struct GodotMethodArguments {
-	Variant *arguments;
-	const Variant **ptr;
-	GodotMethodArguments(int argc) {
-		if (argc) {
-			arguments = memnew_arr(Variant, argc);
-			ptr = memnew_arr(const Variant *, argc);
-			for (int i = 0; i < argc; i++) {
-				ptr[i] = &arguments[i];
-			}
-		} else {
-			arguments = NULL;
-			ptr = NULL;
-		}
-	}
-	~GodotMethodArguments() {
-		if (ptr)
-			memdelete_arr(ptr);
-		if (arguments)
-			memdelete_arr(arguments);
-	}
-};
-
-_FORCE_INLINE_ static JavaScriptGCHandler *BINDING_DATA_FROM_GD(Object *p_object) {
-	ERR_FAIL_COND_V(p_object == NULL, NULL);
-	JavaScriptLanguage *lang = JavaScriptLanguage::get_singleton();
-	JavaScriptGCHandler *bind = (JavaScriptGCHandler *)(p_object)->get_instance_binding(lang, lang->get_instance_binding_callbacks());
-	return bind;
-}
-
-_FORCE_INLINE_ static JavaScriptGCHandler *BINDING_DATA_FROM_GD(JSContext *ctx, Object *p_object) {
-	ERR_FAIL_COND_V(p_object == NULL || ctx == NULL, NULL);
-	JavaScriptGCHandler *bind = BINDING_DATA_FROM_GD(p_object);
-	if (bind) {
-		if (bind->context && bind->context != ctx) {
-			ERR_FAIL_V_MSG(NULL, "The object is not belong to this context");
-		}
-		if (!bind->context) {
-			QuickJSBinder::bind_gc_object(ctx, bind, p_object);
-		}
-	}
-	return bind;
-}
-
-JSValue QuickJSBinder::console_functions(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic) {
-	PackedStringArray args;
-	args.resize(argc);
-
-	QuickJSBinder *binder = get_context_binder(ctx);
-	JSValue object_to_json = JS_GetPropertyStr(ctx, binder->console_object, PROP_NAME_CONSOLE_LOG_OBJECT_TO_JSON);
-	bool to_json = js_to_bool(ctx, object_to_json);
-	JS_FreeValue(ctx, object_to_json);
-
-	for (int i = 0; i < argc; ++i) {
-		int32_t tag = JS_VALUE_GET_TAG(argv[i]);
-		if (to_json && tag == JS_TAG_OBJECT && NULL == BINDING_DATA_FROM_JS(ctx, argv[i])) {
-			JSValue str = JS_JSONStringify(ctx, argv[i], JS_UNDEFINED, JS_UNDEFINED);
-			args.write[i] = js_to_string(ctx, str);
-			JS_FreeValue(ctx, str);
-		} else {
-			size_t size;
-			const char *utf8 = JS_ToCStringLen(ctx, &size, argv[i]);
-			args.write[i].parse_utf8(utf8, size);
-			JS_FreeCString(ctx, utf8);
-		}
-	}
-
-	JavaScriptStackInfo stack_top;
-	List<JavaScriptStackInfo> stacks;
-	String message = "";
-	for (int i = 0; i < argc; ++i) {
-		message += args[i];
-		if (i < argc - 1) {
-			message += " ";
-		}
-	}
-
-	if (magic == CONSOLE_ERROR || magic == CONSOLE_TRACE || magic == CONSOLE_WARN) {
-		if (binder->get_stacks(stacks) == OK) {
-			stack_top = stacks.front()->get();
-			message += ENDL;
-			message += binder->get_backtrace_message(stacks);
-		}
-	}
-
-	switch (magic) {
-		case CONSOLE_ERROR:
-			_err_print_error(stack_top.function.utf8().get_data(), stack_top.file.utf8().get_data(), stack_top.line, message, ErrorHandlerType::ERR_HANDLER_ERROR);
-			break;
-		case CONSOLE_WARN:
-			_err_print_error(stack_top.function.utf8().get_data(), stack_top.file.utf8().get_data(), stack_top.line, message, ErrorHandlerType::ERR_HANDLER_WARNING);
-			break;
-		case CONSOLE_LOG:
-		case CONSOLE_TRACE:
-		default:
-			print_line(message);
-			break;
-	}
-	return JS_UNDEFINED;
-}
-
-void QuickJSBinder::add_global_console() {
-	JSValue console = JS_NewObject(ctx);
-	JSValue log = JS_NewCFunctionMagic(ctx, console_functions, "log", 0, JS_CFUNC_generic_magic, CONSOLE_LOG);
-	JSValue warn = JS_NewCFunctionMagic(ctx, console_functions, "warn", 0, JS_CFUNC_generic_magic, CONSOLE_WARN);
-	JSValue err = JS_NewCFunctionMagic(ctx, console_functions, "error", 0, JS_CFUNC_generic_magic, CONSOLE_ERROR);
-	JSValue trace = JS_NewCFunctionMagic(ctx, console_functions, "trace", 0, JS_CFUNC_generic_magic, CONSOLE_TRACE);
-	JS_DefinePropertyValueStr(ctx, global_object, "console", console, PROP_DEF_DEFAULT);
-	JS_DefinePropertyValueStr(ctx, console, "log", log, PROP_DEF_DEFAULT);
-	JS_DefinePropertyValueStr(ctx, console, "warn", warn, PROP_DEF_DEFAULT);
-	JS_DefinePropertyValueStr(ctx, console, "error", err, PROP_DEF_DEFAULT);
-	JS_DefinePropertyValueStr(ctx, console, "trace", trace, PROP_DEF_DEFAULT);
-	console_object = JS_DupValue(ctx, console);
-}
-
-void QuickJSBinder::add_global_properties() {
-	// globalThis.requestAnimationFrame
-	JSValue js_func_requestAnimationFrame = JS_NewCFunction(ctx, global_request_animation_frame, "requestAnimationFrame", 1);
-	JS_DefinePropertyValueStr(ctx, global_object, "requestAnimationFrame", js_func_requestAnimationFrame, PROP_DEF_DEFAULT);
-	// globalThis.cancelAnimationFrame
-	JSValue js_func_cancelAnimationFrame = JS_NewCFunction(ctx, global_cancel_animation_frame, "cancelAnimationFrame", 1);
-	JS_DefinePropertyValueStr(ctx, global_object, "cancelAnimationFrame", js_func_cancelAnimationFrame, PROP_DEF_DEFAULT);
-}
-
-JSValue QuickJSBinder::object_method(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int method_id) {
-	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-	ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "Call native method without native binding data"));
-	ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "Call native method without native object caller"));
-
-	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
-	Object *obj = bind->get_godot_object();
-	MethodBind *mb = binder->godot_methods[method_id];
-
-	if (!mb->is_vararg()) {
-		argc = MIN(argc, mb->get_argument_count());
-	}
-
-	GodotMethodArguments args(argc);
-	for (int i = 0; i < argc; ++i) {
-		args.arguments[i] = var_to_variant(ctx, argv[i]);
-	}
-
-	Callable::CallError call_err;
-	Variant ret_val = mb->call(obj, args.ptr, argc, call_err);
-	JSValue ret = variant_to_var(ctx, ret_val);
-#ifdef DEBUG_METHODS_ENABLED
-	String err_message;
-	switch (call_err.error) {
-		case Callable::CallError::CALL_ERROR_INVALID_ARGUMENT:
-			err_message = vformat("Argument of type '%s' is not assignable to parameter #%d of type '%s'", Variant::get_type_name(args.arguments[call_err.argument].get_type()), call_err.argument, Variant::get_type_name((Variant::Type)call_err.expected));
-			break;
-		case Callable::CallError::CALL_ERROR_INVALID_METHOD:
-			err_message = vformat("Invalid method '%s' for type '%s'", mb->get_name(), obj->get_class_name());
-			break;
-		case Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
-			err_message = vformat("Too few arguments for method '%s'", mb->get_name());
-			break;
-		case Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:
-			err_message = vformat("Too many arguments for method '%s'", mb->get_name());
-			break;
-		case Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL:
-			err_message = vformat("Attempt to call '%s' on a null instance.", mb->get_name());
-			break;
-		default:
-			break;
-	}
-	if (call_err.error != Callable::CallError::CALL_OK) {
-		List<JavaScriptStackInfo> stacks;
-		String stack_message;
-		if (binder->get_stacks(stacks) == OK) {
-			stack_message = binder->get_backtrace_message(stacks);
-		}
-		ERR_PRINT(obj->get_class() + "." + mb->get_name() + ENDL + err_message + ENDL + stack_message);
-		JS_FreeValue(ctx, ret);
-		ret = JS_ThrowTypeError(ctx, "%s", err_message.utf8().get_data());
-	}
-#endif
-
-	return ret;
-}
-
-JSValue QuickJSBinder::object_indexed_property(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int property_id) {
-	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-	ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "Using indexed property without native binding data"));
-	ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "Using indexed property without native object caller"));
-
-	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
-	bool is_setter = argc > 0;
-
-	Object *obj = bind->get_godot_object();
-	const ClassDB::PropertySetGet *prop = binder->godot_object_indexed_properties[property_id];
-	MethodBind *mb = is_setter ? prop->_setptr : prop->_getptr;
-
-	GodotMethodArguments args(2);
-	args.arguments[0] = prop->index;
-	if (is_setter) {
-		args.arguments[1] = var_to_variant(ctx, argv[0]);
-	}
-
-	Callable::CallError call_err;
-	Variant ret_val = mb->call(obj, args.ptr, argc + 1, call_err);
-	return variant_to_var(ctx, ret_val);
-}
-
-JSValue QuickJSBinder::variant_to_var(JSContext *ctx, const Variant p_var) {
-	switch (p_var.get_type()) {
-		case Variant::BOOL:
-			return ((bool)p_var) ? JS_TRUE : JS_FALSE;
-		case Variant::INT:
-			return JS_NewInt64(ctx, int64_t(p_var));
-		case Variant::FLOAT:
-			return JS_NewFloat64(ctx, (double)(p_var));
-		case Variant::NODE_PATH:
-		case Variant::STRING:
-			return to_js_string(ctx, p_var);
-		case Variant::OBJECT: {
-			Object *obj = p_var;
-			if (obj == NULL)
-				return JS_NULL;
-			JavaScriptGCHandler *data = BINDING_DATA_FROM_GD(ctx, obj);
-			ERR_FAIL_NULL_V(data, JS_UNDEFINED);
-			ERR_FAIL_NULL_V(data->javascript_object, JS_UNDEFINED);
-			ERR_FAIL_COND_V(data->context != ctx, (JS_UNDEFINED));
-			JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, data->javascript_object);
-			JS_DupValue(ctx, js_obj);
-
-			return js_obj;
-		}
-		case Variant::ARRAY: {
-			Array arr = p_var;
-			JSValue js_arr = JS_NewArray(ctx);
-			for (int i = 0; i < arr.size(); i++) {
-				JS_SetPropertyUint32(ctx, js_arr, i, variant_to_var(ctx, arr[int(i)]));
-			}
-			return js_arr;
-		}
-		case Variant::DICTIONARY: {
-			Dictionary dict = p_var;
-			JSValue obj = JS_NewObject(ctx);
-			Array keys = dict.keys();
-			for (int i = 0; i < keys.size(); i++) {
-				const Variant &key = keys[i];
-				const Variant &value = dict[key];
-				String key_str = keys[i];
-				JS_SetPropertyStr(ctx, obj, key_str.utf8().get_data(), variant_to_var(ctx, value));
-			}
-			return obj;
-		}
-		case Variant::NIL:
-			return JS_NULL;
-		default:
-			return QuickJSBuiltinBinder::new_object_from(ctx, p_var);
-	}
-}
-
-Variant QuickJSBinder::var_to_variant(JSContext *ctx, JSValue p_val) {
-	int64_t tag = JS_VALUE_GET_TAG(p_val);
-	switch (tag) {
-		case JS_TAG_INT:
-			return Variant(JS_VALUE_GET_INT(p_val));
-		case JS_TAG_BOOL:
-			return Variant(bool(JS_VALUE_GET_INT(p_val)));
-		case JS_TAG_FLOAT64:
-			return Variant(real_t(JS_VALUE_GET_FLOAT64(p_val)));
-		case JS_TAG_STRING:
-			return js_to_string(ctx, p_val);
-		case JS_TAG_OBJECT: {
-			if (JS_VALUE_GET_PTR(p_val) == NULL) {
-				return Variant();
-			}
-			int length = get_js_array_length(ctx, p_val);
-			if (length != -1) { // Array
-				Array arr;
-				arr.resize(length);
-				for (int i = 0; i < length; i++) {
-					JSValue val = JS_GetPropertyUint32(ctx, p_val, i);
-					arr[int(i)] = var_to_variant(ctx, val);
-					JS_FreeValue(ctx, val);
-				}
-				return arr;
-			} else if (JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, p_val)) { // Binding object
-				ERR_FAIL_NULL_V(bind, Variant());
-				ERR_FAIL_NULL_V(bind->godot_object, Variant());
-				return bind->get_value();
-			} else if (JS_IsFunction(ctx, p_val)) {
-				JSValue name = JS_GetProperty(ctx, p_val, JS_ATOM_name);
-				String ret = vformat("function %s() { ... }", js_to_string(ctx, name));
-				JS_FreeValue(ctx, name);
-				return ret;
-			} else { // Plain Object as Dictionary
-				List<void *> stack;
-				return js_to_dictionary(ctx, p_val, stack);
-			}
-		} break;
-		case JS_TAG_NULL:
-		case JS_TAG_UNDEFINED:
-			return Variant();
-			break;
-		default:
-#ifdef JS_NAN_BOXING
-			if (tag > JS_TAG_FLOAT64 || tag < JS_TAG_FIRST) {
-				return Variant(real_t(JS_VALUE_GET_FLOAT64(p_val)));
-			}
-#endif
-			return Variant();
-	}
-}
-
-JSValue QuickJSBinder::godot_builtin_function(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic) {
-	Variant ret;
-	Callable::CallError err;
-	String err_msg;
-#if 0 // TODO: builtin functions
-	Expression::BuiltinFunc func = (Expression::BuiltinFunc)magic;
-	int arg_required = Expression::get_func_argument_count(func);
-	if (argc < arg_required) {
-		String func_name = Expression::get_func_name(func);
-		return JS_ThrowTypeError(ctx, "%d arguments expected for builtin funtion %s", arg_required, func_name.ascii().get_data());
-	}
-
-	QuickJSBinder *binder = get_context_binder(ctx);
-	GodotMethodArguments args(argc);
-	for (int i = 0; i < argc; ++i) {
-		args.arguments[i] = var_to_variant(ctx, argv[i]);
-	}
-	Expression::exec_func(func, args.ptr, &ret, err, err_msg);
-#ifdef DEBUG_METHODS_ENABLED
-	if (err.error != Variant::CallError::CALL_OK) {
-		String func_name = Expression::get_func_name(func);
-		if (err_msg.empty()) {
-			switch (err.error) {
-				case Variant::CallError::CALL_ERROR_INVALID_ARGUMENT:
-					err_msg = vformat("Argument of type '%s' is not assignable to parameter #%d of type '%s'", Variant::get_type_name(args.arguments[err.argument].get_type()), err.argument, Variant::get_type_name(err.expected));
-					break;
-				case Variant::CallError::CALL_ERROR_INVALID_METHOD:
-					err_msg = vformat("Invalid builtin function", func_name);
-					break;
-				case Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
-					err_msg = vformat("Too few arguments builtin function", func_name);
-					break;
-				case Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:
-					err_msg = vformat("Too many arguments for builtin function", func_name);
-					break;
-				default:
-					break;
-			}
-		}
-	}
-#endif
-
-	if (err.error != Variant::CallError::CALL_OK) {
-		String func_name = Expression::get_func_name(func);
-		return JS_ThrowTypeError(ctx, "Call builtin function error %s: %s", func_name.ascii().get_data(), err_msg.utf8().get_data());
-	}
-
-#endif
-
-	return variant_to_var(ctx, ret);
-}
-
-bool QuickJSBinder::validate_type(JSContext *ctx, Variant::Type p_type, JSValueConst &p_val) {
-	switch (p_type) {
-		case Variant::NIL:
-			return JS_IsNull(p_val) || JS_IsUndefined(p_val);
-		case Variant::BOOL:
-		case Variant::INT:
-		case Variant::FLOAT:
-			return JS_IsNumber(p_val) || JS_IsBool(p_val) || JS_IsNull(p_val) || JS_IsUndefined(p_val);
-		case Variant::STRING:
-			return JS_IsString(p_val);
-		case Variant::DICTIONARY:
-			return JS_IsObject(p_val);
-		case Variant::ARRAY:
-			return JS_IsArray(ctx, p_val);
-		default: {
-			JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, p_val);
-			return bind != NULL && bind->type == p_type;
-		}
-	}
-}
-
-void QuickJSBinder::dump_exception(JSContext *ctx, const JSValue &p_exception, JavaScriptError *r_error) {
-	JSValue err_file = JS_GetProperty(ctx, p_exception, JS_ATOM_fileName);
-	JSValue err_line = JS_GetProperty(ctx, p_exception, JS_ATOM_lineNumber);
-	JSValue err_msg = JS_GetProperty(ctx, p_exception, JS_ATOM_message);
-	JSValue err_stack = JS_GetProperty(ctx, p_exception, JS_ATOM_stack);
-
-	JS_ToInt32(ctx, &r_error->line, err_line);
-	r_error->message = js_to_string(ctx, err_msg);
-	r_error->file = js_to_string(ctx, err_file);
-	r_error->stack.push_back(js_to_string(ctx, err_stack));
-	r_error->column = 0;
-
-	JS_FreeValue(ctx, err_file);
-	JS_FreeValue(ctx, err_line);
-	JS_FreeValue(ctx, err_msg);
-	JS_FreeValue(ctx, err_stack);
-}
-
-String QuickJSBinder::error_to_string(const JavaScriptError &p_error) {
-	String message = "JavaScript Error";
-	if (p_error.stack.size()) {
-		message += p_error.stack[0];
-	}
-	message += p_error.message;
-	for (int i = 1; i < p_error.stack.size(); i++) {
-		message += p_error.stack[i];
-	}
-	return message;
-}
-
-Error QuickJSBinder::get_stacks(List<JavaScriptStackInfo> &r_stacks) {
-	JSValue error_constructor = JS_GetProperty(ctx, global_object, JS_ATOM_Error);
-	JSValue error = JS_CallConstructor(ctx, error_constructor, 0, NULL);
-	JSValue stack = JS_GetProperty(ctx, error, JS_ATOM_stack);
-	String stack_text = js_to_string(ctx, stack);
-	Vector<String> raw_stacks = stack_text.split("\n", false);
-	for (int i = 1; i < raw_stacks.size(); i++) {
-		String line_text = raw_stacks[i].strip_edges();
-		if (line_text.is_empty())
-			continue;
-		JavaScriptStackInfo s;
-		int colon = line_text.rfind(":");
-		int bracket = line_text.rfind("(");
-		s.line = line_text.substr(colon + 1, line_text.length() - colon - 2).to_int();
-		s.file = line_text.substr(bracket + 1, colon - bracket - 1);
-		s.function = line_text.substr(3, bracket - 4);
-		r_stacks.push_back(s);
-	}
-	JS_FreeValue(ctx, stack);
-	JS_FreeValue(ctx, error);
-	JS_FreeValue(ctx, error_constructor);
-	return OK;
-}
-
-String QuickJSBinder::get_backtrace_message(const List<JavaScriptStackInfo> &stacks) {
-	String message;
-	for (const List<JavaScriptStackInfo>::Element *E = stacks.front(); E; E = E->next()) {
-		message += "  ";
-		message += vformat("at %s (%s:%d)", E->get().function, E->get().file, E->get().line);
-		if (E != stacks.back()) {
-			message += ENDL;
-		}
-	}
-	return message;
-}
-
-Dictionary QuickJSBinder::js_to_dictionary(JSContext *ctx, const JSValue &p_val, List<void *> &stack) {
-	Dictionary dict;
-	HashSet<String> keys;
-	get_own_property_names(ctx, p_val, &keys);
-	stack.push_back(JS_VALUE_GET_PTR(p_val));
-	for (const String &key : keys) {
-		JSValue v = JS_GetPropertyStr(ctx, p_val, key.utf8().get_data());
-		Variant val;
-		if (JS_IsObject(v)) {
-			void *ptr = JS_VALUE_GET_PTR(v);
-			if (stack.find(ptr)) {
-				union {
-					const void *p;
-					uint64_t i;
-				} u;
-				u.p = ptr;
-				ERR_PRINT(vformat("Property '%s' circular reference to 0x%X", key, u.i));
-				JS_FreeValue(ctx, v);
-				continue;
-			} else {
-				stack.push_back(ptr);
-				val = var_to_variant(ctx, v);
-				stack.pop_back();
-			}
-		} else {
-			val = var_to_variant(ctx, v);
-		}
-		dict[key] = val;
-		JS_FreeValue(ctx, v);
-	}
-	stack.pop_back();
-	return dict;
-}
-
-JSAtom QuickJSBinder::get_atom(JSContext *ctx, const StringName &p_key) {
-	String name = p_key;
-	CharString name_str = name.ascii();
-	JSAtom atom = JS_NewAtom(ctx, name_str.get_data());
-	return atom;
-}
-
-JSValue QuickJSBinder::godot_to_string(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-	String str = var_to_variant(ctx, this_val);
-	CharString ascii = str.ascii();
-	return JS_NewStringLen(ctx, ascii.get_data(), ascii.length());
-}
-
-JSValue QuickJSBinder::godot_get_type(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-#ifdef DEBUG_METHODS_ENABLED
-	ERR_FAIL_COND_V(argc < 1, JS_ThrowTypeError(ctx, "parameter expected for %s.%s", GODOT_OBJECT_NAME, "get_type"));
-#endif
-	Variant value;
-	if (argc) {
-		value = var_to_variant(ctx, argv[0]);
-	}
-	return JS_NewInt32(ctx, value.get_type());
-}
-
-JSValue QuickJSBinder::godot_load(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-#ifdef DEBUG_METHODS_ENABLED
-	ERR_FAIL_COND_V(argc < 1 || !JS_IsString(argv[0]), JS_ThrowTypeError(ctx, "string expected for %s.%s", GODOT_OBJECT_NAME, "load"));
-#endif
-	String path = js_to_string(ctx, argv[0]);
-	Ref<Resource> res = ResourceLoader::load(path);
-	return variant_to_var(ctx, res);
-}
-
-JSValue QuickJSBinder::godot_instance_from_id(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-#ifdef DEBUG_METHODS_ENABLED
-	ERR_FAIL_COND_V(argc < 1 || !JS_IsNumber(argv[0]), JS_ThrowTypeError(ctx, "number expected for %s.%s", GODOT_OBJECT_NAME, "instance_from_id"));
-#endif
-	ObjectID id(js_to_uint64(ctx, argv[0]));
-	Object *obj = ObjectDB::get_instance(id);
-	return variant_to_var(ctx, obj);
-}
-
-JSValue QuickJSBinder::godot_object_method_connect(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-#ifdef DEBUG_METHODS_ENABLED
-	ERR_FAIL_COND_V(argc < 2 || !JS_IsString(argv[0]) || !JS_IsFunction(ctx, argv[1]), JS_ThrowTypeError(ctx, "string and function expected for %s.%s", "Object", "connect"));
-#endif
-	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
-	Object *obj = bind->get_godot_object();
-	StringName signal = binder->js_to_string(ctx, argv[0]);
-	Callable callable = memnew(QuickJSCallable(ctx, argv[1]));
-	obj->connect(signal, callable);
-	return JS_UNDEFINED;
-}
-
-void QuickJSBinder::add_debug_binding_info(JSContext *ctx, JSValueConst p_obj, const JavaScriptGCHandler *p_bind) {
-	if (!p_bind)
-		return;
-	JSValue classname = JS_UNDEFINED;
-	if (p_bind->type != Variant::OBJECT) {
-		classname = to_js_string(ctx, Variant::get_type_name(p_bind->type));
-	} else {
-		if (p_bind->is_object()) {
-			classname = to_js_string(ctx, p_bind->godot_object->get_class_name());
-		}
-	}
-
-	Array arr;
-	String ptr_str = "0x%X";
-	bool err;
-	union {
-		const void *p;
-		uint64_t i;
-	} u;
-	u.p = p_bind->godot_object;
-	arr.push_back(int(u.i));
-	ptr_str = ptr_str.sprintf(arr, &err);
-	JSValue ptrvalue = to_js_string(ctx, ptr_str);
-
-	u.p = ctx;
-	arr[0] = int(u.i);
-	ptr_str = "0x%X";
-	ptr_str = ptr_str.sprintf(arr, &err);
-	JSValue ptrctx = to_js_string(ctx, ptr_str);
-
-	JS_DefinePropertyValueStr(ctx, p_obj, "__class__", classname, PROP_DEF_DEFAULT);
-	JS_DefinePropertyValueStr(ctx, p_obj, "__ptr__", ptrvalue, PROP_DEF_DEFAULT);
-	JS_DefinePropertyValueStr(ctx, p_obj, "__ctx__", ptrctx, PROP_DEF_DEFAULT);
-}
-
-static HashMap<String, String> resolve_path_cache;
-
-String QuickJSBinder::resolve_module_file(const String &file) {
-	if (const String *ptr = resolve_path_cache.getptr(file)) {
-		return *ptr;
-	}
-	String path = file;
-	if (FileAccess::exists(path))
-		return path;
-	// add extensions to try
-	String extension = file.get_extension();
-	List<String> extensions;
-	JavaScriptLanguage::get_singleton()->get_recognized_extensions(&extensions);
-	if (extensions.find(extension) == NULL) {
-		for (List<String>::Element *E = extensions.front(); E; E = E->next()) {
-			path = file + "." + E->get();
-			if (FileAccess::exists(path)) {
-				return path;
-			}
-		}
-	}
-	// try index file under the folder
-	for (List<String>::Element *E = extensions.front(); E; E = E->next()) {
-		path = file + "/index." + E->get();
-		if (FileAccess::exists(path)) {
-			return path;
-		}
-	}
-	return "";
-}
-
-JSModuleDef *QuickJSBinder::js_module_loader(JSContext *ctx, const char *module_name, void *opaque) {
-	JSModuleDef *m = NULL;
-	Error err;
-
-	String resolving_file;
-	resolving_file.parse_utf8(module_name);
-
-	String file = resolve_module_file(resolving_file);
-	ERR_FAIL_COND_V_MSG(file.is_empty(), NULL, "Failed to resolve module: '" + resolving_file + "'.");
-	resolve_path_cache.insert(resolving_file, file);
-
-	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
-	if (ModuleCache *ptr = binder->module_cache.getptr(file)) {
-		m = ptr->module;
-	}
-
-	if (!m) {
-		List<String> extensions;
-		JavaScriptLanguage::get_singleton()->get_recognized_extensions(&extensions);
-		if (extensions.find(file.get_extension()) != NULL) {
-			Ref<JavaScriptModule> em = ResourceFormatLoaderJavaScriptModule::load_static(file, "", &err);
-			if (err != OK || !em.is_valid()) {
-				JS_ThrowReferenceError(ctx, "Could not load module '%s'", file.utf8().get_data());
-				return NULL;
-			}
-			JavaScriptError es_err;
-
-			const Vector<uint8_t> &bytecode = em->get_bytecode();
-			if (bytecode.size()) {
-				JavaScriptGCHandler js;
-				if (binder->load_bytecode(bytecode, file, &js) == OK) {
-					m = static_cast<JSModuleDef *>(js.javascript_object);
-				}
-			} else {
-				String code = em->get_source_code();
-				if (file.ends_with(EXT_JSON)) {
-					code = "export default " + code;
-				}
-				if (ModuleCache *module = binder->js_compile_and_cache_module(ctx, code, file, &es_err)) {
-					m = module->module;
-				}
-			}
-
-		} else { // Try load as Resource
-			Ref<Resource> res = ResourceLoader::load(file);
-			if (res.is_null()) {
-				JS_ThrowReferenceError(ctx, "Could not load module '%s'", file.utf8().get_data());
-				return NULL;
-			}
-			JSValue val = variant_to_var(ctx, res);
-			m = js_make_module(ctx, file, val);
-			JS_FreeValue(ctx, val);
-
-			ModuleCache module;
-			Variant hash_var = res;
-			module.hash = hash_var.hash();
-			module.module = m;
-			module.res = res;
-			module.res->reference(); // Avoid auto release as module don't release automaticly
-			module.res_value = val;
-			module.flags = MODULE_FLAG_RESOURCE;
-			module.module = m;
-			binder->module_cache.insert(file, module);
-		}
-	}
-
-	return m;
-}
-
-JSModuleDef *QuickJSBinder::js_make_module(JSContext *ctx, const String &p_id, const JSValue &p_value) {
-	JSModuleDef *m = JS_NewCModule(ctx, p_id.utf8().get_data(), resource_module_initializer);
-	JS_AddModuleExport(ctx, m, "default");
-	JSValue func = JS_MKPTR(JS_TAG_MODULE, m);
-	JS_DupValue(ctx, func);
-	JS_EvalFunction(ctx, func);
-	JS_SetModuleExport(ctx, m, "default", JS_DupValue(ctx, p_value));
-	return m;
-}
-
-QuickJSBinder::ModuleCache QuickJSBinder::js_compile_module(JSContext *ctx, const String &p_code, const String &p_filename, JavaScriptError *r_error) {
-	if (NULL != compiling_modules.find(p_filename)) {
-		String chain;
-		for (List<String>::Element *E = compiling_modules.front(); E; E = E->next()) {
-			chain += E->get();
-			if (E->next() != NULL) {
-				chain += " <- ";
-			}
-		}
-		ERR_FAIL_V_MSG(ModuleCache(), vformat("Cyclic module import detected:\r\n  %s", chain));
-	}
-
-	ModuleCache module;
-	module.flags = 0;
-	module.module = NULL;
-	module.hash = p_code.hash();
-
-	CharString code = p_code.utf8();
-	CharString filename = p_filename.utf8();
-	const char *cfilename = filename.get_data();
-	const char *cfilesource = code.get_data();
-
-	compiling_modules.push_back(p_filename);
-	JSValue func = JS_Eval(ctx, cfilesource, code.length(), cfilename, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
-	compiling_modules.pop_back();
-
-	if (!JS_IsException(func)) {
-		module.flags = MODULE_FLAG_SCRIPT;
-		module.module = static_cast<JSModuleDef *>(JS_VALUE_GET_PTR(func));
-		module.res_value = JS_UNDEFINED;
-	} else {
-		JSValue e = JS_GetException(ctx);
-		dump_exception(ctx, e, r_error);
-		JS_Throw(ctx, e);
-	}
-
-	return module;
-}
-
-QuickJSBinder::ModuleCache *QuickJSBinder::js_compile_and_cache_module(JSContext *ctx, const String &p_code, const String &p_filename, JavaScriptError *r_error) {
-	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
-	ModuleCache *last_module = binder->module_cache.getptr(p_filename);
-	if (last_module) {
-		if (last_module->hash == p_code.hash()) {
-#if MODULE_HAS_REFCOUNT
-			if (last_module->module) {
-				JSValue val = JS_MKPTR(JS_TAG_MODULE, last_module->module);
-				JS_DupValue(ctx, val);
-			}
-#endif
-			return last_module;
-		} else {
-#if MODULE_HAS_REFCOUNT
-			JSModuleDef *m = last_module->module;
-			if (m) {
-				JSValue val = JS_MKPTR(JS_TAG_MODULE, m);
-				JS_FreeValue(ctx, val);
-			}
-#endif
-		}
-	}
-
-	ModuleCache mc = js_compile_module(ctx, p_code, p_filename, r_error);
-	mc.hash = p_code.hash();
-	if (mc.module) {
-		binder->module_cache.insert(p_filename, mc);
-	}
-	return binder->module_cache.getptr(p_filename);
-}
-
-QuickJSBinder::ModuleCache *QuickJSBinder::js_compile_and_cache_module(JSContext *ctx, const Vector<uint8_t> &p_bytecode, const String &p_filename, JavaScriptError *r_error) {
-	QuickJSBinder *binder = get_context_binder(ctx);
-	JavaScriptGCHandler module;
-	if (OK == binder->load_bytecode(p_bytecode, p_filename, &module)) {
-		return module_cache.getptr(p_filename);
-	}
-	return NULL;
-}
-
-Error QuickJSBinder::js_evalute_module(JSContext *ctx, QuickJSBinder::ModuleCache *p_module, JavaScriptError *r_error) {
-	if (p_module->flags & MODULE_FLAG_EVALUATED)
-		return OK;
-
-	JSValue module = JS_MKPTR(JS_TAG_MODULE, p_module->module);
-	if (JS_IsException(module)) {
-		JSValue e = JS_GetException(ctx);
-		dump_exception(ctx, e, r_error);
-		JS_Throw(ctx, e);
-		return ERR_PARSE_ERROR;
-	}
-
-	if (!(p_module->flags & MODULE_FLAG_EVALUATED)) {
-		JSValue ret = JS_EvalFunction(ctx, module);
-		if (JS_IsException(ret)) {
-			JSValue e = JS_GetException(ctx);
-			dump_exception(ctx, e, r_error);
-			JS_Throw(ctx, e);
-			return ERR_PARSE_ERROR;
-		} else {
-			p_module->flags |= MODULE_FLAG_EVALUATED;
-		}
-		JS_FreeValue(ctx, ret);
-	}
-
-	return OK;
-}
-
-int QuickJSBinder::resource_module_initializer(JSContext *ctx, JSModuleDef *m) {
-	return JS_SetModuleExport(ctx, m, "default", JS_UNDEFINED);
-}
-
-JSClassID QuickJSBinder::register_class(const ClassDB::ClassInfo *p_cls) {
-	ClassBindData data;
-	data.class_id = 0;
-	data.base_class = NULL;
-
-	if (class_remap.has(p_cls->name)) {
-		data.class_name = class_remap[p_cls->name];
-		data.jsclass.class_name = class_remap[p_cls->name];
-		if (strcmp(data.jsclass.class_name, "") == 0) {
-			return 0;
-		}
-	} else {
-		data.class_name = String(p_cls->name).ascii();
-		data.jsclass.class_name = data.class_name.get_data();
-	}
-
-	data.jsclass.exotic = NULL;
-	data.jsclass.gc_mark = NULL;
-	data.jsclass.call = NULL;
-	data.gdclass = p_cls;
-
-	data.prototype = JS_NewObject(ctx);
-
-	// methods
-	HashMap<StringName, JSValue> methods;
-	{
-		godot_methods.resize(internal_godot_method_id + p_cls->method_map.size());
-		for (const KeyValue<StringName, MethodBind *> &pair : p_cls->method_map) {
-			if (p_cls->name == "Object") {
-				const char *connect = "connect";
-				if (pair.key == connect) {
-					JSValue func = JS_NewCFunction(ctx, godot_object_method_connect, connect, 3);
-					JS_DefinePropertyValueStr(ctx, data.prototype, connect, func, PROP_DEF_DEFAULT);
-					continue;
-				}
-			}
-
-			MethodBind *mb = pair.value;
-			godot_methods.set(internal_godot_method_id, mb);
-			CharString name = String(pair.key).ascii();
-			JSValue method = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_method, name.get_data(), mb->get_argument_count(), JS_CFUNC_generic_magic, internal_godot_method_id);
-			JS_DefinePropertyValueStr(ctx, data.prototype, name.get_data(), method, PROP_DEF_DEFAULT);
-			methods.insert(pair.key, method);
-			++internal_godot_method_id;
-		}
-
-		if (p_cls->name == "Object") {
-			// toString()
-			JSValue to_string_func = JS_NewCFunction(ctx, godot_to_string, TO_STRING_LITERAL, 0);
-			JS_DefinePropertyValueStr(ctx, data.prototype, TO_STRING_LITERAL, to_string_func, PROP_DEF_DEFAULT);
-			// free()
-			const char *free_func_name = "free";
-			JSValue free_func = JS_NewCFunction(ctx, object_free, free_func_name, 0);
-			JS_DefinePropertyValueStr(ctx, data.prototype, free_func_name, free_func, PROP_DEF_DEFAULT);
-		}
-	}
-
-	// properties
-	{
-		for (const KeyValue<StringName, ClassDB::PropertySetGet> &i : p_cls->property_setget) {
-			const StringName &prop_name = i.key;
-			const ClassDB::PropertySetGet &prop = i.value;
-
-			JSValue setter = JS_UNDEFINED;
-			JSValue getter = JS_UNDEFINED;
-
-			if (prop.index >= 0) {
-				int size = godot_object_indexed_properties.size();
-				if (size <= internal_godot_indexed_property_id) {
-					godot_object_indexed_properties.resize(size + 128);
-				}
-				godot_object_indexed_properties.write[internal_godot_indexed_property_id] = &prop;
-				CharString name = String(prop_name).ascii();
-				getter = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_indexed_property, name.get_data(), 0, JS_CFUNC_generic_magic, internal_godot_indexed_property_id);
-				setter = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_indexed_property, name.get_data(), 1, JS_CFUNC_generic_magic, internal_godot_indexed_property_id);
-				++internal_godot_indexed_property_id;
-			} else {
-				if (HashMap<StringName, JSValue>::ConstIterator it = methods.find(prop.setter)) {
-					setter = it->value;
-					JS_DupValue(ctx, setter);
-				} else if (MethodBind *mb = prop._setptr) {
-					if (godot_methods.size() >= internal_godot_method_id) {
-						godot_methods.resize(godot_methods.size() + 1);
-					}
-					godot_methods.write[internal_godot_method_id] = mb;
-					String setter_name = prop.setter;
-					setter = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_method, setter_name.ascii().get_data(), mb->get_argument_count(), JS_CFUNC_generic_magic, internal_godot_method_id);
-					++internal_godot_method_id;
-				}
-
-				if (HashMap<StringName, JSValue>::ConstIterator it = methods.find(prop.getter)) {
-					getter = it->value;
-					JS_DupValue(ctx, getter);
-				} else if (MethodBind *mb = prop._getptr) {
-					if (godot_methods.size() >= internal_godot_method_id) {
-						godot_methods.resize(godot_methods.size() + 1);
-					}
-					godot_methods.write[internal_godot_method_id] = mb;
-					String getter_name = prop.getter;
-					getter = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_method, getter_name.ascii().get_data(), mb->get_argument_count(), JS_CFUNC_generic_magic, internal_godot_method_id);
-					++internal_godot_method_id;
-				}
-			}
-
-			JSAtom atom = get_atom(ctx, prop_name);
-			JS_DefinePropertyGetSet(ctx, data.prototype, atom, getter, setter, PROP_DEF_DEFAULT);
-			JS_FreeAtom(ctx, atom);
-		}
-	}
-
-	JS_NewClassID(&data.class_id);
-	JS_NewClass(JS_GetRuntime(ctx), data.class_id, &data.jsclass);
-	JS_SetClassProto(ctx, data.class_id, data.prototype);
-
-	data.constructor = JS_NewCFunctionMagic(ctx, object_constructor, data.jsclass.class_name, data.class_name.size(), JS_CFUNC_constructor_magic, (int)data.class_id);
-	JS_SetConstructor(ctx, data.constructor, data.prototype);
-	JS_DefinePropertyValue(ctx, data.prototype, js_key_godot_classid, JS_NewInt32(ctx, data.class_id), PROP_DEF_DEFAULT);
-	JS_DefinePropertyValue(ctx, data.constructor, js_key_godot_classid, JS_NewInt32(ctx, data.class_id), PROP_DEF_DEFAULT);
-
-	// constants
-	for (const KeyValue<StringName, int64_t> &pair : p_cls->constant_map) {
-		JSAtom atom = get_atom(ctx, pair.key);
-		JS_DefinePropertyValue(ctx, data.constructor, atom, JS_NewInt64(ctx, pair.value), PROP_DEF_DEFAULT);
-		JS_FreeAtom(ctx, atom);
-	}
-
-	// enumeration
-	for (const KeyValue<StringName, ClassDB::ClassInfo::EnumInfo> &pair : p_cls->enum_map) {
-		JSValue enum_obj = JS_NewObject(ctx);
-		JSAtom atom = get_atom(ctx, pair.key);
-
-		const List<StringName> &const_keys = pair.value.constants;
-		for (const List<StringName>::Element *E = const_keys.front(); E; E = E->next()) {
-			int value = p_cls->constant_map.get(E->get());
-			JSAtom atom_key = get_atom(ctx, E->get());
-			JS_DefinePropertyValue(ctx, enum_obj, atom_key, JS_NewInt32(ctx, value), PROP_DEF_DEFAULT);
-			JS_FreeAtom(ctx, atom_key);
-		}
-
-		JS_DefinePropertyValue(ctx, data.constructor, atom, enum_obj, PROP_DEF_DEFAULT);
-		JS_FreeAtom(ctx, atom);
-	}
-
-	// signals
-	for (const KeyValue<StringName, MethodInfo> &pair : p_cls->signal_map) {
-		JSAtom atom = get_atom(ctx, pair.key);
-		JS_DefinePropertyValue(ctx, data.constructor, atom, to_js_string(ctx, pair.key), PROP_DEF_DEFAULT);
-		JS_FreeAtom(ctx, atom);
-	}
-
-	class_bindings.insert(data.class_id, data);
-	classname_bindings.insert(p_cls->name, class_bindings.getptr(data.class_id));
-
-	return data.class_id;
-}
-
-void QuickJSBinder::add_godot_origin() {
-	godot_origin_class.class_id = 0;
-	godot_origin_class.class_name = "GodotOrigin";
-	godot_origin_class.jsclass.class_name = godot_origin_class.class_name.get_data();
-	godot_origin_class.jsclass.finalizer = origin_finalizer;
-	godot_origin_class.jsclass.exotic = NULL;
-	godot_origin_class.jsclass.call = NULL;
-	godot_origin_class.jsclass.gc_mark = NULL;
-	godot_origin_class.prototype = JS_NewObject(ctx);
-	godot_origin_class.gdclass = NULL;
-	godot_origin_class.base_class = NULL;
-	JS_NewClassID(&godot_origin_class.class_id);
-	JS_NewClass(JS_GetRuntime(ctx), godot_origin_class.class_id, &godot_origin_class.jsclass);
-	JS_SetClassProto(ctx, godot_origin_class.class_id, godot_origin_class.prototype);
-	godot_origin_class.constructor = JS_NewCFunction2(ctx, js_empty_consturctor, godot_origin_class.jsclass.class_name, 0, JS_CFUNC_constructor, 0);
-	JS_SetConstructor(ctx, godot_origin_class.constructor, godot_origin_class.prototype);
-	JS_DefinePropertyValueStr(ctx, godot_object, godot_origin_class.class_name, godot_origin_class.constructor, PROP_DEF_DEFAULT);
-}
-
-void QuickJSBinder::add_godot_classes() {
-	HashMap<const ClassDB::ClassInfo *, JSClassID> gdclass_jsmap;
-	// register classes
-	for (const KeyValue<StringName, ClassDB::ClassInfo> &pair : ClassDB::classes) {
-		const ClassDB::ClassInfo &cls = pair.value;
-		if (JSClassID id = register_class(&cls)) {
-			gdclass_jsmap.insert(&cls, id);
-		}
-	}
-
-	// Setup inherits chain
-	for (const KeyValue<const ClassDB::ClassInfo *, JSClassID> &pair : gdclass_jsmap) {
-		const ClassDB::ClassInfo *gdcls = pair.key;
-		ClassBindData &bind = class_bindings.get(pair.value);
-		if (gdcls->inherits_ptr) {
-			if (const HashMap<const ClassDB::ClassInfo *, JSClassID>::ConstIterator &base = gdclass_jsmap.find(gdcls->inherits_ptr)) {
-				bind.base_class = class_bindings.getptr(base->value);
-			}
-		}
-	}
-
-	// Setup the prototype chain
-	for (const KeyValue<JSClassID, ClassBindData> &pair : class_bindings) {
-		const ClassBindData &data = pair.value;
-		int flags = PROP_DEF_DEFAULT;
-		// Allows redefine as to global object
-		if (Engine::get_singleton()->has_singleton(data.gdclass->name)) {
-			flags |= JS_PROP_CONFIGURABLE;
-		}
-		JS_DefinePropertyValueStr(ctx, godot_object, data.jsclass.class_name, data.constructor, flags);
-		if (data.base_class) {
-			JS_SetPrototype(ctx, data.prototype, data.base_class->prototype);
-		} else {
-			JS_SetPrototype(ctx, data.prototype, godot_origin_class.prototype);
-		}
-	}
-
-	godot_object_class = *classname_bindings.getptr("Object");
-	godot_reference_class = *classname_bindings.getptr("RefCounted");
-}
-
-void QuickJSBinder::add_godot_globals() {
-	// Singletons
-	List<Engine::Singleton> singletons;
-	Engine::get_singleton()->get_singletons(&singletons);
-	for (List<Engine::Singleton>::Element *E = singletons.front(); E; E = E->next()) {
-		const Engine::Singleton &s = E->get();
-
-		ERR_CONTINUE(s.ptr == NULL);
-
-		const ClassBindData **cls_ptr = classname_bindings.getptr(s.ptr->get_class_name());
-		ERR_CONTINUE(cls_ptr == NULL);
-		const ClassBindData *cls = *cls_ptr;
-
-		JSValue obj = JS_NewObjectProtoClass(ctx, cls->prototype, get_origin_class_id());
-		JavaScriptGCHandler *data = new_gc_handler(ctx);
-		data->javascript_object = JS_VALUE_GET_PTR(obj);
-		data->godot_object = s.ptr;
-		data->type = Variant::OBJECT;
-		data->flags = JavaScriptGCHandler::FLAG_OBJECT;
-		JS_SetOpaque(obj, data);
-
-		JSAtom singleton_name = get_atom(ctx, s.name);
-		JSValue last_obj = JS_GetProperty(ctx, godot_object, singleton_name);
-		if (!JS_IsUndefined(last_obj)) {
-			JS_SetPrototype(ctx, obj, cls->prototype);
-			JS_FreeValue(ctx, last_obj);
-		}
-
-		JS_DupValue(ctx, obj);
-		JS_DefinePropertyValue(ctx, godot_object, singleton_name, obj, QuickJSBinder::PROP_DEF_DEFAULT);
-		JS_FreeAtom(ctx, singleton_name);
-		godot_singletons.push_back(obj);
-
-		ClassDB::ClassInfo *gdcls = ClassDB::classes.getptr(s.name);
-		gdcls = gdcls == NULL ? ClassDB::classes.getptr(s.ptr->get_class_name()) : gdcls;
-		if (gdcls) {
-			// constants
-			for (KeyValue<StringName, int64_t> &pair : gdcls->constant_map) {
-				JSAtom const_name = get_atom(ctx, pair.key);
-				JS_DefinePropertyValue(ctx, obj, const_name, JS_NewInt64(ctx, pair.value), QuickJSBinder::PROP_DEF_DEFAULT);
-				JS_FreeAtom(ctx, const_name);
-			}
-			// enumrations
-			for (const KeyValue<StringName, ClassDB::ClassInfo::EnumInfo> &pair : gdcls->enum_map) {
-				const List<StringName> &consts = pair.value.constants;
-				JSValue enum_obj = JS_NewObject(ctx);
-				for (const List<StringName>::Element *E2 = consts.front(); E2; E2 = E2->next()) {
-					JSAtom const_name = get_atom(ctx, E2->get());
-					JS_DefinePropertyValue(ctx, enum_obj, const_name, variant_to_var(ctx, gdcls->constant_map.get(E2->get())), QuickJSBinder::PROP_DEF_DEFAULT);
-					JS_FreeAtom(ctx, const_name);
-				}
-				JSAtom enum_name = get_atom(ctx, pair.key);
-				JS_DefinePropertyValue(ctx, obj, enum_name, enum_obj, QuickJSBinder::PROP_DEF_DEFAULT);
-				JS_FreeAtom(ctx, enum_name);
-			}
-		}
-	}
-
-	// global constants
-	HashMap<StringName, HashMap<StringName, int64_t>> global_constants;
-	for (int i = 0; i < CoreConstants::get_global_constant_count(); ++i) {
-		StringName enum_name = CoreConstants::get_global_constant_enum(i);
-		const char *const_name = CoreConstants::get_global_constant_name(i);
-		const int value = CoreConstants::get_global_constant_value(i);
-
-		JSAtom js_const_name = JS_NewAtom(ctx, const_name);
-		JS_DefinePropertyValue(ctx, godot_object, js_const_name, JS_MKVAL(JS_TAG_INT, value), QuickJSBinder::PROP_DEF_DEFAULT);
-		JS_FreeAtom(ctx, js_const_name);
-
-		if (HashMap<StringName, int64_t> *consts = global_constants.getptr(enum_name)) {
-			consts->insert(const_name, value);
-		} else {
-			HashMap<StringName, int64_t> enum_;
-			enum_.insert(const_name, value);
-			global_constants.insert(enum_name, enum_);
-		}
-	}
-	// global numbers
-	GlobalNumberConstant consts[] = {
-		{ "PI", Math_PI },
-		{ "TAU", Math_TAU },
-		{ "NAN", NAN },
-		{ "INF", INFINITY },
-		{ "E", Math_E },
-		{ "LN2", Math_LN2 },
-		{ "SQRT2", Math_SQRT2 },
-		{ "SQRT12", Math_SQRT12 },
-	};
-	for (uint32_t i = 0; i < sizeof(consts) / sizeof(GlobalNumberConstant); i++) {
-		const GlobalNumberConstant &c = consts[i];
-		JSAtom js_const_name = get_atom(ctx, c.name);
-		JS_DefinePropertyValue(ctx, godot_object, js_const_name, JS_NewFloat64(ctx, c.value), QuickJSBinder::PROP_DEF_DEFAULT);
-		JS_FreeAtom(ctx, js_const_name);
-	}
-
-	// global enums
-	for (const KeyValue<StringName, HashMap<StringName, int64_t>> &pair : global_constants) {
-		String enum_name_str = pair.key;
-		if (enum_name_str.is_empty())
-			continue;
-		enum_name_str = enum_name_str.replace(".", "");
-
-		JSAtom atom_enum_name = get_atom(ctx, enum_name_str);
-		JSValue enum_object = JS_NewObject(ctx);
-		JS_DefinePropertyValue(ctx, godot_object, atom_enum_name, enum_object, QuickJSBinder::PROP_DEF_DEFAULT);
-		JS_FreeAtom(ctx, atom_enum_name);
-
-		for (const KeyValue<StringName, int64_t> &c : pair.value) {
-			JSAtom js_const_name = get_atom(ctx, c.key);
-			JS_DefinePropertyValue(ctx, enum_object, js_const_name, JS_NewInt64(ctx, c.value), QuickJSBinder::PROP_DEF_DEFAULT);
-			JS_FreeAtom(ctx, js_const_name);
-		}
-	}
-
-#if 0
-	// builtin functions
-	for (int i = 0; i < Expression::FUNC_MAX; ++i) {
-		Expression::BuiltinFunc func = (Expression::BuiltinFunc)i;
-		String name = Expression::get_func_name(func);
-		JSValue js_func = JS_NewCFunctionMagic(ctx, godot_builtin_function, name.ascii().get_data(), 0, JS_CFUNC_generic_magic, i);
-		JSAtom atom = get_atom(ctx, name);
-		JS_DefinePropertyValue(ctx, godot_object, atom, js_func, QuickJSBinder::PROP_DEF_DEFAULT);
-		JS_FreeAtom(ctx, atom);
-	}
-#endif
-
-	// godot.register_class
-	JSValue js_func_register_class = JS_NewCFunction(ctx, godot_register_class, "register_class", 2);
-	JS_DefinePropertyValueStr(ctx, godot_object, "register_class", js_func_register_class, PROP_DEF_DEFAULT);
-	// godot.register_signal
-	JSValue js_func_register_signal = JS_NewCFunction(ctx, godot_register_signal, "register_signal", 2);
-	JS_DefinePropertyValueStr(ctx, godot_object, "register_signal", js_func_register_signal, PROP_DEF_DEFAULT);
-	// godot.register_property
-	JSValue js_func_register_property = JS_NewCFunction(ctx, godot_register_property, "register_property", 3);
-	JS_DefinePropertyValueStr(ctx, godot_object, "register_property", js_func_register_property, PROP_DEF_DEFAULT);
-	// godot.set_script_tooled
-	JSValue js_func_set_tooled = JS_NewCFunctionMagic(ctx, godot_set_script_meta, "set_script_tooled", 2, JS_CFUNC_generic_magic, QuickJSBinder::SCRIPT_META_TOOLED);
-	JS_DefinePropertyValueStr(ctx, godot_object, "set_script_tooled", js_func_set_tooled, PROP_DEF_DEFAULT);
-	// godot.set_script_icon
-	JSValue js_set_script_icon = JS_NewCFunctionMagic(ctx, godot_set_script_meta, "set_script_icon", 2, JS_CFUNC_generic_magic, QuickJSBinder::SCRIPT_META_ICON);
-	JS_DefinePropertyValueStr(ctx, godot_object, "set_script_icon", js_set_script_icon, PROP_DEF_DEFAULT);
-	// godot.get_type
-	JSValue js_get_type = JS_NewCFunction(ctx, godot_get_type, "get_type", 1);
-	JS_DefinePropertyValueStr(ctx, godot_object, "get_type", js_get_type, PROP_DEF_DEFAULT);
-	// godot.load
-	JSValue js_func_load = JS_NewCFunction(ctx, godot_load, "load", 1);
-	JS_DefinePropertyValueStr(ctx, godot_object, "load", js_func_load, PROP_DEF_DEFAULT);
-	// godot.instance_from_id
-	JSValue js_godot_instance_from_id = JS_NewCFunction(ctx, godot_instance_from_id, "instance_from_id", 1);
-	JS_DefinePropertyValueStr(ctx, godot_object, "instance_from_id", js_godot_instance_from_id, PROP_DEF_DEFAULT);
-
-	// godot.abandon_value
-	JSValue abandon_value_func = JS_NewCFunction(ctx, godot_abandon_value, "abandon_value", 1);
-	JS_DefinePropertyValueStr(ctx, godot_object, "abandon_value", abandon_value_func, PROP_DEF_DEFAULT);
-	// godot.adopt_value
-	JSValue adopt_value_func = JS_NewCFunction(ctx, godot_adopt_value, "adopt_value", 1);
-	JS_DefinePropertyValueStr(ctx, godot_object, "adopt_value", adopt_value_func, PROP_DEF_DEFAULT);
-
-	{
-		// godot.DEBUG_ENABLED
-#ifdef DEBUG_ENABLED
-		JS_DefinePropertyValueStr(ctx, godot_object, "DEBUG_ENABLED", JS_TRUE, JS_PROP_ENUMERABLE);
-#endif
-		// godot.TOOLS_ENABLED
-#ifdef TOOLS_ENABLED
-		JS_DefinePropertyValueStr(ctx, godot_object, "TOOLS_ENABLED", JS_TRUE, JS_PROP_ENUMERABLE);
-#endif
-#ifdef DEBUG_METHODS_ENABLED
-		// godot.DEBUG_METHODS_ENABLED
-		JS_DefinePropertyValueStr(ctx, godot_object, "DEBUG_METHODS_ENABLED", JS_TRUE, JS_PROP_ENUMERABLE);
-#endif
-	}
-}
-
-QuickJSBinder::QuickJSBinder() {
-	context_id = QuickJSBinder::global_context_id.increment();
-	internal_godot_method_id = 0;
-	internal_godot_indexed_property_id = 0;
-	godot_allocator.js_malloc = QuickJSBinder::js_binder_malloc;
-	godot_allocator.js_free = QuickJSBinder::js_binder_free;
-	godot_allocator.js_realloc = QuickJSBinder::js_binder_realloc;
-	godot_allocator.js_malloc_usable_size = NULL;
-	godot_object_class = NULL;
-	godot_reference_class = NULL;
-
-	if (class_remap.is_empty()) {
-#if 0
-		class_remap.insert(File::get_class_static(), "File");
-		class_remap.insert(_Directory::get_class_static(), "Directory");
-		class_remap.insert(_Thread::get_class_static(), "");
-		class_remap.insert(_Mutex::get_class_static(), "");
-		class_remap.insert(_Semaphore::get_class_static(), "");
-#endif
-	}
-}
-
-QuickJSBinder::~QuickJSBinder() {
-}
-
-void QuickJSBinder::initialize() {
-	thread_id = Thread::get_caller_id();
-	{
-		GLOBAL_LOCK_FUNCTION
-		JavaScriptLanguage::get_singleton()->thread_binder_map.insert(thread_id, this);
-	}
-
-	// create runtime and context for the binder
-	runtime = JS_NewRuntime2(&godot_allocator, this);
-	ctx = JS_NewContext(runtime);
-	JS_AddIntrinsicOperators(ctx);
-
-	JS_SetModuleLoaderFunc(runtime, /*js_module_resolve*/ NULL, js_module_loader, this);
-	JS_SetContextOpaque(ctx, this);
-
-	empty_function = JS_NewCFunction(ctx, js_empty_func, "virtual_fuction", 0);
-	// global = globalThis
-	global_object = JS_GetGlobalObject(ctx);
-	// globalThis.Operators.create
-	js_operators = JS_GetProperty(ctx, global_object, JS_ATOM_Operators);
-	js_operators_create = JS_GetPropertyStr(ctx, js_operators, "create");
-	// global.godot
-	godot_object = JS_NewObject(ctx);
-	js_key_godot_classid = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("native_class"));
-	js_key_godot_classname = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("js_class"));
-	js_key_godot_exports = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("exports"));
-	js_key_godot_signals = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("signals"));
-	js_key_godot_tooled = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("tool"));
-	js_key_godot_icon_path = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("icon"));
-	JS_DefinePropertyValueStr(ctx, global_object, GODOT_OBJECT_NAME, godot_object, PROP_DEF_DEFAULT);
-	// godot.GodotOrigin
-	add_godot_origin();
-	// godot.Vector2 godot.Color ...
-	builtin_binder.initialize(ctx, this);
-	// godot.Object godot.Node godot.Theme ...
-	add_godot_classes();
-	// godot.print godot.sin ...
-	add_godot_globals();
-	// globalThis.Worker
-	add_global_worker();
-	// Other global properties
-	add_global_properties();
-	// globalThis.console
-	add_global_console();
-	// binding script
-	String script_binding_error;
-	JavaScriptGCHandler eval_ret;
-	if (OK == safe_eval_text(JavaScriptBinder::BINDING_SCRIPT_CONTENT, JavaScriptBinder::EVAL_TYPE_GLOBAL, "<internal: binding_script.js>", script_binding_error, eval_ret)) {
-#ifdef TOOLS_ENABLED
-		if (eval_ret.javascript_object) {
-			JSValue ret = JS_MKPTR(JS_TAG_OBJECT, eval_ret.javascript_object);
-			modified_api = var_to_variant(ctx, ret);
-			JS_FreeValue(ctx, ret);
-		}
-#endif
-	} else {
-		CRASH_NOW_MSG("Execute script binding failed:" ENDL + script_binding_error);
-	}
-
-#ifdef QUICKJS_WITH_DEBUGGER
-	debugger.instantiate();
-	bool is_editor_hint = false;
-	bool default_server_enabled = GLOBAL_DEF("JavaScript/debugger/enabled", false);
-	int default_port = GLOBAL_DEF("JavaScript/debugger/port", 5556);
-#ifdef TOOLS_ENABLED
-	is_editor_hint = Engine::get_singleton()->is_editor_hint();
-#endif
-	if (!is_editor_hint) {
-		List<String> args = OS::get_singleton()->get_cmdline_args();
-		if (List<String>::Element *E = args.find("--js-debugger-connect")) {
-			if (E->next() && E->next()->get().find(":") != -1) {
-				String address = E->next()->get();
-				Error err = debugger->connect(ctx, address);
-				if (err != OK) {
-					ERR_PRINT(vformat("Failed to connect to JavaScript debugger at %s", address));
-				}
-			} else {
-				ERR_PRINT("Invalid debugger address");
-			}
-		} else if (List<String>::Element *E2 = args.find("--js-debugger-listen")) {
-			if (E2->next() && E2->next()->get().find(":") != -1) {
-				String address = E2->next()->get();
-				Error err = debugger->listen(ctx, address);
-				if (err == OK) {
-					print_line(vformat("JavaScript debugger started at %s", address));
-				} else {
-					ERR_PRINT(vformat("Failed to start JavaScript debugger at %s", address));
-				}
-			} else {
-				ERR_PRINT("Invalid debugger address");
-			}
-		} else if (default_server_enabled) {
-			String address = vformat("0.0.0.0:%d", default_port);
-			Error err = debugger->listen(ctx, address);
-			if (err == OK) {
-				print_line(vformat("JavaScript debugger started at %s", address));
-			} else {
-				ERR_PRINT(vformat("Failed to start JavaScript debugger at %s", address));
-			}
-		}
-	} else {
-#ifdef TOOLS_ENABLED
-		// TODO: debug editor plugin support
-#endif
-	}
-#endif
-}
-
-void QuickJSBinder::uninitialize() {
-	godot_object_class = NULL;
-	godot_reference_class = NULL;
-	builtin_binder.uninitialize();
-
-	// Free singletons
-	for (int i = 0; i < godot_singletons.size(); i++) {
-		JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, godot_singletons[i]);
-		if (bind) {
-			memdelete(bind);
-			JS_SetOpaque(godot_singletons[i], NULL);
-		}
-		JS_FreeValue(ctx, godot_singletons[i]);
-	}
-
-	// Free registered js classes
-	for (const KeyValue<String, JavaScriptClassInfo> &pair : javascript_classes) {
-		const JavaScriptClassInfo &js_class = pair.value;
-		free_javascript_class(js_class);
-	}
-	javascript_classes.clear();
-
-	// Free frame callbacks
-	for (const KeyValue<int64_t, JavaScriptGCHandler> &pair : frame_callbacks) {
-		const JavaScriptGCHandler &func = pair.value;
-		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.javascript_object);
-		JS_FreeValue(ctx, js_func);
-	}
-	frame_callbacks.clear();
-
-	// modules
-	List<Ref<Resource>> module_resources;
-	for (KeyValue<String, ModuleCache> &pair : module_cache) {
-		ModuleCache &m = pair.value;
-#if MODULE_HAS_REFCOUNT
-		if (m.module) {
-			JSValue val = JS_MKPTR(JS_TAG_MODULE, m.module);
-			JS_FreeValue(ctx, val);
-		}
-#endif
-		if (m.res.is_valid()) {
-			JS_FreeValue(ctx, m.res_value);
-			module_resources.push_back(m.res);
-			m.res = Ref<Resource>();
-		}
-	}
-	module_cache.clear();
-
-	// commonjs modules
-	for (KeyValue<String, CommonJSModule> &pair : commonjs_module_cache) {
-		CommonJSModule &m = pair.value;
-		JS_FreeValue(ctx, m.exports);
-		m.res = Ref<Resource>();
-	}
-	commonjs_module_cache.clear();
-
-	JS_FreeAtom(ctx, js_key_godot_classid);
-	JS_FreeAtom(ctx, js_key_godot_classname);
-	JS_FreeAtom(ctx, js_key_godot_tooled);
-	JS_FreeAtom(ctx, js_key_godot_icon_path);
-	JS_FreeAtom(ctx, js_key_godot_exports);
-	JS_FreeAtom(ctx, js_key_godot_signals);
-	JS_FreeValue(ctx, js_operators);
-	JS_FreeValue(ctx, js_operators_create);
-	JS_FreeValue(ctx, empty_function);
-	JS_FreeValue(ctx, console_object);
-	JS_FreeValue(ctx, global_object);
-
-	JS_SetContextOpaque(ctx, NULL);
-	JS_FreeContext(ctx);
-	JS_FreeRuntime(runtime);
-
-	for (List<Ref<Resource>>::Element *E = module_resources.front(); E; E = E->next()) {
-		E->get()->unreference(); // Avoid imported resource leaking
-	}
-
-#ifdef QUICKJS_WITH_DEBUGGER
-	debugger = Ref<QuickJSDebugger>();
-#endif
-
-	ctx = NULL;
-	runtime = NULL;
-
-	{
-		GLOBAL_LOCK_FUNCTION
-		JavaScriptLanguage::get_singleton()->thread_binder_map.erase(thread_id);
-	}
-}
-
-void QuickJSBinder::language_finalize() {
-	GLOBAL_LOCK_FUNCTION
-	transfer_deopot.clear();
-}
-
-void QuickJSBinder::frame() {
-	JSContext *ctx1;
-	for (;;) {
-		int err = JS_ExecutePendingJob(JS_GetRuntime(ctx), &ctx1);
-		if (err <= 0) {
-			if (err < 0) {
-				JavaScriptError script_err;
-				JSValue e = JS_GetException(ctx1);
-				dump_exception(ctx1, e, &script_err);
-				ERR_PRINT(error_to_string(script_err));
-				JS_FreeValue(ctx1, e);
-			}
-			break;
-		}
-	}
-
-	for (List<JavaScriptGCHandler *>::Element *E = workers.front(); E; E = E->next()) {
-		JavaScriptGCHandler *bind = E->get();
-		QuickJSWorker *worker = static_cast<QuickJSWorker *>(bind->native_ptr);
-		JSValue object = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
-		worker->frame_of_host(this, object);
-	}
-
-	for (const KeyValue<int64_t, JavaScriptGCHandler> &pair : frame_callbacks) {
-		if (canceled_frame_callbacks.has(pair.key))
-			continue;
-		const JavaScriptGCHandler &func = pair.value;
-		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.javascript_object);
-		double timestamp = OS::get_singleton()->get_ticks_usec() / 1000.0;
-		JSValue argv[] = { JS_NewFloat64(ctx, timestamp) };
-		JSValue ret = JS_Call(ctx, js_func, global_object, 1, argv);
-		JS_FreeValue(ctx, argv[0]);
-		if (JS_IsException(ret)) {
-			JSValue e = JS_GetException(ctx);
-			JavaScriptError err;
-			dump_exception(ctx, e, &err);
-			ERR_PRINT("Error in requestAnimationFrame:" ENDL + error_to_string(err));
-			JS_FreeValue(ctx, e);
-		}
-	}
-	for (const KeyValue<int64_t, JavaScriptGCHandler> &pair : frame_callbacks) {
-		const JavaScriptGCHandler &func = pair.value;
-		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.javascript_object);
-		JS_FreeValue(ctx, js_func);
-	}
-	frame_callbacks.clear();
-	canceled_frame_callbacks.clear();
-
-#ifdef QUICKJS_WITH_DEBUGGER
-	debugger->poll();
-#endif
-}
-
-Error QuickJSBinder::eval_string(const String &p_source, EvalType type, const String &p_path, JavaScriptGCHandler &r_ret) {
-	String error;
-	Error err = safe_eval_text(p_source, type, p_path, error, r_ret);
-	if (err != OK && !error.is_empty()) {
-		ERR_PRINT(error);
-	}
-	return err;
-}
-
-Error QuickJSBinder::safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, JavaScriptGCHandler &r_ret) {
-	ERR_FAIL_COND_V(p_source.is_empty(), FAILED);
-	CharString utf8_str = p_source.utf8();
-	const char *filename = p_path.utf8().get_data();
-	const char *code = utf8_str.get_data();
-	int flags = JS_EVAL_FLAG_STRICT;
-	if (type == JavaScriptBinder::EVAL_TYPE_MODULE) {
-		flags |= JS_EVAL_TYPE_MODULE;
-	} else {
-		flags |= JS_EVAL_TYPE_GLOBAL;
-	}
-	JSValue ret = JS_Eval(ctx, code, utf8_str.length(), filename, flags);
-	r_ret.context = ctx;
-	r_ret.javascript_object = JS_VALUE_GET_PTR(ret);
-	if (JS_IsException(ret)) {
-		JSValue e = JS_GetException(ctx);
-		JavaScriptError err;
-		dump_exception(ctx, e, &err);
-		r_error = error_to_string(err);
-		JS_Throw(ctx, e);
-		return ERR_PARSE_ERROR;
-	}
-	return OK;
-}
-Error QuickJSBinder::compile_to_bytecode(const String &p_code, const String &p_file, Vector<uint8_t> &r_bytecode) {
-	JavaScriptError script_err;
-	ModuleCache mc = js_compile_module(ctx, p_code, p_file, &script_err);
-	if (mc.module) {
-		JSValue module = JS_MKPTR(JS_TAG_MODULE, mc.module);
-		size_t size;
-		if (uint8_t *buf = JS_WriteObject(ctx, &size, module, JS_WRITE_OBJ_BYTECODE | JS_WRITE_OBJ_REFERENCE | JS_WRITE_OBJ_SAB)) {
-			r_bytecode.resize(size);
-			memcpy(r_bytecode.ptrw(), buf, size);
-			js_free(ctx, buf);
-			JS_FreeValue(ctx, module);
-		} else {
-			ERR_FAIL_V(ERR_PARSE_ERROR);
-		}
-	} else {
-		ERR_FAIL_V_MSG(ERR_PARSE_ERROR, error_to_string(script_err));
-	}
-	return OK;
-}
-
-Error QuickJSBinder::load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, JavaScriptGCHandler *r_module) {
-	Variant bytes = p_bytecode;
-	if (ModuleCache *ptr = module_cache.getptr(p_file)) {
-		if (bytes.hash() == ptr->hash) {
-			r_module->javascript_object = ptr->module;
-			return OK;
-		}
-	}
-
-	JSValue value = JS_ReadObject(ctx, p_bytecode.ptr(), p_bytecode.size(), JS_READ_OBJ_BYTECODE | JS_READ_OBJ_REFERENCE | JS_READ_OBJ_SAB | JS_READ_OBJ_ROM_DATA);
-	ERR_FAIL_COND_V(JS_VALUE_GET_TAG(value) != JS_TAG_MODULE, ERR_PARSE_ERROR);
-	void *ptr = JS_VALUE_GET_PTR(value);
-	r_module->javascript_object = ptr;
-
-	ModuleCache mc;
-	mc.flags = MODULE_FLAG_SCRIPT;
-	mc.hash = bytes.hash();
-	mc.module = static_cast<JSModuleDef *>(ptr);
-	module_cache.insert(p_file, mc);
-
-	if (JS_ResolveModule(ctx, value) < 0) {
-		JSValue e = JS_GetException(ctx);
-		JavaScriptError err;
-		dump_exception(ctx, e, &err);
-		JS_Throw(ctx, e);
-		ERR_FAIL_V_MSG(ERR_PARSE_ERROR, error_to_string(err));
-	}
-	return OK;
-}
-
-/************************* Memory Management ******************************/
-
-JavaScriptGCHandler *QuickJSBinder::alloc_object_binding_data(Object *p_object) {
-	JavaScriptGCHandler *data = new_gc_handler(nullptr);
-	bind_gc_object(ctx, data, p_object);
-	return data;
-}
-
-void QuickJSBinder::free_object_binding_data(JavaScriptGCHandler *p_gc_handle) {
-	JavaScriptGCHandler *bind = (JavaScriptGCHandler *)p_gc_handle;
-	if (!bind->is_ref_counted()) {
-		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
-		JS_SetOpaque(js_obj, NULL);
-		JS_FreeValue((JSContext *)bind->context, js_obj);
-	}
-	memdelete(bind);
-}
-
-Error QuickJSBinder::bind_gc_object(JSContext *ctx, JavaScriptGCHandler *data, Object *p_object) {
-	QuickJSBinder *binder = get_context_binder(ctx);
-	const ClassBindData **bind_ptr = binder->classname_bindings.getptr(p_object->get_class_name());
-	if (!bind_ptr)
-		bind_ptr = binder->classname_bindings.getptr(p_object->get_parent_class_static());
-	if (!bind_ptr) {
-		bind_ptr = Object::cast_to<RefCounted>(p_object) == NULL ? &binder->godot_object_class : &binder->godot_reference_class;
-#ifdef DEBUG_ENABLED
-		WARN_PRINT("Class " + p_object->get_class_name() + " is not registed to ClassDB");
-#endif
-	}
-	if (bind_ptr) {
-		JSValue obj = JS_NewObjectProtoClass(ctx, (*bind_ptr)->prototype, binder->get_origin_class_id());
-		data->javascript_object = JS_VALUE_GET_PTR(obj);
-		data->context = ctx;
-		data->godot_object = p_object;
-		data->type = Variant::OBJECT;
-		data->flags = JavaScriptGCHandler::FLAG_OBJECT;
-		if (p_object->is_ref_counted()) {
-			if (static_cast<RefCounted *>(p_object)->init_ref()) {
-				data->flags |= JavaScriptGCHandler::FLAG_REF_COUNTED;
-			}
-		}
-		JS_SetOpaque(obj, data);
-#ifdef DUMP_LEAKS
-		add_debug_binding_info(ctx, obj, data);
-		JS_DefinePropertyValueStr(ctx, obj, "__id__", to_js_number(ctx, static_cast<uint64_t>(p_object->get_instance_id())), PROP_DEF_DEFAULT);
-#endif
-		return OK;
-	}
-	return FAILED;
-}
-
-void QuickJSBinder::godot_refcount_incremented(JavaScriptGCHandler *bind) {
-	if (bind->is_valid_javascript_object()) {
-		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
-		JS_DupValue((JSContext *)bind->context, js_obj);
-	}
-}
-
-bool QuickJSBinder::godot_refcount_decremented(JavaScriptGCHandler *bind) {
-	if (bind->is_valid_javascript_object()) {
-		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
-		JS_FreeValue((JSContext *)bind->context, js_obj);
-		return bind->is_finalized();
-	} else {
-		return true;
-	}
-}
-
-JSValue QuickJSBinder::object_constructor(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv, int class_id) {
-	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
-	const ClassBindData &cls = binder->class_bindings.get(class_id);
-	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, new_target);
-	JSValue js_obj;
-	if (bind) {
-		js_obj = new_target;
-	} else {
-		Object *gd_obj = cls.gdclass->creation_func();
-		JavaScriptLanguage *lang = JavaScriptLanguage::get_singleton();
-		bind = new_gc_handler(ctx);
-		bind_gc_object(ctx, bind, gd_obj);
-		gd_obj->set_instance_binding(lang, bind, lang->get_instance_binding_callbacks());
-		js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
-
-		if (JS_IsFunction(ctx, new_target)) {
-			JSValue prototype = JS_GetProperty(ctx, new_target, QuickJSBinder::JS_ATOM_prototype);
-			JS_SetPrototype(ctx, js_obj, prototype);
-			JS_FreeValue(ctx, prototype);
-		}
-
-#if 0
-		// Make script and script instance for the object
-		JavaScriptInstance *si = memnew(JavaScriptInstance);
-		si->javascript_object = *bind;
-		si->binder = binder;
-		si->owner = gd_obj;
-		JSValue js_class_name = JS_GetProperty(ctx, js_obj, binder->js_key_godot_classname);
-		if (JS_IsString(js_class_name)) {
-			if (JavaScriptClassInfo *js_class = binder->javascript_classes.getptr(js_to_string(ctx, js_class_name))) {
-				si->script.instantiate();
-				si->script->javascript_class = js_class;
-				si->script->instances.insert(gd_obj);
-				si->script->javascript_class = js_class;
-				si->javascript_class = js_class;
-				initialize_properties(ctx, js_class, js_obj);
-			}
-		}
-		JS_FreeValue(ctx, js_class_name);
-		gd_obj->set_script_instance(si);
-#endif
-		if (!bind->is_ref_counted()) { // Object need to be freed manually
-			JS_DupValue(ctx, js_obj);
-		}
-	}
-	return js_obj;
-}
-
-void QuickJSBinder::initialize_properties(JSContext *ctx, const JavaScriptClassInfo *p_class, JSValue p_object) {
-	QuickJSBinder *binder = get_context_binder(ctx);
-	for (const KeyValue<StringName, JavaScriptProperyInfo> &pair : p_class->properties) {
-		JSAtom pname = get_atom(ctx, pair.key);
-		int ret = JS_SetProperty(ctx, p_object, pname, variant_to_var(ctx, pair.value.default_value));
-		if (ret < 0) {
-			JSValue e = JS_GetException(ctx);
-			JavaScriptError error;
-			dump_exception(ctx, e, &error);
-			JS_FreeValue(ctx, e);
-			ERR_PRINT(vformat("Cannot initialize property '%s' of class '%s'\n%s", pair.key, p_class->class_name, binder->error_to_string(error)));
-		}
-		JS_FreeAtom(ctx, pname);
-	}
-}
-
-void QuickJSBinder::object_finalizer(JavaScriptGCHandler *p_bind) {
-	p_bind->flags ^= JavaScriptGCHandler::FLAG_OBJECT;
-	if (p_bind->godot_object->is_ref_counted()) {
-		RefCounted *ref = static_cast<RefCounted *>(p_bind->godot_object);
-		if (ref->unreference()) {
-			memdelete(ref);
-		}
-	}
-}
-
-void QuickJSBinder::origin_finalizer(JSRuntime *rt, JSValue val) {
-	QuickJSBinder *binder = get_runtime_binder(rt);
-	JavaScriptGCHandler *bind = static_cast<JavaScriptGCHandler *>(JS_GetOpaque(val, binder->godot_origin_class.class_id));
-	if (bind) {
-		bind->flags |= JavaScriptGCHandler::FLAG_FINALIZED;
-		if (bind->type == Variant::OBJECT) {
-			object_finalizer(bind);
-		} else {
-			binder->builtin_binder.builtin_finalizer(bind);
-		}
-		JS_SetOpaque(val, NULL);
-	}
-}
-
-JSValue QuickJSBinder::object_free(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-	ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "The object already be freed"));
-	ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "The object already be freed"));
-	ERR_FAIL_COND_V(bind->godot_object->is_ref_counted(), JS_ThrowReferenceError(ctx, "Call free to RefCounted object is not allowed"));
-
-	memdelete(bind->godot_object);
-	JS_SetOpaque(this_val, NULL);
-	return JS_UNDEFINED;
-}
-
-/************************* END Memory Management ******************************/
-
-/********************************* Script --> C++ ****************************/
-JSValue QuickJSBinder::godot_register_class(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-	ERR_FAIL_COND_V(argc < 1 || !JS_IsFunction(ctx, argv[0]), JS_ThrowTypeError(ctx, "Godot class expected"));
-	QuickJSBinder *binder = get_context_binder(ctx);
-	String class_name;
-#if NO_MODULE_EXPORT_SUPPORT
-	class_name = binder->parsing_script_file;
-#endif
-	if (class_name.is_empty()) {
-		if (argc > 1 && JS_IsString(argv[1])) {
-			class_name = js_to_string(ctx, argv[1]);
-		} else {
-			JSValue name = JS_GetProperty(ctx, *argv, JS_ATOM_name);
-			class_name = js_to_string(ctx, name);
-			JS_FreeValue(ctx, name);
-		}
-	}
-	binder->register_javascript_class(argv[0], class_name);
-	return JS_UNDEFINED;
-}
-
-const JavaScriptClassInfo *QuickJSBinder::register_javascript_class(const JSValue &p_constructor, const String &p_path) {
-	QuickJSBinder *binder = get_context_binder(ctx);
-	JSValue prototype = JS_UNDEFINED;
-	JSValue classid = JS_UNDEFINED;
-	JSValue tooled = JS_UNDEFINED;
-	JSValue icon = JS_UNDEFINED;
-	JSClassID id = 0;
-
-	if (!JS_IsFunction(ctx, p_constructor)) {
-		JS_ThrowTypeError(ctx, "Godot class expected: %s", p_path.utf8().get_data());
-		goto fail;
-	}
-
-	prototype = JS_GetProperty(ctx, p_constructor, QuickJSBinder::JS_ATOM_prototype);
-	classid = JS_GetProperty(ctx, prototype, js_key_godot_classid);
-	tooled = JS_GetProperty(ctx, p_constructor, js_key_godot_tooled);
-	icon = JS_GetProperty(ctx, p_constructor, js_key_godot_icon_path);
-
-	if (JS_IsUndefined(classid)) {
-		JS_ThrowTypeError(ctx, "Godot class expected: %s", p_path.utf8().get_data());
-		goto fail;
-	}
-
-	id = JS_VALUE_GET_INT(classid);
-	if (const ClassBindData *bind = binder->class_bindings.getptr(id)) {
-		// Add reference to the class function
-		JS_DupValue(ctx, p_constructor);
-
-		JSValue name = JS_GetProperty(ctx, p_constructor, JS_ATOM_name);
-		StringName class_name = js_to_string(ctx, name);
-		JS_FreeValue(ctx, name);
-
-		JavaScriptClassInfo js_class;
-		js_class.icon_path = "";
-		js_class.tool = false;
-		js_class.native_class = bind->gdclass;
-		js_class.class_name = class_name;
-		js_class.prototype.context = ctx;
-		js_class.prototype.javascript_object = JS_VALUE_GET_PTR(prototype);
-		js_class.constructor.context = ctx;
-		js_class.constructor.javascript_object = JS_VALUE_GET_PTR(p_constructor);
-		js_class.tool = JS_ToBool(ctx, tooled);
-		if (JS_IsString(icon)) {
-			js_class.icon_path = js_to_string(ctx, icon);
-		}
-
-		// signals
-		JSValue signals = JS_GetProperty(ctx, prototype, js_key_godot_signals);
-		if (JS_IsObject(signals)) {
-			HashSet<String> keys;
-			get_own_property_names(ctx, signals, &keys);
-			for (const String &key : keys) {
-				MethodInfo mi;
-				mi.name = key;
-				js_class.signals.insert(mi.name, mi);
-			}
-		}
-		JS_FreeValue(ctx, signals);
-
-		// properties
-		JSValue props = JS_GetProperty(ctx, prototype, js_key_godot_exports);
-		if (JS_IsObject(props)) {
-			HashSet<String> keys;
-			get_own_property_names(ctx, props, &keys);
-			for (const String &key : keys) {
-				JavaScriptProperyInfo ei;
-				ei.name = key;
-				ei.type = Variant::NIL;
-				ei.hint = PropertyHint::PROPERTY_HINT_NONE;
-				ei.usage = PropertyUsageFlags::PROPERTY_USAGE_DEFAULT;
-
-				JSAtom pname = get_atom(ctx, key);
-				JSValue js_prop = JS_GetProperty(ctx, props, pname);
-				Variant prop = var_to_variant(ctx, js_prop);
-
-				int found_entry = 0;
-				if (prop.get_type() == Variant::DICTIONARY) {
-					Dictionary prop_info = prop;
-					if (const Variant *ptr = prop_info.getptr("type")) {
-						Variant::Type type = Variant::Type(int(*ptr));
-						if (type > Variant::NIL && type < Variant::VARIANT_MAX) {
-							ei.type = type;
-							found_entry++;
-						}
-					}
-					if (const Variant *ptr = prop_info.getptr("hint")) {
-						PropertyHint hint = PropertyHint(int(*ptr));
-						if (hint > PropertyHint::PROPERTY_HINT_NONE && hint < PropertyHint::PROPERTY_HINT_MAX) {
-							ei.hint = hint;
-							found_entry++;
-						}
-					}
-					if (const Variant *ptr = prop_info.getptr("usage")) {
-						ei.usage = *ptr;
-						found_entry++;
-					}
-					if (const Variant *ptr = prop_info.getptr("hint_string")) {
-						ei.hint_string = *ptr;
-						found_entry++;
-					}
-					if (const Variant *ptr = prop_info.getptr("class_name")) {
-						ei.class_name = *ptr;
-						found_entry++;
-					}
-					if (const Variant *ptr = prop_info.getptr("default")) {
-						ei.default_value = *ptr;
-						found_entry++;
-					}
-				}
-
-				if (found_entry <= 0) {
-					ei.default_value = prop;
-				}
-				if (ei.type == Variant::NIL) {
-					ei.type = ei.default_value.get_type();
-				}
-				JS_FreeAtom(ctx, pname);
-				js_class.properties.insert(key, ei);
-				JS_FreeValue(ctx, js_prop);
-			}
-		}
-		JS_FreeValue(ctx, props);
-
-		// methods
-		HashSet<String> keys;
-		get_own_property_names(ctx, prototype, &keys);
-		for (const String &E : keys) {
-			JSAtom key = get_atom(ctx, E);
-			JSValue value = JS_GetProperty(ctx, prototype, key);
-			if (JS_IsFunction(ctx, value)) {
-				MethodInfo mi;
-				mi.name = E;
-				js_class.methods.insert(E, mi);
-			}
-			JS_FreeValue(ctx, value);
-			JS_FreeAtom(ctx, key);
-		}
-
-		// cache the class
-		if (const JavaScriptClassInfo *ptr = binder->javascript_classes.getptr(p_path)) {
-			binder->free_javascript_class(*ptr);
-		}
-		binder->javascript_classes.insert(p_path, js_class);
-		JS_DefinePropertyValue(ctx, prototype, js_key_godot_classname, to_js_string(ctx, p_path), PROP_DEF_DEFAULT);
-	}
-fail:
-	JS_FreeValue(ctx, classid);
-	JS_FreeValue(ctx, prototype);
-	JS_FreeValue(ctx, icon);
-	JS_FreeValue(ctx, tooled);
-	return binder->javascript_classes.getptr(p_path);
-}
-
-void QuickJSBinder::free_javascript_class(const JavaScriptClassInfo &p_class) {
-	JSValue class_func = JS_MKPTR(JS_TAG_OBJECT, p_class.constructor.javascript_object);
-	JS_FreeValue(ctx, class_func);
-}
-
-JSValue QuickJSBinder::godot_register_signal(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-	ERR_FAIL_COND_V(argc < 2, JS_ThrowTypeError(ctx, "Two or more arguments expected"));
-	ERR_FAIL_COND_V(!JS_IsObject(argv[0]), JS_ThrowTypeError(ctx, "protorype of Godot function expected for agurment 0"));
-	ERR_FAIL_COND_V(!JS_IsString(argv[1]), JS_ThrowTypeError(ctx, "string expected for agurment 1"));
-	QuickJSBinder *binder = get_context_binder(ctx);
-
-	JSValue prototype = JS_UNDEFINED;
-	if (JS_IsFunction(ctx, argv[0])) {
-		prototype = JS_GetProperty(ctx, argv[0], QuickJSBinder::JS_ATOM_prototype);
-	} else {
-		prototype = JS_DupValue(ctx, argv[0]);
-	}
-
-	JSValue object = JS_GetProperty(ctx, prototype, binder->js_key_godot_signals);
-	if (!JS_IsObject(object)) {
-		object = JS_NewObject(ctx);
-	}
-	const char *signal = JS_ToCString(ctx, argv[1]);
-	JS_DupValue(ctx, argv[1]);
-	JS_SetPropertyStr(ctx, object, signal, argv[1]);
-	JS_FreeCString(ctx, signal);
-
-	JS_SetProperty(ctx, prototype, binder->js_key_godot_signals, object);
-	JS_FreeValue(ctx, prototype);
-	return JS_UNDEFINED;
-}
-
-JSValue QuickJSBinder::godot_register_property(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-	ERR_FAIL_COND_V(argc < 3, JS_ThrowTypeError(ctx, "Three or more arguments expected"));
-	ERR_FAIL_COND_V(!JS_IsObject(argv[0]), JS_ThrowTypeError(ctx, "protorype of Godot class function expected for agurment 0"));
-	ERR_FAIL_COND_V(!JS_IsString(argv[1]), JS_ThrowTypeError(ctx, "string expected for agurment 1"));
-
-	QuickJSBinder *binder = get_context_binder(ctx);
-	JSValue prototype = JS_UNDEFINED;
-	if (JS_IsFunction(ctx, argv[0])) {
-		prototype = JS_GetProperty(ctx, argv[0], QuickJSBinder::JS_ATOM_prototype);
-	} else {
-		prototype = JS_DupValue(ctx, argv[0]);
-	}
-
-	JSValue object = JS_GetProperty(ctx, prototype, binder->js_key_godot_exports);
-	if (!JS_IsObject(object)) {
-		object = JS_NewObject(ctx);
-	}
-	const char *name = JS_ToCString(ctx, argv[1]);
-	JS_DupValue(ctx, argv[2]);
-	JS_SetPropertyStr(ctx, object, name, argv[2]);
-	JS_FreeCString(ctx, name);
-
-	JS_SetProperty(ctx, prototype, binder->js_key_godot_exports, object);
-	JS_FreeValue(ctx, prototype);
-
-	return JS_UNDEFINED;
-}
-
-Error QuickJSBinder::define_operators(JSContext *ctx, JSValue p_prototype, JSValue *p_operators, int p_size) {
-	QuickJSBinder *binder = get_context_binder(ctx);
-	JSValue operators = JS_Call(ctx, binder->js_operators_create, binder->js_operators, p_size, p_operators);
-	if (JS_IsException(operators)) {
-		JavaScriptError error;
-		JSValue e = JS_GetException(ctx);
-		dump_exception(ctx, e, &error);
-		JS_FreeValue(ctx, e);
-		ERR_PRINT(binder->error_to_string(error));
-		return FAILED;
-	}
-	JS_DefinePropertyValue(ctx, p_prototype, JS_ATOM_Symbol_operatorSet, operators, PROP_DEF_DEFAULT);
-	return OK;
-}
-
-JSValue QuickJSBinder::godot_set_script_meta(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic) {
-	ERR_FAIL_COND_V(argc < 2, JS_ThrowTypeError(ctx, "Two or more arguments expected"));
-	ERR_FAIL_COND_V(!JS_IsFunction(ctx, argv[0]), JS_ThrowTypeError(ctx, "godot class expected for argument #0"));
-	JSValue constructor = argv[0];
-	QuickJSBinder *binder = get_context_binder(ctx);
-	switch (magic) {
-		case QuickJSBinder::SCRIPT_META_TOOLED:
-			JS_SetProperty(ctx, constructor, binder->js_key_godot_tooled, JS_DupValue(ctx, argv[1]));
-			break;
-		case QuickJSBinder::SCRIPT_META_ICON:
-			JS_SetProperty(ctx, constructor, binder->js_key_godot_icon_path, JS_DupValue(ctx, argv[1]));
-			break;
-	}
-	return JS_UNDEFINED;
-}
-
-JSValue QuickJSBinder::global_request_animation_frame(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-	ERR_FAIL_COND_V(argc < 1 || !JS_IsFunction(ctx, argv[0]), JS_ThrowTypeError(ctx, "Function expected for argument #0"));
-	static SafeNumeric<int64_t> id;
-	JSValue js_func = JS_DupValue(ctx, argv[0]);
-	JavaScriptGCHandler func;
-	func.javascript_object = JS_VALUE_GET_PTR(js_func);
-	QuickJSBinder *binder = get_context_binder(ctx);
-	int64_t value = id.increment();
-	binder->frame_callbacks.insert(value, func);
-	return JS_NewInt64(ctx, value);
-}
-
-JSValue QuickJSBinder::global_cancel_animation_frame(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-	ERR_FAIL_COND_V(argc < 1 || !JS_IsNumber(argv[0]), JS_ThrowTypeError(ctx, "Request ID expected for argument #0"));
-	QuickJSBinder *binder = get_context_binder(ctx);
-	binder->canceled_frame_callbacks.insert(js_to_int64(ctx, argv[0]));
-	return JS_UNDEFINED;
-}
-
-int QuickJSBinder::get_js_array_length(JSContext *ctx, JSValue p_val) {
-	if (!JS_IsArray(ctx, p_val))
-		return -1;
-	JSValue ret = JS_GetProperty(ctx, p_val, JS_ATOM_length);
-	int32_t length = -1;
-	if (JS_ToInt32(ctx, &length, ret))
-		return -1;
-	return length;
-}
-
-void QuickJSBinder::get_own_property_names(JSContext *ctx, JSValue p_object, HashSet<String> *r_list) {
-	ERR_FAIL_COND(!JS_IsObject(p_object));
-	JSPropertyEnum *props = NULL;
-	uint32_t tab_atom_count;
-	JS_GetOwnPropertyNames(ctx, &props, &tab_atom_count, p_object, JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK);
-	for (uint32_t i = 0; i < tab_atom_count; i++) {
-		JSValue key = JS_AtomToValue(ctx, props[i].atom);
-		String name = js_to_string(ctx, key);
-		r_list->insert(name);
-		JS_FreeAtom(ctx, props[i].atom);
-		JS_FreeValue(ctx, key);
-	}
-	js_free_rt(JS_GetRuntime(ctx), props);
-}
-
-JavaScriptGCHandler QuickJSBinder::create_js_instance_for_godot_object(const JavaScriptClassInfo *p_class, Object *p_object) {
-	ERR_FAIL_NULL_V(p_object, JavaScriptGCHandler());
-	ERR_FAIL_NULL_V(p_class, JavaScriptGCHandler());
-
-	JavaScriptGCHandler *bind = BINDING_DATA_FROM_GD(ctx, p_object);
-	ERR_FAIL_NULL_V(bind, JavaScriptGCHandler());
-
-	JSValue constructor = JS_MKPTR(JS_TAG_OBJECT, p_class->constructor.javascript_object);
-	JSValue object = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
-	JS_CallConstructor2(ctx, constructor, object, 0, NULL);
-	if (JS_SetPrototype(ctx, object, JS_MKPTR(JS_TAG_OBJECT, p_class->prototype.javascript_object)) < 0) {
-		JSValue e = JS_GetException(ctx);
-		JavaScriptError error;
-		dump_exception(ctx, e, &error);
-		JS_FreeValue(ctx, e);
-		bind->javascript_object = NULL;
-		ERR_FAIL_V_MSG(*bind, vformat("Cannot create instance from Godot class '%s'\n%s", p_class->class_name, error_to_string(error)));
-	}
-	initialize_properties(ctx, p_class, object);
-	return *bind;
-}
-
-Variant QuickJSBinder::call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
-	JSValue object = GET_JSVALUE(p_object);
-	JSAtom atom = get_atom(ctx, p_method);
-	JSValue method = JS_GetProperty(ctx, object, atom);
-	JS_FreeAtom(ctx, atom);
-	JavaScriptGCHandler func;
-	func.javascript_object = JS_VALUE_GET_PTR(method);
-	Variant ret = call(func, p_object, p_args, p_argcount, r_error);
-	JS_FreeValue(ctx, method);
-	return ret;
-}
-
-Variant QuickJSBinder::call(const JavaScriptGCHandler &p_fuction, const JavaScriptGCHandler &p_target, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
-	JSValue return_val = JS_UNDEFINED;
-	JSValue *argv = NULL;
-	JSValue method = JS_MKPTR(JS_TAG_OBJECT, p_fuction.javascript_object);
-	JSValue object = p_target.is_valid_javascript_object() ? JS_MKPTR(JS_TAG_OBJECT, p_target.javascript_object) : JS_UNDEFINED;
-
-	if (!JS_IsFunction(ctx, method) || JS_IsPureCFunction(ctx, method)) {
-		r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
-		goto finish;
-	}
-
-	argv = memnew_arr(JSValue, p_argcount);
-	for (int i = 0; i < p_argcount; ++i) {
-		argv[i] = variant_to_var(ctx, *p_args[i]);
-	}
-	return_val = JS_Call(ctx, method, object, p_argcount, argv);
-
-	if (JS_IsException(return_val)) {
-		r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
-		JSValue exception = JS_GetException(ctx);
-		JavaScriptError err;
-		dump_exception(ctx, exception, &err);
-		ERR_PRINT(error_to_string(err));
-		JS_Throw(ctx, exception);
-	} else {
-		r_error.error = Callable::CallError::CALL_OK;
-	}
-finish:
-	Variant ret = var_to_variant(ctx, return_val);
-	if (argv) {
-		for (int i = 0; i < p_argcount; i++) {
-			JS_FreeValue(ctx, argv[i]);
-		}
-		memdelete_arr(argv);
-	}
-	JS_FreeValue(ctx, return_val);
-	return ret;
-}
-
-bool QuickJSBinder::get_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) {
-	bool success = false;
-	JSValue obj = GET_JSVALUE(p_object);
-	JSAtom atom = get_atom(ctx, p_name);
-	JSValue ret = JS_GetProperty(ctx, obj, atom);
-	JS_FreeAtom(ctx, atom);
-	r_ret = var_to_variant(ctx, ret);
-	success = !JS_IsUndefined(ret);
-	JS_FreeValue(ctx, ret);
-	return success;
-}
-
-bool QuickJSBinder::set_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) {
-	JSValue obj = GET_JSVALUE(p_object);
-	JSAtom atom = get_atom(ctx, p_name);
-	bool success = JS_SetProperty(ctx, obj, atom, variant_to_var(ctx, p_value));
-	JS_FreeAtom(ctx, atom);
-	return success;
-}
-
-bool QuickJSBinder::has_method(const JavaScriptGCHandler &p_object, const StringName &p_name) {
-	JSValue obj = GET_JSVALUE(p_object);
-	ERR_FAIL_COND_V(!JS_IsObject(obj), false);
-	JSAtom atom = get_atom(ctx, p_name);
-	JSValue value = JS_GetProperty(ctx, GET_JSVALUE(p_object), atom);
-	bool success = JS_IsFunction(ctx, value);
-	JS_FreeAtom(ctx, atom);
-	JS_FreeValue(ctx, value);
-	return success;
-}
-
-const JavaScriptClassInfo *QuickJSBinder::parse_javascript_class(const String &p_code, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) {
-	if (!ignore_cacehe) {
-		if (const JavaScriptClassInfo *cls = javascript_classes.getptr(p_path)) {
-			return cls;
-		}
-	}
-	JavaScriptError err;
-	ModuleCache *mc = js_compile_and_cache_module(ctx, p_code, p_path, r_error);
-	return parse_javascript_class_from_module(mc, p_path, r_error);
-}
-
-const JavaScriptClassInfo *QuickJSBinder::parse_javascript_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) {
-	if (!ignore_cacehe) {
-		if (const JavaScriptClassInfo *cls = javascript_classes.getptr(p_path)) {
-			return cls;
-		}
-	}
-	ModuleCache *mc = js_compile_and_cache_module(ctx, p_bytecode, p_path, r_error);
-	ERR_FAIL_NULL_V(mc, NULL);
-	return parse_javascript_class_from_module(mc, p_path, r_error);
-}
-
-const JavaScriptClassInfo *QuickJSBinder::parse_javascript_class_from_module(ModuleCache *p_module, const String &p_path, JavaScriptError *r_error) {
-	ERR_FAIL_COND_V(p_module == NULL || p_module->module == NULL, NULL);
-
-	const JavaScriptClassInfo *js_class = NULL;
-	JSValue default_entry = JS_UNDEFINED;
-	if (OK != js_evalute_module(ctx, p_module, r_error)) {
-		goto fail;
-	}
-
-	for (int i = 0; i < JS_GetModuleExportEntriesCount(p_module->module); i++) {
-		JSAtom name = JS_GetModuleExportEntryName(ctx, p_module->module, i);
-		if (name == JS_ATOM_default) {
-			default_entry = JS_GetModuleExportEntry(ctx, p_module->module, i);
-			JS_FreeAtom(ctx, name);
-			break;
-		}
-		JS_FreeAtom(ctx, name);
-	}
-	if (!JS_IsFunction(ctx, default_entry)) {
-		String err = "Failed parse Godot class from script " + p_path + ENDL "\t" + "Default export entry must be a godot class!";
-		ERR_PRINT(err);
-		JS_ThrowTypeError(ctx, "%s", err.utf8().get_data());
-		goto fail;
-	}
-	js_class = register_javascript_class(default_entry, p_path);
-fail:
-	JS_FreeValue(ctx, default_entry);
-	return js_class;
-}
-
-bool QuickJSBinder::has_signal(const JavaScriptClassInfo *p_class, const StringName &p_signal) {
-	ERR_FAIL_NULL_V(p_class, false);
-	bool found = false;
-	JSValue object = JS_GetProperty(ctx, GET_JSVALUE(p_class->prototype), js_key_godot_signals);
-	if (!JS_IsObject(object)) {
-		JS_FreeValue(ctx, object);
-		return false;
-	}
-	JSAtom atom = get_atom(ctx, p_signal);
-	JSValue signal = JS_GetProperty(ctx, object, atom);
-	found = !JS_IsUndefined(signal);
-	JS_FreeAtom(ctx, atom);
-	JS_FreeValue(ctx, signal);
-	JS_FreeValue(ctx, object);
-	return found;
-}
-/**************************** END Script --> C++ ******************************/
-
-/********************************** Worker *************************************/
-JSValue QuickJSBinder::worker_constructor(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-	ERR_FAIL_COND_V(argc < 1 || !JS_IsString(argv[0]), JS_ThrowTypeError(ctx, "script path expected for argument #0"));
-	QuickJSBinder *host = QuickJSBinder::get_context_binder(ctx);
-
-	QuickJSWorker *worker = memnew(QuickJSWorker(host));
-	worker->start(js_to_string(ctx, argv[0]));
-	JSValue obj = JS_NewObjectProtoClass(ctx, host->worker_class_data.prototype, host->worker_class_data.class_id);
-
-	JavaScriptGCHandler *data = host->new_gc_handler(ctx);
-	data->native_ptr = worker;
-	data->javascript_object = JS_VALUE_GET_PTR(obj);
-	JS_SetOpaque(obj, data);
-	host->workers.push_back(data);
-
-	return obj;
-}
-
-void QuickJSBinder::worker_finializer(JSRuntime *rt, JSValue val) {
-	QuickJSBinder *host = QuickJSBinder::get_runtime_binder(rt);
-	if (JavaScriptGCHandler *bind = static_cast<JavaScriptGCHandler *>(JS_GetOpaque(val, host->worker_class_data.class_id))) {
-		QuickJSWorker *worker = static_cast<QuickJSWorker *>(bind->native_ptr);
-		worker->stop();
-		if (List<JavaScriptGCHandler *>::Element *E = host->workers.find(bind)) {
-			host->workers.erase(E);
-		}
-		memdelete(worker);
-		memdelete(bind);
-	}
-}
-
-JSValue QuickJSBinder::worker_post_message(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-	ERR_FAIL_COND_V(argc < 1, JS_ThrowTypeError(ctx, "message value expected of argument #0"));
-	QuickJSBinder *host = QuickJSBinder::get_context_binder(ctx);
-	if (JavaScriptGCHandler *bind = static_cast<JavaScriptGCHandler *>(JS_GetOpaque(this_val, host->worker_class_data.class_id))) {
-		QuickJSWorker *worker = static_cast<QuickJSWorker *>(bind->native_ptr);
-		worker->post_message_from_host(var_to_variant(ctx, argv[0]));
-	}
-	return JS_UNDEFINED;
-}
-
-JSValue QuickJSBinder::worker_terminate(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-	QuickJSBinder *host = QuickJSBinder::get_context_binder(ctx);
-	if (JavaScriptGCHandler *bind = static_cast<JavaScriptGCHandler *>(JS_GetOpaque(this_val, host->worker_class_data.class_id))) {
-		QuickJSWorker *worker = static_cast<QuickJSWorker *>(bind->native_ptr);
-		if (List<JavaScriptGCHandler *>::Element *E = host->workers.find(bind)) {
-			host->workers.erase(E);
-		}
-		worker->stop();
-	}
-	return JS_UNDEFINED;
-}
-
-JSValue QuickJSBinder::godot_abandon_value(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-	ERR_FAIL_COND_V(argc != 1, JS_ThrowTypeError(ctx, "one argument expected"));
-	JSValue &value = argv[0];
-	bool valid = true;
-	Variant gd_value = var_to_variant(ctx, value);
-	if (gd_value.get_type() == Variant::OBJECT) {
-		JavaScriptGCHandler *data = BINDING_DATA_FROM_JS(ctx, value);
-		if (data) {
-			JS_SetOpaque(value, NULL);
-			if (data->is_ref_counted()) {
-				static_cast<RefCounted *>(data->godot_object)->unreference();
-			} else if (data->is_object()) {
-				JS_FreeValue(ctx, value);
-			}
-			data->godot_object = NULL;
-			data->javascript_object = NULL;
-			data->context = NULL;
-			data->flags |= JavaScriptGCHandler::FLAG_TRANSFERABLE;
-		} else {
-			valid = false;
-		}
-	}
-
-	uint64_t id = 0;
-	if (valid) {
-		id = QuickJSBinder::global_transfer_id.increment();
-		GLOBAL_LOCK_FUNCTION
-		transfer_deopot.insert(id, gd_value);
-	}
-	return JS_NewInt64(ctx, id);
-}
-
-JSValue QuickJSBinder::godot_adopt_value(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
-	ERR_FAIL_COND_V(argc != 1 || !JS_IsNumber(argv[0]), JS_ThrowTypeError(ctx, "value id expected"));
-	int64_t id = js_to_int64(ctx, argv[0]);
-	ERR_FAIL_COND_V(id == 0, JS_ThrowTypeError(ctx, "id must greater than 0"));
-
-	Variant value;
-	{
-		GLOBAL_LOCK_FUNCTION
-		if (Variant *ptr = transfer_deopot.getptr(id)) {
-			value = *ptr;
-			transfer_deopot.erase(id);
-		}
-	}
-	ERR_FAIL_NULL_V(static_cast<Object *>(value), JS_UNDEFINED);
-	return variant_to_var(ctx, value);
-}
-
-void QuickJSBinder::add_global_worker() {
-	worker_class_data.gdclass = NULL;
-	worker_class_data.class_id = 0;
-	worker_class_data.base_class = NULL;
-	worker_class_data.class_name = "Worker";
-	worker_class_data.jsclass.class_name = "Worker";
-	worker_class_data.jsclass.finalizer = worker_finializer;
-	worker_class_data.jsclass.exotic = NULL;
-	worker_class_data.jsclass.gc_mark = NULL;
-	worker_class_data.jsclass.call = NULL;
-	worker_class_data.gdclass = NULL;
-	worker_class_data.prototype = JS_NewObject(ctx);
-	worker_class_data.constructor = JS_NewCFunction2(ctx, worker_constructor, worker_class_data.jsclass.class_name, worker_class_data.class_name.size(), JS_CFUNC_constructor, 0);
-
-	// Worker.prototype.onmessage
-	JS_SetPropertyStr(ctx, worker_class_data.prototype, "onmessage", JS_NULL);
-	// Worker.prototype.postMessage
-	JSValue post_message_func = JS_NewCFunction(ctx, worker_post_message, "postMessage", 1);
-	JS_DefinePropertyValueStr(ctx, worker_class_data.prototype, "postMessage", post_message_func, PROP_DEF_DEFAULT);
-	// Worker.prototype.terminate
-	JSValue terminate_func = JS_NewCFunction(ctx, worker_terminate, "terminate", 1);
-	JS_DefinePropertyValueStr(ctx, worker_class_data.prototype, "terminate", terminate_func, PROP_DEF_DEFAULT);
-
-	JS_NewClassID(&worker_class_data.class_id);
-	JS_NewClass(JS_GetRuntime(ctx), worker_class_data.class_id, &worker_class_data.jsclass);
-	JS_SetClassProto(ctx, worker_class_data.class_id, worker_class_data.prototype);
-	JS_SetConstructor(ctx, worker_class_data.constructor, worker_class_data.prototype);
-	JS_DefinePropertyValueStr(ctx, global_object, "Worker", worker_class_data.constructor, PROP_DEF_DEFAULT);
-}
-
-/********************************* END Worker **********************************/
-
-bool QuickJSBinder::validate(const String &p_code, const String &p_path, JavaScriptError *r_error) {
-	ModuleCache *module = js_compile_and_cache_module(ctx, p_code, p_path, r_error);
-	return module != NULL;
-}
diff --git a/quickjs/quickjs_binder.h b/quickjs/quickjs_binder.h
deleted file mode 100644
index 1be30191..00000000
--- a/quickjs/quickjs_binder.h
+++ /dev/null
@@ -1,350 +0,0 @@
-#ifndef QUICKJS_BINDING_HELPER_H
-#define QUICKJS_BINDING_HELPER_H
-
-#include "../javascript_binder.h"
-#include "./quickjs/quickjs.h"
-
-#ifdef QUICKJS_WITH_DEBUGGER
-#include "quickjs_debugger.h"
-#endif
-#include "core/os/memory.h"
-#include "core/os/thread.h"
-#include "core/io/resource.h"
-#include "core/variant/callable.h"
-#include "quickjs_builtin_binder.h"
-#define JS_HIDDEN_SYMBOL(x) ("\xFF" x)
-#define BINDING_DATA_FROM_JS(ctx, p_val) (JavaScriptGCHandler *)JS_GetOpaque((p_val), QuickJSBinder::get_origin_class_id((ctx)))
-#define GET_JSVALUE(p_gc_handler) JS_MKPTR(JS_TAG_OBJECT, (p_gc_handler).javascript_object)
-#define NO_MODULE_EXPORT_SUPPORT 0
-#define MODULE_HAS_REFCOUNT 0 // module seems don't follow the refrence count rule in quickjs
-#define MAX_ARGUMENT_COUNT 50
-#define PROP_NAME_CONSOLE_LOG_OBJECT_TO_JSON "LOG_OBJECT_TO_JSON"
-#define ENDL "\r\n"
-
-class QuickJSWorker;
-class QuickJSBinder : public JavaScriptBinder {
-
-	friend class QuickJSBuiltinBinder;
-	friend class QuickJSWorker;
-	QuickJSBuiltinBinder builtin_binder;
-
-protected:
-	static SafeNumeric<uint32_t> global_context_id;
-	static SafeNumeric<uint64_t> global_transfer_id;
-	JSRuntime *runtime;
-	JSContext *ctx;
-	JSMallocFunctions godot_allocator;
-	uint32_t context_id;
-	Thread::ID thread_id;
-#ifdef QUICKJS_WITH_DEBUGGER
-	Ref<QuickJSDebugger> debugger;
-#endif
-
-public:
-	struct PtrHasher {
-		static _FORCE_INLINE_ uint32_t hash(const void *p_ptr) {
-			union {
-				const void *p;
-				uint64_t i;
-			} u;
-			u.p = p_ptr;
-			return HashMapHasherDefault::hash(u.i);
-		}
-	};
-
-	enum JavaScriptModuleFlags {
-		MODULE_FLAG_SCRIPT = 1,
-		MODULE_FLAG_NATIVE = 2,
-		MODULE_FLAG_EVALUATED = 1 << 3,
-		MODULE_FLAG_RESOURCE = 1 << 4,
-	};
-
-	struct ModuleCache {
-		int flags = 0;
-		JSModuleDef *module = NULL;
-		uint32_t hash = 0;
-		JSValue res_value;
-		Ref<Resource> res;
-	};
-
-	struct CommonJSModule {
-		int flags;
-		JSValue exports;
-		String md5;
-		Ref<Resource> res;
-	};
-
-	enum {
-		PROP_DEF_DEFAULT = JS_PROP_ENUMERABLE | JS_PROP_CONFIGURABLE,
-	};
-
-	enum {
-		__JS_ATOM_NULL = JS_ATOM_NULL,
-#if !defined(EMSCRIPTEN)
-#define CONFIG_ATOMICS
-#endif
-#define DEF(name, str) JS_ATOM_##name,
-#include "quickjs/quickjs-atom.h"
-#undef DEF
-#ifdef CONFIG_ATOMICS
-#undef CONFIG_ATOMICS
-#endif
-		JS_ATOM_END,
-	};
-
-	enum ConsoleLogType {
-		CONSOLE_LOG,
-		CONSOLE_WARN,
-		CONSOLE_ERROR,
-		CONSOLE_TRACE,
-	};
-
-protected:
-	JSAtom js_key_godot_classid;
-	JSAtom js_key_godot_classname;
-	JSAtom js_key_godot_tooled;
-	JSAtom js_key_godot_icon_path;
-	JSAtom js_key_godot_exports;
-	JSAtom js_key_godot_signals;
-
-	JSValue global_object;
-	JSValue godot_object;
-	JSValue console_object;
-	JSValue empty_function;
-	JSValue js_operators;
-	JSValue js_operators_create;
-	Vector<JSValue> godot_singletons;
-
-	_FORCE_INLINE_ static void *js_binder_malloc(JSMallocState *s, size_t size) { return memalloc(size); }
-	_FORCE_INLINE_ static void js_binder_free(JSMallocState *s, void *ptr) {
-		if (ptr) memfree(ptr);
-	}
-	_FORCE_INLINE_ static void *js_binder_realloc(JSMallocState *s, void *ptr, size_t size) { return memrealloc(ptr, size); }
-
-	static String resolve_module_file(const String &file);
-	static JSModuleDef *js_module_loader(JSContext *ctx, const char *module_name, void *opaque);
-	static JSModuleDef *js_make_module(JSContext *ctx, const String &p_id, const JSValueConst &p_value);
-	ModuleCache *js_compile_and_cache_module(JSContext *ctx, const String &p_code, const String &p_filename, JavaScriptError *r_error);
-	ModuleCache *js_compile_and_cache_module(JSContext *ctx, const Vector<uint8_t> &p_bytecode, const String &p_filename, JavaScriptError *r_error);
-	ModuleCache js_compile_module(JSContext *ctx, const String &p_code, const String &p_filename, JavaScriptError *r_error);
-	static Error js_evalute_module(JSContext *ctx, ModuleCache *p_module, JavaScriptError *r_error);
-	static int resource_module_initializer(JSContext *ctx, JSModuleDef *m);
-
-	struct ClassBindData {
-		JSClassID class_id;
-		CharString class_name;
-		JSValue prototype;
-		JSValue constructor;
-		JSClassDef jsclass;
-		const ClassDB::ClassInfo *gdclass;
-		const ClassBindData *base_class;
-	};
-	ClassBindData godot_origin_class;
-	const ClassBindData *godot_object_class;
-	const ClassBindData *godot_reference_class;
-	HashMap<JSClassID, ClassBindData> class_bindings;
-	HashMap<StringName, const ClassBindData *> classname_bindings;
-	HashMap<String, ModuleCache> module_cache;
-	HashMap<String, CommonJSModule> commonjs_module_cache;
-	ClassBindData worker_class_data;
-	List<JavaScriptGCHandler *> workers;
-	Vector<MethodBind *> godot_methods;
-	int internal_godot_method_id;
-	Vector<const ClassDB::PropertySetGet *> godot_object_indexed_properties;
-	int internal_godot_indexed_property_id;
-#if NO_MODULE_EXPORT_SUPPORT
-	String parsing_script_file;
-#endif
-
-	JSClassID register_class(const ClassDB::ClassInfo *p_cls);
-	void add_godot_origin();
-	void add_godot_classes();
-	void add_godot_globals();
-	void add_global_console();
-	void add_global_properties();
-	void add_global_worker();
-
-	static JSValue object_constructor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int class_id);
-	static void initialize_properties(JSContext *ctx, const JavaScriptClassInfo *p_class, JSValue p_object);
-
-	static void object_finalizer(JavaScriptGCHandler *p_bind);
-	static void origin_finalizer(JSRuntime *rt, JSValue val);
-
-	static JSValue object_free(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-	static JSValue object_method(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int method_id);
-	static JSValue object_indexed_property(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int property_id);
-	static JSValue godot_to_string(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-	static JSValue godot_get_type(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-	static JSValue godot_load(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-	static JSValue godot_instance_from_id(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-
-	static JSValue godot_object_method_connect(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-
-	static void add_debug_binding_info(JSContext *ctx, JSValueConst p_obj, const JavaScriptGCHandler *p_bind);
-
-	const JavaScriptClassInfo *register_javascript_class(const JSValueConst &p_constructor, const String &p_path);
-	void free_javascript_class(const JavaScriptClassInfo &p_class);
-	static JSValue godot_register_class(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-	static JSValue godot_register_signal(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-	static JSValue godot_register_property(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-
-	enum {
-		SCRIPT_META_TOOLED,
-		SCRIPT_META_ICON,
-	};
-	static JSValue godot_set_script_meta(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic);
-
-	static JSValue console_functions(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic);
-	static JSValue global_request_animation_frame(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-	static JSValue global_cancel_animation_frame(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-
-	static JSValue worker_constructor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-	static void worker_finializer(JSRuntime *rt, JSValue val);
-	static JSValue worker_post_message(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-	static JSValue worker_terminate(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-	static JSValue godot_abandon_value(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-	static JSValue godot_adopt_value(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
-
-	_FORCE_INLINE_ static JSValue js_empty_func(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { return JS_UNDEFINED; }
-	_FORCE_INLINE_ static JSValue js_empty_consturctor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { return JS_NewObject(ctx); }
-	static JSValue godot_builtin_function(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic);
-
-	static int get_js_array_length(JSContext *ctx, JSValue p_val);
-	static void get_own_property_names(JSContext *ctx, JSValue p_object, HashSet<String> *r_list);
-
-	static JSAtom get_atom(JSContext *ctx, const StringName &p_key);
-	static HashMap<uint64_t, Variant> transfer_deopot;
-	static HashMap<String, const char *> class_remap;
-#ifdef TOOLS_ENABLED
-	Dictionary modified_api;
-#endif
-public:
-	static Error define_operators(JSContext *ctx, JSValue p_prototype, JSValue *p_operators, int p_size);
-
-public:
-	static JSValue variant_to_var(JSContext *ctx, const Variant p_var);
-	static Variant var_to_variant(JSContext *ctx, JSValue p_val);
-	static bool validate_type(JSContext *ctx, Variant::Type p_type, JSValueConst &p_val);
-	static void dump_exception(JSContext *ctx, const JSValueConst &p_exception, JavaScriptError *r_error);
-	virtual String error_to_string(const JavaScriptError &p_error) override;
-	virtual Error get_stacks(List<JavaScriptStackInfo> &r_stacks) override;
-	virtual String get_backtrace_message(const List<JavaScriptStackInfo> &stacks) override;
-
-	static Dictionary js_to_dictionary(JSContext *ctx, const JSValueConst &p_val, List<void *> &stack);
-
-	_FORCE_INLINE_ static real_t js_to_number(JSContext *ctx, const JSValueConst &p_val) {
-		double_t v = 0;
-		JS_ToFloat64(ctx, &v, p_val);
-		return real_t(v);
-	}
-	_FORCE_INLINE_ static String js_to_string(JSContext *ctx, const JSValueConst &p_val) {
-		String ret;
-		size_t len = 0;
-		const char *utf8 = JS_ToCStringLen(ctx, &len, p_val);
-		ret.parse_utf8(utf8, len);
-		JS_FreeCString(ctx, utf8);
-		return ret;
-	}
-	_FORCE_INLINE_ static bool js_to_bool(JSContext *ctx, const JSValueConst &p_val) {
-		return JS_ToBool(ctx, p_val);
-	}
-	_FORCE_INLINE_ static int32_t js_to_int(JSContext *ctx, const JSValueConst &p_val) {
-		int32_t i;
-		JS_ToInt32(ctx, &i, p_val);
-		return i;
-	}
-	_FORCE_INLINE_ static uint32_t js_to_uint(JSContext *ctx, const JSValueConst &p_val) {
-		uint32_t u;
-		JS_ToUint32(ctx, &u, p_val);
-		return u;
-	}
-	_FORCE_INLINE_ static int64_t js_to_int64(JSContext *ctx, const JSValueConst &p_val) {
-		int64_t i;
-		JS_ToInt64(ctx, &i, p_val);
-		return i;
-	}
-	_FORCE_INLINE_ static uint64_t js_to_uint64(JSContext *ctx, const JSValueConst &p_val) {
-		uint64_t i;
-		JS_ToIndex(ctx, &i, p_val);
-		return i;
-	}
-	_FORCE_INLINE_ static JSValue to_js_number(JSContext *ctx, real_t p_val) {
-		return JS_NewFloat64(ctx, double(p_val));
-	}
-	_FORCE_INLINE_ static JSValue to_js_string(JSContext *ctx, const String &text) {
-		CharString utf8 = text.utf8();
-		return JS_NewStringLen(ctx, utf8.get_data(), utf8.length());
-	}
-	_FORCE_INLINE_ static JSValue to_js_bool(JSContext *ctx, bool p_val) {
-		return JS_NewBool(ctx, p_val);
-	}
-
-public:
-	QuickJSBinder();
-	virtual ~QuickJSBinder();
-
-	_FORCE_INLINE_ static QuickJSBinder *get_context_binder(JSContext *ctx) {
-		return static_cast<QuickJSBinder *>(JS_GetContextOpaque(ctx));
-	}
-
-	virtual JavaScriptBinder *get_context_binder(void *p_context) override {
-		return QuickJSBinder::get_context_binder((JSContext *)p_context);
-	}
-
-	virtual Thread::ID get_thread_id() const override { return thread_id; }
-
-	_FORCE_INLINE_ static QuickJSBinder *get_runtime_binder(JSRuntime *rt) {
-		return static_cast<QuickJSBinder *>(JS_GetMollocState(rt)->opaque);
-	}
-
-	_FORCE_INLINE_ static JavaScriptGCHandler *new_gc_handler(JSContext *ctx) {
-		JavaScriptGCHandler *h = memnew(JavaScriptGCHandler);
-		h->context = ctx;
-		return h;
-	}
-
-	_FORCE_INLINE_ QuickJSBuiltinBinder &get_builtin_binder() { return builtin_binder; }
-
-	_FORCE_INLINE_ JSClassID get_origin_class_id() { return godot_origin_class.class_id; }
-	_FORCE_INLINE_ const ClassBindData get_origin_class() const { return godot_origin_class; }
-	_FORCE_INLINE_ static JSClassID get_origin_class_id(JSContext *ctx) { return get_context_binder(ctx)->godot_origin_class.class_id; }
-
-	virtual void initialize() override;
-	virtual void uninitialize() override;
-	virtual void language_finalize() override;
-	virtual void frame() override;
-
-	virtual JavaScriptGCHandler *alloc_object_binding_data(Object *p_object) override;
-	virtual void free_object_binding_data(JavaScriptGCHandler *p_gc_handle) override;
-	virtual void godot_refcount_incremented(JavaScriptGCHandler *p_gc_handle) override;
-	virtual bool godot_refcount_decremented(JavaScriptGCHandler *p_gc_handle) override;
-
-	static Error bind_gc_object(JSContext *ctx, JavaScriptGCHandler *data, Object *p_object);
-
-	virtual Error eval_string(const String &p_source, EvalType type, const String &p_path, JavaScriptGCHandler &r_ret) override;
-	virtual Error safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, JavaScriptGCHandler &r_ret) override;
-
-	virtual Error compile_to_bytecode(const String &p_code, const String &p_file, Vector<uint8_t> &r_bytecode) override;
-	virtual Error load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, JavaScriptGCHandler *r_module) override;
-
-	virtual const JavaScriptClassInfo *parse_javascript_class(const String &p_code, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) override;
-	virtual const JavaScriptClassInfo *parse_javascript_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) override;
-	const JavaScriptClassInfo *parse_javascript_class_from_module(ModuleCache *p_module, const String &p_path, JavaScriptError *r_error);
-
-	virtual JavaScriptGCHandler create_js_instance_for_godot_object(const JavaScriptClassInfo *p_class, Object *p_object) override;
-
-	virtual bool get_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) override;
-	virtual bool set_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) override;
-	virtual bool has_method(const JavaScriptGCHandler &p_object, const StringName &p_name) override;
-	virtual bool has_signal(const JavaScriptClassInfo *p_class, const StringName &p_signal) override;
-	virtual bool validate(const String &p_code, const String &p_path, JavaScriptError *r_error) override;
-
-	virtual Variant call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override;
-	virtual Variant call(const JavaScriptGCHandler &p_fuction, const JavaScriptGCHandler &p_target, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override;
-
-#ifdef TOOLS_ENABLED
-	virtual const Dictionary &get_modified_api() const override { return modified_api; }
-#endif
-};
-
-#endif // QUICKJS_BINDING_HELPER_H
diff --git a/register_types.cpp b/register_types.cpp
index 8b5781f2..4fa75f15 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -1,32 +1,32 @@
-/*************************************************************************/
-/*  register_types.cpp                                                   */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
+/**************************************************************************/
+/*  register_types.cpp                                                    */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
 
 #include "register_types.h"
 #include "javascript.h"
diff --git a/register_types.h b/register_types.h
index c81b4a71..18785d49 100644
--- a/register_types.h
+++ b/register_types.h
@@ -1,38 +1,38 @@
-/*************************************************************************/
-/*  register_types.h                                                     */
-/*************************************************************************/
-/*                       This file is part of:                           */
-/*                           GODOT ENGINE                                */
-/*                      https://godotengine.org                          */
-/*************************************************************************/
-/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
-/*                                                                       */
-/* Permission is hereby granted, free of charge, to any person obtaining */
-/* a copy of this software and associated documentation files (the       */
-/* "Software"), to deal in the Software without restriction, including   */
-/* without limitation the rights to use, copy, modify, merge, publish,   */
-/* distribute, sublicense, and/or sell copies of the Software, and to    */
-/* permit persons to whom the Software is furnished to do so, subject to */
-/* the following conditions:                                             */
-/*                                                                       */
-/* The above copyright notice and this permission notice shall be        */
-/* included in all copies or substantial portions of the Software.       */
-/*                                                                       */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
-/*************************************************************************/
+/**************************************************************************/
+/*  register_types.h                                                      */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
 
-#ifndef JAVASCRIPT_MODULE_H
-#define JAVASCRIPT_MODULE_H
+#ifndef JAVASCRIPT_REGISTER_TYPES_H
+#define JAVASCRIPT_REGISTER_TYPES_H
 
 #include "modules/register_module_types.h"
 void initialize_javascript_module(ModuleInitializationLevel p_level);
 void uninitialize_javascript_module(ModuleInitializationLevel p_level);
 
-#endif
+#endif // JAVASCRIPT_REGISTER_TYPES_H
diff --git a/tests/UnitTest.js.disable b/tests/UnitTest.js.disable
new file mode 100644
index 00000000..c9699d38
--- /dev/null
+++ b/tests/UnitTest.js.disable
@@ -0,0 +1,100 @@
+// @ts-nocheck
+const TEST_ENTRIES = new Map();
+
+
+test('godot', typeof godot === 'object', 'core');
+test('new Object', () => {
+	let obj = new godot.Object();
+	let ok = obj && obj instanceof godot.Object;
+	obj.free();
+	return ok;
+}, 'core');
+
+test('new Resource', () => {
+	let obj = new godot.Resource();
+	let ok = obj && obj.get_class() === 'Resource';
+	return ok;
+}, 'core');
+
+test('Object.prototype.get_class', () => {
+	let obj = new godot.Object();
+	let ok = obj.get_class() === 'Object';
+	obj.free();
+	return ok;
+}, 'core')
+
+test('Object.prototype.connect', () => {
+	let ok = typeof godot.Object.prototype.connect === 'function';
+	if (!ok) return ok;
+
+	let obj = new godot.Object();
+	obj.connect('script_changed', (...args)=> {
+		console.log(`signal 'script_changed' emited with:`, ...args);
+		ok = true;
+	});
+	obj.emit_signal('script_changed', 123, 'hello');
+	obj.free();
+	return ok;
+}, 'core')
+
+
+// --------------------------- Unit Test Implementation ------------------------
+function test(description, blcok, group = 'default') {
+	const entries = TEST_ENTRIES.get(group) || [];
+	entries.push({ description, blcok });
+	TEST_ENTRIES.set(group, entries);
+}
+function runEntry(entry) {
+	return new Promise((resolve, reject) => {
+		switch (typeof (entry.blcok)) {
+			case 'boolean':
+				return resolve(entry.blcok);
+			case 'function': {
+				try {
+					resolve(entry.blcok());
+				} catch (error) {
+					console.error(error);
+					resolve(false);
+				}
+			}
+			break;
+			case 'object':
+				if (entry.blcok instanceof Promise) {
+					entry.blcok.then(() => {
+						resolve(true);
+					}).catch(err => {
+						resolve(false);
+					});
+				}
+				break;
+			default:
+				return resolve(false);
+		}
+	});
+}
+async function run() {
+	let count = 0;
+	let passed = 0;
+	for (const [group, entries] of TEST_ENTRIES) {
+		console.log(`Start test ${group}`);
+		count += entries.length;
+		let groupCount = 0;
+		for (let i = 0; i < entries.length; i++) {
+			const entry = entries[i];
+			const ret = await runEntry(entry);
+			if (ret) {
+				passed++;
+				groupCount++;
+				console.log(`\t[${i + 1}/${entries.length}][ √ ] ${entry.description}`);
+			}
+			else {
+				console.error(`\t[${i + 1}/${entries.length}][ X ] ${entry.description}`);
+			}
+		}
+		const logFunc2 = groupCount == entries.length ? console.log : console.warn;
+		logFunc2(`\tTest ${group} finished: ${groupCount}/${entries.length} passed`);
+	}
+	const logFunc = passed == count ? console.log : console.warn;
+	logFunc(`Test complete: ${passed}/${count} passed`);
+}
+const _ = run(); // QuickJS BUG ? 返回的是一个 Promise 对象，不赋给临时变量，会导致 Promise 对象无法被 GC
diff --git a/quickjs/builtin_binding_generator.py b/thirdparty/quickjs/builtin_binding_generator.py
similarity index 50%
rename from quickjs/builtin_binding_generator.py
rename to thirdparty/quickjs/builtin_binding_generator.py
index 3d47b953..7c94f799 100644
--- a/quickjs/builtin_binding_generator.py
+++ b/thirdparty/quickjs/builtin_binding_generator.py
@@ -1,128 +1,131 @@
 #!/usr/bin/env python
 import json, os
 
-DIR = os.path.abspath( os.path.dirname(__file__) )
+DIR = os.path.abspath(os.path.dirname(__file__))
 OUTPUT_FILE = os.path.join(DIR, "quickjs_builtin_binder.gen.cpp")
-API = json.load(open(os.path.join(DIR, '..', 'builtin_api.gen.json'), 'r'))
+API = json.load(open(os.path.join(DIR, "../..", "builtin_api.gen.json"), "r"))
 
 VariantTypes = {
-	"Variant": "Variant::NIL",
-	"boolean": "Variant::BOOL",
-	"number": "Variant::FLOAT",
-	"string": "Variant::STRING",
-	"Vector2": "Variant::VECTOR2",
-	"Vector3": "Variant::VECTOR3",
-	"Basis": "Variant::BASIS",
-	"Quaternion": "Variant::QUATERNION",
-	"Color": "Variant::COLOR",
-	"Rect2": "Variant::RECT2",
-	"RID": "Variant::RID",
-	"Transform2D": "Variant::TRANSFORM2D",
-	"Plane": "Variant::PLANE",
-	"AABB": "Variant::AABB",
-	"Transform3D": "Variant::TRANSFORM3D",
-	"PackedByteArray": "Variant::PACKED_BYTE_ARRAY",
-	"PackedInt32Array": "Variant::PACKED_INT32_ARRAY",
-	"PackedInt64Array": "Variant::PACKED_INT64_ARRAY",
-	"PackedFloat32Array": "Variant::PACKED_FLOAT32_ARRAY",
-	"PackedFloat64Array": "Variant::PACKED_FLOAT64_ARRAY",
-	"PackedStringArray": "Variant::PACKED_STRING_ARRAY",
-	"PackedVector2Array": "Variant::PACKED_VECTOR2_ARRAY",
-	"PackedVector3Array": "Variant::PACKED_VECTOR3_ARRAY",
-	"PackedColorArray": "Variant::PACKED_COLOR_ARRAY",
+    "Variant": "Variant::NIL",
+    "boolean": "Variant::BOOL",
+    "number": "Variant::FLOAT",
+    "string": "Variant::STRING",
+    "Vector2": "Variant::VECTOR2",
+    "Vector3": "Variant::VECTOR3",
+    "Basis": "Variant::BASIS",
+    "Quaternion": "Variant::QUATERNION",
+    "Color": "Variant::COLOR",
+    "Rect2": "Variant::RECT2",
+    "RID": "Variant::RID",
+    "Transform2D": "Variant::TRANSFORM2D",
+    "Plane": "Variant::PLANE",
+    "AABB": "Variant::AABB",
+    "Transform3D": "Variant::TRANSFORM3D",
+    "PackedByteArray": "Variant::PACKED_BYTE_ARRAY",
+    "PackedInt32Array": "Variant::PACKED_INT32_ARRAY",
+    "PackedInt64Array": "Variant::PACKED_INT64_ARRAY",
+    "PackedFloat32Array": "Variant::PACKED_FLOAT32_ARRAY",
+    "PackedFloat64Array": "Variant::PACKED_FLOAT64_ARRAY",
+    "PackedStringArray": "Variant::PACKED_STRING_ARRAY",
+    "PackedVector2Array": "Variant::PACKED_VECTOR2_ARRAY",
+    "PackedVector3Array": "Variant::PACKED_VECTOR3_ARRAY",
+    "PackedColorArray": "Variant::PACKED_COLOR_ARRAY",
 }
 
 JSToGodotTemplates = {
-	"number": 'QuickJSBinder::js_to_number(ctx, ${arg})',
-	"string": 'QuickJSBinder::js_to_string(ctx, ${arg})',
-	"boolean": 'QuickJSBinder::js_to_bool(ctx, ${arg})',
-	"Vector2": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getVector2()',
-	"Rect2": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getRect2()',
-	"Color": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getColor()',
-	"RID": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getRID()',
-	"AABB": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getAABB()',
-	"Plane": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPlane()',
-	"Quaternion": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getQuaternion()',
-	"Transform2D": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getTransform2D()',
-	"Vector3": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getVector3()',
-	"Basis": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getBasis()',
-	"Transform3D": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getTransform3D()',
-	"PackedByteArray": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedByteArray()',
-	"PackedInt32Array": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedInt32Array()',
-	"PackedInt64Array": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedInt64Array()',
-	"PackedFloat32Array": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedFloat32Array()',
-	"PackedFloat64Array": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedFloat64Array()',
-	"PackedStringArray": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedStringArray()',
-	"PackedVector2Array": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedVector2Array()',
-	"PackedVector3Array": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedVector3Array()',
-	"PackedColorArray": '*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedColorArray()',
-	"Variant": '(BINDING_DATA_FROM_JS(ctx, ${arg}))->get_value()',
+    "number": "QuickJSBinder::js_to_number(ctx, ${arg})",
+    "string": "QuickJSBinder::js_to_string(ctx, ${arg})",
+    "boolean": "QuickJSBinder::js_to_bool(ctx, ${arg})",
+    "Vector2": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getVector2()",
+    "Rect2": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getRect2()",
+    "Color": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getColor()",
+    "RID": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getRID()",
+    "AABB": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getAABB()",
+    "Plane": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPlane()",
+    "Quaternion": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getQuaternion()",
+    "Transform2D": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getTransform2D()",
+    "Vector3": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getVector3()",
+    "Basis": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getBasis()",
+    "Transform3D": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getTransform3D()",
+    "PackedByteArray": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedByteArray()",
+    "PackedInt32Array": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedInt32Array()",
+    "PackedInt64Array": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedInt64Array()",
+    "PackedFloat32Array": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedFloat32Array()",
+    "PackedFloat64Array": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedFloat64Array()",
+    "PackedStringArray": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedStringArray()",
+    "PackedVector2Array": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedVector2Array()",
+    "PackedVector3Array": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedVector3Array()",
+    "PackedColorArray": "*(BINDING_DATA_FROM_JS(ctx, ${arg}))->getPackedColorArray()",
+    "Variant": "(BINDING_DATA_FROM_JS(ctx, ${arg}))->get_value()",
 }
 
 GodotTypeNames = {
-	"number": "real_t",
-	"string": "String",
-	"boolean": "bool",
-	"Vector2": "Vector2",
-	"Rect2": "Rect2",
-	"Color": "Color",
-	"RID": "RID",
-	"AABB": "AABB",
-	"Plane": "Plane",
-	"Quaternion": "Quaternion",
-	"Transform2D": "Transform2D",
-	"Vector3": "Vector3",
-	"Basis": "Basis",
-	"Transform3D": "Transform3D",
-	"PackedByteArray": "PackedByteArray",
-	"PackedInt32Array": "PackedInt32Array",
-	"PackedInt64Array": "PackedInt64Array",
-	"PackedFloat32Array": "PackedFloat32Array",
-	"PackedFloat64Array": "PackedFloat64Array",
-	"PackedStringArray": "PackedStringArray",
-	"PackedVector2Array": "PackedVector2Array",
-	"PackedVector3Array": "PackedVector3Array",
-	"PackedColorArray": "PackedColorArray",
-	"Variant": "Variant",
+    "number": "real_t",
+    "string": "String",
+    "boolean": "bool",
+    "Vector2": "Vector2",
+    "Rect2": "Rect2",
+    "Color": "Color",
+    "RID": "RID",
+    "AABB": "AABB",
+    "Plane": "Plane",
+    "Quaternion": "Quaternion",
+    "Transform2D": "Transform2D",
+    "Vector3": "Vector3",
+    "Basis": "Basis",
+    "Transform3D": "Transform3D",
+    "PackedByteArray": "PackedByteArray",
+    "PackedInt32Array": "PackedInt32Array",
+    "PackedInt64Array": "PackedInt64Array",
+    "PackedFloat32Array": "PackedFloat32Array",
+    "PackedFloat64Array": "PackedFloat64Array",
+    "PackedStringArray": "PackedStringArray",
+    "PackedVector2Array": "PackedVector2Array",
+    "PackedVector3Array": "PackedVector3Array",
+    "PackedColorArray": "PackedColorArray",
+    "Variant": "Variant",
 }
 
 GodotToJSTemplates = {
-	"number": 'QuickJSBinder::to_js_number(ctx, ${arg})',
-	"string": 'QuickJSBinder::to_js_string(ctx, ${arg})',
-	"boolean": 'QuickJSBinder::to_js_bool(ctx, ${arg})',
-	"Vector2": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"Rect2": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"Color": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"RID": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"AABB": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"Plane": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"Quaternion": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"Transform2D": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"Vector3": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"Basis": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"Transform3D": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PackedByteArray": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PackedInt32Array": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PackedInt64Array": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PackedFloat32Array": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PackedFloat64Array": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PackedStringArray": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PackedVector2Array": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PackedVector3Array": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"PackedColorArray": 'QuickJSBuiltinBinder::new_object_from(ctx, ${arg})',
-	"Variant": 'QuickJSBinder::variant_to_var(ctx, ${arg})',
+    "number": "QuickJSBinder::to_js_number(ctx, ${arg})",
+    "string": "QuickJSBinder::to_js_string(ctx, ${arg})",
+    "boolean": "QuickJSBinder::to_js_bool(ctx, ${arg})",
+    "Vector2": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "Rect2": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "Color": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "RID": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "AABB": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "Plane": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "Quaternion": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "Transform2D": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "Vector3": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "Basis": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "Transform3D": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "PackedByteArray": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "PackedInt32Array": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "PackedInt64Array": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "PackedFloat32Array": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "PackedFloat64Array": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "PackedStringArray": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "PackedVector2Array": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "PackedVector3Array": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "PackedColorArray": "QuickJSBuiltinBinder::new_object_from(ctx, ${arg})",
+    "Variant": "QuickJSBinder::variant_to_var(ctx, ${arg})",
 }
 
+
 def apply_pattern(template, values):
-	for key in values:
-		template = template.replace( '${' + key + '}', values[key])
-	return template
+    for key in values:
+        template = template.replace("${" + key + "}", values[key])
+    return template
 
 
 def generate_constructor(cls):
-	TemplateConstructorName = '${class}_constructor'
-	TemplateConstructorDeclare = 'static JSValue ${class}_constructor(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv);\n'
-	TemplateConstructor = '''
+    TemplateConstructorName = "${class}_constructor"
+    TemplateConstructorDeclare = (
+        "static JSValue ${class}_constructor(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv);\n"
+    )
+    TemplateConstructor = """
 static JSValue ${func}(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv) {
 	${class} tmp;
 	${initializer}
@@ -133,8 +136,8 @@ def generate_constructor(cls):
 	return obj;
 	// return QuickJSBuiltinBinder::create_builtin_value(ctx, ${type}, &tmp);
 }
-'''
-	TemplateSimplePackedArrays = '''
+"""
+    TemplateSimplePackedArrays = """
 	if (argc == 1) {
 #ifdef DEBUG_METHODS_ENABLED
 		ERR_FAIL_COND_V(!JS_IsArray(ctx, argv[0]), (JS_ThrowTypeError(ctx, "Array expected for argument #0 of ${class}(from)")));
@@ -142,8 +145,8 @@ def generate_constructor(cls):
 		Variant arr = QuickJSBinder::var_to_variant(ctx, argv[0]);
 		tmp.operator=(arr);
 	}
-	'''
-	TemplatePackedArrays = '''
+	"""
+    TemplatePackedArrays = """
 	if (argc == 1) {
 		if (JS_IsArray(ctx, argv[0])) {
 			Variant arr = QuickJSBinder::var_to_variant(ctx, argv[0]);
@@ -181,9 +184,9 @@ def generate_constructor(cls):
 #endif
 		}
 	}
-	'''
-	ConstructorInitializers = {
-		"Vector2": '''
+	"""
+    ConstructorInitializers = {
+        "Vector2": """
 	if (argc == 2) {
 		tmp.x = QuickJSBinder::js_to_number(ctx, argv[0]);
 		tmp.y = QuickJSBinder::js_to_number(ctx, argv[1]);
@@ -197,8 +200,8 @@ def generate_constructor(cls):
 			tmp.y = tmp.x;
 		}
 	}
-''',
-		"Vector3": '''
+""",
+        "Vector3": """
 	if (argc == 1) {
 		if (JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0])) {
 			if (bind->type == Variant::VECTOR3)
@@ -212,8 +215,8 @@ def generate_constructor(cls):
 		tmp.y = QuickJSBinder::js_to_number(ctx, argv[1]);
 		tmp.z = QuickJSBinder::js_to_number(ctx, argv[2]);
 	}
-''',
-		"Color": '''
+""",
+        "Color": """
 	if (argc >= 3) {
 		tmp.r = QuickJSBinder::js_to_number(ctx, argv[0]);
 		tmp.g = QuickJSBinder::js_to_number(ctx, argv[1]);
@@ -230,8 +233,8 @@ def generate_constructor(cls):
 			}
 		}
 	}
-''',
-		"Rect2": '''
+""",
+        "Rect2": """
 	if (argc == 4) {
 		tmp.position.x = QuickJSBinder::js_to_number(ctx, argv[0]);
 		tmp.position.y = QuickJSBinder::js_to_number(ctx, argv[1]);
@@ -252,8 +255,8 @@ def generate_constructor(cls):
 				tmp = *bind->getRect2();
 		}
 	}
-''',
-		"AABB": '''
+""",
+        "AABB": """
 	if (argc == 2) {
 #ifdef DEBUG_METHODS_ENABLED
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 0 of AABB(position, size)")));
@@ -269,8 +272,8 @@ def generate_constructor(cls):
 				tmp = *bind->getAABB();
 		}
 	}
-''',
-		"Plane": '''
+""",
+        "Plane": """
 	if (argc == 4) {
 		tmp.normal.x = QuickJSBinder::js_to_number(ctx, argv[0]);
 		tmp.normal.y = QuickJSBinder::js_to_number(ctx, argv[1]);
@@ -298,8 +301,8 @@ def generate_constructor(cls):
 				tmp = *bind->getPlane();
 		}
 	}
-''',
-		"Quaternion": '''
+""",
+        "Quaternion": """
 	if (argc == 4) {
 		tmp.x = QuickJSBinder::js_to_number(ctx, argv[0]);
 		tmp.y = QuickJSBinder::js_to_number(ctx, argv[1]);
@@ -319,13 +322,13 @@ def generate_constructor(cls):
 				tmp = *bind->getBasis();
 			} else if (bind->type == Variant::VECTOR3) {
 				Basis basis;
-				basis.from_euler(*bind->getVector3());
+				basis = basis.from_euler(*bind->getVector3());
 				tmp = basis.get_rotation_quaternion();
 			}
 		}
 	}
-''',
-		"Transform2D": '''
+""",
+        "Transform2D": """
 	if (argc == 3) {
 #ifdef DEBUG_METHODS_ENABLED
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR2, argv[0]), (JS_ThrowTypeError(ctx, "Vector2 expected for argument 0 of Transform2D(x_axis, y_axis, origin)")));
@@ -354,8 +357,8 @@ def generate_constructor(cls):
 			}
 		}
 	}
-''',
-		"Basis": '''
+""",
+        "Basis": """
 	if (argc == 3) {
 #ifdef DEBUG_METHODS_ENABLED
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 0 of Basis(x_axis, y_axis, z_axis)")));
@@ -385,8 +388,8 @@ def generate_constructor(cls):
 			}
 		}
 	}
-''',
-		"Transform3D": '''
+""",
+        "Transform3D": """
 	if (argc == 4) {
 #ifdef DEBUG_METHODS_ENABLED
 		ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0]), (JS_ThrowTypeError(ctx, "Vector3 expected for argument 0 of Transform3D(x_axis, y_axis, z_axis, origin)")));
@@ -421,38 +424,65 @@ def generate_constructor(cls):
 			}
 		}
 	}
-''',
-		"PackedByteArray": apply_pattern(TemplatePackedArrays, {"class": "PackedByteArray", "type": "Variant::PACKED_BYTE_ARRAY", "element": "uint8_t"}),
-		"PackedInt32Array": apply_pattern(TemplatePackedArrays, {"class": "PackedInt32Array", "type": "Variant::PACKED_INT32_ARRAY", "element": "int32_t"}),
-		"PackedInt64Array": apply_pattern(TemplatePackedArrays, {"class": "PackedInt64Array", "type": "Variant::PACKED_INT64_ARRAY", "element": "int64_t"}),
-		"PackedFloat32Array": apply_pattern(TemplatePackedArrays, {"class": "PackedFloat32Array", "type": "Variant::PACKED32_FLOAT_ARRAY", "element": "real_t"}),
-		"PackedFloat64Array": apply_pattern(TemplatePackedArrays, {"class": "PackedFloat64Array", "type": "Variant::PACKED64_FLOAT_ARRAY", "element": "real_t"}),
-		"PackedVector2Array": apply_pattern(TemplatePackedArrays, {"class": "PackedVector2Array", "type": "Variant::PACKED_VECTOR2_ARRAY", "element": "Vector2"}),
-		"PackedVector3Array": apply_pattern(TemplatePackedArrays, {"class": "PackedVector3Array", "type": "Variant::PACKED_VECTOR3_ARRAY", "element": "Vector3"}),
-		"PackedColorArray": apply_pattern(TemplatePackedArrays, {"class": "PackedColorArray", "type": "Variant::PACKED_COLOR_ARRAY", "element": "Color"}),
-		"PackedStringArray": apply_pattern(TemplateSimplePackedArrays,{"class": "PackedStringArray", "type": "Variant::PACKED_STRING_ARRAY", "element": "String"}),
-	}
-	class_name = cls['name']
-	constructor_name = apply_pattern(TemplateConstructorName, {"class": class_name})
-	constructor_declare = apply_pattern(TemplateConstructorDeclare, {"class": class_name})
-	
-	initializer = ''
-	if class_name in ConstructorInitializers:
-		initializer = ConstructorInitializers[class_name]
-	constructor = apply_pattern(TemplateConstructor, {
-		'class': class_name,
-		'type': VariantTypes[class_name],
-		'func': constructor_name,
-		'initializer': initializer
-	})
-	return constructor_name, constructor_declare, constructor
+""",
+        "PackedByteArray": apply_pattern(
+            TemplatePackedArrays,
+            {"class": "PackedByteArray", "type": "Variant::PACKED_BYTE_ARRAY", "element": "uint8_t"},
+        ),
+        "PackedInt32Array": apply_pattern(
+            TemplatePackedArrays,
+            {"class": "PackedInt32Array", "type": "Variant::PACKED_INT32_ARRAY", "element": "int32_t"},
+        ),
+        "PackedInt64Array": apply_pattern(
+            TemplatePackedArrays,
+            {"class": "PackedInt64Array", "type": "Variant::PACKED_INT64_ARRAY", "element": "int64_t"},
+        ),
+        "PackedFloat32Array": apply_pattern(
+            TemplatePackedArrays,
+            {"class": "PackedFloat32Array", "type": "Variant::PACKED32_FLOAT_ARRAY", "element": "real_t"},
+        ),
+        "PackedFloat64Array": apply_pattern(
+            TemplatePackedArrays,
+            {"class": "PackedFloat64Array", "type": "Variant::PACKED64_FLOAT_ARRAY", "element": "real_t"},
+        ),
+        "PackedVector2Array": apply_pattern(
+            TemplatePackedArrays,
+            {"class": "PackedVector2Array", "type": "Variant::PACKED_VECTOR2_ARRAY", "element": "Vector2"},
+        ),
+        "PackedVector3Array": apply_pattern(
+            TemplatePackedArrays,
+            {"class": "PackedVector3Array", "type": "Variant::PACKED_VECTOR3_ARRAY", "element": "Vector3"},
+        ),
+        "PackedColorArray": apply_pattern(
+            TemplatePackedArrays,
+            {"class": "PackedColorArray", "type": "Variant::PACKED_COLOR_ARRAY", "element": "Color"},
+        ),
+        "PackedStringArray": apply_pattern(
+            TemplateSimplePackedArrays,
+            {"class": "PackedStringArray", "type": "Variant::PACKED_STRING_ARRAY", "element": "String"},
+        ),
+    }
+    class_name = cls["name"]
+    constructor_name = apply_pattern(TemplateConstructorName, {"class": class_name})
+    constructor_declare = apply_pattern(TemplateConstructorDeclare, {"class": class_name})
+
+    initializer = ""
+    if class_name in ConstructorInitializers:
+        initializer = ConstructorInitializers[class_name]
+    constructor = apply_pattern(
+        TemplateConstructor,
+        {"class": class_name, "type": VariantTypes[class_name], "func": constructor_name, "initializer": initializer},
+    )
+    return constructor_name, constructor_declare, constructor
+
 
 def generate_property_bindings(cls):
-	class_name = cls['name']
-	TemplateDeclar = 'static void bind_${class}_properties(JSContext *octx);\n'
-	TemplateBind = '\tbind_${class}_properties(ctx);\n'
-	def generate_members(cls):
-		Template = '''
+    class_name = cls["name"]
+    TemplateDeclar = "static void bind_${class}_properties(JSContext *octx);\n"
+    TemplateBind = "\tbind_${class}_properties(ctx);\n"
+
+    def generate_members(cls):
+        Template = """
 	JSCFunctionMagic *getter = [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic) -> JSValue {
 		JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 		const ${class} *ptr = bind->get${class}();
@@ -461,7 +491,7 @@ def generate_members(cls):
 		}
 		return JS_UNDEFINED;
 	};
-	
+
 	JSCFunctionMagic *setter = [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic) -> JSValue {
 		JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 		${class} *ptr = bind->get${class}();\
@@ -472,50 +502,59 @@ def generate_members(cls):
 		return JS_DupValue(ctx, argv[0]);
 	};
 ${bindings}
-		'''
-		TemplateGetterItem = '''
+		"""
+        TemplateGetterItem = """
 			case ${index}:
-				return ${value};'''
-		TemplateSetterItem = '''
+				return ${value};"""
+        TemplateSetterItem = """
 			case ${index}:
 #ifdef DEBUG_METHODS_ENABLED
 				ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, ${type}, argv[0]), (JS_ThrowTypeError(ctx, "${type_name} expected for ${class}.${name}")));
 #endif
 				ptr->${native} = ${value};
-				break;'''
-		TemplateItemBinding = '\tbinder->get_builtin_binder().register_property(${type}, "${name}", getter, setter, ${index});\n'
-		getters = ''
-		setters = ''
-		bindings = ''
-		for i in range(len(cls['properties'])):
-			p = cls['properties'][i]
-			type = p['type']
-			name = p['name']
-			native_name = p['native']
-			getters += apply_pattern(TemplateGetterItem, {
-				'index': str(i),
-				'value': apply_pattern(GodotToJSTemplates[type], { 'arg': apply_pattern('ptr->${native}', {'native': native_name}) })
-			})
-			setters += apply_pattern(TemplateSetterItem, {
-				'index': str(i),
-				'name': name,
-				'native': native_name,
-				'type': VariantTypes[type],
-				'type_name': type,
-				'class': class_name,
-				'value': apply_pattern(JSToGodotTemplates[type], {'arg': 'argv[0]'})
-			})
-			bindings += apply_pattern(TemplateItemBinding, {'index': str(i), 'name': name, 'type': VariantTypes[class_name]})
-		return apply_pattern(Template, {
-			'class': class_name,
-			'getters': getters,
-			'setters': setters,
-			'bindings': bindings,
-			'validation': ''
-		})
-	
-	def generate_methods(cls):
-		TemplateMethod = '''
+				break;"""
+        TemplateItemBinding = (
+            '\tbinder->get_builtin_binder().register_property(${type}, "${name}", getter, setter, ${index});\n'
+        )
+        getters = ""
+        setters = ""
+        bindings = ""
+        for i in range(len(cls["properties"])):
+            p = cls["properties"][i]
+            type = p["type"]
+            name = p["name"]
+            native_name = p["native"]
+            getters += apply_pattern(
+                TemplateGetterItem,
+                {
+                    "index": str(i),
+                    "value": apply_pattern(
+                        GodotToJSTemplates[type], {"arg": apply_pattern("ptr->${native}", {"native": native_name})}
+                    ),
+                },
+            )
+            setters += apply_pattern(
+                TemplateSetterItem,
+                {
+                    "index": str(i),
+                    "name": name,
+                    "native": native_name,
+                    "type": VariantTypes[type],
+                    "type_name": type,
+                    "class": class_name,
+                    "value": apply_pattern(JSToGodotTemplates[type], {"arg": "argv[0]"}),
+                },
+            )
+            bindings += apply_pattern(
+                TemplateItemBinding, {"index": str(i), "name": name, "type": VariantTypes[class_name]}
+            )
+        return apply_pattern(
+            Template,
+            {"class": class_name, "getters": getters, "setters": setters, "bindings": bindings, "validation": ""},
+        )
+
+    def generate_methods(cls):
+        TemplateMethod = """
 	binder->get_builtin_binder().register_method(
 		${type},
 		"${name}",
@@ -526,73 +565,84 @@ def generate_methods(cls):
 			${call}
 			return ${return};
 		},
-		${argc});'''
-		TemplateArgDeclare = '''
+		${argc});"""
+        TemplateArgDeclare = """
 #ifdef DEBUG_METHODS_ENABLED
 			ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, ${type}, argv[${index}]), (JS_ThrowTypeError(ctx, "${type_name} expected for argument ${index} of ${class}.${name}")));
 #endif
 			const ${godot_type} &arg${index} = ${arg};
-'''
-		TemplateReturnValue = '${godot_type} ret = '
-		bindings = ''
-		for m in cls['methods']:
-			args = ''
-			arg_declares = ''
-			for i in range(len(m['arguments'])):
-				arg = m['arguments'][i]
-				arg_type = arg['type']
-				arg_declares += apply_pattern(TemplateArgDeclare, {
-					'index': str(i),
-					'type': VariantTypes[arg_type],
-					'type_name': arg_type,
-					'class': class_name,
-					'name': m['name'],
-					'arg': apply_pattern(JSToGodotTemplates[arg_type], {'arg': 'argv[' + str(i) +']'}),
-					'godot_type': GodotTypeNames[arg_type],
-				})
-				if i > 0: args += ', '
-				args += 'arg' + str(i)
-			CallTemplate = ('' if m['return'] == 'void' else (apply_pattern(TemplateReturnValue, {"godot_type": GodotTypeNames[m['return']]}))) + 'ptr->${native_method}(${args});'
-			call = apply_pattern(CallTemplate, {'native_method': m['native_method'], 'args': args})
-			bindings += apply_pattern(TemplateMethod, {
-				"class": class_name,
-				"type": VariantTypes[class_name],
-				"name": m['name'],
-				"call": call,
-				"arg_declares": arg_declares,
-				"argc": str(len(m['arguments'])),
-				"return": 'JS_UNDEFINED' if m['return'] == 'void' else apply_pattern(GodotToJSTemplates[m['return']], {'arg': 'ret'}),
-			})
-		return bindings
-		
-	def generate_constants(cls):
-		ConstTemplate = '\tbinder->get_builtin_binder().register_constant(${type}, "${name}", ${value});\n'
-		bindings = ''
-		for c in cls['constants']:
-			bindings += apply_pattern(ConstTemplate, {
-				"name": c['name'],
-				"type": VariantTypes[class_name],
-				"value": c['value']
-			})
-		return bindings
-	
-	def genertate_operators(cls):
-		OperatorMap = {
-			'operator+': '+',
-			'operator-': '-',
-			'operator*': '*',
-			'operator/': '/',
-			'operator==': '==',
-			'operator<': '<'
-		}
-		TargetDeclareTemplate = '''
+"""
+        TemplateReturnValue = "${godot_type} ret = "
+        bindings = ""
+        for m in cls["methods"]:
+            args = ""
+            arg_declares = ""
+            for i in range(len(m["arguments"])):
+                arg = m["arguments"][i]
+                arg_type = arg["type"]
+                arg_declares += apply_pattern(
+                    TemplateArgDeclare,
+                    {
+                        "index": str(i),
+                        "type": VariantTypes[arg_type],
+                        "type_name": arg_type,
+                        "class": class_name,
+                        "name": m["name"],
+                        "arg": apply_pattern(JSToGodotTemplates[arg_type], {"arg": "argv[" + str(i) + "]"}),
+                        "godot_type": GodotTypeNames[arg_type],
+                    },
+                )
+                if i > 0:
+                    args += ", "
+                args += "arg" + str(i)
+            CallTemplate = (
+                ""
+                if m["return"] == "void"
+                else (apply_pattern(TemplateReturnValue, {"godot_type": GodotTypeNames[m["return"]]}))
+            ) + "ptr->${native_method}(${args});"
+            call = apply_pattern(CallTemplate, {"native_method": m["native_method"], "args": args})
+            bindings += apply_pattern(
+                TemplateMethod,
+                {
+                    "class": class_name,
+                    "type": VariantTypes[class_name],
+                    "name": m["name"],
+                    "call": call,
+                    "arg_declares": arg_declares,
+                    "argc": str(len(m["arguments"])),
+                    "return": "JS_UNDEFINED"
+                    if m["return"] == "void"
+                    else apply_pattern(GodotToJSTemplates[m["return"]], {"arg": "ret"}),
+                },
+            )
+        return bindings
+
+    def generate_constants(cls):
+        ConstTemplate = '\tbinder->get_builtin_binder().register_constant(${type}, "${name}", ${value});\n'
+        bindings = ""
+        for c in cls["constants"]:
+            bindings += apply_pattern(
+                ConstTemplate, {"name": c["name"], "type": VariantTypes[class_name], "value": c["value"]}
+            )
+        return bindings
+
+    def genertate_operators(cls):
+        OperatorMap = {
+            "operator+": "+",
+            "operator-": "-",
+            "operator*": "*",
+            "operator/": "/",
+            "operator==": "==",
+            "operator<": "<",
+        }
+        TargetDeclareTemplate = """
 #ifdef DEBUG_METHODS_ENABLED
 			ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, ${type}, argv[1]), (JS_ThrowTypeError(ctx, "${target_class} expected for ${class}.${operator}")));
 #endif
 			JavaScriptGCHandler *bind1 = BINDING_DATA_FROM_JS(ctx, argv[1]);
 			${target_class} *target = bind1->get${target_class}();\
-'''
-		OperatorTemplate = '''
+"""
+        OperatorTemplate = """
 	JS_SetPropertyStr(octx, base_operators, "${js_op}",
 		JS_NewCFunction(octx, [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 			JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, argv[0]);
@@ -604,52 +654,67 @@ def genertate_operators(cls):
 		"${name}",
 		${argc})
 	);
-	'''
-		TemplateReturnValue = '${godot_type} ret = '
-		bindings = '''\
+	"""
+        TemplateReturnValue = "${godot_type} ret = "
+        bindings = """\
 	Vector<JSValue> operators;
 	JSValue base_operators = JS_NewObject(octx);
-'''
-		for o in cls['operators']:
-			op = o['native_method']
-			if op in OperatorMap:
-				argc = len(o['arguments']) + 1
-				js_op = OperatorMap[op]
-				if argc <= 1:
-					if op in ['operator-']:
-						js_op = 'neg'
-					
-				args = ''
-				target_declare = ''
-				if argc > 1:
-					arg_class = o['arguments'][0]['type']
-					target_declare = apply_pattern(TargetDeclareTemplate, {
-						'target_class': arg_class,
-						'type': VariantTypes[arg_class],
-						'class': class_name,
-						'operator': o['native_method'],
-					})
-					args = '*target'
-				CallTemplate = ('' if o['return'] == 'void' else apply_pattern(TemplateReturnValue, {'godot_type': GodotTypeNames[o['return']] })) + 'ptr->${op}(${args});'
-				call = apply_pattern(CallTemplate, {'op': op, 'args': args})
-				bindings += apply_pattern(OperatorTemplate, {
-					'type': VariantTypes[class_name],
-					'class': class_name,
-					'js_op': js_op,
-					'call': call,
-					'name': o['name'],
-					'target_declare': target_declare,
-					"return": 'JS_UNDEFINED' if o['return'] == 'void' else apply_pattern(GodotToJSTemplates[o['return']], {'arg': 'ret'}),
-					'argc': str(argc)
-				})
-		bindings += apply_pattern('''
+"""
+        for o in cls["operators"]:
+            op = o["native_method"]
+            if op in OperatorMap:
+                argc = len(o["arguments"]) + 1
+                js_op = OperatorMap[op]
+                if argc <= 1:
+                    if op in ["operator-"]:
+                        js_op = "neg"
+
+                args = ""
+                target_declare = ""
+                if argc > 1:
+                    arg_class = o["arguments"][0]["type"]
+                    target_declare = apply_pattern(
+                        TargetDeclareTemplate,
+                        {
+                            "target_class": arg_class,
+                            "type": VariantTypes[arg_class],
+                            "class": class_name,
+                            "operator": o["native_method"],
+                        },
+                    )
+                    args = "*target"
+                CallTemplate = (
+                    ""
+                    if o["return"] == "void"
+                    else apply_pattern(TemplateReturnValue, {"godot_type": GodotTypeNames[o["return"]]})
+                ) + "ptr->${op}(${args});"
+                call = apply_pattern(CallTemplate, {"op": op, "args": args})
+                bindings += apply_pattern(
+                    OperatorTemplate,
+                    {
+                        "type": VariantTypes[class_name],
+                        "class": class_name,
+                        "js_op": js_op,
+                        "call": call,
+                        "name": o["name"],
+                        "target_declare": target_declare,
+                        "return": "JS_UNDEFINED"
+                        if o["return"] == "void"
+                        else apply_pattern(GodotToJSTemplates[o["return"]], {"arg": "ret"}),
+                        "argc": str(argc),
+                    },
+                )
+        bindings += apply_pattern(
+            """
 	operators.push_back(base_operators);
 	binder->get_builtin_binder().get_cross_type_operators(${type}, operators);
 	binder->get_builtin_binder().register_operators(${type}, operators);
-''', {'type': VariantTypes[class_name]})
-		return bindings
-	
-	TemplateBindDefine = '''
+""",
+            {"type": VariantTypes[class_name]},
+        )
+        return bindings
+
+    TemplateBindDefine = """
 static void bind_${class}_properties(JSContext *octx) {
 	QuickJSBinder *binder = QuickJSBinder::get_context_binder(octx);
 ${members}
@@ -657,33 +722,38 @@ def genertate_operators(cls):
 ${constants}
 ${methods}
 }
-'''
-	class_name = cls['name']
-	property_declare = apply_pattern(TemplateDeclar, {"class": class_name})
-	property_defines = apply_pattern(TemplateBindDefine, {
-		"class": class_name,
-		"members": generate_members(cls) if len(cls['properties']) else '',
-		"methods": generate_methods(cls),
-		"constants": generate_constants(cls),
-		"operators": genertate_operators(cls),
-	})
-	property_bind = apply_pattern(TemplateBind, {"class": class_name})
-	return property_declare, property_defines, property_bind
+"""
+    class_name = cls["name"]
+    property_declare = apply_pattern(TemplateDeclar, {"class": class_name})
+    property_defines = apply_pattern(
+        TemplateBindDefine,
+        {
+            "class": class_name,
+            "members": generate_members(cls) if len(cls["properties"]) else "",
+            "methods": generate_methods(cls),
+            "constants": generate_constants(cls),
+            "operators": genertate_operators(cls),
+        },
+    )
+    property_bind = apply_pattern(TemplateBind, {"class": class_name})
+    return property_declare, property_defines, property_bind
 
 
 def generate_class_bind_action(cls, constructor):
-	Template = '\tregister_builtin_class(${type}, "${class}", ${constructor}, ${argc});\n'
-	return apply_pattern(Template, {
-		'class': cls['name'],
-		'constructor': constructor,
-		'type': VariantTypes[cls['name']],
-		'argc': str(cls['constructor_argc'])
-	})
-
+    Template = '\tregister_builtin_class(${type}, "${class}", ${constructor}, ${argc});\n'
+    return apply_pattern(
+        Template,
+        {
+            "class": cls["name"],
+            "constructor": constructor,
+            "type": VariantTypes[cls["name"]],
+            "argc": str(cls["constructor_argc"]),
+        },
+    )
 
 
 def generate_builtin_bindings():
-	Template = '''\
+    Template = """\
 #include "core/variant/variant.h"
 #include "quickjs_binder.h"
 #include "quickjs_builtin_binder.h"
@@ -700,29 +770,33 @@ def generate_builtin_bindings():
 }
 
 ${definitions}
-'''
-	
-	declarations = ''
-	definitions = ''
-	bindings = ''
-	for cls in API:
-		constructor_name, constructor_declare, constructor = generate_constructor(cls)
-		declarations += constructor_declare
-		definitions += constructor
-		bindings += generate_class_bind_action(cls, constructor_name)
-		
-		property_declare, property_defines, property_bind= generate_property_bindings(cls)
-		declarations += property_declare
-		definitions += property_defines
-		bindings += property_bind
-	
-	output = apply_pattern(Template, {
-		'declarations': declarations,
-		'bindings': bindings,
-		'definitions': definitions,
-	})
-	file = open(OUTPUT_FILE, 'w')
-	file.write(output)
+"""
+
+    declarations = ""
+    definitions = ""
+    bindings = ""
+    for cls in API:
+        constructor_name, constructor_declare, constructor = generate_constructor(cls)
+        declarations += constructor_declare
+        definitions += constructor
+        bindings += generate_class_bind_action(cls, constructor_name)
+
+        property_declare, property_defines, property_bind = generate_property_bindings(cls)
+        declarations += property_declare
+        definitions += property_defines
+        bindings += property_bind
+
+    output = apply_pattern(
+        Template,
+        {
+            "declarations": declarations,
+            "bindings": bindings,
+            "definitions": definitions,
+        },
+    )
+    file = open(OUTPUT_FILE, "w")
+    file.write(output)
+
 
 if __name__ == "__main__":
-	generate_builtin_bindings()
+    generate_builtin_bindings()
diff --git a/quickjs/quickjs/VERSION.txt b/thirdparty/quickjs/quickjs/VERSION.txt
similarity index 100%
rename from quickjs/quickjs/VERSION.txt
rename to thirdparty/quickjs/quickjs/VERSION.txt
diff --git a/quickjs/quickjs/cutils.c b/thirdparty/quickjs/quickjs/cutils.c
similarity index 99%
rename from quickjs/quickjs/cutils.c
rename to thirdparty/quickjs/quickjs/cutils.c
index a02fb768..b4960f9c 100644
--- a/quickjs/quickjs/cutils.c
+++ b/thirdparty/quickjs/quickjs/cutils.c
@@ -1,6 +1,6 @@
 /*
  * C utilities
- * 
+ *
  * Copyright (c) 2017 Fabrice Bellard
  * Copyright (c) 2018 Charlie Gordon
  *
@@ -172,7 +172,7 @@ int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
     va_list ap;
     char buf[128];
     int len;
-    
+
     va_start(ap, fmt);
     len = vsnprintf(buf, sizeof(buf), fmt, ap);
     va_end(ap);
diff --git a/quickjs/quickjs/cutils.h b/thirdparty/quickjs/quickjs/cutils.h
similarity index 94%
rename from quickjs/quickjs/cutils.h
rename to thirdparty/quickjs/quickjs/cutils.h
index 31f7cd84..e7d500fc 100644
--- a/quickjs/quickjs/cutils.h
+++ b/thirdparty/quickjs/quickjs/cutils.h
@@ -1,6 +1,6 @@
 /*
  * C utilities
- * 
+ *
  * Copyright (c) 2017 Fabrice Bellard
  * Copyright (c) 2018 Charlie Gordon
  *
@@ -220,13 +220,13 @@ static inline uint32_t bswap32(uint32_t v)
 
 static inline uint64_t bswap64(uint64_t v)
 {
-    return ((v & ((uint64_t)0xff << (7 * 8))) >> (7 * 8)) | 
-        ((v & ((uint64_t)0xff << (6 * 8))) >> (5 * 8)) | 
-        ((v & ((uint64_t)0xff << (5 * 8))) >> (3 * 8)) | 
-        ((v & ((uint64_t)0xff << (4 * 8))) >> (1 * 8)) | 
-        ((v & ((uint64_t)0xff << (3 * 8))) << (1 * 8)) | 
-        ((v & ((uint64_t)0xff << (2 * 8))) << (3 * 8)) | 
-        ((v & ((uint64_t)0xff << (1 * 8))) << (5 * 8)) | 
+    return ((v & ((uint64_t)0xff << (7 * 8))) >> (7 * 8)) |
+        ((v & ((uint64_t)0xff << (6 * 8))) >> (5 * 8)) |
+        ((v & ((uint64_t)0xff << (5 * 8))) >> (3 * 8)) |
+        ((v & ((uint64_t)0xff << (4 * 8))) >> (1 * 8)) |
+        ((v & ((uint64_t)0xff << (3 * 8))) << (1 * 8)) |
+        ((v & ((uint64_t)0xff << (2 * 8))) << (3 * 8)) |
+        ((v & ((uint64_t)0xff << (1 * 8))) << (5 * 8)) |
         ((v & ((uint64_t)0xff << (0 * 8))) << (7 * 8));
 }
 
diff --git a/quickjs/quickjs/libbf.c b/thirdparty/quickjs/quickjs/libbf.c
similarity index 98%
rename from quickjs/quickjs/libbf.c
rename to thirdparty/quickjs/quickjs/libbf.c
index 3bf257a1..f1cf45b5 100644
--- a/quickjs/quickjs/libbf.c
+++ b/thirdparty/quickjs/quickjs/libbf.c
@@ -1,6 +1,6 @@
 /*
  * Tiny arbitrary precision floating point library
- * 
+ *
  * Copyright (c) 2017-2020 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -55,8 +55,8 @@
 #define UDIV1NORM_THRESHOLD 3
 
 #if LIMB_BITS == 64
-#define FMT_LIMB1 "%" PRIx64 
-#define FMT_LIMB "%016" PRIx64 
+#define FMT_LIMB1 "%" PRIx64
+#define FMT_LIMB "%016" PRIx64
 #define PRId_LIMB PRId64
 #define PRIu_LIMB PRIu64
 
@@ -194,7 +194,7 @@ void bf_init(bf_context_t *s, bf_t *r)
 int bf_resize(bf_t *r, limb_t len)
 {
     limb_t *tab;
-    
+
     if (len != r->len) {
         tab = bf_realloc(r->ctx, r->tab, len * sizeof(limb_t));
         if (!tab && len != 0)
@@ -212,7 +212,7 @@ int bf_set_ui(bf_t *r, uint64_t a)
     if (a == 0) {
         r->expn = BF_EXP_ZERO;
         bf_resize(r, 0); /* cannot fail */
-    } 
+    }
 #if LIMB_BITS == 32
     else if (a <= 0xffffffff)
 #else
@@ -374,7 +374,7 @@ static inline limb_t scan_bit_nz(const bf_t *r, slimb_t bit_pos)
 {
     slimb_t pos;
     limb_t v;
-    
+
     pos = bit_pos >> LIMB_LOG2_BITS;
     if (pos < 0)
         return 0;
@@ -397,7 +397,7 @@ static int bf_get_rnd_add(int *pret, const bf_t *r, limb_t l,
 {
     int add_one, inexact;
     limb_t bit1, bit0;
-    
+
     if (rnd_mode == BF_RNDF) {
         bit0 = 1; /* faithful rounding does not honor the INEXACT flag */
     } else {
@@ -408,7 +408,7 @@ static int bf_get_rnd_add(int *pret, const bf_t *r, limb_t l,
     /* get the bit at 'prec' */
     bit1 = get_bit(r->tab, l, l * LIMB_BITS - 1 - prec);
     inexact = (bit1 | bit0) != 0;
-    
+
     add_one = 0;
     switch(rnd_mode) {
     case BF_RNDZ:
@@ -439,7 +439,7 @@ static int bf_get_rnd_add(int *pret, const bf_t *r, limb_t l,
     default:
         abort();
     }
-    
+
     if (inexact)
         *pret |= BF_ST_INEXACT;
     return add_one;
@@ -449,7 +449,7 @@ static int bf_set_overflow(bf_t *r, int sign, limb_t prec, bf_flags_t flags)
 {
     slimb_t i, l, e_max;
     int rnd_mode;
-    
+
     rnd_mode = flags & BF_RND_MASK;
     if (prec == BF_PREC_INF ||
         rnd_mode == BF_RNDN ||
@@ -492,7 +492,7 @@ static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l,
     e_range = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
     e_min = -e_range + 3;
     e_max = e_range;
-    
+
     if (flags & BF_FLAG_RADPNT_PREC) {
         /* 'prec' is the precision after the radix point */
         if (prec1 != BF_PREC_INF)
@@ -511,7 +511,7 @@ static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l,
     /* round to prec bits */
     rnd_mode = flags & BF_RND_MASK;
     add_one = bf_get_rnd_add(&ret, r, l, prec, rnd_mode);
-    
+
     if (prec <= 0) {
         if (add_one) {
             bf_resize(r, 1); /* cannot fail */
@@ -524,12 +524,12 @@ static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l,
         }
     } else if (add_one) {
         limb_t carry;
-        
+
         /* add one starting at digit 'prec - 1' */
         bit_pos = l * LIMB_BITS - 1 - (prec - 1);
         pos = bit_pos >> LIMB_LOG2_BITS;
         carry = (limb_t)1 << (bit_pos & (LIMB_BITS - 1));
-        
+
         for(i = pos; i < l; i++) {
             v = r->tab[i] + carry;
             carry = (v < carry);
@@ -548,7 +548,7 @@ static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l,
             r->expn++;
         }
     }
-    
+
     /* check underflow */
     if (unlikely(r->expn < e_min)) {
         if (flags & BF_FLAG_SUBNORMAL) {
@@ -562,11 +562,11 @@ static int __bf_round(bf_t *r, limb_t prec1, bf_flags_t flags, limb_t l,
             return ret;
         }
     }
-    
+
     /* check overflow */
     if (unlikely(r->expn > e_max))
         return bf_set_overflow(r, r->sign, prec1, flags);
-    
+
     /* keep the bits starting at 'prec - 1' */
     bit_pos = l * LIMB_BITS - 1 - (prec - 1);
     i = bit_pos >> LIMB_LOG2_BITS;
@@ -594,7 +594,7 @@ int bf_normalize_and_round(bf_t *r, limb_t prec1, bf_flags_t flags)
     limb_t l, v, a;
     int shift, ret;
     slimb_t i;
-    
+
     //    bf_print_str("bf_renorm", r);
     l = r->len;
     while (l > 0 && r->tab[l - 1] == 0)
@@ -633,7 +633,7 @@ int bf_can_round(const bf_t *a, slimb_t prec, bf_rnd_t rnd_mode, slimb_t k)
     BOOL is_rndn;
     slimb_t bit_pos, n;
     limb_t bit;
-    
+
     if (a->expn == BF_EXP_INF || a->expn == BF_EXP_NAN)
         return FALSE;
     if (rnd_mode == BF_RNDF) {
@@ -647,7 +647,7 @@ int bf_can_round(const bf_t *a, slimb_t prec, bf_rnd_t rnd_mode, slimb_t k)
     bit_pos = a->len * LIMB_BITS - 1 - prec;
     n = k - prec;
     /* bit pattern for RNDN or RNDNA: 0111.. or 1000...
-       for other rounding modes: 000... or 111... 
+       for other rounding modes: 000... or 111...
     */
     bit = get_bit(a->tab, a->len, bit_pos);
     bit_pos--;
@@ -739,7 +739,7 @@ int bf_cmpu(const bf_t *a, const bf_t *b)
 {
     slimb_t i;
     limb_t len, v1, v2;
-    
+
     if (a->expn != b->expn) {
         if (a->expn < b->expn)
             return -1;
@@ -764,7 +764,7 @@ int bf_cmpu(const bf_t *a, const bf_t *b)
 int bf_cmp_full(const bf_t *a, const bf_t *b)
 {
     int res;
-    
+
     if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
         if (a->expn == b->expn)
             res = 0;
@@ -788,7 +788,7 @@ int bf_cmp_full(const bf_t *a, const bf_t *b)
 int bf_cmp(const bf_t *a, const bf_t *b)
 {
     int res;
-    
+
     if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
         res = 2;
     } else if (a->sign != b->sign) {
@@ -807,7 +807,7 @@ int bf_cmp(const bf_t *a, const bf_t *b)
 /* Compute the number of bits 'n' matching the pattern:
    a= X1000..0
    b= X0111..1
-              
+
    When computing a-b, the result will have at least n leading zero
    bits.
 
@@ -922,7 +922,7 @@ static int bf_add_internal(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
         } else {
             cancelled_bits = 0;
         }
-        
+
         /* add two extra bits for rounding */
         precl = (cancelled_bits + prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
         tot_len = bf_max(a->len, b->len + (d + LIMB_BITS - 1) / LIMB_BITS);
@@ -940,7 +940,7 @@ static int bf_add_internal(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
         while (i < 0) {
             slimb_t ap, bp;
             BOOL inflag;
-            
+
             ap = a_offset + i;
             bp = b_bit_offset + i * LIMB_BITS;
             inflag = FALSE;
@@ -964,7 +964,7 @@ static int bf_add_internal(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
                 if (ap < 0)
                     i = bf_min(i, -a_offset);
                 /* b_bit_offset + i * LIMB_BITS + LIMB_BITS >= 1
-                   equivalent to 
+                   equivalent to
                    i >= ceil(-b_bit_offset + 1 - LIMB_BITS) / LIMB_BITS)
                 */
                 if (bp + LIMB_BITS <= 0)
@@ -1021,12 +1021,12 @@ static int __bf_sub(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
     return bf_add_internal(r, a, b, prec, flags, 1);
 }
 
-limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2, 
+limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2,
               limb_t n, limb_t carry)
 {
     slimb_t i;
     limb_t k, a, v, k1;
-    
+
     k = carry;
     for(i=0;i<n;i++) {
         v = op1[i];
@@ -1055,12 +1055,12 @@ limb_t mp_add_ui(limb_t *tab, limb_t b, size_t n)
     return k;
 }
 
-limb_t mp_sub(limb_t *res, const limb_t *op1, const limb_t *op2, 
+limb_t mp_sub(limb_t *res, const limb_t *op1, const limb_t *op2,
               mp_size_t n, limb_t carry)
 {
     int i;
     limb_t k, a, v, k1;
-    
+
     k = carry;
     for(i=0;i<n;i++) {
         v = op1[i];
@@ -1078,7 +1078,7 @@ static limb_t mp_neg(limb_t *res, const limb_t *op2, mp_size_t n, limb_t carry)
 {
     int i;
     limb_t k, a, v, k1;
-    
+
     k = carry;
     for(i=0;i<n;i++) {
         v = 0;
@@ -1095,7 +1095,7 @@ limb_t mp_sub_ui(limb_t *tab, limb_t b, mp_size_t n)
 {
     mp_size_t i;
     limb_t k, a, v;
-    
+
     k=b;
     for(i=0;i<n;i++) {
         v = tab[i];
@@ -1108,9 +1108,9 @@ limb_t mp_sub_ui(limb_t *tab, limb_t b, mp_size_t n)
     return k;
 }
 
-/* r = (a + high*B^n) >> shift. Return the remainder r (0 <= r < 2^shift). 
+/* r = (a + high*B^n) >> shift. Return the remainder r (0 <= r < 2^shift).
    1 <= shift <= LIMB_BITS - 1 */
-static limb_t mp_shr(limb_t *tab_r, const limb_t *tab, mp_size_t n, 
+static limb_t mp_shr(limb_t *tab_r, const limb_t *tab, mp_size_t n,
                      int shift, limb_t high)
 {
     mp_size_t i;
@@ -1127,7 +1127,7 @@ static limb_t mp_shr(limb_t *tab_r, const limb_t *tab, mp_size_t n,
 }
 
 /* tabr[] = taba[] * b + l. Return the high carry */
-static limb_t mp_mul1(limb_t *tabr, const limb_t *taba, limb_t n, 
+static limb_t mp_mul1(limb_t *tabr, const limb_t *taba, limb_t n,
                       limb_t b, limb_t l)
 {
     limb_t i;
@@ -1147,7 +1147,7 @@ static limb_t mp_add_mul1(limb_t *tabr, const limb_t *taba, limb_t n,
 {
     limb_t i, l;
     dlimb_t t;
-    
+
     l = 0;
     for(i = 0; i < n; i++) {
         t = (dlimb_t)taba[i] * (dlimb_t)b + l + tabr[i];
@@ -1158,12 +1158,12 @@ static limb_t mp_add_mul1(limb_t *tabr, const limb_t *taba, limb_t n,
 }
 
 /* size of the result : op1_size + op2_size. */
-static void mp_mul_basecase(limb_t *result, 
-                            const limb_t *op1, limb_t op1_size, 
-                            const limb_t *op2, limb_t op2_size) 
+static void mp_mul_basecase(limb_t *result,
+                            const limb_t *op1, limb_t op1_size,
+                            const limb_t *op2, limb_t op2_size)
 {
     limb_t i, r;
-    
+
     result[op1_size] = mp_mul1(result, op1, op1_size, op2[0], 0);
     for(i=1;i<op2_size;i++) {
         r = mp_add_mul1(result + i, op1, op1_size, op2[i]);
@@ -1173,9 +1173,9 @@ static void mp_mul_basecase(limb_t *result,
 
 /* return 0 if OK, -1 if memory error */
 /* XXX: change API so that result can be allocated */
-int mp_mul(bf_context_t *s, limb_t *result, 
-           const limb_t *op1, limb_t op1_size, 
-           const limb_t *op2, limb_t op2_size) 
+int mp_mul(bf_context_t *s, limb_t *result,
+           const limb_t *op1, limb_t op1_size,
+           const limb_t *op2, limb_t op2_size)
 {
 #ifdef USE_FFT_MUL
     if (unlikely(bf_min(op1_size, op2_size) >= FFT_MUL_THRESHOLD)) {
@@ -1200,7 +1200,7 @@ static limb_t mp_sub_mul1(limb_t *tabr, const limb_t *taba, limb_t n,
 {
     limb_t i, l;
     dlimb_t t;
-    
+
     l = 0;
     for(i = 0; i < n; i++) {
         t = tabr[i] - (dlimb_t)taba[i] * (dlimb_t)b - l;
@@ -1264,15 +1264,15 @@ static limb_t mp_div1norm(limb_t *tabr, const limb_t *taba, limb_t n,
     return r;
 }
 
-static int mp_divnorm_large(bf_context_t *s, 
-                            limb_t *tabq, limb_t *taba, limb_t na, 
+static int mp_divnorm_large(bf_context_t *s,
+                            limb_t *tabq, limb_t *taba, limb_t na,
                             const limb_t *tabb, limb_t nb);
 
 /* base case division: divides taba[0..na-1] by tabb[0..nb-1]. tabb[nb
    - 1] must be >= 1 << (LIMB_BITS - 1). na - nb must be >= 0. 'taba'
    is modified and contains the remainder (nb limbs). tabq[0..na-nb]
    contains the quotient with tabq[na - nb] <= 1. */
-static int mp_divnorm(bf_context_t *s, limb_t *tabq, limb_t *taba, limb_t na, 
+static int mp_divnorm(bf_context_t *s, limb_t *tabq, limb_t *taba, limb_t na,
                       const limb_t *tabb, limb_t nb)
 {
     limb_t r, a, c, q, v, b1, b1_inv, n, dummy_r;
@@ -1287,7 +1287,7 @@ static int mp_divnorm(bf_context_t *s, limb_t *tabq, limb_t *taba, limb_t na,
     if (bf_min(n, nb) >= DIVNORM_LARGE_THRESHOLD) {
         return mp_divnorm_large(s, tabq, taba, na, tabb, nb);
     }
-    
+
     if (n >= UDIV1NORM_THRESHOLD)
         b1_inv = udiv1norm_init(b1);
     else
@@ -1306,7 +1306,7 @@ static int mp_divnorm(bf_context_t *s, limb_t *tabq, limb_t *taba, limb_t na,
     if (q) {
         mp_sub(taba + n, taba + n, tabb, nb, 0);
     }
-    
+
     for(i = n - 1; i >= 0; i--) {
         if (unlikely(taba[i + nb] >= b1)) {
             q = -1;
@@ -1345,14 +1345,14 @@ static int mp_divnorm(bf_context_t *s, limb_t *tabq, limb_t *taba, limb_t na,
 
 /* compute r=B^(2*n)/a such as a*r < B^(2*n) < a*r + 2 with n >= 1. 'a'
    has n limbs with a[n-1] >= B/2 and 'r' has n+1 limbs with r[n] = 1.
-   
+
    See Modern Computer Arithmetic by Richard P. Brent and Paul
    Zimmermann, algorithm 3.5 */
 int mp_recip(bf_context_t *s, limb_t *tabr, const limb_t *taba, limb_t n)
 {
     mp_size_t l, h, k, i;
     limb_t *tabxh, *tabt, c, *tabu;
-    
+
     if (n <= 2) {
         /* return ceil(B^(2*n)/a) - 1 */
         /* XXX: could avoid allocation */
@@ -1430,8 +1430,8 @@ static int mp_cmp(const limb_t *taba, const limb_t *tabb, mp_size_t n)
 //#define DEBUG_DIVNORM_LARGE2
 
 /* subquadratic divnorm */
-static int mp_divnorm_large(bf_context_t *s, 
-                            limb_t *tabq, limb_t *taba, limb_t na, 
+static int mp_divnorm_large(bf_context_t *s,
+                            limb_t *tabq, limb_t *taba, limb_t na,
                             const limb_t *tabb, limb_t nb)
 {
     limb_t *tabb_inv, nq, *tabt, i, n;
@@ -1444,7 +1444,7 @@ static int mp_divnorm_large(bf_context_t *s,
     assert(nq >= 1);
     n = nq;
     if (nq < nb)
-        n++; 
+        n++;
     tabb_inv = bf_malloc(s, sizeof(limb_t) * (n + 1));
     tabt = bf_malloc(s, sizeof(limb_t) * 2 * (n + 1));
     if (!tabb_inv || !tabt)
@@ -1473,7 +1473,7 @@ static int mp_divnorm_large(bf_context_t *s,
     /* Q=A*B^-1 */
     if (mp_mul(s, tabt, tabb_inv, n + 1, taba + na - (n + 1), n + 1))
         goto fail;
-    
+
     for(i = 0; i < nq + 1; i++)
         tabq[i] = tabt[i + 2 * (n + 1) - (nq + 1)];
 #ifdef DEBUG_DIVNORM_LARGE
@@ -1483,7 +1483,7 @@ static int mp_divnorm_large(bf_context_t *s,
     bf_free(s, tabt);
     bf_free(s, tabb_inv);
     tabb_inv = NULL;
-    
+
     /* R=A-B*Q */
     tabt = bf_malloc(s, sizeof(limb_t) * (na + 1));
     if (!tabt)
@@ -1554,10 +1554,10 @@ int bf_mul(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
         bf_t tmp, *r1 = NULL;
         limb_t a_len, b_len, precl;
         limb_t *a_tab, *b_tab;
-            
+
         a_len = a->len;
         b_len = b->len;
-        
+
         if ((flags & BF_RND_MASK) == BF_RNDF) {
             /* faithful rounding does not require using the full inputs */
             precl = (prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
@@ -1566,7 +1566,7 @@ int bf_mul(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
         }
         a_tab = a->tab + a->len - a_len;
         b_tab = b->tab + b->len - b_len;
-        
+
 #ifdef USE_FFT_MUL
         if (b_len >= FFT_MUL_THRESHOLD) {
             int mul_flags = 0;
@@ -1622,7 +1622,7 @@ slimb_t bf_get_exp_min(const bf_t *a)
     slimb_t i;
     limb_t v;
     int k;
-    
+
     for(i = 0; i < a->len; i++) {
         v = a->tab[i];
         if (v != 0) {
@@ -1655,7 +1655,7 @@ static int __bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
     bf_context_t *s = r->ctx;
     int ret, r_sign;
     limb_t n, nb, precl;
-    
+
     r_sign = a->sign ^ b->sign;
     if (a->expn >= BF_EXP_INF || b->expn >= BF_EXP_INF) {
         if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
@@ -1688,11 +1688,11 @@ static int __bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
     precl = (prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
     nb = b->len;
     n = bf_max(a->len, precl);
-    
+
     {
         limb_t *taba, na;
         slimb_t d;
-        
+
         na = n + nb;
         taba = bf_malloc(s, (na + 1) * sizeof(limb_t));
         if (!taba)
@@ -1721,8 +1721,8 @@ static int __bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
     return BF_ST_MEM_ERROR;
 }
 
-/* division and remainder. 
-   
+/* division and remainder.
+
    rnd_mode is the rounding mode for the quotient. The additional
    rounding mode BF_RND_EUCLIDIAN is supported.
 
@@ -1736,11 +1736,11 @@ int bf_divrem(bf_t *q, bf_t *r, const bf_t *a, const bf_t *b,
     bf_t b1_s, *b1 = &b1_s;
     int q_sign, ret;
     BOOL is_ceil, is_rndn;
-    
+
     assert(q != a && q != b);
     assert(r != a && r != b);
     assert(q != r);
-    
+
     if (a->len == 0 || b->len == 0) {
         bf_set_zero(q, 0);
         if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
@@ -1782,7 +1782,7 @@ int bf_divrem(bf_t *q, bf_t *r, const bf_t *a, const bf_t *b,
     a1->tab = a->tab;
     a1->len = a->len;
     a1->sign = 0;
-    
+
     b1->expn = b->expn;
     b1->tab = b->tab;
     b1->len = b->len;
@@ -1828,7 +1828,7 @@ int bf_rem(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
 {
     bf_t q_s, *q = &q_s;
     int ret;
-    
+
     bf_init(r->ctx, q);
     ret = bf_divrem(q, r, a, b, prec, flags, rnd_mode);
     bf_delete(q);
@@ -1849,7 +1849,7 @@ int bf_remquo(slimb_t *pq, bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
 {
     bf_t q_s, *q = &q_s;
     int ret;
-    
+
     bf_init(r->ctx, q);
     ret = bf_divrem(q, r, a, b, prec, flags, rnd_mode);
     bf_get_limb(pq, q, BF_GET_INT_MOD);
@@ -1887,7 +1887,7 @@ static const uint16_t sqrt_table[192] = {
 static limb_t mp_sqrtrem1(limb_t *pr, limb_t a)
 {
     limb_t s1, r1, s, r, q, u, num;
-    
+
     /* use a table for the 16 -> 8 bit sqrt */
     s1 = sqrt_table[(a >> (LIMB_BITS - 8)) - 64];
     r1 = (a >> (LIMB_BITS - 16)) - s1 * s1;
@@ -1895,7 +1895,7 @@ static limb_t mp_sqrtrem1(limb_t *pr, limb_t a)
         r1 -= 2 * s1 + 1;
         s1++;
     }
-    
+
     /* one iteration to get a 32 -> 16 bit sqrt */
     num = (r1 << 8) | ((a >> (LIMB_BITS - 32 + 8)) & 0xff);
     q = num / (2 * s1); /* q <= 2^8 */
@@ -1977,7 +1977,7 @@ static int mp_sqrtrem_rec(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n,
                           limb_t *tmp_buf, limb_t *prh)
 {
     limb_t l, h, rh, ql, qh, c, i;
-    
+
     if (n == 1) {
         *prh = mp_sqrtrem2(tabs, taba);
         return 0;
@@ -1994,7 +1994,7 @@ static int mp_sqrtrem_rec(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n,
     mp_print_str_h("r1", taba + 2 * l, h, qh);
     mp_print_str_h("r2", taba + l, n, qh);
 #endif
-    
+
     /* the remainder is in taba + 2 * l. Its high bit is in qh */
     if (qh) {
         mp_sub(taba + 2 * l, taba + 2 * l, tabs + l, h, 0);
@@ -2016,12 +2016,12 @@ static int mp_sqrtrem_rec(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n,
     mp_print_str_h("q", tabs, l, qh);
     mp_print_str_h("u", taba + l, h, rh);
 #endif
-    
+
     mp_add_ui(tabs + l, qh, h);
 #ifdef DEBUG_SQRTREM
     mp_print_str_h("s2", tabs, n, sh);
 #endif
-    
+
     /* q = qh, tabs[l - 1 ... 0], r = taba[n - 1 ... l] */
     /* subtract q^2. if qh = 1 then q = B^l, so we can take shortcuts */
     if (qh) {
@@ -2073,7 +2073,7 @@ int mp_sqrtrem(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n)
 int bf_sqrtrem(bf_t *r, bf_t *rem1, const bf_t *a)
 {
     int ret;
-    
+
     if (a->len == 0) {
         if (a->expn == BF_EXP_NAN) {
             bf_set_nan(r);
@@ -2093,7 +2093,7 @@ int bf_sqrtrem(bf_t *r, bf_t *rem1, const bf_t *a)
         ret = BF_ST_INVALID_OP;
     } else {
         bf_t rem_s, *rem;
-        
+
         bf_sqrt(r, a, (a->expn + 1) / 2, BF_RNDZ);
         bf_rint(r, BF_RNDZ);
         /* see if the result is exact by computing the remainder */
@@ -2147,7 +2147,7 @@ int bf_sqrt(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
         limb_t *a1;
         slimb_t n, n1;
         limb_t res;
-        
+
         /* convert the mantissa to an integer with at least 2 *
            prec + 4 bits */
         n = (2 * (prec + 2) + 2 * LIMB_BITS - 1) / (2 * LIMB_BITS);
@@ -2192,7 +2192,7 @@ static no_inline int bf_op2(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
 {
     bf_t tmp;
     int ret;
-    
+
     if (r == a || r == b) {
         bf_init(r->ctx, &tmp);
         ret = func(&tmp, a, b, prec, flags);
@@ -2250,7 +2250,7 @@ int bf_add_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec,
 {
     bf_t b;
     int ret;
-    
+
     bf_init(r->ctx, &b);
     ret = bf_set_si(&b, b1);
     ret |= bf_add(r, a, &b, prec, flags);
@@ -2262,7 +2262,7 @@ static int bf_pow_ui(bf_t *r, const bf_t *a, limb_t b, limb_t prec,
                      bf_flags_t flags)
 {
     int ret, n_bits, i;
-    
+
     assert(r != a);
     if (b == 0)
         return bf_set_ui(r, 1);
@@ -2281,7 +2281,7 @@ static int bf_pow_ui_ui(bf_t *r, limb_t a1, limb_t b,
 {
     bf_t a;
     int ret;
-    
+
     if (a1 == 10 && b <= LIMB_DIGITS) {
         /* use precomputed powers. We do not round at this point
            because we expect the caller to do it */
@@ -2326,7 +2326,7 @@ static int bf_logic_op(bf_t *r, const bf_t *a1, const bf_t *b1, int op)
     slimb_t l, i, a_bit_offset, b_bit_offset;
     limb_t v1, v2, v1_mask, v2_mask, r_mask;
     int ret;
-    
+
     assert(r != a1 && r != b1);
 
     if (a1->expn <= 0)
@@ -2338,7 +2338,7 @@ static int bf_logic_op(bf_t *r, const bf_t *a1, const bf_t *b1, int op)
         b_sign = 0; /* minus zero is considered as positive */
     else
         b_sign = b1->sign;
-    
+
     if (a_sign) {
         a = &a1_s;
         bf_init(r->ctx, a);
@@ -2358,7 +2358,7 @@ static int bf_logic_op(bf_t *r, const bf_t *a1, const bf_t *b1, int op)
     } else {
         b = (bf_t *)b1;
     }
-    
+
     r_sign = bf_logic_op1(a_sign, b_sign, op);
     if (op == BF_LOGIC_AND && r_sign == 0) {
         /* no need to compute extra zeros for and */
@@ -2435,13 +2435,13 @@ int bf_get_float64(const bf_t *a, double *pres, bf_rnd_t rnd_mode)
     Float64Union u;
     int e, ret;
     uint64_t m;
-    
+
     ret = 0;
     if (a->expn == BF_EXP_NAN) {
         u.u = 0x7ff8000000000000; /* quiet nan */
     } else {
         bf_t b_s, *b = &b_s;
-        
+
         bf_init(a->ctx, b);
         bf_set(b, a);
         if (bf_is_finite(b)) {
@@ -2484,7 +2484,7 @@ int bf_set_float64(bf_t *a, double d)
     Float64Union u;
     uint64_t m;
     int shift, e, sgn;
-    
+
     u.d = d;
     sgn = u.u >> 63;
     e = (u.u >> 52) & ((1 << 11) - 1);
@@ -2555,7 +2555,7 @@ int bf_get_int32(int *pres, const bf_t *a, int flags)
         ret = BF_ST_INVALID_OP;
         if (a->sign) {
             v = (uint32_t)INT32_MAX + 1;
-            if (a->expn == 32 && 
+            if (a->expn == 32 &&
                 (a->tab[a->len - 1] >> (LIMB_BITS - 32)) == v) {
                 ret = 0;
             }
@@ -2563,7 +2563,7 @@ int bf_get_int32(int *pres, const bf_t *a, int flags)
             v = INT32_MAX;
         }
     } else {
-        v = get_bits(a->tab, a->len, a->len * LIMB_BITS - a->expn); 
+        v = get_bits(a->tab, a->len, a->len * LIMB_BITS - a->expn);
         if (a->sign)
             v = -v;
         ret = 0;
@@ -2621,7 +2621,7 @@ int bf_get_int64(int64_t *pres, const bf_t *a, int flags)
         }
     } else {
         slimb_t bit_pos = a->len * LIMB_BITS - a->expn;
-        v = get_bits(a->tab, a->len, bit_pos); 
+        v = get_bits(a->tab, a->len, bit_pos);
 #if LIMB_BITS == 32
         v |= (uint64_t)get_bits(a->tab, a->len, bit_pos + 32) << 32;
 #endif
@@ -2681,7 +2681,7 @@ static limb_t get_limb_radix(int radix)
 {
     int i, k;
     limb_t radixl;
-    
+
     k = digits_per_limb_table[radix - 2];
     radixl = radix;
     for(i = 1; i < k; i++)
@@ -2700,7 +2700,7 @@ static int bf_integer_from_radix_rec(bf_t *r, const limb_t *tab,
     } else {
         bf_t T_s, *T = &T_s, *B;
         limb_t n1, n2;
-        
+
         n2 = (((n0 * 2) >> (level + 1)) + 1) / 2;
         n1 = n - n2;
         //        printf("level=%d n0=%ld n1=%ld n2=%ld\n", level, n0, n1, n2);
@@ -2736,7 +2736,7 @@ static int bf_integer_from_radix(bf_t *r, const limb_t *tab,
     int pow_tab_len, i, ret;
     limb_t radixl;
     bf_t *pow_tab;
-    
+
     radixl = get_limb_radix(radix);
     pow_tab_len = ceil_log2(n) + 2; /* XXX: check */
     pow_tab = bf_malloc(s, sizeof(pow_tab[0]) * pow_tab_len);
@@ -2885,7 +2885,7 @@ static int bf_atof_internal(bf_t *r, slimb_t *pexponent,
     slimb_t pos, expn, int_len, digit_count;
     BOOL has_decpt, is_bin_exp;
     bf_t a_s, *a;
-    
+
     *pexponent = 0;
     p = str;
     if (!(flags & BF_ATOF_NO_NAN_INF) && radix <= 16 &&
@@ -2895,7 +2895,7 @@ static int bf_atof_internal(bf_t *r, slimb_t *pexponent,
         goto done;
     }
     is_neg = 0;
-    
+
     if (p[0] == '+') {
         p++;
         p_start = p;
@@ -2938,7 +2938,7 @@ static int bf_atof_internal(bf_t *r, slimb_t *pexponent,
             goto done;
         }
     }
-    
+
     if (radix == 0)
         radix = 10;
     if (is_dec) {
@@ -3029,7 +3029,7 @@ static int bf_atof_internal(bf_t *r, slimb_t *pexponent,
             goto done;
         }
     }
-            
+
     /* reset the next limbs to zero (we prefer to reallocate in the
        renormalization) */
     memset(a->tab, 0, (pos + 1) * sizeof(limb_t));
@@ -3087,7 +3087,7 @@ static int bf_atof_internal(bf_t *r, slimb_t *pexponent,
     } else if (radix_bits) {
         /* XXX: may overflow */
         if (!is_bin_exp)
-            expn *= radix_bits; 
+            expn *= radix_bits;
         a->expn = expn + (int_len * radix_bits);
         a->sign = is_neg;
         ret = bf_normalize_and_round(a, prec, flags);
@@ -3126,9 +3126,9 @@ static int bf_atof_internal(bf_t *r, slimb_t *pexponent,
     return ret;
 }
 
-/* 
+/*
    Return (status, n, exp). 'status' is the floating point status. 'n'
-   is the parsed number. 
+   is the parsed number.
 
    If (flags & BF_ATOF_EXPONENT) and if the radix is not a power of
    two, the parsed number is equal to r *
@@ -3343,7 +3343,7 @@ slimb_t bf_mul_log2_radix(slimb_t a1, unsigned int radix, int is_inv,
         const uint32_t *tab;
         limb_t b0, b1;
         dlimb_t t;
-        
+
         if (is_inv) {
             tab = inv_log2_radix[radix - 2];
 #if LIMB_BITS == 32
@@ -3377,7 +3377,7 @@ static int bf_integer_to_radix_rec(bf_t *pow_tab,
 {
     limb_t n1, n2, q_prec;
     int ret;
-    
+
     assert(n >= 1);
     if (n == 1) {
         out[0] = get_bits(a->tab, a->len, a->len * LIMB_BITS - a->expn);
@@ -3417,7 +3417,7 @@ static int bf_integer_to_radix_rec(bf_t *pow_tab,
         q_prec = n1 * radixl_bits;
         ret |= bf_mul(&Q, a, B_inv, q_prec, BF_RNDN);
         ret |= bf_rint(&Q, BF_RNDZ);
-        
+
         ret |= bf_mul(&R, &Q, B, BF_PREC_INF, BF_RNDZ);
         ret |= bf_sub(&R, a, &R, BF_PREC_INF, BF_RNDZ);
 
@@ -3462,7 +3462,7 @@ static int bf_integer_to_radix(bf_t *r, const bf_t *a, limb_t radixl)
     limb_t r_len;
     bf_t *pow_tab;
     int i, pow_tab_len, ret;
-    
+
     r_len = r->len;
     pow_tab_len = (ceil_log2(r_len) + 2) * 2; /* XXX: check */
     pow_tab = bf_malloc(s, sizeof(pow_tab[0]) * pow_tab_len);
@@ -3492,7 +3492,7 @@ static int bf_convert_to_radix(bf_t *r, slimb_t *pE,
     slimb_t E, e, prec, extra_bits, ziv_extra_bits, prec0;
     bf_t B_s, *B = &B_s;
     int e_sign, ret, res;
-    
+
     if (a->len == 0) {
         /* zero case */
         *pE = 0;
@@ -3507,7 +3507,7 @@ static int bf_convert_to_radix(bf_t *r, slimb_t *pE,
     }
     //    bf_print_str("a", a);
     //    printf("E=%ld P=%ld radix=%d\n", E, P, radix);
-    
+
     for(;;) {
         e = P - E;
         e_sign = 0;
@@ -3703,7 +3703,7 @@ static char *bf_ftoa_internal(size_t *plen, const bf_t *a2, int radix,
     bf_context_t *ctx = a2->ctx;
     DynBuf s_s, *s = &s_s;
     int radix_bits;
-    
+
     //    bf_print_str("ftoa", a2);
     //    printf("radix=%d\n", radix);
     dbuf_init2(s, ctx, bf_dbuf_realloc);
@@ -3785,7 +3785,7 @@ static char *bf_ftoa_internal(size_t *plen, const bf_t *a2, int radix,
                     a->len = a2->len;
                     a->expn = a2->expn;
                     a->sign = 0;
-                    
+
                     /* one more digit for the rounding */
                     n = 1 + bf_mul_log2_radix(bf_max(a->expn, 0), radix, TRUE, TRUE);
                     n_digits = n + prec;
@@ -3860,19 +3860,19 @@ static char *bf_ftoa_internal(size_t *plen, const bf_t *a2, int radix,
                     n = ceil_div(a1->expn, radix_bits);
                 } else {
                     bf_t a_s, *a = &a_s;
-                    
+
                     /* make a positive number */
                     a->tab = a2->tab;
                     a->len = a2->len;
                     a->expn = a2->expn;
                     a->sign = 0;
-                    
+
                     if (fmt == BF_FTOA_FORMAT_FIXED) {
                         n_digits = prec;
                         n_max = n_digits;
                     } else {
                         slimb_t n_digits_max, n_digits_min;
-                        
+
                         assert(prec != BF_PREC_INF);
                         n_digits = 1 + bf_mul_log2_radix(prec, radix, TRUE, TRUE);
                         /* max number of digits for non exponential
@@ -3881,7 +3881,7 @@ static char *bf_ftoa_internal(size_t *plen, const bf_t *a2, int radix,
                         n_max = n_digits + 4;
                         if (fmt == BF_FTOA_FORMAT_FREE_MIN) {
                             bf_t b_s, *b = &b_s;
-                            
+
                             /* find the minimum number of digits by
                                dichotomy. */
                             /* XXX: inefficient */
@@ -4020,7 +4020,7 @@ static void bf_const_log2_rec(bf_t *T, bf_t *P, bf_t *Q, limb_t n1,
         bf_t T1_s, *T1 = &T1_s;
         bf_t P1_s, *P1 = &P1_s;
         bf_t Q1_s, *Q1 = &Q1_s;
-        
+
         m = n1 + ((n2 - n1) >> 1);
         bf_const_log2_rec(T, P, Q, n1, m, TRUE);
         bf_init(s, T1);
@@ -4071,7 +4071,7 @@ static void chud_bs(bf_t *P, bf_t *Q, bf_t *G, int64_t a, int64_t b, int need_g,
 
     if (a == (b - 1)) {
         bf_t T0, T1;
-        
+
         bf_init(s, &T0);
         bf_init(s, &T1);
         bf_set_ui(G, 2 * b - 1);
@@ -4092,7 +4092,7 @@ static void chud_bs(bf_t *P, bf_t *Q, bf_t *G, int64_t a, int64_t b, int need_g,
         bf_delete(&T1);
     } else {
         bf_t P2, Q2, G2;
-        
+
         bf_init(s, &P2);
         bf_init(s, &Q2);
         bf_init(s, &G2);
@@ -4100,7 +4100,7 @@ static void chud_bs(bf_t *P, bf_t *Q, bf_t *G, int64_t a, int64_t b, int need_g,
         c = (a + b) / 2;
         chud_bs(P, Q, G, a, c, 1, prec);
         chud_bs(&P2, &Q2, &G2, c, b, need_g, prec);
-        
+
         /* Q = Q1 * Q2 */
         /* G = G1 * G2 */
         /* P = P1 * Q2 + P2 * G1 */
@@ -4136,11 +4136,11 @@ static void bf_const_pi_internal(bf_t *Q, limb_t prec)
     bf_init(s, &G);
 
     chud_bs(&P, Q, &G, 0, n, 0, BF_PREC_INF);
-    
+
     bf_mul_ui(&G, Q, CHUD_A, prec1, BF_RNDN);
     bf_add(&P, &G, &P, prec1, BF_RNDN);
     bf_div(Q, Q, &P, prec1, BF_RNDF);
- 
+
     bf_set_ui(&P, CHUD_C);
     bf_sqrt(&G, &P, prec1, BF_RNDF);
     bf_mul_ui(&G, &G, (uint64_t)CHUD_C / 12, prec1, BF_RNDF);
@@ -4223,7 +4223,7 @@ static int bf_ziv_rounding(bf_t *r, const bf_t *a,
 {
     int rnd_mode, ret;
     slimb_t prec1, ziv_extra_bits;
-    
+
     rnd_mode = flags & BF_RND_MASK;
     if (rnd_mode == BF_RNDF) {
         /* no need to iterate */
@@ -4282,7 +4282,7 @@ static int bf_exp_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
     bf_context_t *s = r->ctx;
     bf_t T_s, *T = &T_s;
     slimb_t n, K, l, i, prec1;
-    
+
     assert(r != a);
 
     /* argument reduction:
@@ -4315,14 +4315,14 @@ static int bf_exp_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
 
     /* reduce the range of T */
     bf_mul_2exp(T, -K, BF_PREC_INF, BF_RNDZ);
-    
+
     /* Taylor expansion around zero :
-     1 + x + x^2/2 + ... + x^n/n! 
+     1 + x + x^2/2 + ... + x^n/n!
      = (1 + x * (1 + x/2 * (1 + ... (x/n))))
     */
     {
         bf_t U_s, *U = &U_s;
-        
+
         bf_init(s, U);
         bf_set_ui(r, 1);
         for(i = l ; i >= 1; i--) {
@@ -4334,7 +4334,7 @@ static int bf_exp_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
         bf_delete(U);
     }
     bf_delete(T);
-    
+
     /* undo the range reduction */
     for(i = 0; i < K; i++) {
         bf_mul(r, r, r, prec1, BF_RNDN | BF_FLAG_EXT_EXP);
@@ -4354,7 +4354,7 @@ static int check_exp_underflow_overflow(bf_context_t *s, bf_t *r,
     bf_t T_s, *T = &T_s;
     bf_t log2_s, *log2 = &log2_s;
     slimb_t e_min, e_max;
-    
+
     if (a_high->expn <= 0)
         return 0;
 
@@ -4362,7 +4362,7 @@ static int check_exp_underflow_overflow(bf_context_t *s, bf_t *r,
     e_min = -e_max + 3;
     if (flags & BF_FLAG_SUBNORMAL)
         e_min -= (prec - 1);
-    
+
     bf_init(s, T);
     bf_init(s, log2);
     bf_const_log2(log2, LIMB_BITS, BF_RNDU);
@@ -4379,7 +4379,7 @@ static int check_exp_underflow_overflow(bf_context_t *s, bf_t *r,
     bf_mul_si(T, log2, e_min - 2, LIMB_BITS, BF_RNDD);
     if (bf_cmp_lt(a_high, T)) {
         int rnd_mode = flags & BF_RND_MASK;
-        
+
         /* underflow */
         bf_delete(T);
         bf_delete(log2);
@@ -4419,12 +4419,12 @@ int bf_exp(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
     ret = check_exp_underflow_overflow(s, r, a, a, prec, flags);
     if (ret)
         return ret;
-    if (a->expn < 0 && (-a->expn) >= (prec + 2)) { 
+    if (a->expn < 0 && (-a->expn) >= (prec + 2)) {
         /* small argument case: result = 1 + epsilon * sign(x) */
         bf_set_ui(r, 1);
         return bf_add_epsilon(r, r, -(prec + 2), a->sign, prec, flags);
     }
-                         
+
     return bf_ziv_rounding(r, a, prec, flags, bf_exp_internal, NULL);
 }
 
@@ -4435,7 +4435,7 @@ static int bf_log_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
     bf_t U_s, *U = &U_s;
     bf_t V_s, *V = &V_s;
     slimb_t n, prec1, l, i, K;
-    
+
     assert(r != a);
 
     bf_init(s, T);
@@ -4448,7 +4448,7 @@ static int bf_log_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
         T->expn = 0;
         /* U= ~ 2/3 */
         bf_init(s, U);
-        bf_set_ui(U, 0xaaaaaaaa); 
+        bf_set_ui(U, 0xaaaaaaaa);
         U->expn = 0;
         if (bf_cmp_lt(T, U)) {
             T->expn++;
@@ -4461,18 +4461,18 @@ static int bf_log_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
 
     /* XXX: precision analysis */
     /* number of iterations for argument reduction 2 */
-    K = bf_isqrt((prec + 1) / 2); 
+    K = bf_isqrt((prec + 1) / 2);
     /* order of Taylor expansion */
-    l = prec / (2 * K) + 1; 
+    l = prec / (2 * K) + 1;
     /* precision of the intermediate computations */
     prec1 = prec + K + 2 * l + 32;
 
     bf_init(s, U);
     bf_init(s, V);
-    
+
     /* Note: cancellation occurs here, so we use more precision (XXX:
        reduce the precision by computing the exact cancellation) */
-    bf_add_si(T, T, -1, BF_PREC_INF, BF_RNDN); 
+    bf_add_si(T, T, -1, BF_PREC_INF, BF_RNDN);
 
     /* argument reduction 2 */
     for(i = 0; i < K; i++) {
@@ -4490,7 +4490,7 @@ static int bf_log_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
         bf_init(s, Y2);
 
         /* compute ln(1+x) = ln((1+y)/(1-y)) with y=x/(2+x)
-           = y + y^3/3 + ... + y^(2*l + 1) / (2*l+1) 
+           = y + y^3/3 + ... + y^(2*l + 1) / (2*l+1)
            with Y=Y^2
            = y*(1+Y/3+Y^2/5+...) = y*(1+Y*(1/3+Y*(1/5 + ...)))
         */
@@ -4517,12 +4517,12 @@ static int bf_log_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
     /* multiplication by 2 for the Taylor expansion and undo the
        argument reduction 2*/
     bf_mul_2exp(r, K + 1, BF_PREC_INF, BF_RNDZ);
-    
+
     /* undo the argument reduction 1 */
     bf_const_log2(T, prec1, BF_RNDF);
     bf_mul_si(T, T, n, prec1, BF_RNDN);
     bf_add(r, r, T, prec1, BF_RNDN);
-    
+
     bf_delete(T);
     return BF_ST_INEXACT;
 }
@@ -4531,7 +4531,7 @@ int bf_log(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
 {
     bf_context_t *s = r->ctx;
     bf_t T_s, *T = &T_s;
-    
+
     assert(r != a);
     if (a->len == 0) {
         if (a->expn == BF_EXP_NAN) {
@@ -4596,7 +4596,7 @@ static int bf_pow_int(bf_t *r, const bf_t *x, limb_t prec, void *opaque)
     limb_t prec1;
     int ret;
     slimb_t y1;
-    
+
     bf_get_limb(&y1, y, 0);
     if (y1 < 0)
         y1 = -y1;
@@ -4621,7 +4621,7 @@ static BOOL check_exact_power2n(bf_t *r, const bf_t *x, slimb_t n)
     bf_t T_s, *T = &T_s;
     slimb_t e, i, er;
     limb_t v;
-    
+
     /* x = m*2^e with m odd integer */
     e = bf_get_exp_min(x);
     /* fast check on the exponent */
@@ -4661,7 +4661,7 @@ int bf_pow(bf_t *r, const bf_t *x, const bf_t *y, limb_t prec, bf_flags_t flags)
     BOOL y_is_int, y_is_odd;
     int r_sign, ret, rnd_mode;
     slimb_t y_emin;
-    
+
     if (x->len == 0 || y->len == 0) {
         if (y->expn == BF_EXP_ZERO) {
             /* pow(x, 0) = 1 */
@@ -4735,7 +4735,7 @@ int bf_pow(bf_t *r, const bf_t *x, const bf_t *y, limb_t prec, bf_flags_t flags)
             bf_t al_s, *al = &al_s;
             bf_t ah_s, *ah = &ah_s;
             limb_t precl = LIMB_BITS;
-            
+
             bf_init(s, al);
             bf_init(s, ah);
             /* compute bounds of log(abs(x)) * y with a low precision */
@@ -4751,7 +4751,7 @@ int bf_pow(bf_t *r, const bf_t *x, const bf_t *y, limb_t prec, bf_flags_t flags)
             if (ret)
                 goto done;
         }
-        
+
         if (y_is_int) {
             slimb_t T_bits, e;
         int_pow:
@@ -4846,18 +4846,18 @@ static int bf_sincos(bf_t *s, bf_t *c, const bf_t *a, limb_t prec)
     bf_t r_s, *r = &r_s;
     slimb_t K, prec1, i, l, mod, prec2;
     int is_neg;
-    
+
     assert(c != a && s != a);
 
     bf_init(s1, T);
     bf_init(s1, U);
     bf_init(s1, r);
-    
+
     /* XXX: precision analysis */
     K = bf_isqrt(prec / 2);
     l = prec / (2 * K) + 1;
     prec1 = prec + 2 * K + l + 8;
-    
+
     /* after the modulo reduction, -pi/4 <= T <= pi/4 */
     if (a->expn <= -1) {
         /* abs(a) <= 0.25: no modulo reduction needed */
@@ -4880,13 +4880,13 @@ static int bf_sincos(bf_t *s, bf_t *c, const bf_t *a, limb_t prec)
         }
         mod &= 3;
     }
-    
+
     is_neg = T->sign;
-        
+
     /* compute cosm1(x) = cos(x) - 1 */
     bf_mul(T, T, T, prec1, BF_RNDN);
     bf_mul_2exp(T, -2 * K, BF_PREC_INF, BF_RNDZ);
-    
+
     /* Taylor expansion:
        -x^2/2 + x^4/4! - x^6/6! + ...
     */
@@ -4965,7 +4965,7 @@ int bf_cos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
             return bf_add_epsilon(r, r, e, 1, prec, flags);
         }
     }
-    
+
     return bf_ziv_rounding(r, a, prec, flags, bf_cos_internal, NULL);
 }
 
@@ -5008,7 +5008,7 @@ static int bf_tan_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
     bf_context_t *s = r->ctx;
     bf_t T_s, *T = &T_s;
     limb_t prec1;
-    
+
     /* XXX: precision analysis */
     prec1 = prec + 8;
     bf_init(s, T);
@@ -5044,7 +5044,7 @@ int bf_tan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
             return bf_add_epsilon(r, r, e, a->sign, prec, flags);
         }
     }
-            
+
     return bf_ziv_rounding(r, a, prec, flags, bf_tan_internal, NULL);
 }
 
@@ -5061,13 +5061,13 @@ static int bf_atan_internal(bf_t *r, const bf_t *a, limb_t prec,
     bf_t X2_s, *X2 = &X2_s;
     int cmp_1;
     slimb_t prec1, i, K, l;
-    
+
     /* XXX: precision analysis */
     K = bf_isqrt((prec + 1) / 2);
     l = prec / (2 * K) + 1;
     prec1 = prec + K + 2 * l + 32;
     //    printf("prec=%d K=%d l=%d prec1=%d\n", (int)prec, (int)K, (int)l, (int)prec1);
-    
+
     bf_init(s, T);
     cmp_1 = (a->expn >= 1); /* a >= 1 */
     if (cmp_1) {
@@ -5093,8 +5093,8 @@ static int bf_atan_internal(bf_t *r, const bf_t *a, limb_t prec,
         bf_div(T, T, V, prec1, BF_RNDN);
     }
 
-    /* Taylor series: 
-       x - x^3/3 + ... + (-1)^ l * y^(2*l + 1) / (2*l+1) 
+    /* Taylor series:
+       x - x^3/3 + ... + (-1)^ l * y^(2*l + 1) / (2*l+1)
     */
     bf_mul(X2, T, T, prec1, BF_RNDN);
     bf_set_ui(r, 0);
@@ -5112,7 +5112,7 @@ static int bf_atan_internal(bf_t *r, const bf_t *a, limb_t prec,
 
     /* undo the argument reduction */
     bf_mul_2exp(r, K, BF_PREC_INF, BF_RNDZ);
-    
+
     bf_delete(U);
     bf_delete(V);
     bf_delete(X2);
@@ -5131,7 +5131,7 @@ static int bf_atan_internal(bf_t *r, const bf_t *a, limb_t prec,
         T->sign = (i < 0);
         bf_add(r, T, r, prec1, BF_RNDN);
     }
-    
+
     bf_delete(T);
     return BF_ST_INEXACT;
 }
@@ -5141,7 +5141,7 @@ int bf_atan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
     bf_context_t *s = r->ctx;
     bf_t T_s, *T = &T_s;
     int res;
-    
+
     if (a->len == 0) {
         if (a->expn == BF_EXP_NAN) {
             bf_set_nan(r);
@@ -5156,7 +5156,7 @@ int bf_atan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
             return 0;
         }
     }
-    
+
     bf_init(s, T);
     bf_set_ui(T, 1);
     res = bf_cmpu(a, T);
@@ -5178,7 +5178,7 @@ int bf_atan(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
             return bf_add_epsilon(r, r, e, 1 - a->sign, prec, flags);
         }
     }
-    
+
     return bf_ziv_rounding(r, a, prec, flags, bf_atan_internal, (void *)FALSE);
 }
 
@@ -5189,7 +5189,7 @@ static int bf_atan2_internal(bf_t *r, const bf_t *y, limb_t prec, void *opaque)
     bf_t T_s, *T = &T_s;
     limb_t prec1;
     int ret;
-    
+
     if (y->expn == BF_EXP_NAN || x->expn == BF_EXP_NAN) {
         bf_set_nan(r);
         return 0;
@@ -5232,8 +5232,8 @@ static int bf_asin_internal(bf_t *r, const bf_t *a, limb_t prec, void *opaque)
     BOOL is_acos = (BOOL)(intptr_t)opaque;
     bf_t T_s, *T = &T_s;
     limb_t prec1, prec2;
-    
-    /* asin(x) = atan(x/sqrt(1-x^2)) 
+
+    /* asin(x) = atan(x/sqrt(1-x^2))
        acos(x) = pi/2 - asin(x) */
     prec1 = prec + 8;
     /* increase the precision in x^2 to compensate the cancellation in
@@ -5283,7 +5283,7 @@ int bf_asin(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
         bf_set_nan(r);
         return BF_ST_INVALID_OP;
     }
-    
+
     /* small argument case: result = x+r(x) with r(x) = x^3/6 +
        O(X^5). We assume r(x) < 2^(3*EXP(x) - 2). */
     if (a->expn < 0) {
@@ -5328,7 +5328,7 @@ int bf_acos(bf_t *r, const bf_t *a, limb_t prec, bf_flags_t flags)
         bf_set_zero(r, 0);
         return 0;
     }
-    
+
     return bf_ziv_rounding(r, a, prec, flags, bf_asin_internal, (void *)TRUE);
 }
 
@@ -5561,8 +5561,8 @@ static inline limb_t fast_shr_dec(limb_t a, int shift)
 
 /* division and remainder by 10^shift */
 #define fast_shr_rem_dec(q, r, a, shift) q = fast_shr_dec(a, shift), r = a - q * mp_pow_dec[shift]
-    
-limb_t mp_add_dec(limb_t *res, const limb_t *op1, const limb_t *op2, 
+
+limb_t mp_add_dec(limb_t *res, const limb_t *op1, const limb_t *op2,
                   mp_size_t n, limb_t carry)
 {
     limb_t base = BF_DEC_BASE;
@@ -5575,7 +5575,7 @@ limb_t mp_add_dec(limb_t *res, const limb_t *op1, const limb_t *op2,
         v = op1[i];
         a = v + op2[i] + k - base;
         k = a <= v;
-        if (!k) 
+        if (!k)
             a += base;
         res[i]=a;
     }
@@ -5593,7 +5593,7 @@ limb_t mp_add_ui_dec(limb_t *tab, limb_t b, mp_size_t n)
         v = tab[i];
         a = v + k - base;
         k = a <= v;
-        if (!k) 
+        if (!k)
             a += base;
         tab[i] = a;
         if (k == 0)
@@ -5602,7 +5602,7 @@ limb_t mp_add_ui_dec(limb_t *tab, limb_t b, mp_size_t n)
     return k;
 }
 
-limb_t mp_sub_dec(limb_t *res, const limb_t *op1, const limb_t *op2, 
+limb_t mp_sub_dec(limb_t *res, const limb_t *op1, const limb_t *op2,
                   mp_size_t n, limb_t carry)
 {
     limb_t base = BF_DEC_BASE;
@@ -5626,7 +5626,7 @@ limb_t mp_sub_ui_dec(limb_t *tab, limb_t b, mp_size_t n)
     limb_t base = BF_DEC_BASE;
     mp_size_t i;
     limb_t k, v, a;
-    
+
     k=b;
     for(i=0;i<n;i++) {
         v = tab[i];
@@ -5642,7 +5642,7 @@ limb_t mp_sub_ui_dec(limb_t *tab, limb_t b, mp_size_t n)
 }
 
 /* taba[] = taba[] * b + l. 0 <= b, l <= base - 1. Return the high carry */
-limb_t mp_mul1_dec(limb_t *tabr, const limb_t *taba, mp_size_t n, 
+limb_t mp_mul1_dec(limb_t *tabr, const limb_t *taba, mp_size_t n,
                    limb_t b, limb_t l)
 {
     mp_size_t i;
@@ -5704,13 +5704,13 @@ limb_t mp_sub_mul1_dec(limb_t *tabr, const limb_t *taba, mp_size_t n,
 }
 
 /* size of the result : op1_size + op2_size. */
-void mp_mul_basecase_dec(limb_t *result, 
-                         const limb_t *op1, mp_size_t op1_size, 
-                         const limb_t *op2, mp_size_t op2_size) 
+void mp_mul_basecase_dec(limb_t *result,
+                         const limb_t *op1, mp_size_t op1_size,
+                         const limb_t *op2, mp_size_t op2_size)
 {
     mp_size_t i;
     limb_t r;
-    
+
     result[op1_size] = mp_mul1_dec(result, op1, op1_size, op2[0], 0);
 
     for(i=1;i<op2_size;i++) {
@@ -5721,7 +5721,7 @@ void mp_mul_basecase_dec(limb_t *result,
 
 /* taba[] = (taba[] + r*base^na) / b. 0 <= b < base. 0 <= r <
    b. Return the remainder. */
-limb_t mp_div1_dec(limb_t *tabr, const limb_t *taba, mp_size_t na, 
+limb_t mp_div1_dec(limb_t *tabr, const limb_t *taba, mp_size_t na,
                    limb_t b, limb_t r)
 {
     limb_t base = BF_DEC_BASE;
@@ -5745,7 +5745,7 @@ limb_t mp_div1_dec(limb_t *tabr, const limb_t *taba, mp_size_t na,
         }
         if (r)
             r = 1;
-    } else 
+    } else
 #endif
     if (na >= UDIV1NORM_THRESHOLD) {
         shift = clz(b);
@@ -5815,7 +5815,7 @@ static __maybe_unused void mp_print_str_h_dec(const char *str,
 
 #define DIV_STATIC_ALLOC_LEN 16
 
-/* return q = a / b and r = a % b. 
+/* return q = a / b and r = a % b.
 
    taba[na] must be allocated if tabb1[nb - 1] < B / 2.  tabb1[nb - 1]
    must be != zero. na must be >= nb. 's' can be NULL if tabb1[nb - 1]
@@ -5829,14 +5829,14 @@ static __maybe_unused void mp_print_str_h_dec(const char *str,
 */
 /* XXX: optimize */
 static int mp_div_dec(bf_context_t *s, limb_t *tabq,
-                      limb_t *taba, mp_size_t na, 
+                      limb_t *taba, mp_size_t na,
                       const limb_t *tabb1, mp_size_t nb)
 {
     limb_t base = BF_DEC_BASE;
     limb_t r, mult, t0, t1, a, c, q, v, *tabb;
     mp_size_t i, j;
     limb_t static_tabb[DIV_STATIC_ALLOC_LEN];
-    
+
 #ifdef DEBUG_DIV_SLOW
     mp_print_str_dec("a", taba, na);
     mp_print_str_dec("b", tabb1, nb);
@@ -5934,7 +5934,7 @@ static int mp_div_dec(bf_context_t *s, limb_t *tabq,
 }
 
 /* divide by 10^shift */
-static limb_t mp_shr_dec(limb_t *tab_r, const limb_t *tab, mp_size_t n, 
+static limb_t mp_shr_dec(limb_t *tab_r, const limb_t *tab, mp_size_t n,
                          limb_t shift, limb_t high)
 {
     mp_size_t i;
@@ -5952,7 +5952,7 @@ static limb_t mp_shr_dec(limb_t *tab_r, const limb_t *tab, mp_size_t n,
 }
 
 /* multiply by 10^shift */
-static limb_t mp_shl_dec(limb_t *tab_r, const limb_t *tab, mp_size_t n, 
+static limb_t mp_shl_dec(limb_t *tab_r, const limb_t *tab, mp_size_t n,
                          limb_t shift, limb_t low)
 {
     mp_size_t i;
@@ -5998,7 +5998,7 @@ static limb_t mp_sqrtrem_rec_dec(limb_t *tabs, limb_t *taba, limb_t n,
                                  limb_t *tmp_buf)
 {
     limb_t l, h, rh, ql, qh, c, i;
-    
+
     if (n == 1)
         return mp_sqrtrem2_dec(tabs, taba);
 #ifdef DEBUG_SQRTREM_DEC
@@ -6012,7 +6012,7 @@ static limb_t mp_sqrtrem_rec_dec(limb_t *tabs, limb_t *taba, limb_t n,
     mp_print_str_h_dec("r1", taba + 2 * l, h, qh);
     mp_print_str_h_dec("r2", taba + l, n, qh);
 #endif
-    
+
     /* the remainder is in taba + 2 * l. Its high bit is in qh */
     if (qh) {
         mp_sub_dec(taba + 2 * l, taba + 2 * l, tabs + l, h, 0);
@@ -6033,12 +6033,12 @@ static limb_t mp_sqrtrem_rec_dec(limb_t *tabs, limb_t *taba, limb_t n,
     mp_print_str_h_dec("q", tabs, l, qh);
     mp_print_str_h_dec("u", taba + l, h, rh);
 #endif
-    
+
     mp_add_ui_dec(tabs + l, qh, h);
 #ifdef DEBUG_SQRTREM_DEC
     mp_print_str_dec("s2", tabs, n);
 #endif
-    
+
     /* q = qh, tabs[l - 1 ... 0], r = taba[n - 1 ... l] */
     /* subtract q^2. if qh = 1 then q = B^l, so we can take shortcuts */
     if (qh) {
@@ -6332,7 +6332,7 @@ static limb_t get_digits(const limb_t *tab, limb_t len, slimb_t pos)
     limb_t a0, a1;
     int shift;
     slimb_t i;
-    
+
     i = floor_div(pos, LIMB_DIGITS);
     shift = pos - i * LIMB_DIGITS;
     if (i >= 0 && i < len)
@@ -6360,7 +6360,7 @@ static int bfdec_get_rnd_add(int *pret, const bfdec_t *r, limb_t l,
 {
     int add_one, inexact;
     limb_t digit1, digit0;
-    
+
     //    bfdec_print_str("get_rnd_add", r);
     if (rnd_mode == BF_RNDF) {
         digit0 = 1; /* faithful rounding does not honor the INEXACT flag */
@@ -6372,7 +6372,7 @@ static int bfdec_get_rnd_add(int *pret, const bfdec_t *r, limb_t l,
     /* get the digit at 'prec' */
     digit1 = get_digit(r->tab, l, l * LIMB_DIGITS - 1 - prec);
     inexact = (digit1 | digit0) != 0;
-    
+
     add_one = 0;
     switch(rnd_mode) {
     case BF_RNDZ:
@@ -6405,7 +6405,7 @@ static int bfdec_get_rnd_add(int *pret, const bfdec_t *r, limb_t l,
     default:
         abort();
     }
-    
+
     if (inexact)
         *pret |= BF_ST_INEXACT;
     return add_one;
@@ -6425,7 +6425,7 @@ static int __bfdec_round(bfdec_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
     e_range = (limb_t)1 << (bf_get_exp_bits(flags) - 1);
     e_min = -e_range + 3;
     e_max = e_range;
-    
+
     if (flags & BF_FLAG_RADPNT_PREC) {
         /* 'prec' is the precision after the decimal point */
         if (prec1 != BF_PREC_INF)
@@ -6440,12 +6440,12 @@ static int __bfdec_round(bfdec_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
     } else {
         prec = prec1;
     }
-    
+
     /* round to prec bits */
     rnd_mode = flags & BF_RND_MASK;
     ret = 0;
     add_one = bfdec_get_rnd_add(&ret, r, l, prec, rnd_mode);
-    
+
     if (prec <= 0) {
         if (add_one) {
             bfdec_resize(r, 1); /* cannot fail because r is non zero */
@@ -6458,7 +6458,7 @@ static int __bfdec_round(bfdec_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
         }
     } else if (add_one) {
         limb_t carry;
-        
+
         /* add one starting at digit 'prec - 1' */
         bit_pos = l * LIMB_DIGITS - 1 - (prec - 1);
         pos = bit_pos / LIMB_DIGITS;
@@ -6470,7 +6470,7 @@ static int __bfdec_round(bfdec_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
             r->expn++;
         }
     }
-    
+
     /* check underflow */
     if (unlikely(r->expn < e_min)) {
         if (flags & BF_FLAG_SUBNORMAL) {
@@ -6484,14 +6484,14 @@ static int __bfdec_round(bfdec_t *r, limb_t prec1, bf_flags_t flags, limb_t l)
             return ret;
         }
     }
-    
+
     /* check overflow */
     if (unlikely(r->expn > e_max)) {
         bfdec_set_inf(r, r->sign);
         ret |= BF_ST_OVERFLOW | BF_ST_INEXACT;
         return ret;
     }
-    
+
     /* keep the bits starting at 'prec - 1' */
     bit_pos = l * LIMB_DIGITS - 1 - (prec - 1);
     i = floor_div(bit_pos, LIMB_DIGITS);
@@ -6528,7 +6528,7 @@ int bfdec_normalize_and_round(bfdec_t *r, limb_t prec1, bf_flags_t flags)
 {
     limb_t l, v;
     int shift, ret;
-    
+
     //    bfdec_print_str("bf_renorm", r);
     l = r->len;
     while (l > 0 && r->tab[l - 1] == 0)
@@ -6645,7 +6645,7 @@ static int bfdec_add_internal(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, li
         limb_t *b1_tab;
         int b_shift;
         mp_size_t b1_len;
-        
+
         d = a->expn - b->expn;
 
         /* XXX: not efficient in time and memory if the precision is
@@ -6661,7 +6661,7 @@ static int bfdec_add_internal(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, li
             r->tab[i] = 0;
         for(i = 0; i < a->len; i++)
             r->tab[a_offset + i] = a->tab[i];
-        
+
         b_shift = d % LIMB_DIGITS;
         if (b_shift == 0) {
             b1_len = b->len;
@@ -6675,7 +6675,7 @@ static int bfdec_add_internal(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, li
                 mp_pow_dec[LIMB_DIGITS - b_shift];
         }
         b_offset = r_len - (b->len + (d + LIMB_DIGITS - 1) / LIMB_DIGITS);
-        
+
         if (is_sub) {
             carry = mp_sub_dec(r->tab + b_offset, r->tab + b_offset,
                                b1_tab, b1_len, 0);
@@ -6771,12 +6771,12 @@ int bfdec_mul(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
         bfdec_t tmp, *r1 = NULL;
         limb_t a_len, b_len;
         limb_t *a_tab, *b_tab;
-            
+
         a_len = a->len;
         b_len = b->len;
         a_tab = a->tab;
         b_tab = b->tab;
-        
+
         if (r == a || r == b) {
             bfdec_init(r->ctx, &tmp);
             r1 = r;
@@ -6815,7 +6815,7 @@ int bfdec_add_si(bfdec_t *r, const bfdec_t *a, int64_t b1, limb_t prec,
 {
     bfdec_t b;
     int ret;
-    
+
     bfdec_init(r->ctx, &b);
     ret = bfdec_set_si(&b, b1);
     ret |= bfdec_add(r, a, &b, prec, flags);
@@ -6828,7 +6828,7 @@ static int __bfdec_div(bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
 {
     int ret, r_sign;
     limb_t n, nb, precl;
-    
+
     r_sign = a->sign ^ b->sign;
     if (a->expn >= BF_EXP_INF || b->expn >= BF_EXP_INF) {
         if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
@@ -6873,11 +6873,11 @@ static int __bfdec_div(bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
         precl = (prec + 2 + LIMB_DIGITS - 1) / LIMB_DIGITS;
     }
     n = bf_max(a->len, precl);
-    
+
     {
         limb_t *taba, na, i;
         slimb_t d;
-        
+
         na = n + nb;
         taba = bf_malloc(r->ctx, (na + 1) * sizeof(limb_t));
         if (!taba)
@@ -6938,8 +6938,8 @@ static void bfdec_tdivremu(bf_context_t *s, bfdec_t *q, bfdec_t *r,
     }
 }
 
-/* division and remainder. 
-   
+/* division and remainder.
+
    rnd_mode is the rounding mode for the quotient. The additional
    rounding mode BF_RND_EUCLIDIAN is supported.
 
@@ -6955,11 +6955,11 @@ int bfdec_divrem(bfdec_t *q, bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
     bfdec_t r1_s, *r1 = &r1_s;
     int q_sign, res;
     BOOL is_ceil, is_rndn;
-    
+
     assert(q != a && q != b);
     assert(r != a && r != b);
     assert(q != r);
-    
+
     if (a->len == 0 || b->len == 0) {
         bfdec_set_zero(q, 0);
         if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
@@ -7001,7 +7001,7 @@ int bfdec_divrem(bfdec_t *q, bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
     a1->tab = a->tab;
     a1->len = a->len;
     a1->sign = 0;
-    
+
     b1->expn = b->expn;
     b1->tab = b->tab;
     b1->len = b->len;
@@ -7015,7 +7015,7 @@ int bfdec_divrem(bfdec_t *q, bfdec_t *r, const bfdec_t *a, const bfdec_t *b,
         goto fail;
     //    bfdec_print_str("q", q);
     //    bfdec_print_str("r", r);
-    
+
     if (r->len != 0) {
         if (is_rndn) {
             bfdec_init(s, r1);
@@ -7056,7 +7056,7 @@ int bfdec_rem(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
 {
     bfdec_t q_s, *q = &q_s;
     int ret;
-    
+
     bfdec_init(r->ctx, q);
     ret = bfdec_divrem(q, r, a, b, prec, flags, rnd_mode);
     bfdec_delete(q);
@@ -7204,7 +7204,7 @@ int bfdec_get_int32(int *pres, const bfdec_t *a)
 int bfdec_pow_ui(bfdec_t *r, const bfdec_t *a, limb_t b)
 {
     int ret, n_bits, i;
-    
+
     assert(r != a);
     if (b == 0)
         return bfdec_set_ui(r, 1);
@@ -7344,7 +7344,7 @@ static const limb_t ntt_mods_cr[NB_MODS * (NB_MODS - 1) / 2] = {
 
 typedef struct BFNTTState {
     bf_context_t *ctx;
-    
+
     /* used for mul_mod_fast() */
     limb_t ntt_mods_div[NB_MODS];
 
@@ -7384,16 +7384,16 @@ static inline limb_t sub_mod(limb_t a, limb_t b, limb_t m)
     return r;
 }
 
-/* return (r0+r1*B) mod m 
-   precondition: 0 <= r0+r1*B < 2^(64+NTT_MOD_LOG2_MIN) 
+/* return (r0+r1*B) mod m
+   precondition: 0 <= r0+r1*B < 2^(64+NTT_MOD_LOG2_MIN)
 */
-static inline limb_t mod_fast(dlimb_t r, 
+static inline limb_t mod_fast(dlimb_t r,
                                 limb_t m, limb_t m_inv)
 {
     limb_t a1, q, t0, r1, r0;
-    
+
     a1 = r >> NTT_MOD_LOG2_MIN;
-    
+
     q = ((dlimb_t)a1 * m_inv) >> LIMB_BITS;
     r = r - (dlimb_t)q * m - m * 2;
     r1 = r >> LIMB_BITS;
@@ -7405,9 +7405,9 @@ static inline limb_t mod_fast(dlimb_t r,
     return r0;
 }
 
-/* faster version using precomputed modulo inverse. 
+/* faster version using precomputed modulo inverse.
    precondition: 0 <= a * b < 2^(64+NTT_MOD_LOG2_MIN) */
-static inline limb_t mul_mod_fast(limb_t a, limb_t b, 
+static inline limb_t mul_mod_fast(limb_t a, limb_t b,
                                     limb_t m, limb_t m_inv)
 {
     dlimb_t r;
@@ -7426,7 +7426,7 @@ static inline limb_t init_mul_mod_fast(limb_t m)
 
 /* Faster version used when the multiplier is constant. 0 <= a < 2^64,
    0 <= b < m. */
-static inline limb_t mul_mod_fast2(limb_t a, limb_t b, 
+static inline limb_t mul_mod_fast2(limb_t a, limb_t b,
                                      limb_t m, limb_t b_inv)
 {
     limb_t r, q;
@@ -7441,7 +7441,7 @@ static inline limb_t mul_mod_fast2(limb_t a, limb_t b,
 /* Faster version used when the multiplier is constant. 0 <= a < 2^64,
    0 <= b < m. Let r = a * b mod m. The return value is 'r' or 'r +
    m'. */
-static inline limb_t mul_mod_fast3(limb_t a, limb_t b, 
+static inline limb_t mul_mod_fast3(limb_t a, limb_t b,
                                      limb_t m, limb_t b_inv)
 {
     limb_t r, q;
@@ -7547,9 +7547,9 @@ static no_inline int ntt_fft(BFNTTState *s,
     __m256d m_inv, mf, m2f, c, a0, a1, b0, b1;
     limb_t m;
     int l;
-    
+
     m = ntt_mods[m_idx];
-    
+
     m_inv = _mm256_set1_pd(1.0 / (double)m);
     mf = _mm256_set1_pd(m);
     m2f = _mm256_set1_pd(m * 2);
@@ -7603,7 +7603,7 @@ static no_inline int ntt_fft(BFNTTState *s,
     tmp = tab_in;
     tab_in = tab_out;
     tab_out = tmp;
-    
+
     nb_blocks = n / 4;
     fft_per_block = 4;
 
@@ -7654,7 +7654,7 @@ static void ntt_vec_mul(BFNTTState *s,
 {
     limb_t i, c_inv, n, m;
     __m256d m_inv, mf, a, b, c;
-    
+
     m = ntt_mods[m_idx];
     c_inv = s->ntt_len_inv[m_idx][k_tot][0];
     m_inv = _mm256_set1_pd(1.0 / (double)m);
@@ -7676,7 +7676,7 @@ static no_inline void mul_trig(NTTLimb *buf,
     limb_t i, c2, c3, c4;
     __m256d c, c_mul, a0, mf, m_inv;
     assert(n >= 2);
-    
+
     mf = _mm256_set1_pd(m);
     m_inv = _mm256_set1_pd(1.0 / (double)m);
 
@@ -7725,7 +7725,7 @@ static no_inline int ntt_fft(BFNTTState *s, NTTLimb *out_buf, NTTLimb *in_buf,
     limb_t nb_blocks, fft_per_block, p, k, n, stride_in, i, j, m, m2;
     NTTLimb *tab_in, *tab_out, *tmp, a0, a1, b0, b1, c, *trig, c_inv;
     int l;
-    
+
     m = ntt_mods[m_idx];
     m2 = 2 * m;
     n = (limb_t)1 << fft_len_log2;
@@ -7765,7 +7765,7 @@ static no_inline int ntt_fft(BFNTTState *s, NTTLimb *out_buf, NTTLimb *in_buf,
         tab_out = tmp;
     }
     /* no twiddle in last step */
-    tab_out = out_buf; 
+    tab_out = out_buf;
     for(k = 0; k < stride_in; k++) {
         a0 = tab_in[k];
         a1 = tab_in[k + stride_in];
@@ -7782,7 +7782,7 @@ static void ntt_vec_mul(BFNTTState *s,
                         int k_tot, int m_idx)
 {
     limb_t i, norm, norm_inv, a, n, m, m_inv;
-    
+
     m = ntt_mods[m_idx];
     m_inv = s->ntt_mods_div[m_idx];
     norm = s->ntt_len_inv[m_idx][k_tot][0];
@@ -7804,7 +7804,7 @@ static no_inline void mul_trig(NTTLimb *buf,
                                limb_t n, limb_t c_mul, limb_t m, limb_t m_inv)
 {
     limb_t i, c0, c_mul_inv;
-    
+
     c0 = 1;
     c_mul_inv = init_mul_mod_fast2(c_mul, m);
     for(i = 0; i < n; i++) {
@@ -7820,7 +7820,7 @@ static no_inline NTTLimb *get_trig(BFNTTState *s,
 {
     NTTLimb *tab;
     limb_t i, n2, c, c_mul, m, c_mul_inv;
-    
+
     if (k > NTT_TRIG_K_MAX)
         return NULL;
 
@@ -7885,7 +7885,7 @@ static int ntt_fft_partial(BFNTTState *s, NTTLimb *buf1,
 {
     limb_t i, j, c_mul, c0, m, m_inv, strip_len, l;
     NTTLimb *buf2, *buf3;
-    
+
     buf2 = NULL;
     buf3 = ntt_malloc(s, sizeof(NTTLimb) * n1);
     if (!buf3)
@@ -7918,7 +7918,7 @@ static int ntt_fft_partial(BFNTTState *s, NTTLimb *buf1,
                     mul_trig(buf2 + l * n1, n1, c_mul, m, m_inv);
                 c_mul = mul_mod_fast(c_mul, c0, m, m_inv);
             }
-            
+
             for(i = 0; i < n1; i++) {
                 for(l = 0; l < strip_len; l++) {
                     buf1[i * n2 + (j + l)] = buf2[i + l *n1];
@@ -7942,7 +7942,7 @@ static int ntt_conv(BFNTTState *s, NTTLimb *buf1, NTTLimb *buf2,
 {
     limb_t n1, n2, i;
     int k1, k2;
-    
+
     if (k <= NTT_TRIG_K_MAX) {
         k1 = k;
     } else {
@@ -7952,7 +7952,7 @@ static int ntt_conv(BFNTTState *s, NTTLimb *buf1, NTTLimb *buf2,
     k2 = k - k1;
     n1 = (limb_t)1 << k1;
     n2 = (limb_t)1 << k2;
-    
+
     if (ntt_fft_partial(s, buf1, k1, k2, n1, n2, 0, m_idx))
         return -1;
     if (ntt_fft_partial(s, buf2, k1, k2, n1, n2, 0, m_idx))
@@ -7979,13 +7979,13 @@ static no_inline void limb_to_ntt(BFNTTState *s,
     dlimb_t a, b;
     int j, shift;
     limb_t base_mask1, a0, a1, a2, r, m, m_inv;
-    
+
 #if 0
     for(i = 0; i < a_len; i++) {
         printf("%" PRId64 ": " FMT_LIMB "\n",
                (int64_t)i, taba[i]);
     }
-#endif   
+#endif
     memset(tabr, 0, sizeof(NTTLimb) * fft_len * nb_mods);
     shift = dpl & (LIMB_BITS - 1);
     if (shift == 0)
@@ -8050,21 +8050,21 @@ static no_inline void ntt_to_limb(BFNTTState *s, limb_t *tabr, limb_t r_len,
     slimb_t i, len, pos;
     int j, k, l, shift, n_limb1, p;
     dlimb_t t;
-        
+
     j = NB_MODS * (NB_MODS - 1) / 2 - nb_mods * (nb_mods - 1) / 2;
     mods_cr_vec = s->ntt_mods_cr_vec + j;
     mf = s->ntt_mods_vec + NB_MODS - nb_mods;
     m_inv = s->ntt_mods_inv_vec + NB_MODS - nb_mods;
-        
+
     shift = dpl & (LIMB_BITS - 1);
     if (shift == 0)
         base_mask1 = -1;
     else
         base_mask1 = ((limb_t)1 << shift) - 1;
     n_limb1 = ((unsigned)dpl - 1) / LIMB_BITS;
-    for(j = 0; j < NB_MODS; j++) 
+    for(j = 0; j < NB_MODS; j++)
         carry[j] = 0;
-    for(j = 0; j < NB_MODS; j++) 
+    for(j = 0; j < NB_MODS; j++)
         u[j] = 0; /* avoid warnings */
     memset(tabr, 0, sizeof(limb_t) * r_len);
     fft_len = (limb_t)1 << fft_len_log2;
@@ -8086,7 +8086,7 @@ static no_inline void ntt_to_limb(BFNTTState *s, limb_t *tabr, limb_t r_len,
             }
         }
         y[j].v = ntt_mod1(y[j].v, mf[j]);
-        
+
         for(p = 0; p < VEC_LEN; p++) {
             /* back to normal representation */
             u[0] = (int64_t)y[nb_mods - 1].d[p];
@@ -8102,7 +8102,7 @@ static no_inline void ntt_to_limb(BFNTTState *s, limb_t *tabr, limb_t r_len,
                 l++;
             }
             /* XXX: for nb_mods = 5, l should be 4 */
-            
+
             /* last step adds the carry */
             r = (int64_t)y[0].d[p];
             for(k = 0; k < l; k++) {
@@ -8119,7 +8119,7 @@ static no_inline void ntt_to_limb(BFNTTState *s, limb_t *tabr, limb_t r_len,
             }
             printf("\n");
 #endif
-            
+
             /* write the digits */
             pos = i * dpl;
             for(j = 0; j < n_limb1; j++) {
@@ -8153,7 +8153,7 @@ static no_inline void ntt_to_limb(BFNTTState *s, limb_t *tabr, limb_t r_len,
     slimb_t i, len, pos;
     int j, k, l, shift, n_limb1;
     dlimb_t t;
-        
+
     j = NB_MODS * (NB_MODS - 1) / 2 - nb_mods * (nb_mods - 1) / 2;
     mods_cr = ntt_mods_cr + j;
     mods_cr_inv = s->ntt_mods_cr_inv + j;
@@ -8164,9 +8164,9 @@ static no_inline void ntt_to_limb(BFNTTState *s, limb_t *tabr, limb_t r_len,
     else
         base_mask1 = ((limb_t)1 << shift) - 1;
     n_limb1 = ((unsigned)dpl - 1) / LIMB_BITS;
-    for(j = 0; j < NB_MODS; j++) 
+    for(j = 0; j < NB_MODS; j++)
         carry[j] = 0;
-    for(j = 0; j < NB_MODS; j++) 
+    for(j = 0; j < NB_MODS; j++)
         u[j] = 0; /* avoid warnings */
     memset(tabr, 0, sizeof(limb_t) * r_len);
     fft_len = (limb_t)1 << fft_len_log2;
@@ -8184,12 +8184,12 @@ static no_inline void ntt_to_limb(BFNTTState *s, limb_t *tabr, limb_t r_len,
                 m = mods[k];
                 /* Note: there is no overflow in the sub_mod() because
                    the modulos are sorted by increasing order */
-                y[k] = mul_mod_fast2(y[k] - y[j] + m, 
+                y[k] = mul_mod_fast2(y[k] - y[j] + m,
                                      mods_cr[l], m, mods_cr_inv[l]);
                 l++;
             }
         }
-        
+
         /* back to normal representation */
         u[0] = y[nb_mods - 1];
         l = 1;
@@ -8203,7 +8203,7 @@ static no_inline void ntt_to_limb(BFNTTState *s, limb_t *tabr, limb_t r_len,
             u[l] = r;
             l++;
         }
-        
+
         /* last step adds the carry */
         r = y[0];
         for(k = 0; k < l; k++) {
@@ -8220,7 +8220,7 @@ static no_inline void ntt_to_limb(BFNTTState *s, limb_t *tabr, limb_t r_len,
         }
         printf("\n");
 #endif
-        
+
         /* write the digits */
         pos = i * dpl;
         for(j = 0; j < n_limb1; j++) {
@@ -8261,7 +8261,7 @@ static int ntt_static_init(bf_context_t *s1)
     memset(s, 0, sizeof(*s));
     s1->ntt_state = s;
     s->ctx = s1;
-    
+
     for(j = 0; j < NB_MODS; j++) {
         m = ntt_mods[j];
         m_inv = init_mul_mod_fast(m);
@@ -8310,7 +8310,7 @@ int bf_get_fft_size(int *pdpl, int *pnb_mods, limb_t len)
     int dpl, fft_len_log2, n_bits, nb_mods, dpl_found, fft_len_log2_found;
     int int_bits, nb_mods_found;
     limb_t cost, min_cost;
-    
+
     min_cost = -1;
     dpl_found = 0;
     nb_mods_found = 4;
@@ -8366,11 +8366,11 @@ static no_inline int fft_mul(bf_context_t *s1,
 #if defined(USE_MUL_CHECK)
     limb_t ha, hb, hr, h_ref;
 #endif
-    
+
     if (ntt_static_init(s1))
         return -1;
     s = s1->ntt_state;
-    
+
     /* find the optimal number of digits per limb (dpl) */
     len = a_len + b_len;
     fft_len_log2 = bf_get_fft_size(&dpl, &nb_mods, len);
@@ -8398,7 +8398,7 @@ static no_inline int fft_mul(bf_context_t *s1,
         return -1;
     limb_to_ntt(s, buf1, fft_len, a_tab, a_len, dpl,
                 NB_MODS - nb_mods, nb_mods);
-    if ((mul_flags & (FFT_MUL_R_OVERLAP_A | FFT_MUL_R_OVERLAP_B)) == 
+    if ((mul_flags & (FFT_MUL_R_OVERLAP_A | FFT_MUL_R_OVERLAP_B)) ==
         FFT_MUL_R_OVERLAP_A) {
         if (!(mul_flags & FFT_MUL_R_NORESIZE))
             bf_resize(res, 0);
@@ -8448,7 +8448,7 @@ static no_inline int fft_mul(bf_context_t *s1,
         //        printf("ha=0x" FMT_LIMB" hb=0x" FMT_LIMB " hr=0x" FMT_LIMB " expected=0x" FMT_LIMB "\n", ha, hb, hr, h_ref);
         exit(1);
     }
-#endif    
+#endif
     return 0;
  fail:
     ntt_free(s, buf1);
diff --git a/quickjs/quickjs/libbf.h b/thirdparty/quickjs/quickjs/libbf.h
similarity index 98%
rename from quickjs/quickjs/libbf.h
rename to thirdparty/quickjs/quickjs/libbf.h
index 6749b35c..3396e86e 100644
--- a/quickjs/quickjs/libbf.h
+++ b/thirdparty/quickjs/quickjs/libbf.h
@@ -1,6 +1,6 @@
 /*
  * Tiny arbitrary precision floating point library
- * 
+ *
  * Copyright (c) 2017-2020 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -171,7 +171,7 @@ static inline bf_flags_t bf_set_exp_bits(int n)
 #define BF_ST_UNDERFLOW   (1 << 3)
 #define BF_ST_INEXACT     (1 << 4)
 /* indicate that a memory allocation error occured. NaN is returned */
-#define BF_ST_MEM_ERROR   (1 << 5) 
+#define BF_ST_MEM_ERROR   (1 << 5)
 
 #define BF_RADIX_MAX 36 /* maximum radix for bf_atof() and bf_ftoa() */
 
@@ -284,7 +284,7 @@ int bf_sub(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags)
 int bf_add_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec, bf_flags_t flags);
 int bf_mul(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
 int bf_mul_ui(bf_t *r, const bf_t *a, uint64_t b1, limb_t prec, bf_flags_t flags);
-int bf_mul_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec, 
+int bf_mul_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec,
               bf_flags_t flags);
 int bf_mul_2exp(bf_t *r, slimb_t e, limb_t prec, bf_flags_t flags);
 int bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
@@ -341,12 +341,12 @@ int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
 /* fractional format: prec digits after the decimal point rounded with
    (flags & BF_RND_MASK) */
 #define BF_FTOA_FORMAT_FRAC  (1 << 16)
-/* free format: 
-   
+/* free format:
+
    For binary radices with bf_ftoa() and for bfdec_ftoa(): use the minimum
    number of digits to represent 'a'. The precision and the rounding
    mode are ignored.
-   
+
    For the non binary radices with bf_ftoa(): use as many digits as
    necessary so that bf_atof() return the same number when using
    precision 'prec', rounding to nearest and the subnormal
@@ -373,7 +373,7 @@ char *bf_ftoa(size_t *plen, const bf_t *a, int radix, limb_t prec,
               bf_flags_t flags);
 
 /* modulo 2^n instead of saturation. NaN and infinity return 0 */
-#define BF_GET_INT_MOD (1 << 0) 
+#define BF_GET_INT_MOD (1 << 0)
 int bf_get_int32(int *pres, const bf_t *a, int flags);
 int bf_get_int64(int64_t *pres, const bf_t *a, int flags);
 int bf_get_uint64(uint64_t *pres, const bf_t *a);
@@ -387,10 +387,10 @@ int bf_normalize_and_round(bf_t *r, limb_t prec1, bf_flags_t flags);
 int bf_can_round(const bf_t *a, slimb_t prec, bf_rnd_t rnd_mode, slimb_t k);
 slimb_t bf_mul_log2_radix(slimb_t a1, unsigned int radix, int is_inv,
                           int is_ceil1);
-int mp_mul(bf_context_t *s, limb_t *result, 
-           const limb_t *op1, limb_t op1_size, 
+int mp_mul(bf_context_t *s, limb_t *result,
+           const limb_t *op1, limb_t op1_size,
            const limb_t *op2, limb_t op2_size);
-limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2, 
+limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2,
               limb_t n, limb_t carry);
 limb_t mp_add_ui(limb_t *tab, limb_t b, size_t n);
 int mp_sqrtrem(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n);
diff --git a/quickjs/quickjs/libregexp-opcode.h b/thirdparty/quickjs/quickjs/libregexp-opcode.h
similarity index 99%
rename from quickjs/quickjs/libregexp-opcode.h
rename to thirdparty/quickjs/quickjs/libregexp-opcode.h
index f90c23b3..cd3683f6 100644
--- a/quickjs/quickjs/libregexp-opcode.h
+++ b/thirdparty/quickjs/quickjs/libregexp-opcode.h
@@ -1,6 +1,6 @@
 /*
  * Regular Expression Engine
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
diff --git a/quickjs/quickjs/libregexp.c b/thirdparty/quickjs/quickjs/libregexp.c
similarity index 99%
rename from quickjs/quickjs/libregexp.c
rename to thirdparty/quickjs/quickjs/libregexp.c
index bbb5e9d7..7368b32b 100644
--- a/quickjs/quickjs/libregexp.c
+++ b/thirdparty/quickjs/quickjs/libregexp.c
@@ -1,6 +1,6 @@
 /*
  * Regular Expression Engine
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -226,7 +226,7 @@ static int cr_init_char_range(REParseState *s, CharRange *cr, uint32_t c)
     BOOL invert;
     const uint16_t *c_pt;
     int len, i;
-    
+
     invert = c & 1;
     c_pt = char_range_table[c >> 1];
     len = *c_pt++;
@@ -276,7 +276,7 @@ static __maybe_unused void lre_dump_bytecode(const uint8_t *buf,
 {
     int pos, len, opcode, bc_len, re_flags, i;
     uint32_t val;
-    
+
     assert(buf_len >= RE_HEADER_LEN);
 
     re_flags=  buf[0];
@@ -448,7 +448,7 @@ static int parse_digits(const uint8_t **pp, BOOL allow_overflow)
     const uint8_t *p;
     uint64_t v;
     int c;
-    
+
     p = *pp;
     v = 0;
     for(;;) {
@@ -520,7 +520,7 @@ int lre_parse_escape(const uint8_t **pp, int allow_utf16)
         {
             int h, n, i;
             uint32_t c1;
-            
+
             if (*p == '{' && allow_utf16) {
                 p++;
                 c = 0;
@@ -714,7 +714,7 @@ static int get_class_atom(REParseState *s, CharRange *cr,
     const uint8_t *p;
     uint32_t c;
     int ret;
-    
+
     p = *pp;
 
     c = *p;
@@ -822,7 +822,7 @@ static int re_emit_range(REParseState *s, const CharRange *cr)
 {
     int len, i;
     uint32_t high;
-    
+
     len = (unsigned)cr->len / 2;
     if (len >= 65535)
         return re_parse_error(s, "too many ranges");
@@ -863,7 +863,7 @@ static int re_parse_char_class(REParseState *s, const uint8_t **pp)
     CharRange cr_s, *cr = &cr_s;
     CharRange cr1_s, *cr1 = &cr1_s;
     BOOL invert;
-    
+
     cr_init(cr, s->mem_opaque, lre_realloc);
     p = *pp;
     p++;    /* skip '[' */
@@ -953,12 +953,12 @@ static int re_check_advance(const uint8_t *bc_buf, int bc_buf_len)
     uint32_t val, last;
     BOOL has_back_reference;
     uint8_t capture_bitmap[CAPTURE_COUNT_MAX];
-    
+
     ret = -2; /* not known yet */
     pos = 0;
     has_back_reference = FALSE;
     memset(capture_bitmap, 0, sizeof(capture_bitmap));
-    
+
     while (pos < bc_buf_len) {
         opcode = bc_buf[pos];
         len = reopcode_info[opcode].size;
@@ -1035,7 +1035,7 @@ static int re_is_simple_quantifier(const uint8_t *bc_buf, int bc_buf_len)
 {
     int pos, opcode, len, count;
     uint32_t val;
-    
+
     count = 0;
     pos = 0;
     while (pos < bc_buf_len) {
@@ -1190,7 +1190,7 @@ static int find_group_name(REParseState *s, const char *name)
     const char *p, *buf_end;
     size_t len, name_len;
     int capture_index;
-    
+
     name_len = strlen(name);
     p = (char *)s->group_names.buf;
     buf_end = (char *)s->group_names.buf + s->group_names.size;
@@ -1213,7 +1213,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
     int c, last_atom_start, quant_min, quant_max, last_capture_count;
     BOOL greedy, add_zero_advance_check, is_neg, is_backward_lookahead;
     CharRange cr_s, *cr = &cr_s;
-    
+
     last_atom_start = -1;
     last_capture_count = 0;
     p = s->buf_ptr;
@@ -1336,15 +1336,15 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             capture_index = s->capture_count++;
             re_emit_op_u8(s, REOP_save_start + is_backward_dir,
                           capture_index);
-            
+
             s->buf_ptr = p;
             if (re_parse_disjunction(s, is_backward_dir))
                 return -1;
             p = s->buf_ptr;
-            
+
             re_emit_op_u8(s, REOP_save_start + 1 - is_backward_dir,
                           capture_index);
-            
+
             if (re_parse_expect(s, &p, ')'))
                 return -1;
         }
@@ -1360,7 +1360,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             {
                 const uint8_t *p1;
                 int dummy_res;
-                
+
                 p1 = p;
                 if (p1[2] != '<') {
                     /* annex B: we tolerate invalid group names in non
@@ -1413,10 +1413,10 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             goto normal_char;
         case '1': case '2': case '3': case '4':
         case '5': case '6': case '7': case '8':
-        case '9': 
+        case '9':
             {
                 const uint8_t *q = ++p;
-                
+
                 c = parse_digits(&p, FALSE);
                 if (c < 0 || (c >= s->capture_count && c >= re_count_captures(s))) {
                     if (!s->is_utf16) {
@@ -1557,7 +1557,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             }
             if (greedy) {
                 int len, pos;
-                
+
                 if (quant_max > 0) {
                     /* specific optimization for simple quantifiers */
                     if (dbuf_error(&s->byte_code))
@@ -1566,7 +1566,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                                                  s->byte_code.size - last_atom_start);
                     if (len > 0) {
                         re_emit_op(s, REOP_match);
-                        
+
                         if (dbuf_insert(&s->byte_code, last_atom_start, 17))
                             goto out_of_memory;
                         pos = last_atom_start;
@@ -1583,7 +1583,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                         goto done;
                     }
                 }
-                
+
                 if (dbuf_error(&s->byte_code))
                     goto out_of_memory;
                 add_zero_advance_check = (re_check_advance(s->byte_code.buf + last_atom_start,
@@ -1591,7 +1591,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
             } else {
                 add_zero_advance_check = FALSE;
             }
-            
+
             {
                 int len, pos;
                 len = s->byte_code.size - last_atom_start;
@@ -1626,7 +1626,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                                atom (only works if the atom has no
                                side effect) */
                             s->byte_code.buf[last_atom_start + 1 + 4] = REOP_push_char_pos;
-                            re_emit_goto(s, REOP_bne_char_pos, last_atom_start); 
+                            re_emit_goto(s, REOP_bne_char_pos, last_atom_start);
                         } else {
                             re_emit_goto(s, REOP_goto, last_atom_start);
                         }
@@ -1677,7 +1677,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
                         re_emit_op_u32(s, REOP_split_goto_first + greedy, len + 5);
                         /* copy the atom */
                         dbuf_put_self(&s->byte_code, last_atom_start, len);
-                        
+
                         re_emit_goto(s, REOP_loop, pos);
                         re_emit_op(s, REOP_drop);
                     }
@@ -1729,7 +1729,7 @@ static int re_parse_alternative(REParseState *s, BOOL is_backward_dir)
     }
     return 0;
 }
-    
+
 static int re_parse_disjunction(REParseState *s, BOOL is_backward_dir)
 {
     int start, len, pos;
@@ -1753,7 +1753,7 @@ static int re_parse_disjunction(REParseState *s, BOOL is_backward_dir)
 
         if (re_parse_alternative(s, is_backward_dir))
             return -1;
-        
+
         /* patch the goto */
         len = s->byte_code.size - (pos + 4);
         put_u32(s->byte_code.buf + pos, len);
@@ -1766,7 +1766,7 @@ static int compute_stack_size(const uint8_t *bc_buf, int bc_buf_len)
 {
     int stack_size, stack_size_max, pos, opcode, len;
     uint32_t val;
-    
+
     stack_size = 0;
     stack_size_max = 0;
     bc_buf += RE_HEADER_LEN;
@@ -1817,7 +1817,7 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
     REParseState s_s, *s = &s_s;
     int stack_size;
     BOOL is_sticky;
-    
+
     memset(s, 0, sizeof(*s));
     s->mem_opaque = opaque;
     s->buf_ptr = (const uint8_t *)buf;
@@ -1831,7 +1831,7 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
     s->capture_count = 1;
     s->total_capture_count = -1;
     s->has_named_captures = -1;
-    
+
     dbuf_init2(&s->byte_code, opaque, lre_realloc);
     dbuf_init2(&s->group_names, opaque, lre_realloc);
 
@@ -1839,7 +1839,7 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
     dbuf_putc(&s->byte_code, 0); /* second element is the number of captures */
     dbuf_putc(&s->byte_code, 0); /* stack size */
     dbuf_put_u32(&s->byte_code, 0); /* bytecode length */
-    
+
     if (!is_sticky) {
         /* iterate thru all positions (about the same as .*?( ... ) )
            .  We do it without an explicit loop so that lock step
@@ -1861,7 +1861,7 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
     }
 
     re_emit_op_u8(s, REOP_save_end, 0);
-    
+
     re_emit_op(s, REOP_match);
 
     if (*s->buf_ptr != '\0') {
@@ -1873,13 +1873,13 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
         re_parse_out_of_memory(s);
         goto error;
     }
-    
+
     stack_size = compute_stack_size(s->byte_code.buf, s->byte_code.size);
     if (stack_size < 0) {
         re_parse_error(s, "too many imbricated quantifiers");
         goto error;
     }
-    
+
     s->byte_code.buf[RE_HEADER_CAPTURE_COUNT] = s->capture_count;
     s->byte_code.buf[RE_HEADER_STACK_SIZE] = stack_size;
     put_u32(s->byte_code.buf + 3, s->byte_code.size - RE_HEADER_LEN);
@@ -1890,11 +1890,11 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
         s->byte_code.buf[RE_HEADER_FLAGS] |= LRE_FLAG_NAMED_GROUPS;
     }
     dbuf_free(&s->group_names);
-    
+
 #ifdef DUMP_REOP
     lre_dump_bytecode(s->byte_code.buf, s->byte_code.size);
 #endif
-    
+
     error_msg[0] = '\0';
     *plen = s->byte_code.size;
     return s->byte_code.buf;
@@ -2025,7 +2025,7 @@ typedef struct {
     const uint8_t *cbuf;
     const uint8_t *cbuf_end;
     /* 0 = 8 bit chars, 1 = 16 bit chars, 2 = 16 bit chars, UTF-16 */
-    int cbuf_type; 
+    int cbuf_type;
     int capture_count;
     int stack_size_max;
     BOOL multi_line;
@@ -2087,7 +2087,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
     int cbuf_type;
     uint32_t val, c;
     const uint8_t *cbuf_end;
-    
+
     cbuf_type = s->cbuf_type;
     cbuf_end = s->cbuf_end;
 
@@ -2185,7 +2185,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
         case REOP_split_next_first:
             {
                 const uint8_t *pc1;
-                
+
                 val = get_u32(pc);
                 pc += 4;
                 if (opcode == REOP_split_next_first) {
@@ -2211,7 +2211,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
             if (ret < 0)
                 return -1;
             break;
-            
+
         case REOP_goto:
             val = get_u32(pc);
             pc += 4 + (int)val;
@@ -2317,7 +2317,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
             {
                 const uint8_t *cptr1, *cptr1_end, *cptr1_start;
                 uint32_t c1, c2;
-                
+
                 val = *pc++;
                 if (val >= s->capture_count)
                     goto no_match;
@@ -2360,7 +2360,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
             {
                 int n;
                 uint32_t low, high, idx_min, idx_max, idx;
-                
+
                 n = get_u16(pc); /* n must be >= 1 */
                 pc += 2;
                 if (cptr >= cbuf_end)
@@ -2400,7 +2400,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
             {
                 int n;
                 uint32_t low, high, idx_min, idx_max, idx;
-                
+
                 n = get_u16(pc); /* n must be >= 1 */
                 pc += 2;
                 if (cptr >= cbuf_end)
@@ -2445,14 +2445,14 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
                 size_t q;
                 intptr_t res;
                 const uint8_t *pc1;
-                
+
                 next_pos = get_u32(pc);
                 quant_min = get_u32(pc + 4);
                 quant_max = get_u32(pc + 8);
                 pc += 16;
                 pc1 = pc;
                 pc += (int)next_pos;
-                
+
                 q = 0;
                 for(;;) {
                     res = lre_exec_backtrack(s, capture, stack, stack_len,
@@ -2495,7 +2495,7 @@ int lre_exec(uint8_t **capture,
     REExecContext s_s, *s = &s_s;
     int re_flags, i, alloca_size, ret;
     StackInt *stack_buf;
-    
+
     re_flags = bc_buf[RE_HEADER_FLAGS];
     s->multi_line = (re_flags & LRE_FLAG_MULTILINE) != 0;
     s->ignore_case = (re_flags & LRE_FLAG_IGNORECASE) != 0;
@@ -2515,7 +2515,7 @@ int lre_exec(uint8_t **capture,
     s->state_stack = NULL;
     s->state_stack_len = 0;
     s->state_stack_size = 0;
-    
+
     for(i = 0; i < s->capture_count * 2; i++)
         capture[i] = NULL;
     alloca_size = s->stack_size_max * sizeof(stack_buf[0]);
@@ -2567,7 +2567,7 @@ int main(int argc, char **argv)
     uint8_t *capture[CAPTURE_COUNT_MAX * 2];
     const char *input;
     int input_len, capture_count;
-    
+
     if (argc < 3) {
         printf("usage: %s regexp input\n", argv[0]);
         exit(1);
@@ -2581,7 +2581,7 @@ int main(int argc, char **argv)
 
     input = argv[2];
     input_len = strlen(input);
-    
+
     ret = lre_exec(capture, bc, (uint8_t *)input, 0, input_len, 0, NULL);
     printf("ret=%d\n", ret);
     if (ret == 1) {
diff --git a/quickjs/quickjs/libregexp.h b/thirdparty/quickjs/quickjs/libregexp.h
similarity index 99%
rename from quickjs/quickjs/libregexp.h
rename to thirdparty/quickjs/quickjs/libregexp.h
index 9aedb7e9..cbf339e4 100644
--- a/quickjs/quickjs/libregexp.h
+++ b/thirdparty/quickjs/quickjs/libregexp.h
@@ -1,6 +1,6 @@
 /*
  * Regular Expression Engine
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -53,7 +53,7 @@ int lre_parse_escape(const uint8_t **pp, int allow_utf16);
 LRE_BOOL lre_is_space(int c);
 
 /* must be provided by the user */
-LRE_BOOL lre_check_stack_overflow(void *opaque, size_t alloca_size); 
+LRE_BOOL lre_check_stack_overflow(void *opaque, size_t alloca_size);
 void *lre_realloc(void *opaque, void *ptr, size_t size);
 
 /* JS identifier test */
diff --git a/quickjs/quickjs/libunicode-table.h b/thirdparty/quickjs/quickjs/libunicode-table.h
similarity index 100%
rename from quickjs/quickjs/libunicode-table.h
rename to thirdparty/quickjs/quickjs/libunicode-table.h
diff --git a/quickjs/quickjs/libunicode.c b/thirdparty/quickjs/quickjs/libunicode.c
similarity index 99%
rename from quickjs/quickjs/libunicode.c
rename to thirdparty/quickjs/quickjs/libunicode.c
index 63c12a07..91d131ad 100644
--- a/quickjs/quickjs/libunicode.c
+++ b/thirdparty/quickjs/quickjs/libunicode.c
@@ -1,6 +1,6 @@
 /*
  * Unicode utilities
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -49,9 +49,9 @@ enum {
 };
 
 /* conv_type:
-   0 = to upper 
+   0 = to upper
    1 = to lower
-   2 = case folding (= to lower with modifications) 
+   2 = case folding (= to lower with modifications)
 */
 int lre_case_conv(uint32_t *res, uint32_t c, int conv_type)
 {
@@ -68,7 +68,7 @@ int lre_case_conv(uint32_t *res, uint32_t c, int conv_type)
     } else {
         uint32_t v, code, data, type, len, a, is_lower;
         int idx, idx_min, idx_max;
-        
+
         is_lower = (conv_type != 0);
         idx_min = 0;
         idx_max = countof(case_conv_table1) - 1;
@@ -208,7 +208,7 @@ static BOOL lre_is_in_table(uint32_t c, const uint8_t *table,
     uint32_t code, b, bit;
     int pos;
     const uint8_t *p;
-    
+
     pos = get_index_pos(&code, c, index_table, index_table_len);
     if (pos < 0)
         return FALSE; /* outside the table */
@@ -241,7 +241,7 @@ BOOL lre_is_cased(uint32_t c)
 {
     uint32_t v, code, len;
     int idx, idx_min, idx_max;
-        
+
     idx_min = 0;
     idx_max = countof(case_conv_table1) - 1;
     while (idx_min <= idx_max) {
@@ -300,7 +300,7 @@ int cr_realloc(CharRange *cr, int size)
 {
     int new_size;
     uint32_t *new_buf;
-    
+
     if (size > cr->size) {
         new_size = max_int(size, cr->size * 3 / 2);
         new_buf = cr->realloc_func(cr->mem_opaque, cr->points,
@@ -327,7 +327,7 @@ static void cr_compress(CharRange *cr)
 {
     int i, j, k, len;
     uint32_t *pt;
-    
+
     pt = cr->points;
     len = cr->len;
     i = 0;
@@ -357,7 +357,7 @@ int cr_op(CharRange *cr, const uint32_t *a_pt, int a_len,
 {
     int a_idx, b_idx, is_in;
     uint32_t v;
-    
+
     a_idx = 0;
     b_idx = 0;
     for(;;) {
@@ -658,7 +658,7 @@ static int unicode_decomp_char(uint32_t *res, uint32_t c, BOOL is_compat1)
 {
     uint32_t v, type, is_compat, code, len;
     int idx_min, idx_max, idx;
-    
+
     idx_min = 0;
     idx_max = countof(unicode_decomp_table1) - 1;
     while (idx_min <= idx_max) {
@@ -688,7 +688,7 @@ static int unicode_compose_pair(uint32_t c0, uint32_t c1)
     uint32_t code, len, type, v, idx1, d_idx, d_offset, ch;
     int idx_min, idx_max, idx, d;
     uint32_t pair[2];
-    
+
     idx_min = 0;
     idx_max = countof(unicode_comp_table) - 1;
     while (idx_min <= idx_max) {
@@ -724,7 +724,7 @@ static int unicode_get_cc(uint32_t c)
     uint32_t code, n, type, cc, c1, b;
     int pos;
     const uint8_t *p;
-    
+
     pos = get_index_pos(&code, c,
                         unicode_cc_index, sizeof(unicode_cc_index) / 3);
     if (pos < 0)
@@ -773,7 +773,7 @@ static int unicode_get_cc(uint32_t c)
 static void sort_cc(int *buf, int len)
 {
     int i, j, k, cc, cc1, start, ch1;
-    
+
     for(i = 0; i < len; i++) {
         cc = unicode_get_cc(buf[i]);
         if (cc != 0) {
@@ -812,7 +812,7 @@ static void to_nfd_rec(DynBuf *dbuf,
     uint32_t c, v;
     int i, l;
     uint32_t res[UNICODE_DECOMP_LEN_MAX];
-    
+
     for(i = 0; i < src_len; i++) {
         c = src[i];
         if (c >= 0xac00 && c < 0xd7a4) {
@@ -857,7 +857,7 @@ int unicode_normalize(uint32_t **pdst, const uint32_t *src, int src_len,
     int *buf, buf_len, i, p, starter_pos, cc, last_cc, out_len;
     BOOL is_compat;
     DynBuf dbuf_s, *dbuf = &dbuf_s;
-    
+
     is_compat = n_type >> 1;
 
     dbuf_init2(dbuf, opaque, realloc_func);
@@ -885,15 +885,15 @@ int unicode_normalize(uint32_t **pdst, const uint32_t *src, int src_len,
     }
     buf = (int *)dbuf->buf;
     buf_len = dbuf->size / sizeof(int);
-        
+
     sort_cc(buf, buf_len);
-    
+
     if (buf_len <= 1 || (n_type & 1) != 0) {
         /* NFD / NFKD */
         *pdst = (uint32_t *)buf;
         return buf_len;
     }
-    
+
     i = 1;
     out_len = 1;
     while (i < buf_len) {
@@ -930,7 +930,7 @@ static int unicode_find_name(const char *name_table, const char *name)
     const char *p, *r;
     int pos;
     size_t name_len, len;
-    
+
     p = name_table;
     pos = 0;
     name_len = strlen(name);
@@ -963,13 +963,13 @@ int unicode_script(CharRange *cr,
     CharRange cr1_s, *cr1;
     CharRange cr2_s, *cr2 = &cr2_s;
     BOOL is_common;
-    
+
     script_idx = unicode_find_name(unicode_script_name_table, script_name);
     if (script_idx < 0)
         return -2;
     /* Note: we remove the "Unknown" Script */
     script_idx += UNICODE_SCRIPT_Unknown + 1;
-        
+
     is_common = (script_idx == UNICODE_SCRIPT_Common ||
                  script_idx == UNICODE_SCRIPT_Inherited);
     if (is_ext) {
@@ -1236,7 +1236,7 @@ static int unicode_case1(CharRange *cr, int case_mask)
     }
     return 0;
 }
-        
+
 typedef enum {
     POP_GC,
     POP_PROP,
@@ -1256,7 +1256,7 @@ static int unicode_prop_ops(CharRange *cr, ...)
     CharRange stack[POP_STACK_LEN_MAX];
     int stack_len, op, ret, i;
     uint32_t a;
-    
+
     va_start(ap, cr);
     stack_len = 0;
     for(;;) {
@@ -1342,7 +1342,7 @@ int unicode_general_category(CharRange *cr, const char *gc_name)
 {
     int gc_idx;
     uint32_t gc_mask;
-    
+
     gc_idx = unicode_find_name(unicode_gc_name_table, gc_name);
     if (gc_idx < 0)
         return -2;
@@ -1360,7 +1360,7 @@ int unicode_general_category(CharRange *cr, const char *gc_name)
 int unicode_prop(CharRange *cr, const char *prop_name)
 {
     int prop_idx, ret;
-    
+
     prop_idx = unicode_find_name(unicode_prop_name_table, prop_name);
     if (prop_idx < 0)
         return -2;
diff --git a/quickjs/quickjs/libunicode.h b/thirdparty/quickjs/quickjs/libunicode.h
similarity index 99%
rename from quickjs/quickjs/libunicode.h
rename to thirdparty/quickjs/quickjs/libunicode.h
index cfa600a5..0acc2095 100644
--- a/quickjs/quickjs/libunicode.h
+++ b/thirdparty/quickjs/quickjs/libunicode.h
@@ -1,6 +1,6 @@
 /*
  * Unicode utilities
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
diff --git a/quickjs/quickjs/list.h b/thirdparty/quickjs/quickjs/list.h
similarity index 98%
rename from quickjs/quickjs/list.h
rename to thirdparty/quickjs/quickjs/list.h
index 0a1bc5a4..c23193fe 100644
--- a/quickjs/quickjs/list.h
+++ b/thirdparty/quickjs/quickjs/list.h
@@ -1,6 +1,6 @@
 /*
  * Linux klist like system
- * 
+ *
  * Copyright (c) 2016-2017 Fabrice Bellard
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -46,7 +46,7 @@ static inline void init_list_head(struct list_head *head)
 }
 
 /* insert 'el' between 'prev' and 'next' */
-static inline void __list_add(struct list_head *el, 
+static inline void __list_add(struct list_head *el,
                               struct list_head *prev, struct list_head *next)
 {
     prev->next = el;
diff --git a/quickjs/quickjs/quickjs-atom.h b/thirdparty/quickjs/quickjs/quickjs-atom.h
similarity index 99%
rename from quickjs/quickjs/quickjs-atom.h
rename to thirdparty/quickjs/quickjs/quickjs-atom.h
index a353ad44..5c998674 100644
--- a/quickjs/quickjs/quickjs-atom.h
+++ b/thirdparty/quickjs/quickjs/quickjs-atom.h
@@ -1,6 +1,6 @@
 /*
  * QuickJS atom definitions
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  * Copyright (c) 2017-2018 Charlie Gordon
  *
@@ -201,7 +201,7 @@ DEF(RegExp, "RegExp")
 DEF(ArrayBuffer, "ArrayBuffer")
 DEF(SharedArrayBuffer, "SharedArrayBuffer")
 /* must keep same order as class IDs for typed arrays */
-DEF(Uint8ClampedArray, "Uint8ClampedArray") 
+DEF(Uint8ClampedArray, "Uint8ClampedArray")
 DEF(Int8Array, "Int8Array")
 DEF(Uint8Array, "Uint8Array")
 DEF(Int16Array, "Int16Array")
@@ -268,5 +268,5 @@ DEF(Symbol_asyncIterator, "Symbol.asyncIterator")
 #ifdef CONFIG_BIGNUM
 DEF(Symbol_operatorSet, "Symbol.operatorSet")
 #endif
-    
+
 #endif /* DEF */
diff --git a/quickjs/quickjs/quickjs-debugger.c b/thirdparty/quickjs/quickjs/quickjs-debugger.c
similarity index 99%
rename from quickjs/quickjs/quickjs-debugger.c
rename to thirdparty/quickjs/quickjs/quickjs-debugger.c
index c7493f31..f7557064 100644
--- a/quickjs/quickjs/quickjs-debugger.c
+++ b/thirdparty/quickjs/quickjs/quickjs-debugger.c
@@ -407,7 +407,7 @@ static void js_process_breakpoints(JSDebuggerInfo *info, JSValue message) {
 JSValue js_debugger_file_breakpoints(JSContext *ctx, const char* path) {
     JSDebuggerInfo *info = js_debugger_info(JS_GetRuntime(ctx));
     JSValue path_data = JS_GetPropertyStr(ctx, info->breakpoints, path);
-    return path_data;    
+    return path_data;
 }
 
 static int js_process_debugger_messages(JSDebuggerInfo *info, const uint8_t *cur_pc) {
@@ -448,7 +448,7 @@ static int js_process_debugger_messages(JSDebuggerInfo *info, const uint8_t *cur
 
         if (!js_transport_read_fully(info, info->message_buffer, message_length))
             goto done;
-        
+
         info->message_buffer[message_length] = '\0';
 
         JSValue message = JS_ParseJSON(ctx, info->message_buffer, message_length, "<debugger>");
@@ -659,7 +659,7 @@ void js_debugger_check(JSContext* ctx, const uint8_t *cur_pc) {
     if (js_process_debugger_messages(info, cur_pc))
         goto done;
 
-    fail: 
+    fail:
         js_debugger_free(JS_GetRuntime(ctx), info);
     done:
         info->is_debugging = 0;
@@ -730,4 +730,4 @@ int js_debugger_is_transport_connected(JSRuntime *rt) {
 
 void js_debugger_cooperate(JSContext *ctx) {
     js_debugger_info(JS_GetRuntime(ctx))->should_peek = 1;
-}
\ No newline at end of file
+}
diff --git a/quickjs/quickjs/quickjs-debugger.h b/thirdparty/quickjs/quickjs/quickjs-debugger.h
similarity index 99%
rename from quickjs/quickjs/quickjs-debugger.h
rename to thirdparty/quickjs/quickjs/quickjs-debugger.h
index eba243cf..d3b7787c 100644
--- a/quickjs/quickjs/quickjs-debugger.h
+++ b/thirdparty/quickjs/quickjs/quickjs-debugger.h
@@ -30,7 +30,7 @@ typedef struct JSDebuggerInfo {
     // JSContext that is used to for the JSON transport and debugger state.
     JSContext *ctx;
     JSContext *debugging_ctx;
- 
+
     int attempted_connect;
     int attempted_wait;
     int peek_ticks;
@@ -102,4 +102,4 @@ JSValue js_debugger_evaluate(JSContext *ctx, int stack_index, JSValue expression
 }
 #endif
 
-#endif
\ No newline at end of file
+#endif
diff --git a/quickjs/quickjs/quickjs-opcode.h b/thirdparty/quickjs/quickjs/quickjs-opcode.h
similarity index 99%
rename from quickjs/quickjs/quickjs-opcode.h
rename to thirdparty/quickjs/quickjs/quickjs-opcode.h
index 387363c3..ea91bd2c 100644
--- a/quickjs/quickjs/quickjs-opcode.h
+++ b/thirdparty/quickjs/quickjs/quickjs-opcode.h
@@ -1,6 +1,6 @@
 /*
  * QuickJS opcode definitions
- * 
+ *
  * Copyright (c) 2017-2018 Fabrice Bellard
  * Copyright (c) 2017-2018 Charlie Gordon
  *
@@ -165,14 +165,14 @@ DEF(        set_loc, 3, 1, 1, loc) /* must come after put_loc */
 DEF(        get_arg, 3, 0, 1, arg)
 DEF(        put_arg, 3, 1, 0, arg) /* must come after get_arg */
 DEF(        set_arg, 3, 1, 1, arg) /* must come after put_arg */
-DEF(    get_var_ref, 3, 0, 1, var_ref) 
+DEF(    get_var_ref, 3, 0, 1, var_ref)
 DEF(    put_var_ref, 3, 1, 0, var_ref) /* must come after get_var_ref */
 DEF(    set_var_ref, 3, 1, 1, var_ref) /* must come after put_var_ref */
 DEF(set_loc_uninitialized, 3, 0, 0, loc)
 DEF(  get_loc_check, 3, 0, 1, loc)
 DEF(  put_loc_check, 3, 1, 0, loc) /* must come after get_loc_check */
 DEF(  put_loc_check_init, 3, 1, 0, loc)
-DEF(get_var_ref_check, 3, 0, 1, var_ref) 
+DEF(get_var_ref_check, 3, 0, 1, var_ref)
 DEF(put_var_ref_check, 3, 1, 0, var_ref) /* must come after get_var_ref_check */
 DEF(put_var_ref_check_init, 3, 1, 0, var_ref)
 DEF(      close_loc, 3, 0, 0, loc)
@@ -262,7 +262,7 @@ DEF(      mul_pow10, 1, 2, 1, none)
 DEF(       math_mod, 1, 2, 1, none)
 #endif
 /* must be the last non short and non temporary opcode */
-DEF(            nop, 1, 0, 0, none) 
+DEF(            nop, 1, 0, 0, none)
 
 /* temporary opcodes: never emitted in the final bytecode */
 
@@ -285,7 +285,7 @@ def(scope_get_private_field2, 7, 1, 2, atom_u16) /* obj -> obj value, emitted in
 def(scope_put_private_field, 7, 1, 1, atom_u16) /* obj value ->, emitted in phase 1, removed in phase 2 */
 
 def( set_class_name, 5, 1, 1, u32) /* emitted in phase 1, removed in phase 2 */
-    
+
 def(       line_num, 5, 0, 0, u32) /* emitted in phase 1, removed in phase 3 */
 
 #if SHORT_OPCODES
diff --git a/quickjs/quickjs/quickjs.c b/thirdparty/quickjs/quickjs/quickjs.c
similarity index 99%
rename from quickjs/quickjs/quickjs.c
rename to thirdparty/quickjs/quickjs/quickjs.c
index 0e01ac1e..99b6be9e 100644
--- a/quickjs/quickjs/quickjs.c
+++ b/thirdparty/quickjs/quickjs/quickjs.c
@@ -1,6 +1,6 @@
 /*
  * QuickJS Javascript Engine
- * 
+ *
  * Copyright (c) 2017-2020 Fabrice Bellard
  * Copyright (c) 2017-2020 Charlie Gordon
  *
@@ -197,7 +197,7 @@ typedef enum JSErrorEnum {
     JS_URI_ERROR,
     JS_INTERNAL_ERROR,
     JS_AGGREGATE_ERROR,
-    
+
     JS_NATIVE_ERROR_COUNT, /* number of different NativeError objects */
 } JSErrorEnum;
 
@@ -260,7 +260,7 @@ struct JSRuntime {
        by the garbage collector) */
     struct list_head gc_obj_list;
     /* list of JSGCObjectHeader.link. Used during JS_FreeValueRT() */
-    struct list_head gc_zero_ref_count_list; 
+    struct list_head gc_zero_ref_count_list;
     struct list_head tmp_obj_list; /* used during GC */
     JSGCPhaseEnum gc_phase : 8;
     size_t malloc_gc_threshold;
@@ -282,7 +282,7 @@ struct JSRuntime {
 
     JSHostPromiseRejectionTracker *host_promise_rejection_tracker;
     void *host_promise_rejection_tracker_opaque;
-    
+
     struct list_head job_list; /* list of JSJobEntry.link */
 
     JSModuleNormalizeFunc *module_normalize_func;
@@ -292,7 +292,7 @@ struct JSRuntime {
     BOOL can_block : 8; /* TRUE if Atomics.wait can block */
     /* used to allocate, free and clone SharedArrayBuffers */
     JSSharedArrayBufferFunctions sab_funcs;
-    
+
     /* Shape hash table */
     int shape_hash_bits;
     int shape_hash_size;
@@ -337,7 +337,7 @@ typedef struct JSStackFrame {
     int arg_count;
     int js_mode; /* 0 or JS_MODE_MATH for C functions */
     /* only used in generators. Current stack pointer value. NULL if
-       the function is running. */ 
+       the function is running. */
     JSValue *cur_sp;
 } JSStackFrame;
 
@@ -371,9 +371,9 @@ typedef struct JSVarRef {
 
             /* 0 : the JSVarRef is on the stack. header.link is an element
                of JSStackFrame.var_ref_list.
-               1 : the JSVarRef is detached. header.link has the normal meanning 
+               1 : the JSVarRef is detached. header.link has the normal meanning
             */
-            uint8_t is_detached : 1; 
+            uint8_t is_detached : 1;
             uint8_t is_arg : 1;
             uint16_t var_idx; /* index of the corresponding function variable on
                                  the stack */
@@ -793,7 +793,7 @@ struct JSModuleDef {
     BOOL eval_mark : 8; /* temporary use during js_evaluate_module() */
     /* true if evaluation yielded an exception. It is saved in
        eval_exception */
-    BOOL eval_has_exception : 8; 
+    BOOL eval_has_exception : 8;
     JSValue eval_exception;
     JSValue meta_obj; /* for import.meta */
 };
@@ -861,7 +861,7 @@ struct JSObject {
         struct {
             int __gc_ref_count; /* corresponds to header.ref_count */
             uint8_t __gc_mark; /* corresponds to header.mark/gc_obj_type */
-            
+
             uint8_t extensible : 1;
             uint8_t free_mark : 1; /* only used when freeing objects with cycles */
             uint8_t is_exotic : 1; /* TRUE if object has exotic property handlers */
@@ -921,7 +921,7 @@ struct JSObject {
                 struct JSTypedArray *typed_array; /* JS_CLASS_UINT8C_ARRAY..JS_CLASS_FLOAT64_ARRAY */
             } u1;
             union {
-                JSValue *values;        /* JS_CLASS_ARRAY, JS_CLASS_ARGUMENTS */ 
+                JSValue *values;        /* JS_CLASS_ARRAY, JS_CLASS_ARGUMENTS */
                 void *ptr;              /* JS_CLASS_UINT8C_ARRAY..JS_CLASS_FLOAT64_ARRAY */
                 int8_t *int8_ptr;       /* JS_CLASS_INT8_ARRAY */
                 uint8_t *uint8_ptr;     /* JS_CLASS_UINT8_ARRAY, JS_CLASS_UINT8C_ARRAY */
@@ -1620,7 +1620,7 @@ JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
     init_list_head(&rt->gc_obj_list);
     init_list_head(&rt->gc_zero_ref_count_list);
     rt->gc_phase = JS_GC_PHASE_NONE;
-    
+
 #ifdef DUMP_LEAKS
     init_list_head(&rt->string_list);
 #endif
@@ -2278,7 +2278,7 @@ void JS_FreeContext(JSContext *ctx)
     if (--ctx->header.ref_count > 0)
         return;
     assert(ctx->header.ref_count == 0);
-    
+
 #ifdef DUMP_ATOMS
     JS_DumpAtoms(ctx->rt);
 #endif
@@ -3318,7 +3318,7 @@ static JSAtom js_atom_concat_str(JSContext *ctx, JSAtom name, const char *str1)
     const char *cstr;
     char *cstr2;
     size_t len, len1;
-    
+
     str = JS_AtomToString(ctx, name);
     if (JS_IsException(str))
         return JS_ATOM_NULL;
@@ -3854,7 +3854,7 @@ JSValue JS_NewStringLen(JSContext *ctx, const char *buf, size_t buf_len)
     uint32_t c;
     StringBuffer b_s, *b = &b_s;
     size_t len1;
-    
+
     p_start = (const uint8_t *)buf;
     p_end = p_start + buf_len;
     p = p_start;
@@ -4346,7 +4346,7 @@ static no_inline JSShape *js_new_shape2(JSContext *ctx, JSObject *proto,
     sh->prop_size = prop_size;
     sh->prop_count = 0;
     sh->deleted_prop_count = 0;
-    
+
     /* insert in the hash table */
     sh->hash = shape_initial_hash(proto);
     sh->is_hashed = TRUE;
@@ -4506,7 +4506,7 @@ static int compact_properties(JSContext *ctx, JSObject *p)
     uint32_t new_hash_size, i, j, new_hash_mask, new_size;
     JSShapeProperty *old_pr, *pr;
     JSProperty *prop, *new_prop;
-    
+
     sh = p->shape;
     assert(!sh->is_hashed);
 
@@ -4528,7 +4528,7 @@ static int compact_properties(JSContext *ctx, JSObject *p)
     list_del(&old_sh->header.link);
     memcpy(sh, old_sh, sizeof(JSShape));
     list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
-    
+
     memset(prop_hash_end(sh) - new_hash_size, 0,
            sizeof(prop_hash_end(sh)[0]) * new_hash_size);
 
@@ -4557,7 +4557,7 @@ static int compact_properties(JSContext *ctx, JSObject *p)
 
     p->shape = sh;
     js_free(ctx, get_alloc_from_shape(old_sh));
-    
+
     /* reduce the size of the object properties */
     new_prop = js_realloc(ctx, p->prop, sizeof(new_prop[0]) * new_size);
     if (new_prop)
@@ -4684,7 +4684,7 @@ static __maybe_unused void JS_DumpShapes(JSRuntime *rt)
     struct list_head *el;
     JSObject *p;
     JSGCObjectHeader *gp;
-    
+
     printf("JSShapes: {\n");
     printf("%5s %4s %14s %5s %5s %s\n", "SLOT", "REFS", "PROTO", "SIZE", "COUNT", "PROPS");
     for(i = 0; i < rt->shape_hash_size; i++) {
@@ -5012,7 +5012,7 @@ static JSValue JS_NewCFunction3(JSContext *ctx, JSCFunction *func,
     JSValue func_obj;
     JSObject *p;
     JSAtom name_atom;
-    
+
     func_obj = JS_NewObjectProtoClass(ctx, proto_val, JS_CLASS_C_FUNCTION);
     if (JS_IsException(func_obj))
         return func_obj;
@@ -5443,7 +5443,7 @@ static void free_zero_refcount(JSRuntime *rt)
 {
     struct list_head *el;
     JSGCObjectHeader *p;
-    
+
     rt->gc_phase = JS_GC_PHASE_DECREF;
     for(;;) {
         el = rt->gc_zero_ref_count_list.next;
@@ -5675,7 +5675,7 @@ static void gc_decref(JSRuntime *rt)
 {
     struct list_head *el, *el1;
     JSGCObjectHeader *p;
-    
+
     init_list_head(&rt->tmp_obj_list);
 
     /* decrement the refcount of all the children of all the GC
@@ -5722,7 +5722,7 @@ static void gc_scan(JSRuntime *rt)
         p->mark = 0; /* reset the mark for the next GC call */
         mark_children(rt, p, gc_scan_incref_child);
     }
-    
+
     /* restore the refcount of the objects to be deleted. */
     list_for_each(el, &rt->tmp_obj_list) {
         p = list_entry(el, JSGCObjectHeader, link);
@@ -5768,7 +5768,7 @@ static void gc_free_cycles(JSRuntime *rt)
         }
     }
     rt->gc_phase = JS_GC_PHASE_NONE;
-           
+
     list_for_each_safe(el, el1, &rt->gc_zero_ref_count_list) {
         p = list_entry(el, JSGCObjectHeader, link);
         assert(p->gc_obj_type == JS_GC_OBJ_TYPE_JS_OBJECT ||
@@ -6438,7 +6438,7 @@ static const char *get_func_name(JSContext *ctx, JSValueConst func)
     JSProperty *pr;
     JSShapeProperty *prs;
     JSValueConst val;
-    
+
     if (JS_VALUE_GET_TAG(func) != JS_TAG_OBJECT)
         return NULL;
     prs = find_own_property(&pr, JS_VALUE_GET_OBJ(func), JS_ATOM_name);
@@ -6469,7 +6469,7 @@ static void build_backtrace(JSContext *ctx, JSValueConst error_obj,
     const char *str1;
     JSObject *p;
     BOOL backtrace_barrier;
-    
+
     js_dbuf_init(ctx, &dbuf);
     if (filename) {
         dbuf_printf(&dbuf, "    at %s", filename);
@@ -7028,7 +7028,7 @@ static int JS_AutoInitProperty(JSContext *ctx, JSObject *p, JSAtom prop,
     int ret;
     JSContext *realm;
     JSAutoInitFunc *func;
-    
+
     realm = js_autoinit_get_realm(pr);
     func = js_autoinit_func_table[js_autoinit_get_id(pr)];
     ret = func(realm, p, prop, pr->u.init.opaque);
@@ -7287,7 +7287,7 @@ static int JS_AddBrand(JSContext *ctx, JSValueConst obj, JSValueConst home_obj)
     JSProperty *pr;
     JSValue brand;
     JSAtom brand_atom;
-    
+
     if (unlikely(JS_VALUE_GET_TAG(home_obj) != JS_TAG_OBJECT)) {
         JS_ThrowTypeErrorNotAnObject(ctx);
         return -1;
@@ -7309,7 +7309,7 @@ static int JS_AddBrand(JSContext *ctx, JSValueConst obj, JSValueConst home_obj)
         brand = JS_DupValue(ctx, pr->u.value);
     }
     brand_atom = js_symbol_to_atom(ctx, brand);
-    
+
     if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT)) {
         JS_ThrowTypeErrorNotAnObject(ctx);
         JS_FreeAtom(ctx, brand_atom);
@@ -7330,7 +7330,7 @@ static int JS_CheckBrand(JSContext *ctx, JSValueConst obj, JSValueConst func)
     JSShapeProperty *prs;
     JSProperty *pr;
     JSValueConst brand;
-    
+
     /* get the home object of 'func' */
     if (unlikely(JS_VALUE_GET_TAG(func) != JS_TAG_OBJECT)) {
     not_obj:
@@ -7352,7 +7352,7 @@ static int JS_CheckBrand(JSContext *ctx, JSValueConst obj, JSValueConst func)
     /* safety check */
     if (unlikely(JS_VALUE_GET_TAG(brand) != JS_TAG_SYMBOL))
         goto not_obj;
-    
+
     /* get the brand array of 'obj' */
     if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
         goto not_obj;
@@ -7411,7 +7411,7 @@ static int __exception JS_GetOwnPropertyNamesInternal(JSContext *ctx,
     BOOL is_enumerable, num_sorted;
     uint32_t num_key;
     JSAtomKindEnum kind;
-    
+
     /* clear pointer for consistency in case of failure */
     *ptab = NULL;
     *plen = 0;
@@ -9350,7 +9350,7 @@ static BOOL js_object_has_name(JSContext *ctx, JSValueConst obj)
     JSShapeProperty *prs;
     JSValueConst val;
     JSString *p;
-    
+
     prs = find_own_property(&pr, JS_VALUE_GET_OBJ(obj), JS_ATOM_name);
     if (!prs)
         return FALSE;
@@ -9624,7 +9624,7 @@ int JS_DeleteProperty(JSContext *ctx, JSValueConst obj, JSAtom prop, int flags)
     JSValue obj1;
     JSObject *p;
     int res;
-    
+
     obj1 = JS_ToObject(ctx, obj);
     if (JS_IsException(obj1))
         return -1;
@@ -9871,7 +9871,7 @@ static inline BOOL JS_IsHTMLDDA(JSContext *ctx, JSValueConst obj)
     p = JS_VALUE_GET_OBJ(obj);
     return p->is_HTMLDDA;
 }
-                         
+
 static int JS_ToBoolFree(JSContext *ctx, JSValue val)
 {
     uint32_t tag = JS_VALUE_GET_TAG(val);
@@ -9973,11 +9973,11 @@ static double js_strtod(const char *p, int radix, BOOL is_float)
 {
     double d;
     int c;
-    
+
     if (!is_float || radix != 10) {
         uint64_t n_max, n;
         int int_exp, is_neg;
-        
+
         is_neg = 0;
         if (*p == '-') {
             is_neg = 1;
@@ -10025,7 +10025,7 @@ static double js_strtod(const char *p, int radix, BOOL is_float)
 /* accept _ between digits as a digit separator */
 #define ATOD_ACCEPT_UNDERSCORES  (1 << 5)
 /* allow a suffix to override the type */
-#define ATOD_ACCEPT_SUFFIX    (1 << 6) 
+#define ATOD_ACCEPT_SUFFIX    (1 << 6)
 /* default type */
 #define ATOD_TYPE_MASK        (3 << 7)
 #define ATOD_TYPE_FLOAT64     (0 << 7)
@@ -10034,7 +10034,7 @@ static double js_strtod(const char *p, int radix, BOOL is_float)
 #define ATOD_TYPE_BIG_DECIMAL (3 << 7)
 /* assume bigint mode: floats are parsed as integers if no decimal
    point nor exponent */
-#define ATOD_MODE_BIGINT      (1 << 9) 
+#define ATOD_MODE_BIGINT      (1 << 9)
 /* accept -0x1 */
 #define ATOD_ACCEPT_PREFIX_AFTER_SIGN (1 << 10)
 
@@ -10064,7 +10064,7 @@ static JSValue js_string_to_bigfloat(JSContext *ctx, const char *buf,
     bf_t *a;
     int ret;
     JSValue val;
-    
+
     val = JS_NewBigFloat(ctx);
     if (JS_IsException(val))
         return val;
@@ -10090,7 +10090,7 @@ static JSValue js_string_to_bigdecimal(JSContext *ctx, const char *buf,
     bfdec_t *a;
     int ret;
     JSValue val;
-    
+
     val = JS_NewBigDecimal(ctx);
     if (JS_IsException(val))
         return val;
@@ -10124,11 +10124,11 @@ static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
     int i, j, len;
     BOOL buf_allocated = FALSE;
     JSValue val;
-    
+
     /* optional separator between digits */
     sep = (flags & ATOD_ACCEPT_UNDERSCORES) ? '_' : 256;
     has_legacy_octal = FALSE;
-    
+
     p = str;
     p_start = p;
     is_neg = 0;
@@ -10333,7 +10333,7 @@ static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
         val = JS_NewFloat64(ctx, d);
     }
 #endif
-    
+
 done:
     if (buf_allocated)
         js_free_rt(ctx->rt, buf);
@@ -10415,7 +10415,7 @@ static JSValue JS_ToNumberHintFree(JSContext *ctx, JSValue val,
             const char *str;
             const char *p;
             size_t len;
-            
+
             str = JS_ToCStringLen(ctx, &len, val);
             JS_FreeValue(ctx, val);
             if (!str)
@@ -11729,7 +11729,7 @@ static __maybe_unused void JS_DumpObject(JSRuntime *rt, JSObject *p)
         }
         printf(" }");
     }
-    
+
     if (js_class_has_bytecode(p->class_id)) {
         JSFunctionBytecode *b = p->u.func.function_bytecode;
         JSVarRef **var_refs;
@@ -12021,7 +12021,7 @@ static bfdec_t *JS_ToBigDecimal(JSContext *ctx, JSValueConst val)
     uint32_t tag;
     JSBigDecimal *p;
     bfdec_t *r;
-    
+
     tag = JS_VALUE_GET_NORM_TAG(val);
     switch(tag) {
     case JS_TAG_BIG_DECIMAL:
@@ -12042,7 +12042,7 @@ static JSValue JS_StringToBigInt(JSContext *ctx, JSValue val)
     const char *str, *p;
     size_t len;
     int flags;
-    
+
     str = JS_ToCStringLen(ctx, &len, val);
     JS_FreeValue(ctx, val);
     if (!str)
@@ -12158,7 +12158,7 @@ static __maybe_unused JSValue JS_ToBigIntValueFree(JSContext *ctx, JSValue val)
     } else {
         bf_t a_s, *a, *r;
         int ret;
-        JSValue res; 
+        JSValue res;
 
         res = JS_NewBigInt(ctx);
         if (JS_IsException(res))
@@ -12260,7 +12260,7 @@ static JSValue JS_CompactBigInt1(JSContext *ctx, JSValue val,
 {
     int64_t v;
     bf_t *a;
-    
+
     if (JS_VALUE_GET_TAG(val) != JS_TAG_BIG_INT)
         return val; /* fail safe */
     a = JS_GetBigInt(val);
@@ -12388,10 +12388,10 @@ static __exception int js_call_binary_op_fallback(JSContext *ctx,
     JSOverloadableOperatorEnum ovop;
     JSObject *p;
     JSValueConst args[2];
-    
+
     if (!ctx->allow_operator_overloading)
         return 0;
-    
+
     opset2_obj = JS_UNDEFINED;
     opset1_obj = JS_GetProperty(ctx, op1, JS_ATOM_Symbol_operatorSet);
     if (JS_IsException(opset1_obj))
@@ -12420,7 +12420,7 @@ static __exception int js_call_binary_op_fallback(JSContext *ctx,
     }
 
     ovop = get_ovop_from_opcode(op);
-    
+
     if (opset1->operator_counter == opset2->operator_counter) {
         p = opset1->self_ops[ovop];
     } else if (opset1->operator_counter > opset2->operator_counter) {
@@ -12445,7 +12445,7 @@ static __exception int js_call_binary_op_fallback(JSContext *ctx,
     } else {
         new_op1 = JS_DupValue(ctx, op1);
     }
-    
+
     if (opset2->is_primitive) {
         if (is_numeric) {
             new_op2 = JS_ToNumeric(ctx, op2);
@@ -12462,7 +12462,7 @@ static __exception int js_call_binary_op_fallback(JSContext *ctx,
 
     /* XXX: could apply JS_ToPrimitive() if primitive type so that the
        operator function does not get a value object */
-    
+
     method = JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, p));
     if (ovop == JS_OVOP_LESS && (op == OP_lte || op == OP_gt)) {
         args[0] = new_op2;
@@ -12573,7 +12573,7 @@ static __exception int js_call_unary_op_fallback(JSContext *ctx,
 
     if (!ctx->allow_operator_overloading)
         return 0;
-    
+
     opset1_obj = JS_GetProperty(ctx, op1, JS_ATOM_Symbol_operatorSet);
     if (JS_IsException(opset1_obj))
         goto exception;
@@ -12629,7 +12629,7 @@ static int js_unary_arith_bigint(JSContext *ctx,
     bf_t a_s, *r, *a;
     int ret, v;
     JSValue res;
-    
+
     if (op == OP_plus && !is_math_mode(ctx)) {
         JS_ThrowTypeError(ctx, "bigint argument with unary +");
         JS_FreeValue(ctx, op1);
@@ -12681,7 +12681,7 @@ static int js_unary_arith_bigfloat(JSContext *ctx,
     bf_t a_s, *r, *a;
     int ret, v;
     JSValue res;
-    
+
     if (op == OP_plus && !is_math_mode(ctx)) {
         JS_ThrowTypeError(ctx, "bigfloat argument with unary +");
         JS_FreeValue(ctx, op1);
@@ -12730,7 +12730,7 @@ static int js_unary_arith_bigdecimal(JSContext *ctx,
     bfdec_t *r, *a;
     int ret, v;
     JSValue res;
-    
+
     if (op == OP_plus && !is_math_mode(ctx)) {
         JS_ThrowTypeError(ctx, "bigdecimal argument with unary +");
         JS_FreeValue(ctx, op1);
@@ -12890,7 +12890,7 @@ static no_inline int js_not_slow(JSContext *ctx, JSValue *sp)
 {
     JSValue op1, val;
     int ret;
-    
+
     op1 = sp[-1];
     if (JS_IsObject(op1)) {
         ret = js_call_unary_op_fallback(ctx, &val, op1, OP_not);
@@ -12927,7 +12927,7 @@ static int js_binary_arith_bigfloat(JSContext *ctx, OPCodeEnum op,
     bf_t a_s, b_s, *r, *a, *b;
     int ret;
     JSValue res;
-    
+
     res = JS_NewBigFloat(ctx);
     if (JS_IsException(res)) {
         JS_FreeValue(ctx, op1);
@@ -12988,7 +12988,7 @@ static int js_binary_arith_bigint(JSContext *ctx, OPCodeEnum op,
     bf_t a_s, b_s, *r, *a, *b;
     int ret;
     JSValue res;
-    
+
     res = JS_NewBigInt(ctx);
     if (JS_IsException(res))
         goto fail;
@@ -13175,7 +13175,7 @@ static int js_binary_arith_bigdecimal(JSContext *ctx, OPCodeEnum op,
     if (JS_IsException(res))
         goto fail;
     r = JS_GetBigDecimal(res);
-    
+
     a = JS_ToBigDecimal(ctx, op1);
     if (!a)
         goto fail;
@@ -13602,7 +13602,7 @@ static int js_compare_bigfloat(JSContext *ctx, OPCodeEnum op,
 {
     bf_t a_s, b_s, *a, *b;
     int res;
-    
+
     a = JS_ToBigFloat(ctx, &a_s, op1);
     if (!a) {
         JS_FreeValue(ctx, op2);
@@ -13664,7 +13664,7 @@ static int js_compare_bigdecimal(JSContext *ctx, OPCodeEnum op,
     }
     a = JS_ToBigDecimal(ctx, op1);
     b = JS_ToBigDecimal(ctx, op2);
-    
+
     switch(op) {
     case OP_lt:
         res = bfdec_cmp_lt(a, b); /* if NaN return false */
@@ -14053,7 +14053,7 @@ static JSValue js_mul_pow10_to_float64(JSContext *ctx, const bf_t *a,
     bf_t r_s, *r = &r_s;
     double d;
     int ret;
-    
+
     /* always convert to Float64 */
     bf_init(ctx->bf_ctx, r);
     ret = bf_mul_pow_radix(r, a, 10, exponent,
@@ -14775,7 +14775,7 @@ static __exception int js_operator_typeof(JSContext *ctx, JSValueConst op1)
         {
             JSObject *p;
             p = JS_VALUE_GET_OBJ(op1);
-            if (unlikely(p->is_HTMLDDA)) 
+            if (unlikely(p->is_HTMLDDA))
                 atom = JS_ATOM_undefined;
             else if (JS_IsFunction(ctx, op1))
                 atom = JS_ATOM_function;
@@ -15488,7 +15488,7 @@ static __exception int js_append_enumerate(JSContext *ctx, JSValue *sp)
     int is_array_iterator;
     JSValue *arrp;
     uint32_t i, count32, pos;
-    
+
     if (JS_VALUE_GET_TAG(sp[-2]) != JS_TAG_INT) {
         JS_ThrowInternalError(ctx, "invalid index for append");
         return -1;
@@ -15936,7 +15936,7 @@ static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
     sf->prev_frame = prev_sf;
     rt->current_stack_frame = sf;
     ctx = p->u.cfunc.realm; /* change the current realm */
-    
+
 #ifdef CONFIG_BIGNUM
     /* we only propagate the bignum mode as some runtime functions
        test it */
@@ -16124,7 +16124,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
 #define DEF(id, size, n_pop, n_push, f) && case_OP_ ## id,
 #if SHORT_OPCODES
 #define def(id, size, n_pop, n_push, f)
-#else                                                     
+#else
 #define def(id, size, n_pop, n_push, f) && case_default,
 #endif
 #include "quickjs-opcode.h"
@@ -16238,7 +16238,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
     sf->prev_frame = rt->current_stack_frame;
     rt->current_stack_frame = sf;
     ctx = b->realm; /* set the current realm */
-    
+
  restart:
     for(;;) {
         int call_argc;
@@ -16691,7 +16691,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             JS_FreeValue(ctx, sp[-1]);
             sp -= 2;
             BREAK;
-            
+
         CASE(OP_throw):
             JS_Throw(ctx, *--sp);
             goto exception;
@@ -17529,7 +17529,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             {
                 JSAtom atom;
                 JSValue val;
-                
+
                 atom = get_u32(pc);
                 pc += 4;
                 val = JS_NewSymbolFromAtom(ctx, atom, JS_ATOM_TYPE_PRIVATE);
@@ -17538,7 +17538,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
                 *sp++ = val;
             }
             BREAK;
-            
+
         CASE(OP_get_private_field):
             {
                 JSValue val;
@@ -17691,7 +17691,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
             {
                 int class_flags;
                 JSAtom atom;
-                
+
                 atom = get_u32(pc);
                 class_flags = pc[4];
                 pc += 5;
@@ -18669,7 +18669,7 @@ static JSContext *JS_GetFunctionRealm(JSContext *ctx, JSValueConst func_obj)
 {
     JSObject *p;
     JSContext *realm;
-    
+
     if (JS_VALUE_GET_TAG(func_obj) != JS_TAG_OBJECT)
         return ctx;
     p = JS_VALUE_GET_OBJ(func_obj);
@@ -18718,7 +18718,7 @@ static JSValue js_create_from_ctor(JSContext *ctx, JSValueConst ctor,
 {
     JSValue proto, obj;
     JSContext *realm;
-    
+
     if (JS_IsUndefined(ctor)) {
         proto = JS_DupValue(ctx, ctx->class_proto[class_id]);
     } else {
@@ -18885,7 +18885,7 @@ static void async_func_free(JSRuntime *rt, JSAsyncFunctionState *s)
 
     /* close the closure variables. */
     close_var_refs(rt, sf);
-    
+
     if (sf->arg_buf) {
         /* cannot free the function if it is running */
         assert(sf->cur_sp != NULL);
@@ -20011,7 +20011,7 @@ typedef struct JSFunctionDef {
     int this_active_func_var_idx; /* variable containg the 'this.active_func' value, -1 if none */
     int home_object_var_idx;
     BOOL need_home_object;
-    
+
     int scope_level;    /* index into fd->scopes if the current lexical scope */
     int scope_first;    /* index into vd->vars of first lexically scoped variable */
     int scope_size;     /* allocated size of fd->scopes array */
@@ -20027,7 +20027,7 @@ typedef struct JSFunctionDef {
     int last_opcode_pos; /* -1 if no last opcode */
     int last_opcode_line_num;
     BOOL use_short_opcodes; /* true if short opcodes are used in byte_code */
-    
+
     LabelSlot *label_slots;
     int label_size; /* allocated size for label_slots[] */
     int label_count;
@@ -20242,7 +20242,7 @@ int __attribute__((format(printf, 2, 3))) js_parse_error(JSParseState *s, const
     JSContext *ctx = s->ctx;
     va_list ap;
     int backtrace_flags;
-    
+
     va_start(ap, fmt);
     JS_ThrowError2(ctx, JS_SYNTAX_ERROR, fmt, ap, FALSE);
     va_end(ap);
@@ -20592,7 +20592,7 @@ static __exception int ident_realloc(JSContext *ctx, char **pbuf, size_t *psize,
 {
     char *buf, *new_buf;
     size_t size, new_size;
-    
+
     buf = *pbuf;
     size = *psize;
     if (size >= (SIZE_MAX / 3) * 2)
@@ -20622,7 +20622,7 @@ static JSAtom parse_ident(JSParseState *s, const uint8_t **pp,
     char ident_buf[128], *buf;
     size_t ident_size, ident_pos;
     JSAtom atom;
-    
+
     p = *pp;
     buf = ident_buf;
     ident_size = sizeof(ident_buf);
@@ -20631,7 +20631,7 @@ static JSAtom parse_ident(JSParseState *s, const uint8_t **pp,
         buf[ident_pos++] = '#';
     for(;;) {
         p1 = p;
-        
+
         if (c < 128) {
             buf[ident_pos++] = c;
         } else {
@@ -20669,11 +20669,11 @@ static __exception int next_token(JSParseState *s)
     int c;
     BOOL ident_has_escape;
     JSAtom atom;
-    
+
     if (js_check_stack_overflow(s->ctx->rt, 0)) {
         return js_parse_error(s, "stack overflow");
     }
-    
+
     free_token(s, &s->token);
 
     p = s->last_ptr = s->buf_ptr;
@@ -20800,14 +20800,14 @@ static __exception int next_token(JSParseState *s)
     case 'm': case 'n': case 'o': case 'p':
     case 'q': case 'r': case 's': case 't':
     case 'u': case 'v': case 'w': case 'x':
-    case 'y': case 'z': 
+    case 'y': case 'z':
     case 'A': case 'B': case 'C': case 'D':
     case 'E': case 'F': case 'G': case 'H':
     case 'I': case 'J': case 'K': case 'L':
     case 'M': case 'N': case 'O': case 'P':
     case 'Q': case 'R': case 'S': case 'T':
     case 'U': case 'V': case 'W': case 'X':
-    case 'Y': case 'Z': 
+    case 'Y': case 'Z':
     case '_':
     case '$':
         /* identifier */
@@ -20891,7 +20891,7 @@ static __exception int next_token(JSParseState *s)
         goto parse_number;
     case '1': case '2': case '3': case '4':
     case '5': case '6': case '7': case '8':
-    case '9': 
+    case '9':
         /* number */
     parse_number:
         {
@@ -21149,7 +21149,7 @@ static __exception int next_token(JSParseState *s)
             case CP_LS:
                 /* XXX: should avoid incrementing line_number, but
                    needed to handle HTML comments */
-                goto line_terminator; 
+                goto line_terminator;
             default:
                 if (lre_is_space(c)) {
                     goto redo;
@@ -21184,7 +21184,7 @@ static JSAtom json_parse_ident(JSParseState *s, const uint8_t **pp, int c)
     char ident_buf[128], *buf;
     size_t ident_size, ident_pos;
     JSAtom atom;
-    
+
     p = *pp;
     buf = ident_buf;
     ident_size = sizeof(ident_buf);
@@ -21216,11 +21216,11 @@ static __exception int json_next_token(JSParseState *s)
     const uint8_t *p;
     int c;
     JSAtom atom;
-    
+
     if (js_check_stack_overflow(s->ctx->rt, 0)) {
         return js_parse_error(s, "stack overflow");
     }
-    
+
     free_token(s, &s->token);
 
     p = s->last_ptr = s->buf_ptr;
@@ -21330,14 +21330,14 @@ static __exception int json_next_token(JSParseState *s)
     case 'm': case 'n': case 'o': case 'p':
     case 'q': case 'r': case 's': case 't':
     case 'u': case 'v': case 'w': case 'x':
-    case 'y': case 'z': 
+    case 'y': case 'z':
     case 'A': case 'B': case 'C': case 'D':
     case 'E': case 'F': case 'G': case 'H':
     case 'I': case 'J': case 'K': case 'L':
     case 'M': case 'N': case 'O': case 'P':
     case 'Q': case 'R': case 'S': case 'T':
     case 'U': case 'V': case 'W': case 'X':
-    case 'Y': case 'Z': 
+    case 'Y': case 'Z':
     case '_':
     case '$':
         /* identifier : only pure ascii characters are accepted */
@@ -21364,7 +21364,7 @@ static __exception int json_next_token(JSParseState *s)
         goto parse_number;
     case '1': case '2': case '3': case '4':
     case '5': case '6': case '7': case '8':
-    case '9': 
+    case '9':
         /* number */
     parse_number:
         {
@@ -21412,7 +21412,7 @@ static int simple_next_token(const uint8_t **pp, BOOL no_line_terminator)
 {
     const uint8_t *p;
     uint32_t c;
-    
+
     /* skip spaces and comments */
     p = *pp;
     for (;;) {
@@ -21643,7 +21643,7 @@ static int emit_goto(JSParseState *s, int opcode, int label)
 static int cpool_add(JSParseState *s, JSValue val)
 {
     JSFunctionDef *fd = s->cur_func;
-    
+
     if (js_resize_array(s->ctx, (void *)&fd->cpool, sizeof(fd->cpool[0]),
                         &fd->cpool_size, fd->cpool_count + 1))
         return -1;
@@ -21993,7 +21993,7 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name,
         if (find_var_in_child_scope(ctx, fd, name, fd->scope_level) >= 0) {
             return js_parse_error(s, "invalid redefinition of a variable");
         }
-        
+
         if (fd->is_global_var) {
             JSHoistedDef *hf;
             hf = find_hoisted_def(fd, name);
@@ -22002,7 +22002,7 @@ static int define_var(JSParseState *s, JSFunctionDef *fd, JSAtom name,
                 return js_parse_error(s, "invalid redefinition of global identifier");
             }
         }
-        
+
         if (fd->is_eval &&
             (fd->eval_type == JS_EVAL_TYPE_GLOBAL ||
              fd->eval_type == JS_EVAL_TYPE_MODULE) &&
@@ -22271,7 +22271,7 @@ static int __exception js_parse_property_name(JSParseState *s,
     BOOL is_non_reserved_ident;
     JSAtom name;
     int prop_type;
-    
+
     prop_type = PROP_TYPE_IDENT;
     if (allow_method) {
         if (token_is_pseudo_keyword(s, JS_ATOM_get)
@@ -22496,7 +22496,7 @@ static int js_parse_skip_parens_token(JSParseState *s, int *pbits, BOOL no_line_
                 if (level >= sizeof(state))
                     goto done;
                 state[level++] = '`';
-            } 
+            }
             break;
         case TOK_EOF:
             goto done;
@@ -22732,7 +22732,7 @@ static __exception int js_parse_class_default_ctor(JSParseState *s,
     int ret, line_num;
     JSParseFunctionEnum func_type;
     const uint8_t *saved_buf_end;
-    
+
     js_parse_get_pos(s, &pos);
     if (has_super) {
         str = "(...a){super(...a);}";
@@ -22778,7 +22778,7 @@ static int find_private_class_field(JSContext *ctx, JSFunctionDef *fd,
 static void emit_class_field_init(JSParseState *s)
 {
     int label_next;
-    
+
     emit_op(s, OP_scope_get_var);
     emit_atom(s, JS_ATOM_class_fields_init);
     emit_u16(s, s->cur_func->scope_level);
@@ -22786,13 +22786,13 @@ static void emit_class_field_init(JSParseState *s)
     /* no need to call the class field initializer if not defined */
     emit_op(s, OP_dup);
     label_next = emit_goto(s, OP_if_false, -1);
-    
+
     emit_op(s, OP_scope_get_var);
     emit_atom(s, JS_ATOM_this);
     emit_u16(s, 0);
-    
+
     emit_op(s, OP_swap);
-    
+
     emit_op(s, OP_call_method);
     emit_u16(s, 0);
 
@@ -22817,29 +22817,29 @@ static __exception int emit_class_init_start(JSParseState *s,
                                              ClassFieldsDef *cf)
 {
     int label_add_brand;
-    
+
     cf->fields_init_fd = js_parse_function_class_fields_init(s);
     if (!cf->fields_init_fd)
         return -1;
 
     s->cur_func = cf->fields_init_fd;
-    
+
     /* XXX: would be better to add the code only if needed, maybe in a
        later pass */
     emit_op(s, OP_push_false); /* will be patched later */
     cf->brand_push_pos = cf->fields_init_fd->last_opcode_pos;
     label_add_brand = emit_goto(s, OP_if_false, -1);
-    
+
     emit_op(s, OP_scope_get_var);
     emit_atom(s, JS_ATOM_this);
     emit_u16(s, 0);
-    
+
     emit_op(s, OP_scope_get_var);
     emit_atom(s, JS_ATOM_home_object);
     emit_u16(s, 0);
-    
+
     emit_op(s, OP_add_brand);
-    
+
     emit_label(s, label_add_brand);
 
     s->cur_func = s->cur_func->parent;
@@ -22856,7 +22856,7 @@ static __exception int add_brand(JSParseState *s, ClassFieldsDef *cf)
         }
         /* patch the start of the function to enable the OP_add_brand code */
         cf->fields_init_fd->byte_code.buf[cf->brand_push_pos] = OP_push_true;
-        
+
         cf->has_brand = TRUE;
     }
     return 0;
@@ -22865,11 +22865,11 @@ static __exception int add_brand(JSParseState *s, ClassFieldsDef *cf)
 static void emit_class_init_end(JSParseState *s, ClassFieldsDef *cf)
 {
     int cpool_idx;
-        
+
     s->cur_func = cf->fields_init_fd;
     emit_op(s, OP_return_undef);
     s->cur_func = s->cur_func->parent;
-    
+
     cpool_idx = cpool_add(s, JS_NULL);
     cf->fields_init_fd->parent_cpool_idx = cpool_idx;
     emit_op(s, OP_fclosure);
@@ -22892,7 +22892,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
     const uint8_t *class_start_ptr = s->token.ptr;
     const uint8_t *start_ptr;
     ClassFieldsDef class_fields[2];
-        
+
     /* classes are parsed and executed in strict mode */
     saved_js_mode = fd->js_mode;
     fd->js_mode |= JS_MODE_STRICT;
@@ -22956,7 +22956,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
     } else {
         class_name1 = class_name;
     }
-    
+
     emit_op(s, OP_define_class);
     emit_atom(s, class_name1);
     emit_u8(s, class_flags);
@@ -22968,7 +22968,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         cf->computed_fields_count = 0;
         cf->has_brand = FALSE;
     }
-    
+
     ctor_fd = NULL;
     while (s->token.val != '}') {
         if (s->token.val == ';') {
@@ -22998,7 +22998,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         }
         is_private = prop_type & PROP_TYPE_PRIVATE;
         prop_type &= ~PROP_TYPE_PRIVATE;
-        
+
         if ((name == JS_ATOM_constructor && !is_static &&
              prop_type != PROP_TYPE_IDENT) ||
             (name == JS_ATOM_prototype && is_static) ||
@@ -23044,7 +23044,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                 if (is_set) {
                     JSAtom setter_name;
                     int ret;
-                    
+
                     setter_name = get_private_setter_name(ctx, name);
                     if (setter_name == JS_ATOM_NULL)
                         goto fail;
@@ -23070,7 +23070,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         } else if (prop_type == PROP_TYPE_IDENT && s->token.val != '(') {
             ClassFieldsDef *cf = &class_fields[is_static];
             JSAtom field_var_name = JS_ATOM_NULL;
-            
+
             /* class field */
 
             /* XXX: spec: not consistent with method name checks */
@@ -23078,7 +23078,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                 js_parse_error(s, "invalid field name");
                 goto fail;
             }
-            
+
             if (is_private) {
                 if (find_private_class_field(ctx, fd, name,
                                              fd->scope_level) >= 0) {
@@ -23128,7 +23128,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
                 emit_atom(s, name);
                 emit_u16(s, s->cur_func->scope_level);
             }
-            
+
             if (s->token.val == '=') {
                 if (next_token(s))
                     goto fail;
@@ -23155,7 +23155,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         } else {
             JSParseFunctionEnum func_type;
             JSFunctionKindEnum func_kind;
-            
+
             func_type = JS_PARSE_FUNC_METHOD;
             func_kind = JS_FUNC_NORMAL;
             if (prop_type == PROP_TYPE_STAR) {
@@ -23247,7 +23247,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
     {
         ClassFieldsDef *cf = &class_fields[0];
         int var_idx;
-        
+
         var_idx = define_var(s, fd, JS_ATOM_class_fields_init,
                              JS_VAR_DEF_CONST);
         if (var_idx < 0)
@@ -23274,7 +23274,7 @@ static __exception int js_parse_class(JSParseState *s, BOOL is_class_expr,
         emit_u16(s, 0);
         emit_op(s, OP_drop);
     }
-    
+
     if (class_name != JS_ATOM_NULL) {
         /* store the class name in the scoped class name variable (it
            is independent from the class statement variable
@@ -23678,7 +23678,7 @@ static void put_lvalue(JSParseState *s, int opcode, int scope,
     default:
         break;
     }
-    
+
     switch(opcode) {
     case OP_scope_get_var:  /* val -- */
         assert(special == PUT_LVALUE_NOKEEP ||
@@ -23732,7 +23732,7 @@ static __exception int js_define_var(JSParseState *s, JSAtom name, int tok)
 {
     JSFunctionDef *fd = s->cur_func;
     JSVarDefEnum var_def_type;
-    
+
     if (name == JS_ATOM_yield && fd->func_kind == JS_FUNC_GENERATOR) {
         return js_parse_error(s, "yield is a reserved identifier");
     }
@@ -24275,7 +24275,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
 {
     FuncCallType call_type;
     int optional_chaining_label;
-    
+
     call_type = FUNC_CALL_NORMAL;
     switch(s->token.val) {
     case TOK_NUMBER:
@@ -24331,7 +24331,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
         if (next_token(s))
             return -1;
         break;
-        
+
     case TOK_DIV_ASSIGN:
         s->buf_ptr -= 2;
         goto parse_regexp;
@@ -24570,7 +24570,7 @@ static __exception int js_parse_postfix_expr(JSParseState *s, BOOL accept_lparen
     for(;;) {
         JSFunctionDef *fd = s->cur_func;
         BOOL has_optional_chain = FALSE;
-        
+
         if (s->token.val == TOK_QUESTION_MARK_DOT) {
             /* optional chaining */
             if (next_token(s))
@@ -25063,7 +25063,7 @@ static __exception int js_parse_unary(JSParseState *s, int exponentiation_flag)
             put_lvalue(s, opcode, scope, name, label, PUT_LVALUE_KEEP_SECOND,
                        FALSE);
             if (next_token(s))
-                return -1;        
+                return -1;
         }
         break;
     }
@@ -25296,7 +25296,7 @@ static __exception int js_parse_logical_and_or(JSParseState *s, int op,
 static __exception int js_parse_coalesce_expr(JSParseState *s, BOOL in_accepted)
 {
     int label1;
-    
+
     if (js_parse_logical_and_or(s, TOK_LOR, in_accepted))
         return -1;
     if (s->token.val == TOK_DOUBLE_QUESTION_MARK) {
@@ -25304,12 +25304,12 @@ static __exception int js_parse_coalesce_expr(JSParseState *s, BOOL in_accepted)
         for(;;) {
             if (next_token(s))
                 return -1;
-            
+
             emit_op(s, OP_dup);
             emit_op(s, OP_is_undefined_or_null);
             emit_goto(s, OP_if_false, label1);
             emit_op(s, OP_drop);
-            
+
             if (js_parse_expr_binary(s, 8, in_accepted))
                 return -1;
             if (s->token.val != TOK_DOUBLE_QUESTION_MARK)
@@ -25528,7 +25528,7 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
         put_lvalue(s, opcode, scope, name, label, PUT_LVALUE_KEEP_TOP, FALSE);
     } else if (op >= TOK_LAND_ASSIGN && op <= TOK_DOUBLE_QUESTION_MARK_ASSIGN) {
         int label, label1, depth_lvalue, label2;
-        
+
         if (next_token(s))
             return -1;
         if (get_lvalue(s, &opcode, &scope, &name, &label,
@@ -25541,7 +25541,7 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
         label1 = emit_goto(s, op == TOK_LOR_ASSIGN ? OP_if_true : OP_if_false,
                            -1);
         emit_op(s, OP_drop);
-        
+
         if (js_parse_assign_expr(s, in_accepted)) {
             JS_FreeAtom(s->ctx, name);
             return -1;
@@ -25550,7 +25550,7 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
         if (opcode == OP_get_ref_value && name == name0) {
             set_object_name(s, name);
         }
-        
+
         switch(depth_lvalue) {
         case 1:
             emit_op(s, OP_insert2);
@@ -25570,7 +25570,7 @@ static __exception int js_parse_assign_expr(JSParseState *s, BOOL in_accepted)
         put_lvalue(s, opcode, scope, name, label, PUT_LVALUE_NOKEEP_DEPTH,
                    FALSE);
         label2 = emit_goto(s, OP_goto, -1);
-        
+
         emit_label(s, label1);
 
         /* remove the lvalue stack entries */
@@ -26870,7 +26870,7 @@ static __exception int js_parse_statement_or_decl(JSParseState *s,
         if (js_parse_expect_semi(s))
             goto fail;
         break;
-        
+
     case TOK_ENUM:
     case TOK_EXPORT:
     case TOK_EXTENDS:
@@ -27187,7 +27187,7 @@ static JSModuleDef *js_find_loaded_module(JSContext *ctx, JSAtom name)
 {
     struct list_head *el;
     JSModuleDef *m;
-    
+
     /* first look at the loaded modules */
     list_for_each(el, &ctx->loaded_modules) {
         m = list_entry(el, JSModuleDef, link);
@@ -27252,7 +27252,7 @@ static JSModuleDef *js_host_resolve_imported_module_atom(JSContext *ctx,
 {
     const char *base_cname, *cname;
     JSModuleDef *m;
-    
+
     base_cname = JS_AtomToCString(ctx, base_module_name);
     if (!base_cname)
         return NULL;
@@ -27567,7 +27567,7 @@ static int js_module_ns_autoinit(JSContext *ctx, JSObject *p, JSAtom atom,
 {
     JSModuleDef *m = opaque;
     JSValue val, this_val = JS_MKPTR(JS_TAG_OBJECT, p);
-    
+
     val = js_get_module_ns(ctx, m);
     if (JS_IsException(val))
         return -1;
@@ -27798,7 +27798,7 @@ static int js_create_module_function(JSContext *ctx, JSModuleDef *m)
     BOOL is_c_module;
     int i;
     JSVarRef *var_ref;
-    
+
     if (m->func_created)
         return 0;
 
@@ -27822,7 +27822,7 @@ static int js_create_module_function(JSContext *ctx, JSModuleDef *m)
     m->func_created = TRUE;
 
     /* do it on the dependencies */
-    
+
     for(i = 0; i < m->req_module_entries_count; i++) {
         JSReqModuleEntry *rme = &m->req_module_entries[i];
         if (js_create_module_function(ctx, rme->module) < 0)
@@ -27830,9 +27830,9 @@ static int js_create_module_function(JSContext *ctx, JSModuleDef *m)
     }
 
     return 0;
-}    
+}
+
 
-    
 /* Prepare a module to be executed by resolving all the imported
    variables. */
 static int js_instantiate_module(JSContext *ctx, JSModuleDef *m)
@@ -28038,7 +28038,7 @@ static JSValue js_import_meta(JSContext *ctx)
 {
     JSAtom filename;
     JSModuleDef *m;
-    
+
     filename = JS_GetScriptOrModuleName(ctx, 0);
     if (filename == JS_ATOM_NULL)
         goto fail;
@@ -28061,11 +28061,11 @@ JSModuleDef *JS_RunModule(JSContext *ctx, const char *basename,
 {
     JSModuleDef *m;
     JSValue ret, func_obj;
-    
+
     m = js_host_resolve_imported_module(ctx, basename, filename);
     if (!m)
         return NULL;
-    
+
     if (js_resolve_module(ctx, m) < 0) {
         js_free_modules(ctx, JS_FREE_MODULE_NOT_RESOLVED);
         return NULL;
@@ -28101,7 +28101,7 @@ static JSValue js_dynamic_import_job(JSContext *ctx,
     filename = JS_ToCString(ctx, specifier);
     if (!filename)
         goto exception;
-                     
+
     m = JS_RunModule(ctx, basename, filename);
     JS_FreeCString(ctx, filename);
     if (!m)
@@ -28143,7 +28143,7 @@ static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier)
     JS_FreeAtom(ctx, basename);
     if (JS_IsException(basename_val))
         return basename_val;
-    
+
     promise = JS_NewPromiseCapability(ctx, resolving_funcs);
     if (JS_IsException(promise)) {
         JS_FreeValue(ctx, basename_val);
@@ -28154,7 +28154,7 @@ static JSValue js_dynamic_import(JSContext *ctx, JSValueConst specifier)
     args[1] = resolving_funcs[1];
     args[2] = basename_val;
     args[3] = specifier;
-    
+
     JS_EnqueueJob(ctx, js_dynamic_import_job, 4, args);
 
     JS_FreeValue(ctx, basename_val);
@@ -28564,7 +28564,7 @@ static __exception int js_parse_source_element(JSParseState *s)
 {
     JSFunctionDef *fd = s->cur_func;
     int tok;
-    
+
     if (s->token.val == TOK_FUNCTION ||
         (token_is_pseudo_keyword(s, JS_ATOM_async) &&
          peek_token(s, TRUE) == TOK_FUNCTION)) {
@@ -28653,7 +28653,7 @@ static void free_bytecode_atoms(JSRuntime *rt,
     int pos, len, op;
     JSAtom atom;
     const JSOpCode *oi;
-    
+
     pos = 0;
     while (pos < bc_len) {
         op = bc_buf[pos];
@@ -28661,7 +28661,7 @@ static void free_bytecode_atoms(JSRuntime *rt,
             oi = &short_opcode_info(op);
         else
             oi = &opcode_info[op];
-            
+
         len = oi->size;
         switch(oi->fmt) {
         case OP_FMT_atom:
@@ -29899,7 +29899,7 @@ static void get_loc_or_ref(DynBuf *bc, BOOL is_ref, int idx)
 {
     /* if the field is not initialized, the error is catched when
        accessing it */
-    if (is_ref) 
+    if (is_ref)
         dbuf_putc(bc, OP_get_var_ref);
     else
         dbuf_putc(bc, OP_get_loc);
@@ -29914,7 +29914,7 @@ static int resolve_scope_private_field1(JSContext *ctx,
     int idx, var_kind;
     JSFunctionDef *fd;
     BOOL is_ref;
-    
+
     fd = s;
     is_ref = FALSE;
     for(;;) {
@@ -30898,7 +30898,7 @@ static __exception int resolve_variables(JSContext *ctx, JSFunctionDef *s)
         case OP_set_class_name:
             /* only used during parsing */
             break;
-            
+
         default:
         no_change:
             dbuf_put(&bc_out, bc_buf + pos, len);
@@ -32427,7 +32427,7 @@ static JSValue js_create_function(JSContext *ctx, JSFunctionDef *fd)
     b->realm = JS_DupContext(ctx);
 
     add_gc_object(ctx->rt, &b->header, JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
-    
+
 #if defined(DUMP_BYTECODE) && (DUMP_BYTECODE & 1)
     if (!(fd->js_mode & JS_MODE_STRIP)) {
         js_dump_function_bytecode(ctx, b);
@@ -32642,7 +32642,7 @@ static int js_parse_function_check_names(JSParseState *s, JSFunctionDef *fd,
 static JSFunctionDef *js_parse_function_class_fields_init(JSParseState *s)
 {
     JSFunctionDef *fd;
-    
+
     fd = js_new_function_def(s->ctx, s->cur_func, FALSE, FALSE,
                              s->filename, 0);
     if (!fd)
@@ -32650,7 +32650,7 @@ static JSFunctionDef *js_parse_function_class_fields_init(JSParseState *s)
     fd->func_name = JS_ATOM_NULL;
     fd->has_prototype = FALSE;
     fd->has_home_object = TRUE;
-    
+
     fd->has_arguments_binding = FALSE;
     fd->has_this_binding = TRUE;
     fd->is_derived_class_constructor = FALSE;
@@ -32658,7 +32658,7 @@ static JSFunctionDef *js_parse_function_class_fields_init(JSParseState *s)
     fd->super_call_allowed = FALSE;
     fd->super_allowed = fd->has_home_object;
     fd->arguments_allowed = FALSE;
-    
+
     fd->func_kind = JS_FUNC_NORMAL;
     fd->func_type = JS_PARSE_FUNC_METHOD;
     return fd;
@@ -32832,7 +32832,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
     if (func_type == JS_PARSE_FUNC_CLASS_CONSTRUCTOR) {
         emit_class_field_init(s);
     }
-    
+
     /* parse arguments */
     fd->has_simple_parameter_list = TRUE;
     has_opt_arg = FALSE;
@@ -33089,7 +33089,7 @@ static __exception int js_parse_function_decl2(JSParseState *s,
                     /* it is considered as defined at the top level
                        (needed for annex B.3.3.4 and B.3.3.5
                        checks) */
-                    hf->scope_level = 0; 
+                    hf->scope_level = 0;
                     hf->force_init = ((s->cur_func->js_mode & JS_MODE_STRICT) != 0);
                     /* store directly into global var, bypass lexical scope */
                     emit_op(s, OP_dup);
@@ -33490,13 +33490,13 @@ static int js_object_list_resize_hash(JSContext *ctx, JSObjectList *s,
     js_free(ctx, s->hash_table);
     s->hash_table = new_hash_table;
     s->hash_size = new_hash_size;
-    
+
     for(i = 0; i < s->hash_size; i++) {
         s->hash_table[i] = -1;
     }
     for(i = 0; i < s->object_count; i++) {
         e = &s->object_tab[i];
-        h = js_object_list_get_hash(e->obj, s->hash_size); 
+        h = js_object_list_get_hash(e->obj, s->hash_size);
         e->hash_next = s->hash_table[h];
         s->hash_table[h] = i;
     }
@@ -33509,7 +33509,7 @@ static int js_object_list_add(JSContext *ctx, JSObjectList *s, JSObject *obj)
 {
     JSObjectListEntry *e;
     uint32_t h, new_hash_size;
-    
+
     if (js_resize_array(ctx, (void *)&s->object_tab,
                         sizeof(s->object_tab[0]),
                         &s->object_size, s->object_count + 1))
@@ -33522,7 +33522,7 @@ static int js_object_list_add(JSContext *ctx, JSObjectList *s, JSObject *obj)
             return -1;
     }
     e = &s->object_tab[s->object_count++];
-    h = js_object_list_get_hash(obj, s->hash_size); 
+    h = js_object_list_get_hash(obj, s->hash_size);
     e->obj = obj;
     e->hash_next = s->hash_table[h];
     s->hash_table[h] = s->object_count - 1;
@@ -33538,7 +33538,7 @@ static int js_object_list_find(JSContext *ctx, JSObjectList *s, JSObject *obj)
     /* must test empty size because there is no hash table */
     if (s->object_count == 0)
         return -1;
-    h = js_object_list_get_hash(obj, s->hash_size); 
+    h = js_object_list_get_hash(obj, s->hash_size);
     p = s->hash_table[h];
     while (p != -1) {
         e = &s->object_tab[p];
@@ -33942,7 +33942,7 @@ static int JS_WriteBigNum(BCWriterState *s, JSValueConst obj)
             int bpos, d;
             uint8_t v8;
             size_t i0;
-            
+
             /* little endian BCD */
             i = 0;
             while (i < a->len && a->tab[i] == 0)
@@ -33962,7 +33962,7 @@ static int JS_WriteBigNum(BCWriterState *s, JSValueConst obj)
                 return -1;
             }
             bc_put_leb128(s, len);
-            
+
             bpos = 0;
             v8 = 0;
             i0 = i;
@@ -34000,7 +34000,7 @@ static int JS_WriteFunctionTag(BCWriterState *s, JSValueConst obj)
     JSFunctionBytecode *b = JS_VALUE_GET_PTR(obj);
     uint32_t flags;
     int idx, i;
-    
+
     bc_put_u8(s, BC_TAG_FUNCTION_BYTECODE);
     flags = idx = 0;
     bc_set_flags(&flags, &idx, b->has_prototype, 1);
@@ -34018,7 +34018,7 @@ static int JS_WriteFunctionTag(BCWriterState *s, JSValueConst obj)
     bc_put_u16(s, flags);
     bc_put_u8(s, b->js_mode);
     bc_put_atom(s, b->func_name);
-    
+
     bc_put_leb128(s, b->arg_count);
     bc_put_leb128(s, b->var_count);
     bc_put_leb128(s, b->defined_arg_count);
@@ -34045,7 +34045,7 @@ static int JS_WriteFunctionTag(BCWriterState *s, JSValueConst obj)
     } else {
         bc_put_leb128(s, 0);
     }
-    
+
     for(i = 0; i < b->closure_var_count; i++) {
         JSClosureVar *cv = &b->closure_var[i];
         bc_put_atom(s, cv->var_name);
@@ -34059,17 +34059,17 @@ static int JS_WriteFunctionTag(BCWriterState *s, JSValueConst obj)
         assert(idx <= 8);
         bc_put_u8(s, flags);
     }
-    
+
     if (JS_WriteFunctionBytecode(s, b->byte_code_buf, b->byte_code_len))
         goto fail;
-    
+
     if (b->has_debug) {
         bc_put_atom(s, b->debug.filename);
         bc_put_leb128(s, b->debug.line_num);
         bc_put_leb128(s, b->debug.pc2line_len);
         dbuf_put(&s->dbuf, b->debug.pc2line_buf, b->debug.pc2line_len);
     }
-    
+
     for(i = 0; i < b->cpool_count; i++) {
         if (JS_WriteObjectRec(s, b->cpool[i]))
             goto fail;
@@ -34083,16 +34083,16 @@ static int JS_WriteModule(BCWriterState *s, JSValueConst obj)
 {
     JSModuleDef *m = JS_VALUE_GET_PTR(obj);
     int i;
-    
+
     bc_put_u8(s, BC_TAG_MODULE);
     bc_put_atom(s, m->module_name);
-    
+
     bc_put_leb128(s, m->req_module_entries_count);
     for(i = 0; i < m->req_module_entries_count; i++) {
         JSReqModuleEntry *rme = &m->req_module_entries[i];
         bc_put_atom(s, rme->module_name);
     }
-    
+
     bc_put_leb128(s, m->export_entries_count);
     for(i = 0; i < m->export_entries_count; i++) {
         JSExportEntry *me = &m->export_entries[i];
@@ -34105,13 +34105,13 @@ static int JS_WriteModule(BCWriterState *s, JSValueConst obj)
         }
         bc_put_atom(s, me->export_name);
     }
-    
+
     bc_put_leb128(s, m->star_export_entries_count);
     for(i = 0; i < m->star_export_entries_count; i++) {
         JSStarExportEntry *se = &m->star_export_entries[i];
         bc_put_leb128(s, se->req_module_idx);
     }
-    
+
     bc_put_leb128(s, m->import_entries_count);
     for(i = 0; i < m->import_entries_count; i++) {
         JSImportEntry *mi = &m->import_entries[i];
@@ -34119,7 +34119,7 @@ static int JS_WriteModule(BCWriterState *s, JSValueConst obj)
         bc_put_atom(s, mi->import_name);
         bc_put_leb128(s, mi->req_module_idx);
     }
-    
+
     if (JS_WriteObjectRec(s, m->func_obj))
         goto fail;
     return 0;
@@ -34134,7 +34134,7 @@ static int JS_WriteArray(BCWriterState *s, JSValueConst obj)
     JSValue val;
     int ret;
     BOOL is_template;
-    
+
     if (s->allow_bytecode && !p->extensible) {
         /* not extensible array: we consider it is a
            template when we are saving bytecode */
@@ -34308,7 +34308,7 @@ static int JS_WriteObjectRec(BCWriterState *s, JSValueConst obj)
         {
             JSObject *p = JS_VALUE_GET_OBJ(obj);
             int ret, idx;
-            
+
             if (s->allow_reference) {
                 idx = js_object_list_find(s->ctx, &s->object_list, p);
                 if (idx >= 0) {
@@ -34449,7 +34449,7 @@ uint8_t *JS_WriteObject2(JSContext *ctx, size_t *psize, JSValueConst obj,
         s->first_atom = 1;
     js_dbuf_init(ctx, &s->dbuf);
     js_object_list_init(&s->object_list);
-    
+
     if (JS_WriteObjectRec(s, obj))
         goto fail;
     if (JS_WriteObjectAtoms(s))
@@ -34497,7 +34497,7 @@ typedef struct BCReaderState {
     JSObject **objects;
     int objects_count;
     int objects_size;
-    
+
 #ifdef DUMP_READ_OBJECT
     const uint8_t *ptr_last;
     int level;
@@ -34782,7 +34782,7 @@ static JSValue JS_ReadBigNum(BCReaderState *s, int tag)
     limb_t v;
     bf_t *a;
     int bpos, d;
-    
+
     p = js_new_bf(s->ctx);
     if (!p)
         goto fail;
@@ -34994,11 +34994,11 @@ static JSValue JS_ReadFunctionTag(BCReaderState *s)
     b = js_mallocz(ctx, function_size);
     if (!b)
         return JS_EXCEPTION;
-            
+
     memcpy(b, &bc, offsetof(JSFunctionBytecode, debug));
     b->header.ref_count = 1;
     add_gc_object(ctx->rt, &b->header, JS_GC_OBJ_TYPE_FUNCTION_BYTECODE);
-            
+
     obj = JS_MKPTR(JS_TAG_FUNCTION_BYTECODE, b);
 
 #ifdef DUMP_READ_OBJECT
@@ -35115,7 +35115,7 @@ static JSValue JS_ReadModule(BCReaderState *s)
     JSAtom module_name;
     int i;
     uint8_t v8;
-    
+
     if (bc_get_atom(s, &module_name))
         goto fail;
 #ifdef DUMP_READ_OBJECT
@@ -35216,7 +35216,7 @@ static JSValue JS_ReadObjectTag(BCReaderState *s)
     JSAtom atom;
     JSValue val;
     int ret;
-    
+
     obj = JS_NewObject(ctx);
     if (BC_add_object_ref(s, obj))
         goto fail;
@@ -35296,7 +35296,7 @@ static JSValue JS_ReadTypedArray(BCReaderState *s)
     uint8_t array_tag;
     JSValueConst args[3];
     uint32_t offset, len, idx;
-    
+
     if (bc_get_u8(s, &array_tag))
         return JS_EXCEPTION;
     if (array_tag >= JS_TYPED_ARRAY_COUNT)
@@ -35341,7 +35341,7 @@ static JSValue JS_ReadArrayBuffer(BCReaderState *s)
     JSContext *ctx = s->ctx;
     uint32_t byte_length;
     JSValue obj;
-    
+
     if (bc_get_leb128(s, &byte_length))
         return JS_EXCEPTION;
     if (unlikely(s->buf_end - s->ptr < byte_length)) {
@@ -35367,7 +35367,7 @@ static JSValue JS_ReadSharedArrayBuffer(BCReaderState *s)
     uint8_t *data_ptr;
     JSValue obj;
     uint64_t u64;
-    
+
     if (bc_get_leb128(s, &byte_length))
         return JS_EXCEPTION;
     if (bc_get_u64(s, &u64))
@@ -35874,7 +35874,7 @@ static void JS_SetConstructor2(JSContext *ctx,
     set_cycle_flag(ctx, proto);
 }
 
-void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj, 
+void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj,
                        JSValueConst proto)
 {
     JS_SetConstructor2(ctx, func_obj, proto,
@@ -36691,7 +36691,7 @@ static JSValue js_object_seal(JSContext *ctx, JSValueConst this_val,
     if (!res) {
         return JS_ThrowTypeError(ctx, "proxy preventExtensions handler returned false");
     }
-    
+
     p = JS_VALUE_GET_OBJ(obj);
     flags = JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK;
     if (JS_GetOwnPropertyNamesInternal(ctx, &props, &len, p, flags))
@@ -36732,7 +36732,7 @@ static JSValue js_object_isSealed(JSContext *ctx, JSValueConst this_val,
     JSPropertyEnum *props;
     uint32_t len, i;
     int flags, res;
-    
+
     if (!JS_IsObject(obj))
         return JS_TRUE;
 
@@ -36761,7 +36761,7 @@ static JSValue js_object_isSealed(JSContext *ctx, JSValueConst this_val,
     if (res < 0)
         return JS_EXCEPTION;
     res ^= 1;
-done:        
+done:
     js_free_prop_enum(ctx, props, len);
     return JS_NewBool(ctx, res);
 
@@ -36784,14 +36784,14 @@ static JSValue js_object_fromEntries(JSContext *ctx, JSValueConst this_val,
     obj = JS_NewObject(ctx);
     if (JS_IsException(obj))
         return obj;
-    
+
     iter = JS_GetIterator(ctx, iterable, FALSE);
     if (JS_IsException(iter))
         goto fail;
     next_method = JS_GetProperty(ctx, iter, JS_ATOM_next);
     if (JS_IsException(next_method))
         goto fail;
-    
+
     for(;;) {
         JSValue key, value, item;
         item = JS_IteratorNext(ctx, iter, next_method, 0, NULL, &done);
@@ -36801,7 +36801,7 @@ static JSValue js_object_fromEntries(JSContext *ctx, JSValueConst this_val,
             JS_FreeValue(ctx, item);
             break;
         }
-        
+
         key = JS_UNDEFINED;
         value = JS_UNDEFINED;
         if (!JS_IsObject(item)) {
@@ -37185,7 +37185,7 @@ static JSValue js_function_constructor(JSContext *ctx, JSValueConst new_target,
 
     string_buffer_init(ctx, b, 0);
     string_buffer_putc8(b, '(');
-    
+
     if (func_kind == JS_FUNC_ASYNC || func_kind == JS_FUNC_ASYNC_GENERATOR) {
         string_buffer_puts8(b, "async ");
     }
@@ -37512,7 +37512,7 @@ static JSValue iterator_to_array(JSContext *ctx, JSValueConst items)
     JSValue v, r = JS_UNDEFINED;
     int64_t k;
     BOOL done;
-    
+
     iter = JS_GetIterator(ctx, items, FALSE);
     if (JS_IsException(iter))
         goto exception;
@@ -37558,7 +37558,7 @@ static JSValue js_error_constructor(JSContext *ctx, JSValueConst new_target,
     if (!JS_IsObject(proto)) {
         JSContext *realm;
         JSValueConst proto1;
-        
+
         JS_FreeValue(ctx, proto);
         realm = JS_GetFunctionRealm(ctx, new_target);
         if (!realm)
@@ -37646,7 +37646,7 @@ static JSValue js_aggregate_error_constructor(JSContext *ctx,
                                               JSValueConst errors)
 {
     JSValue obj;
-    
+
     obj = JS_NewObjectProtoClass(ctx,
                                  ctx->native_error_proto[JS_AGGREGATE_ERROR],
                                  JS_CLASS_ERROR);
@@ -37885,7 +37885,7 @@ static JSValue JS_ArraySpeciesCreate(JSContext *ctx, JSValueConst obj,
     JSValue ctor, ret, species;
     int res;
     JSContext *realm;
-    
+
     res = JS_IsArray(ctx, obj);
     if (res < 0)
         return JS_EXCEPTION;
@@ -38050,7 +38050,7 @@ static JSValue js_array_every(JSContext *ctx, JSValueConst this_val,
     this_arg = JS_UNDEFINED;
     if (argc > 1)
         this_arg = argv[1];
-        
+
     if (check_function(ctx, func))
         goto exception;
 
@@ -39763,7 +39763,7 @@ static int js_string_define_own_property(JSContext *ctx,
     uint32_t idx;
     JSObject *p;
     JSString *p1, *p2;
-    
+
     if (__JS_AtomIsTaggedInt(prop)) {
         idx = __JS_AtomToUInt32(prop);
         p = JS_VALUE_GET_OBJ(this_obj);
@@ -39930,7 +39930,7 @@ static JSValue js_string_raw(JSContext *ctx, JSValueConst this_val,
         goto exception;
     if (js_get_length64(ctx, &n, raw) < 0)
         goto exception;
-        
+
     for (i = 0; i < n; i++) {
         val = JS_ToStringFree(ctx, JS_GetPropertyInt64(ctx, raw, i));
         if (JS_IsException(val))
@@ -40283,7 +40283,7 @@ static int check_regexp_g_flag(JSContext *ctx, JSValueConst regexp)
 {
     int ret;
     JSValue flags;
-    
+
     ret = js_is_regexp(ctx, regexp);
     if (ret < 0)
         return -1;
@@ -40555,7 +40555,7 @@ static JSValue js_string_replace(JSContext *ctx, JSValueConst this_val,
         }
         if (JS_IsException(repl_str))
             goto exception;
-        
+
         string_buffer_concat(b, sp, endOfLastMatch, pos);
         string_buffer_concat_value_free(b, repl_str);
         endOfLastMatch = pos + searchp->len;
@@ -41233,7 +41233,7 @@ static JSValue js_string_CreateHTML(JSContext *ctx, JSValueConst this_val,
     static struct { const char *tag, *attr; } const defs[] = {
         { "a", "name" }, { "big", NULL }, { "blink", NULL }, { "b", NULL },
         { "tt", NULL }, { "font", "color" }, { "font", "size" }, { "i", NULL },
-        { "a", "href" }, { "small", NULL }, { "strike", NULL }, 
+        { "a", "href" }, { "small", NULL }, { "strike", NULL },
         { "sub", NULL }, { "sup", NULL },
     };
 
@@ -42033,7 +42033,7 @@ static JSValue js_regexp_get_source(JSContext *ctx, JSValueConst this_val)
     if (p->len == 0) {
     empty_regex:
         return JS_NewString(ctx, "(?:)");
-    }    
+    }
     string_buffer_init2(ctx, b, p->len, p->is_wide_char);
 
     /* Escape '/' and newline sequences as needed */
@@ -42092,7 +42092,7 @@ static JSValue js_regexp_get_flag(JSContext *ctx, JSValueConst this_val, int mas
         else
             return JS_ThrowTypeErrorInvalidClass(ctx, JS_CLASS_REGEXP);
     }
-    
+
     flags = lre_get_flags(re->bytecode->u.str8);
     return JS_NewBool(ctx, (flags & mask) != 0);
 }
@@ -42619,7 +42619,7 @@ static JSValue js_regexp_Symbol_matchAll(JSContext *ctx, JSValueConst this_val,
     JSString *strp;
     int64_t lastIndex;
     JSRegExpStringIteratorData *it;
-    
+
     if (!JS_IsObject(R))
         return JS_ThrowTypeErrorNotAnObject(ctx);
 
@@ -42627,7 +42627,7 @@ static JSValue js_regexp_Symbol_matchAll(JSContext *ctx, JSValueConst this_val,
     flags = JS_UNDEFINED;
     matcher = JS_UNDEFINED;
     iter = JS_UNDEFINED;
-    
+
     S = JS_ToString(ctx, argv[0]);
     if (JS_IsException(S))
         goto exception;
@@ -42648,7 +42648,7 @@ static JSValue js_regexp_Symbol_matchAll(JSContext *ctx, JSValueConst this_val,
     if (JS_SetProperty(ctx, matcher, JS_ATOM_lastIndex,
                        JS_NewInt64(ctx, lastIndex)) < 0)
         goto exception;
-    
+
     iter = JS_NewObjectClass(ctx, JS_CLASS_REGEXP_STRING_ITERATOR);
     if (JS_IsException(iter))
         goto exception;
@@ -42786,7 +42786,7 @@ static JSValue js_regexp_Symbol_replace(JSContext *ctx, JSValueConst this_val,
     str = JS_ToString(ctx, argv[0]);
     if (JS_IsException(str))
         goto exception;
-        
+
     sp = JS_VALUE_GET_STRING(str);
     rp = NULL;
     functionalReplace = JS_IsFunction(ctx, rep);
@@ -43061,7 +43061,7 @@ static JSValue js_regexp_Symbol_split(JSContext *ctx, JSValueConst this_val,
     while (q < size) {
         if (JS_SetProperty(ctx, splitter, JS_ATOM_lastIndex, JS_NewInt32(ctx, q)) < 0)
             goto exception;
-        JS_FreeValue(ctx, z);    
+        JS_FreeValue(ctx, z);
         z = JS_RegExpExec(ctx, splitter, str);
         if (JS_IsException(z))
             goto exception;
@@ -43115,7 +43115,7 @@ static JSValue js_regexp_Symbol_split(JSContext *ctx, JSValueConst this_val,
     JS_FreeValue(ctx, ctor);
     JS_FreeValue(ctx, splitter);
     JS_FreeValue(ctx, flags);
-    JS_FreeValue(ctx, z);    
+    JS_FreeValue(ctx, z);
     return A;
 }
 
@@ -43200,7 +43200,7 @@ static JSValue json_parse_value(JSParseState *s)
         {
             JSValue prop_val;
             JSAtom prop_name;
-            
+
             if (json_next_token(s))
                 goto fail;
             val = JS_NewObject(ctx);
@@ -43343,7 +43343,7 @@ JSValue JS_ParseJSON2(JSContext *ctx, const char *buf, size_t buf_len,
 JSValue JS_ParseJSON(JSContext *ctx, const char *buf, size_t buf_len,
                      const char *filename)
 {
-    return JS_ParseJSON2(ctx, buf, buf_len, filename, 0); 
+    return JS_ParseJSON2(ctx, buf, buf_len, filename, 0);
 }
 
 static JSValue internalize_json_property(JSContext *ctx, JSValueConst holder,
@@ -43536,7 +43536,7 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
     int64_t i, len;
     int cl, ret;
     BOOL has_content;
-    
+
     indent1 = JS_UNDEFINED;
     sep = JS_UNDEFINED;
     sep1 = JS_UNDEFINED;
@@ -43711,7 +43711,7 @@ static int js_json_to_str(JSContext *ctx, JSONStringifyContext *jsc,
         JS_FreeValue(ctx, val);
         return 0;
     }
-    
+
 exception:
     JS_FreeValue(ctx, val);
     JS_FreeValue(ctx, tab);
@@ -43829,7 +43829,7 @@ JSValue JS_JSONStringify(JSContext *ctx, JSValueConst obj,
                                JS_DupValue(ctx, obj), JS_PROP_C_W_E) < 0)
         goto exception;
     val = JS_DupValue(ctx, obj);
-                           
+
     val = js_json_check(ctx, jsc, wrapper, val, jsc->empty);
     if (JS_IsException(val))
         goto exception;
@@ -44085,7 +44085,7 @@ static JSProxyData *get_proxy_method(JSContext *ctx, JSValue *pmethod,
         JS_ThrowStackOverflow(ctx);
         return NULL;
     }
-    
+
     /* 's' should never be NULL */
     if (s->is_revoked) {
         JS_ThrowTypeErrorRevokedProxy(ctx);
@@ -44484,7 +44484,7 @@ static int js_proxy_get_own_property(JSContext *ctx, JSPropertyDescriptor *pdesc
         JS_FreeValue(ctx, trap_result_obj);
         if (res < 0)
             return -1;
-        
+
         if (target_desc_ret) {
             /* convert result_desc.flags to defineProperty flags */
             flags1 = result_desc.flags | JS_PROP_HAS_CONFIGURABLE | JS_PROP_HAS_ENUMERABLE;
@@ -44849,7 +44849,7 @@ static JSValue js_proxy_call(JSContext *ctx, JSValueConst func_obj,
 
     if (flags & JS_CALL_FLAG_CONSTRUCTOR)
         return js_proxy_call_constructor(ctx, func_obj, this_obj, argc, argv);
-    
+
     s = get_proxy_method(ctx, &method, func_obj, JS_ATOM_apply);
     if (!s)
         return JS_EXCEPTION;
@@ -45434,7 +45434,7 @@ static void reset_weak_ref(JSRuntime *rt, JSObject *p)
 {
     JSMapRecord *mr, *mr_next;
     JSMapState *s;
-    
+
     /* first pass to remove the records from the WeakMap/WeakSet
        lists */
     for(mr = p->first_weak_ref; mr != NULL; mr = mr->next_weak_ref) {
@@ -45444,7 +45444,7 @@ static void reset_weak_ref(JSRuntime *rt, JSObject *p)
         list_del(&mr->hash_link);
         list_del(&mr->link);
     }
-    
+
     /* second pass to free the values to avoid modifying the weak
        reference list while traversing it. */
     for(mr = p->first_weak_ref; mr != NULL; mr = mr_next) {
@@ -46443,7 +46443,7 @@ static JSValue js_promise_all_resolve_element(JSContext *ctx,
     JSValueConst resolve_element_env = func_data[4];
     JSValue ret, obj;
     int is_zero, index;
-    
+
     if (JS_ToInt32(ctx, &index, func_data[1]))
         return JS_EXCEPTION;
     if (alreadyCalled)
@@ -46452,7 +46452,7 @@ static JSValue js_promise_all_resolve_element(JSContext *ctx,
 
     if (resolve_type == PROMISE_MAGIC_allSettled) {
         JSValue str;
-        
+
         obj = JS_NewObject(ctx);
         if (JS_IsException(obj))
             return JS_EXCEPTION;
@@ -46477,7 +46477,7 @@ static JSValue js_promise_all_resolve_element(JSContext *ctx,
     if (JS_DefinePropertyValueUint32(ctx, values, index,
                                      obj, JS_PROP_C_W_E) < 0)
         return JS_EXCEPTION;
-    
+
     is_zero = remainingElementsCount_add(ctx, resolve_element_env, -1);
     if (is_zero < 0)
         return JS_EXCEPTION;
@@ -46510,7 +46510,7 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
     JSValueConst then_args[2], resolve_element_data[5];
     BOOL done;
     int index, is_zero, is_promise_any = (magic == PROMISE_MAGIC_any);
-    
+
     if (!JS_IsObject(this_val))
         return JS_ThrowTypeErrorNotAnObject(ctx);
     result_promise = js_new_promise_capability(ctx, resolving_funcs, this_val);
@@ -46546,7 +46546,7 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
                                          JS_NewInt32(ctx, 1),
                                          JS_PROP_CONFIGURABLE | JS_PROP_ENUMERABLE | JS_PROP_WRITABLE) < 0)
             goto fail_reject;
-        
+
         index = 0;
         for(;;) {
             /* XXX: conformance: should close the iterator if error on 'done'
@@ -46556,7 +46556,7 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
                 goto fail_reject;
             if (done)
                 break;
-            next_promise = JS_Call(ctx, promise_resolve, 
+            next_promise = JS_Call(ctx, promise_resolve,
                                    this_val, 1, (JSValueConst *)&item);
             JS_FreeValue(ctx, item);
             if (JS_IsException(next_promise)) {
@@ -46576,7 +46576,7 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
                 JS_FreeValue(ctx, next_promise);
                 goto fail_reject1;
             }
-            
+
             if (magic == PROMISE_MAGIC_allSettled) {
                 reject_element =
                     JS_NewCFunctionData(ctx, js_promise_all_resolve_element, 1,
@@ -48071,13 +48071,13 @@ static JSValue js_Date_parse(JSContext *ctx, JSValueConst this_val,
     int p, i, c, sgn;
     JSString *sp;
     BOOL is_local;
-    
+
     rv = JS_NAN;
 
     s = JS_ToString(ctx, argv[0]);
     if (JS_IsException(s))
         return JS_EXCEPTION;
-    
+
     sp = JS_VALUE_GET_STRING(s);
     p = 0;
     if (p < sp->len && (((c = string_get(sp, p)) >= '0' && c <= '9') || c == '+' || c == '-')) {
@@ -48405,7 +48405,7 @@ static void js_operator_set_finalizer(JSRuntime *rt, JSValue val)
     JSOperatorSetData *opset = JS_GetOpaque(val, JS_CLASS_OPERATOR_SET);
     int i, j;
     JSBinaryOperatorDefEntry *ent;
-    
+
     if (opset) {
         for(i = 0; i < JS_OVOP_COUNT; i++) {
             if (opset->self_ops[i])
@@ -48437,7 +48437,7 @@ static void js_operator_set_mark(JSRuntime *rt, JSValueConst val,
     JSOperatorSetData *opset = JS_GetOpaque(val, JS_CLASS_OPERATOR_SET);
     int i, j;
     JSBinaryOperatorDefEntry *ent;
-    
+
     if (opset) {
         for(i = 0; i < JS_OVOP_COUNT; i++) {
             if (opset->self_ops[i])
@@ -48537,7 +48537,7 @@ static JSValue js_operators_create_internal(JSContext *ctx,
         }
         op_count = opset1->operator_counter;
         JS_FreeValue(ctx, prop);
-        
+
         /* we assume there are few entries */
         new_tab = js_realloc(ctx, def->tab,
                              (def->count + 1) * sizeof(def->tab[0]));
@@ -48548,7 +48548,7 @@ static JSValue js_operators_create_internal(JSContext *ctx,
         ent = def->tab + def->count - 1;
         memset(ent, 0, sizeof(def->tab[0]));
         ent->operator_index = op_count;
-        
+
         for(i = 0; i < JS_OVOP_BINARY_COUNT; i++) {
             prop = JS_GetPropertyStr(ctx, arg,
                                      js_overloadable_operator_names[i]);
@@ -48585,7 +48585,7 @@ static JSValue js_operators_updateBigIntOperators(JSContext *ctx, JSValueConst t
     const JSOverloadableOperatorEnum ops[2] = { JS_OVOP_DIV, JS_OVOP_POW };
     JSOverloadableOperatorEnum op;
     int i;
-    
+
     opset_obj = JS_GetProperty(ctx, ctx->class_proto[JS_CLASS_BIG_INT],
                                JS_ATOM_Symbol_operatorSet);
     if (JS_IsException(opset_obj))
@@ -48715,7 +48715,7 @@ static JSValue JS_ToBigIntCtorFree(JSContext *ctx, JSValue val)
     case JS_TAG_BIG_FLOAT:
         {
             bf_t *a, a_s;
-            
+
             a = JS_ToBigFloat(ctx, &a_s, val);
             if (!bf_is_finite(a)) {
                 JS_FreeValue(ctx, val);
@@ -48828,7 +48828,7 @@ static JSValue js_bigint_div(JSContext *ctx,
     bf_t a_s, b_s, *a, *b, *r, *q;
     int status;
     JSValue q_val, r_val;
-    
+
     q_val = JS_NewBigInt(ctx);
     if (JS_IsException(q_val))
         return JS_EXCEPTION;
@@ -48879,7 +48879,7 @@ static JSValue js_bigint_sqrt(JSContext *ctx,
     bf_t a_s, *a, *r, *rem;
     int status;
     JSValue r_val, rem_val;
-    
+
     r_val = JS_NewBigInt(ctx);
     if (JS_IsException(r_val))
         return JS_EXCEPTION;
@@ -48957,7 +48957,7 @@ static JSValue js_bigint_asUintN(JSContext *ctx,
     uint64_t bits;
     bf_t a_s, *a = &a_s, *r, mask_s, *mask = &mask_s;
     JSValue res;
-    
+
     if (JS_ToIndex(ctx, &bits, argv[0]))
         return JS_EXCEPTION;
     res = JS_NewBigInt(ctx);
@@ -49024,7 +49024,7 @@ void JS_AddIntrinsicBigInt(JSContext *ctx)
     rt->bigint_ops.unary_arith = js_unary_arith_bigint;
     rt->bigint_ops.binary_arith = js_binary_arith_bigint;
     rt->bigint_ops.compare = js_compare_bigfloat;
-    
+
     ctx->class_proto[JS_CLASS_BIG_INT] = JS_NewObject(ctx);
     JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_INT],
                                js_bigint_proto_funcs,
@@ -49448,7 +49448,7 @@ static JSValue js_bigfloat_isFinite(JSContext *ctx, JSValueConst this_val,
 {
     JSValueConst val = argv[0];
     JSBigFloat *p;
-    
+
     if (JS_VALUE_GET_NORM_TAG(val) != JS_TAG_BIG_FLOAT)
         return JS_FALSE;
     p = JS_VALUE_GET_PTR(val);
@@ -49460,7 +49460,7 @@ static JSValue js_bigfloat_isNaN(JSContext *ctx, JSValueConst this_val,
 {
     JSValueConst val = argv[0];
     JSBigFloat *p;
-    
+
     if (JS_VALUE_GET_NORM_TAG(val) != JS_TAG_BIG_FLOAT)
         return JS_FALSE;
     p = JS_VALUE_GET_PTR(val);
@@ -49915,7 +49915,7 @@ void JS_AddIntrinsicBigFloat(JSContext *ctx)
     JSRuntime *rt = ctx->rt;
     JSValue obj1;
     JSValueConst obj2;
-    
+
     rt->bigfloat_ops.to_string = js_bigfloat_to_string;
     rt->bigfloat_ops.from_string = js_string_to_bigfloat;
     rt->bigfloat_ops.unary_arith = js_unary_arith_bigfloat;
@@ -49923,7 +49923,7 @@ void JS_AddIntrinsicBigFloat(JSContext *ctx)
     rt->bigfloat_ops.compare = js_compare_bigfloat;
     rt->bigfloat_ops.mul_pow10_to_float64 = js_mul_pow10_to_float64;
     rt->bigfloat_ops.mul_pow10 = js_mul_pow10;
-    
+
     ctx->class_proto[JS_CLASS_BIG_FLOAT] = JS_NewObject(ctx);
     JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_BIG_FLOAT],
                                js_bigfloat_proto_funcs,
@@ -50098,7 +50098,7 @@ static int js_bigdecimal_get_rnd_mode(JSContext *ctx, JSValueConst obj)
     const char *str;
     size_t size;
     int rnd_mode;
-    
+
     str = JS_ToCStringLen(ctx, &size, obj);
     if (!str)
         return -1;
@@ -50138,7 +50138,7 @@ static int js_bigdecimal_get_env(JSContext *ctx, BigDecimalEnv *fe,
     int64_t val;
     BOOL has_prec;
     int rnd_mode;
-    
+
     if (!JS_IsObject(obj)) {
         JS_ThrowTypeErrorNotAnObject(ctx);
         return -1;
@@ -50151,7 +50151,7 @@ static int js_bigdecimal_get_env(JSContext *ctx, BigDecimalEnv *fe,
     if (rnd_mode < 0)
         return -1;
     fe->flags = rnd_mode;
-    
+
     prop = JS_GetProperty(ctx, obj, JS_ATOM_maximumSignificantDigits);
     if (JS_IsException(prop))
         return -1;
@@ -50206,7 +50206,7 @@ static JSValue js_bigdecimal_fop(JSContext *ctx, JSValueConst this_val,
         op_count = 1;
     else
         op_count = 2;
-    
+
     op1 = JS_ToNumeric(ctx, argv[0]);
     if (JS_IsException(op1))
         return op1;
@@ -51164,7 +51164,7 @@ JSValue JS_GetTypedArrayBuffer(JSContext *ctx, JSValueConst obj,
     }
     return JS_DupValue(ctx, JS_MKPTR(JS_TAG_OBJECT, ta->buffer));
 }
-                               
+
 static JSValue js_typed_array_get_toStringTag(JSContext *ctx,
                                               JSValueConst this_val)
 {
@@ -51584,7 +51584,7 @@ static JSValue js_typed_array_fill(JSContext *ctx, JSValueConst this_val,
 
     if (typed_array_is_detached(ctx, p))
         return JS_ThrowTypeErrorDetachedArrayBuffer(ctx);
-    
+
     shift = typed_array_size_log2(p->class_id);
     switch(shift) {
     case 0:
@@ -51737,7 +51737,7 @@ static JSValue js_typed_array_indexOf(JSContext *ctx, JSValueConst this_val,
 #ifdef CONFIG_BIGNUM
     if (tag == JS_TAG_BIG_INT) {
         JSBigFloat *p1 = JS_VALUE_GET_PTR(argv[0]);
-        
+
         if (p->class_id == JS_CLASS_BIG_INT64_ARRAY) {
             if (bf_get_int64(&v64, &p1->num, 0) != 0)
                 goto done;
@@ -52368,7 +52368,7 @@ static JSValue js_typed_array_sort(JSContext *ctx, JSValueConst this_val,
             uint32_t *array_idx;
             void *array_tmp;
             size_t i, j;
-            
+
             /* XXX: a stable sort would use less memory */
             array_idx = js_malloc(ctx, len * sizeof(array_idx[0]));
             if (!array_idx)
@@ -53182,7 +53182,7 @@ static JSValue js_atomics_op(JSContext *ctx,
    }
 
    switch(op | (size_log2 << 3)) {
-            
+
 #ifdef CONFIG_BIGNUM
 #define OP(op_name, func_name)                          \
     case ATOMICS_OP_ ## op_name | (0 << 3):             \
@@ -53231,7 +53231,7 @@ static JSValue js_atomics_op(JSContext *ctx,
         a = atomic_load((_Atomic(uint64_t) *)ptr);
         break;
 #endif
-        
+
     case ATOMICS_OP_COMPARE_EXCHANGE | (0 << 3):
         {
             uint8_t v1 = v;
@@ -53406,7 +53406,7 @@ static JSValue js_atomics_wait(JSContext *ctx,
             return JS_EXCEPTION;
     } else
 #endif
-    {        
+    {
         if (JS_ToInt32(ctx, &v32, argv[2]))
             return JS_EXCEPTION;
         v = v32;
diff --git a/quickjs/quickjs/quickjs.h b/thirdparty/quickjs/quickjs/quickjs.h
similarity index 99%
rename from quickjs/quickjs/quickjs.h
rename to thirdparty/quickjs/quickjs/quickjs.h
index 2dd9f53d..27dc7f12 100644
--- a/quickjs/quickjs/quickjs.h
+++ b/thirdparty/quickjs/quickjs/quickjs.h
@@ -126,7 +126,7 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
 {
     return 0;
 }
-    
+
 #elif defined(JS_NAN_BOXING)
 
 typedef uint64_t JSValue;
@@ -191,7 +191,7 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
     tag = JS_VALUE_GET_TAG(v);
     return tag == (JS_NAN >> 32);
 }
-    
+
 #else /* !JS_NAN_BOXING */
 
 typedef union JSValueUnion {
@@ -948,7 +948,7 @@ static inline JSValue JS_NewCFunctionMagic(JSContext *ctx, JSCFunctionMagic *fun
 {
     return JS_NewCFunction2(ctx, (JSCFunction *)func, name, length, cproto, magic);
 }
-void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj, 
+void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj,
                        JSValueConst proto);
 
 /* C property definition */
diff --git a/quickjs/quickjs_builtin_binder.cpp b/thirdparty/quickjs/quickjs_builtin_binder.cpp
similarity index 100%
rename from quickjs/quickjs_builtin_binder.cpp
rename to thirdparty/quickjs/quickjs_builtin_binder.cpp
diff --git a/quickjs/quickjs_builtin_binder.h b/thirdparty/quickjs/quickjs_builtin_binder.h
similarity index 100%
rename from quickjs/quickjs_builtin_binder.h
rename to thirdparty/quickjs/quickjs_builtin_binder.h
diff --git a/thirdparty/quickjs/quickjs_callable.cpp b/thirdparty/quickjs/quickjs_callable.cpp
new file mode 100644
index 00000000..c2ed5cc3
--- /dev/null
+++ b/thirdparty/quickjs/quickjs_callable.cpp
@@ -0,0 +1,65 @@
+#include "quickjs_callable.h"
+#include "javascript_language.h"
+#include "quickjs/quickjs.h"
+#include "quickjs_binder.h"
+
+bool QuickJSCallable::compare_equal(const CallableCustom *p_a, const CallableCustom *p_b) {
+	const QuickJSCallable *a = static_cast<const QuickJSCallable *>(p_a);
+	const QuickJSCallable *b = static_cast<const QuickJSCallable *>(p_b);
+	return a->js_function.javascript_object == b->js_function.javascript_object;
+}
+
+bool QuickJSCallable::compare_less(const CallableCustom *p_a, const CallableCustom *p_b) {
+	if (compare_equal(p_a, p_b)) {
+		return false;
+	}
+	return p_a < p_b;
+}
+
+QuickJSCallable::QuickJSCallable(JSContext *ctx, const JSValue &p_value) {
+	ERR_FAIL_COND(!JS_IsFunction(ctx, p_value));
+	JSValue v = JS_DupValue(ctx, p_value);
+	js_function.context = ctx;
+	js_function.javascript_object = JS_VALUE_GET_PTR(v);
+}
+
+QuickJSCallable::QuickJSCallable(const JavaScriptGCHandler &p_function) : JavaScriptCallable(p_function) {
+	JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, p_function.javascript_object);
+	JSContext *ctx = static_cast<JSContext *>(p_function.context);
+	ERR_FAIL_COND(JS_IsFunction(ctx, js_func));
+	JS_DupValue(ctx, js_func);
+}
+
+QuickJSCallable::~QuickJSCallable() {
+	if (js_function.is_valid_javascript_object()) {
+		JSContext *ctx = static_cast<JSContext *>(js_function.context);
+		JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, js_function.javascript_object);
+		JS_FreeValue(ctx, js_func);
+	}
+}
+
+uint32_t QuickJSCallable::hash() const {
+	JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, js_function.javascript_object);
+	return hash_murmur3_one_64((uint64_t)JS_VALUE_GET_PTR(js_func));
+}
+
+String QuickJSCallable::get_as_text() const {
+	QuickJSBinder *binder = QuickJSBinder::get_context_binder(static_cast<JSContext *>(js_function.context));
+	JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, js_function.javascript_object);
+	JSContext *ctx = static_cast<JSContext *>(js_function.context);
+	String text = binder->js_to_string(ctx, js_func);
+	return text;
+}
+
+ObjectID QuickJSCallable::get_object() const {
+	return JavaScriptLanguage::get_singleton()->get_callable_middleman()->get_instance_id();
+}
+
+void QuickJSCallable::call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, Callable::CallError &r_call_error) const {
+	QuickJSBinder *binder = QuickJSBinder::get_context_binder(static_cast<JSContext *>(js_function.context));
+	JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, js_function.javascript_object);
+	JavaScriptGCHandler func;
+	func.javascript_object = JS_VALUE_GET_PTR(js_func);
+	JavaScriptGCHandler caller;
+	r_return_value = binder->call(func, caller, p_arguments, p_argcount, r_call_error);
+}
diff --git a/thirdparty/quickjs/quickjs_callable.h b/thirdparty/quickjs/quickjs_callable.h
new file mode 100644
index 00000000..e82261d3
--- /dev/null
+++ b/thirdparty/quickjs/quickjs_callable.h
@@ -0,0 +1,30 @@
+#ifndef QUICKJS_CALLABLE_H
+#define QUICKJS_CALLABLE_H
+#include "javascript_callable.h"
+#include "quickjs/quickjs.h"
+
+#if !defined(JS_NAN_BOXING)
+///typedef uint64_t JSValue; defined in quickjs.h if defined(JS_NAN_BOXING)
+struct JSValue;
+#endif
+
+class QuickJSCallable : public JavaScriptCallable {
+	static bool compare_equal(const CallableCustom *p_a, const CallableCustom *p_b);
+	static bool compare_less(const CallableCustom *p_a, const CallableCustom *p_b);
+
+public:
+	QuickJSCallable(JSContext *ctx, const JSValue &p_value);
+	QuickJSCallable(const JavaScriptGCHandler &p_function);
+	virtual ~QuickJSCallable();
+
+	virtual uint32_t hash() const override;
+	virtual String get_as_text() const override;
+
+	virtual CompareEqualFunc get_compare_equal_func() const override { return QuickJSCallable::compare_equal; }
+	virtual CompareLessFunc get_compare_less_func() const override { return QuickJSCallable::compare_less; }
+
+	virtual ObjectID get_object() const override;
+	virtual void call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, Callable::CallError &r_call_error) const override;
+};
+
+#endif // QUICKJS_CALLABLE_H
diff --git a/quickjs/quickjs_debugger.cpp b/thirdparty/quickjs/quickjs_debugger.cpp
similarity index 100%
rename from quickjs/quickjs_debugger.cpp
rename to thirdparty/quickjs/quickjs_debugger.cpp
diff --git a/quickjs/quickjs_debugger.h b/thirdparty/quickjs/quickjs_debugger.h
similarity index 100%
rename from quickjs/quickjs_debugger.h
rename to thirdparty/quickjs/quickjs_debugger.h
diff --git a/quickjs/quickjs_worker.cpp b/thirdparty/quickjs/quickjs_worker.cpp
similarity index 100%
rename from quickjs/quickjs_worker.cpp
rename to thirdparty/quickjs/quickjs_worker.cpp
diff --git a/quickjs/quickjs_worker.h b/thirdparty/quickjs/quickjs_worker.h
similarity index 100%
rename from quickjs/quickjs_worker.h
rename to thirdparty/quickjs/quickjs_worker.h
diff --git a/tools/editor_tools.cpp b/tools/editor_tools.cpp
index 1c705fa9..d94169d3 100644
--- a/tools/editor_tools.cpp
+++ b/tools/editor_tools.cpp
@@ -1,3 +1,33 @@
+/**************************************************************************/
+/*  editor_tools.cpp                                                      */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
 #include "editor_tools.h"
 #include "../javascript_language.h"
 #include "core/math/expression.h"
@@ -62,7 +92,6 @@ void JavaScriptPlugin::_on_menu_item_pressed(int item) {
 }
 
 JavaScriptPlugin::JavaScriptPlugin(EditorNode *p_node) {
-
 	PopupMenu *menu = memnew(PopupMenu);
 	add_tool_submenu_item(TTR("JavaScript"), menu);
 	menu->add_item(TTR("Generate TypeScript Declaration File"), ITEM_GEN_DECLARE_FILE);
@@ -318,32 +347,34 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 	String constants = "";
 	HashMap<String, Vector<const DocData::ConstantDoc *>> enumerations;
 	for (const DocData::ConstantDoc &const_doc : class_doc.constants) {
-		if (ignore_members.has(const_doc.name)) continue;
+		if (ignore_members.has(const_doc.name)) {
+			continue;
+		}
 
-		Dictionary dict;
-		dict["description"] = format_doc_text(const_doc.description, "\t\t ");
-		dict["name"] = format_property_name(const_doc.name);
-		dict["value"] = const_doc.value;
+		Dictionary new_dict;
+		new_dict["description"] = format_doc_text(const_doc.description, "\t\t ");
+		new_dict["name"] = format_property_name(const_doc.name);
+		new_dict["value"] = const_doc.value;
 		String type = "number";
 		if (!const_doc.enumeration.is_empty()) {
 			type = const_doc.enumeration + "." + const_doc.name;
 		} else if (const_doc.value.find("(") != -1) {
 			type = const_doc.value.split("(")[0];
 		} else if (const_doc.value.is_valid_int()) {
-			type = dict["value"];
+			type = new_dict["value"];
 		}
-		dict["type"] = type;
+		new_dict["type"] = type;
 
-		String const_str = "\n"
-						   "\t\t/** ${description} */\n"
-						   "${TS_IGNORE}"
-						   "\t\tconst ${name}: ${type};\n";
+		String new_const_str = "\n"
+							   "\t\t/** ${description} */\n"
+							   "${TS_IGNORE}"
+							   "\t\tconst ${name}: ${type};\n";
 		if (ts_ignore_errors.has(class_doc.name) && ts_ignore_errors[class_doc.name].has(const_doc.name)) {
-			const_str = const_str.replace("${TS_IGNORE}", "\t\t" TS_IGNORE);
+			new_const_str = new_const_str.replace("${TS_IGNORE}", "\t\t" TS_IGNORE);
 		} else {
-			const_str = const_str.replace("${TS_IGNORE}", "");
+			new_const_str = new_const_str.replace("${TS_IGNORE}", "");
 		}
-		constants += apply_pattern(const_str, dict);
+		constants += apply_pattern(new_const_str, new_dict);
 
 		if (!const_doc.enumeration.is_empty()) {
 			if (!enumerations.has(const_doc.enumeration)) {
@@ -368,11 +399,11 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 		for (int i = 0; i < enums.size(); i++) {
 			String const_str = "\t\t\t/** ${description} */\n"
 							   "\t\t\t${name} = ${value},\n";
-			Dictionary dict;
-			dict["description"] = format_doc_text(enums[i]->description, "\t\t\t ");
-			dict["name"] = format_property_name(enums[i]->name);
-			dict["value"] = enums[i]->value;
-			enum_str += apply_pattern(const_str, dict);
+			Dictionary new_dict;
+			new_dict["description"] = format_doc_text(enums[i]->description, "\t\t\t ");
+			new_dict["name"] = format_property_name(enums[i]->name);
+			new_dict["value"] = enums[i]->value;
+			enum_str += apply_pattern(const_str, new_dict);
 		}
 		enum_str += "\t\t}\n";
 		enumerations_str += enum_str;
@@ -382,7 +413,8 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 	Vector<DocData::MethodDoc> method_list = class_doc.methods;
 	String properties = "";
 	for (const DocData::PropertyDoc &prop_doc : class_doc.properties) {
-		if (ignore_members.has(prop_doc.name)) continue;
+		if (ignore_members.has(prop_doc.name))
+			continue;
 
 		String prop_str = "\n"
 						  "\t\t/** ${description} */\n"
@@ -394,12 +426,12 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 			prop_str = prop_str.replace("${TS_IGNORE}", "");
 		}
 
-		Dictionary dict;
-		dict["description"] = format_doc_text(prop_doc.description, "\t\t ");
-		dict["name"] = format_property_name(prop_doc.name);
-		dict["type"] = get_type_name(prop_doc.type);
-		dict["static"] = Engine::get_singleton()->has_singleton(class_doc.name) ? "static " : "";
-		properties += apply_pattern(prop_str, dict);
+		Dictionary new_dict;
+		new_dict["description"] = format_doc_text(prop_doc.description, "\t\t ");
+		new_dict["name"] = format_property_name(prop_doc.name);
+		new_dict["type"] = get_type_name(prop_doc.type);
+		new_dict["static"] = Engine::get_singleton()->has_singleton(class_doc.name) ? "static " : "";
+		properties += apply_pattern(prop_str, new_dict);
 
 		if (!prop_doc.getter.is_empty()) {
 			DocData::MethodDoc md;
@@ -426,7 +458,8 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 	String signals = "";
 	for (int i = 0; i < class_doc.signals.size(); ++i) {
 		const DocData::MethodDoc &signal = class_doc.signals[i];
-		if (ignore_members.has(signal.name)) continue;
+		if (ignore_members.has(signal.name))
+			continue;
 
 		String signal_str = "\n"
 							"\t\t/** ${description} */\n"
@@ -437,10 +470,10 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 		} else {
 			signal_str = signal_str.replace("${TS_IGNORE}", "");
 		}
-		Dictionary dict;
-		dict["description"] = format_doc_text(signal.description, "\t\t\t ");
-		dict["name"] = signal.name;
-		signals += apply_pattern(signal_str, dict);
+		Dictionary new_dict;
+		new_dict["description"] = format_doc_text(signal.description, "\t\t\t ");
+		new_dict["name"] = signal.name;
+		signals += apply_pattern(signal_str, new_dict);
 	}
 	dict["signals"] = signals;
 
@@ -448,7 +481,8 @@ String _export_class(const DocData::ClassDoc &class_doc) {
 	String methods = "";
 	for (int i = 0; i < method_list.size(); i++) {
 		const DocData::MethodDoc &method_doc = method_list[i];
-		if (ignore_members.has(method_doc.name)) continue;
+		if (ignore_members.has(method_doc.name))
+			continue;
 
 		if (method_doc.name == class_doc.name) {
 			continue;
@@ -570,18 +604,18 @@ void JavaScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 								   "\tconst ${name}: ${type};\n";
 				for (int i = 0; i < class_doc.constants.size(); i++) {
 					const DocData::ConstantDoc &const_doc = class_doc.constants[i];
-					Dictionary dict;
-					dict["description"] = format_doc_text(const_doc.description, "\t ");
-					dict["name"] = format_property_name(const_doc.name);
-					dict["value"] = const_doc.value;
+					Dictionary new_dict;
+					new_dict["description"] = format_doc_text(const_doc.description, "\t ");
+					new_dict["name"] = format_property_name(const_doc.name);
+					new_dict["value"] = const_doc.value;
 					if (const_doc.name == "NAN" || const_doc.name == "INF") {
-						dict["type"] = "number";
+						new_dict["type"] = "number";
 					} else if (!const_doc.enumeration.is_empty()) {
-						dict["type"] = format_enum_name(const_doc.enumeration) + "." + const_doc.name;
+						new_dict["type"] = format_enum_name(const_doc.enumeration) + "." + const_doc.name;
 					} else {
-						dict["type"] = dict["value"];
+						new_dict["type"] = new_dict["value"];
 					}
-					constants += apply_pattern(const_str, dict);
+					constants += apply_pattern(const_str, new_dict);
 
 					if (!const_doc.enumeration.is_empty()) {
 						if (!enumerations.has(const_doc.enumeration)) {
@@ -595,18 +629,18 @@ void JavaScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 				}
 				class_enumerations.insert(GODOT_OBJECT_NAME, enumerations);
 
-				for (auto E : enumerations) {
-					String enum_str = "\tenum " + format_enum_name(E.key) + " {\n";
-					const Vector<const DocData::ConstantDoc *> &enums = E.value;
+				for (auto F : enumerations) {
+					String enum_str = "\tenum " + format_enum_name(F.key) + " {\n";
+					const Vector<const DocData::ConstantDoc *> &enums = F.value;
 					for (int i = 0; i < enums.size(); i++) {
-						String const_str = "\t\t/** ${description} */\n"
-										   "\t\t${name} = ${value},\n";
-						Dictionary dict;
-						dict["description"] = format_doc_text(enums[i]->description, "\t\t\t ");
-						dict["name"] = format_property_name(enums[i]->name);
-						dict["value"] = enums[i]->value;
-
-						enum_str += apply_pattern(const_str, dict);
+						String new_const_str = "\t\t/** ${description} */\n"
+											   "\t\t${name} = ${value},\n";
+						Dictionary new_dict;
+						new_dict["description"] = format_doc_text(enums[i]->description, "\t\t\t ");
+						new_dict["name"] = format_property_name(enums[i]->name);
+						new_dict["value"] = enums[i]->value;
+
+						enum_str += apply_pattern(new_const_str, new_dict);
 					}
 					enum_str += "\t}\n";
 					enumerations_str += enum_str;
@@ -676,10 +710,10 @@ void JavaScriptPlugin::_export_enumeration_binding_file(const String &p_path) {
 				}
 			}
 			enum_items_text += " }";
-			Dictionary dict;
-			dict["name"] = format_enum_name(E.key);
-			dict["values"] = enum_items_text;
-			class_enums += apply_pattern("\n\t\t${name}: { value: ${values} }", dict);
+			Dictionary new_dict;
+			new_dict["name"] = format_enum_name(E.key);
+			new_dict["values"] = enum_items_text;
+			class_enums += apply_pattern("\n\t\t${name}: { value: ${values} }", new_dict);
 			if (idx < enumeration.size() - 1) {
 				class_enums += ", ";
 			} else {
@@ -688,14 +722,14 @@ void JavaScriptPlugin::_export_enumeration_binding_file(const String &p_path) {
 			idx++;
 		}
 		static String class_template = "\tbind(${class}, {${enumerations}});\n";
-		Dictionary dict;
-		dict["class"] = class_name;
-		dict["enumerations"] = class_enums;
-		enumerations += apply_pattern(class_template, dict);
+		Dictionary class_dict;
+		class_dict["class"] = class_name;
+		class_dict["enumerations"] = class_enums;
+		enumerations += apply_pattern(class_template, class_dict);
 	}
-	Dictionary dict;
-	dict["enumerations"] = enumerations;
-	file_content = apply_pattern(file_content, dict);
+	Dictionary enum_dict;
+	enum_dict["enumerations"] = enumerations;
+	file_content = apply_pattern(file_content, enum_dict);
 
 	dump_to_file(p_path, file_content);
 }
diff --git a/tools/editor_tools.h b/tools/editor_tools.h
index 040005ae..9612f7cb 100644
--- a/tools/editor_tools.h
+++ b/tools/editor_tools.h
@@ -1,5 +1,36 @@
-#ifndef JAVASCRIPT_PLUGIN_H
-#define JAVASCRIPT_PLUGIN_H
+/**************************************************************************/
+/*  editor_tools.h                                                        */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef EDITOR_TOOLS_H
+#define EDITOR_TOOLS_H
+
 #include "editor/editor_file_dialog.h"
 #include "editor/editor_node.h"
 
@@ -35,4 +66,4 @@ class JavaScriptPlugin : public EditorPlugin {
 	JavaScriptPlugin(EditorNode *p_node);
 };
 
-#endif
+#endif // EDITOR_TOOLS_H

From 398a108ff59035c989a9115f16e2fdca64d87520 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 15 Jun 2023 06:08:06 -0700
Subject: [PATCH 17/71] Update generate_builtin_api.py, javascript.cpp,
 javascript.h, and 13 more files

---
 SCsub                                         |   5 +-
 generate_builtin_api.py                       |   2 +
 javascript.cpp                                |   2 +-
 javascript.h                                  |   3 +-
 javascript_instance.h                         |   1 +
 javascript_language.cpp                       |   6 +-
 javascript_language.h                         |   3 +-
 register_types.cpp                            |  25 +-
 .../quickjs/builtin_binding_generator.py      |   3 +-
 thirdparty/quickjs/quickjs_binder.h           | 351 ++++++++++++++++++
 thirdparty/quickjs/quickjs_builtin_binder.cpp | 133 +++----
 thirdparty/quickjs/quickjs_builtin_binder.h   |   6 +-
 thirdparty/quickjs/quickjs_callable.cpp       |   2 +
 thirdparty/quickjs/quickjs_worker.h           |   1 +
 tools/editor_tools.cpp                        |   5 +-
 tools/editor_tools.h                          |   5 +-
 16 files changed, 452 insertions(+), 101 deletions(-)
 create mode 100644 thirdparty/quickjs/quickjs_binder.h

diff --git a/SCsub b/SCsub
index d1cef8ad..fe690f9a 100644
--- a/SCsub
+++ b/SCsub
@@ -30,14 +30,12 @@ def dump_text_file_to_cpp(file):
 
 
 if JS_ENGINE == "quickjs":
-    # generate builtin binding code
     import generate_builtin_api
 
     generate_builtin_api.generate_api_json(os.path.join(GetLaunchDir(), "modules", os.path.basename(os.getcwd())))
     import thirdparty.quickjs.builtin_binding_generator
 
     thirdparty.quickjs.builtin_binding_generator.generate_builtin_bindings()
-    # build quickjs source
     version = open("thirdparty/quickjs/quickjs/VERSION.txt", "r").read().split("\n")[0]
     env_module.Append(CPPDEFINES={"QUICKJS_CONFIG_VERSION": '"' + version + '"'})
     env_module.Append(CPPDEFINES=["CONFIG_BIGNUM"])
@@ -45,8 +43,7 @@ if JS_ENGINE == "quickjs":
         env_module.Append(CPPDEFINES={"DUMP_LEAKS": 1})
         env_module.Append(CPPDEFINES={"QUICKJS_WITH_DEBUGGER": 1})
     env_module.Append(CPPPATH=["thirdparty/quickjs/quickjs"])
-    # env_module.Append(CXXFLAGS=["-std=c++20"])
-    # env_module.Append(CCFLAGS=["-std=c++20"])
+    env_module.Append(CPPPATH=["thirdparty/quickjs"])
     if TOOLS:
         env_module.add_source_files(env.modules_sources, "tools/editor_tools.cpp")
     env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp")
diff --git a/generate_builtin_api.py b/generate_builtin_api.py
index 745226ea..d7da70c2 100755
--- a/generate_builtin_api.py
+++ b/generate_builtin_api.py
@@ -314,6 +314,8 @@ def parse_class(cls):
             continue  # ignored methods
         if class_name == "PackedByteArray" and method_name.startswith("encode_") or method_name.startswith("decode_"):
             continue  # ignore decode/encode methods
+        if class_name == "PackedByteArray" and method_name == "get_string_from_wchar":
+            continue
         return_type = m.find("return").attrib["type"] if m.find("return") != None else "void"
         if return_type in TYPE_MAP:
             return_type = TYPE_MAP[return_type]
diff --git a/javascript.cpp b/javascript.cpp
index e5f5ea4e..9c1c0940 100644
--- a/javascript.cpp
+++ b/javascript.cpp
@@ -349,7 +349,7 @@ void JavaScriptModule::_bind_methods() {
 }
 
 JavaScriptModule::JavaScriptModule() {
-	set_source_code("module.exports = {};" ENDL);
+	set_source_code("module.exports = {};\n");
 }
 
 Ref<Resource> ResourceFormatLoaderJavaScriptModule::load(const String &p_path, const String &p_original_path, Error *r_error, bool p_use_sub_threads, float *r_progress, ResourceFormatLoader::CacheMode p_cache_mode) {
diff --git a/javascript.h b/javascript.h
index 51407c47..6a62530f 100644
--- a/javascript.h
+++ b/javascript.h
@@ -34,9 +34,10 @@
 #include "core/io/resource_loader.h"
 #include "core/io/resource_saver.h"
 #include "core/object/script_language.h"
-#include "javascript_binder.h"
 #include "scene/resources/text_file.h"
 
+#include "javascript_binder.h"
+
 #define EXT_JSCLASS "mjs"
 #define EXT_JSMODULE "js"
 #define EXT_JSON "json"
diff --git a/javascript_instance.h b/javascript_instance.h
index 32320dcd..f013c1df 100644
--- a/javascript_instance.h
+++ b/javascript_instance.h
@@ -32,6 +32,7 @@
 #define JAVASCRIPT_INSTANCE_H
 
 #include "core/object/script_language.h"
+
 #include "core/variant/callable.h"
 #include "javascript.h"
 #include "javascript_binder.h"
diff --git a/javascript_language.cpp b/javascript_language.cpp
index 17dd831f..180844d1 100644
--- a/javascript_language.cpp
+++ b/javascript_language.cpp
@@ -31,7 +31,11 @@
 #include "javascript_language.h"
 #include "core/io/file_access.h"
 #include "core/object/class_db.h"
-JavaScriptLanguage *JavaScriptLanguage::singleton = NULL;
+
+#include "javascript_binder.h"
+#include "quickjs_binder.h"
+
+JavaScriptLanguage *JavaScriptLanguage::singleton = nullptr;
 
 namespace JavaScriptInstanceBindingCallbacks {
 
diff --git a/javascript_language.h b/javascript_language.h
index 2721295a..cc0aa326 100644
--- a/javascript_language.h
+++ b/javascript_language.h
@@ -32,8 +32,9 @@
 #define JAVASCRIPT_LANGUAGE_H
 
 #include "core/object/script_language.h"
+
 #include "javascript.h"
-#include "thirdparty/quickjs/quickjs_binder.h"
+#include "javascript_binder.h"
 
 class CallableMiddleman : public Object {
 	GDCLASS(CallableMiddleman, Object);
diff --git a/register_types.cpp b/register_types.cpp
index 4fa75f15..1ca45654 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -29,6 +29,7 @@
 /**************************************************************************/
 
 #include "register_types.h"
+
 #include "javascript.h"
 #include "javascript_language.h"
 
@@ -45,31 +46,11 @@ class EditorExportJavaScript : public EditorExportPlugin {
 public:
 	virtual void _export_file(const String &p_path, const String &p_type, const HashSet<String> &p_features) override {
 		String script_key;
-		// int script_mode = EditorExportPreset::MODE_SCRIPT_COMPILED;
 		const Ref<EditorExportPreset> &preset = get_export_preset();
-
-		// if (preset.is_valid()) {
-		// 	script_mode = preset->get_file_export_mode(p_path);
-		// }
-
-		// if (script_mode == EditorExportPreset::MODE_SCRIPT_TEXT)
-		// 	return;
-
 		String extension = p_path.get_extension();
-		if (extension != EXT_JSCLASS && extension != EXT_JSMODULE)
+		if (extension != EXT_JSCLASS && extension != EXT_JSMODULE) {
 			return;
-
-// 		if (script_mode == EditorExportPreset::FileExportMode::MODE_SCRIPT_COMPILED) {
-// #if 0 // Disable compile to bytecode as it is not battle tested on all platform
-// 			Error err;
-// 			String code = FileAccess::get_file_as_string(p_path, &err);
-// 			ERR_FAIL_COND(err != OK);
-
-// 			Vector<uint8_t> file;
-// 			ERR_FAIL_COND(JavaScriptLanguage::get_singleton()->get_main_binder()->compile_to_bytecode(code, p_path, file) != OK);
-// 			add_file(p_path.get_basename() + "." + extension + "b", file, true);
-// #endif
-// 		}
+		}
 	}
 	virtual String _get_name() const override { return "JavaScript"; }
 };
diff --git a/thirdparty/quickjs/builtin_binding_generator.py b/thirdparty/quickjs/builtin_binding_generator.py
index 7c94f799..9bbfa90d 100644
--- a/thirdparty/quickjs/builtin_binding_generator.py
+++ b/thirdparty/quickjs/builtin_binding_generator.py
@@ -755,8 +755,9 @@ def generate_class_bind_action(cls, constructor):
 def generate_builtin_bindings():
     Template = """\
 #include "core/variant/variant.h"
-#include "quickjs_binder.h"
+
 #include "quickjs_builtin_binder.h"
+#include "quickjs_worker.h"
 
 #ifndef inf
 #define inf INFINITY
diff --git a/thirdparty/quickjs/quickjs_binder.h b/thirdparty/quickjs/quickjs_binder.h
new file mode 100644
index 00000000..56b39389
--- /dev/null
+++ b/thirdparty/quickjs/quickjs_binder.h
@@ -0,0 +1,351 @@
+#ifndef QUICKJS_BINDING_HELPER_H
+#define QUICKJS_BINDING_HELPER_H
+
+#include "core/io/resource.h"
+#include "core/os/memory.h"
+#include "core/os/thread.h"
+#include "core/variant/callable.h"
+
+#include "../../javascript_binder.h"
+#include "./quickjs/quickjs.h"
+#include "quickjs_builtin_binder.h"
+
+#ifdef QUICKJS_WITH_DEBUGGER
+#include "quickjs_debugger.h"
+#endif
+
+#define JS_HIDDEN_SYMBOL(x) ("\xFF" x)
+#define BINDING_DATA_FROM_JS(ctx, p_val) (JavaScriptGCHandler *)JS_GetOpaque((p_val), QuickJSBinder::get_origin_class_id((ctx)))
+#define GET_JSVALUE(p_gc_handler) JS_MKPTR(JS_TAG_OBJECT, (p_gc_handler).javascript_object)
+#define NO_MODULE_EXPORT_SUPPORT 0
+#define MODULE_HAS_REFCOUNT 0 // The module doesn't seem to follow the reference count rule in quickjs.
+#define MAX_ARGUMENT_COUNT 50
+#define PROP_NAME_CONSOLE_LOG_OBJECT_TO_JSON "LOG_OBJECT_TO_JSON"
+#define ENDL "\r\n"
+
+class QuickJSBinder : public JavaScriptBinder {
+	friend class QuickJSBuiltinBinder;
+	friend class QuickJSWorker;
+	QuickJSBuiltinBinder builtin_binder;
+
+protected:
+	static SafeNumeric<uint32_t> global_context_id;
+	static SafeNumeric<uint64_t> global_transfer_id;
+	JSRuntime *runtime;
+	JSContext *ctx;
+	JSMallocFunctions godot_allocator;
+	uint32_t context_id;
+	Thread::ID thread_id;
+#ifdef QUICKJS_WITH_DEBUGGER
+	Ref<QuickJSDebugger> debugger;
+#endif
+
+public:
+	struct PtrHasher {
+		static _FORCE_INLINE_ uint32_t hash(const void *p_ptr) {
+			union {
+				const void *p;
+				uint64_t i;
+			} u;
+			u.p = p_ptr;
+			return HashMapHasherDefault::hash(u.i);
+		}
+	};
+
+	enum JavaScriptModuleFlags {
+		MODULE_FLAG_SCRIPT = 1,
+		MODULE_FLAG_NATIVE = 2,
+		MODULE_FLAG_EVALUATED = 1 << 3,
+		MODULE_FLAG_RESOURCE = 1 << 4,
+	};
+
+	struct ModuleCache {
+		int flags = 0;
+		JSModuleDef *module = NULL;
+		uint32_t hash = 0;
+		JSValue res_value;
+		Ref<Resource> res;
+	};
+
+	struct CommonJSModule {
+		int flags;
+		JSValue exports;
+		String md5;
+		Ref<Resource> res;
+	};
+
+	enum {
+		PROP_DEF_DEFAULT = JS_PROP_ENUMERABLE | JS_PROP_CONFIGURABLE,
+	};
+
+	enum {
+		__JS_ATOM_NULL = JS_ATOM_NULL,
+#if !defined(EMSCRIPTEN)
+#define CONFIG_ATOMICS
+#endif
+#define DEF(name, str) JS_ATOM_##name,
+#include "quickjs/quickjs-atom.h"
+#undef DEF
+#ifdef CONFIG_ATOMICS
+#undef CONFIG_ATOMICS
+#endif
+		JS_ATOM_END,
+	};
+
+	enum ConsoleLogType {
+		CONSOLE_LOG,
+		CONSOLE_WARN,
+		CONSOLE_ERROR,
+		CONSOLE_TRACE,
+	};
+
+protected:
+	JSAtom js_key_godot_classid;
+	JSAtom js_key_godot_classname;
+	JSAtom js_key_godot_tooled;
+	JSAtom js_key_godot_icon_path;
+	JSAtom js_key_godot_exports;
+	JSAtom js_key_godot_signals;
+
+	JSValue global_object;
+	JSValue godot_object;
+	JSValue console_object;
+	JSValue empty_function;
+	JSValue js_operators;
+	JSValue js_operators_create;
+	Vector<JSValue> godot_singletons;
+
+	_FORCE_INLINE_ static void *js_binder_malloc(JSMallocState *s, size_t size) { return memalloc(size); }
+	_FORCE_INLINE_ static void js_binder_free(JSMallocState *s, void *ptr) {
+		if (ptr)
+			memfree(ptr);
+	}
+	_FORCE_INLINE_ static void *js_binder_realloc(JSMallocState *s, void *ptr, size_t size) { return memrealloc(ptr, size); }
+
+	static String resolve_module_file(const String &file);
+	static JSModuleDef *js_module_loader(JSContext *ctx, const char *module_name, void *opaque);
+	static JSModuleDef *js_make_module(JSContext *ctx, const String &p_id, const JSValueConst &p_value);
+	ModuleCache *js_compile_and_cache_module(JSContext *ctx, const String &p_code, const String &p_filename, JavaScriptError *r_error);
+	ModuleCache *js_compile_and_cache_module(JSContext *ctx, const Vector<uint8_t> &p_bytecode, const String &p_filename, JavaScriptError *r_error);
+	ModuleCache js_compile_module(JSContext *ctx, const String &p_code, const String &p_filename, JavaScriptError *r_error);
+	static Error js_evalute_module(JSContext *ctx, ModuleCache *p_module, JavaScriptError *r_error);
+	static int resource_module_initializer(JSContext *ctx, JSModuleDef *m);
+
+	struct ClassBindData {
+		JSClassID class_id;
+		CharString class_name;
+		JSValue prototype;
+		JSValue constructor;
+		JSClassDef jsclass;
+		const ClassDB::ClassInfo *gdclass;
+		const ClassBindData *base_class;
+	};
+	ClassBindData godot_origin_class;
+	const ClassBindData *godot_object_class;
+	const ClassBindData *godot_reference_class;
+	HashMap<JSClassID, ClassBindData> class_bindings;
+	HashMap<StringName, const ClassBindData *> classname_bindings;
+	HashMap<String, ModuleCache> module_cache;
+	HashMap<String, CommonJSModule> commonjs_module_cache;
+	ClassBindData worker_class_data;
+	List<JavaScriptGCHandler *> workers;
+	Vector<MethodBind *> godot_methods;
+	int internal_godot_method_id;
+	Vector<const ClassDB::PropertySetGet *> godot_object_indexed_properties;
+	int internal_godot_indexed_property_id;
+#if NO_MODULE_EXPORT_SUPPORT
+	String parsing_script_file;
+#endif
+
+	JSClassID register_class(const ClassDB::ClassInfo *p_cls);
+	void add_godot_origin();
+	void add_godot_classes();
+	void add_godot_globals();
+	void add_global_console();
+	void add_global_properties();
+	void add_global_worker();
+
+	static JSValue object_constructor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int class_id);
+	static void initialize_properties(JSContext *ctx, const JavaScriptClassInfo *p_class, JSValue p_object);
+
+	static void object_finalizer(JavaScriptGCHandler *p_bind);
+	static void origin_finalizer(JSRuntime *rt, JSValue val);
+
+	static JSValue object_free(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+	static JSValue object_method(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int method_id);
+	static JSValue object_indexed_property(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int property_id);
+	static JSValue godot_to_string(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+	static JSValue godot_get_type(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+	static JSValue godot_load(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+	static JSValue godot_instance_from_id(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+
+	static JSValue godot_object_method_connect(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+
+	static void add_debug_binding_info(JSContext *ctx, JSValueConst p_obj, const JavaScriptGCHandler *p_bind);
+
+	const JavaScriptClassInfo *register_javascript_class(const JSValueConst &p_constructor, const String &p_path);
+	void free_javascript_class(const JavaScriptClassInfo &p_class);
+	static JSValue godot_register_class(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+	static JSValue godot_register_signal(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+	static JSValue godot_register_property(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+
+	enum {
+		SCRIPT_META_TOOLED,
+		SCRIPT_META_ICON,
+	};
+	static JSValue godot_set_script_meta(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic);
+
+	static JSValue console_functions(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic);
+	static JSValue global_request_animation_frame(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+	static JSValue global_cancel_animation_frame(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+
+	static JSValue worker_constructor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+	static void worker_finializer(JSRuntime *rt, JSValue val);
+	static JSValue worker_post_message(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+	static JSValue worker_terminate(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+	static JSValue godot_abandon_value(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+	static JSValue godot_adopt_value(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
+
+	_FORCE_INLINE_ static JSValue js_empty_func(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { return JS_UNDEFINED; }
+	_FORCE_INLINE_ static JSValue js_empty_consturctor(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) { return JS_NewObject(ctx); }
+	static JSValue godot_builtin_function(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic);
+
+	static int get_js_array_length(JSContext *ctx, JSValue p_val);
+	static void get_own_property_names(JSContext *ctx, JSValue p_object, HashSet<String> *r_list);
+
+	static JSAtom get_atom(JSContext *ctx, const StringName &p_key);
+	static HashMap<uint64_t, Variant> transfer_deopot;
+	static HashMap<String, const char *> class_remap;
+#ifdef TOOLS_ENABLED
+	Dictionary modified_api;
+#endif
+public:
+	static Error define_operators(JSContext *ctx, JSValue p_prototype, JSValue *p_operators, int p_size);
+
+public:
+	static JSValue variant_to_var(JSContext *ctx, const Variant p_var);
+	static Variant var_to_variant(JSContext *ctx, JSValue p_val);
+	static bool validate_type(JSContext *ctx, Variant::Type p_type, JSValueConst &p_val);
+	static void dump_exception(JSContext *ctx, const JSValueConst &p_exception, JavaScriptError *r_error);
+	virtual String error_to_string(const JavaScriptError &p_error) override;
+	virtual Error get_stacks(List<JavaScriptStackInfo> &r_stacks) override;
+	virtual String get_backtrace_message(const List<JavaScriptStackInfo> &stacks) override;
+
+	static Dictionary js_to_dictionary(JSContext *ctx, const JSValueConst &p_val, List<void *> &stack);
+
+	_FORCE_INLINE_ static real_t js_to_number(JSContext *ctx, const JSValueConst &p_val) {
+		double_t v = 0;
+		JS_ToFloat64(ctx, &v, p_val);
+		return real_t(v);
+	}
+	_FORCE_INLINE_ static String js_to_string(JSContext *ctx, const JSValueConst &p_val) {
+		String ret;
+		size_t len = 0;
+		const char *utf8 = JS_ToCStringLen(ctx, &len, p_val);
+		ret.parse_utf8(utf8, len);
+		JS_FreeCString(ctx, utf8);
+		return ret;
+	}
+	_FORCE_INLINE_ static bool js_to_bool(JSContext *ctx, const JSValueConst &p_val) {
+		return JS_ToBool(ctx, p_val);
+	}
+	_FORCE_INLINE_ static int32_t js_to_int(JSContext *ctx, const JSValueConst &p_val) {
+		int32_t i;
+		JS_ToInt32(ctx, &i, p_val);
+		return i;
+	}
+	_FORCE_INLINE_ static uint32_t js_to_uint(JSContext *ctx, const JSValueConst &p_val) {
+		uint32_t u;
+		JS_ToUint32(ctx, &u, p_val);
+		return u;
+	}
+	_FORCE_INLINE_ static int64_t js_to_int64(JSContext *ctx, const JSValueConst &p_val) {
+		int64_t i;
+		JS_ToInt64(ctx, &i, p_val);
+		return i;
+	}
+	_FORCE_INLINE_ static uint64_t js_to_uint64(JSContext *ctx, const JSValueConst &p_val) {
+		uint64_t i;
+		JS_ToIndex(ctx, &i, p_val);
+		return i;
+	}
+	_FORCE_INLINE_ static JSValue to_js_number(JSContext *ctx, real_t p_val) {
+		return JS_NewFloat64(ctx, double(p_val));
+	}
+	_FORCE_INLINE_ static JSValue to_js_string(JSContext *ctx, const String &text) {
+		CharString utf8 = text.utf8();
+		return JS_NewStringLen(ctx, utf8.get_data(), utf8.length());
+	}
+	_FORCE_INLINE_ static JSValue to_js_bool(JSContext *ctx, bool p_val) {
+		return JS_NewBool(ctx, p_val);
+	}
+
+public:
+	QuickJSBinder();
+	virtual ~QuickJSBinder();
+
+	_FORCE_INLINE_ static QuickJSBinder *get_context_binder(JSContext *ctx) {
+		return static_cast<QuickJSBinder *>(JS_GetContextOpaque(ctx));
+	}
+
+	virtual JavaScriptBinder *get_context_binder(void *p_context) override {
+		return QuickJSBinder::get_context_binder((JSContext *)p_context);
+	}
+
+	virtual Thread::ID get_thread_id() const override { return thread_id; }
+
+	_FORCE_INLINE_ static QuickJSBinder *get_runtime_binder(JSRuntime *rt) {
+		return static_cast<QuickJSBinder *>(JS_GetMollocState(rt)->opaque);
+	}
+
+	_FORCE_INLINE_ static JavaScriptGCHandler *new_gc_handler(JSContext *ctx) {
+		JavaScriptGCHandler *h = memnew(JavaScriptGCHandler);
+		h->context = ctx;
+		return h;
+	}
+
+	_FORCE_INLINE_ QuickJSBuiltinBinder &get_builtin_binder() { return builtin_binder; }
+
+	_FORCE_INLINE_ JSClassID get_origin_class_id() { return godot_origin_class.class_id; }
+	_FORCE_INLINE_ const ClassBindData get_origin_class() const { return godot_origin_class; }
+	_FORCE_INLINE_ static JSClassID get_origin_class_id(JSContext *ctx) { return get_context_binder(ctx)->godot_origin_class.class_id; }
+
+	virtual void initialize() override;
+	virtual void uninitialize() override;
+	virtual void language_finalize() override;
+	virtual void frame() override;
+
+	virtual JavaScriptGCHandler *alloc_object_binding_data(Object *p_object) override;
+	virtual void free_object_binding_data(JavaScriptGCHandler *p_gc_handle) override;
+	virtual void godot_refcount_incremented(JavaScriptGCHandler *p_gc_handle) override;
+	virtual bool godot_refcount_decremented(JavaScriptGCHandler *p_gc_handle) override;
+
+	static Error bind_gc_object(JSContext *ctx, JavaScriptGCHandler *data, Object *p_object);
+
+	virtual Error eval_string(const String &p_source, EvalType type, const String &p_path, JavaScriptGCHandler &r_ret) override;
+	virtual Error safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, JavaScriptGCHandler &r_ret) override;
+
+	virtual Error compile_to_bytecode(const String &p_code, const String &p_file, Vector<uint8_t> &r_bytecode) override;
+	virtual Error load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, JavaScriptGCHandler *r_module) override;
+
+	virtual const JavaScriptClassInfo *parse_javascript_class(const String &p_code, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) override;
+	virtual const JavaScriptClassInfo *parse_javascript_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) override;
+	const JavaScriptClassInfo *parse_javascript_class_from_module(ModuleCache *p_module, const String &p_path, JavaScriptError *r_error);
+
+	virtual JavaScriptGCHandler create_js_instance_for_godot_object(const JavaScriptClassInfo *p_class, Object *p_object) override;
+
+	virtual bool get_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) override;
+	virtual bool set_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) override;
+	virtual bool has_method(const JavaScriptGCHandler &p_object, const StringName &p_name) override;
+	virtual bool has_signal(const JavaScriptClassInfo *p_class, const StringName &p_signal) override;
+	virtual bool validate(const String &p_code, const String &p_path, JavaScriptError *r_error) override;
+
+	virtual Variant call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override;
+	virtual Variant call(const JavaScriptGCHandler &p_fuction, const JavaScriptGCHandler &p_target, const Variant **p_args, int p_argcount, Callable::CallError &r_error) override;
+
+#ifdef TOOLS_ENABLED
+	virtual const Dictionary &get_modified_api() const override { return modified_api; }
+#endif
+};
+
+#endif // QUICKJS_BINDING_HELPER_H
diff --git a/thirdparty/quickjs/quickjs_builtin_binder.cpp b/thirdparty/quickjs/quickjs_builtin_binder.cpp
index 3a6c48fe..34aa19d8 100644
--- a/thirdparty/quickjs/quickjs_builtin_binder.cpp
+++ b/thirdparty/quickjs/quickjs_builtin_binder.cpp
@@ -1,11 +1,14 @@
-#include "quickjs_builtin_binder.h"
+#include "core/io/compression.h"
 #include "core/math/color.h"
+#include "core/os/memory.h"
 #include "core/variant/variant.h"
-#include "quickjs_binder.h"
-#include <core/io/compression.h>
-#include <core/os/memory.h>
+
 #include <cstring>
 
+#include "javascript_binder.h"
+#include "quickjs_binder.h"
+#include "quickjs_builtin_binder.h"
+
 QuickJSBuiltinBinder::QuickJSBuiltinBinder() {
 	ctx = NULL;
 	builtin_class_map = memnew_arr(BuiltinClass, Variant::VARIANT_MAX);
@@ -16,7 +19,6 @@ QuickJSBuiltinBinder::~QuickJSBuiltinBinder() {
 }
 
 void QuickJSBuiltinBinder::bind_builtin_object(JSContext *ctx, JSValue target, Variant::Type p_type, const void *p_object) {
-
 	void *ptr = NULL;
 	JavaScriptGCHandler *bind = NULL;
 	switch (p_type) {
@@ -636,7 +638,6 @@ JSValue QuickJSBuiltinBinder::new_object_from(JSContext *ctx, const PackedVector
 }
 
 void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
-
 	{ // Color
 		JSCFunctionMagic *getter = [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic) -> JSValue {
 			JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
@@ -727,22 +728,22 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 		binder->get_builtin_binder().register_property(Variant::RECT2, "end", getter, setter, 0);
 
 		binder->get_builtin_binder().register_method(
-			Variant::RECT2,
-			"grow_side",
-			[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
+				Variant::RECT2,
+				"grow_side",
+				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
 #ifdef DEBUG_METHODS_ENABLED
-				ERR_FAIL_COND_V(argc < 2, (JS_ThrowTypeError(ctx, "Two arguments expected for Rect2.grow_margin")));
+					ERR_FAIL_COND_V(argc < 2, (JS_ThrowTypeError(ctx, "Two arguments expected for Rect2.grow_margin")));
 #endif
-				JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-				Rect2 *ptr = bind->getRect2();
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					Rect2 *ptr = bind->getRect2();
 #ifdef DEBUG_METHODS_ENABLED
-				ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::INT, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 0 of Rect2.grow_margin")));
-				ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::FLOAT, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 1 of Rect2.grow_margin")));
+					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::INT, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 0 of Rect2.grow_margin")));
+					ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, Variant::FLOAT, argv[0]), (JS_ThrowTypeError(ctx, "number expected for argument 1 of Rect2.grow_margin")));
 #endif
-				Rect2 ret = ptr->grow_side(Side(QuickJSBinder::js_to_int(ctx, argv[0])), QuickJSBinder::js_to_number(ctx, argv[1]));
-				return QuickJSBinder::variant_to_var(ctx, ret);
-			},
-			2);
+					Rect2 ret = ptr->grow_side(Side(QuickJSBinder::js_to_int(ctx, argv[0])), QuickJSBinder::js_to_number(ctx, argv[1]));
+					return QuickJSBinder::variant_to_var(ctx, ret);
+				},
+				2);
 	}
 
 	{ // Transform2D
@@ -896,51 +897,51 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 	}
 	{ // Transform
 		binder->get_builtin_binder().register_method(
-			Variant::TRANSFORM3D,
-			"xform",
-			[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-				ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform3D.xform")));
-				JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-				Transform3D *ptr = bind->getTransform3D();
-				if (QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0])) {
-					Vector3 ret = ptr->xform(Vector3(QuickJSBinder::var_to_variant(ctx, argv[0])));
-					return QuickJSBinder::variant_to_var(ctx, ret);
-				} else if (QuickJSBinder::validate_type(ctx, Variant::PLANE, argv[0])) {
-					Plane ret = ptr->xform(Plane(QuickJSBinder::var_to_variant(ctx, argv[0])));
-					return QuickJSBinder::variant_to_var(ctx, ret);
-				} else if (QuickJSBinder::validate_type(ctx, Variant::AABB, argv[0])) {
-					AABB ret = ptr->xform(AABB(QuickJSBinder::var_to_variant(ctx, argv[0])));
-					return QuickJSBinder::variant_to_var(ctx, ret);
-				} else if (QuickJSBinder::validate_type(ctx, Variant::PACKED_VECTOR3_ARRAY, argv[0])) {
-					PackedVector3Array ret = ptr->xform(PackedVector3Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
-					return QuickJSBinder::variant_to_var(ctx, ret);
-				}
-				ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector3, Plane, AABB or PackedVector3Array expected for argument #0 of Transform3D.xform"));
-			},
-			1);
+				Variant::TRANSFORM3D,
+				"xform",
+				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
+					ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform3D.xform")));
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					Transform3D *ptr = bind->getTransform3D();
+					if (QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0])) {
+						Vector3 ret = ptr->xform(Vector3(QuickJSBinder::var_to_variant(ctx, argv[0])));
+						return QuickJSBinder::variant_to_var(ctx, ret);
+					} else if (QuickJSBinder::validate_type(ctx, Variant::PLANE, argv[0])) {
+						Plane ret = ptr->xform(Plane(QuickJSBinder::var_to_variant(ctx, argv[0])));
+						return QuickJSBinder::variant_to_var(ctx, ret);
+					} else if (QuickJSBinder::validate_type(ctx, Variant::AABB, argv[0])) {
+						AABB ret = ptr->xform(AABB(QuickJSBinder::var_to_variant(ctx, argv[0])));
+						return QuickJSBinder::variant_to_var(ctx, ret);
+					} else if (QuickJSBinder::validate_type(ctx, Variant::PACKED_VECTOR3_ARRAY, argv[0])) {
+						PackedVector3Array ret = ptr->xform(PackedVector3Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
+						return QuickJSBinder::variant_to_var(ctx, ret);
+					}
+					ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector3, Plane, AABB or PackedVector3Array expected for argument #0 of Transform3D.xform"));
+				},
+				1);
 		binder->get_builtin_binder().register_method(
-			Variant::TRANSFORM3D,
-			"xform_inv",
-			[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-				ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform3D.xform_inv")));
-				JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-				Transform3D *ptr = bind->getTransform3D();
-				if (QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0])) {
-					Vector3 ret = ptr->xform_inv(Vector3(QuickJSBinder::var_to_variant(ctx, argv[0])));
-					return QuickJSBinder::variant_to_var(ctx, ret);
-				} else if (QuickJSBinder::validate_type(ctx, Variant::PLANE, argv[0])) {
-					Plane ret = ptr->xform_inv(Plane(QuickJSBinder::var_to_variant(ctx, argv[0])));
-					return QuickJSBinder::variant_to_var(ctx, ret);
-				} else if (QuickJSBinder::validate_type(ctx, Variant::AABB, argv[0])) {
-					AABB ret = ptr->xform_inv(AABB(QuickJSBinder::var_to_variant(ctx, argv[0])));
-					return QuickJSBinder::variant_to_var(ctx, ret);
-				} else if (QuickJSBinder::validate_type(ctx, Variant::PACKED_VECTOR3_ARRAY, argv[0])) {
-					PackedVector3Array ret = ptr->xform_inv(PackedVector3Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
-					return QuickJSBinder::variant_to_var(ctx, ret);
-				}
-				ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector3, Plane, AABB or PackedVector3Array expected for argument #0 of Transform3D.xform_inv"));
-			},
-			1);
+				Variant::TRANSFORM3D,
+				"xform_inv",
+				[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
+					ERR_FAIL_COND_V(argc < 1, (JS_ThrowTypeError(ctx, "Argument expected for Transform3D.xform_inv")));
+					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+					Transform3D *ptr = bind->getTransform3D();
+					if (QuickJSBinder::validate_type(ctx, Variant::VECTOR3, argv[0])) {
+						Vector3 ret = ptr->xform_inv(Vector3(QuickJSBinder::var_to_variant(ctx, argv[0])));
+						return QuickJSBinder::variant_to_var(ctx, ret);
+					} else if (QuickJSBinder::validate_type(ctx, Variant::PLANE, argv[0])) {
+						Plane ret = ptr->xform_inv(Plane(QuickJSBinder::var_to_variant(ctx, argv[0])));
+						return QuickJSBinder::variant_to_var(ctx, ret);
+					} else if (QuickJSBinder::validate_type(ctx, Variant::AABB, argv[0])) {
+						AABB ret = ptr->xform_inv(AABB(QuickJSBinder::var_to_variant(ctx, argv[0])));
+						return QuickJSBinder::variant_to_var(ctx, ret);
+					} else if (QuickJSBinder::validate_type(ctx, Variant::PACKED_VECTOR3_ARRAY, argv[0])) {
+						PackedVector3Array ret = ptr->xform_inv(PackedVector3Array(QuickJSBinder::var_to_variant(ctx, argv[0])));
+						return QuickJSBinder::variant_to_var(ctx, ret);
+					}
+					ERR_FAIL_V(JS_ThrowTypeError(ctx, "Vector3, Plane, AABB or PackedVector3Array expected for argument #0 of Transform3D.xform_inv"));
+				},
+				1);
 	}
 
 	{ // PackedByteArray
@@ -1131,10 +1132,10 @@ void QuickJSBuiltinBinder::bind_builtin_propties_manually() {
 					JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
 					PackedColorArray *array = memnew(PackedColorArray(*bind->getPackedColorArray()));
 					JSValue ret = JS_NewArrayBuffer(
-						ctx, (uint8_t *)(array->ptr()), array->size() * sizeof(Color), [](JSRuntime *rt, void *opaque, void *ptr) {
-							memdelete(static_cast<PackedColorArray *>(opaque));
-						},
-						array, false);
+							ctx, (uint8_t *)(array->ptr()), array->size() * sizeof(Color), [](JSRuntime *rt, void *opaque, void *ptr) {
+								memdelete(static_cast<PackedColorArray *>(opaque));
+							},
+							array, false);
 					return ret;
 				},
 				0);
diff --git a/thirdparty/quickjs/quickjs_builtin_binder.h b/thirdparty/quickjs/quickjs_builtin_binder.h
index 33e90159..55c697df 100644
--- a/thirdparty/quickjs/quickjs_builtin_binder.h
+++ b/thirdparty/quickjs/quickjs_builtin_binder.h
@@ -1,14 +1,16 @@
 #ifndef QUICKJS_BUILTIN_BINDER_H
 #define QUICKJS_BUILTIN_BINDER_H
 
-#include "quickjs/quickjs.h"
 #include "core/variant/variant.h"
+
+#include "quickjs/quickjs.h"
+
 struct JavaScriptGCHandler;
-class QuickJSBinder;
 
 typedef JSValue (*JSConstructorFunc)(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv);
 typedef void (*JSFinalizerFunc)(JSRuntime *rt, JSValue val);
 
+class QuickJSBinder;
 class QuickJSBuiltinBinder {
 public:
 	struct BuiltinClass {
diff --git a/thirdparty/quickjs/quickjs_callable.cpp b/thirdparty/quickjs/quickjs_callable.cpp
index c2ed5cc3..109129e8 100644
--- a/thirdparty/quickjs/quickjs_callable.cpp
+++ b/thirdparty/quickjs/quickjs_callable.cpp
@@ -1,6 +1,8 @@
 #include "quickjs_callable.h"
 #include "javascript_language.h"
 #include "quickjs/quickjs.h"
+
+#include "quickjs_builtin_binder.h"
 #include "quickjs_binder.h"
 
 bool QuickJSCallable::compare_equal(const CallableCustom *p_a, const CallableCustom *p_b) {
diff --git a/thirdparty/quickjs/quickjs_worker.h b/thirdparty/quickjs/quickjs_worker.h
index 9d481dfa..de998a20 100644
--- a/thirdparty/quickjs/quickjs_worker.h
+++ b/thirdparty/quickjs/quickjs_worker.h
@@ -2,6 +2,7 @@
 #define QUICKJS_WORKER_H
 
 #include "core/os/thread.h"
+
 #include "quickjs_binder.h"
 
 class QuickJSWorker : public QuickJSBinder {
diff --git a/tools/editor_tools.cpp b/tools/editor_tools.cpp
index d94169d3..06294b1c 100644
--- a/tools/editor_tools.cpp
+++ b/tools/editor_tools.cpp
@@ -29,11 +29,14 @@
 /**************************************************************************/
 
 #include "editor_tools.h"
-#include "../javascript_language.h"
 #include "core/math/expression.h"
 #include "core/os/keyboard.h"
+#include "editor/doc_tools.h"
+#include "editor/editor_help.h"
 #include "editor/filesystem_dock.h"
 
+#include "../javascript_language.h"
+
 #define TS_IGNORE "//@ts-ignore\n"
 static HashMap<String, HashSet<String>> ts_ignore_errors;
 static HashMap<String, HashSet<String>> removed_members;
diff --git a/tools/editor_tools.h b/tools/editor_tools.h
index 9612f7cb..de095523 100644
--- a/tools/editor_tools.h
+++ b/tools/editor_tools.h
@@ -31,9 +31,12 @@
 #ifndef EDITOR_TOOLS_H
 #define EDITOR_TOOLS_H
 
-#include "editor/editor_file_dialog.h"
+#include "editor/gui/editor_file_dialog.h"
 #include "editor/editor_node.h"
+#include "editor/editor_plugin.h"
 
+class DocTools;
+class EditorFileDialog;
 class JavaScriptPlugin : public EditorPlugin {
 	GDCLASS(JavaScriptPlugin, EditorPlugin);
 

From 847fe107890b7dd905639893c7f609855215b5a4 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 15 Jun 2023 06:13:03 -0700
Subject: [PATCH 18/71] Remove build_github_actions.py

---
 build_github_actions.py | 344 ----------------------------------------
 1 file changed, 344 deletions(-)
 delete mode 100644 build_github_actions.py

diff --git a/build_github_actions.py b/build_github_actions.py
deleted file mode 100644
index 78bef44b..00000000
--- a/build_github_actions.py
+++ /dev/null
@@ -1,344 +0,0 @@
-#!/usr/bin/env python
-"""
-run this every time you upgrade the godot-base version to generate new matching github workflows
-You must be in this directory, and in the modules subfolder of godot (just as if you would install this project into godot)
-
-usage:
-python build_github_actions.py --godot-version "4.0" --godot-github-folder ../../.github --js-github-folder .github
-
-"""
-
-import argparse
-import yaml
-import os
-import subprocess
-from dataclasses import dataclass, field
-from typing import Dict, List, Any
-import copy
-
-
-# https://stackoverflow.com/a/33300001 + some changes
-def str_presenter(dumper, data):
-    if len(data.splitlines()) > 1 or "\n" in data:  # check for multiline string
-        return dumper.represent_scalar("tag:yaml.org,2002:str", data, style="|")
-    return dumper.represent_scalar("tag:yaml.org,2002:str", data)
-
-
-yaml.add_representer(str, str_presenter)
-
-# to use with safe_dump:
-yaml.representer.SafeRepresenter.add_representer(str, str_presenter)
-
-# END https://stackoverflow.com/a/33300001
-
-
-@dataclass
-class BuildOpts:
-    SCONSFLAGS: str
-    GODOT_BASE_BRANCH: str
-    ENV: Dict[str, str] = field(default_factory=dict)
-
-    def add_to_flags(self, toadd: str) -> None:
-        if not self.SCONSFLAGS.endswith(" "):
-            toadd = f" {toadd}"
-        self.SCONSFLAGS = f"{self.SCONSFLAGS} {toadd}"
-
-    def get_fixed_flags(self) -> str:
-        todel = ["warnings=all", "werror=yes"]
-        for x in todel:
-            self.SCONSFLAGS = self.SCONSFLAGS.replace(x, "")
-        return self.SCONSFLAGS
-
-
-def parseargs():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--godot-version", required=True)
-    parser.add_argument("--godot-github-folder", required=True)
-    parser.add_argument("--js-github-folder", required=True)
-    return parser.parse_args()
-
-
-def checkout_local_godot_install(tag: str):
-    cmd = ["git", "checkout", f"tags/{tag}"]
-    ret = subprocess.run(cmd, cwd="../../")
-    if ret.returncode != 0:
-        raise RuntimeError(f"godot not setup properly, could not checkout '{' '.join(cmd)}'")
-
-
-def get_windows_mingw_checkout_steps() -> List[object]:
-    out = [
-        {
-            "name": "setup-msys2",
-            "uses": "msys2/setup-msys2@v2",
-            "with": {"msystem": "MINGW64", "update": True, "install": "mingw-w64-x86_64-gcc"},
-        },
-        {
-            "name": "update mingw2",
-            "run": "pacman -Syu --needed --noconfirm mingw-w64-x86_64-python3-pip mingw-w64-x86_64-gcc mingw-w64-i686-python3-pip mingw-w64-i686-gcc make",
-        },
-        {
-            "name": "update scons",
-            "run": "pip3 install scons",
-        },
-    ]
-    return out
-
-
-def get_js_checkout_steps() -> List[Dict[str, Any]]:
-    out = [
-        {
-            "name": "Checkout Godot",
-            "uses": "actions/checkout@v2",
-            "with": {"repository": "godotengine/godot", "ref": "${{ env.GODOT_BASE_BRANCH }}"},
-        },
-        {
-            "name": "Checkout javascript",
-            "uses": "actions/checkout@v2",
-            "with": {"path": "${{github.workspace}}/modules/javascript/"},
-        },
-    ]
-    return out
-
-
-def get_rid_of_ubsan_asan_linux(matrix_step: Dict[str, Any]) -> Dict[str, Any]:
-    for get_rid_of in ["use_ubsan=yes", "use_asan=yes"]:
-        matrix_step["name"] = matrix_step["name"].replace(get_rid_of, "").replace(" , ", " ").replace(", )", ")")
-        matrix_step["sconsflags"] = matrix_step["sconsflags"].replace(get_rid_of, "").replace(", )", ")")
-    return matrix_step
-
-
-def fix_all_workflows(
-    js_github_folder: str, workflows: Dict[str, BuildOpts], wf_actions_that_require_shell: List[str]
-) -> List[str]:
-    wf_names: List[str] = []
-    for wf_base_fn, build_opts in workflows.items():
-        full_fn = os.path.join(js_github_folder, "workflows", wf_base_fn)
-        data = yaml.safe_load(open(full_fn))
-        wf_names.append(data["name"])
-
-        build_opts.add_to_flags(data["env"]["SCONSFLAGS"])
-        data["env"]["SCONSFLAGS"] = build_opts.get_fixed_flags()
-        data["env"]["GODOT_BASE_BRANCH"] = build_opts.GODOT_BASE_BRANCH
-        for k, v in build_opts.ENV.items():
-            data["env"][k] = v
-
-        if True in data.keys():
-            new_data = {"name": data["name"], "on": data[True]}
-            del data[True]
-            for k, v in data.items():
-                if k in ("name", "on"):
-                    continue
-                new_data[k] = v
-            data = new_data
-        assert len(data["jobs"]) == 1
-        only_template_name = list(data["jobs"].keys())[0]
-
-        new_steps = []
-        if "windows" in wf_base_fn:
-            # quickjs can't build under msvc, must use mingw, install it here
-            new_steps += get_windows_mingw_checkout_steps()
-            data["jobs"][only_template_name]["defaults"] = {"run": {"shell": "msys2 {0}"}}
-
-        elif "linux" in wf_base_fn:
-            for matrix_step in data["jobs"][only_template_name]["strategy"]["matrix"]["include"]:
-                # quickjs fails under ubsan & asan, don't include those flags
-                if "name" in matrix_step and "Editor and sanitizers" in matrix_step["name"]:
-                    matrix_step = get_rid_of_ubsan_asan_linux(matrix_step)
-
-        base_github_string = "./.github/"
-        for step in data["jobs"][only_template_name]["steps"]:
-            # replace godot checkout routine with this checkout routine
-            if "uses" in step and "checkout" in step["uses"]:
-                new_steps += get_js_checkout_steps()
-            elif (
-                "uses" in step
-                and base_github_string in step["uses"]
-                and any(x in step["uses"] for x in wf_actions_that_require_shell)
-            ):
-                step["uses"] = step["uses"].replace(base_github_string, "./modules/javascript/.github/")
-                to_add = {"shell": "msys2 {0}" if "windows" in wf_base_fn else "sh"}
-                if "with" not in step:
-                    step["with"] = to_add
-                else:
-                    step["with"].update(to_add)
-                new_steps.append(step)
-            else:
-                new_steps.append(step)
-
-        data["jobs"][only_template_name]["steps"] = new_steps
-        with open(full_fn, "w") as fh:
-            yaml.dump(data, fh, sort_keys=False, allow_unicode=True)
-    return wf_names
-
-
-def fix_all_actions(js_github_folder: str, actions: List[str]) -> List[str]:
-    """
-    This can be simplified once:
-    https://github.com/actions/runner/pull/1767
-    is completed
-    """
-    actions_that_require_shell_set = set()
-    for action_base_fn in actions:
-        full_action_fn = os.path.join(js_github_folder, action_base_fn)
-        data = yaml.safe_load(open(full_action_fn))
-        new_steps = []
-        for step in data["runs"]["steps"]:
-            if "shell" in step:
-                for shell in ["sh", "msys2 {0}"]:
-                    cp_step = copy.deepcopy(step)
-                    cp_step["shell"] = shell
-                    cp_step["if"] = f"inputs.shell == '{shell}'"
-                    new_steps.append(cp_step)
-                data["inputs"]["shell"] = {"description": "the shell to run this under", "default": "sh"}
-                actions_that_require_shell_set.add(action_base_fn)
-            else:
-                new_steps.append(step)
-            # new_steps.append(step)
-            # Uncomment this when github actions updated
-            # if "shell" in step:
-            #     step["shell"] = "${{ inputs.shell }}"
-            #     data["inputs"]["shell"] = {"description": "the shell to run this under", "default": "sh"}
-            # new_steps.append(step)
-
-            # We ca
-        data["runs"]["steps"] = new_steps
-        with open(full_action_fn, "w") as fh:
-            yaml.dump(data, fh, sort_keys=False, allow_unicode=True)
-    return list(sorted([x.split("/")[1] for x in actions_that_require_shell_set]))
-
-
-def add_publish_workflow(out_fn: str, wf_name_list: List[str]):
-    # "on": {"tag":  "",   "workflow_run": {"workflows": wf_name_list, "types": ["completed"]}},
-    # run_id: ${{ github.event.workflow_run.id }},
-    # var matchArtifact = artifacts.data.artifacts.filter((artifact) => {
-    #   return artifact.name == "pr"
-    # })[0];
-
-    script_text = (
-        """var total_slept = 0;
-var downloaded_files = [];
-var seen_completed_wfs = [];
-var expected_to_see = """
-        + str(len(wf_name_list))
-        + """;
-while (total_slept < 3600000 && seen_completed_wfs.length < expected_to_see) {
-    var all_workflows = await github.rest.actions.listWorkflowRunsForRepo({
-        owner: context.repo.owner,
-        repo: context.repo.repo,
-    });
-    console.log("Expecting to download from " + expected_to_see + " workflows, currently at " + seen_completed_wfs.length + ". Have already downloaded " + downloaded_files.length + " files as " + downloaded_files);
-    for (const workflow of all_workflows.data.workflow_runs) {
-        if (workflow.head_sha == "${{ github.sha }}") {
-            console.log("found " + workflow.name + " " + workflow.status);
-            if (workflow.status == "completed") {
-                if (seen_completed_wfs.includes(workflow.name)) {continue;}
-                if (workflow.conclusion == "success") {
-                    var artifacts = await github.rest.actions.listWorkflowRunArtifacts({
-                        owner: context.repo.owner,
-                        repo: context.repo.repo,
-                        run_id: workflow.id,
-                        per_page: 100,
-                    });
-                    for (const artifact of artifacts.data.artifacts) {
-                        var fn = '${{github.workspace}}/' + artifact.name + '.zip';
-                        if (downloaded_files.includes(fn)) {continue;}
-                        var download = await github.rest.actions.downloadArtifact({
-                            owner: context.repo.owner,
-                            repo: context.repo.repo,
-                            artifact_id: artifact.id,
-                            archive_format: 'zip',
-                        });
-                        var fs = require('fs');
-                        fs.writeFileSync(fn, Buffer.from(download.data));
-                        downloaded_files.push(fn);
-                    }
-                    seen_completed_wfs.push(workflow.name);
-                }
-            }
-        }
-    }
-    if (seen_completed_wfs.length < expected_to_see) {
-        console.log("sleeping " + 300000);
-        await new Promise(r => setTimeout(r, 300000));
-        total_slept = total_slept + 300000;
-        console.log("done sleeping " + 300000);
-    }
-}
-console.log(downloaded_files);"""
-    )
-
-    data = {
-        "name": "🚢 Publish release",
-        # You should tag as late as possible, don't want to sleep too long and get push job killed
-        "on": {
-            "push": {"tags": ["*"]},
-        },
-        "jobs": {
-            "collect-template": {
-                "runs-on": "ubuntu-latest",
-                "steps": [
-                    # {"name": "show dir", "run": "sleep 900"},
-                    {
-                        "name": "download artifacts",
-                        "uses": "actions/github-script@v6",
-                        "if": "startsWith(github.ref, 'refs/tags')",
-                        "with": {"script": script_text},
-                    },
-                    {"name": "show dir", "run": "ls -R"},
-                    {
-                        "name": "Upload binaries to release",
-                        "uses": "svenstaro/upload-release-action@v2",
-                        "if": "startsWith(github.ref, 'refs/tags')",
-                        "with": {
-                            "repo_token": "${{ secrets.GITHUB_TOKEN }}",
-                            "file": "*.zip",
-                            "tag": "${{ github.ref }}",
-                            "overwrite": "true",
-                            "file_glob": "true",
-                        },
-                    },
-                ],
-            }
-        },
-    }
-
-    with open(out_fn, "w") as fh:
-        yaml.dump(data, fh, sort_keys=False, allow_unicode=True)
-
-
-def main():
-    args = parseargs()
-    assert os.path.isdir(args.godot_github_folder)
-    assert os.path.isdir(args.js_github_folder)
-    checkout_local_godot_install(args.godot_version)
-
-    for x in ["actions", "workflows"]:
-        subprocess.call(["rm", "-rf", os.path.join(args.js_github_folder, x)])
-        subprocess.call(["cp", "-r", os.path.join(args.godot_github_folder, x), os.path.join(args.js_github_folder, x)])
-
-    basic_flags = " "
-    actions = [
-        "actions/godot-build/action.yml",
-        "actions/godot-cache/action.yml",
-        "actions/godot-deps/action.yml",
-        "actions/upload-artifact/action.yml",
-    ]
-    wf_actions_that_require_shell = fix_all_actions(args.js_github_folder, actions)
-    workflows = {
-        "android_builds.yml": BuildOpts(basic_flags, args.godot_version),
-        "ios_builds.yml": BuildOpts(basic_flags, args.godot_version),
-        "javascript_builds.yml": BuildOpts(basic_flags, args.godot_version),
-        "linux_builds.yml": BuildOpts(basic_flags, args.godot_version),
-        "macos_builds.yml": BuildOpts(basic_flags, args.godot_version),
-        "server_builds.yml": BuildOpts(basic_flags, args.godot_version),
-        "windows_builds.yml": BuildOpts(f"{basic_flags} use_mingw=yes", args.godot_version),
-    }
-    wf_names = fix_all_workflows(args.js_github_folder, workflows, wf_actions_that_require_shell)
-    subprocess.call(["rm", os.path.join(args.js_github_folder, "workflows", "static_checks.yml")])
-
-    out_publish_fn = os.path.join(args.js_github_folder, "workflows", "on_tag.yml")
-    add_publish_workflow(out_publish_fn, wf_names)
-
-
-if __name__ == "__main__":
-    main()

From caa8840c359ffedd291e025aa306ee11093591e3 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 15 Jun 2023 12:28:05 -0700
Subject: [PATCH 19/71] Update godot-javascript to better pass tests.

---
 README.md                                     |  260 +-
 SCsub                                         |   10 +-
 config.py                                     |   12 +
 doc_classes/JavaScript.xml                    |   11 +
 doc_classes/JavaScriptModule.xml              |   44 +
 quickjs/quickjs_callable.cpp                  |    2 +-
 tests/UnitTest.js.disable                     |  100 -
 .../quickjs/builtin_binding_generator.py      |  116 +-
 thirdparty/quickjs/quickjs/cutils.c           |    3 +-
 thirdparty/quickjs/quickjs/cutils.h           |   54 +-
 thirdparty/quickjs/quickjs/libregexp.c        |   11 +-
 thirdparty/quickjs/quickjs/quickjs.h          |    8 +-
 thirdparty/quickjs/quickjs_binder.cpp         | 2340 +++++++++++++++++
 thirdparty/quickjs/quickjs_binder.h           |   17 +-
 thirdparty/quickjs/quickjs_callable.cpp       |   23 +-
 thirdparty/quickjs/quickjs_callable.h         |    1 -
 thirdparty/quickjs/quickjs_debugger.cpp       |    5 +-
 thirdparty/winpthreads/COPYING                |   57 +
 thirdparty/winpthreads/README                 |   10 +
 thirdparty/winpthreads/include/pthread.h      |  685 +++++
 .../winpthreads/include/pthread_compat.h      |   86 +
 .../winpthreads/include/pthread_signal.h      |   29 +
 thirdparty/winpthreads/include/pthread_time.h |  102 +
 .../winpthreads/include/pthread_unistd.h      |  192 ++
 thirdparty/winpthreads/include/sched.h        |   83 +
 thirdparty/winpthreads/include/semaphore.h    |   85 +
 thirdparty/winpthreads/src/barrier.c          |  246 ++
 thirdparty/winpthreads/src/barrier.h          |   49 +
 thirdparty/winpthreads/src/clock.c            |  286 ++
 thirdparty/winpthreads/src/cond.c             |  755 ++++++
 thirdparty/winpthreads/src/cond.h             |   61 +
 .../winpthreads/src/libgcc/dll_dependency.S   |   90 +
 thirdparty/winpthreads/src/libgcc/dll_math.c  |  586 +++++
 thirdparty/winpthreads/src/misc.c             |  158 ++
 thirdparty/winpthreads/src/misc.h             |  114 +
 thirdparty/winpthreads/src/mutex.c            |  385 +++
 thirdparty/winpthreads/src/nanosleep.c        |   71 +
 thirdparty/winpthreads/src/ref.c              |   34 +
 thirdparty/winpthreads/src/ref.h              |   29 +
 thirdparty/winpthreads/src/rwlock.c           |  533 ++++
 thirdparty/winpthreads/src/rwlock.h           |   52 +
 thirdparty/winpthreads/src/sched.c            |  218 ++
 thirdparty/winpthreads/src/sem.c              |  354 +++
 thirdparty/winpthreads/src/sem.h              |   40 +
 thirdparty/winpthreads/src/spinlock.c         |   86 +
 thirdparty/winpthreads/src/thread.c           | 1885 +++++++++++++
 thirdparty/winpthreads/src/thread.h           |   79 +
 thirdparty/winpthreads/src/version.rc         |   62 +
 .../winpthreads/src/winpthread_internal.h     |   27 +
 thirdparty/winpthreads/src/wpth_ver.h         |   29 +
 50 files changed, 10262 insertions(+), 313 deletions(-)
 create mode 100644 doc_classes/JavaScript.xml
 create mode 100644 doc_classes/JavaScriptModule.xml
 delete mode 100644 tests/UnitTest.js.disable
 create mode 100644 thirdparty/quickjs/quickjs_binder.cpp
 create mode 100644 thirdparty/winpthreads/COPYING
 create mode 100644 thirdparty/winpthreads/README
 create mode 100644 thirdparty/winpthreads/include/pthread.h
 create mode 100644 thirdparty/winpthreads/include/pthread_compat.h
 create mode 100644 thirdparty/winpthreads/include/pthread_signal.h
 create mode 100644 thirdparty/winpthreads/include/pthread_time.h
 create mode 100644 thirdparty/winpthreads/include/pthread_unistd.h
 create mode 100644 thirdparty/winpthreads/include/sched.h
 create mode 100644 thirdparty/winpthreads/include/semaphore.h
 create mode 100644 thirdparty/winpthreads/src/barrier.c
 create mode 100644 thirdparty/winpthreads/src/barrier.h
 create mode 100644 thirdparty/winpthreads/src/clock.c
 create mode 100644 thirdparty/winpthreads/src/cond.c
 create mode 100644 thirdparty/winpthreads/src/cond.h
 create mode 100644 thirdparty/winpthreads/src/libgcc/dll_dependency.S
 create mode 100644 thirdparty/winpthreads/src/libgcc/dll_math.c
 create mode 100644 thirdparty/winpthreads/src/misc.c
 create mode 100644 thirdparty/winpthreads/src/misc.h
 create mode 100644 thirdparty/winpthreads/src/mutex.c
 create mode 100644 thirdparty/winpthreads/src/nanosleep.c
 create mode 100644 thirdparty/winpthreads/src/ref.c
 create mode 100644 thirdparty/winpthreads/src/ref.h
 create mode 100644 thirdparty/winpthreads/src/rwlock.c
 create mode 100644 thirdparty/winpthreads/src/rwlock.h
 create mode 100644 thirdparty/winpthreads/src/sched.c
 create mode 100644 thirdparty/winpthreads/src/sem.c
 create mode 100644 thirdparty/winpthreads/src/sem.h
 create mode 100644 thirdparty/winpthreads/src/spinlock.c
 create mode 100644 thirdparty/winpthreads/src/thread.c
 create mode 100644 thirdparty/winpthreads/src/thread.h
 create mode 100644 thirdparty/winpthreads/src/version.rc
 create mode 100644 thirdparty/winpthreads/src/winpthread_internal.h
 create mode 100644 thirdparty/winpthreads/src/wpth_ver.h

diff --git a/README.md b/README.md
index 1562ff78..0261ca5d 100644
--- a/README.md
+++ b/README.md
@@ -1,136 +1,137 @@
-## JavaScript language binding for godot game engine
+# JavaScript language binding for Godot game engine
 
-This module implements JavaScript/TypeScript language support for the godot game engine. [QuickJS](https://bellard.org/quickjs/) is used as the JavaScript engine.
+This module implements JavaScript/TypeScript language support for the Godot game engine using [QuickJS](https://bellard.org/quickjs/) as the JavaScript engine.
 
------
+## Features
 
-### Features
 - Almost complete ES2020 support
-- All godot api avaliable
-- Operator overriding for builtin types (Vector3, Color, etc)
+- All Godot API available
+- Operator overriding for built-in types (Vector3, Color, etc)
 - TypeScript support
-- [Using thirdpart libraries from npm](https://github.com/GodotExplorer/ECMAScriptDemos/tree/master/npm_module)
+- [Using third-party libraries from npm](https://github.com/GodotExplorer/ECMAScriptDemos/tree/master/npm_module)
 - Multi-thread support with Worker API
-- Full code completion support for all godot APIs including signals and enumerations
+- Full code completion support for all Godot APIs including signals and enumerations
 - Debug in Visual Studio Code with the [plugin](https://marketplace.visualstudio.com/items?itemName=geequlim.godot-javascript-debug)
 
-### Installation
-No installation or setup necessary. The binaries for download are the complete, usable Godot editor and engine with Javascript/Typescript language support.
+## Installation
 
-### Download
-You can try the pre-compiled binaries from the [release page](https://github.com/GodotExplorer/ECMAScript/releases)
-You can also get the binaries with lastest commits from the [github build action result](https://github.com/GodotExplorer/ECMAScript/actions)
+No installation or setup necessary. The binaries for download are the complete, usable Godot editor and engine with JavaScript/TypeScript language support.
 
-### Compilation
-* Clone the source code of [godot](https://github.com/godotengine/godot)
-* Clone this module and put it into `godot/modules/` and make sure the folder name of this module is `javascript`
-* [Recompile the godot engine](https://docs.godotengine.org/en/3.3/development/compiling/index.html) <b>(Only MinGW is supported on Windows for now!)</b>
+## Download
+
+You can try the pre-compiled binaries from the [release page](https://github.com/GodotExplorer/ECMAScript/releases) or get the binaries with the latest commits from the [GitHub build action result](https://github.com/GodotExplorer/ECMAScript/actions).
+
+## Compilation
+
+1. Clone the source code of [godot](https://github.com/godotengine/godot)
+2. Clone this module and put it into `godot/modules/` and make sure the folder name of this module is `javascript`
+3. [Recompile the godot engine](https://docs.godotengine.org/en/3.3/development/compiling/index.html) **(Only MinGW is supported on Windows for now!)**
 
 ![Build Godot with ECMAScript](https://github.com/GodotExplorer/ECMAScript/workflows/Build%20Godot%20with%20ECMAScript/badge.svg)
 
-### Usage
+## Usage
+
+### How to export script class to Godot
+
+1. Define your JavaScript class and inherit from a Godot class, then export it as the **default** entry:
 
-##### How to export script class to godot
-1. Define your JavaScript class and inherit from a godot class then export it as the **default** entry
 ```js
-// The default export entry is treated as an exported class to godot
+// The default export entry is treated as an exported class to Godot
 export default class MySprite extends godot.Sprite {
-
 	// this is _init() in GDScript
 	constructor() {
 		super();
 	}
 
-	_ready() {
+	_ready() {}
 
-	}
-
-	_process(delta) {
-
-	}
+	_process(delta) {}
 }
 ```
+
 2. Save the script with extension `.mjs`
 3. Attach the script file to the node or resource object like you do with GDScript
 
-##### How to export signals
+### How to export signals
 
 ```js
-export default class MySprite extends godot.Sprite {};
+export default class MySprite extends godot.Sprite {}
 // register game_over signal to MySprite class
-godot.register_signal(MySprite, 'game_over');
+godot.register_signal(MySprite, "game_over");
 ```
 
-##### How to export properties
+### How to export properties
+
 ```js
 export default class MySprite extends godot.Sprite {
 	_process(delta) {
 		// Yes! We can use operators in JavaScript like GDScript
 		this.position += this.direction * delta;
 	}
-};
-// export 'direction' properties to MySprite godot inspector
-godot.register_property(MySprite, 'direction', new godot.Vector2(1, 0));
+}
+// export 'direction' properties to MySprite Godot inspector
+godot.register_property(MySprite, "direction", new godot.Vector2(1, 0));
 ```
 
-There are 2 ways of using the `godot.register_property`, the thrid param can either be
-a default value for the property you're trying to export or an object giving a more detailed
-description on how the editor should show it.
+There are 2 ways of using the `godot.register_property`. The third parameter can either be a default value for the property you're trying to export or an object giving a more detailed description of how the editor should show it.
 
 ```js
 function register_property(target: GodotClass | godot.Object, name: string, value: any);
 function register_property(target: GodotClass | godot.Object, name: string, info: PropertyInfo);
 ```
 
-So calling the register_property like this:
+So calling the `register_property` like this:
+
 ```js
-godot.register_property(MyClass, 'number_value', 3.14);
+godot.register_property(MyClass, "number_value", 3.14);
 ```
 
 Is the simplified version of:
+
 ```js
-godot.register_property(MyClass, 'number_value',  {
+godot.register_property(MyClass, "number_value", {
 	type: godot.TYPE_REAL,
 	hint: godot.PropertyHint.PROPERTY_HINT_NONE,
 	hint_string: "",
-	default: 3.14
+	default: 3.14,
 });
 ```
 
 For more detail on how to use it, [click here](https://github.com/Geequlim/ECMAScript/issues/24#issuecomment-655584829).
 
-#### About the API
-
-All of godots api's are defined within the `godot` namespace.
-
-No API names have been renamed or changed so you shouldn't need to change your habits.
-
-GDScript | JavaScript
----- | ---
-null | null
-int | number
-float | number
-String | string
-Array | Array
-Dictionary | Object
-NodePath | string
-Object | godot.Object
-Resource | godot.Resource
-Vector2 | godot.Vector2
-Color | godot.Color
-sin(v)| godot.sin(v)
-print(v)| godot.print(v)
-PI|godot.PI
-Color.black | godot.Color.black
-Control.CursorShape | godot.Control.CursorShape
-Label.Align.ALIGN_LEFT | godot.Label.Align.ALIGN_LEFT
-
-##### API specification:
+### About the API
+
+All of Godot's APIs are defined within the `godot` namespace.
+
+No API names have been renamed or changed, so you shouldn't need to change your habits.
+
+| GDScript               | JavaScript                   |
+| ---------------------- | ---------------------------- |
+| null                   | null                         |
+| int                    | number                       |
+| float                  | number                       |
+| String                 | string                       |
+| Array                  | Array                        |
+| Dictionary             | Object                       |
+| NodePath               | string                       |
+| Object                 | godot.Object                 |
+| Resource               | godot.Resource               |
+| Vector2                | godot.Vector2                |
+| Color                  | godot.Color                  |
+| sin(v)                 | godot.sin(v)                 |
+| print(v)               | godot.print(v)               |
+| PI                     | godot.PI                     |
+| Color.black            | godot.Color.black            |
+| Control.CursorShape    | godot.Control.CursorShape    |
+| Label.Align.ALIGN_LEFT | godot.Label.Align.ALIGN_LEFT |
+
+#### API specification:
+
 - Keys of Dictionary are converted to String in JavaScript
-- Signals are defined as constants to its classes
-	```
-	godot.Control.resized === 'resized' // true
-	```
+- Signals are defined as constants to their classes
+  ```
+  godot.Control.resized === 'resized' // true
+  ```
 - Additional functions
   - `godot.register_signal(cls, signal_name)` to register signals
   - `godot.register_property(cls, name, default_value)` to define and export properties
@@ -144,49 +145,56 @@ Label.Align.ALIGN_LEFT | godot.Label.Align.ALIGN_LEFT
   - `require(module_id)` to load a CommonJS module or load a resource file
   - `$` is the alias of `Node.get_node`
 - Using signals in the ECMAScript way
-  - Allow passing functions for `godot.Object.connect`, `godot.Object.disconnect` and `godot.Object.is_connected`
-	```js
-		this.panel.connect(godot.Control.resized, (size) => {
-			console.log('The size of the panel changed to:', size);
-		});
-	```
-  - Using `await` to wait signals
-	```js
-	await godot.yield(this.get_tree().create_timer(1), godot.SceneTreeTimer.timeout);
-	console.log('After one second to show');
-	```
+  - Allow passing functions for `godot.Object.connect`, `godot.Object.disconnect`, and `godot.Object.is_connected`
+  ```js
+  this.panel.connect(godot.Control.resized, (size) => {
+  	console.log("The size of the panel changed to:", size);
+  });
+  ```
+  - Using `await` to wait for signals
+  ```js
+  await godot.yield(
+  	this.get_tree().create_timer(1),
+  	godot.SceneTreeTimer.timeout
+  );
+  console.log("After one second to show");
+  ```
 - Preload resources with ECMAScript import statement
-	```js
-	import ICON from 'res://icon.png';
-	```
+  ```js
+  import ICON from "res://icon.png";
+  ```
 - Multi-threading with minimal [Worker API](https://developer.mozilla.org/en-US/docs/Web/API/Worker) (**This is an experimental feature**)
-	- Start a new thread with Worker
-		```js
-		const worker = new Worker('worker.js'); // Run worker.js in a new thread context
-		worker.postMessage({type: 'load_dlc', value: 'dlc01.pck'});
-		worker.onmessage = function(msg) {
-			console.log("[MainThread] received message from worker thread:", msg);
-		}
-		```
-	- Transfer value in different thread context with `godot.abandon_value` and `godot.adopt_value`
-		```js
-		// In worker thread
-		let id = godot.abandon_value(object);
-		postMessage({ type: 'return_value', id: id });
-
-		// In the host thread
-		worker.onmessage = function(msg) {
-			if (typeof msg === 'object' && msg.type === 'return_value') {
-				let value_from_worker = godot.adopt_value(msg.id);
-			}
-		}
-		```
+
+  - Start a new thread with Worker
+    ```js
+    const worker = new Worker("worker.js"); // Run worker.js in a new thread context
+    worker.postMessage({ type: "load_dlc", value: "dlc01.pck" });
+    worker.onmessage = function (msg) {
+    	console.log("[MainThread] received message from worker thread:", msg);
+    };
+    ```
+  - Transfer value in different thread context with `godot.abandon_value` and `godot.adopt_value`
+
+    ```js
+    // In worker thread
+    let id = godot.abandon_value(object);
+    postMessage({ type: "return_value", id: id });
+
+    // In the host thread
+    worker.onmessage = function (msg) {
+    	if (typeof msg === "object" && msg.type === "return_value") {
+    		let value_from_worker = godot.adopt_value(msg.id);
+    	}
+    };
+    ```
 
 ### TypeScript support
-- Run the menu command `Project > Tools > JavaScript > Generate TypeScript Project` from the godot editor to generate a TypeScript project
+
+- Run the menu command `Project > Tools > JavaScript > Generate TypeScript Project` from the Godot editor to generate a TypeScript project
 - Run `tsc -w -p .` under your project folder in the terminal to compile scripts
 
 #### Code completion
+
 - Code completion in TS will automatically work once the TypeScript project is generated by the above steps.
 - Code completion in VSCode is achieved by the property `"types": "./godot.d.ts"` in the generated package.json file of the TypeScript project. The `godot.d.ts` file can be generated alone via the `Project > Tools > ECMAScript > Generate TypeScript Declaration File` editor menu option and added to a `package.json` file manually to achieve this without a full TypeScript project.
 
@@ -201,7 +209,6 @@ import { signal, property, tool, onready, node } from "./decorators";
 
 @tool // make the script runnable in godot editor
 export default class InputLine extends godot.HBoxContainer {
-
 	// define a signal
 	@signal
 	static readonly OnTextChanged: string;
@@ -216,7 +223,9 @@ export default class InputLine extends godot.HBoxContainer {
 
 	// register properties for godot editor inspector
 	@property({ type: godot.VariantType.TYPE_STRING })
-	get title() { return this._title; }
+	get title() {
+		return this._title;
+	}
 	set title(v: string) {
 		this._title = v;
 		if (this._label) {
@@ -226,7 +235,9 @@ export default class InputLine extends godot.HBoxContainer {
 	private _title: string;
 
 	@property({ default: "Input text here" })
-	get hint() { return this._hint; }
+	get hint() {
+		return this._hint;
+	}
 	set hint(v: string) {
 		this._hint = v;
 		if (this.edit) {
@@ -236,11 +247,13 @@ export default class InputLine extends godot.HBoxContainer {
 	}
 	private _hint: string;
 
-	get label(): godot.Label { return this._label; }
+	get label(): godot.Label {
+		return this._label;
+	}
 	protected _label: godot.Label;
 
 	// call get_node('LineEdit') and assign the returned value to 'this.edit' automatically when the node is ready
-	@onready('LineEdit')
+	@onready("LineEdit")
 	edit: godot.LineEdit;
 
 	get text(): string {
@@ -255,7 +268,7 @@ export default class InputLine extends godot.HBoxContainer {
 		this.title = this.title;
 		this.hint = this.hint;
 
-		this.edit.connect(godot.LineEdit.text_changed, (text: string)=>{
+		this.edit.connect(godot.LineEdit.text_changed, (text: string) => {
 			this.emit_signal(InputLine.OnTextChanged, text);
 		});
 	}
@@ -263,15 +276,16 @@ export default class InputLine extends godot.HBoxContainer {
 ```
 
 ## Demo
+
 You can try demos in the [ECMAScriptDemos](https://github.com/Geequlim/ECMAScriptDemos)
 
 ## Developer notes
-* This package is not compatible with MSVC, you will get build errors in quickjs.
-* To update the github actions scripts we have the file `build_github_actions.py`.  This script will copy the actions from the godot repo (usually at `../../`) and modify them to fix the requirements of quickjs and this repo.
-** If you are updating this repo's compatibility, you should run that script (a brief description is at the top of the script) and it will re-create the actions `.yml` files for you.
-* The script also build the `on_tag.yml` script which automates the github release publishing.
-** The `on_tag.yml` functionality tries to sleep until all jobs with the same `sha` are completed.  It should be fine to run whenever, but depending on how github actions culls long running jobs you might want to make sure that all/(most of) the builds look good before tagging.
-* Linux ubsan asan build woes:
-* The godot repo has ubsan and asan builds that we can't build from.  Currently we skip them (get removed via the `build_github_actions.py` script).
-* They should definitely be fixed & enabled at some point, **so please submit a PR if you have any ideas of how to do that!**
 
+- This package is not compatible with MSVC, you will get build errors in quickjs.
+- To update the github actions scripts we have the file `build_github_actions.py`. This script will copy the actions from the godot repo (usually at `../../`) and modify them to fix the requirements of quickjs and this repo.
+  \*\* If you are updating this repo's compatibility, you should run that script (a brief description is at the top of the script) and it will re-create the actions `.yml` files for you.
+- The script also build the `on_tag.yml` script which automates the github release publishing.
+  \*\* The `on_tag.yml` functionality tries to sleep until all jobs with the same `sha` are completed. It should be fine to run whenever, but depending on how github actions culls long running jobs you might want to make sure that all/(most of) the builds look good before tagging.
+- Linux ubsan asan build woes:
+- The godot repo has ubsan and asan builds that we can't build from. Currently we skip them (get removed via the `build_github_actions.py` script).
+- They should definitely be fixed & enabled at some point, **so please submit a PR if you have any ideas of how to do that!**
diff --git a/SCsub b/SCsub
index fe690f9a..9f9c7826 100644
--- a/SCsub
+++ b/SCsub
@@ -5,8 +5,7 @@ Import("env")
 Import("env_modules")
 env_module = env_modules.Clone()
 JS_ENGINE = "quickjs"
-TOOLS = "editor" == env_module["target"]  # env.get('TOOLS');
-
+TOOLS = "editor" == env_module["target"]
 
 def open_file(path, mode):
     if platform.python_version() > "3":
@@ -44,12 +43,19 @@ if JS_ENGINE == "quickjs":
         env_module.Append(CPPDEFINES={"QUICKJS_WITH_DEBUGGER": 1})
     env_module.Append(CPPPATH=["thirdparty/quickjs/quickjs"])
     env_module.Append(CPPPATH=["thirdparty/quickjs"])
+    
     if TOOLS:
         env_module.add_source_files(env.modules_sources, "tools/editor_tools.cpp")
     env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp")
     env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/*.cpp")
     env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs/*.c")
 
+    if env.msvc:
+        env.Append(CXXFLAGS=["/std:c++latest"])
+    else:
+        env_module.Append(CXXFLAGS=["-std=c++20"])
+
+ 
 # Binding script to run at engine initializing
 with open("misc/godot.binding_script.gen.cpp", "w") as f:
     text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "../javascript_binder.h"\nString JavaScriptBinder::BINDING_SCRIPT_CONTENT = \n${source};'
diff --git a/config.py b/config.py
index d22f9454..c62e9428 100644
--- a/config.py
+++ b/config.py
@@ -4,3 +4,15 @@ def can_build(env, platform):
 
 def configure(env):
     pass
+
+
+
+def get_doc_classes():
+    return [
+        "JavaScript",
+        "JavaScriptModule",
+    ]
+
+
+def get_doc_path():
+    return "doc_classes"
diff --git a/doc_classes/JavaScript.xml b/doc_classes/JavaScript.xml
new file mode 100644
index 00000000..ca3f4659
--- /dev/null
+++ b/doc_classes/JavaScript.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="JavaScript" inherits="Script" version="4.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
+	<brief_description>
+		A JavaScript script resource for creating and managing JavaScript scripts in Godot.
+	</brief_description>
+	<description>
+		The JavaScript class provides a way to create and manage JavaScript scripts within the Godot game engine. It inherits from the Script class and allows you to write game logic using JavaScript as the scripting language.
+	</description>
+	<tutorials>
+	</tutorials>
+</class>
diff --git a/doc_classes/JavaScriptModule.xml b/doc_classes/JavaScriptModule.xml
new file mode 100644
index 00000000..c9f1c7f9
--- /dev/null
+++ b/doc_classes/JavaScriptModule.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<class name="JavaScriptModule" inherits="Resource" version="4.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
+	<brief_description>
+		A JavaScript module resource for managing JavaScript source code and bytecode.
+	</brief_description>
+	<description>
+		The JavaScriptModule class provides methods to manage JavaScript source code and bytecode. It allows you to get and set both the source code and bytecode of a JavaScript module.
+	</description>
+	<tutorials>
+	</tutorials>
+	<methods>
+		<method name="get_bytecode" qualifiers="const">
+			<return type="PackedByteArray" />
+			<description>
+				Returns the bytecode of the JavaScript module as a PackedByteArray.
+			</description>
+		</method>
+		<method name="get_source_code" qualifiers="const">
+			<return type="String" />
+			<description>
+				Returns the source code of the JavaScript module as a String.
+			</description>
+		</method>
+		<method name="set_bytecode">
+			<return type="void" />
+			<param index="0" name="bytecode" type="PackedByteArray" />
+			<description>
+				Sets the bytecode of the JavaScript module using a PackedByteArray.
+			</description>
+		</method>
+		<method name="set_source_code">
+			<return type="void" />
+			<param index="0" name="source_code" type="String" />
+			<description>
+				Sets the source code of the JavaScript module using a String.
+			</description>
+		</method>
+	</methods>
+	<members>
+		<member name="script_path" type="String" setter="set_script_path" getter="get_script_path" default="&quot;&quot;">
+			The path to the JavaScript script file.
+		</member>
+	</members>
+</class>
diff --git a/quickjs/quickjs_callable.cpp b/quickjs/quickjs_callable.cpp
index 24799d7e..7f8cef8e 100644
--- a/quickjs/quickjs_callable.cpp
+++ b/quickjs/quickjs_callable.cpp
@@ -1,7 +1,7 @@
 #include "quickjs_callable.h"
 #include "../javascript_language.h"
 #include "quickjs/quickjs.h"
-#include "quickjs_binder.h"
+#include "../../quickjs_binder.h"
 
 bool QuickJSCallable::compare_equal(const CallableCustom *p_a, const CallableCustom *p_b) {
 	const QuickJSCallable *a = static_cast<const QuickJSCallable *>(p_a);
diff --git a/tests/UnitTest.js.disable b/tests/UnitTest.js.disable
deleted file mode 100644
index c9699d38..00000000
--- a/tests/UnitTest.js.disable
+++ /dev/null
@@ -1,100 +0,0 @@
-// @ts-nocheck
-const TEST_ENTRIES = new Map();
-
-
-test('godot', typeof godot === 'object', 'core');
-test('new Object', () => {
-	let obj = new godot.Object();
-	let ok = obj && obj instanceof godot.Object;
-	obj.free();
-	return ok;
-}, 'core');
-
-test('new Resource', () => {
-	let obj = new godot.Resource();
-	let ok = obj && obj.get_class() === 'Resource';
-	return ok;
-}, 'core');
-
-test('Object.prototype.get_class', () => {
-	let obj = new godot.Object();
-	let ok = obj.get_class() === 'Object';
-	obj.free();
-	return ok;
-}, 'core')
-
-test('Object.prototype.connect', () => {
-	let ok = typeof godot.Object.prototype.connect === 'function';
-	if (!ok) return ok;
-
-	let obj = new godot.Object();
-	obj.connect('script_changed', (...args)=> {
-		console.log(`signal 'script_changed' emited with:`, ...args);
-		ok = true;
-	});
-	obj.emit_signal('script_changed', 123, 'hello');
-	obj.free();
-	return ok;
-}, 'core')
-
-
-// --------------------------- Unit Test Implementation ------------------------
-function test(description, blcok, group = 'default') {
-	const entries = TEST_ENTRIES.get(group) || [];
-	entries.push({ description, blcok });
-	TEST_ENTRIES.set(group, entries);
-}
-function runEntry(entry) {
-	return new Promise((resolve, reject) => {
-		switch (typeof (entry.blcok)) {
-			case 'boolean':
-				return resolve(entry.blcok);
-			case 'function': {
-				try {
-					resolve(entry.blcok());
-				} catch (error) {
-					console.error(error);
-					resolve(false);
-				}
-			}
-			break;
-			case 'object':
-				if (entry.blcok instanceof Promise) {
-					entry.blcok.then(() => {
-						resolve(true);
-					}).catch(err => {
-						resolve(false);
-					});
-				}
-				break;
-			default:
-				return resolve(false);
-		}
-	});
-}
-async function run() {
-	let count = 0;
-	let passed = 0;
-	for (const [group, entries] of TEST_ENTRIES) {
-		console.log(`Start test ${group}`);
-		count += entries.length;
-		let groupCount = 0;
-		for (let i = 0; i < entries.length; i++) {
-			const entry = entries[i];
-			const ret = await runEntry(entry);
-			if (ret) {
-				passed++;
-				groupCount++;
-				console.log(`\t[${i + 1}/${entries.length}][ √ ] ${entry.description}`);
-			}
-			else {
-				console.error(`\t[${i + 1}/${entries.length}][ X ] ${entry.description}`);
-			}
-		}
-		const logFunc2 = groupCount == entries.length ? console.log : console.warn;
-		logFunc2(`\tTest ${group} finished: ${groupCount}/${entries.length} passed`);
-	}
-	const logFunc = passed == count ? console.log : console.warn;
-	logFunc(`Test complete: ${passed}/${count} passed`);
-}
-const _ = run(); // QuickJS BUG ? 返回的是一个 Promise 对象，不赋给临时变量，会导致 Promise 对象无法被 GC
diff --git a/thirdparty/quickjs/builtin_binding_generator.py b/thirdparty/quickjs/builtin_binding_generator.py
index 9bbfa90d..2ca05276 100644
--- a/thirdparty/quickjs/builtin_binding_generator.py
+++ b/thirdparty/quickjs/builtin_binding_generator.py
@@ -552,70 +552,70 @@ def generate_members(cls):
             Template,
             {"class": class_name, "getters": getters, "setters": setters, "bindings": bindings, "validation": ""},
         )
-
     def generate_methods(cls):
-        TemplateMethod = """
-	binder->get_builtin_binder().register_method(
-		${type},
-		"${name}",
-		[](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-			JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
-			${class} *ptr = bind->get${class}();\
-${arg_declares}
-			${call}
-			return ${return};
-		},
-		${argc});"""
-        TemplateArgDeclare = """
-#ifdef DEBUG_METHODS_ENABLED
-			ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, ${type}, argv[${index}]), (JS_ThrowTypeError(ctx, "${type_name} expected for argument ${index} of ${class}.${name}")));
-#endif
-			const ${godot_type} &arg${index} = ${arg};
-"""
-        TemplateReturnValue = "${godot_type} ret = "
-        bindings = ""
-        for m in cls["methods"]:
-            args = ""
-            arg_declares = ""
-            for i in range(len(m["arguments"])):
-                arg = m["arguments"][i]
-                arg_type = arg["type"]
-                arg_declares += apply_pattern(
-                    TemplateArgDeclare,
+            TemplateMethod = """
+        binder->get_builtin_binder().register_method(
+            ${type},
+            "${name}",
+            [](JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
+                JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+                ${class} *ptr = bind->get${class}();\
+        ${arg_declares}
+                ${call}
+                return ${return};
+            },
+            ${argc});"""
+            TemplateArgDeclare = """
+        #ifdef DEBUG_METHODS_ENABLED
+                ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, ${type}, argv[${index}]), JS_ThrowTypeError(ctx, "${type_name} expected for argument ${index} of ${class}.${name}"));
+        #endif
+                const ${godot_type} &arg${index} = ${arg};
+        """
+            TemplateReturnValue = "${godot_type} ret = "
+            bindings = ""
+            for m in cls["methods"]:
+                args = ""
+                arg_declares = ""
+                for i in range(len(m["arguments"])):
+                    arg = m["arguments"][i]
+                    arg_type = arg["type"]
+                    arg_declares += apply_pattern(
+                        TemplateArgDeclare,
+                        {
+                            "index": str(i),
+                            "type": VariantTypes[arg_type],
+                            "type_name": arg_type,
+                            "class": class_name,
+                            "name": m["name"],
+                            "arg": apply_pattern(JSToGodotTemplates[arg_type], {"arg": "argv[" + str(i) + "]"}),
+                            "godot_type": GodotTypeNames[arg_type],
+                        },
+                    )
+                    if i > 0:
+                        args += ", "
+                    args += "arg" + str(i)
+                CallTemplate = (
+                    ""
+                    if m["return"] == "void"
+                    else (apply_pattern(TemplateReturnValue, {"godot_type": GodotTypeNames[m["return"]]}))
+                ) + "ptr->${native_method}(${args});"
+                call = apply_pattern(CallTemplate, {"native_method": m["native_method"], "args": args})
+                bindings += apply_pattern(
+                    TemplateMethod,
                     {
-                        "index": str(i),
-                        "type": VariantTypes[arg_type],
-                        "type_name": arg_type,
                         "class": class_name,
+                        "type": VariantTypes[class_name],
                         "name": m["name"],
-                        "arg": apply_pattern(JSToGodotTemplates[arg_type], {"arg": "argv[" + str(i) + "]"}),
-                        "godot_type": GodotTypeNames[arg_type],
+                        "call": call,
+                        "arg_declares": arg_declares,
+                        "argc": str(len(m["arguments"])),
+                        "return": "JS_UNDEFINED"
+                        if m["return"] == "void"
+                        else apply_pattern(GodotToJSTemplates[m["return"]], {"arg": "ret"}),
                     },
                 )
-                if i > 0:
-                    args += ", "
-                args += "arg" + str(i)
-            CallTemplate = (
-                ""
-                if m["return"] == "void"
-                else (apply_pattern(TemplateReturnValue, {"godot_type": GodotTypeNames[m["return"]]}))
-            ) + "ptr->${native_method}(${args});"
-            call = apply_pattern(CallTemplate, {"native_method": m["native_method"], "args": args})
-            bindings += apply_pattern(
-                TemplateMethod,
-                {
-                    "class": class_name,
-                    "type": VariantTypes[class_name],
-                    "name": m["name"],
-                    "call": call,
-                    "arg_declares": arg_declares,
-                    "argc": str(len(m["arguments"])),
-                    "return": "JS_UNDEFINED"
-                    if m["return"] == "void"
-                    else apply_pattern(GodotToJSTemplates[m["return"]], {"arg": "ret"}),
-                },
-            )
-        return bindings
+            return bindings
+        
 
     def generate_constants(cls):
         ConstTemplate = '\tbinder->get_builtin_binder().register_constant(${type}, "${name}", ${value});\n'
diff --git a/thirdparty/quickjs/quickjs/cutils.c b/thirdparty/quickjs/quickjs/cutils.c
index b4960f9c..94dde37b 100644
--- a/thirdparty/quickjs/quickjs/cutils.c
+++ b/thirdparty/quickjs/quickjs/cutils.c
@@ -166,8 +166,7 @@ int dbuf_putstr(DynBuf *s, const char *str)
     return dbuf_put(s, (const uint8_t *)str, strlen(str));
 }
 
-int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
-                                                      const char *fmt, ...)
+int dbuf_printf(DynBuf *s, const char *fmt, ...)
 {
     va_list ap;
     char buf[128];
diff --git a/thirdparty/quickjs/quickjs/cutils.h b/thirdparty/quickjs/quickjs/cutils.h
index e7d500fc..09be07a9 100644
--- a/thirdparty/quickjs/quickjs/cutils.h
+++ b/thirdparty/quickjs/quickjs/cutils.h
@@ -31,11 +31,19 @@
 /* set if CPU is big endian */
 #undef WORDS_BIGENDIAN
 
+#if defined(_MSC_VER) || !defined(__MINGW32__)
+#define likely(x)       (x)
+#define unlikely(x)     (x)
+#define force_inline __forceinline
+#define no_inline __declspec(noinline)
+#define __maybe_unused __pragma(warning(suppress: 4100))
+#else
 #define likely(x)       __builtin_expect(!!(x), 1)
 #define unlikely(x)     __builtin_expect(!!(x), 0)
 #define force_inline inline __attribute__((always_inline))
 #define no_inline __attribute__((noinline))
 #define __maybe_unused __attribute__((unused))
+#endif
 
 #define xglue(x, y) x ## y
 #define glue(x, y) xglue(x, y)
@@ -135,18 +143,35 @@ static inline int ctz64(uint64_t a)
     return __builtin_ctzll(a);
 }
 
-struct __attribute__((packed)) packed_u64 {
-    uint64_t v;
-};
-
-struct __attribute__((packed)) packed_u32 {
-    uint32_t v;
-};
-
-struct __attribute__((packed)) packed_u16 {
-    uint16_t v;
-};
-
+#ifdef _MSC_VER
+#pragma pack(push, 1)
+    struct packed_u64 {
+        uint64_t v;
+    };
+#pragma pack(pop)
+
+#pragma pack(push, 1)
+    struct packed_u32 {
+        uint32_t v;
+    };
+#pragma pack(pop)
+
+#pragma pack(push, 1)
+    struct packed_u16 {
+        uint16_t v;
+    };
+    #pragma pack(pop)
+#else
+    struct __attribute__((packed)) packed_u64 {
+        uint64_t v;
+    };
+    struct __attribute__((packed)) packed_u32 {
+        uint32_t v;
+    };
+    struct __attribute__((packed)) packed_u16 {
+        uint16_t v;
+    };
+#endif
 static inline uint64_t get_u64(const uint8_t *tab)
 {
     return ((const struct packed_u64 *)tab)->v;
@@ -262,8 +287,9 @@ static inline int dbuf_put_u64(DynBuf *s, uint64_t val)
 {
     return dbuf_put(s, (uint8_t *)&val, 8);
 }
-int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
-                                                      const char *fmt, ...);
+
+int dbuf_printf(DynBuf *s, const char *fmt, ...);
+
 void dbuf_free(DynBuf *s);
 static inline BOOL dbuf_error(DynBuf *s) {
     return s->error;
diff --git a/thirdparty/quickjs/quickjs/libregexp.c b/thirdparty/quickjs/quickjs/libregexp.c
index 7368b32b..1bac3e51 100644
--- a/thirdparty/quickjs/quickjs/libregexp.c
+++ b/thirdparty/quickjs/quickjs/libregexp.c
@@ -427,7 +427,16 @@ static void re_emit_op_u16(REParseState *s, int op, uint32_t val)
     dbuf_put_u16(&s->byte_code, val);
 }
 
-static int __attribute__((format(printf, 2, 3))) re_parse_error(REParseState *s, const char *fmt, ...)
+#include <stdarg.h>
+#include <stdio.h>
+
+#ifdef _MSC_VER
+#define ATTRIBUTE_FORMAT_PRINTF _Printf_format_string_
+#else
+#define ATTRIBUTE_FORMAT_PRINTF __attribute__((format(printf, 2, 3)))
+#endif
+
+static int ATTRIBUTE_FORMAT_PRINTF re_parse_error(REParseState *s, const char *fmt, ...)
 {
     va_list ap;
     va_start(ap, fmt);
diff --git a/thirdparty/quickjs/quickjs/quickjs.h b/thirdparty/quickjs/quickjs/quickjs.h
index 27dc7f12..6d130152 100644
--- a/thirdparty/quickjs/quickjs/quickjs.h
+++ b/thirdparty/quickjs/quickjs/quickjs.h
@@ -32,6 +32,12 @@
 extern "C" {
 #endif
 
+#ifdef _MSC_VER
+#define INLINE_FUNC __forceinline
+#else
+#define INLINE_FUNC inline
+#endif
+
 #if defined(__GNUC__) || defined(__clang__)
 #define js_likely(x)          __builtin_expect(!!(x), 1)
 #define js_unlikely(x)        __builtin_expect(!!(x), 0)
@@ -40,7 +46,7 @@ extern "C" {
 #else
 #define js_likely(x)     (x)
 #define js_unlikely(x)   (x)
-#define js_force_inline  inline
+#define js_force_inline  INLINE_FUNC
 #define __js_printf_like(a, b)
 #endif
 
diff --git a/thirdparty/quickjs/quickjs_binder.cpp b/thirdparty/quickjs/quickjs_binder.cpp
new file mode 100644
index 00000000..9093c398
--- /dev/null
+++ b/thirdparty/quickjs/quickjs_binder.cpp
@@ -0,0 +1,2340 @@
+#include "core/config/engine.h"
+#include "core/config/project_settings.h"
+#include "core/core_bind.h"
+#include "core/core_constants.h"
+#include "core/io/file_access.h"
+#include "core/io/json.h"
+#include "core/math/expression.h"
+#include "core/os/os.h"
+
+#ifdef TOOLS_ENABLED
+#include "editor/editor_settings.h"
+#endif
+
+#include "javascript.h"
+#include "javascript_instance.h"
+#include "javascript_language.h"
+#include "quickjs_binder.h"
+#include "quickjs_callable.h"
+#include "quickjs_worker.h"
+
+
+#include <cstring>
+
+SafeNumeric<uint32_t> QuickJSBinder::global_context_id;
+SafeNumeric<uint64_t> QuickJSBinder::global_transfer_id;
+
+HashMap<uint64_t, Variant> QuickJSBinder::transfer_deopot;
+HashMap<String, const char *> QuickJSBinder::class_remap;
+List<String> compiling_modules;
+
+struct GodotMethodArguments {
+	Variant *arguments;
+	const Variant **ptr;
+	GodotMethodArguments(int argc) {
+		if (argc) {
+			arguments = memnew_arr(Variant, argc);
+			ptr = memnew_arr(const Variant *, argc);
+			for (int i = 0; i < argc; i++) {
+				ptr[i] = &arguments[i];
+			}
+		} else {
+			arguments = NULL;
+			ptr = NULL;
+		}
+	}
+	~GodotMethodArguments() {
+		if (ptr)
+			memdelete_arr(ptr);
+		if (arguments)
+			memdelete_arr(arguments);
+	}
+};
+
+_FORCE_INLINE_ static JavaScriptGCHandler *BINDING_DATA_FROM_GD(Object *p_object) {
+	ERR_FAIL_COND_V(p_object == NULL, NULL);
+	JavaScriptLanguage *lang = JavaScriptLanguage::get_singleton();
+	JavaScriptGCHandler *bind = (JavaScriptGCHandler *)(p_object)->get_instance_binding(lang, lang->get_instance_binding_callbacks());
+	return bind;
+}
+
+_FORCE_INLINE_ static JavaScriptGCHandler *BINDING_DATA_FROM_GD(JSContext *ctx, Object *p_object) {
+	ERR_FAIL_COND_V(p_object == NULL || ctx == NULL, NULL);
+	JavaScriptGCHandler *bind = BINDING_DATA_FROM_GD(p_object);
+	if (bind) {
+		if (bind->context && bind->context != ctx) {
+			ERR_FAIL_V_MSG(NULL, "The object is not belong to this context");
+		}
+		if (!bind->context) {
+			QuickJSBinder::bind_gc_object(ctx, bind, p_object);
+		}
+	}
+	return bind;
+}
+
+JSValue QuickJSBinder::console_functions(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic) {
+	PackedStringArray args;
+	args.resize(argc);
+
+	QuickJSBinder *binder = get_context_binder(ctx);
+	JSValue object_to_json = JS_GetPropertyStr(ctx, binder->console_object, PROP_NAME_CONSOLE_LOG_OBJECT_TO_JSON);
+	bool to_json = js_to_bool(ctx, object_to_json);
+	JS_FreeValue(ctx, object_to_json);
+
+	for (int i = 0; i < argc; ++i) {
+		int32_t tag = JS_VALUE_GET_TAG(argv[i]);
+		if (to_json && tag == JS_TAG_OBJECT && NULL == BINDING_DATA_FROM_JS(ctx, argv[i])) {
+			JSValue str = JS_JSONStringify(ctx, argv[i], JS_UNDEFINED, JS_UNDEFINED);
+			args.write[i] = js_to_string(ctx, str);
+			JS_FreeValue(ctx, str);
+		} else {
+			size_t size;
+			const char *utf8 = JS_ToCStringLen(ctx, &size, argv[i]);
+			args.write[i].parse_utf8(utf8, size);
+			JS_FreeCString(ctx, utf8);
+		}
+	}
+
+	JavaScriptStackInfo stack_top;
+	List<JavaScriptStackInfo> stacks;
+	String message = "";
+	for (int i = 0; i < argc; ++i) {
+		message += args[i];
+		if (i < argc - 1) {
+			message += " ";
+		}
+	}
+
+	if (magic == CONSOLE_ERROR || magic == CONSOLE_TRACE || magic == CONSOLE_WARN) {
+		if (binder->get_stacks(stacks) == OK) {
+			stack_top = stacks.front()->get();
+			message += ENDL;
+			message += binder->get_backtrace_message(stacks);
+		}
+	}
+
+	switch (magic) {
+		case CONSOLE_ERROR:
+			_err_print_error(stack_top.function.utf8().get_data(), stack_top.file.utf8().get_data(), stack_top.line, message, ErrorHandlerType::ERR_HANDLER_ERROR);
+			break;
+		case CONSOLE_WARN:
+			_err_print_error(stack_top.function.utf8().get_data(), stack_top.file.utf8().get_data(), stack_top.line, message, ErrorHandlerType::ERR_HANDLER_WARNING);
+			break;
+		case CONSOLE_LOG:
+		case CONSOLE_TRACE:
+		default:
+			print_line(message);
+			break;
+	}
+	return JS_UNDEFINED;
+}
+
+void QuickJSBinder::add_global_console() {
+	JSValue console = JS_NewObject(ctx);
+	JSValue log = JS_NewCFunctionMagic(ctx, console_functions, "log", 0, JS_CFUNC_generic_magic, CONSOLE_LOG);
+	JSValue warn = JS_NewCFunctionMagic(ctx, console_functions, "warn", 0, JS_CFUNC_generic_magic, CONSOLE_WARN);
+	JSValue err = JS_NewCFunctionMagic(ctx, console_functions, "error", 0, JS_CFUNC_generic_magic, CONSOLE_ERROR);
+	JSValue trace = JS_NewCFunctionMagic(ctx, console_functions, "trace", 0, JS_CFUNC_generic_magic, CONSOLE_TRACE);
+	JS_DefinePropertyValueStr(ctx, global_object, "console", console, PROP_DEF_DEFAULT);
+	JS_DefinePropertyValueStr(ctx, console, "log", log, PROP_DEF_DEFAULT);
+	JS_DefinePropertyValueStr(ctx, console, "warn", warn, PROP_DEF_DEFAULT);
+	JS_DefinePropertyValueStr(ctx, console, "error", err, PROP_DEF_DEFAULT);
+	JS_DefinePropertyValueStr(ctx, console, "trace", trace, PROP_DEF_DEFAULT);
+	console_object = JS_DupValue(ctx, console);
+}
+
+void QuickJSBinder::add_global_properties() {
+	// globalThis.requestAnimationFrame
+	JSValue js_func_requestAnimationFrame = JS_NewCFunction(ctx, global_request_animation_frame, "requestAnimationFrame", 1);
+	JS_DefinePropertyValueStr(ctx, global_object, "requestAnimationFrame", js_func_requestAnimationFrame, PROP_DEF_DEFAULT);
+	// globalThis.cancelAnimationFrame
+	JSValue js_func_cancelAnimationFrame = JS_NewCFunction(ctx, global_cancel_animation_frame, "cancelAnimationFrame", 1);
+	JS_DefinePropertyValueStr(ctx, global_object, "cancelAnimationFrame", js_func_cancelAnimationFrame, PROP_DEF_DEFAULT);
+}
+
+JSValue QuickJSBinder::object_method(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int method_id) {
+	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+	ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "Call native method without native binding data"));
+	ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "Call native method without native object caller"));
+
+	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
+	Object *obj = bind->get_godot_object();
+	MethodBind *mb = binder->godot_methods[method_id];
+
+	if (!mb->is_vararg()) {
+		argc = MIN(argc, mb->get_argument_count());
+	}
+
+	GodotMethodArguments args(argc);
+	for (int i = 0; i < argc; ++i) {
+		args.arguments[i] = var_to_variant(ctx, argv[i]);
+	}
+
+	Callable::CallError call_err;
+	Variant ret_val = mb->call(obj, args.ptr, argc, call_err);
+	JSValue ret = variant_to_var(ctx, ret_val);
+#ifdef DEBUG_METHODS_ENABLED
+	String err_message;
+	switch (call_err.error) {
+		case Callable::CallError::CALL_ERROR_INVALID_ARGUMENT:
+			err_message = vformat("Argument of type '%s' is not assignable to parameter #%d of type '%s'", Variant::get_type_name(args.arguments[call_err.argument].get_type()), call_err.argument, Variant::get_type_name((Variant::Type)call_err.expected));
+			break;
+		case Callable::CallError::CALL_ERROR_INVALID_METHOD:
+			err_message = vformat("Invalid method '%s' for type '%s'", mb->get_name(), obj->get_class_name());
+			break;
+		case Callable::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
+			err_message = vformat("Too few arguments for method '%s'", mb->get_name());
+			break;
+		case Callable::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:
+			err_message = vformat("Too many arguments for method '%s'", mb->get_name());
+			break;
+		case Callable::CallError::CALL_ERROR_INSTANCE_IS_NULL:
+			err_message = vformat("Attempt to call '%s' on a null instance.", mb->get_name());
+			break;
+		default:
+			break;
+	}
+	if (call_err.error != Callable::CallError::CALL_OK) {
+		List<JavaScriptStackInfo> stacks;
+		String stack_message;
+		if (binder->get_stacks(stacks) == OK) {
+			stack_message = binder->get_backtrace_message(stacks);
+		}
+		ERR_PRINT(obj->get_class() + "." + mb->get_name() + ENDL + err_message + ENDL + stack_message);
+		JS_FreeValue(ctx, ret);
+		ret = JS_ThrowTypeError(ctx, "%s", err_message.utf8().get_data());
+	}
+#endif
+
+	return ret;
+}
+
+JSValue QuickJSBinder::object_indexed_property(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int property_id) {
+	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+	ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "Using indexed property without native binding data"));
+	ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "Using indexed property without native object caller"));
+
+	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
+	bool is_setter = argc > 0;
+
+	Object *obj = bind->get_godot_object();
+	const ClassDB::PropertySetGet *prop = binder->godot_object_indexed_properties[property_id];
+	MethodBind *mb = is_setter ? prop->_setptr : prop->_getptr;
+
+	GodotMethodArguments args(2);
+	args.arguments[0] = prop->index;
+	if (is_setter) {
+		args.arguments[1] = var_to_variant(ctx, argv[0]);
+	}
+
+	Callable::CallError call_err;
+	Variant ret_val = mb->call(obj, args.ptr, argc + 1, call_err);
+	return variant_to_var(ctx, ret_val);
+}
+
+JSValue QuickJSBinder::variant_to_var(JSContext *ctx, const Variant p_var) {
+	switch (p_var.get_type()) {
+		case Variant::BOOL:
+			return ((bool)p_var) ? JS_TRUE : JS_FALSE;
+		case Variant::INT:
+			return JS_NewInt64(ctx, int64_t(p_var));
+		case Variant::FLOAT:
+			return JS_NewFloat64(ctx, (double)(p_var));
+		case Variant::NODE_PATH:
+		case Variant::STRING:
+			return to_js_string(ctx, p_var);
+		case Variant::OBJECT: {
+			Object *obj = p_var;
+			if (obj == NULL)
+				return JS_NULL;
+			JavaScriptGCHandler *data = BINDING_DATA_FROM_GD(ctx, obj);
+			ERR_FAIL_NULL_V(data, JS_UNDEFINED);
+			ERR_FAIL_NULL_V(data->javascript_object, JS_UNDEFINED);
+			ERR_FAIL_COND_V(data->context != ctx, (JS_UNDEFINED));
+			JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, data->javascript_object);
+			JS_DupValue(ctx, js_obj);
+
+			return js_obj;
+		}
+		case Variant::ARRAY: {
+			Array arr = p_var;
+			JSValue js_arr = JS_NewArray(ctx);
+			for (int i = 0; i < arr.size(); i++) {
+				JS_SetPropertyUint32(ctx, js_arr, i, variant_to_var(ctx, arr[int(i)]));
+			}
+			return js_arr;
+		}
+		case Variant::DICTIONARY: {
+			Dictionary dict = static_cast<Dictionary>(p_var);
+			JSValue obj = JS_NewObject(ctx);
+			Array keys = dict.keys();
+			for (int i = 0; i < keys.size(); i++) {
+				const Variant &key = keys[i];
+				const Variant &value = dict[key];
+				String key_str = keys[i];
+				JS_SetPropertyStr(ctx, obj, key_str.utf8().get_data(), variant_to_var(ctx, value));
+			}
+			return obj;
+		}
+		case Variant::NIL:
+			return JS_NULL;
+		default:
+			return QuickJSBuiltinBinder::new_object_from(ctx, p_var);
+	}
+}
+
+Variant QuickJSBinder::var_to_variant(JSContext *ctx, JSValue p_val) {
+	int64_t tag = JS_VALUE_GET_TAG(p_val);
+	switch (tag) {
+		case JS_TAG_INT:
+			return Variant(JS_VALUE_GET_INT(p_val));
+		case JS_TAG_BOOL:
+			return Variant(bool(JS_VALUE_GET_INT(p_val)));
+		case JS_TAG_FLOAT64:
+			return Variant(real_t(JS_VALUE_GET_FLOAT64(p_val)));
+		case JS_TAG_STRING:
+			return js_to_string(ctx, p_val);
+		case JS_TAG_OBJECT: {
+			if (JS_VALUE_GET_PTR(p_val) == NULL) {
+				return Variant();
+			}
+			int length = get_js_array_length(ctx, p_val);
+			if (length != -1) { // Array
+				Array arr;
+				arr.resize(length);
+				for (int i = 0; i < length; i++) {
+					JSValue val = JS_GetPropertyUint32(ctx, p_val, i);
+					arr[int(i)] = var_to_variant(ctx, val);
+					JS_FreeValue(ctx, val);
+				}
+				return arr;
+			} else if (JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, p_val)) { // Binding object
+				ERR_FAIL_NULL_V(bind, Variant());
+				ERR_FAIL_NULL_V(bind->godot_object, Variant());
+				return bind->get_value();
+			} else if (JS_IsFunction(ctx, p_val)) {
+				JSValue name = JS_GetProperty(ctx, p_val, JS_ATOM_name);
+				String ret = vformat("function %s() { ... }", js_to_string(ctx, name));
+				JS_FreeValue(ctx, name);
+				return ret;
+			} else { // Plain Object as Dictionary
+				List<void *> stack;
+				return js_to_dictionary(ctx, p_val, stack);
+			}
+		} break;
+		case JS_TAG_NULL:
+		case JS_TAG_UNDEFINED:
+			return Variant();
+			break;
+		default:
+#ifdef JS_NAN_BOXING
+			if (tag > JS_TAG_FLOAT64 || tag < JS_TAG_FIRST) {
+				return Variant(real_t(JS_VALUE_GET_FLOAT64(p_val)));
+			}
+#endif
+			return Variant();
+	}
+}
+
+JSValue QuickJSBinder::godot_builtin_function(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic) {
+	Variant ret;
+	Callable::CallError err;
+	String err_msg;
+#if 0 // TODO: builtin functions
+	Expression::BuiltinFunc func = (Expression::BuiltinFunc)magic;
+	int arg_required = Expression::get_func_argument_count(func);
+	if (argc < arg_required) {
+		String func_name = Expression::get_func_name(func);
+		return JS_ThrowTypeError(ctx, "%d arguments expected for builtin funtion %s", arg_required, func_name.ascii().get_data());
+	}
+
+	QuickJSBinder *binder = get_context_binder(ctx);
+	GodotMethodArguments args(argc);
+	for (int i = 0; i < argc; ++i) {
+		args.arguments[i] = var_to_variant(ctx, argv[i]);
+	}
+	Expression::exec_func(func, args.ptr, &ret, err, err_msg);
+#ifdef DEBUG_METHODS_ENABLED
+	if (err.error != Variant::CallError::CALL_OK) {
+		String func_name = Expression::get_func_name(func);
+		if (err_msg.empty()) {
+			switch (err.error) {
+				case Variant::CallError::CALL_ERROR_INVALID_ARGUMENT:
+					err_msg = vformat("Argument of type '%s' is not assignable to parameter #%d of type '%s'", Variant::get_type_name(args.arguments[err.argument].get_type()), err.argument, Variant::get_type_name(err.expected));
+					break;
+				case Variant::CallError::CALL_ERROR_INVALID_METHOD:
+					err_msg = vformat("Invalid builtin function", func_name);
+					break;
+				case Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS:
+					err_msg = vformat("Too few arguments builtin function", func_name);
+					break;
+				case Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS:
+					err_msg = vformat("Too many arguments for builtin function", func_name);
+					break;
+				default:
+					break;
+			}
+		}
+	}
+#endif
+
+	if (err.error != Variant::CallError::CALL_OK) {
+		String func_name = Expression::get_func_name(func);
+		return JS_ThrowTypeError(ctx, "Call builtin function error %s: %s", func_name.ascii().get_data(), err_msg.utf8().get_data());
+	}
+
+#endif
+
+	return variant_to_var(ctx, ret);
+}
+
+bool QuickJSBinder::validate_type(JSContext *ctx, Variant::Type p_type, JSValueConst &p_val) {
+	switch (p_type) {
+		case Variant::NIL:
+			return JS_IsNull(p_val) || JS_IsUndefined(p_val);
+		case Variant::BOOL:
+		case Variant::INT:
+		case Variant::FLOAT:
+			return JS_IsNumber(p_val) || JS_IsBool(p_val) || JS_IsNull(p_val) || JS_IsUndefined(p_val);
+		case Variant::STRING:
+			return JS_IsString(p_val);
+		case Variant::DICTIONARY:
+			return JS_IsObject(p_val);
+		case Variant::ARRAY:
+			return JS_IsArray(ctx, p_val);
+		default: {
+			JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, p_val);
+			return bind != NULL && bind->type == p_type;
+		}
+	}
+}
+
+void QuickJSBinder::dump_exception(JSContext *ctx, const JSValue &p_exception, JavaScriptError *r_error) {
+	JSValue err_file = JS_GetProperty(ctx, p_exception, JS_ATOM_fileName);
+	JSValue err_line = JS_GetProperty(ctx, p_exception, JS_ATOM_lineNumber);
+	JSValue err_msg = JS_GetProperty(ctx, p_exception, JS_ATOM_message);
+	JSValue err_stack = JS_GetProperty(ctx, p_exception, JS_ATOM_stack);
+
+	JS_ToInt32(ctx, &r_error->line, err_line);
+	r_error->message = js_to_string(ctx, err_msg);
+	r_error->file = js_to_string(ctx, err_file);
+	r_error->stack.push_back(js_to_string(ctx, err_stack));
+	r_error->column = 0;
+
+	JS_FreeValue(ctx, err_file);
+	JS_FreeValue(ctx, err_line);
+	JS_FreeValue(ctx, err_msg);
+	JS_FreeValue(ctx, err_stack);
+}
+
+String QuickJSBinder::error_to_string(const JavaScriptError &p_error) {
+	String message = "JavaScript Error";
+	if (p_error.stack.size()) {
+		message += p_error.stack[0];
+	}
+	message += p_error.message;
+	for (int i = 1; i < p_error.stack.size(); i++) {
+		message += p_error.stack[i];
+	}
+	return message;
+}
+
+Error QuickJSBinder::get_stacks(List<JavaScriptStackInfo> &r_stacks) {
+	JSValue error_constructor = JS_GetProperty(ctx, global_object, JS_ATOM_Error);
+	JSValue error = JS_CallConstructor(ctx, error_constructor, 0, NULL);
+	JSValue stack = JS_GetProperty(ctx, error, JS_ATOM_stack);
+	String stack_text = js_to_string(ctx, stack);
+	Vector<String> raw_stacks = stack_text.split("\n", false);
+	for (int i = 1; i < raw_stacks.size(); i++) {
+		String line_text = raw_stacks[i].strip_edges();
+		if (line_text.is_empty())
+			continue;
+		JavaScriptStackInfo s;
+		int colon = line_text.rfind(":");
+		int bracket = line_text.rfind("(");
+		s.line = line_text.substr(colon + 1, line_text.length() - colon - 2).to_int();
+		s.file = line_text.substr(bracket + 1, colon - bracket - 1);
+		s.function = line_text.substr(3, bracket - 4);
+		r_stacks.push_back(s);
+	}
+	JS_FreeValue(ctx, stack);
+	JS_FreeValue(ctx, error);
+	JS_FreeValue(ctx, error_constructor);
+	return OK;
+}
+
+String QuickJSBinder::get_backtrace_message(const List<JavaScriptStackInfo> &stacks) {
+	String message;
+	for (const List<JavaScriptStackInfo>::Element *E = stacks.front(); E; E = E->next()) {
+		message += "  ";
+		message += vformat("at %s (%s:%d)", E->get().function, E->get().file, E->get().line);
+		if (E != stacks.back()) {
+			message += ENDL;
+		}
+	}
+	return message;
+}
+
+Dictionary QuickJSBinder::js_to_dictionary(JSContext *ctx, const JSValue &p_val, List<void *> &stack) {
+	Dictionary dict;
+	HashSet<String> keys;
+	get_own_property_names(ctx, p_val, &keys);
+	stack.push_back(JS_VALUE_GET_PTR(p_val));
+	for (const String &key : keys) {
+		JSValue v = JS_GetPropertyStr(ctx, p_val, key.utf8().get_data());
+		Variant val;
+		if (JS_IsObject(v)) {
+			void *ptr = JS_VALUE_GET_PTR(v);
+			if (stack.find(ptr)) {
+				union {
+					const void *p;
+					uint64_t i;
+				} u;
+				u.p = ptr;
+				ERR_PRINT(vformat("Property '%s' circular reference to 0x%X", key, u.i));
+				JS_FreeValue(ctx, v);
+				continue;
+			} else {
+				stack.push_back(ptr);
+				val = var_to_variant(ctx, v);
+				stack.pop_back();
+			}
+		} else {
+			val = var_to_variant(ctx, v);
+		}
+		dict[key] = val;
+		JS_FreeValue(ctx, v);
+	}
+	stack.pop_back();
+	return dict;
+}
+
+JSAtom QuickJSBinder::get_atom(JSContext *ctx, const StringName &p_key) {
+	String name = p_key;
+	CharString name_str = name.ascii();
+	JSAtom atom = JS_NewAtom(ctx, name_str.get_data());
+	return atom;
+}
+
+JSValue QuickJSBinder::godot_to_string(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+	String str = var_to_variant(ctx, this_val);
+	CharString ascii = str.ascii();
+	return JS_NewStringLen(ctx, ascii.get_data(), ascii.length());
+}
+
+JSValue QuickJSBinder::godot_get_type(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+#ifdef DEBUG_METHODS_ENABLED
+	ERR_FAIL_COND_V(argc < 1, JS_ThrowTypeError(ctx, "parameter expected for %s.%s", GODOT_OBJECT_NAME, "get_type"));
+#endif
+	Variant value;
+	if (argc) {
+		value = var_to_variant(ctx, argv[0]);
+	}
+	return JS_NewInt32(ctx, value.get_type());
+}
+
+JSValue QuickJSBinder::godot_load(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+#ifdef DEBUG_METHODS_ENABLED
+	ERR_FAIL_COND_V(argc < 1 || !JS_IsString(argv[0]), JS_ThrowTypeError(ctx, "string expected for %s.%s", GODOT_OBJECT_NAME, "load"));
+#endif
+	String path = js_to_string(ctx, argv[0]);
+	Ref<Resource> res = ResourceLoader::load(path);
+	return variant_to_var(ctx, res);
+}
+
+JSValue QuickJSBinder::godot_instance_from_id(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+#ifdef DEBUG_METHODS_ENABLED
+	ERR_FAIL_COND_V(argc < 1 || !JS_IsNumber(argv[0]), JS_ThrowTypeError(ctx, "number expected for %s.%s", GODOT_OBJECT_NAME, "instance_from_id"));
+#endif
+	ObjectID id(js_to_uint64(ctx, argv[0]));
+	Object *obj = ObjectDB::get_instance(id);
+	return variant_to_var(ctx, obj);
+}
+
+JSValue QuickJSBinder::godot_object_method_connect(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+#ifdef DEBUG_METHODS_ENABLED
+	ERR_FAIL_COND_V(argc < 2 || !JS_IsString(argv[0]) || !JS_IsFunction(ctx, argv[1]), JS_ThrowTypeError(ctx, "string and function expected for %s.%s", "Object", "connect"));
+#endif
+	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
+	Object *obj = bind->get_godot_object();
+	StringName signal = binder->js_to_string(ctx, argv[0]);
+	Callable callable = memnew(QuickJSCallable(ctx, argv[1]));
+	obj->connect(signal, callable);
+	return JS_UNDEFINED;
+}
+
+void QuickJSBinder::add_debug_binding_info(JSContext *ctx, JSValueConst p_obj, const JavaScriptGCHandler *p_bind) {
+	if (!p_bind)
+		return;
+	JSValue classname = JS_UNDEFINED;
+	if (p_bind->type != Variant::OBJECT) {
+		classname = to_js_string(ctx, Variant::get_type_name(p_bind->type));
+	} else {
+		if (p_bind->is_object()) {
+			classname = to_js_string(ctx, p_bind->godot_object->get_class_name());
+		}
+	}
+
+	Array arr;
+	String ptr_str = "0x%X";
+	bool err;
+	union {
+		const void *p;
+		uint64_t i;
+	} u;
+	u.p = p_bind->godot_object;
+	arr.push_back(int(u.i));
+	ptr_str = ptr_str.sprintf(arr, &err);
+	JSValue ptrvalue = to_js_string(ctx, ptr_str);
+
+	u.p = ctx;
+	arr[0] = int(u.i);
+	ptr_str = "0x%X";
+	ptr_str = ptr_str.sprintf(arr, &err);
+	JSValue ptrctx = to_js_string(ctx, ptr_str);
+
+	JS_DefinePropertyValueStr(ctx, p_obj, "__class__", classname, PROP_DEF_DEFAULT);
+	JS_DefinePropertyValueStr(ctx, p_obj, "__ptr__", ptrvalue, PROP_DEF_DEFAULT);
+	JS_DefinePropertyValueStr(ctx, p_obj, "__ctx__", ptrctx, PROP_DEF_DEFAULT);
+}
+
+static HashMap<String, String> resolve_path_cache;
+
+String QuickJSBinder::resolve_module_file(const String &file) {
+	if (const String *ptr = resolve_path_cache.getptr(file)) {
+		return *ptr;
+	}
+	String path = file;
+	if (FileAccess::exists(path))
+		return path;
+	// add extensions to try
+	String extension = file.get_extension();
+	List<String> extensions;
+	JavaScriptLanguage::get_singleton()->get_recognized_extensions(&extensions);
+	if (extensions.find(extension) == NULL) {
+		for (List<String>::Element *E = extensions.front(); E; E = E->next()) {
+			path = file + "." + E->get();
+			if (FileAccess::exists(path)) {
+				return path;
+			}
+		}
+	}
+	// try index file under the folder
+	for (List<String>::Element *E = extensions.front(); E; E = E->next()) {
+		path = file + "/index." + E->get();
+		if (FileAccess::exists(path)) {
+			return path;
+		}
+	}
+	return "";
+}
+
+JSModuleDef *QuickJSBinder::js_module_loader(JSContext *ctx, const char *module_name, void *opaque) {
+	JSModuleDef *m = NULL;
+	Error err;
+
+	String resolving_file;
+	resolving_file.parse_utf8(module_name);
+
+	String file = resolve_module_file(resolving_file);
+	ERR_FAIL_COND_V_MSG(file.is_empty(), NULL, "Failed to resolve module: '" + resolving_file + "'.");
+	resolve_path_cache.insert(resolving_file, file);
+
+	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
+	if (ModuleCache *ptr = binder->module_cache.getptr(file)) {
+		m = ptr->module;
+	}
+
+	if (!m) {
+		List<String> extensions;
+		JavaScriptLanguage::get_singleton()->get_recognized_extensions(&extensions);
+		if (extensions.find(file.get_extension()) != NULL) {
+			Ref<JavaScriptModule> em = ResourceFormatLoaderJavaScriptModule::load_static(file, "", &err);
+			if (err != OK || !em.is_valid()) {
+				JS_ThrowReferenceError(ctx, "Could not load module '%s'", file.utf8().get_data());
+				return NULL;
+			}
+			JavaScriptError es_err;
+
+			const Vector<uint8_t> &bytecode = em->get_bytecode();
+			if (bytecode.size()) {
+				JavaScriptGCHandler js;
+				if (binder->load_bytecode(bytecode, file, &js) == OK) {
+					m = static_cast<JSModuleDef *>(js.javascript_object);
+				}
+			} else {
+				String code = em->get_source_code();
+				if (file.ends_with(EXT_JSON)) {
+					code = "export default " + code;
+				}
+				if (ModuleCache *module = binder->js_compile_and_cache_module(ctx, code, file, &es_err)) {
+					m = module->module;
+				}
+			}
+
+		} else { // Try load as Resource
+			Ref<Resource> res = ResourceLoader::load(file);
+			if (res.is_null()) {
+				JS_ThrowReferenceError(ctx, "Could not load module '%s'", file.utf8().get_data());
+				return NULL;
+			}
+			JSValue val = variant_to_var(ctx, res);
+			m = js_make_module(ctx, file, val);
+			JS_FreeValue(ctx, val);
+
+			ModuleCache module;
+			Variant hash_var = res;
+			module.hash = hash_var.hash();
+			module.module = m;
+			module.res = res;
+			module.res->reference(); // Avoid auto release as module don't release automaticly
+			module.res_value = val;
+			module.flags = MODULE_FLAG_RESOURCE;
+			module.module = m;
+			binder->module_cache.insert(file, module);
+		}
+	}
+
+	return m;
+}
+
+JSModuleDef *QuickJSBinder::js_make_module(JSContext *ctx, const String &p_id, const JSValue &p_value) {
+	JSModuleDef *m = JS_NewCModule(ctx, p_id.utf8().get_data(), resource_module_initializer);
+	JS_AddModuleExport(ctx, m, "default");
+	JSValue func = JS_MKPTR(JS_TAG_MODULE, m);
+	JS_DupValue(ctx, func);
+	JS_EvalFunction(ctx, func);
+	JS_SetModuleExport(ctx, m, "default", JS_DupValue(ctx, p_value));
+	return m;
+}
+
+QuickJSBinder::ModuleCache QuickJSBinder::js_compile_module(JSContext *ctx, const String &p_code, const String &p_filename, JavaScriptError *r_error) {
+	if (NULL != compiling_modules.find(p_filename)) {
+		String chain;
+		for (List<String>::Element *E = compiling_modules.front(); E; E = E->next()) {
+			chain += E->get();
+			if (E->next() != NULL) {
+				chain += " <- ";
+			}
+		}
+		ERR_FAIL_V_MSG(ModuleCache(), vformat("Cyclic module import detected:\r\n  %s", chain));
+	}
+
+	ModuleCache module;
+	module.flags = 0;
+	module.module = NULL;
+	module.hash = p_code.hash();
+
+	CharString code = p_code.utf8();
+	CharString filename = p_filename.utf8();
+	const char *cfilename = filename.get_data();
+	const char *cfilesource = code.get_data();
+
+	compiling_modules.push_back(p_filename);
+	JSValue func = JS_Eval(ctx, cfilesource, code.length(), cfilename, JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
+	compiling_modules.pop_back();
+
+	if (!JS_IsException(func)) {
+		module.flags = MODULE_FLAG_SCRIPT;
+		module.module = static_cast<JSModuleDef *>(JS_VALUE_GET_PTR(func));
+		module.res_value = JS_UNDEFINED;
+	} else {
+		JSValue e = JS_GetException(ctx);
+		dump_exception(ctx, e, r_error);
+		JS_Throw(ctx, e);
+	}
+
+	return module;
+}
+
+QuickJSBinder::ModuleCache *QuickJSBinder::js_compile_and_cache_module(JSContext *ctx, const String &p_code, const String &p_filename, JavaScriptError *r_error) {
+	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
+	ModuleCache *last_module = binder->module_cache.getptr(p_filename);
+	if (last_module) {
+		if (last_module->hash == p_code.hash()) {
+#if MODULE_HAS_REFCOUNT
+			if (last_module->module) {
+				JSValue val = JS_MKPTR(JS_TAG_MODULE, last_module->module);
+				JS_DupValue(ctx, val);
+			}
+#endif
+			return last_module;
+		} else {
+#if MODULE_HAS_REFCOUNT
+			JSModuleDef *m = last_module->module;
+			if (m) {
+				JSValue val = JS_MKPTR(JS_TAG_MODULE, m);
+				JS_FreeValue(ctx, val);
+			}
+#endif
+		}
+	}
+
+	ModuleCache mc = js_compile_module(ctx, p_code, p_filename, r_error);
+	mc.hash = p_code.hash();
+	if (mc.module) {
+		binder->module_cache.insert(p_filename, mc);
+	}
+	return binder->module_cache.getptr(p_filename);
+}
+
+QuickJSBinder::ModuleCache *QuickJSBinder::js_compile_and_cache_module(JSContext *ctx, const Vector<uint8_t> &p_bytecode, const String &p_filename, JavaScriptError *r_error) {
+	QuickJSBinder *binder = get_context_binder(ctx);
+	JavaScriptGCHandler module;
+	if (OK == binder->load_bytecode(p_bytecode, p_filename, &module)) {
+		return module_cache.getptr(p_filename);
+	}
+	return NULL;
+}
+
+Error QuickJSBinder::js_evalute_module(JSContext *ctx, QuickJSBinder::ModuleCache *p_module, JavaScriptError *r_error) {
+	if (p_module->flags & MODULE_FLAG_EVALUATED)
+		return OK;
+
+	JSValue module = JS_MKPTR(JS_TAG_MODULE, p_module->module);
+	if (JS_IsException(module)) {
+		JSValue e = JS_GetException(ctx);
+		dump_exception(ctx, e, r_error);
+		JS_Throw(ctx, e);
+		return ERR_PARSE_ERROR;
+	}
+
+	if (!(p_module->flags & MODULE_FLAG_EVALUATED)) {
+		JSValue ret = JS_EvalFunction(ctx, module);
+		if (JS_IsException(ret)) {
+			JSValue e = JS_GetException(ctx);
+			dump_exception(ctx, e, r_error);
+			JS_Throw(ctx, e);
+			return ERR_PARSE_ERROR;
+		} else {
+			p_module->flags |= MODULE_FLAG_EVALUATED;
+		}
+		JS_FreeValue(ctx, ret);
+	}
+
+	return OK;
+}
+
+int QuickJSBinder::resource_module_initializer(JSContext *ctx, JSModuleDef *m) {
+	return JS_SetModuleExport(ctx, m, "default", JS_UNDEFINED);
+}
+
+JSClassID QuickJSBinder::register_class(const ClassDB::ClassInfo *p_cls) {
+	ClassBindData data;
+	data.class_id = 0;
+	data.base_class = NULL;
+
+	if (class_remap.has(p_cls->name)) {
+		data.class_name = class_remap[p_cls->name];
+		data.jsclass.class_name = class_remap[p_cls->name];
+		if (strcmp(data.jsclass.class_name, "") == 0) {
+			return 0;
+		}
+	} else {
+		data.class_name = String(p_cls->name).ascii();
+		data.jsclass.class_name = data.class_name.get_data();
+	}
+
+	data.jsclass.exotic = NULL;
+	data.jsclass.gc_mark = NULL;
+	data.jsclass.call = NULL;
+	data.gdclass = p_cls;
+
+	data.prototype = JS_NewObject(ctx);
+
+	// methods
+	HashMap<StringName, JSValue> methods;
+	{
+		godot_methods.resize(internal_godot_method_id + p_cls->method_map.size());
+		for (const KeyValue<StringName, MethodBind *> &pair : p_cls->method_map) {
+			if (p_cls->name == "Object") {
+				const char *connect = "connect";
+				if (pair.key == connect) {
+					JSValue func = JS_NewCFunction(ctx, godot_object_method_connect, connect, 3);
+					JS_DefinePropertyValueStr(ctx, data.prototype, connect, func, PROP_DEF_DEFAULT);
+					continue;
+				}
+			}
+
+			MethodBind *mb = pair.value;
+			godot_methods.set(internal_godot_method_id, mb);
+			CharString name = String(pair.key).ascii();
+			JSValue method = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_method, name.get_data(), mb->get_argument_count(), JS_CFUNC_generic_magic, internal_godot_method_id);
+			JS_DefinePropertyValueStr(ctx, data.prototype, name.get_data(), method, PROP_DEF_DEFAULT);
+			methods.insert(pair.key, method);
+			++internal_godot_method_id;
+		}
+
+		if (p_cls->name == "Object") {
+			// toString()
+			JSValue to_string_func = JS_NewCFunction(ctx, godot_to_string, TO_STRING_LITERAL, 0);
+			JS_DefinePropertyValueStr(ctx, data.prototype, TO_STRING_LITERAL, to_string_func, PROP_DEF_DEFAULT);
+			// free()
+			const char *free_func_name = "free";
+			JSValue free_func = JS_NewCFunction(ctx, object_free, free_func_name, 0);
+			JS_DefinePropertyValueStr(ctx, data.prototype, free_func_name, free_func, PROP_DEF_DEFAULT);
+		}
+	}
+
+	// properties
+	{
+		for (const KeyValue<StringName, ClassDB::PropertySetGet> &i : p_cls->property_setget) {
+			const StringName &prop_name = i.key;
+			const ClassDB::PropertySetGet &prop = i.value;
+
+			JSValue setter = JS_UNDEFINED;
+			JSValue getter = JS_UNDEFINED;
+
+			if (prop.index >= 0) {
+				int size = godot_object_indexed_properties.size();
+				if (size <= internal_godot_indexed_property_id) {
+					godot_object_indexed_properties.resize(size + 128);
+				}
+				godot_object_indexed_properties.write[internal_godot_indexed_property_id] = &prop;
+				CharString name = String(prop_name).ascii();
+				getter = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_indexed_property, name.get_data(), 0, JS_CFUNC_generic_magic, internal_godot_indexed_property_id);
+				setter = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_indexed_property, name.get_data(), 1, JS_CFUNC_generic_magic, internal_godot_indexed_property_id);
+				++internal_godot_indexed_property_id;
+			} else {
+				if (HashMap<StringName, JSValue>::ConstIterator it = methods.find(prop.setter)) {
+					setter = it->value;
+					JS_DupValue(ctx, setter);
+				} else if (MethodBind *mb = prop._setptr) {
+					if (godot_methods.size() >= internal_godot_method_id) {
+						godot_methods.resize(godot_methods.size() + 1);
+					}
+					godot_methods.write[internal_godot_method_id] = mb;
+					String setter_name = prop.setter;
+					setter = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_method, setter_name.ascii().get_data(), mb->get_argument_count(), JS_CFUNC_generic_magic, internal_godot_method_id);
+					++internal_godot_method_id;
+				}
+
+				if (HashMap<StringName, JSValue>::ConstIterator it = methods.find(prop.getter)) {
+					getter = it->value;
+					JS_DupValue(ctx, getter);
+				} else if (MethodBind *mb = prop._getptr) {
+					if (godot_methods.size() >= internal_godot_method_id) {
+						godot_methods.resize(godot_methods.size() + 1);
+					}
+					godot_methods.write[internal_godot_method_id] = mb;
+					String getter_name = prop.getter;
+					getter = JS_NewCFunctionMagic(ctx, &QuickJSBinder::object_method, getter_name.ascii().get_data(), mb->get_argument_count(), JS_CFUNC_generic_magic, internal_godot_method_id);
+					++internal_godot_method_id;
+				}
+			}
+
+			JSAtom atom = get_atom(ctx, prop_name);
+			JS_DefinePropertyGetSet(ctx, data.prototype, atom, getter, setter, PROP_DEF_DEFAULT);
+			JS_FreeAtom(ctx, atom);
+		}
+	}
+
+	JS_NewClassID(&data.class_id);
+	JS_NewClass(JS_GetRuntime(ctx), data.class_id, &data.jsclass);
+	JS_SetClassProto(ctx, data.class_id, data.prototype);
+
+	data.constructor = JS_NewCFunctionMagic(ctx, object_constructor, data.jsclass.class_name, data.class_name.size(), JS_CFUNC_constructor_magic, (int)data.class_id);
+	JS_SetConstructor(ctx, data.constructor, data.prototype);
+	JS_DefinePropertyValue(ctx, data.prototype, js_key_godot_classid, JS_NewInt32(ctx, data.class_id), PROP_DEF_DEFAULT);
+	JS_DefinePropertyValue(ctx, data.constructor, js_key_godot_classid, JS_NewInt32(ctx, data.class_id), PROP_DEF_DEFAULT);
+
+	// constants
+	for (const KeyValue<StringName, int64_t> &pair : p_cls->constant_map) {
+		JSAtom atom = get_atom(ctx, pair.key);
+		JS_DefinePropertyValue(ctx, data.constructor, atom, JS_NewInt64(ctx, pair.value), PROP_DEF_DEFAULT);
+		JS_FreeAtom(ctx, atom);
+	}
+
+	// enumeration
+	for (const KeyValue<StringName, ClassDB::ClassInfo::EnumInfo> &pair : p_cls->enum_map) {
+		JSValue enum_obj = JS_NewObject(ctx);
+		JSAtom atom = get_atom(ctx, pair.key);
+
+		const List<StringName> &const_keys = pair.value.constants;
+		for (const List<StringName>::Element *E = const_keys.front(); E; E = E->next()) {
+			int value = p_cls->constant_map.get(E->get());
+			JSAtom atom_key = get_atom(ctx, E->get());
+			JS_DefinePropertyValue(ctx, enum_obj, atom_key, JS_NewInt32(ctx, value), PROP_DEF_DEFAULT);
+			JS_FreeAtom(ctx, atom_key);
+		}
+
+		JS_DefinePropertyValue(ctx, data.constructor, atom, enum_obj, PROP_DEF_DEFAULT);
+		JS_FreeAtom(ctx, atom);
+	}
+
+	// signals
+	for (const KeyValue<StringName, MethodInfo> &pair : p_cls->signal_map) {
+		JSAtom atom = get_atom(ctx, pair.key);
+		JS_DefinePropertyValue(ctx, data.constructor, atom, to_js_string(ctx, pair.key), PROP_DEF_DEFAULT);
+		JS_FreeAtom(ctx, atom);
+	}
+
+	class_bindings.insert(data.class_id, data);
+	classname_bindings.insert(p_cls->name, class_bindings.getptr(data.class_id));
+
+	return data.class_id;
+}
+
+void QuickJSBinder::add_godot_origin() {
+	godot_origin_class.class_id = 0;
+	godot_origin_class.class_name = "GodotOrigin";
+	godot_origin_class.jsclass.class_name = godot_origin_class.class_name.get_data();
+	godot_origin_class.jsclass.finalizer = origin_finalizer;
+	godot_origin_class.jsclass.exotic = NULL;
+	godot_origin_class.jsclass.call = NULL;
+	godot_origin_class.jsclass.gc_mark = NULL;
+	godot_origin_class.prototype = JS_NewObject(ctx);
+	godot_origin_class.gdclass = NULL;
+	godot_origin_class.base_class = NULL;
+	JS_NewClassID(&godot_origin_class.class_id);
+	JS_NewClass(JS_GetRuntime(ctx), godot_origin_class.class_id, &godot_origin_class.jsclass);
+	JS_SetClassProto(ctx, godot_origin_class.class_id, godot_origin_class.prototype);
+	godot_origin_class.constructor = JS_NewCFunction2(ctx, js_empty_consturctor, godot_origin_class.jsclass.class_name, 0, JS_CFUNC_constructor, 0);
+	JS_SetConstructor(ctx, godot_origin_class.constructor, godot_origin_class.prototype);
+	JS_DefinePropertyValueStr(ctx, godot_object, godot_origin_class.class_name, godot_origin_class.constructor, PROP_DEF_DEFAULT);
+}
+
+void QuickJSBinder::add_godot_classes() {
+	HashMap<const ClassDB::ClassInfo *, JSClassID> gdclass_jsmap;
+	// register classes
+	for (const KeyValue<StringName, ClassDB::ClassInfo> &pair : ClassDB::classes) {
+		const ClassDB::ClassInfo &cls = pair.value;
+		if (JSClassID id = register_class(&cls)) {
+			gdclass_jsmap.insert(&cls, id);
+		}
+	}
+
+	// Setup inherits chain
+	for (const KeyValue<const ClassDB::ClassInfo *, JSClassID> &pair : gdclass_jsmap) {
+		const ClassDB::ClassInfo *gdcls = pair.key;
+		ClassBindData &bind = class_bindings.get(pair.value);
+		if (gdcls->inherits_ptr) {
+			if (const HashMap<const ClassDB::ClassInfo *, JSClassID>::ConstIterator &base = gdclass_jsmap.find(gdcls->inherits_ptr)) {
+				bind.base_class = class_bindings.getptr(base->value);
+			}
+		}
+	}
+
+	// Setup the prototype chain
+	for (const KeyValue<JSClassID, ClassBindData> &pair : class_bindings) {
+		const ClassBindData &data = pair.value;
+		int flags = PROP_DEF_DEFAULT;
+		// Allows redefine as to global object
+		if (Engine::get_singleton()->has_singleton(data.gdclass->name)) {
+			flags |= JS_PROP_CONFIGURABLE;
+		}
+		JS_DefinePropertyValueStr(ctx, godot_object, data.jsclass.class_name, data.constructor, flags);
+		if (data.base_class) {
+			JS_SetPrototype(ctx, data.prototype, data.base_class->prototype);
+		} else {
+			JS_SetPrototype(ctx, data.prototype, godot_origin_class.prototype);
+		}
+	}
+
+	godot_object_class = *classname_bindings.getptr("Object");
+	godot_reference_class = *classname_bindings.getptr("RefCounted");
+}
+
+void QuickJSBinder::add_godot_globals() {
+	// Singletons
+	List<Engine::Singleton> singletons;
+	Engine::get_singleton()->get_singletons(&singletons);
+	for (List<Engine::Singleton>::Element *E = singletons.front(); E; E = E->next()) {
+		const Engine::Singleton &s = E->get();
+
+		ERR_CONTINUE(s.ptr == NULL);
+
+		const ClassBindData **cls_ptr = classname_bindings.getptr(s.ptr->get_class_name());
+		ERR_CONTINUE(cls_ptr == NULL);
+		const ClassBindData *cls = *cls_ptr;
+
+		JSValue obj = JS_NewObjectProtoClass(ctx, cls->prototype, get_origin_class_id());
+		JavaScriptGCHandler *data = new_gc_handler(ctx);
+		data->javascript_object = JS_VALUE_GET_PTR(obj);
+		data->godot_object = s.ptr;
+		data->type = Variant::OBJECT;
+		data->flags = JavaScriptGCHandler::FLAG_OBJECT;
+		JS_SetOpaque(obj, data);
+
+		JSAtom singleton_name = get_atom(ctx, s.name);
+		JSValue last_obj = JS_GetProperty(ctx, godot_object, singleton_name);
+		if (!JS_IsUndefined(last_obj)) {
+			JS_SetPrototype(ctx, obj, cls->prototype);
+			JS_FreeValue(ctx, last_obj);
+		}
+
+		JS_DupValue(ctx, obj);
+		JS_DefinePropertyValue(ctx, godot_object, singleton_name, obj, QuickJSBinder::PROP_DEF_DEFAULT);
+		JS_FreeAtom(ctx, singleton_name);
+		godot_singletons.push_back(obj);
+
+		ClassDB::ClassInfo *gdcls = ClassDB::classes.getptr(s.name);
+		gdcls = gdcls == NULL ? ClassDB::classes.getptr(s.ptr->get_class_name()) : gdcls;
+		if (gdcls) {
+			// constants
+			for (KeyValue<StringName, int64_t> &pair : gdcls->constant_map) {
+				JSAtom const_name = get_atom(ctx, pair.key);
+				JS_DefinePropertyValue(ctx, obj, const_name, JS_NewInt64(ctx, pair.value), QuickJSBinder::PROP_DEF_DEFAULT);
+				JS_FreeAtom(ctx, const_name);
+			}
+			// enumrations
+			for (const KeyValue<StringName, ClassDB::ClassInfo::EnumInfo> &pair : gdcls->enum_map) {
+				const List<StringName> &consts = pair.value.constants;
+				JSValue enum_obj = JS_NewObject(ctx);
+				for (const List<StringName>::Element *E2 = consts.front(); E2; E2 = E2->next()) {
+					JSAtom const_name = get_atom(ctx, E2->get());
+					JS_DefinePropertyValue(ctx, enum_obj, const_name, variant_to_var(ctx, gdcls->constant_map.get(E2->get())), QuickJSBinder::PROP_DEF_DEFAULT);
+					JS_FreeAtom(ctx, const_name);
+				}
+				JSAtom enum_name = get_atom(ctx, pair.key);
+				JS_DefinePropertyValue(ctx, obj, enum_name, enum_obj, QuickJSBinder::PROP_DEF_DEFAULT);
+				JS_FreeAtom(ctx, enum_name);
+			}
+		}
+	}
+
+	// global constants
+	HashMap<StringName, HashMap<StringName, int64_t>> global_constants;
+	for (int i = 0; i < CoreConstants::get_global_constant_count(); ++i) {
+		StringName enum_name = CoreConstants::get_global_constant_enum(i);
+		const char *const_name = CoreConstants::get_global_constant_name(i);
+		const int value = CoreConstants::get_global_constant_value(i);
+
+		JSAtom js_const_name = JS_NewAtom(ctx, const_name);
+		JS_DefinePropertyValue(ctx, godot_object, js_const_name, JS_MKVAL(JS_TAG_INT, value), QuickJSBinder::PROP_DEF_DEFAULT);
+		JS_FreeAtom(ctx, js_const_name);
+
+		if (HashMap<StringName, int64_t> *consts = global_constants.getptr(enum_name)) {
+			consts->insert(const_name, value);
+		} else {
+			HashMap<StringName, int64_t> enum_;
+			enum_.insert(const_name, value);
+			global_constants.insert(enum_name, enum_);
+		}
+	}
+	// global numbers
+	GlobalNumberConstant consts[] = {
+		{ "PI", Math_PI },
+		{ "TAU", Math_TAU },
+		{ "NAN", NAN },
+		{ "INF", INFINITY },
+		{ "E", Math_E },
+		{ "LN2", Math_LN2 },
+		{ "SQRT2", Math_SQRT2 },
+		{ "SQRT12", Math_SQRT12 },
+	};
+	for (uint32_t i = 0; i < sizeof(consts) / sizeof(GlobalNumberConstant); i++) {
+		const GlobalNumberConstant &c = consts[i];
+		JSAtom js_const_name = get_atom(ctx, c.name);
+		JS_DefinePropertyValue(ctx, godot_object, js_const_name, JS_NewFloat64(ctx, c.value), QuickJSBinder::PROP_DEF_DEFAULT);
+		JS_FreeAtom(ctx, js_const_name);
+	}
+
+	// global enums
+	for (const KeyValue<StringName, HashMap<StringName, int64_t>> &pair : global_constants) {
+		String enum_name_str = pair.key;
+		if (enum_name_str.is_empty())
+			continue;
+		enum_name_str = enum_name_str.replace(".", "");
+
+		JSAtom atom_enum_name = get_atom(ctx, enum_name_str);
+		JSValue enum_object = JS_NewObject(ctx);
+		JS_DefinePropertyValue(ctx, godot_object, atom_enum_name, enum_object, QuickJSBinder::PROP_DEF_DEFAULT);
+		JS_FreeAtom(ctx, atom_enum_name);
+
+		for (const KeyValue<StringName, int64_t> &c : pair.value) {
+			JSAtom js_const_name = get_atom(ctx, c.key);
+			JS_DefinePropertyValue(ctx, enum_object, js_const_name, JS_NewInt64(ctx, c.value), QuickJSBinder::PROP_DEF_DEFAULT);
+			JS_FreeAtom(ctx, js_const_name);
+		}
+	}
+
+#if 0
+	// builtin functions
+	for (int i = 0; i < Expression::FUNC_MAX; ++i) {
+		Expression::BuiltinFunc func = (Expression::BuiltinFunc)i;
+		String name = Expression::get_func_name(func);
+		JSValue js_func = JS_NewCFunctionMagic(ctx, godot_builtin_function, name.ascii().get_data(), 0, JS_CFUNC_generic_magic, i);
+		JSAtom atom = get_atom(ctx, name);
+		JS_DefinePropertyValue(ctx, godot_object, atom, js_func, QuickJSBinder::PROP_DEF_DEFAULT);
+		JS_FreeAtom(ctx, atom);
+	}
+#endif
+
+	// godot.register_class
+	JSValue js_func_register_class = JS_NewCFunction(ctx, godot_register_class, "register_class", 2);
+	JS_DefinePropertyValueStr(ctx, godot_object, "register_class", js_func_register_class, PROP_DEF_DEFAULT);
+	// godot.register_signal
+	JSValue js_func_register_signal = JS_NewCFunction(ctx, godot_register_signal, "register_signal", 2);
+	JS_DefinePropertyValueStr(ctx, godot_object, "register_signal", js_func_register_signal, PROP_DEF_DEFAULT);
+	// godot.register_property
+	JSValue js_func_register_property = JS_NewCFunction(ctx, godot_register_property, "register_property", 3);
+	JS_DefinePropertyValueStr(ctx, godot_object, "register_property", js_func_register_property, PROP_DEF_DEFAULT);
+	// godot.set_script_tooled
+	JSValue js_func_set_tooled = JS_NewCFunctionMagic(ctx, godot_set_script_meta, "set_script_tooled", 2, JS_CFUNC_generic_magic, QuickJSBinder::SCRIPT_META_TOOLED);
+	JS_DefinePropertyValueStr(ctx, godot_object, "set_script_tooled", js_func_set_tooled, PROP_DEF_DEFAULT);
+	// godot.set_script_icon
+	JSValue js_set_script_icon = JS_NewCFunctionMagic(ctx, godot_set_script_meta, "set_script_icon", 2, JS_CFUNC_generic_magic, QuickJSBinder::SCRIPT_META_ICON);
+	JS_DefinePropertyValueStr(ctx, godot_object, "set_script_icon", js_set_script_icon, PROP_DEF_DEFAULT);
+	// godot.get_type
+	JSValue js_get_type = JS_NewCFunction(ctx, godot_get_type, "get_type", 1);
+	JS_DefinePropertyValueStr(ctx, godot_object, "get_type", js_get_type, PROP_DEF_DEFAULT);
+	// godot.load
+	JSValue js_func_load = JS_NewCFunction(ctx, godot_load, "load", 1);
+	JS_DefinePropertyValueStr(ctx, godot_object, "load", js_func_load, PROP_DEF_DEFAULT);
+	// godot.instance_from_id
+	JSValue js_godot_instance_from_id = JS_NewCFunction(ctx, godot_instance_from_id, "instance_from_id", 1);
+	JS_DefinePropertyValueStr(ctx, godot_object, "instance_from_id", js_godot_instance_from_id, PROP_DEF_DEFAULT);
+
+	// godot.abandon_value
+	JSValue abandon_value_func = JS_NewCFunction(ctx, godot_abandon_value, "abandon_value", 1);
+	JS_DefinePropertyValueStr(ctx, godot_object, "abandon_value", abandon_value_func, PROP_DEF_DEFAULT);
+	// godot.adopt_value
+	JSValue adopt_value_func = JS_NewCFunction(ctx, godot_adopt_value, "adopt_value", 1);
+	JS_DefinePropertyValueStr(ctx, godot_object, "adopt_value", adopt_value_func, PROP_DEF_DEFAULT);
+
+	{
+		// godot.DEBUG_ENABLED
+#ifdef DEBUG_ENABLED
+		JS_DefinePropertyValueStr(ctx, godot_object, "DEBUG_ENABLED", JS_TRUE, JS_PROP_ENUMERABLE);
+#endif
+		// godot.TOOLS_ENABLED
+#ifdef TOOLS_ENABLED
+		JS_DefinePropertyValueStr(ctx, godot_object, "TOOLS_ENABLED", JS_TRUE, JS_PROP_ENUMERABLE);
+#endif
+#ifdef DEBUG_METHODS_ENABLED
+		// godot.DEBUG_METHODS_ENABLED
+		JS_DefinePropertyValueStr(ctx, godot_object, "DEBUG_METHODS_ENABLED", JS_TRUE, JS_PROP_ENUMERABLE);
+#endif
+	}
+}
+
+void QuickJSBinder::initialize() {
+	thread_id = Thread::get_caller_id();
+	{
+		GLOBAL_LOCK_FUNCTION
+		JavaScriptLanguage::get_singleton()->thread_binder_map.insert(thread_id, this);
+	}
+
+	// create runtime and context for the binder
+	runtime = JS_NewRuntime2(&godot_allocator, this);
+	ctx = JS_NewContext(runtime);
+	JS_AddIntrinsicOperators(ctx);
+
+	JS_SetModuleLoaderFunc(runtime, /*js_module_resolve*/ NULL, js_module_loader, this);
+	JS_SetContextOpaque(ctx, this);
+
+	empty_function = JS_NewCFunction(ctx, js_empty_func, "virtual_fuction", 0);
+	// global = globalThis
+	global_object = JS_GetGlobalObject(ctx);
+	// globalThis.Operators.create
+	js_operators = JS_GetProperty(ctx, global_object, JS_ATOM_Operators);
+	js_operators_create = JS_GetPropertyStr(ctx, js_operators, "create");
+	// global.godot
+	godot_object = JS_NewObject(ctx);
+	js_key_godot_classid = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("native_class"));
+	js_key_godot_classname = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("js_class"));
+	js_key_godot_exports = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("exports"));
+	js_key_godot_signals = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("signals"));
+	js_key_godot_tooled = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("tool"));
+	js_key_godot_icon_path = JS_NewAtom(ctx, JS_HIDDEN_SYMBOL("icon"));
+	JS_DefinePropertyValueStr(ctx, global_object, GODOT_OBJECT_NAME, godot_object, PROP_DEF_DEFAULT);
+	// godot.GodotOrigin
+	add_godot_origin();
+	// godot.Vector2 godot.Color ...
+	builtin_binder.initialize(ctx, this);
+	// godot.Object godot.Node godot.Theme ...
+	add_godot_classes();
+	// godot.print godot.sin ...
+	add_godot_globals();
+	// globalThis.Worker
+	add_global_worker();
+	// Other global properties
+	add_global_properties();
+	// globalThis.console
+	add_global_console();
+	// binding script
+	String script_binding_error;
+	JavaScriptGCHandler eval_ret;
+	if (OK == safe_eval_text(JavaScriptBinder::BINDING_SCRIPT_CONTENT, JavaScriptBinder::EVAL_TYPE_GLOBAL, "<internal: binding_script.js>", script_binding_error, eval_ret)) {
+#ifdef TOOLS_ENABLED
+		if (eval_ret.javascript_object) {
+			JSValue ret = JS_MKPTR(JS_TAG_OBJECT, eval_ret.javascript_object);
+			modified_api = var_to_variant(ctx, ret);
+			JS_FreeValue(ctx, ret);
+		}
+#endif
+	} else {
+		CRASH_NOW_MSG("Execute script binding failed:" ENDL + script_binding_error);
+	}
+
+#ifdef QUICKJS_WITH_DEBUGGER
+	debugger.instantiate();
+	bool is_editor_hint = false;
+	bool default_server_enabled = GLOBAL_DEF("JavaScript/debugger/enabled", false);
+	int default_port = GLOBAL_DEF("JavaScript/debugger/port", 5556);
+#ifdef TOOLS_ENABLED
+	is_editor_hint = Engine::get_singleton()->is_editor_hint();
+#endif
+	if (!is_editor_hint) {
+		List<String> args = OS::get_singleton()->get_cmdline_args();
+		if (List<String>::Element *E = args.find("--js-debugger-connect")) {
+			if (E->next() && E->next()->get().find(":") != -1) {
+				String address = E->next()->get();
+				Error err = debugger->connect(ctx, address);
+				if (err != OK) {
+					ERR_PRINT(vformat("Failed to connect to JavaScript debugger at %s", address));
+				}
+			} else {
+				ERR_PRINT("Invalid debugger address");
+			}
+		} else if (List<String>::Element *E2 = args.find("--js-debugger-listen")) {
+			if (E2->next() && E2->next()->get().find(":") != -1) {
+				String address = E2->next()->get();
+				Error err = debugger->listen(ctx, address);
+				if (err == OK) {
+					print_line(vformat("JavaScript debugger started at %s", address));
+				} else {
+					ERR_PRINT(vformat("Failed to start JavaScript debugger at %s", address));
+				}
+			} else {
+				ERR_PRINT("Invalid debugger address");
+			}
+		} else if (default_server_enabled) {
+			String address = vformat("0.0.0.0:%d", default_port);
+			Error err = debugger->listen(ctx, address);
+			if (err == OK) {
+				print_line(vformat("JavaScript debugger started at %s", address));
+			} else {
+				ERR_PRINT(vformat("Failed to start JavaScript debugger at %s", address));
+			}
+		}
+	} else {
+#ifdef TOOLS_ENABLED
+		// TODO: debug editor plugin support
+#endif
+	}
+#endif
+}
+
+void QuickJSBinder::uninitialize() {
+	godot_object_class = NULL;
+	godot_reference_class = NULL;
+	builtin_binder.uninitialize();
+
+	// Free singletons
+	for (int i = 0; i < godot_singletons.size(); i++) {
+		JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, godot_singletons[i]);
+		if (bind) {
+			memdelete(bind);
+			JS_SetOpaque(godot_singletons[i], NULL);
+		}
+		JS_FreeValue(ctx, godot_singletons[i]);
+	}
+
+	// Free registered js classes
+	for (const KeyValue<String, JavaScriptClassInfo> &pair : javascript_classes) {
+		const JavaScriptClassInfo &js_class = pair.value;
+		free_javascript_class(js_class);
+	}
+	javascript_classes.clear();
+
+	// Free frame callbacks
+	for (const KeyValue<int64_t, JavaScriptGCHandler> &pair : frame_callbacks) {
+		const JavaScriptGCHandler &func = pair.value;
+		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.javascript_object);
+		JS_FreeValue(ctx, js_func);
+	}
+	frame_callbacks.clear();
+
+	// modules
+	List<Ref<Resource>> module_resources;
+	for (KeyValue<String, ModuleCache> &pair : module_cache) {
+		ModuleCache &m = pair.value;
+#if MODULE_HAS_REFCOUNT
+		if (m.module) {
+			JSValue val = JS_MKPTR(JS_TAG_MODULE, m.module);
+			JS_FreeValue(ctx, val);
+		}
+#endif
+		if (m.res.is_valid()) {
+			JS_FreeValue(ctx, m.res_value);
+			module_resources.push_back(m.res);
+			m.res = Ref<Resource>();
+		}
+	}
+	module_cache.clear();
+
+	// commonjs modules
+	for (KeyValue<String, CommonJSModule> &pair : commonjs_module_cache) {
+		CommonJSModule &m = pair.value;
+		JS_FreeValue(ctx, m.exports);
+		m.res = Ref<Resource>();
+	}
+	commonjs_module_cache.clear();
+
+	JS_FreeAtom(ctx, js_key_godot_classid);
+	JS_FreeAtom(ctx, js_key_godot_classname);
+	JS_FreeAtom(ctx, js_key_godot_tooled);
+	JS_FreeAtom(ctx, js_key_godot_icon_path);
+	JS_FreeAtom(ctx, js_key_godot_exports);
+	JS_FreeAtom(ctx, js_key_godot_signals);
+	JS_FreeValue(ctx, js_operators);
+	JS_FreeValue(ctx, js_operators_create);
+	JS_FreeValue(ctx, empty_function);
+	JS_FreeValue(ctx, console_object);
+	JS_FreeValue(ctx, global_object);
+
+	JS_SetContextOpaque(ctx, NULL);
+	JS_FreeContext(ctx);
+	JS_FreeRuntime(runtime);
+
+	for (List<Ref<Resource>>::Element *E = module_resources.front(); E; E = E->next()) {
+		E->get()->unreference(); // Avoid imported resource leaking
+	}
+
+#ifdef QUICKJS_WITH_DEBUGGER
+	debugger = Ref<QuickJSDebugger>();
+#endif
+
+	ctx = NULL;
+	runtime = NULL;
+
+	{
+		GLOBAL_LOCK_FUNCTION
+		JavaScriptLanguage::get_singleton()->thread_binder_map.erase(thread_id);
+	}
+}
+
+void QuickJSBinder::language_finalize() {
+	GLOBAL_LOCK_FUNCTION
+	transfer_deopot.clear();
+}
+
+void QuickJSBinder::frame() {
+	JSContext *ctx1;
+	for (;;) {
+		int err = JS_ExecutePendingJob(JS_GetRuntime(ctx), &ctx1);
+		if (err <= 0) {
+			if (err < 0) {
+				JavaScriptError script_err;
+				JSValue e = JS_GetException(ctx1);
+				dump_exception(ctx1, e, &script_err);
+				ERR_PRINT(error_to_string(script_err));
+				JS_FreeValue(ctx1, e);
+			}
+			break;
+		}
+	}
+
+	for (List<JavaScriptGCHandler *>::Element *E = workers.front(); E; E = E->next()) {
+		JavaScriptGCHandler *bind = E->get();
+		QuickJSWorker *worker = static_cast<QuickJSWorker *>(bind->native_ptr);
+		JSValue object = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
+		worker->frame_of_host(this, object);
+	}
+
+	for (const KeyValue<int64_t, JavaScriptGCHandler> &pair : frame_callbacks) {
+		if (canceled_frame_callbacks.has(pair.key))
+			continue;
+		const JavaScriptGCHandler &func = pair.value;
+		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.javascript_object);
+		double timestamp = OS::get_singleton()->get_ticks_usec() / 1000.0;
+		JSValue argv[] = { JS_NewFloat64(ctx, timestamp) };
+		JSValue ret = JS_Call(ctx, js_func, global_object, 1, argv);
+		JS_FreeValue(ctx, argv[0]);
+		if (JS_IsException(ret)) {
+			JSValue e = JS_GetException(ctx);
+			JavaScriptError err;
+			dump_exception(ctx, e, &err);
+			ERR_PRINT("Error in requestAnimationFrame:" ENDL + error_to_string(err));
+			JS_FreeValue(ctx, e);
+		}
+	}
+	for (const KeyValue<int64_t, JavaScriptGCHandler> &pair : frame_callbacks) {
+		const JavaScriptGCHandler &func = pair.value;
+		JSValueConst js_func = JS_MKPTR(JS_TAG_OBJECT, func.javascript_object);
+		JS_FreeValue(ctx, js_func);
+	}
+	frame_callbacks.clear();
+	canceled_frame_callbacks.clear();
+
+#ifdef QUICKJS_WITH_DEBUGGER
+	debugger->poll();
+#endif
+}
+
+Error QuickJSBinder::eval_string(const String &p_source, EvalType type, const String &p_path, JavaScriptGCHandler &r_ret) {
+	String error;
+	Error err = safe_eval_text(p_source, type, p_path, error, r_ret);
+	if (err != OK && !error.is_empty()) {
+		ERR_PRINT(error);
+	}
+	return err;
+}
+
+Error QuickJSBinder::safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, JavaScriptGCHandler &r_ret) {
+	ERR_FAIL_COND_V(p_source.is_empty(), FAILED);
+	CharString utf8_str = p_source.utf8();
+	const char *filename = p_path.utf8().get_data();
+	const char *code = utf8_str.get_data();
+	int flags = JS_EVAL_FLAG_STRICT;
+	if (type == JavaScriptBinder::EVAL_TYPE_MODULE) {
+		flags |= JS_EVAL_TYPE_MODULE;
+	} else {
+		flags |= JS_EVAL_TYPE_GLOBAL;
+	}
+	JSValue ret = JS_Eval(ctx, code, utf8_str.length(), filename, flags);
+	r_ret.context = ctx;
+	r_ret.javascript_object = JS_VALUE_GET_PTR(ret);
+	if (JS_IsException(ret)) {
+		JSValue e = JS_GetException(ctx);
+		JavaScriptError err;
+		dump_exception(ctx, e, &err);
+		r_error = error_to_string(err);
+		JS_Throw(ctx, e);
+		return ERR_PARSE_ERROR;
+	}
+	return OK;
+}
+Error QuickJSBinder::compile_to_bytecode(const String &p_code, const String &p_file, Vector<uint8_t> &r_bytecode) {
+	JavaScriptError script_err;
+	ModuleCache mc = js_compile_module(ctx, p_code, p_file, &script_err);
+	if (mc.module) {
+		JSValue module = JS_MKPTR(JS_TAG_MODULE, mc.module);
+		size_t size;
+		if (uint8_t *buf = JS_WriteObject(ctx, &size, module, JS_WRITE_OBJ_BYTECODE | JS_WRITE_OBJ_REFERENCE | JS_WRITE_OBJ_SAB)) {
+			r_bytecode.resize(size);
+			memcpy(r_bytecode.ptrw(), buf, size);
+			js_free(ctx, buf);
+			JS_FreeValue(ctx, module);
+		} else {
+			ERR_FAIL_V(ERR_PARSE_ERROR);
+		}
+	} else {
+		ERR_FAIL_V_MSG(ERR_PARSE_ERROR, error_to_string(script_err));
+	}
+	return OK;
+}
+
+Error QuickJSBinder::load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, JavaScriptGCHandler *r_module) {
+	Variant bytes = p_bytecode;
+	if (ModuleCache *ptr = module_cache.getptr(p_file)) {
+		if (bytes.hash() == ptr->hash) {
+			r_module->javascript_object = ptr->module;
+			return OK;
+		}
+	}
+
+	JSValue value = JS_ReadObject(ctx, p_bytecode.ptr(), p_bytecode.size(), JS_READ_OBJ_BYTECODE | JS_READ_OBJ_REFERENCE | JS_READ_OBJ_SAB | JS_READ_OBJ_ROM_DATA);
+	ERR_FAIL_COND_V(JS_VALUE_GET_TAG(value) != JS_TAG_MODULE, ERR_PARSE_ERROR);
+	void *ptr = JS_VALUE_GET_PTR(value);
+	r_module->javascript_object = ptr;
+
+	ModuleCache mc;
+	mc.flags = MODULE_FLAG_SCRIPT;
+	mc.hash = bytes.hash();
+	mc.module = static_cast<JSModuleDef *>(ptr);
+	module_cache.insert(p_file, mc);
+
+	if (JS_ResolveModule(ctx, value) < 0) {
+		JSValue e = JS_GetException(ctx);
+		JavaScriptError err;
+		dump_exception(ctx, e, &err);
+		JS_Throw(ctx, e);
+		ERR_FAIL_V_MSG(ERR_PARSE_ERROR, error_to_string(err));
+	}
+	return OK;
+}
+
+/************************* Memory Management ******************************/
+
+JavaScriptGCHandler *QuickJSBinder::alloc_object_binding_data(Object *p_object) {
+	JavaScriptGCHandler *data = new_gc_handler(nullptr);
+	bind_gc_object(ctx, data, p_object);
+	return data;
+}
+
+void QuickJSBinder::free_object_binding_data(JavaScriptGCHandler *p_gc_handle) {
+	JavaScriptGCHandler *bind = (JavaScriptGCHandler *)p_gc_handle;
+	if (!bind->is_ref_counted()) {
+		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
+		JS_SetOpaque(js_obj, NULL);
+		JS_FreeValue((JSContext *)bind->context, js_obj);
+	}
+	memdelete(bind);
+}
+
+Error QuickJSBinder::bind_gc_object(JSContext *ctx, JavaScriptGCHandler *data, Object *p_object) {
+	QuickJSBinder *binder = get_context_binder(ctx);
+	const ClassBindData **bind_ptr = binder->classname_bindings.getptr(p_object->get_class_name());
+	if (!bind_ptr)
+		bind_ptr = binder->classname_bindings.getptr(p_object->get_parent_class_static());
+	if (!bind_ptr) {
+		bind_ptr = Object::cast_to<RefCounted>(p_object) == NULL ? &binder->godot_object_class : &binder->godot_reference_class;
+#ifdef DEBUG_ENABLED
+		WARN_PRINT("Class " + p_object->get_class_name() + " is not registed to ClassDB");
+#endif
+	}
+	if (bind_ptr) {
+		JSValue obj = JS_NewObjectProtoClass(ctx, (*bind_ptr)->prototype, binder->get_origin_class_id());
+		data->javascript_object = JS_VALUE_GET_PTR(obj);
+		data->context = ctx;
+		data->godot_object = p_object;
+		data->type = Variant::OBJECT;
+		data->flags = JavaScriptGCHandler::FLAG_OBJECT;
+		if (p_object->is_ref_counted()) {
+			if (static_cast<RefCounted *>(p_object)->init_ref()) {
+				data->flags |= JavaScriptGCHandler::FLAG_REF_COUNTED;
+			}
+		}
+		JS_SetOpaque(obj, data);
+#ifdef DUMP_LEAKS
+		add_debug_binding_info(ctx, obj, data);
+		JS_DefinePropertyValueStr(ctx, obj, "__id__", to_js_number(ctx, static_cast<uint64_t>(p_object->get_instance_id())), PROP_DEF_DEFAULT);
+#endif
+		return OK;
+	}
+	return FAILED;
+}
+
+void QuickJSBinder::godot_refcount_incremented(JavaScriptGCHandler *bind) {
+	if (bind->is_valid_javascript_object()) {
+		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
+		JS_DupValue((JSContext *)bind->context, js_obj);
+	}
+}
+
+bool QuickJSBinder::godot_refcount_decremented(JavaScriptGCHandler *bind) {
+	if (bind->is_valid_javascript_object()) {
+		JSValue js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
+		JS_FreeValue((JSContext *)bind->context, js_obj);
+		return bind->is_finalized();
+	} else {
+		return true;
+	}
+}
+
+JSValue QuickJSBinder::object_constructor(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv, int class_id) {
+	QuickJSBinder *binder = QuickJSBinder::get_context_binder(ctx);
+	const ClassBindData &cls = binder->class_bindings.get(class_id);
+	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, new_target);
+	JSValue js_obj;
+	if (bind) {
+		js_obj = new_target;
+	} else {
+		Object *gd_obj = cls.gdclass->creation_func();
+		JavaScriptLanguage *lang = JavaScriptLanguage::get_singleton();
+		bind = new_gc_handler(ctx);
+		bind_gc_object(ctx, bind, gd_obj);
+		gd_obj->set_instance_binding(lang, bind, lang->get_instance_binding_callbacks());
+		js_obj = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
+
+		if (JS_IsFunction(ctx, new_target)) {
+			JSValue prototype = JS_GetProperty(ctx, new_target, QuickJSBinder::JS_ATOM_prototype);
+			JS_SetPrototype(ctx, js_obj, prototype);
+			JS_FreeValue(ctx, prototype);
+		}
+
+#if 0
+		// Make script and script instance for the object
+		JavaScriptInstance *si = memnew(JavaScriptInstance);
+		si->javascript_object = *bind;
+		si->binder = binder;
+		si->owner = gd_obj;
+		JSValue js_class_name = JS_GetProperty(ctx, js_obj, binder->js_key_godot_classname);
+		if (JS_IsString(js_class_name)) {
+			if (JavaScriptClassInfo *js_class = binder->javascript_classes.getptr(js_to_string(ctx, js_class_name))) {
+				si->script.instantiate();
+				si->script->javascript_class = js_class;
+				si->script->instances.insert(gd_obj);
+				si->script->javascript_class = js_class;
+				si->javascript_class = js_class;
+				initialize_properties(ctx, js_class, js_obj);
+			}
+		}
+		JS_FreeValue(ctx, js_class_name);
+		gd_obj->set_script_instance(si);
+#endif
+		if (!bind->is_ref_counted()) { // Object need to be freed manually
+			JS_DupValue(ctx, js_obj);
+		}
+	}
+	return js_obj;
+}
+
+void QuickJSBinder::initialize_properties(JSContext *ctx, const JavaScriptClassInfo *p_class, JSValue p_object) {
+	QuickJSBinder *binder = get_context_binder(ctx);
+	for (const KeyValue<StringName, JavaScriptProperyInfo> &pair : p_class->properties) {
+		JSAtom pname = get_atom(ctx, pair.key);
+		int ret = JS_SetProperty(ctx, p_object, pname, variant_to_var(ctx, pair.value.default_value));
+		if (ret < 0) {
+			JSValue e = JS_GetException(ctx);
+			JavaScriptError error;
+			dump_exception(ctx, e, &error);
+			JS_FreeValue(ctx, e);
+			ERR_PRINT(vformat("Cannot initialize property '%s' of class '%s'\n%s", pair.key, p_class->class_name, binder->error_to_string(error)));
+		}
+		JS_FreeAtom(ctx, pname);
+	}
+}
+
+void QuickJSBinder::object_finalizer(JavaScriptGCHandler *p_bind) {
+	p_bind->flags ^= JavaScriptGCHandler::FLAG_OBJECT;
+	if (p_bind->godot_object->is_ref_counted()) {
+		RefCounted *ref = static_cast<RefCounted *>(p_bind->godot_object);
+		if (ref->unreference()) {
+			memdelete(ref);
+		}
+	}
+}
+
+void QuickJSBinder::origin_finalizer(JSRuntime *rt, JSValue val) {
+	QuickJSBinder *binder = get_runtime_binder(rt);
+	JavaScriptGCHandler *bind = static_cast<JavaScriptGCHandler *>(JS_GetOpaque(val, binder->godot_origin_class.class_id));
+	if (bind) {
+		bind->flags |= JavaScriptGCHandler::FLAG_FINALIZED;
+		if (bind->type == Variant::OBJECT) {
+			object_finalizer(bind);
+		} else {
+			binder->builtin_binder.builtin_finalizer(bind);
+		}
+		JS_SetOpaque(val, NULL);
+	}
+}
+
+JSValue QuickJSBinder::object_free(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+	JavaScriptGCHandler *bind = BINDING_DATA_FROM_JS(ctx, this_val);
+	ERR_FAIL_NULL_V(bind, JS_ThrowReferenceError(ctx, "The object already be freed"));
+	ERR_FAIL_NULL_V(bind->godot_object, JS_ThrowReferenceError(ctx, "The object already be freed"));
+	ERR_FAIL_COND_V(bind->godot_object->is_ref_counted(), JS_ThrowReferenceError(ctx, "Call free to RefCounted object is not allowed"));
+
+	memdelete(bind->godot_object);
+	JS_SetOpaque(this_val, NULL);
+	return JS_UNDEFINED;
+}
+
+/************************* END Memory Management ******************************/
+
+/********************************* Script --> C++ ****************************/
+JSValue QuickJSBinder::godot_register_class(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
+	ERR_FAIL_COND_V(argc < 1 || !JS_IsFunction(ctx, argv[0]), JS_ThrowTypeError(ctx, "Godot class expected"));
+	QuickJSBinder *binder = get_context_binder(ctx);
+	String class_name;
+#if NO_MODULE_EXPORT_SUPPORT
+	class_name = binder->parsing_script_file;
+#endif
+	if (class_name.is_empty()) {
+		if (argc > 1 && JS_IsString(argv[1])) {
+			class_name = js_to_string(ctx, argv[1]);
+		} else {
+			JSValue name = JS_GetProperty(ctx, *argv, JS_ATOM_name);
+			class_name = js_to_string(ctx, name);
+			JS_FreeValue(ctx, name);
+		}
+	}
+	binder->register_javascript_class(argv[0], class_name);
+	return JS_UNDEFINED;
+}
+
+const JavaScriptClassInfo *QuickJSBinder::register_javascript_class(const JSValue &p_constructor, const String &p_path) {
+	QuickJSBinder *binder = get_context_binder(ctx);
+	JSValue prototype = JS_UNDEFINED;
+	JSValue classid = JS_UNDEFINED;
+	JSValue tooled = JS_UNDEFINED;
+	JSValue icon = JS_UNDEFINED;
+	JSClassID id = 0;
+
+	if (!JS_IsFunction(ctx, p_constructor)) {
+		JS_ThrowTypeError(ctx, "Godot class expected: %s", p_path.utf8().get_data());
+		goto fail;
+	}
+
+	prototype = JS_GetProperty(ctx, p_constructor, QuickJSBinder::JS_ATOM_prototype);
+	classid = JS_GetProperty(ctx, prototype, js_key_godot_classid);
+	tooled = JS_GetProperty(ctx, p_constructor, js_key_godot_tooled);
+	icon = JS_GetProperty(ctx, p_constructor, js_key_godot_icon_path);
+
+	if (JS_IsUndefined(classid)) {
+		JS_ThrowTypeError(ctx, "Godot class expected: %s", p_path.utf8().get_data());
+		goto fail;
+	}
+
+	id = JS_VALUE_GET_INT(classid);
+	if (const ClassBindData *bind = binder->class_bindings.getptr(id)) {
+		// Add reference to the class function
+		JS_DupValue(ctx, p_constructor);
+
+		JSValue name = JS_GetProperty(ctx, p_constructor, JS_ATOM_name);
+		StringName class_name = js_to_string(ctx, name);
+		JS_FreeValue(ctx, name);
+
+		JavaScriptClassInfo js_class;
+		js_class.icon_path = "";
+		js_class.tool = false;
+		js_class.native_class = bind->gdclass;
+		js_class.class_name = class_name;
+		js_class.prototype.context = ctx;
+		js_class.prototype.javascript_object = JS_VALUE_GET_PTR(prototype);
+		js_class.constructor.context = ctx;
+		js_class.constructor.javascript_object = JS_VALUE_GET_PTR(p_constructor);
+		js_class.tool = JS_ToBool(ctx, tooled);
+		if (JS_IsString(icon)) {
+			js_class.icon_path = js_to_string(ctx, icon);
+		}
+
+		// signals
+		JSValue signals = JS_GetProperty(ctx, prototype, js_key_godot_signals);
+		if (JS_IsObject(signals)) {
+			HashSet<String> keys;
+			get_own_property_names(ctx, signals, &keys);
+			for (const String &key : keys) {
+				MethodInfo mi;
+				mi.name = key;
+				js_class.signals.insert(mi.name, mi);
+			}
+		}
+		JS_FreeValue(ctx, signals);
+
+		// properties
+		JSValue props = JS_GetProperty(ctx, prototype, js_key_godot_exports);
+		if (JS_IsObject(props)) {
+			HashSet<String> keys;
+			get_own_property_names(ctx, props, &keys);
+			for (const String &key : keys) {
+				JavaScriptProperyInfo ei;
+				ei.name = key;
+				ei.type = Variant::NIL;
+				ei.hint = PropertyHint::PROPERTY_HINT_NONE;
+				ei.usage = PropertyUsageFlags::PROPERTY_USAGE_DEFAULT;
+
+				JSAtom pname = get_atom(ctx, key);
+				JSValue js_prop = JS_GetProperty(ctx, props, pname);
+				Variant prop = var_to_variant(ctx, js_prop);
+
+				int found_entry = 0;
+				if (prop.get_type() == Variant::DICTIONARY) {
+					Dictionary prop_info = prop;
+					if (const Variant *ptr = prop_info.getptr("type")) {
+						Variant::Type type = Variant::Type(int(*ptr));
+						if (type > Variant::NIL && type < Variant::VARIANT_MAX) {
+							ei.type = type;
+							found_entry++;
+						}
+					}
+					if (const Variant *ptr = prop_info.getptr("hint")) {
+						PropertyHint hint = PropertyHint(int(*ptr));
+						if (hint > PropertyHint::PROPERTY_HINT_NONE && hint < PropertyHint::PROPERTY_HINT_MAX) {
+							ei.hint = hint;
+							found_entry++;
+						}
+					}
+					if (const Variant *ptr = prop_info.getptr("usage")) {
+						ei.usage = *ptr;
+						found_entry++;
+					}
+					if (const Variant *ptr = prop_info.getptr("hint_string")) {
+						ei.hint_string = *ptr;
+						found_entry++;
+					}
+					if (const Variant *ptr = prop_info.getptr("class_name")) {
+						ei.class_name = *ptr;
+						found_entry++;
+					}
+					if (const Variant *ptr = prop_info.getptr("default")) {
+						ei.default_value = *ptr;
+						found_entry++;
+					}
+				}
+
+				if (found_entry <= 0) {
+					ei.default_value = prop;
+				}
+				if (ei.type == Variant::NIL) {
+					ei.type = ei.default_value.get_type();
+				}
+				JS_FreeAtom(ctx, pname);
+				js_class.properties.insert(key, ei);
+				JS_FreeValue(ctx, js_prop);
+			}
+		}
+		JS_FreeValue(ctx, props);
+
+		// methods
+		HashSet<String> keys;
+		get_own_property_names(ctx, prototype, &keys);
+		for (const String &E : keys) {
+			JSAtom key = get_atom(ctx, E);
+			JSValue value = JS_GetProperty(ctx, prototype, key);
+			if (JS_IsFunction(ctx, value)) {
+				MethodInfo mi;
+				mi.name = E;
+				js_class.methods.insert(E, mi);
+			}
+			JS_FreeValue(ctx, value);
+			JS_FreeAtom(ctx, key);
+		}
+
+		// cache the class
+		if (const JavaScriptClassInfo *ptr = binder->javascript_classes.getptr(p_path)) {
+			binder->free_javascript_class(*ptr);
+		}
+		binder->javascript_classes.insert(p_path, js_class);
+		JS_DefinePropertyValue(ctx, prototype, js_key_godot_classname, to_js_string(ctx, p_path), PROP_DEF_DEFAULT);
+	}
+fail:
+	JS_FreeValue(ctx, classid);
+	JS_FreeValue(ctx, prototype);
+	JS_FreeValue(ctx, icon);
+	JS_FreeValue(ctx, tooled);
+	return binder->javascript_classes.getptr(p_path);
+}
+
+void QuickJSBinder::free_javascript_class(const JavaScriptClassInfo &p_class) {
+	JSValue class_func = JS_MKPTR(JS_TAG_OBJECT, p_class.constructor.javascript_object);
+	JS_FreeValue(ctx, class_func);
+}
+
+JSValue QuickJSBinder::godot_register_signal(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+	ERR_FAIL_COND_V(argc < 2, JS_ThrowTypeError(ctx, "Two or more arguments expected"));
+	ERR_FAIL_COND_V(!JS_IsObject(argv[0]), JS_ThrowTypeError(ctx, "protorype of Godot function expected for agurment 0"));
+	ERR_FAIL_COND_V(!JS_IsString(argv[1]), JS_ThrowTypeError(ctx, "string expected for agurment 1"));
+	QuickJSBinder *binder = get_context_binder(ctx);
+
+	JSValue prototype = JS_UNDEFINED;
+	if (JS_IsFunction(ctx, argv[0])) {
+		prototype = JS_GetProperty(ctx, argv[0], QuickJSBinder::JS_ATOM_prototype);
+	} else {
+		prototype = JS_DupValue(ctx, argv[0]);
+	}
+
+	JSValue object = JS_GetProperty(ctx, prototype, binder->js_key_godot_signals);
+	if (!JS_IsObject(object)) {
+		object = JS_NewObject(ctx);
+	}
+	const char *signal = JS_ToCString(ctx, argv[1]);
+	JS_DupValue(ctx, argv[1]);
+	JS_SetPropertyStr(ctx, object, signal, argv[1]);
+	JS_FreeCString(ctx, signal);
+
+	JS_SetProperty(ctx, prototype, binder->js_key_godot_signals, object);
+	JS_FreeValue(ctx, prototype);
+	return JS_UNDEFINED;
+}
+
+JSValue QuickJSBinder::godot_register_property(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+	ERR_FAIL_COND_V(argc < 3, JS_ThrowTypeError(ctx, "Three or more arguments expected"));
+	ERR_FAIL_COND_V(!JS_IsObject(argv[0]), JS_ThrowTypeError(ctx, "protorype of Godot class function expected for agurment 0"));
+	ERR_FAIL_COND_V(!JS_IsString(argv[1]), JS_ThrowTypeError(ctx, "string expected for agurment 1"));
+
+	QuickJSBinder *binder = get_context_binder(ctx);
+	JSValue prototype = JS_UNDEFINED;
+	if (JS_IsFunction(ctx, argv[0])) {
+		prototype = JS_GetProperty(ctx, argv[0], QuickJSBinder::JS_ATOM_prototype);
+	} else {
+		prototype = JS_DupValue(ctx, argv[0]);
+	}
+
+	JSValue object = JS_GetProperty(ctx, prototype, binder->js_key_godot_exports);
+	if (!JS_IsObject(object)) {
+		object = JS_NewObject(ctx);
+	}
+	const char *name = JS_ToCString(ctx, argv[1]);
+	JS_DupValue(ctx, argv[2]);
+	JS_SetPropertyStr(ctx, object, name, argv[2]);
+	JS_FreeCString(ctx, name);
+
+	JS_SetProperty(ctx, prototype, binder->js_key_godot_exports, object);
+	JS_FreeValue(ctx, prototype);
+
+	return JS_UNDEFINED;
+}
+
+Error QuickJSBinder::define_operators(JSContext *ctx, JSValue p_prototype, JSValue *p_operators, int p_size) {
+	QuickJSBinder *binder = get_context_binder(ctx);
+	JSValue operators = JS_Call(ctx, binder->js_operators_create, binder->js_operators, p_size, p_operators);
+	if (JS_IsException(operators)) {
+		JavaScriptError error;
+		JSValue e = JS_GetException(ctx);
+		dump_exception(ctx, e, &error);
+		JS_FreeValue(ctx, e);
+		ERR_PRINT(binder->error_to_string(error));
+		return FAILED;
+	}
+	JS_DefinePropertyValue(ctx, p_prototype, JS_ATOM_Symbol_operatorSet, operators, PROP_DEF_DEFAULT);
+	return OK;
+}
+
+JSValue QuickJSBinder::godot_set_script_meta(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic) {
+	ERR_FAIL_COND_V(argc < 2, JS_ThrowTypeError(ctx, "Two or more arguments expected"));
+	ERR_FAIL_COND_V(!JS_IsFunction(ctx, argv[0]), JS_ThrowTypeError(ctx, "godot class expected for argument #0"));
+	JSValue constructor = argv[0];
+	QuickJSBinder *binder = get_context_binder(ctx);
+	switch (magic) {
+		case QuickJSBinder::SCRIPT_META_TOOLED:
+			JS_SetProperty(ctx, constructor, binder->js_key_godot_tooled, JS_DupValue(ctx, argv[1]));
+			break;
+		case QuickJSBinder::SCRIPT_META_ICON:
+			JS_SetProperty(ctx, constructor, binder->js_key_godot_icon_path, JS_DupValue(ctx, argv[1]));
+			break;
+	}
+	return JS_UNDEFINED;
+}
+
+JSValue QuickJSBinder::global_request_animation_frame(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+	ERR_FAIL_COND_V(argc < 1 || !JS_IsFunction(ctx, argv[0]), JS_ThrowTypeError(ctx, "Function expected for argument #0"));
+	static SafeNumeric<int64_t> id;
+	JSValue js_func = JS_DupValue(ctx, argv[0]);
+	JavaScriptGCHandler func;
+	func.javascript_object = JS_VALUE_GET_PTR(js_func);
+	QuickJSBinder *binder = get_context_binder(ctx);
+	int64_t value = id.increment();
+	binder->frame_callbacks.insert(value, func);
+	return JS_NewInt64(ctx, value);
+}
+
+JSValue QuickJSBinder::global_cancel_animation_frame(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+	ERR_FAIL_COND_V(argc < 1 || !JS_IsNumber(argv[0]), JS_ThrowTypeError(ctx, "Request ID expected for argument #0"));
+	QuickJSBinder *binder = get_context_binder(ctx);
+	binder->canceled_frame_callbacks.insert(js_to_int64(ctx, argv[0]));
+	return JS_UNDEFINED;
+}
+
+int QuickJSBinder::get_js_array_length(JSContext *ctx, JSValue p_val) {
+	if (!JS_IsArray(ctx, p_val))
+		return -1;
+	JSValue ret = JS_GetProperty(ctx, p_val, JS_ATOM_length);
+	int32_t length = -1;
+	if (JS_ToInt32(ctx, &length, ret))
+		return -1;
+	return length;
+}
+
+void QuickJSBinder::get_own_property_names(JSContext *ctx, JSValue p_object, HashSet<String> *r_list) {
+	ERR_FAIL_COND(!JS_IsObject(p_object));
+	JSPropertyEnum *props = NULL;
+	uint32_t tab_atom_count;
+	JS_GetOwnPropertyNames(ctx, &props, &tab_atom_count, p_object, JS_GPN_STRING_MASK | JS_GPN_SYMBOL_MASK);
+	for (uint32_t i = 0; i < tab_atom_count; i++) {
+		JSValue key = JS_AtomToValue(ctx, props[i].atom);
+		String name = js_to_string(ctx, key);
+		r_list->insert(name);
+		JS_FreeAtom(ctx, props[i].atom);
+		JS_FreeValue(ctx, key);
+	}
+	js_free_rt(JS_GetRuntime(ctx), props);
+}
+
+JavaScriptGCHandler QuickJSBinder::create_js_instance_for_godot_object(const JavaScriptClassInfo *p_class, Object *p_object) {
+	ERR_FAIL_NULL_V(p_object, JavaScriptGCHandler());
+	ERR_FAIL_NULL_V(p_class, JavaScriptGCHandler());
+
+	JavaScriptGCHandler *bind = BINDING_DATA_FROM_GD(ctx, p_object);
+	ERR_FAIL_NULL_V(bind, JavaScriptGCHandler());
+
+	JSValue constructor = JS_MKPTR(JS_TAG_OBJECT, p_class->constructor.javascript_object);
+	JSValue object = JS_MKPTR(JS_TAG_OBJECT, bind->javascript_object);
+	JS_CallConstructor2(ctx, constructor, object, 0, NULL);
+	if (JS_SetPrototype(ctx, object, JS_MKPTR(JS_TAG_OBJECT, p_class->prototype.javascript_object)) < 0) {
+		JSValue e = JS_GetException(ctx);
+		JavaScriptError error;
+		dump_exception(ctx, e, &error);
+		JS_FreeValue(ctx, e);
+		bind->javascript_object = NULL;
+		ERR_FAIL_V_MSG(*bind, vformat("Cannot create instance from Godot class '%s'\n%s", p_class->class_name, error_to_string(error)));
+	}
+	initialize_properties(ctx, p_class, object);
+	return *bind;
+}
+
+Variant QuickJSBinder::call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
+	JSValue object = GET_JSVALUE(p_object);
+	JSAtom atom = get_atom(ctx, p_method);
+	JSValue method = JS_GetProperty(ctx, object, atom);
+	JS_FreeAtom(ctx, atom);
+	JavaScriptGCHandler func;
+	func.javascript_object = JS_VALUE_GET_PTR(method);
+	Variant ret = call(func, p_object, p_args, p_argcount, r_error);
+	JS_FreeValue(ctx, method);
+	return ret;
+}
+
+Variant QuickJSBinder::call(const JavaScriptGCHandler &p_fuction, const JavaScriptGCHandler &p_target, const Variant **p_args, int p_argcount, Callable::CallError &r_error) {
+	JSValue return_val = JS_UNDEFINED;
+	JSValue *argv = NULL;
+	JSValue method = JS_MKPTR(JS_TAG_OBJECT, p_fuction.javascript_object);
+	JSValue object = p_target.is_valid_javascript_object() ? JS_MKPTR(JS_TAG_OBJECT, p_target.javascript_object) : JS_UNDEFINED;
+
+	if (!JS_IsFunction(ctx, method) || JS_IsPureCFunction(ctx, method)) {
+		r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
+		goto finish;
+	}
+
+	argv = memnew_arr(JSValue, p_argcount);
+	for (int i = 0; i < p_argcount; ++i) {
+		argv[i] = variant_to_var(ctx, *p_args[i]);
+	}
+	return_val = JS_Call(ctx, method, object, p_argcount, argv);
+
+	if (JS_IsException(return_val)) {
+		r_error.error = Callable::CallError::CALL_ERROR_INVALID_METHOD;
+		JSValue exception = JS_GetException(ctx);
+		JavaScriptError err;
+		dump_exception(ctx, exception, &err);
+		ERR_PRINT(error_to_string(err));
+		JS_Throw(ctx, exception);
+	} else {
+		r_error.error = Callable::CallError::CALL_OK;
+	}
+finish:
+	Variant ret = var_to_variant(ctx, return_val);
+	if (argv) {
+		for (int i = 0; i < p_argcount; i++) {
+			JS_FreeValue(ctx, argv[i]);
+		}
+		memdelete_arr(argv);
+	}
+	JS_FreeValue(ctx, return_val);
+	return ret;
+}
+
+bool QuickJSBinder::get_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) {
+	bool success = false;
+	JSValue obj = GET_JSVALUE(p_object);
+	JSAtom atom = get_atom(ctx, p_name);
+	JSValue ret = JS_GetProperty(ctx, obj, atom);
+	JS_FreeAtom(ctx, atom);
+	r_ret = var_to_variant(ctx, ret);
+	success = !JS_IsUndefined(ret);
+	JS_FreeValue(ctx, ret);
+	return success;
+}
+
+bool QuickJSBinder::set_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) {
+	JSValue obj = GET_JSVALUE(p_object);
+	JSAtom atom = get_atom(ctx, p_name);
+	bool success = JS_SetProperty(ctx, obj, atom, variant_to_var(ctx, p_value));
+	JS_FreeAtom(ctx, atom);
+	return success;
+}
+
+bool QuickJSBinder::has_method(const JavaScriptGCHandler &p_object, const StringName &p_name) {
+	JSValue obj = GET_JSVALUE(p_object);
+	ERR_FAIL_COND_V(!JS_IsObject(obj), false);
+	JSAtom atom = get_atom(ctx, p_name);
+	JSValue value = JS_GetProperty(ctx, GET_JSVALUE(p_object), atom);
+	bool success = JS_IsFunction(ctx, value);
+	JS_FreeAtom(ctx, atom);
+	JS_FreeValue(ctx, value);
+	return success;
+}
+
+const JavaScriptClassInfo *QuickJSBinder::parse_javascript_class(const String &p_code, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) {
+	if (!ignore_cacehe) {
+		if (const JavaScriptClassInfo *cls = javascript_classes.getptr(p_path)) {
+			return cls;
+		}
+	}
+	JavaScriptError err;
+	ModuleCache *mc = js_compile_and_cache_module(ctx, p_code, p_path, r_error);
+	return parse_javascript_class_from_module(mc, p_path, r_error);
+}
+
+const JavaScriptClassInfo *QuickJSBinder::parse_javascript_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) {
+	if (!ignore_cacehe) {
+		if (const JavaScriptClassInfo *cls = javascript_classes.getptr(p_path)) {
+			return cls;
+		}
+	}
+	ModuleCache *mc = js_compile_and_cache_module(ctx, p_bytecode, p_path, r_error);
+	ERR_FAIL_NULL_V(mc, NULL);
+	return parse_javascript_class_from_module(mc, p_path, r_error);
+}
+
+const JavaScriptClassInfo *QuickJSBinder::parse_javascript_class_from_module(ModuleCache *p_module, const String &p_path, JavaScriptError *r_error) {
+	ERR_FAIL_COND_V(p_module == NULL || p_module->module == NULL, NULL);
+
+	const JavaScriptClassInfo *js_class = NULL;
+	JSValue default_entry = JS_UNDEFINED;
+	if (OK != js_evalute_module(ctx, p_module, r_error)) {
+		goto fail;
+	}
+
+	for (int i = 0; i < JS_GetModuleExportEntriesCount(p_module->module); i++) {
+		JSAtom name = JS_GetModuleExportEntryName(ctx, p_module->module, i);
+		if (name == JS_ATOM_default) {
+			default_entry = JS_GetModuleExportEntry(ctx, p_module->module, i);
+			JS_FreeAtom(ctx, name);
+			break;
+		}
+		JS_FreeAtom(ctx, name);
+	}
+	if (!JS_IsFunction(ctx, default_entry)) {
+		String err = "Failed parse Godot class from script " + p_path + ENDL "\t" + "Default export entry must be a godot class!";
+		ERR_PRINT(err);
+		JS_ThrowTypeError(ctx, "%s", err.utf8().get_data());
+		goto fail;
+	}
+	js_class = register_javascript_class(default_entry, p_path);
+fail:
+	JS_FreeValue(ctx, default_entry);
+	return js_class;
+}
+
+bool QuickJSBinder::has_signal(const JavaScriptClassInfo *p_class, const StringName &p_signal) {
+	ERR_FAIL_NULL_V(p_class, false);
+	bool found = false;
+	JSValue object = JS_GetProperty(ctx, GET_JSVALUE(p_class->prototype), js_key_godot_signals);
+	if (!JS_IsObject(object)) {
+		JS_FreeValue(ctx, object);
+		return false;
+	}
+	JSAtom atom = get_atom(ctx, p_signal);
+	JSValue signal = JS_GetProperty(ctx, object, atom);
+	found = !JS_IsUndefined(signal);
+	JS_FreeAtom(ctx, atom);
+	JS_FreeValue(ctx, signal);
+	JS_FreeValue(ctx, object);
+	return found;
+}
+/**************************** END Script --> C++ ******************************/
+
+/********************************** Worker *************************************/
+JSValue QuickJSBinder::worker_constructor(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+	ERR_FAIL_COND_V(argc < 1 || !JS_IsString(argv[0]), JS_ThrowTypeError(ctx, "script path expected for argument #0"));
+	QuickJSBinder *host = QuickJSBinder::get_context_binder(ctx);
+
+	QuickJSWorker *worker = memnew(QuickJSWorker(host));
+	worker->start(js_to_string(ctx, argv[0]));
+	JSValue obj = JS_NewObjectProtoClass(ctx, host->worker_class_data.prototype, host->worker_class_data.class_id);
+
+	JavaScriptGCHandler *data = host->new_gc_handler(ctx);
+	data->native_ptr = worker;
+	data->javascript_object = JS_VALUE_GET_PTR(obj);
+	JS_SetOpaque(obj, data);
+	host->workers.push_back(data);
+
+	return obj;
+}
+
+void QuickJSBinder::worker_finializer(JSRuntime *rt, JSValue val) {
+	QuickJSBinder *host = QuickJSBinder::get_runtime_binder(rt);
+	if (JavaScriptGCHandler *bind = static_cast<JavaScriptGCHandler *>(JS_GetOpaque(val, host->worker_class_data.class_id))) {
+		QuickJSWorker *worker = static_cast<QuickJSWorker *>(bind->native_ptr);
+		worker->stop();
+		if (List<JavaScriptGCHandler *>::Element *E = host->workers.find(bind)) {
+			host->workers.erase(E);
+		}
+		memdelete(worker);
+		memdelete(bind);
+	}
+}
+
+JSValue QuickJSBinder::worker_post_message(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+	ERR_FAIL_COND_V(argc < 1, JS_ThrowTypeError(ctx, "message value expected of argument #0"));
+	QuickJSBinder *host = QuickJSBinder::get_context_binder(ctx);
+	if (JavaScriptGCHandler *bind = static_cast<JavaScriptGCHandler *>(JS_GetOpaque(this_val, host->worker_class_data.class_id))) {
+		QuickJSWorker *worker = static_cast<QuickJSWorker *>(bind->native_ptr);
+		worker->post_message_from_host(var_to_variant(ctx, argv[0]));
+	}
+	return JS_UNDEFINED;
+}
+
+JSValue QuickJSBinder::worker_terminate(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+	QuickJSBinder *host = QuickJSBinder::get_context_binder(ctx);
+	if (JavaScriptGCHandler *bind = static_cast<JavaScriptGCHandler *>(JS_GetOpaque(this_val, host->worker_class_data.class_id))) {
+		QuickJSWorker *worker = static_cast<QuickJSWorker *>(bind->native_ptr);
+		if (List<JavaScriptGCHandler *>::Element *E = host->workers.find(bind)) {
+			host->workers.erase(E);
+		}
+		worker->stop();
+	}
+	return JS_UNDEFINED;
+}
+
+JSValue QuickJSBinder::godot_abandon_value(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+	ERR_FAIL_COND_V(argc != 1, JS_ThrowTypeError(ctx, "one argument expected"));
+	JSValue &value = argv[0];
+	bool valid = true;
+	Variant gd_value = var_to_variant(ctx, value);
+	if (gd_value.get_type() == Variant::OBJECT) {
+		JavaScriptGCHandler *data = BINDING_DATA_FROM_JS(ctx, value);
+		if (data) {
+			JS_SetOpaque(value, NULL);
+			if (data->is_ref_counted()) {
+				static_cast<RefCounted *>(data->godot_object)->unreference();
+			} else if (data->is_object()) {
+				JS_FreeValue(ctx, value);
+			}
+			data->godot_object = NULL;
+			data->javascript_object = NULL;
+			data->context = NULL;
+			data->flags |= JavaScriptGCHandler::FLAG_TRANSFERABLE;
+		} else {
+			valid = false;
+		}
+	}
+
+	uint64_t id = 0;
+	if (valid) {
+		id = QuickJSBinder::global_transfer_id.increment();
+		GLOBAL_LOCK_FUNCTION
+		transfer_deopot.insert(id, gd_value);
+	}
+	return JS_NewInt64(ctx, id);
+}
+
+JSValue QuickJSBinder::godot_adopt_value(JSContext *ctx, JSValue this_val, int argc, JSValue *argv) {
+	ERR_FAIL_COND_V(argc != 1 || !JS_IsNumber(argv[0]), JS_ThrowTypeError(ctx, "value id expected"));
+	int64_t id = js_to_int64(ctx, argv[0]);
+	ERR_FAIL_COND_V(id == 0, JS_ThrowTypeError(ctx, "id must greater than 0"));
+
+	Variant value;
+	{
+		GLOBAL_LOCK_FUNCTION
+		if (Variant *ptr = transfer_deopot.getptr(id)) {
+			value = *ptr;
+			transfer_deopot.erase(id);
+		}
+	}
+	ERR_FAIL_NULL_V(static_cast<Object *>(value), JS_UNDEFINED);
+	return variant_to_var(ctx, value);
+}
+
+void QuickJSBinder::add_global_worker() {
+	worker_class_data.gdclass = NULL;
+	worker_class_data.class_id = 0;
+	worker_class_data.base_class = NULL;
+	worker_class_data.class_name = "Worker";
+	worker_class_data.jsclass.class_name = "Worker";
+	worker_class_data.jsclass.finalizer = worker_finializer;
+	worker_class_data.jsclass.exotic = NULL;
+	worker_class_data.jsclass.gc_mark = NULL;
+	worker_class_data.jsclass.call = NULL;
+	worker_class_data.gdclass = NULL;
+	worker_class_data.prototype = JS_NewObject(ctx);
+	worker_class_data.constructor = JS_NewCFunction2(ctx, worker_constructor, worker_class_data.jsclass.class_name, worker_class_data.class_name.size(), JS_CFUNC_constructor, 0);
+
+	// Worker.prototype.onmessage
+	JS_SetPropertyStr(ctx, worker_class_data.prototype, "onmessage", JS_NULL);
+	// Worker.prototype.postMessage
+	JSValue post_message_func = JS_NewCFunction(ctx, worker_post_message, "postMessage", 1);
+	JS_DefinePropertyValueStr(ctx, worker_class_data.prototype, "postMessage", post_message_func, PROP_DEF_DEFAULT);
+	// Worker.prototype.terminate
+	JSValue terminate_func = JS_NewCFunction(ctx, worker_terminate, "terminate", 1);
+	JS_DefinePropertyValueStr(ctx, worker_class_data.prototype, "terminate", terminate_func, PROP_DEF_DEFAULT);
+
+	JS_NewClassID(&worker_class_data.class_id);
+	JS_NewClass(JS_GetRuntime(ctx), worker_class_data.class_id, &worker_class_data.jsclass);
+	JS_SetClassProto(ctx, worker_class_data.class_id, worker_class_data.prototype);
+	JS_SetConstructor(ctx, worker_class_data.constructor, worker_class_data.prototype);
+	JS_DefinePropertyValueStr(ctx, global_object, "Worker", worker_class_data.constructor, PROP_DEF_DEFAULT);
+}
+
+/********************************* END Worker **********************************/
+
+bool QuickJSBinder::validate(const String &p_code, const String &p_path, JavaScriptError *r_error) {
+	ModuleCache *module = js_compile_and_cache_module(ctx, p_code, p_path, r_error);
+	return module != NULL;
+}
diff --git a/thirdparty/quickjs/quickjs_binder.h b/thirdparty/quickjs/quickjs_binder.h
index 56b39389..1d003dd1 100644
--- a/thirdparty/quickjs/quickjs_binder.h
+++ b/thirdparty/quickjs/quickjs_binder.h
@@ -281,8 +281,21 @@ class QuickJSBinder : public JavaScriptBinder {
 	}
 
 public:
-	QuickJSBinder();
-	virtual ~QuickJSBinder();
+
+	QuickJSBinder() {
+		context_id = QuickJSBinder::global_context_id.increment();
+		internal_godot_method_id = 0;
+		internal_godot_indexed_property_id = 0;
+		godot_allocator.js_malloc = QuickJSBinder::js_binder_malloc;
+		godot_allocator.js_free = QuickJSBinder::js_binder_free;
+		godot_allocator.js_realloc = QuickJSBinder::js_binder_realloc;
+		godot_allocator.js_malloc_usable_size = nullptr;
+		godot_object_class = nullptr;
+		godot_reference_class = nullptr;
+	}
+
+	virtual ~QuickJSBinder() {
+	}
 
 	_FORCE_INLINE_ static QuickJSBinder *get_context_binder(JSContext *ctx) {
 		return static_cast<QuickJSBinder *>(JS_GetContextOpaque(ctx));
diff --git a/thirdparty/quickjs/quickjs_callable.cpp b/thirdparty/quickjs/quickjs_callable.cpp
index 109129e8..07336d54 100644
--- a/thirdparty/quickjs/quickjs_callable.cpp
+++ b/thirdparty/quickjs/quickjs_callable.cpp
@@ -2,8 +2,8 @@
 #include "javascript_language.h"
 #include "quickjs/quickjs.h"
 
-#include "quickjs_builtin_binder.h"
 #include "quickjs_binder.h"
+#include "quickjs_builtin_binder.h"
 
 bool QuickJSCallable::compare_equal(const CallableCustom *p_a, const CallableCustom *p_b) {
 	const QuickJSCallable *a = static_cast<const QuickJSCallable *>(p_a);
@@ -26,7 +26,9 @@ QuickJSCallable::QuickJSCallable(JSContext *ctx, const JSValue &p_value) {
 }
 
 QuickJSCallable::QuickJSCallable(const JavaScriptGCHandler &p_function) : JavaScriptCallable(p_function) {
-	JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, p_function.javascript_object);
+	JSValue js_func;
+	js_func.u.ptr = p_function.javascript_object;
+	js_func.tag = JS_TAG_OBJECT;
 	JSContext *ctx = static_cast<JSContext *>(p_function.context);
 	ERR_FAIL_COND(JS_IsFunction(ctx, js_func));
 	JS_DupValue(ctx, js_func);
@@ -35,19 +37,26 @@ QuickJSCallable::QuickJSCallable(const JavaScriptGCHandler &p_function) : JavaSc
 QuickJSCallable::~QuickJSCallable() {
 	if (js_function.is_valid_javascript_object()) {
 		JSContext *ctx = static_cast<JSContext *>(js_function.context);
-		JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, js_function.javascript_object);
+		JSValue temp;
+		temp.u.ptr = js_function.javascript_object;
+		temp.tag = JS_TAG_OBJECT;
+		JSValue js_func = temp;
 		JS_FreeValue(ctx, js_func);
 	}
 }
 
 uint32_t QuickJSCallable::hash() const {
-	JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, js_function.javascript_object);
+	JSValue js_func;
+	js_func.u.ptr = js_function.javascript_object;
+	js_func.tag = JS_TAG_OBJECT;
 	return hash_murmur3_one_64((uint64_t)JS_VALUE_GET_PTR(js_func));
 }
 
 String QuickJSCallable::get_as_text() const {
 	QuickJSBinder *binder = QuickJSBinder::get_context_binder(static_cast<JSContext *>(js_function.context));
-	JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, js_function.javascript_object);
+	JSValue js_func;
+	js_func.u.ptr = js_function.javascript_object;
+	js_func.tag = JS_TAG_OBJECT;
 	JSContext *ctx = static_cast<JSContext *>(js_function.context);
 	String text = binder->js_to_string(ctx, js_func);
 	return text;
@@ -59,7 +68,9 @@ ObjectID QuickJSCallable::get_object() const {
 
 void QuickJSCallable::call(const Variant **p_arguments, int p_argcount, Variant &r_return_value, Callable::CallError &r_call_error) const {
 	QuickJSBinder *binder = QuickJSBinder::get_context_binder(static_cast<JSContext *>(js_function.context));
-	JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, js_function.javascript_object);
+	JSValue js_func;
+	js_func.tag = JS_TAG_OBJECT;
+	js_func.u.ptr = js_function.javascript_object;
 	JavaScriptGCHandler func;
 	func.javascript_object = JS_VALUE_GET_PTR(js_func);
 	JavaScriptGCHandler caller;
diff --git a/thirdparty/quickjs/quickjs_callable.h b/thirdparty/quickjs/quickjs_callable.h
index e82261d3..48050cd2 100644
--- a/thirdparty/quickjs/quickjs_callable.h
+++ b/thirdparty/quickjs/quickjs_callable.h
@@ -4,7 +4,6 @@
 #include "quickjs/quickjs.h"
 
 #if !defined(JS_NAN_BOXING)
-///typedef uint64_t JSValue; defined in quickjs.h if defined(JS_NAN_BOXING)
 struct JSValue;
 #endif
 
diff --git a/thirdparty/quickjs/quickjs_debugger.cpp b/thirdparty/quickjs/quickjs_debugger.cpp
index 31016cde..36a54765 100644
--- a/thirdparty/quickjs/quickjs_debugger.cpp
+++ b/thirdparty/quickjs/quickjs_debugger.cpp
@@ -1,4 +1,5 @@
 #include "quickjs_debugger.h"
+#include <stddef.h>
 
 #define QJS_DEBUGGER_DEBUG_LOG 0
 
@@ -26,7 +27,7 @@ size_t QuickJSDebugger::transport_read(void *udata, char *buffer, size_t length)
 #endif
 	ERR_FAIL_COND_V(err != OK, -err);
 	ERR_FAIL_COND_V(ret < 0, -4);
-	ERR_FAIL_COND_V(ret > (ssize_t)length, -6);
+	ERR_FAIL_COND_V(ret > (ptrdiff_t)length, -6);
 	return ret;
 }
 
@@ -41,7 +42,7 @@ size_t QuickJSDebugger::transport_write(void *udata, const char *buffer, size_t
 	print_line(vformat("[write] %d %s", length, buffer));
 #endif
 	ERR_FAIL_COND_V(err != OK, -err);
-	ERR_FAIL_COND_V(ret <= 0 || ret > (ssize_t)length, -4);
+	ERR_FAIL_COND_V(ret <= 0 || ret > (ptrdiff_t)length, -4);
 	return ret;
 }
 
diff --git a/thirdparty/winpthreads/COPYING b/thirdparty/winpthreads/COPYING
new file mode 100644
index 00000000..35077012
--- /dev/null
+++ b/thirdparty/winpthreads/COPYING
@@ -0,0 +1,57 @@
+Copyright (c) 2011 mingw-w64 project
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+
+/*
+ * Parts of this library are derived by:
+ *
+ * Posix Threads library for Microsoft Windows
+ *
+ * Use at own risk, there is no implied warranty to this code.
+ * It uses undocumented features of Microsoft Windows that can change
+ * at any time in the future.
+ *
+ * (C) 2010 Lockless Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *  * Neither the name of Lockless Inc. nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AN
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
diff --git a/thirdparty/winpthreads/README b/thirdparty/winpthreads/README
new file mode 100644
index 00000000..55922f00
--- /dev/null
+++ b/thirdparty/winpthreads/README
@@ -0,0 +1,10 @@
+The Winpthreads Library
+-----------------------
+
+This library provides POSIX threading APIs for mingw-w64.
+
+For maximum compatibility, winpthreads headers expose APIs without the
+`dllimport` attribute by default. If your program is linked against the
+DLL, you may define the `WINPTHREADS_USE_DLLIMPORT` macro to add the
+`dllimport` attribute to all APIs, which makes function calls to them a
+bit more efficient.
diff --git a/thirdparty/winpthreads/include/pthread.h b/thirdparty/winpthreads/include/pthread.h
new file mode 100644
index 00000000..6ea4f018
--- /dev/null
+++ b/thirdparty/winpthreads/include/pthread.h
@@ -0,0 +1,685 @@
+/*
+   Copyright (c) 2011-2016 mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+/*
+ * Parts of this library are derived by:
+ *
+ * Posix Threads library for Microsoft Windows
+ *
+ * Use at own risk, there is no implied warranty to this code.
+ * It uses undocumented features of Microsoft Windows that can change
+ * at any time in the future.
+ *
+ * (C) 2010 Lockless Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *  * Neither the name of Lockless Inc. nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AN
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#ifndef WIN_PTHREADS_H
+#define WIN_PTHREADS_H
+
+#include <stddef.h>
+#include <errno.h>
+#include <sys/types.h>
+
+#include <process.h>
+#include <limits.h>
+#include <signal.h>
+#include <time.h>
+
+#include <sys/timeb.h>
+
+#include "pthread_compat.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define __WINPTHREADS_VERSION_MAJOR 0
+#define __WINPTHREADS_VERSION_MINOR 5
+#define __WINPTHREADS_VERSION_PATCHLEVEL 0
+
+/* MSB 8-bit major version, 8-bit minor version, 16-bit patch level.  */
+#define __WINPTHREADS_VERSION 0x00050000
+
+#if defined(IN_WINPTHREAD)
+#  if defined(DLL_EXPORT)
+#    define WINPTHREAD_API  __declspec(dllexport)  /* building the DLL  */
+#  else
+#    define WINPTHREAD_API  /* building the static library  */
+#  endif
+#else
+#  if defined(WINPTHREADS_USE_DLLIMPORT)
+#    define WINPTHREAD_API  __declspec(dllimport)  /* user wants explicit `dllimport`  */
+#  else
+#    define WINPTHREAD_API  /* the default; auto imported in case of DLL  */
+#  endif
+#endif
+
+/* #define WINPTHREAD_DBG 1 */
+
+/* Compatibility stuff: */
+#define RWLS_PER_THREAD						8
+
+/* Error-codes.  */
+#ifndef ETIMEDOUT
+#define ETIMEDOUT	138
+#endif
+#ifndef ENOTSUP
+#define ENOTSUP		129
+#endif
+#ifndef EWOULDBLOCK
+#define EWOULDBLOCK	140
+#endif
+
+/* pthread specific defines.  */
+
+#define PTHREAD_CANCEL_DISABLE 0
+#define PTHREAD_CANCEL_ENABLE 0x01
+
+#define PTHREAD_CANCEL_DEFERRED 0
+#define PTHREAD_CANCEL_ASYNCHRONOUS 0x02
+
+#define PTHREAD_CREATE_JOINABLE 0
+#define PTHREAD_CREATE_DETACHED 0x04
+
+#define PTHREAD_EXPLICIT_SCHED 0
+#define PTHREAD_INHERIT_SCHED 0x08
+
+#define PTHREAD_SCOPE_PROCESS 0
+#define PTHREAD_SCOPE_SYSTEM 0x10
+
+#define PTHREAD_DEFAULT_ATTR (PTHREAD_CANCEL_ENABLE)
+
+#define PTHREAD_CANCELED ((void *) (intptr_t) 0xDEADBEEF)
+
+#define _PTHREAD_NULL_THREAD ((pthread_t) 0)
+
+#define PTHREAD_ONCE_INIT 0
+
+#define PTHREAD_DESTRUCTOR_ITERATIONS 256
+#define PTHREAD_KEYS_MAX (1<<20)
+
+#define PTHREAD_MUTEX_NORMAL 0
+#define PTHREAD_MUTEX_ERRORCHECK 1
+#define PTHREAD_MUTEX_RECURSIVE 2
+#define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
+
+#define PTHREAD_MUTEX_SHARED 1
+#define PTHREAD_MUTEX_PRIVATE 0
+
+#define PTHREAD_PRIO_NONE 0
+#define PTHREAD_PRIO_INHERIT 8
+#define PTHREAD_PRIO_PROTECT 16
+#define PTHREAD_PRIO_MULT 32
+#define PTHREAD_PROCESS_SHARED 1
+#define PTHREAD_PROCESS_PRIVATE 0
+
+#define PTHREAD_MUTEX_FAST_NP		PTHREAD_MUTEX_NORMAL
+#define PTHREAD_MUTEX_TIMED_NP		PTHREAD_MUTEX_FAST_NP
+#define PTHREAD_MUTEX_ADAPTIVE_NP	PTHREAD_MUTEX_FAST_NP
+#define PTHREAD_MUTEX_ERRORCHECK_NP	PTHREAD_MUTEX_ERRORCHECK
+#define PTHREAD_MUTEX_RECURSIVE_NP	PTHREAD_MUTEX_RECURSIVE
+
+void * WINPTHREAD_API pthread_timechange_handler_np(void * dummy);
+int    WINPTHREAD_API pthread_delay_np (const struct timespec *interval);
+int    WINPTHREAD_API pthread_num_processors_np(void);
+int    WINPTHREAD_API pthread_set_num_processors_np(int n);
+
+#define PTHREAD_BARRIER_SERIAL_THREAD 1
+
+/* maximum number of times a read lock may be obtained */
+#define	MAX_READ_LOCKS		(INT_MAX - 1)
+
+/* No fork() in windows - so ignore this */
+#define pthread_atfork(F1,F2,F3) 0
+
+/* unsupported stuff: */
+#define pthread_mutex_getprioceiling(M, P) ENOTSUP
+#define pthread_mutex_setprioceiling(M, P) ENOTSUP
+#define pthread_getcpuclockid(T, C) ENOTSUP
+#define pthread_attr_getguardsize(A, S) ENOTSUP
+#define pthread_attr_setgaurdsize(A, S) ENOTSUP
+
+typedef long pthread_once_t;
+typedef unsigned pthread_mutexattr_t;
+typedef unsigned pthread_key_t;
+typedef void *pthread_barrierattr_t;
+typedef int pthread_condattr_t;
+typedef int pthread_rwlockattr_t;
+
+/*
+struct _pthread_v;
+
+typedef struct pthread_t {
+  struct _pthread_v *p;
+  int x;
+} pthread_t;
+*/
+
+typedef uintptr_t pthread_t;
+
+typedef struct _pthread_cleanup _pthread_cleanup;
+struct _pthread_cleanup
+{
+    void (*func)(void *);
+    void *arg;
+    _pthread_cleanup *next;
+};
+
+#define pthread_cleanup_push(F, A)\
+{\
+    const _pthread_cleanup _pthread_cup = {(F), (A), *pthread_getclean()};\
+    __sync_synchronize();\
+    *pthread_getclean() = (_pthread_cleanup *) &_pthread_cup;\
+    __sync_synchronize()
+
+/* Note that if async cancelling is used, then there is a race here */
+#define pthread_cleanup_pop(E)\
+    (*pthread_getclean() = _pthread_cup.next, ((E) ? (_pthread_cup.func((pthread_once_t *)_pthread_cup.arg)) : (void)0));}
+
+#ifndef SCHED_OTHER
+/* Some POSIX realtime extensions, mostly stubbed */
+#define SCHED_OTHER     0
+#define SCHED_FIFO      1
+#define SCHED_RR        2
+#define SCHED_MIN       SCHED_OTHER
+#define SCHED_MAX       SCHED_RR
+
+struct sched_param {
+  int sched_priority;
+};
+
+int WINPTHREAD_API sched_yield(void);
+int WINPTHREAD_API sched_get_priority_min(int pol);
+int WINPTHREAD_API sched_get_priority_max(int pol);
+int WINPTHREAD_API sched_getscheduler(pid_t pid);
+int WINPTHREAD_API sched_setscheduler(pid_t pid, int pol, const struct sched_param *param);
+
+#endif
+
+typedef struct pthread_attr_t pthread_attr_t;
+struct pthread_attr_t
+{
+    unsigned p_state;
+    void *stack;
+    size_t s_size;
+    struct sched_param param;
+};
+
+int WINPTHREAD_API pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param);
+int WINPTHREAD_API pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param);
+int WINPTHREAD_API pthread_getschedparam(pthread_t thread, int *pol, struct sched_param *param);
+int WINPTHREAD_API pthread_setschedparam(pthread_t thread, int pol, const struct sched_param *param);
+int WINPTHREAD_API pthread_attr_setschedpolicy (pthread_attr_t *attr, int pol);
+int WINPTHREAD_API pthread_attr_getschedpolicy (const pthread_attr_t *attr, int *pol);
+
+/* synchronization objects */
+typedef intptr_t pthread_spinlock_t;
+typedef intptr_t pthread_mutex_t;
+typedef intptr_t pthread_cond_t;
+typedef intptr_t pthread_rwlock_t;
+typedef void	*pthread_barrier_t;
+
+#define PTHREAD_MUTEX_NORMAL 0
+#define PTHREAD_MUTEX_ERRORCHECK 1
+#define PTHREAD_MUTEX_RECURSIVE 2
+
+#define GENERIC_INITIALIZER				-1
+#define GENERIC_ERRORCHECK_INITIALIZER			-2
+#define GENERIC_RECURSIVE_INITIALIZER			-3
+#define GENERIC_NORMAL_INITIALIZER			-1
+#define PTHREAD_MUTEX_INITIALIZER			(pthread_mutex_t)GENERIC_INITIALIZER
+#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER		(pthread_mutex_t)GENERIC_RECURSIVE_INITIALIZER
+#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER		(pthread_mutex_t)GENERIC_ERRORCHECK_INITIALIZER
+#define PTHREAD_NORMAL_MUTEX_INITIALIZER		(pthread_mutex_t)GENERIC_NORMAL_INITIALIZER
+#define PTHREAD_DEFAULT_MUTEX_INITIALIZER		PTHREAD_NORMAL_MUTEX_INITIALIZER
+#define PTHREAD_COND_INITIALIZER			(pthread_cond_t)GENERIC_INITIALIZER
+#define PTHREAD_RWLOCK_INITIALIZER			(pthread_rwlock_t)GENERIC_INITIALIZER
+#define PTHREAD_SPINLOCK_INITIALIZER			(pthread_spinlock_t)GENERIC_INITIALIZER
+
+extern void WINPTHREAD_API (**_pthread_key_dest)(void *);
+int         WINPTHREAD_API pthread_key_create(pthread_key_t *key, void (* dest)(void *));
+int         WINPTHREAD_API pthread_key_delete(pthread_key_t key);
+void *      WINPTHREAD_API pthread_getspecific(pthread_key_t key);
+int         WINPTHREAD_API pthread_setspecific(pthread_key_t key, const void *value);
+
+pthread_t WINPTHREAD_API pthread_self(void);
+int       WINPTHREAD_API pthread_once(pthread_once_t *o, void (*func)(void));
+void      WINPTHREAD_API pthread_testcancel(void);
+int       WINPTHREAD_API pthread_equal(pthread_t t1, pthread_t t2);
+void      WINPTHREAD_API pthread_tls_init(void);
+void      WINPTHREAD_API _pthread_cleanup_dest(pthread_t t);
+int       WINPTHREAD_API pthread_get_concurrency(int *val);
+int       WINPTHREAD_API pthread_set_concurrency(int val);
+void      WINPTHREAD_API pthread_exit(void *res);
+void      WINPTHREAD_API _pthread_invoke_cancel(void);
+int       WINPTHREAD_API pthread_cancel(pthread_t t);
+int       WINPTHREAD_API pthread_kill(pthread_t t, int sig);
+unsigned  WINPTHREAD_API _pthread_get_state(const pthread_attr_t *attr, unsigned flag);
+int       WINPTHREAD_API _pthread_set_state(pthread_attr_t *attr, unsigned flag, unsigned val);
+int       WINPTHREAD_API pthread_setcancelstate(int state, int *oldstate);
+int       WINPTHREAD_API pthread_setcanceltype(int type, int *oldtype);
+int       WINPTHREAD_API pthread_create_wrapper(void *args);
+int       WINPTHREAD_API pthread_create(pthread_t *th, const pthread_attr_t *attr, void *(* func)(void *), void *arg);
+int       WINPTHREAD_API pthread_join(pthread_t t, void **res);
+int       WINPTHREAD_API pthread_detach(pthread_t t);
+int       WINPTHREAD_API pthread_setname_np(pthread_t thread, const char *name);
+int       WINPTHREAD_API pthread_getname_np(pthread_t thread, char *name, size_t len);
+
+
+int WINPTHREAD_API pthread_rwlock_init(pthread_rwlock_t *rwlock_, const pthread_rwlockattr_t *attr);
+int WINPTHREAD_API pthread_rwlock_wrlock(pthread_rwlock_t *l);
+int WINPTHREAD_API pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock, const struct timespec *ts);
+int WINPTHREAD_API pthread_rwlock_rdlock(pthread_rwlock_t *l);
+int WINPTHREAD_API pthread_rwlock_timedrdlock(pthread_rwlock_t *l, const struct timespec *ts);
+int WINPTHREAD_API pthread_rwlock_unlock(pthread_rwlock_t *l);
+int WINPTHREAD_API pthread_rwlock_tryrdlock(pthread_rwlock_t *l);
+int WINPTHREAD_API pthread_rwlock_trywrlock(pthread_rwlock_t *l);
+int WINPTHREAD_API pthread_rwlock_destroy (pthread_rwlock_t *l);
+
+int WINPTHREAD_API pthread_cond_init(pthread_cond_t *cv, const pthread_condattr_t *a);
+int WINPTHREAD_API pthread_cond_destroy(pthread_cond_t *cv);
+int WINPTHREAD_API pthread_cond_signal (pthread_cond_t *cv);
+int WINPTHREAD_API pthread_cond_broadcast (pthread_cond_t *cv);
+int WINPTHREAD_API pthread_cond_wait (pthread_cond_t *cv, pthread_mutex_t *external_mutex);
+int WINPTHREAD_API pthread_cond_timedwait(pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct timespec *t);
+int WINPTHREAD_API pthread_cond_timedwait_relative_np(pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct timespec *t);
+
+int WINPTHREAD_API pthread_mutex_lock(pthread_mutex_t *m);
+int WINPTHREAD_API pthread_mutex_timedlock(pthread_mutex_t *m, const struct timespec *ts);
+int WINPTHREAD_API pthread_mutex_unlock(pthread_mutex_t *m);
+int WINPTHREAD_API pthread_mutex_trylock(pthread_mutex_t *m);
+int WINPTHREAD_API pthread_mutex_init(pthread_mutex_t *m, const pthread_mutexattr_t *a);
+int WINPTHREAD_API pthread_mutex_destroy(pthread_mutex_t *m);
+
+int WINPTHREAD_API pthread_barrier_destroy(pthread_barrier_t *b);
+int WINPTHREAD_API pthread_barrier_init(pthread_barrier_t *b, const void *attr, unsigned int count);
+int WINPTHREAD_API pthread_barrier_wait(pthread_barrier_t *b);
+
+int WINPTHREAD_API pthread_spin_init(pthread_spinlock_t *l, int pshared);
+int WINPTHREAD_API pthread_spin_destroy(pthread_spinlock_t *l);
+/* No-fair spinlock due to lack of knowledge of thread number.  */
+int WINPTHREAD_API pthread_spin_lock(pthread_spinlock_t *l);
+int WINPTHREAD_API pthread_spin_trylock(pthread_spinlock_t *l);
+int WINPTHREAD_API pthread_spin_unlock(pthread_spinlock_t *l);
+
+int WINPTHREAD_API pthread_attr_init(pthread_attr_t *attr);
+int WINPTHREAD_API pthread_attr_destroy(pthread_attr_t *attr);
+int WINPTHREAD_API pthread_attr_setdetachstate(pthread_attr_t *a, int flag);
+int WINPTHREAD_API pthread_attr_getdetachstate(const pthread_attr_t *a, int *flag);
+int WINPTHREAD_API pthread_attr_setinheritsched(pthread_attr_t *a, int flag);
+int WINPTHREAD_API pthread_attr_getinheritsched(const pthread_attr_t *a, int *flag);
+int WINPTHREAD_API pthread_attr_setscope(pthread_attr_t *a, int flag);
+int WINPTHREAD_API pthread_attr_getscope(const pthread_attr_t *a, int *flag);
+int WINPTHREAD_API pthread_attr_getstack(const pthread_attr_t *attr, void **stack, size_t *size);
+int WINPTHREAD_API pthread_attr_setstack(pthread_attr_t *attr, void *stack, size_t size);
+int WINPTHREAD_API pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stack);
+int WINPTHREAD_API pthread_attr_setstackaddr(pthread_attr_t *attr, void *stack);
+int WINPTHREAD_API pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *size);
+int WINPTHREAD_API pthread_attr_setstacksize(pthread_attr_t *attr, size_t size);
+
+int WINPTHREAD_API pthread_mutexattr_init(pthread_mutexattr_t *a);
+int WINPTHREAD_API pthread_mutexattr_destroy(pthread_mutexattr_t *a);
+int WINPTHREAD_API pthread_mutexattr_gettype(const pthread_mutexattr_t *a, int *type);
+int WINPTHREAD_API pthread_mutexattr_settype(pthread_mutexattr_t *a, int type);
+int WINPTHREAD_API pthread_mutexattr_getpshared(const pthread_mutexattr_t *a, int *type);
+int WINPTHREAD_API pthread_mutexattr_setpshared(pthread_mutexattr_t * a, int type);
+int WINPTHREAD_API pthread_mutexattr_getprotocol(const pthread_mutexattr_t *a, int *type);
+int WINPTHREAD_API pthread_mutexattr_setprotocol(pthread_mutexattr_t *a, int type);
+int WINPTHREAD_API pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *a, int * prio);
+int WINPTHREAD_API pthread_mutexattr_setprioceiling(pthread_mutexattr_t *a, int prio);
+int WINPTHREAD_API pthread_getconcurrency(void);
+int WINPTHREAD_API pthread_setconcurrency(int new_level);
+
+int WINPTHREAD_API pthread_condattr_destroy(pthread_condattr_t *a);
+int WINPTHREAD_API pthread_condattr_init(pthread_condattr_t *a);
+int WINPTHREAD_API pthread_condattr_getpshared(const pthread_condattr_t *a, int *s);
+int WINPTHREAD_API pthread_condattr_setpshared(pthread_condattr_t *a, int s);
+
+#ifndef __clockid_t_defined
+typedef int clockid_t;
+#define __clockid_t_defined 1
+#endif  /* __clockid_t_defined */
+
+int WINPTHREAD_API pthread_condattr_getclock (const pthread_condattr_t *attr,
+       clockid_t *clock_id);
+int WINPTHREAD_API pthread_condattr_setclock(pthread_condattr_t *attr,
+       clockid_t clock_id);
+int WINPTHREAD_API __pthread_clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *rqtp, struct timespec *rmtp);
+
+int WINPTHREAD_API pthread_barrierattr_init(void **attr);
+int WINPTHREAD_API pthread_barrierattr_destroy(void **attr);
+int WINPTHREAD_API pthread_barrierattr_setpshared(void **attr, int s);
+int WINPTHREAD_API pthread_barrierattr_getpshared(void **attr, int *s);
+
+/* Private extensions for analysis and internal use.  */
+struct _pthread_cleanup ** WINPTHREAD_API pthread_getclean (void);
+void *                     WINPTHREAD_API pthread_gethandle (pthread_t t);
+void *                     WINPTHREAD_API pthread_getevent (void);
+
+unsigned long long         WINPTHREAD_API _pthread_rel_time_in_ms(const struct timespec *ts);
+unsigned long long         WINPTHREAD_API _pthread_time_in_ms(void);
+unsigned long long         WINPTHREAD_API _pthread_time_in_ms_from_timespec(const struct timespec *ts);
+int                        WINPTHREAD_API _pthread_tryjoin (pthread_t t, void **res);
+int                        WINPTHREAD_API pthread_rwlockattr_destroy(pthread_rwlockattr_t *a);
+int                        WINPTHREAD_API pthread_rwlockattr_getpshared(pthread_rwlockattr_t *a, int *s);
+int                        WINPTHREAD_API pthread_rwlockattr_init(pthread_rwlockattr_t *a);
+int                        WINPTHREAD_API pthread_rwlockattr_setpshared(pthread_rwlockattr_t *a, int s);
+
+#ifndef SIG_BLOCK
+#define SIG_BLOCK 0
+#endif
+#ifndef SIG_UNBLOCK
+#define SIG_UNBLOCK 1
+#endif
+#ifndef SIG_SETMASK
+#define SIG_SETMASK 2
+#endif
+
+#include <pthread_unistd.h>
+
+#undef _POSIX_THREAD_DESTRUCTOR_ITERATIONS
+#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS     PTHREAD_DESTRUCTOR_ITERATIONS
+
+#undef _POSIX_THREAD_KEYS_MAX
+#define _POSIX_THREAD_KEYS_MAX                  PTHREAD_KEYS_MAX
+
+#undef PTHREAD_THREADS_MAX
+#define PTHREAD_THREADS_MAX                     2019
+
+#undef _POSIX_SEM_NSEMS_MAX
+#define _POSIX_SEM_NSEMS_MAX                    256
+
+#undef SEM_NSEMS_MAX
+#define SEM_NSEMS_MAX                           1024
+
+/* Wrap cancellation points.  */
+#ifdef __WINPTRHEAD_ENABLE_WRAP_API
+#define accept(...) (pthread_testcancel(), accept(__VA_ARGS__))
+#define aio_suspend(...) (pthread_testcancel(), aio_suspend(__VA_ARGS__))
+#define clock_nanosleep(...) (pthread_testcancel(), clock_nanosleep(__VA_ARGS__))
+#define close(...) (pthread_testcancel(), close(__VA_ARGS__))
+#define connect(...) (pthread_testcancel(), connect(__VA_ARGS__))
+#define creat(...) (pthread_testcancel(), creat(__VA_ARGS__))
+#define fcntl(...) (pthread_testcancel(), fcntl(__VA_ARGS__))
+#define fdatasync(...) (pthread_testcancel(), fdatasync(__VA_ARGS__))
+#define fsync(...) (pthread_testcancel(), fsync(__VA_ARGS__))
+#define getmsg(...) (pthread_testcancel(), getmsg(__VA_ARGS__))
+#define getpmsg(...) (pthread_testcancel(), getpmsg(__VA_ARGS__))
+#define lockf(...) (pthread_testcancel(), lockf(__VA_ARGS__))
+#define mg_receive(...) (pthread_testcancel(), mg_receive(__VA_ARGS__))
+#define mg_send(...) (pthread_testcancel(), mg_send(__VA_ARGS__))
+#define mg_timedreceive(...) (pthread_testcancel(), mg_timedreceive(__VA_ARGS__))
+#define mg_timessend(...) (pthread_testcancel(), mg_timedsend(__VA_ARGS__))
+#define msgrcv(...) (pthread_testcancel(), msgrecv(__VA_ARGS__))
+#define msgsnd(...) (pthread_testcancel(), msgsnd(__VA_ARGS__))
+#define msync(...) (pthread_testcancel(), msync(__VA_ARGS__))
+#define nanosleep(...) (pthread_testcancel(), nanosleep(__VA_ARGS__))
+#define open(...) (pthread_testcancel(), open(__VA_ARGS__))
+#define pause(...) (pthread_testcancel(), pause(__VA_ARGS__))
+#define poll(...) (pthread_testcancel(), poll(__VA_ARGS__))
+#define pread(...) (pthread_testcancel(), pread(__VA_ARGS__))
+#define pselect(...) (pthread_testcancel(), pselect(__VA_ARGS__))
+#define putmsg(...) (pthread_testcancel(), putmsg(__VA_ARGS__))
+#define putpmsg(...) (pthread_testcancel(), putpmsg(__VA_ARGS__))
+#define pwrite(...) (pthread_testcancel(), pwrite(__VA_ARGS__))
+#define read(...) (pthread_testcancel(), read(__VA_ARGS__))
+#define readv(...) (pthread_testcancel(), readv(__VA_ARGS__))
+#define recv(...) (pthread_testcancel(), recv(__VA_ARGS__))
+#define recvfrom(...) (pthread_testcancel(), recvfrom(__VA_ARGS__))
+#define recvmsg(...) (pthread_testcancel(), recvmsg(__VA_ARGS__))
+#define select(...) (pthread_testcancel(), select(__VA_ARGS__))
+#define sem_timedwait(...) (pthread_testcancel(), sem_timedwait(__VA_ARGS__))
+#define sem_wait(...) (pthread_testcancel(), sem_wait(__VA_ARGS__))
+#define send(...) (pthread_testcancel(), send(__VA_ARGS__))
+#define sendmsg(...) (pthread_testcancel(), sendmsg(__VA_ARGS__))
+#define sendto(...) (pthread_testcancel(), sendto(__VA_ARGS__))
+#define sigpause(...) (pthread_testcancel(), sigpause(__VA_ARGS__))
+#define sigsuspend(...) (pthread_testcancel(), sigsuspend(__VA_ARGS__))
+#define sigwait(...) (pthread_testcancel(), sigwait(__VA_ARGS__))
+#define sigwaitinfo(...) (pthread_testcancel(), sigwaitinfo(__VA_ARGS__))
+#define sleep(...) (pthread_testcancel(), sleep(__VA_ARGS__))
+//#define Sleep(...) (pthread_testcancel(), Sleep(__VA_ARGS__))
+#define system(...) (pthread_testcancel(), system(__VA_ARGS__))
+#define access(...) (pthread_testcancel(), access(__VA_ARGS__))
+#define asctime(...) (pthread_testcancel(), asctime(__VA_ARGS__))
+#define catclose(...) (pthread_testcancel(), catclose(__VA_ARGS__))
+#define catgets(...) (pthread_testcancel(), catgets(__VA_ARGS__))
+#define catopen(...) (pthread_testcancel(), catopen(__VA_ARGS__))
+#define closedir(...) (pthread_testcancel(), closedir(__VA_ARGS__))
+#define closelog(...) (pthread_testcancel(), closelog(__VA_ARGS__))
+#define ctermid(...) (pthread_testcancel(), ctermid(__VA_ARGS__))
+#define ctime(...) (pthread_testcancel(), ctime(__VA_ARGS__))
+#define dbm_close(...) (pthread_testcancel(), dbm_close(__VA_ARGS__))
+#define dbm_delete(...) (pthread_testcancel(), dbm_delete(__VA_ARGS__))
+#define dbm_fetch(...) (pthread_testcancel(), dbm_fetch(__VA_ARGS__))
+#define dbm_nextkey(...) (pthread_testcancel(), dbm_nextkey(__VA_ARGS__))
+#define dbm_open(...) (pthread_testcancel(), dbm_open(__VA_ARGS__))
+#define dbm_store(...) (pthread_testcancel(), dbm_store(__VA_ARGS__))
+#define dlclose(...) (pthread_testcancel(), dlclose(__VA_ARGS__))
+#define dlopen(...) (pthread_testcancel(), dlopen(__VA_ARGS__))
+#define endgrent(...) (pthread_testcancel(), endgrent(__VA_ARGS__))
+#define endhostent(...) (pthread_testcancel(), endhostent(__VA_ARGS__))
+#define endnetent(...) (pthread_testcancel(), endnetent(__VA_ARGS__))
+#define endprotoent(...) (pthread_testcancel(), endprotoend(__VA_ARGS__))
+#define endpwent(...) (pthread_testcancel(), endpwent(__VA_ARGS__))
+#define endservent(...) (pthread_testcancel(), endservent(__VA_ARGS__))
+#define endutxent(...) (pthread_testcancel(), endutxent(__VA_ARGS__))
+#define fclose(...) (pthread_testcancel(), fclose(__VA_ARGS__))
+#define fflush(...) (pthread_testcancel(), fflush(__VA_ARGS__))
+#define fgetc(...) (pthread_testcancel(), fgetc(__VA_ARGS__))
+#define fgetpos(...) (pthread_testcancel(), fgetpos(__VA_ARGS__))
+#define fgets(...) (pthread_testcancel(), fgets(__VA_ARGS__))
+#define fgetwc(...) (pthread_testcancel(), fgetwc(__VA_ARGS__))
+#define fgetws(...) (pthread_testcancel(), fgetws(__VA_ARGS__))
+#define fmtmsg(...) (pthread_testcancel(), fmtmsg(__VA_ARGS__))
+#define fopen(...) (pthread_testcancel(), fopen(__VA_ARGS__))
+#define fpathconf(...) (pthread_testcancel(), fpathconf(__VA_ARGS__))
+#define fprintf(...) (pthread_testcancel(), fprintf(__VA_ARGS__))
+#define fputc(...) (pthread_testcancel(), fputc(__VA_ARGS__))
+#define fputs(...) (pthread_testcancel(), fputs(__VA_ARGS__))
+#define fputwc(...) (pthread_testcancel(), fputwc(__VA_ARGS__))
+#define fputws(...) (pthread_testcancel(), fputws(__VA_ARGS__))
+#define fread(...) (pthread_testcancel(), fread(__VA_ARGS__))
+#define freopen(...) (pthread_testcancel(), freopen(__VA_ARGS__))
+#define fscanf(...) (pthread_testcancel(), fscanf(__VA_ARGS__))
+#define fseek(...) (pthread_testcancel(), fseek(__VA_ARGS__))
+#define fseeko(...) (pthread_testcancel(), fseeko(__VA_ARGS__))
+#define fsetpos(...) (pthread_testcancel(), fsetpos(__VA_ARGS__))
+#define fstat(...) (pthread_testcancel(), fstat(__VA_ARGS__))
+#define ftell(...) (pthread_testcancel(), ftell(__VA_ARGS__))
+#define ftello(...) (pthread_testcancel(), ftello(__VA_ARGS__))
+#define ftw(...) (pthread_testcancel(), ftw(__VA_ARGS__))
+#define fwprintf(...) (pthread_testcancel(), fwprintf(__VA_ARGS__))
+#define fwrite(...) (pthread_testcancel(), fwrite(__VA_ARGS__))
+#define fwscanf(...) (pthread_testcancel(), fwscanf(__VA_ARGS__))
+#define getaddrinfo(...) (pthread_testcancel(), getaddrinfo(__VA_ARGS__))
+#define getc(...) (pthread_testcancel(), getc(__VA_ARGS__))
+#define getc_unlocked(...) (pthread_testcancel(), getc_unlocked(__VA_ARGS__))
+#define getchar(...) (pthread_testcancel(), getchar(__VA_ARGS__))
+#define getchar_unlocked(...) (pthread_testcancel(), getchar_unlocked(__VA_ARGS__))
+#define getcwd(...) (pthread_testcancel(), getcwd(__VA_ARGS__))
+#define getdate(...) (pthread_testcancel(), getdate(__VA_ARGS__))
+#define getgrent(...) (pthread_testcancel(), getgrent(__VA_ARGS__))
+#define getgrgid(...) (pthread_testcancel(), getgrgid(__VA_ARGS__))
+#define getgrgid_r(...) (pthread_testcancel(), getgrgid_r(__VA_ARGS__))
+#define gergrnam(...) (pthread_testcancel(), getgrnam(__VA_ARGS__))
+#define getgrnam_r(...) (pthread_testcancel(), getgrnam_r(__VA_ARGS__))
+#define gethostbyaddr(...) (pthread_testcancel(), gethostbyaddr(__VA_ARGS__))
+#define gethostbyname(...) (pthread_testcancel(), gethostbyname(__VA_ARGS__))
+#define gethostent(...) (pthread_testcancel(), gethostent(__VA_ARGS__))
+#define gethostid(...) (pthread_testcancel(), gethostid(__VA_ARGS__))
+#define gethostname(...) (pthread_testcancel(), gethostname(__VA_ARGS__))
+#define getlogin(...) (pthread_testcancel(), getlogin(__VA_ARGS__))
+#define getlogin_r(...) (pthread_testcancel(), getlogin_r(__VA_ARGS__))
+#define getnameinfo(...) (pthread_testcancel(), getnameinfo(__VA_ARGS__))
+#define getnetbyaddr(...) (pthread_testcancel(), getnetbyaddr(__VA_ARGS__))
+#define getnetbyname(...) (pthread_testcancel(), getnetbyname(__VA_ARGS__))
+#define getnetent(...) (pthread_testcancel(), getnetent(__VA_ARGS__))
+#define getopt(...) (pthread_testcancel(), getopt(__VA_ARGS__))
+#define getprotobyname(...) (pthread_testcancel(), getprotobyname(__VA_ARGS__))
+#define getprotobynumber(...) (pthread_testcancel(), getprotobynumber(__VA_ARGS__))
+#define getprotoent(...) (pthread_testcancel(), getprotoent(__VA_ARGS__))
+#define getpwent(...) (pthread_testcancel(), getpwent(__VA_ARGS__))
+#define getpwnam(...) (pthread_testcancel(), getpwnam(__VA_ARGS__))
+#define getpwnam_r(...) (pthread_testcancel(), getpwnam_r(__VA_ARGS__))
+#define getpwuid(...) (pthread_testcancel(), getpwuid(__VA_ARGS__))
+#define getpwuid_r(...) (pthread_testcancel(), getpwuid_r(__VA_ARGS__))
+#define gets(...) (pthread_testcancel(), gets(__VA_ARGS__))
+#define getservbyname(...) (pthread_testcancel(), getservbyname(__VA_ARGS__))
+#define getservbyport(...) (pthread_testcancel(), getservbyport(__VA_ARGS__))
+#define getservent(...) (pthread_testcancel(), getservent(__VA_ARGS__))
+#define getutxent(...) (pthread_testcancel(), getutxent(__VA_ARGS__))
+#define getutxid(...) (pthread_testcancel(), getutxid(__VA_ARGS__))
+#define getutxline(...) (pthread_testcancel(), getutxline(__VA_ARGS__))
+#undef getwc
+#define getwc(...) (pthread_testcancel(), getwc(__VA_ARGS__))
+#undef getwchar
+#define getwchar(...) (pthread_testcancel(), getwchar(__VA_ARGS__))
+#define getwd(...) (pthread_testcancel(), getwd(__VA_ARGS__))
+#define glob(...) (pthread_testcancel(), glob(__VA_ARGS__))
+#define iconv_close(...) (pthread_testcancel(), iconv_close(__VA_ARGS__))
+#define iconv_open(...) (pthread_testcancel(), iconv_open(__VA_ARGS__))
+#define ioctl(...) (pthread_testcancel(), ioctl(__VA_ARGS__))
+#define link(...) (pthread_testcancel(), link(__VA_ARGS__))
+#define localtime(...) (pthread_testcancel(), localtime(__VA_ARGS__))
+#define lseek(...) (pthread_testcancel(), lseek(__VA_ARGS__))
+#define lstat(...) (pthread_testcancel(), lstat(__VA_ARGS__))
+#define mkstemp(...) (pthread_testcancel(), mkstemp(__VA_ARGS__))
+#define nftw(...) (pthread_testcancel(), nftw(__VA_ARGS__))
+#define opendir(...) (pthread_testcancel(), opendir(__VA_ARGS__))
+#define openlog(...) (pthread_testcancel(), openlog(__VA_ARGS__))
+#define pathconf(...) (pthread_testcancel(), pathconf(__VA_ARGS__))
+#define pclose(...) (pthread_testcancel(), pclose(__VA_ARGS__))
+#define perror(...) (pthread_testcancel(), perror(__VA_ARGS__))
+#define popen(...) (pthread_testcancel(), popen(__VA_ARGS__))
+#define posix_fadvise(...) (pthread_testcancel(), posix_fadvise(__VA_ARGS__))
+#define posix_fallocate(...) (pthread_testcancel(), posix_fallocate(__VA_ARGS__))
+#define posix_madvise(...) (pthread_testcancel(), posix_madvise(__VA_ARGS__))
+#define posix_openpt(...) (pthread_testcancel(), posix_openpt(__VA_ARGS__))
+#define posix_spawn(...) (pthread_testcancel(), posix_spawn(__VA_ARGS__))
+#define posix_spawnp(...) (pthread_testcancel(), posix_spawnp(__VA_ARGS__))
+#define posix_trace_clear(...) (pthread_testcancel(), posix_trace_clear(__VA_ARGS__))
+#define posix_trace_close(...) (pthread_testcancel(), posix_trace_close(__VA_ARGS__))
+#define posix_trace_create(...) (pthread_testcancel(), posix_trace_create(__VA_ARGS__))
+#define posix_trace_create_withlog(...) (pthread_testcancel(), posix_trace_create_withlog(__VA_ARGS__))
+#define posix_trace_eventtypelist_getne(...) (pthread_testcancel(), posix_trace_eventtypelist_getne(__VA_ARGS__))
+#define posix_trace_eventtypelist_rewin(...) (pthread_testcancel(), posix_trace_eventtypelist_rewin(__VA_ARGS__))
+#define posix_trace_flush(...) (pthread_testcancel(), posix_trace_flush(__VA_ARGS__))
+#define posix_trace_get_attr(...) (pthread_testcancel(), posix_trace_get_attr(__VA_ARGS__))
+#define posix_trace_get_filter(...) (pthread_testcancel(), posix_trace_get_filter(__VA_ARGS__))
+#define posix_trace_get_status(...) (pthread_testcancel(), posix_trace_get_status(__VA_ARGS__))
+#define posix_trace_getnext_event(...) (pthread_testcancel(), posix_trace_getnext_event(__VA_ARGS__))
+#define posix_trace_open(...) (pthread_testcancel(), posix_trace_open(__VA_ARGS__))
+#define posix_trace_rewind(...) (pthread_testcancel(), posix_trace_rewind(__VA_ARGS__))
+#define posix_trace_setfilter(...) (pthread_testcancel(), posix_trace_setfilter(__VA_ARGS__))
+#define posix_trace_shutdown(...) (pthread_testcancel(), posix_trace_shutdown(__VA_ARGS__))
+#define posix_trace_timedgetnext_event(...) (pthread_testcancel(), posix_trace_timedgetnext_event(__VA_ARGS__))
+#define posix_typed_mem_open(...) (pthread_testcancel(), posix_typed_mem_open(__VA_ARGS__))
+#define printf(...) (pthread_testcancel(), printf(__VA_ARGS__))
+#define putc(...) (pthread_testcancel(), putc(__VA_ARGS__))
+#define putc_unlocked(...) (pthread_testcancel(), putc_unlocked(__VA_ARGS__))
+#define putchar(...) (pthread_testcancel(), putchar(__VA_ARGS__))
+#define putchar_unlocked(...) (pthread_testcancel(), putchar_unlocked(__VA_ARGS__))
+#define puts(...) (pthread_testcancel(), puts(__VA_ARGS__))
+#define pututxline(...) (pthread_testcancel(), pututxline(__VA_ARGS__))
+#undef putwc
+#define putwc(...) (pthread_testcancel(), putwc(__VA_ARGS__))
+#undef putwchar
+#define putwchar(...) (pthread_testcancel(), putwchar(__VA_ARGS__))
+#define readdir(...) (pthread_testcancel(), readdir(__VA_ARSG__))
+#define readdir_r(...) (pthread_testcancel(), readdir_r(__VA_ARGS__))
+#define remove(...) (pthread_testcancel(), remove(__VA_ARGS__))
+#define rename(...) (pthread_testcancel(), rename(__VA_ARGS__))
+#define rewind(...) (pthread_testcancel(), rewind(__VA_ARGS__))
+#define rewinddir(...) (pthread_testcancel(), rewinddir(__VA_ARGS__))
+#define scanf(...) (pthread_testcancel(), scanf(__VA_ARGS__))
+#define seekdir(...) (pthread_testcancel(), seekdir(__VA_ARGS__))
+#define semop(...) (pthread_testcancel(), semop(__VA_ARGS__))
+#define setgrent(...) (pthread_testcancel(), setgrent(__VA_ARGS__))
+#define sethostent(...) (pthread_testcancel(), sethostemt(__VA_ARGS__))
+#define setnetent(...) (pthread_testcancel(), setnetent(__VA_ARGS__))
+#define setprotoent(...) (pthread_testcancel(), setprotoent(__VA_ARGS__))
+#define setpwent(...) (pthread_testcancel(), setpwent(__VA_ARGS__))
+#define setservent(...) (pthread_testcancel(), setservent(__VA_ARGS__))
+#define setutxent(...) (pthread_testcancel(), setutxent(__VA_ARGS__))
+#define stat(...) (pthread_testcancel(), stat(__VA_ARGS__))
+#define strerror(...) (pthread_testcancel(), strerror(__VA_ARGS__))
+#define strerror_r(...) (pthread_testcancel(), strerror_r(__VA_ARGS__))
+#define strftime(...) (pthread_testcancel(), strftime(__VA_ARGS__))
+#define symlink(...) (pthread_testcancel(), symlink(__VA_ARGS__))
+#define sync(...) (pthread_testcancel(), sync(__VA_ARGS__))
+#define syslog(...) (pthread_testcancel(), syslog(__VA_ARGS__))
+#define tmpfile(...) (pthread_testcancel(), tmpfile(__VA_ARGS__))
+#define tmpnam(...) (pthread_testcancel(), tmpnam(__VA_ARGS__))
+#define ttyname(...) (pthread_testcancel(), ttyname(__VA_ARGS__))
+#define ttyname_r(...) (pthread_testcancel(), ttyname_r(__VA_ARGS__))
+#define tzset(...) (pthread_testcancel(), tzset(__VA_ARGS__))
+#define ungetc(...) (pthread_testcancel(), ungetc(__VA_ARGS__))
+#define ungetwc(...) (pthread_testcancel(), ungetwc(__VA_ARGS__))
+#define unlink(...) (pthread_testcancel(), unlink(__VA_ARGS__))
+#define vfprintf(...) (pthread_testcancel(), vfprintf(__VA_ARGS__))
+#define vfwprintf(...) (pthread_testcancel(), vfwprintf(__VA_ARGS__))
+#define vprintf(...) (pthread_testcancel(), vprintf(__VA_ARGS__))
+#define vwprintf(...) (pthread_testcancel(), vwprintf(__VA_ARGS__))
+#define wcsftime(...) (pthread_testcancel(), wcsftime(__VA_ARGS__))
+#define wordexp(...) (pthread_testcancel(), wordexp(__VA_ARGS__))
+#define wprintf(...) (pthread_testcancel(), wprintf(__VA_ARGS__))
+#define wscanf(...) (pthread_testcancel(), wscanf(__VA_ARGS__))
+#endif
+
+/* We deal here with a gcc issue for posix threading on Windows.
+   We would need to change here gcc's gthr-posix.h header, but this
+   got rejected.  So we deal it within this header.  */
+#ifdef _GTHREAD_USE_MUTEX_INIT_FUNC
+#undef _GTHREAD_USE_MUTEX_INIT_FUNC
+#endif
+#define _GTHREAD_USE_MUTEX_INIT_FUNC 1
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WIN_PTHREADS_H */
diff --git a/thirdparty/winpthreads/include/pthread_compat.h b/thirdparty/winpthreads/include/pthread_compat.h
new file mode 100644
index 00000000..63f5f495
--- /dev/null
+++ b/thirdparty/winpthreads/include/pthread_compat.h
@@ -0,0 +1,86 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+/*
+ * Parts of this library are derived by:
+ *
+ * Posix Threads library for Microsoft Windows
+ *
+ * Use at own risk, there is no implied warranty to this code.
+ * It uses undocumented features of Microsoft Windows that can change
+ * at any time in the future.
+ *
+ * (C) 2010 Lockless Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *  * Neither the name of Lockless Inc. nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AN
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef WIN_PTHREADS_PTHREAD_COMPAT_H
+#define WIN_PTHREADS_PTHREAD_COMPAT_H
+
+#ifdef __GNUC__
+
+#define WINPTHREADS_INLINE inline
+#define WINPTHREADS_ATTRIBUTE(X) __attribute__(X)
+#define WINPTHREADS_SECTION(X) __section__(X)
+
+#elif _MSC_VER
+
+#include "pthread_time.h"
+
+#ifdef _WIN64
+typedef __int64 pid_t;
+#else
+typedef int     pid_t;
+#endif
+typedef int clockid_t;
+
+#define WINPTHREADS_INLINE __inline
+#define WINPTHREADS_ATTRIBUTE(X) __declspec X
+#define WINPTHREADS_SECTION(X) allocate(X)
+
+#endif
+
+#endif
diff --git a/thirdparty/winpthreads/include/pthread_signal.h b/thirdparty/winpthreads/include/pthread_signal.h
new file mode 100644
index 00000000..42a50ae0
--- /dev/null
+++ b/thirdparty/winpthreads/include/pthread_signal.h
@@ -0,0 +1,29 @@
+/*
+   Copyright (c) 2013-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef WIN_PTHREADS_SIGNAL_H
+#define WIN_PTHREADS_SIGNAL_H
+
+/* Windows has rudimentary signals support.  */
+#define pthread_sigmask(H, S1, S2) 0
+
+#endif /* WIN_PTHREADS_SIGNAL_H */
diff --git a/thirdparty/winpthreads/include/pthread_time.h b/thirdparty/winpthreads/include/pthread_time.h
new file mode 100644
index 00000000..7818b114
--- /dev/null
+++ b/thirdparty/winpthreads/include/pthread_time.h
@@ -0,0 +1,102 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#include <sys/timeb.h>
+
+#ifndef WIN_PTHREADS_TIME_H
+#define WIN_PTHREADS_TIME_H
+
+/* Posix timers are supported */
+#ifndef _POSIX_TIMERS
+#define _POSIX_TIMERS           200809L
+#endif
+
+/* Monotonic clocks are available.  */
+#ifndef _POSIX_MONOTONIC_CLOCK
+#define _POSIX_MONOTONIC_CLOCK  200809L
+#endif
+
+/* CPU-time clocks are available.  */
+#ifndef _POSIX_CPUTIME
+#define _POSIX_CPUTIME          200809L
+#endif
+
+/* Clock support in threads are available.  */
+#ifndef _POSIX_THREAD_CPUTIME
+#define _POSIX_THREAD_CPUTIME   200809L
+#endif
+
+#ifndef __clockid_t_defined
+typedef int clockid_t;
+#define __clockid_t_defined 1
+#endif  /* __clockid_t_defined */
+
+#ifndef TIMER_ABSTIME
+#define TIMER_ABSTIME   1
+#endif
+
+#ifndef CLOCK_REALTIME
+#define CLOCK_REALTIME              0
+#endif
+
+#ifndef CLOCK_MONOTONIC
+#define CLOCK_MONOTONIC             1
+#endif
+
+#ifndef CLOCK_PROCESS_CPUTIME_ID
+#define CLOCK_PROCESS_CPUTIME_ID    2
+#endif
+
+#ifndef CLOCK_THREAD_CPUTIME_ID
+#define CLOCK_THREAD_CPUTIME_ID     3
+#endif
+
+#ifndef CLOCK_REALTIME_COARSE
+#define CLOCK_REALTIME_COARSE       4
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Make sure we provide default for WINPTHREAD_API, if not defined.  */
+#pragma push_macro("WINPTHREAD_API")
+#ifndef WINPTHREAD_API
+#define WINPTHREAD_API
+#endif
+
+/* These should really be dllimport'ed if using winpthread dll */
+int __cdecl WINPTHREAD_API nanosleep(const struct timespec *request, struct timespec *remain);
+
+int __cdecl WINPTHREAD_API clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *request, struct timespec *remain);
+int __cdecl WINPTHREAD_API clock_getres(clockid_t clock_id, struct timespec *res);
+int __cdecl WINPTHREAD_API clock_gettime(clockid_t clock_id, struct timespec *tp);
+int __cdecl WINPTHREAD_API clock_settime(clockid_t clock_id, const struct timespec *tp);
+
+#pragma pop_macro("WINPTHREAD_API")
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WIN_PTHREADS_TIME_H */
+
diff --git a/thirdparty/winpthreads/include/pthread_unistd.h b/thirdparty/winpthreads/include/pthread_unistd.h
new file mode 100644
index 00000000..64693534
--- /dev/null
+++ b/thirdparty/winpthreads/include/pthread_unistd.h
@@ -0,0 +1,192 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef WIN_PTHREADS_UNISTD_H
+#define WIN_PTHREADS_UNISTD_H
+
+/* Set defines described by the POSIX Threads Extension (1003.1c-1995) */
+/* _SC_THREADS
+  Basic support for POSIX threads is available. The functions
+
+  pthread_atfork(),
+  pthread_attr_destroy(),
+  pthread_attr_getdetachstate(),
+  pthread_attr_getschedparam(),
+  pthread_attr_init(),
+  pthread_attr_setdetachstate(),
+  pthread_attr_setschedparam(),
+  pthread_cancel(),
+  pthread_cleanup_push(),
+  pthread_cleanup_pop(),
+  pthread_cond_broadcast(),
+  pthread_cond_destroy(),
+  pthread_cond_init(),
+  pthread_cond_signal(),
+  pthread_cond_timedwait(),
+  pthread_cond_wait(),
+  pthread_condattr_destroy(),
+  pthread_condattr_init(),
+  pthread_create(),
+  pthread_detach(),
+  pthread_equal(),
+  pthread_exit(),
+  pthread_getspecific(),
+  pthread_join(,
+  pthread_key_create(),
+  pthread_key_delete(),
+  pthread_mutex_destroy(),
+  pthread_mutex_init(),
+  pthread_mutex_lock(),
+  pthread_mutex_trylock(),
+  pthread_mutex_unlock(),
+  pthread_mutexattr_destroy(),
+  pthread_mutexattr_init(),
+  pthread_once(),
+  pthread_rwlock_destroy(),
+  pthread_rwlock_init(),
+  pthread_rwlock_rdlock(),
+  pthread_rwlock_tryrdlock(),
+  pthread_rwlock_trywrlock(),
+  pthread_rwlock_unlock(),
+  pthread_rwlock_wrlock(),
+  pthread_rwlockattr_destroy(),
+  pthread_rwlockattr_init(),
+  pthread_self(),
+  pthread_setcancelstate(),
+  pthread_setcanceltype(),
+  pthread_setspecific(),
+  pthread_testcancel()
+
+  are present. */
+#undef _POSIX_THREADS
+#define _POSIX_THREADS 200112L
+
+/* _SC_READER_WRITER_LOCKS
+  This option implies the _POSIX_THREADS option. Conversely, under
+  POSIX 1003.1-2001 the _POSIX_THREADS option implies this option.
+
+  The functions
+  pthread_rwlock_destroy(),
+  pthread_rwlock_init(),
+  pthread_rwlock_rdlock(),
+  pthread_rwlock_tryrdlock(),
+  pthread_rwlock_trywrlock(),
+  pthread_rwlock_unlock(),
+  pthread_rwlock_wrlock(),
+  pthread_rwlockattr_destroy(),
+  pthread_rwlockattr_init()
+
+  are present.
+*/
+#undef _POSIX_READER_WRITER_LOCKS
+#define _POSIX_READER_WRITER_LOCKS 200112L
+
+/* _SC_SPIN_LOCKS
+  This option implies the _POSIX_THREADS and _POSIX_THREAD_SAFE_FUNCTIONS
+  options. The functions
+
+  pthread_spin_destroy(),
+  pthread_spin_init(),
+  pthread_spin_lock(),
+  pthread_spin_trylock(),
+  pthread_spin_unlock()
+
+  are present. */
+#undef _POSIX_SPIN_LOCKS
+#define _POSIX_SPIN_LOCKS 200112L
+
+/* _SC_BARRIERS
+  This option implies the _POSIX_THREADS and _POSIX_THREAD_SAFE_FUNCTIONS
+  options. The functions
+
+  pthread_barrier_destroy(),
+  pthread_barrier_init(),
+  pthread_barrier_wait(),
+  pthread_barrierattr_destroy(),
+  pthread_barrierattr_init()
+
+  are present.
+*/
+#undef _POSIX_BARRIERS
+#define _POSIX_BARRIERS 200112L
+
+/* _SC_TIMEOUTS
+  The functions
+
+  mq_timedreceive(), - not supported
+  mq_timedsend(), - not supported
+  posix_trace_timedgetnext_event(), - not supported
+  pthread_mutex_timedlock(),
+  pthread_rwlock_timedrdlock(),
+  pthread_rwlock_timedwrlock(),
+  sem_timedwait(),
+
+  are present. */
+#undef _POSIX_TIMEOUTS
+#define _POSIX_TIMEOUTS 200112L
+
+/* _SC_TIMERS - not supported
+  The functions
+
+  clock_getres(),
+  clock_gettime(),
+  clock_settime(),
+  nanosleep(),
+  timer_create(),
+  timer_delete(),
+  timer_gettime(),
+  timer_getoverrun(),
+  timer_settime()
+
+  are present.  */
+/* #undef _POSIX_TIMERS */
+
+/* _SC_CLOCK_SELECTION
+   This option implies the _POSIX_TIMERS option. The functions
+
+   pthread_condattr_getclock(),
+   pthread_condattr_setclock(),
+   clock_nanosleep()
+
+   are present.
+*/
+#undef _POSIX_CLOCK_SELECTION
+#define _POSIX_CLOCK_SELECTION 200112
+
+/* _SC_SEMAPHORES
+  The include file <semaphore.h> is present. The functions
+
+  sem_close(),
+  sem_destroy(),
+  sem_getvalue(),
+  sem_init(),
+  sem_open(),
+  sem_post(),
+  sem_trywait(),
+  sem_unlink(),
+  sem_wait()
+
+  are present. */
+#undef _POSIX_SEMAPHORES
+#define _POSIX_SEMAPHORES 200112
+
+#endif /* WIN_PTHREADS_UNISTD_H */
diff --git a/thirdparty/winpthreads/include/sched.h b/thirdparty/winpthreads/include/sched.h
new file mode 100644
index 00000000..b5756a95
--- /dev/null
+++ b/thirdparty/winpthreads/include/sched.h
@@ -0,0 +1,83 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#include <stddef.h>
+#include <errno.h>
+#include <sys/types.h>
+
+#include <process.h>
+#include <limits.h>
+#include <signal.h>
+
+#include <sys/timeb.h>
+
+#ifndef WIN_PTHREADS_SCHED_H
+#define WIN_PTHREADS_SCHED_H
+
+#ifndef SCHED_OTHER
+/* Some POSIX realtime extensions, mostly stubbed */
+#define SCHED_OTHER     0
+#define SCHED_FIFO      1
+#define SCHED_RR        2
+#define SCHED_MIN       SCHED_OTHER
+#define SCHED_MAX       SCHED_RR
+
+struct sched_param {
+  int sched_priority;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(IN_WINPTHREAD)
+#  if defined(DLL_EXPORT) && !defined(WINPTHREAD_EXPORT_ALL_DEBUG)
+#    define WINPTHREAD_SCHED_API  __declspec(dllexport)  /* building the DLL  */
+#  else
+#    define WINPTHREAD_SCHED_API  /* building the static library  */
+#  endif
+#else
+#  if defined(WINPTHREADS_USE_DLLIMPORT)
+#    define WINPTHREAD_SCHED_API  __declspec(dllimport)  /* user wants explicit `dllimport`  */
+#  else
+#    define WINPTHREAD_SCHED_API  /* the default; auto imported in case of DLL  */
+#  endif
+#endif
+
+int WINPTHREAD_SCHED_API sched_yield(void);
+int WINPTHREAD_SCHED_API sched_get_priority_min(int pol);
+int WINPTHREAD_SCHED_API sched_get_priority_max(int pol);
+int WINPTHREAD_SCHED_API sched_getscheduler(pid_t pid);
+int WINPTHREAD_SCHED_API sched_setscheduler(pid_t pid, int pol, const struct sched_param *param);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+#ifndef sched_rr_get_interval
+#define sched_rr_get_interval(_p, _i) \
+  ( errno = ENOTSUP, (int) -1 )
+#endif
+
+#endif /* WIN_PTHREADS_SCHED_H */
diff --git a/thirdparty/winpthreads/include/semaphore.h b/thirdparty/winpthreads/include/semaphore.h
new file mode 100644
index 00000000..6fa417f0
--- /dev/null
+++ b/thirdparty/winpthreads/include/semaphore.h
@@ -0,0 +1,85 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef WIN_PTHREADS_SEMAPHORE_H
+#define WIN_PTHREADS_SEMAPHORE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(IN_WINPTHREAD)
+#  if defined(DLL_EXPORT) && !defined(WINPTHREAD_EXPORT_ALL_DEBUG)
+#    define WINPTHREAD_SEMA_API  __declspec(dllexport)  /* building the DLL  */
+#  else
+#    define WINPTHREAD_SEMA_API  /* building the static library  */
+#  endif
+#else
+#  if defined(WINPTHREADS_USE_DLLIMPORT)
+#    define WINPTHREAD_SEMA_API  __declspec(dllimport)  /* user wants explicit `dllimport`  */
+#  else
+#    define WINPTHREAD_SEMA_API  /* the default; auto imported in case of DLL  */
+#  endif
+#endif
+
+/* Set this to 0 to disable it */
+#define USE_SEM_CriticalSection_SpinCount	100
+
+#define SEM_VALUE_MAX   INT_MAX
+
+#ifndef _MODE_T_
+#define	_MODE_T_
+typedef unsigned short mode_t;
+#endif
+
+typedef void		*sem_t;
+
+#define SEM_FAILED 		NULL
+
+int WINPTHREAD_SEMA_API sem_init(sem_t * sem, int pshared, unsigned int value);
+
+int WINPTHREAD_SEMA_API sem_destroy(sem_t *sem);
+
+int WINPTHREAD_SEMA_API sem_trywait(sem_t *sem);
+
+int WINPTHREAD_SEMA_API sem_wait(sem_t *sem);
+
+int WINPTHREAD_SEMA_API sem_timedwait(sem_t * sem, const struct timespec *t);
+
+int WINPTHREAD_SEMA_API sem_post(sem_t *sem);
+
+int WINPTHREAD_SEMA_API sem_post_multiple(sem_t *sem, int count);
+
+/* yes, it returns a semaphore (or SEM_FAILED) */
+sem_t * WINPTHREAD_SEMA_API sem_open(const char * name, int oflag, mode_t mode, unsigned int value);
+
+int WINPTHREAD_SEMA_API sem_close(sem_t * sem);
+
+int WINPTHREAD_SEMA_API sem_unlink(const char * name);
+
+int WINPTHREAD_SEMA_API sem_getvalue(sem_t * sem, int * sval);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* WIN_PTHREADS_SEMAPHORE_H */
diff --git a/thirdparty/winpthreads/src/barrier.c b/thirdparty/winpthreads/src/barrier.c
new file mode 100644
index 00000000..95b2252a
--- /dev/null
+++ b/thirdparty/winpthreads/src/barrier.c
@@ -0,0 +1,246 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#include <windows.h>
+#include <stdio.h>
+#include <malloc.h>
+#include "pthread.h"
+#include "barrier.h"
+#include "ref.h" 
+#include "misc.h"
+
+static pthread_spinlock_t barrier_global = PTHREAD_SPINLOCK_INITIALIZER;
+
+static WINPTHREADS_ATTRIBUTE((noinline)) int
+barrier_unref(volatile pthread_barrier_t *barrier, int res)
+{
+    pthread_spin_lock(&barrier_global);
+#ifdef WINPTHREAD_DBG
+    assert((((barrier_t *)*barrier)->valid == LIFE_BARRIER) && (((barrier_t *)*barrier)->busy > 0));
+#endif
+     ((barrier_t *)*barrier)->busy -= 1;
+    pthread_spin_unlock(&barrier_global);
+    return res;
+}
+
+static WINPTHREADS_ATTRIBUTE((noinline)) int barrier_ref(volatile pthread_barrier_t *barrier)
+{
+    int r = 0;
+    pthread_spin_lock(&barrier_global);
+
+    if (!barrier || !*barrier || ((barrier_t *)*barrier)->valid != LIFE_BARRIER) r = EINVAL;
+    else {
+        ((barrier_t *)*barrier)->busy += 1;
+    }
+
+    pthread_spin_unlock(&barrier_global);
+
+    return r;
+}
+
+static WINPTHREADS_ATTRIBUTE((noinline))  int
+barrier_ref_destroy(volatile pthread_barrier_t *barrier, pthread_barrier_t *bDestroy)
+{
+    int r = 0;
+
+    *bDestroy = NULL;
+    pthread_spin_lock(&barrier_global);
+    
+    if (!barrier || !*barrier || ((barrier_t *)*barrier)->valid != LIFE_BARRIER) r = EINVAL;
+    else {
+        barrier_t *b_ = (barrier_t *)*barrier;
+        if (b_->busy) r = EBUSY;
+        else {
+            *bDestroy = *barrier;
+            *barrier = NULL;
+        }
+    }
+
+    pthread_spin_unlock(&barrier_global);
+    return r;
+}
+
+static WINPTHREADS_ATTRIBUTE((noinline)) void
+barrier_ref_set (volatile pthread_barrier_t *barrier, void *v)
+{
+  pthread_spin_lock(&barrier_global);
+  *barrier = v;
+  pthread_spin_unlock(&barrier_global);
+}
+
+int pthread_barrier_destroy(pthread_barrier_t *b_)
+{
+    pthread_barrier_t bDestroy;
+    barrier_t *b;
+    int r;
+    
+    while ((r = barrier_ref_destroy(b_,&bDestroy)) == EBUSY)
+      Sleep(0);
+    
+    if (r)
+      return r;
+
+    b = (barrier_t *)bDestroy;
+    
+    pthread_mutex_lock(&b->m);
+
+    if (sem_destroy(&b->sems[0]) != 0)
+    {
+        /* Could this happen? */
+        *b_ = bDestroy;
+        pthread_mutex_unlock (&b->m);
+        return EBUSY;
+    }
+    if (sem_destroy(&b->sems[1]) != 0)
+    {
+      sem_init (&b->sems[0], b->share, 0);
+      *b_ = bDestroy;
+      pthread_mutex_unlock (&b->m);
+      return -1;
+    }
+    pthread_mutex_unlock(&b->m);
+    if(pthread_mutex_destroy(&b->m) != 0) {
+     sem_init (&b->sems[0], b->share, 0);
+     sem_init (&b->sems[1], b->share, 0);
+     *b_ = bDestroy;
+     return -1;
+    }
+    b->valid = DEAD_BARRIER;
+    free(bDestroy);
+    return 0;
+
+}
+
+int
+pthread_barrier_init (pthread_barrier_t *b_, const void *attr,
+		      unsigned int count)
+{
+    barrier_t *b;
+
+    if (!count || !b_)
+      return EINVAL;
+
+    if (!(b = (pthread_barrier_t)calloc(1,sizeof(*b))))
+       return ENOMEM;
+    if (!attr || *((int **)attr) == NULL)
+      b->share = PTHREAD_PROCESS_PRIVATE;
+    else
+      memcpy (&b->share, *((void **) attr), sizeof (int));
+    b->total = count;
+    b->count = count;
+    b->valid = LIFE_BARRIER;
+    b->sel = 0;
+
+    if (pthread_mutex_init(&b->m, NULL) != 0)
+    {
+      free (b);
+      return ENOMEM;
+    }
+
+    if (sem_init(&b->sems[0], b->share, 0) != 0)
+    {
+       pthread_mutex_destroy(&b->m);
+       free (b);
+       return ENOMEM;
+    }
+    if (sem_init(&b->sems[1], b->share, 0) != 0)
+    {
+       pthread_mutex_destroy(&b->m);
+       sem_destroy(&b->sems[0]);
+       free (b);
+       return ENOMEM;
+    }
+    barrier_ref_set (b_,b);
+
+    return 0;
+}
+
+int pthread_barrier_wait(pthread_barrier_t *b_)
+{
+  long sel;
+  int r, e, rslt;
+  barrier_t *b;
+
+  r = barrier_ref(b_);
+  if(r) return r;
+
+  b = (barrier_t *)*b_;
+
+  if ((r = pthread_mutex_lock(&b->m))) return  barrier_unref(b_,EINVAL);
+  sel = b->sel;
+  InterlockedDecrement((long*)&b->total);
+  if (b->total == 0)
+  {
+    b->total = b->count;
+    b->sel = (sel != 0 ? 0 : 1);
+    e = 1;
+    rslt = PTHREAD_BARRIER_SERIAL_THREAD;
+    r = (b->count > 1 ? sem_post_multiple (&b->sems[sel], b->count - 1) : 0);
+  }
+  else { e = 0; rslt= 0; }
+  pthread_mutex_unlock(&b->m);
+  if (!e)
+    r = sem_wait(&b->sems[sel]);
+
+  if (!r) r = rslt;
+  return barrier_unref(b_,r);
+}
+
+int pthread_barrierattr_init(void **attr)
+{
+  int *p;
+
+  if (!(p = (int *) calloc (1, sizeof (int))))
+    return ENOMEM;
+
+  *p = PTHREAD_PROCESS_PRIVATE;
+  *attr = p;
+
+  return 0;
+}
+
+int pthread_barrierattr_destroy(void **attr)
+{
+  void *p;
+  if (!attr || (p = *attr) == NULL)
+    return EINVAL;
+  *attr = NULL;
+  free (p);
+  return 0;
+}
+
+int pthread_barrierattr_setpshared(void **attr, int s)
+{
+  if (!attr || *attr == NULL
+      || (s != PTHREAD_PROCESS_SHARED && s != PTHREAD_PROCESS_PRIVATE))
+    return EINVAL;
+  memcpy (*attr, &s, sizeof (int));
+  return 0;
+}
+
+int pthread_barrierattr_getpshared(void **attr, int *s)
+{
+  if (!attr || !s || *attr == NULL)
+    return EINVAL;
+  memcpy (s, *attr, sizeof (int));
+  return 0;
+}
diff --git a/thirdparty/winpthreads/src/barrier.h b/thirdparty/winpthreads/src/barrier.h
new file mode 100644
index 00000000..b3e2146e
--- /dev/null
+++ b/thirdparty/winpthreads/src/barrier.h
@@ -0,0 +1,49 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef WIN_PTHREADS_BARRIER_H
+#define WIN_PTHREADS_BARRIER_H
+
+#define LIFE_BARRIER 0xBAB1FEED
+#define DEAD_BARRIER 0xDEADB00F
+
+#define _PTHREAD_BARRIER_FLAG (1<<30)
+
+#define CHECK_BARRIER(b)  { \
+    if (!(b) || ( ((barrier_t *)(*b))->valid != (unsigned int)LIFE_BARRIER ) ) return EINVAL; }
+
+#include "../include/semaphore.h"
+
+typedef struct barrier_t barrier_t;
+struct barrier_t
+{
+    int valid;
+    int busy;
+    int count;
+    int total;
+    int share;
+    long sel;
+    pthread_mutex_t m;
+    sem_t sems[2];
+};
+
+#endif
diff --git a/thirdparty/winpthreads/src/clock.c b/thirdparty/winpthreads/src/clock.c
new file mode 100644
index 00000000..25d351b6
--- /dev/null
+++ b/thirdparty/winpthreads/src/clock.c
@@ -0,0 +1,286 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the w64 mingw-runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#include <errno.h>
+#include <stdint.h>
+#include <time.h>
+#include <windows.h>
+#include <stdatomic.h>
+#ifndef IN_WINPTHREAD
+#define IN_WINPTHREAD 1
+#endif
+#include "pthread.h"
+#include "pthread_time.h"
+
+#define POW10_7                 10000000
+#define POW10_9                 1000000000
+
+/* Number of 100ns-seconds between the beginning of the Windows epoch
+ * (Jan. 1, 1601) and the Unix epoch (Jan. 1, 1970)
+ */
+#define DELTA_EPOCH_IN_100NS    INT64_C(116444736000000000)
+
+static WINPTHREADS_INLINE int lc_set_errno(int result)
+{
+    if (result != 0) {
+        errno = result;
+        return -1;
+    }
+    return 0;
+}
+
+typedef void (WINAPI * GetSystemTimeAsFileTime_t)(LPFILETIME);
+static GetSystemTimeAsFileTime_t GetSystemTimeAsFileTime_p /* = 0 */;
+
+static GetSystemTimeAsFileTime_t try_load_GetSystemPreciseTimeAsFileTime()
+{
+    /* Use GetSystemTimePreciseAsFileTime() if available (Windows 8 or later) */
+    GetSystemTimeAsFileTime_t get_time = (GetSystemTimeAsFileTime_t)(intptr_t)GetProcAddress(
+        GetModuleHandle("kernel32.dll"),
+        "GetSystemTimePreciseAsFileTime"); /* <1us precision on Windows 10 */
+    if (get_time == NULL) {
+        get_time = GetSystemTimeAsFileTime; /* >15ms precision on Windows 10 */
+    }
+
+    _InterlockedExchangePointer((PVOID volatile *)&GetSystemTimeAsFileTime_p, get_time);
+    return get_time;
+}
+
+static WINPTHREADS_INLINE GetSystemTimeAsFileTime_t load_GetSystemTimeBestAsFileTime() {
+    static _Atomic(GetSystemTimeAsFileTime_t) GetSystemTimeAsFileTime_p;
+    atomic_init(&GetSystemTimeAsFileTime_p, NULL);
+    GetSystemTimeAsFileTime_t get_time =
+        atomic_load_explicit(&GetSystemTimeAsFileTime_p, memory_order_relaxed);
+    if (get_time == NULL) {
+        get_time = try_load_GetSystemPreciseTimeAsFileTime();
+        atomic_store_explicit(&GetSystemTimeAsFileTime_p, get_time, memory_order_relaxed);
+    }
+    return get_time;
+}
+
+/**
+ * Get the resolution of the specified clock clock_id and
+ * stores it in the struct timespec pointed to by res.
+ * @param  clock_id The clock_id argument is the identifier of the particular
+ *         clock on which to act. The following clocks are supported:
+ * <pre>
+ *     CLOCK_REALTIME  System-wide real-time clock. Setting this clock
+ *                 requires appropriate privileges.
+ *     CLOCK_MONOTONIC Clock that cannot be set and represents monotonic
+ *                 time since some unspecified starting point.
+ *     CLOCK_PROCESS_CPUTIME_ID High-resolution per-process timer from the CPU.
+ *     CLOCK_THREAD_CPUTIME_ID  Thread-specific CPU-time clock.
+ * </pre>
+ * @param  res The pointer to a timespec structure to receive the time
+ *         resolution.
+ * @return If the function succeeds, the return value is 0.
+ *         If the function fails, the return value is -1,
+ *         with errno set to indicate the error.
+ */
+int clock_getres(clockid_t clock_id, struct timespec *res)
+{
+    clockid_t id = clock_id;
+
+    if (id == CLOCK_REALTIME && load_GetSystemTimeBestAsFileTime() == GetSystemTimeAsFileTime)
+        id = CLOCK_REALTIME_COARSE; /* GetSystemTimePreciseAsFileTime() not available */
+
+    switch(id) {
+    case CLOCK_REALTIME:
+    case CLOCK_MONOTONIC:
+        {
+            LARGE_INTEGER pf;
+
+            if (QueryPerformanceFrequency(&pf) == 0)
+                return lc_set_errno(EINVAL);
+
+            res->tv_sec = 0;
+            res->tv_nsec = (int) ((POW10_9 + (pf.QuadPart >> 1)) / pf.QuadPart);
+            if (res->tv_nsec < 1)
+                res->tv_nsec = 1;
+
+            return 0;
+        }
+
+    case CLOCK_REALTIME_COARSE:
+    case CLOCK_PROCESS_CPUTIME_ID:
+    case CLOCK_THREAD_CPUTIME_ID:
+        {
+            DWORD   timeAdjustment, timeIncrement;
+            BOOL    isTimeAdjustmentDisabled;
+
+            (void) GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement, &isTimeAdjustmentDisabled);
+            res->tv_sec = 0;
+            res->tv_nsec = timeIncrement * 100;
+
+            return 0;
+        }
+    default:
+        break;
+    }
+
+    return lc_set_errno(EINVAL);
+}
+
+/**
+ * Get the time of the specified clock clock_id and stores it in the struct
+ * timespec pointed to by tp.
+ * @param  clock_id The clock_id argument is the identifier of the particular
+ *         clock on which to act. The following clocks are supported:
+ * <pre>
+ *     CLOCK_REALTIME  System-wide real-time clock. Setting this clock
+ *                 requires appropriate privileges.
+ *     CLOCK_MONOTONIC Clock that cannot be set and represents monotonic
+ *                 time since some unspecified starting point.
+ *     CLOCK_PROCESS_CPUTIME_ID High-resolution per-process timer from the CPU.
+ *     CLOCK_THREAD_CPUTIME_ID  Thread-specific CPU-time clock.
+ * </pre>
+ * @param  tp The pointer to a timespec structure to receive the time.
+ * @return If the function succeeds, the return value is 0.
+ *         If the function fails, the return value is -1,
+ *         with errno set to indicate the error.
+ */
+int clock_gettime(clockid_t clock_id, struct timespec *tp)
+{
+    unsigned __int64 t;
+    LARGE_INTEGER pf, pc;
+    union {
+        unsigned __int64 u64;
+        FILETIME ft;
+    }  ct, et, kt, ut;
+
+    switch(clock_id) {
+    case CLOCK_REALTIME:
+        {
+            load_GetSystemTimeBestAsFileTime()(&ct.ft);
+            t = ct.u64 - DELTA_EPOCH_IN_100NS;
+            tp->tv_sec = t / POW10_7;
+            tp->tv_nsec = ((int) (t % POW10_7)) * 100;
+
+            return 0;
+        }
+
+    case CLOCK_REALTIME_COARSE:
+        {
+            GetSystemTimeAsFileTime(&ct.ft);
+            t = ct.u64 - DELTA_EPOCH_IN_100NS;
+            tp->tv_sec = t / POW10_7;
+            tp->tv_nsec = ((int) (t % POW10_7)) * 100;
+
+            return 0;
+        }
+
+    case CLOCK_MONOTONIC:
+        {
+            if (QueryPerformanceFrequency(&pf) == 0)
+                return lc_set_errno(EINVAL);
+
+            if (QueryPerformanceCounter(&pc) == 0)
+                return lc_set_errno(EINVAL);
+
+            tp->tv_sec = pc.QuadPart / pf.QuadPart;
+            tp->tv_nsec = (int) (((pc.QuadPart % pf.QuadPart) * POW10_9 + (pf.QuadPart >> 1)) / pf.QuadPart);
+            if (tp->tv_nsec >= POW10_9) {
+                tp->tv_sec ++;
+                tp->tv_nsec -= POW10_9;
+            }
+
+            return 0;
+        }
+
+    case CLOCK_PROCESS_CPUTIME_ID:
+        {
+        if(0 == GetProcessTimes(GetCurrentProcess(), &ct.ft, &et.ft, &kt.ft, &ut.ft))
+            return lc_set_errno(EINVAL);
+        t = kt.u64 + ut.u64;
+        tp->tv_sec = t / POW10_7;
+        tp->tv_nsec = ((int) (t % POW10_7)) * 100;
+
+        return 0;
+        }
+
+    case CLOCK_THREAD_CPUTIME_ID: 
+        {
+            if(0 == GetThreadTimes(GetCurrentThread(), &ct.ft, &et.ft, &kt.ft, &ut.ft))
+                return lc_set_errno(EINVAL);
+            t = kt.u64 + ut.u64;
+            tp->tv_sec = t / POW10_7;
+            tp->tv_nsec = ((int) (t % POW10_7)) * 100;
+
+            return 0;
+        }
+
+    default:
+        break;
+    }
+
+    return lc_set_errno(EINVAL);
+}
+
+/**
+ * Sleep for the specified time.
+ * @param  clock_id This argument should always be CLOCK_REALTIME (0).
+ * @param  flags 0 for relative sleep interval, others for absolute waking up.
+ * @param  request The desired sleep interval or absolute waking up time.
+ * @param  remain The remain amount of time to sleep.
+ *         The current implemention just ignore it.
+ * @return If the function succeeds, the return value is 0.
+ *         If the function fails, the return value is -1,
+ *         with errno set to indicate the error.
+ */
+int clock_nanosleep(clockid_t clock_id, int flags,
+                           const struct timespec *request,
+                           struct timespec *remain)
+{
+    struct timespec tp;
+
+    if (clock_id != CLOCK_REALTIME)
+        return lc_set_errno(EINVAL);
+
+    if (flags == 0)
+        return nanosleep(request, remain);
+
+    /* TIMER_ABSTIME = 1 */
+    clock_gettime(CLOCK_REALTIME, &tp);
+
+    tp.tv_sec = request->tv_sec - tp.tv_sec;
+    tp.tv_nsec = request->tv_nsec - tp.tv_nsec;
+    if (tp.tv_nsec < 0) {
+        tp.tv_nsec += POW10_9;
+        tp.tv_sec --;
+    }
+
+    return nanosleep(&tp, remain);
+}
+
+/**
+ * Set the time of the specified clock clock_id.
+ * @param  clock_id This argument should always be CLOCK_REALTIME (0).
+ * @param  tp The requested time.
+ * @return If the function succeeds, the return value is 0.
+ *         If the function fails, the return value is -1,
+ *         with errno set to indicate the error.
+ */
+int clock_settime(clockid_t clock_id, const struct timespec *tp)
+{
+    SYSTEMTIME st;
+
+    union {
+        unsigned __int64 u64;
+        FILETIME ft;
+    }  t;
+
+    if (clock_id != CLOCK_REALTIME)
+        return lc_set_errno(EINVAL);
+
+    t.u64 = tp->tv_sec * (__int64) POW10_7 + tp->tv_nsec / 100 + DELTA_EPOCH_IN_100NS;
+    if (FileTimeToSystemTime(&t.ft, &st) == 0)
+        return lc_set_errno(EINVAL);
+
+    if (SetSystemTime(&st) == 0)
+        return lc_set_errno(EPERM);
+
+    return 0;
+}
diff --git a/thirdparty/winpthreads/src/cond.c b/thirdparty/winpthreads/src/cond.c
new file mode 100644
index 00000000..d50f85b4
--- /dev/null
+++ b/thirdparty/winpthreads/src/cond.c
@@ -0,0 +1,755 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+/*
+ * Posix Condition Variables for Microsoft Windows.
+ * 22-9-2010 Partly based on the ACE framework implementation.
+ */
+#include <windows.h>
+#include <stdio.h>
+#include <malloc.h>
+#include <time.h>
+#include "pthread.h"
+#include "pthread_time.h"
+#include "ref.h"
+#include "cond.h"
+#include "thread.h"
+#include "misc.h"
+#include "winpthread_internal.h"
+
+#include "pthread_compat.h"
+
+int __pthread_shallcancel (void);
+
+static int do_sema_b_wait (HANDLE sema, int nointerrupt, DWORD timeout,CRITICAL_SECTION *cs, LONG *val);
+static int do_sema_b_release(HANDLE sema, LONG count,CRITICAL_SECTION *cs, LONG *val);
+static void cleanup_wait(void *arg);
+
+typedef struct sCondWaitHelper {
+    cond_t *c;
+    pthread_mutex_t *external_mutex;
+    int *r;
+} sCondWaitHelper;
+
+int do_sema_b_wait_intern (HANDLE sema, int nointerrupt, DWORD timeout);
+
+#ifdef WINPTHREAD_DBG
+static int print_state = 0;
+static FILE *fo;
+void cond_print_set(int state, FILE *f)
+{
+    if (f) fo = f;
+    if (!fo) fo = stdout;
+    print_state = state;
+}
+
+void cond_print(volatile pthread_cond_t *c, char *txt)
+{
+    if (!print_state) return;
+    cond_t *c_ = (cond_t *)*c;
+    if (c_ == NULL) {
+        fprintf(fo,"C%p %d %s\n",(void *)*c,(int)GetCurrentThreadId(),txt);
+    } else {
+        fprintf(fo,"C%p %d V=%0X w=%ld %s\n",
+            (void *)*c,
+            (int)GetCurrentThreadId(), 
+            (int)c_->valid, 
+            c_->waiters_count_,
+            txt
+            );
+    }
+}
+#endif
+
+static pthread_spinlock_t cond_locked = PTHREAD_SPINLOCK_INITIALIZER;
+
+static int
+cond_static_init (pthread_cond_t *c)
+{
+  int r = 0;
+  
+  pthread_spin_lock (&cond_locked);
+  if (c == NULL)
+    r = EINVAL;
+  else if (*c == PTHREAD_COND_INITIALIZER)
+    r = pthread_cond_init (c, NULL);
+  else
+    /* We assume someone was faster ... */
+    r = 0;
+  pthread_spin_unlock (&cond_locked);
+  return r;
+}
+
+int
+pthread_condattr_destroy (pthread_condattr_t *a)
+{
+  if (!a)
+    return EINVAL;
+   *a = 0;
+   return 0;
+}
+
+int
+pthread_condattr_init (pthread_condattr_t *a)
+{
+  if (!a)
+    return EINVAL;
+  *a = 0;
+  return 0;
+}
+
+int
+pthread_condattr_getpshared (const pthread_condattr_t *a, int *s)
+{
+  if (!a || !s)
+    return EINVAL;
+  *s = *a;
+  return 0;
+}
+
+int
+pthread_condattr_getclock (const pthread_condattr_t *a, clockid_t *clock_id)
+{
+  if (!a || !clock_id)
+    return EINVAL;
+  *clock_id = 0;
+  return 0;
+}
+
+int
+pthread_condattr_setclock(pthread_condattr_t *a, clockid_t clock_id)
+{
+  if (!a || clock_id != 0)
+    return EINVAL;
+  return 0;
+}
+
+int
+__pthread_clock_nanosleep (clockid_t clock_id, int flags, const struct timespec *rqtp,
+			   struct timespec *rmtp)
+{
+  unsigned long long tick, tick2;
+  unsigned long long delay;
+  DWORD dw;
+
+  if (clock_id != CLOCK_REALTIME
+      && clock_id != CLOCK_MONOTONIC
+      && clock_id != CLOCK_PROCESS_CPUTIME_ID)
+   return EINVAL;
+  if ((flags & TIMER_ABSTIME) != 0)
+    delay = _pthread_rel_time_in_ms (rqtp);
+  else
+    delay = _pthread_time_in_ms_from_timespec (rqtp);
+  do
+    {
+      dw = (DWORD) (delay >= 99999ULL ? 99999ULL : delay);
+      tick = _pthread_time_in_ms ();
+      pthread_delay_np_ms (dw);
+      tick2 = _pthread_time_in_ms ();
+      tick2 -= tick;
+      if (tick2 >= delay)
+        delay = 0;
+      else
+        delay -= tick2;
+    }
+  while (delay != 0ULL);
+  if (rmtp)
+    memset (rmtp, 0, sizeof (*rmtp));
+  return 0;
+}
+
+int
+pthread_condattr_setpshared (pthread_condattr_t *a, int s)
+{
+  if (!a || (s != PTHREAD_PROCESS_SHARED && s != PTHREAD_PROCESS_PRIVATE))
+    return EINVAL;
+  if (s == PTHREAD_PROCESS_SHARED)
+    {
+       *a = PTHREAD_PROCESS_PRIVATE;
+       return ENOSYS;
+    }
+  *a = s;
+  return 0;
+}
+
+int
+pthread_cond_init (pthread_cond_t *c, const pthread_condattr_t *a)
+{
+  cond_t *_c;
+  int r = 0;
+
+  if (!c)
+    return EINVAL;
+  if (a && *a == PTHREAD_PROCESS_SHARED)
+    return ENOSYS;
+
+  if ( !(_c = calloc(1,sizeof(*_c))) ) {
+      return ENOMEM; 
+  }
+  _c->valid  = DEAD_COND;
+  _c->busy = 0;
+  _c->waiters_count_ = 0;
+  _c->waiters_count_gone_ = 0;
+  _c->waiters_count_unblock_ = 0;
+
+  _c->sema_q = CreateSemaphore (NULL,       /* no security */
+      0,          /* initially 0 */
+      0x7fffffff, /* max count */
+      NULL);      /* unnamed  */
+  _c->sema_b =  CreateSemaphore (NULL,       /* no security */
+      0,          /* initially 0 */
+      0x7fffffff, /* max count */
+      NULL);  
+  if (_c->sema_q == NULL || _c->sema_b == NULL) {
+      if (_c->sema_q != NULL)
+	CloseHandle (_c->sema_q);
+      if (_c->sema_b != NULL)
+	CloseHandle (_c->sema_b);
+      free (_c);
+      r = EAGAIN;
+  } else {
+      InitializeCriticalSection(&_c->waiters_count_lock_);
+      InitializeCriticalSection(&_c->waiters_b_lock_);
+      InitializeCriticalSection(&_c->waiters_q_lock_);
+      _c->value_q = 0;
+      _c->value_b = 1;
+  }
+  if (!r)
+    {
+      _c->valid = LIFE_COND;
+      *c = (pthread_cond_t)_c;
+    }
+  else
+    *c = (pthread_cond_t)NULL;
+  return r;
+}
+
+int
+pthread_cond_destroy (pthread_cond_t *c)
+{
+  cond_t *_c;
+  int r;
+  if (!c || !*c)
+    return EINVAL;
+  if (*c == PTHREAD_COND_INITIALIZER)
+    {
+      pthread_spin_lock (&cond_locked);
+      if (*c == PTHREAD_COND_INITIALIZER)
+      {
+	*c = (pthread_cond_t)NULL;
+	r = 0;
+      }
+      else
+	r = EBUSY;
+      pthread_spin_unlock (&cond_locked);
+      return r;
+    }
+  _c = (cond_t *) *c;
+  r = do_sema_b_wait(_c->sema_b, 0, INFINITE,&_c->waiters_b_lock_,&_c->value_b);
+  if (r != 0)
+    return r;
+  if (!TryEnterCriticalSection (&_c->waiters_count_lock_))
+    {
+       do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
+       return EBUSY;
+    }
+  if (_c->waiters_count_ > _c->waiters_count_gone_)
+    {
+      r = do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
+      if (!r) r = EBUSY;
+      LeaveCriticalSection(&_c->waiters_count_lock_);
+      return r;
+    }
+  *c = (pthread_cond_t)NULL;
+  do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
+
+  if (!CloseHandle (_c->sema_q) && !r)
+    r = EINVAL;
+  if (!CloseHandle (_c->sema_b) && !r)
+    r = EINVAL;
+  LeaveCriticalSection (&_c->waiters_count_lock_);
+  DeleteCriticalSection(&_c->waiters_count_lock_);
+  DeleteCriticalSection(&_c->waiters_b_lock_);
+  DeleteCriticalSection(&_c->waiters_q_lock_);
+  _c->valid  = DEAD_COND;
+  free(_c);
+  return 0;
+}
+
+int
+pthread_cond_signal (pthread_cond_t *c)
+{
+  cond_t *_c;
+  int r;
+
+  if (!c || !*c)
+    return EINVAL;
+  _c = (cond_t *)*c;
+  if (_c == (cond_t *)PTHREAD_COND_INITIALIZER)
+    return 0;
+  else if (_c->valid != (unsigned int)LIFE_COND)
+    return EINVAL;
+
+  EnterCriticalSection (&_c->waiters_count_lock_);
+  /* If there aren't any waiters, then this is a no-op.   */
+  if (_c->waiters_count_unblock_ != 0)
+    {
+      if (_c->waiters_count_ == 0)
+      {
+	LeaveCriticalSection (&_c->waiters_count_lock_);
+	/* pthread_testcancel(); */
+	return 0;
+      }
+      _c->waiters_count_ -= 1;
+      _c->waiters_count_unblock_ += 1;
+    }
+  else if (_c->waiters_count_ > _c->waiters_count_gone_)
+    {
+      r = do_sema_b_wait (_c->sema_b, 1, INFINITE,&_c->waiters_b_lock_,&_c->value_b);
+      if (r != 0)
+      {
+	LeaveCriticalSection (&_c->waiters_count_lock_);
+	/* pthread_testcancel(); */
+	return r;
+      }
+      if (_c->waiters_count_gone_ != 0)
+      {
+	_c->waiters_count_ -= _c->waiters_count_gone_;
+	_c->waiters_count_gone_ = 0;
+      }
+      _c->waiters_count_ -= 1;
+      _c->waiters_count_unblock_ = 1;
+    }
+  else
+    {
+      LeaveCriticalSection (&_c->waiters_count_lock_);
+      /* pthread_testcancel(); */
+      return 0;
+    }
+  LeaveCriticalSection (&_c->waiters_count_lock_);
+  r = do_sema_b_release(_c->sema_q, 1,&_c->waiters_q_lock_,&_c->value_q);
+  /* pthread_testcancel(); */
+  return r;
+}
+
+int
+pthread_cond_broadcast (pthread_cond_t *c)
+{
+  cond_t *_c;
+  int r;
+  int relCnt = 0;    
+
+  if (!c || !*c)
+    return EINVAL;
+  _c = (cond_t *)*c;
+  if (_c == (cond_t*)PTHREAD_COND_INITIALIZER)
+    return 0;
+  else if (_c->valid != (unsigned int)LIFE_COND)
+    return EINVAL;
+
+  EnterCriticalSection (&_c->waiters_count_lock_);
+  /* If there aren't any waiters, then this is a no-op.   */
+  if (_c->waiters_count_unblock_ != 0)
+    {
+      if (_c->waiters_count_ == 0)
+      {
+	LeaveCriticalSection (&_c->waiters_count_lock_);
+	/* pthread_testcancel(); */
+	return 0;
+      }
+      relCnt = _c->waiters_count_;
+      _c->waiters_count_ = 0;
+      _c->waiters_count_unblock_ += relCnt;
+    }
+  else if (_c->waiters_count_ > _c->waiters_count_gone_)
+    {
+      r = do_sema_b_wait (_c->sema_b, 1, INFINITE,&_c->waiters_b_lock_,&_c->value_b);
+      if (r != 0)
+      {
+	LeaveCriticalSection (&_c->waiters_count_lock_);
+	/* pthread_testcancel(); */
+	return r;
+      }
+      if (_c->waiters_count_gone_ != 0)
+      {
+	_c->waiters_count_ -= _c->waiters_count_gone_;
+	_c->waiters_count_gone_ = 0;
+      }
+      relCnt = _c->waiters_count_;
+      _c->waiters_count_ = 0;
+      _c->waiters_count_unblock_ = relCnt;
+    }
+  else
+    {
+      LeaveCriticalSection (&_c->waiters_count_lock_);
+      /* pthread_testcancel(); */
+      return 0;
+    }
+  LeaveCriticalSection (&_c->waiters_count_lock_);
+  r = do_sema_b_release(_c->sema_q, relCnt,&_c->waiters_q_lock_,&_c->value_q);
+  /* pthread_testcancel(); */
+  return r;
+}
+
+int
+pthread_cond_wait (pthread_cond_t *c, pthread_mutex_t *external_mutex)
+{
+  sCondWaitHelper ch;
+  cond_t *_c;
+  int r;
+
+  /* pthread_testcancel(); */
+
+  if (!c || *c == (pthread_cond_t)NULL)
+    return EINVAL;
+  _c = (cond_t *)*c;
+  if (*c == PTHREAD_COND_INITIALIZER)
+  {
+    r = cond_static_init(c);
+    if (r != 0 && r != EBUSY)
+      return r;
+    _c = (cond_t *) *c;
+  } else if (_c->valid != (unsigned int)LIFE_COND)
+    return EINVAL;
+
+tryagain:
+  r = do_sema_b_wait (_c->sema_b, 0, INFINITE,&_c->waiters_b_lock_,&_c->value_b);
+  if (r != 0)
+    return r;
+
+  if (!TryEnterCriticalSection (&_c->waiters_count_lock_))
+  {
+    r = do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
+    if (r != 0)
+      return r;
+    sched_yield();
+    goto tryagain;
+  }
+
+  _c->waiters_count_++;
+  LeaveCriticalSection(&_c->waiters_count_lock_);
+  r = do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
+  if (r != 0)
+    return r;
+
+  ch.c = _c;
+  ch.r = &r;
+  ch.external_mutex = external_mutex;
+
+  pthread_cleanup_push(cleanup_wait, (void *) &ch);
+  r = pthread_mutex_unlock(external_mutex);
+  if (!r)
+    r = do_sema_b_wait (_c->sema_q, 0, INFINITE,&_c->waiters_q_lock_,&_c->value_q);
+
+  pthread_cleanup_pop(1);
+  return r;
+}
+
+static int
+pthread_cond_timedwait_impl (pthread_cond_t *c, pthread_mutex_t *external_mutex, const struct timespec *t, int rel)
+{
+  sCondWaitHelper ch;
+  DWORD dwr;
+  int r;
+  cond_t *_c;
+
+  /* pthread_testcancel(); */
+
+  if (!c || !*c)
+    return EINVAL;
+  _c = (cond_t *)*c;
+  if (_c == (cond_t *)PTHREAD_COND_INITIALIZER)
+  {
+    r = cond_static_init(c);
+    if (r && r != EBUSY)
+      return r;
+    _c = (cond_t *) *c;
+  } else if ((_c)->valid != (unsigned int)LIFE_COND)
+    return EINVAL;
+
+  if (rel == 0)
+  {
+    dwr = dwMilliSecs(_pthread_rel_time_in_ms(t));
+  }
+  else
+  {
+    dwr = dwMilliSecs(_pthread_time_in_ms_from_timespec(t));
+  }
+
+tryagain:
+  r = do_sema_b_wait (_c->sema_b, 0, INFINITE,&_c->waiters_b_lock_,&_c->value_b);
+  if (r != 0)
+    return r;
+
+  if (!TryEnterCriticalSection (&_c->waiters_count_lock_))
+  {
+    r = do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
+    if (r != 0)
+      return r;
+    sched_yield();
+    goto tryagain;
+  }
+
+  _c->waiters_count_++;
+  LeaveCriticalSection(&_c->waiters_count_lock_);
+  r = do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
+  if (r != 0)
+    return r;
+
+  ch.c = _c;
+  ch.r = &r;
+  ch.external_mutex = external_mutex;
+  {
+    pthread_cleanup_push(cleanup_wait, (void *) &ch);
+
+    r = pthread_mutex_unlock(external_mutex);
+    if (!r)
+      r = do_sema_b_wait (_c->sema_q, 0, dwr,&_c->waiters_q_lock_,&_c->value_q);
+
+    pthread_cleanup_pop(1);
+  }
+  return r;
+}
+
+int
+pthread_cond_timedwait(pthread_cond_t *c, pthread_mutex_t *m, const struct timespec *t)
+{
+  return pthread_cond_timedwait_impl(c, m, t, 0);
+}
+
+int
+pthread_cond_timedwait_relative_np(pthread_cond_t *c, pthread_mutex_t *m, const struct timespec *t)
+{
+  return pthread_cond_timedwait_impl(c, m, t, 1);
+}
+
+static void
+cleanup_wait (void *arg)
+{
+  int n, r;
+  sCondWaitHelper *ch = (sCondWaitHelper *) arg;
+  cond_t *_c;
+
+  _c = ch->c;
+  EnterCriticalSection (&_c->waiters_count_lock_);
+  n = _c->waiters_count_unblock_;
+  if (n != 0)
+    _c->waiters_count_unblock_ -= 1;
+  else if ((INT_MAX/2) - 1 == _c->waiters_count_gone_)
+  {
+    _c->waiters_count_gone_ += 1;
+    r = do_sema_b_wait (_c->sema_b, 1, INFINITE,&_c->waiters_b_lock_,&_c->value_b);
+    if (r != 0)
+    {
+      LeaveCriticalSection(&_c->waiters_count_lock_);
+      ch->r[0] = r;
+      return;
+    }
+    _c->waiters_count_ -= _c->waiters_count_gone_;
+    r = do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
+    if (r != 0)
+    {
+      LeaveCriticalSection(&_c->waiters_count_lock_);
+      ch->r[0] = r;
+      return;
+    }
+    _c->waiters_count_gone_ = 0;
+  }
+  else
+    _c->waiters_count_gone_ += 1;
+  LeaveCriticalSection (&_c->waiters_count_lock_);
+
+  if (n == 1)
+  {
+    r = do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
+    if (r != 0)
+    {
+      ch->r[0] = r;
+      return;
+    }
+  }
+  r = pthread_mutex_lock(ch->external_mutex);
+  if (r != 0)
+    ch->r[0] = r;
+}
+
+static int
+do_sema_b_wait (HANDLE sema, int nointerrupt, DWORD timeout,CRITICAL_SECTION *cs, LONG *val)
+{
+  int r;
+  LONG v;
+  EnterCriticalSection(cs);
+  InterlockedDecrement(val);
+  v = val[0];
+  LeaveCriticalSection(cs);
+  if (v >= 0)
+    return 0;
+  r = do_sema_b_wait_intern (sema, nointerrupt, timeout);
+  EnterCriticalSection(cs);
+  if (r != 0)
+    InterlockedIncrement(val);
+  LeaveCriticalSection(cs);
+  return r;
+}
+
+int
+do_sema_b_wait_intern (HANDLE sema, int nointerrupt, DWORD timeout)
+{
+  HANDLE arr[2];
+  DWORD maxH = 1;
+  int r = 0;
+  DWORD res, dt;
+  if (nointerrupt == 1)
+  {
+    res = _pthread_wait_for_single_object(sema, timeout);
+    switch (res) {
+    case WAIT_TIMEOUT:
+	r = ETIMEDOUT;
+	break;
+    case WAIT_ABANDONED:
+	r = EPERM;
+	break;
+    case WAIT_OBJECT_0:
+	break;
+    default:
+	/*We can only return EINVAL though it might not be posix compliant  */
+	r = EINVAL;
+    }
+    if (r != 0 && r != EINVAL && WaitForSingleObject(sema, 0) == WAIT_OBJECT_0)
+      r = 0;
+    return r;
+  }
+  arr[0] = sema;
+  arr[1] = (HANDLE) pthread_getevent ();
+  if (arr[1] != NULL) maxH += 1;
+  if (maxH == 2)
+  {
+redo:
+      res = _pthread_wait_for_multiple_objects(maxH, arr, 0, timeout);
+      switch (res) {
+      case WAIT_TIMEOUT:
+	  r = ETIMEDOUT;
+	  break;
+      case (WAIT_OBJECT_0 + 1):
+          ResetEvent(arr[1]);
+          if (nointerrupt != 2)
+	    {
+            pthread_testcancel();
+            return EINVAL;
+	    }
+	  pthread_testcancel ();
+	  goto redo;
+      case WAIT_ABANDONED:
+	  r = EPERM;
+	  break;
+      case WAIT_OBJECT_0:
+          r = 0;
+	  break;
+      default:
+	  /*We can only return EINVAL though it might not be posix compliant  */
+	  r = EINVAL;
+      }
+      if (r != 0 && r != EINVAL && WaitForSingleObject(arr[0], 0) == WAIT_OBJECT_0)
+	r = 0;
+      if (r != 0 && nointerrupt != 2 && __pthread_shallcancel ())
+	return EINVAL;
+      return r;
+  }
+  if (timeout == INFINITE)
+  {
+    do {
+      res = _pthread_wait_for_single_object(sema, 40);
+      switch (res) {
+      case WAIT_TIMEOUT:
+	  r = ETIMEDOUT;
+	  break;
+      case WAIT_ABANDONED:
+	  r = EPERM;
+	  break;
+      case WAIT_OBJECT_0:
+          r = 0;
+	  break;
+      default:
+	  /*We can only return EINVAL though it might not be posix compliant  */
+	  r = EINVAL;
+      }
+      if (r != 0 && __pthread_shallcancel ())
+      {
+	if (nointerrupt != 2)
+	  pthread_testcancel();
+	return EINVAL;
+      }
+    } while (r == ETIMEDOUT);
+    if (r != 0 && r != EINVAL && WaitForSingleObject(sema, 0) == WAIT_OBJECT_0)
+      r = 0;
+    return r;
+  }
+  dt = 20;
+  do {
+    if (dt > timeout) dt = timeout;
+    res = _pthread_wait_for_single_object(sema, dt);
+    switch (res) {
+    case WAIT_TIMEOUT:
+	r = ETIMEDOUT;
+	break;
+    case WAIT_ABANDONED:
+	r = EPERM;
+	break;
+    case WAIT_OBJECT_0:
+	r = 0;
+	break;
+    default:
+	/*We can only return EINVAL though it might not be posix compliant  */
+	r = EINVAL;
+    }
+    timeout -= dt;
+    if (timeout != 0 && r != 0 && __pthread_shallcancel ())
+      return EINVAL;
+  } while (r == ETIMEDOUT && timeout != 0);
+  if (r != 0 && r == ETIMEDOUT && WaitForSingleObject(sema, 0) == WAIT_OBJECT_0)
+    r = 0;
+  if (r != 0 && nointerrupt != 2)
+    pthread_testcancel();
+  return r;
+}
+
+static int
+do_sema_b_release(HANDLE sema, LONG count,CRITICAL_SECTION *cs, LONG *val)
+{
+  int wc;
+  EnterCriticalSection(cs);
+  if (((long long) val[0] + (long long) count) > (long long) 0x7fffffffLL)
+  {
+    LeaveCriticalSection(cs);
+    return ERANGE;
+  }
+  wc = -val[0];
+  InterlockedExchangeAdd(val, count);
+  if (wc <= 0 || ReleaseSemaphore(sema, (wc < count ? wc : count), NULL))
+  {
+    LeaveCriticalSection(cs);
+    return 0;
+  }
+  InterlockedExchangeAdd(val, -count);
+  LeaveCriticalSection(cs);
+  return EINVAL;  
+}
diff --git a/thirdparty/winpthreads/src/cond.h b/thirdparty/winpthreads/src/cond.h
new file mode 100644
index 00000000..c70d3114
--- /dev/null
+++ b/thirdparty/winpthreads/src/cond.h
@@ -0,0 +1,61 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef WIN_PTHREADS_COND_H
+#define WIN_PTHREADS_COND_H
+
+#include <windows.h>
+
+#define CHECK_COND(c)  { \
+    if (!(c) || !*c || (*c == PTHREAD_COND_INITIALIZER) \
+        || ( ((cond_t *)(*c))->valid != (unsigned int)LIFE_COND ) ) \
+        return EINVAL; }
+
+#define LIFE_COND 0xC0BAB1FD
+#define DEAD_COND 0xC0DEADBF
+
+#define STATIC_COND_INITIALIZER(x)		((pthread_cond_t)(x) == ((pthread_cond_t)PTHREAD_COND_INITIALIZER))
+
+typedef struct cond_t cond_t;
+struct cond_t
+{
+    unsigned int valid;   
+    int busy;
+    LONG waiters_count_; /* Number of waiting threads.  */
+    LONG waiters_count_unblock_; /* Number of waiting threads whitch can be unblocked.  */
+    LONG waiters_count_gone_; /* Number of waiters which are gone.  */
+    CRITICAL_SECTION waiters_count_lock_; /* Serialize access to <waiters_count_>.  */
+    CRITICAL_SECTION waiters_q_lock_; /* Serialize access to sema_q.  */
+    LONG value_q;
+    CRITICAL_SECTION waiters_b_lock_; /* Serialize access to sema_b.  */
+    LONG value_b;
+    HANDLE sema_q; /* Semaphore used to queue up threads waiting for the condition to
+                 become signaled.  */
+    HANDLE sema_b; /* Semaphore used to queue up threads waiting for the condition which
+                 became signaled.  */
+};
+
+void cond_print_set(int state, FILE *f);
+
+void cond_print(volatile pthread_cond_t *c, char *txt);
+
+#endif
diff --git a/thirdparty/winpthreads/src/libgcc/dll_dependency.S b/thirdparty/winpthreads/src/libgcc/dll_dependency.S
new file mode 100644
index 00000000..0496e940
--- /dev/null
+++ b/thirdparty/winpthreads/src/libgcc/dll_dependency.S
@@ -0,0 +1,90 @@
+/* Implementation for gcc's internal stack-allocation routines.  */
+#if defined(__i386__) || defined(__x86_64__)
+.global ___chkstk
+.global	__alloca
+
+.global ___chkstk_ms
+___chkstk_ms:
+#ifdef _WIN64
+	pushq	%rax
+	pushq	%rcx
+	cmpq	$0x1000, %rax
+	leaq	24(%rsp), %rcx
+	jb	.Lchkstk_ms_end
+.Lchkstk_ms_loop:
+	subq	$0x1000, %rcx
+	subq	$0x1000, %rax
+	orq	$0x0, (%rcx)
+	cmpq	$0x1000, %rax
+	ja	.Lchkstk_ms_loop
+.Lchkstk_ms_end:
+	subq	%rax, %rcx
+	orq	$0x0, (%rcx)
+	popq	%rcx
+	popq	%rax
+	ret
+#else
+	pushl	%eax
+	pushl	%ecx
+	cmpl	$0x1000, %eax
+	leal	12(%esp), %ecx
+	jb	chkstk_ms_end
+chkstk_ms_loop:
+	subl	$0x1000, %ecx
+	subl	$0x1000, %eax
+	orl	$0x0, (%ecx)
+	cmpl	$0x1000, %eax
+	ja	chkstk_ms_loop
+chkstk_ms_end:
+	subl	%eax, %ecx
+	orl	$0x0, (%ecx)
+	popl	%ecx
+	popl	%eax
+	ret
+#endif
+
+#ifdef _WIN64
+__alloca:
+	movq	%rcx, %rax
+.align	4
+___chkstk:
+	popq	%r11
+	movq	%rsp, %r10
+	cmpq	$0x1000, %rax
+	jb	.Lchkstk_end
+.Lchkstk_loop:
+	subq	$0x1000, %r10
+	subq	$0x1000, %rax
+	orl	$0x0, (%r10)
+	cmpq	$0x1000, %rax
+	ja	.Lchkstk_loop
+.Lchkstk_end:
+	subq	%rax, %r10
+	movq	%rsp, %rax
+	orl	$0x0, (%r10)
+	movq	%r10, %rsp
+	pushq	%r11
+	ret
+#else
+___chkstk:
+__alloca:
+	pushl	%ecx
+	leal	8(%esp), %ecx
+	cmpl	$0x1000, %eax		/* > 4k ?*/
+	jb	chkstk_end
+chkstk_loop:
+	subl	$0x1000, %ecx
+	subl	$0x1000, %eax
+	orl	$0x0, (%ecx)
+	cmpl	$0x1000, %eax
+	ja	chkstk_loop
+chkstk_end:
+	subl	%eax, %ecx	   
+	orl	$0x0, (%ecx)
+	movl	%esp, %eax
+	movl	%ecx, %esp
+	movl	(%eax), %ecx
+	pushl	4(%eax)
+	ret
+#endif
+#endif
diff --git a/thirdparty/winpthreads/src/libgcc/dll_math.c b/thirdparty/winpthreads/src/libgcc/dll_math.c
new file mode 100644
index 00000000..77bb1fea
--- /dev/null
+++ b/thirdparty/winpthreads/src/libgcc/dll_math.c
@@ -0,0 +1,586 @@
+/*-
+ * Copyright (c) 1992, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This software was developed by the Computer Systems Engineering group
+ * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
+ * contributed to Berkeley.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifndef _LIBKERN_QUAD_H_
+#define	_LIBKERN_QUAD_H_
+
+/*
+ * Quad arithmetic.
+ *
+ * This library makes the following assumptions:
+ *
+ *  - The type long long (aka quad_t) exists.
+ *
+ *  - A quad variable is exactly twice as long as `long'.
+ *
+ *  - The machine's arithmetic is two's complement.
+ *
+ * This library can provide 128-bit arithmetic on a machine with 128-bit
+ * quads and 64-bit longs, for instance, or 96-bit arithmetic on machines
+ * with 48-bit longs.
+ */
+/*
+#include <sys/cdefs.h>
+#include <sys/types.h>
+#include <sys/limits.h>
+#include <sys/syslimits.h>
+*/
+
+#include <limits.h>
+typedef long long quad_t;
+typedef unsigned long long u_quad_t;
+typedef unsigned long u_long;
+#define CHAR_BIT __CHAR_BIT__
+
+/*
+ * Define the order of 32-bit words in 64-bit words.
+ * For little endian only.
+ */
+#define _QUAD_HIGHWORD 1
+#define _QUAD_LOWWORD 0
+
+/*
+ * Depending on the desired operation, we view a `long long' (aka quad_t) in
+ * one or more of the following formats.
+ */
+union uu {
+	quad_t	q;		/* as a (signed) quad */
+	quad_t	uq;		/* as an unsigned quad */
+	long	sl[2];		/* as two signed longs */
+	u_long	ul[2];		/* as two unsigned longs */
+};
+
+/*
+ * Define high and low longwords.
+ */
+#define	H		_QUAD_HIGHWORD
+#define	L		_QUAD_LOWWORD
+
+/*
+ * Total number of bits in a quad_t and in the pieces that make it up.
+ * These are used for shifting, and also below for halfword extraction
+ * and assembly.
+ */
+#define	QUAD_BITS	(sizeof(quad_t) * CHAR_BIT)
+#define	LONG_BITS	(sizeof(long) * CHAR_BIT)
+#define	HALF_BITS	(sizeof(long) * CHAR_BIT / 2)
+
+/*
+ * Extract high and low shortwords from longword, and move low shortword of
+ * longword to upper half of long, i.e., produce the upper longword of
+ * ((quad_t)(x) << (number_of_bits_in_long/2)).  (`x' must actually be u_long.)
+ *
+ * These are used in the multiply code, to split a longword into upper
+ * and lower halves, and to reassemble a product as a quad_t, shifted left
+ * (sizeof(long)*CHAR_BIT/2).
+ */
+#define	HHALF(x)	((x) >> HALF_BITS)
+#define	LHALF(x)	((x) & ((1 << HALF_BITS) - 1))
+#define	LHUP(x)		((x) << HALF_BITS)
+
+typedef unsigned int	qshift_t;
+
+quad_t		__ashldi3(quad_t, qshift_t);
+quad_t		__ashrdi3(quad_t, qshift_t);
+int		__cmpdi2(quad_t a, quad_t b);
+quad_t		__divdi3(quad_t a, quad_t b);
+quad_t		__lshrdi3(quad_t, qshift_t);
+quad_t		__moddi3(quad_t a, quad_t b);
+u_quad_t	__qdivrem(u_quad_t u, u_quad_t v, u_quad_t *rem);
+u_quad_t	__udivdi3(u_quad_t a, u_quad_t b);
+u_quad_t	__umoddi3(u_quad_t a, u_quad_t b);
+int		__ucmpdi2(u_quad_t a, u_quad_t b);
+quad_t	__divmoddi4(quad_t a, quad_t b, quad_t *rem);
+u_quad_t	__udivmoddi4(u_quad_t a, u_quad_t b, u_quad_t *rem);
+
+#endif /* !_LIBKERN_QUAD_H_ */
+
+#if defined (_X86_) && !defined (__x86_64__)
+/*
+ * Shift a (signed) quad value left (arithmetic shift left).
+ * This is the same as logical shift left!
+ */
+quad_t
+__ashldi3(a, shift)
+	quad_t a;
+	qshift_t shift;
+{
+	union uu aa;
+
+	aa.q = a;
+	if (shift >= LONG_BITS) {
+		aa.ul[H] = shift >= QUAD_BITS ? 0 :
+		    aa.ul[L] << (shift - LONG_BITS);
+		aa.ul[L] = 0;
+	} else if (shift > 0) {
+		aa.ul[H] = (aa.ul[H] << shift) |
+		    (aa.ul[L] >> (LONG_BITS - shift));
+		aa.ul[L] <<= shift;
+	}
+	return (aa.q);
+}
+
+/*
+ * Shift a (signed) quad value right (arithmetic shift right).
+ */
+quad_t
+__ashrdi3(a, shift)
+	quad_t a;
+	qshift_t shift;
+{
+	union uu aa;
+
+	aa.q = a;
+	if (shift >= LONG_BITS) {
+		long s;
+
+		/*
+		 * Smear bits rightward using the machine's right-shift
+		 * method, whether that is sign extension or zero fill,
+		 * to get the `sign word' s.  Note that shifting by
+		 * LONG_BITS is undefined, so we shift (LONG_BITS-1),
+		 * then 1 more, to get our answer.
+		 */
+		s = (aa.sl[H] >> (LONG_BITS - 1)) >> 1;
+		aa.ul[L] = shift >= QUAD_BITS ? s :
+		    aa.sl[H] >> (shift - LONG_BITS);
+		aa.ul[H] = s;
+	} else if (shift > 0) {
+		aa.ul[L] = (aa.ul[L] >> shift) |
+		    (aa.ul[H] << (LONG_BITS - shift));
+		aa.sl[H] >>= shift;
+	}
+	return (aa.q);
+}
+
+/*
+ * Return 0, 1, or 2 as a <, =, > b respectively.
+ * Both a and b are considered signed---which means only the high word is
+ * signed.
+ */
+int
+__cmpdi2(a, b)
+	quad_t a, b;
+{
+	union uu aa, bb;
+
+	aa.q = a;
+	bb.q = b;
+	return (aa.sl[H] < bb.sl[H] ? 0 : aa.sl[H] > bb.sl[H] ? 2 :
+	    aa.ul[L] < bb.ul[L] ? 0 : aa.ul[L] > bb.ul[L] ? 2 : 1);
+}
+
+/*
+ * Divide two signed quads.
+ * ??? if -1/2 should produce -1 on this machine, this code is wrong
+ */
+quad_t
+__divdi3(a, b)
+	quad_t a, b;
+{
+	u_quad_t ua, ub, uq;
+	int neg;
+
+	if (a < 0)
+		ua = -(u_quad_t)a, neg = 1;
+	else
+		ua = a, neg = 0;
+	if (b < 0)
+		ub = -(u_quad_t)b, neg ^= 1;
+	else
+		ub = b;
+	uq = __qdivrem(ua, ub, (u_quad_t *)0);
+	return (neg ? -uq : uq);
+}
+
+/*
+ * Shift an (unsigned) quad value right (logical shift right).
+ */
+quad_t
+__lshrdi3(a, shift)
+	quad_t a;
+	qshift_t shift;
+{
+	union uu aa;
+
+	aa.q = a;
+	if (shift >= LONG_BITS) {
+		aa.ul[L] = shift >= QUAD_BITS ? 0 :
+		    aa.ul[H] >> (shift - LONG_BITS);
+		aa.ul[H] = 0;
+	} else if (shift > 0) {
+		aa.ul[L] = (aa.ul[L] >> shift) |
+		    (aa.ul[H] << (LONG_BITS - shift));
+		aa.ul[H] >>= shift;
+	}
+	return (aa.q);
+}
+
+/*
+ * Return remainder after dividing two signed quads.
+ *
+ * XXX
+ * If -1/2 should produce -1 on this machine, this code is wrong.
+ */
+quad_t
+__moddi3(a, b)
+	quad_t a, b;
+{
+	u_quad_t ua, ub, ur;
+	int neg;
+
+	if (a < 0)
+		ua = -(u_quad_t)a, neg = 1;
+	else
+		ua = a, neg = 0;
+	if (b < 0)
+		ub = -(u_quad_t)b;
+	else
+		ub = b;
+	(void)__qdivrem(ua, ub, &ur);
+	return (neg ? -ur : ur);
+}
+
+
+/*
+ * Multiprecision divide.  This algorithm is from Knuth vol. 2 (2nd ed),
+ * section 4.3.1, pp. 257--259.
+ */
+
+#define	B	(1 << HALF_BITS)	/* digit base */
+
+/* Combine two `digits' to make a single two-digit number. */
+#define	COMBINE(a, b) (((u_long)(a) << HALF_BITS) | (b))
+
+/* select a type for digits in base B: use unsigned short if they fit */
+#if ULONG_MAX == 0xffffffff && USHRT_MAX >= 0xffff
+typedef unsigned short digit;
+#else
+typedef u_long digit;
+#endif
+
+/*
+ * Shift p[0]..p[len] left `sh' bits, ignoring any bits that
+ * `fall out' the left (there never will be any such anyway).
+ * We may assume len >= 0.  NOTE THAT THIS WRITES len+1 DIGITS.
+ */
+static void
+__shl(register digit *p, register int len, register int sh)
+{
+	register int i;
+
+	for (i = 0; i < len; i++)
+		p[i] = LHALF(p[i] << sh) | (p[i + 1] >> (HALF_BITS - sh));
+	p[i] = LHALF(p[i] << sh);
+}
+
+/*
+ * __qdivrem(u, v, rem) returns u/v and, optionally, sets *rem to u%v.
+ *
+ * We do this in base 2-sup-HALF_BITS, so that all intermediate products
+ * fit within u_long.  As a consequence, the maximum length dividend and
+ * divisor are 4 `digits' in this base (they are shorter if they have
+ * leading zeros).
+ */
+u_quad_t
+__qdivrem(uq, vq, arq)
+	u_quad_t uq, vq, *arq;
+{
+	union uu tmp;
+	digit *u, *v, *q;
+	register digit v1, v2;
+	u_long qhat, rhat, t;
+	int m, n, d, j, i;
+	digit uspace[5], vspace[5], qspace[5];
+
+	/*
+	 * Take care of special cases: divide by zero, and u < v.
+	 */
+	if (vq == 0) {
+		/* divide by zero. */
+		static volatile const unsigned int zero = 0;
+
+		tmp.ul[H] = tmp.ul[L] = 1 / zero;
+		if (arq)
+			*arq = uq;
+		return (tmp.q);
+	}
+	if (uq < vq) {
+		if (arq)
+			*arq = uq;
+		return (0);
+	}
+	u = &uspace[0];
+	v = &vspace[0];
+	q = &qspace[0];
+
+	/*
+	 * Break dividend and divisor into digits in base B, then
+	 * count leading zeros to determine m and n.  When done, we
+	 * will have:
+	 *	u = (u[1]u[2]...u[m+n]) sub B
+	 *	v = (v[1]v[2]...v[n]) sub B
+	 *	v[1] != 0
+	 *	1 < n <= 4 (if n = 1, we use a different division algorithm)
+	 *	m >= 0 (otherwise u < v, which we already checked)
+	 *	m + n = 4
+	 * and thus
+	 *	m = 4 - n <= 2
+	 */
+	tmp.uq = uq;
+	u[0] = 0;
+	u[1] = HHALF(tmp.ul[H]);
+	u[2] = LHALF(tmp.ul[H]);
+	u[3] = HHALF(tmp.ul[L]);
+	u[4] = LHALF(tmp.ul[L]);
+	tmp.uq = vq;
+	v[1] = HHALF(tmp.ul[H]);
+	v[2] = LHALF(tmp.ul[H]);
+	v[3] = HHALF(tmp.ul[L]);
+	v[4] = LHALF(tmp.ul[L]);
+	for (n = 4; v[1] == 0; v++) {
+		if (--n == 1) {
+			u_long rbj;	/* r*B+u[j] (not root boy jim) */
+			digit q1, q2, q3, q4;
+
+			/*
+			 * Change of plan, per exercise 16.
+			 *	r = 0;
+			 *	for j = 1..4:
+			 *		q[j] = floor((r*B + u[j]) / v),
+			 *		r = (r*B + u[j]) % v;
+			 * We unroll this completely here.
+			 */
+			t = v[2];	/* nonzero, by definition */
+			q1 = u[1] / t;
+			rbj = COMBINE(u[1] % t, u[2]);
+			q2 = rbj / t;
+			rbj = COMBINE(rbj % t, u[3]);
+			q3 = rbj / t;
+			rbj = COMBINE(rbj % t, u[4]);
+			q4 = rbj / t;
+			if (arq)
+				*arq = rbj % t;
+			tmp.ul[H] = COMBINE(q1, q2);
+			tmp.ul[L] = COMBINE(q3, q4);
+			return (tmp.q);
+		}
+	}
+
+	/*
+	 * By adjusting q once we determine m, we can guarantee that
+	 * there is a complete four-digit quotient at &qspace[1] when
+	 * we finally stop.
+	 */
+	for (m = 4 - n; u[1] == 0; u++)
+		m--;
+	for (i = 4 - m; --i >= 0;)
+		q[i] = 0;
+	q += 4 - m;
+
+	/*
+	 * Here we run Program D, translated from MIX to C and acquiring
+	 * a few minor changes.
+	 *
+	 * D1: choose multiplier 1 << d to ensure v[1] >= B/2.
+	 */
+	d = 0;
+	for (t = v[1]; t < B / 2; t <<= 1)
+		d++;
+	if (d > 0) {
+		__shl(&u[0], m + n, d);		/* u <<= d */
+		__shl(&v[1], n - 1, d);		/* v <<= d */
+	}
+	/*
+	 * D2: j = 0.
+	 */
+	j = 0;
+	v1 = v[1];	/* for D3 -- note that v[1..n] are constant */
+	v2 = v[2];	/* for D3 */
+	do {
+		register digit uj0, uj1, uj2;
+
+		/*
+		 * D3: Calculate qhat (\^q, in TeX notation).
+		 * Let qhat = min((u[j]*B + u[j+1])/v[1], B-1), and
+		 * let rhat = (u[j]*B + u[j+1]) mod v[1].
+		 * While rhat < B and v[2]*qhat > rhat*B+u[j+2],
+		 * decrement qhat and increase rhat correspondingly.
+		 * Note that if rhat >= B, v[2]*qhat < rhat*B.
+		 */
+		uj0 = u[j + 0];	/* for D3 only -- note that u[j+...] change */
+		uj1 = u[j + 1];	/* for D3 only */
+		uj2 = u[j + 2];	/* for D3 only */
+		if (uj0 == v1) {
+			qhat = B;
+			rhat = uj1;
+			goto qhat_too_big;
+		} else {
+			u_long nn = COMBINE(uj0, uj1);
+			qhat = nn / v1;
+			rhat = nn % v1;
+		}
+		while (v2 * qhat > COMBINE(rhat, uj2)) {
+	qhat_too_big:
+			qhat--;
+			if ((rhat += v1) >= B)
+				break;
+		}
+		/*
+		 * D4: Multiply and subtract.
+		 * The variable `t' holds any borrows across the loop.
+		 * We split this up so that we do not require v[0] = 0,
+		 * and to eliminate a final special case.
+		 */
+		for (t = 0, i = n; i > 0; i--) {
+			t = u[i + j] - v[i] * qhat - t;
+			u[i + j] = LHALF(t);
+			t = (B - HHALF(t)) & (B - 1);
+		}
+		t = u[j] - t;
+		u[j] = LHALF(t);
+		/*
+		 * D5: test remainder.
+		 * There is a borrow if and only if HHALF(t) is nonzero;
+		 * in that (rare) case, qhat was too large (by exactly 1).
+		 * Fix it by adding v[1..n] to u[j..j+n].
+		 */
+		if (HHALF(t)) {
+			qhat--;
+			for (t = 0, i = n; i > 0; i--) { /* D6: add back. */
+				t += u[i + j] + v[i];
+				u[i + j] = LHALF(t);
+				t = HHALF(t);
+			}
+			u[j] = LHALF(u[j] + t);
+		}
+		q[j] = qhat;
+	} while (++j <= m);		/* D7: loop on j. */
+
+	/*
+	 * If caller wants the remainder, we have to calculate it as
+	 * u[m..m+n] >> d (this is at most n digits and thus fits in
+	 * u[m+1..m+n], but we may need more source digits).
+	 */
+	if (arq) {
+		if (d) {
+			for (i = m + n; i > m; --i)
+				u[i] = (u[i] >> d) |
+				    LHALF(u[i - 1] << (HALF_BITS - d));
+			u[i] = 0;
+		}
+		tmp.ul[H] = COMBINE(uspace[1], uspace[2]);
+		tmp.ul[L] = COMBINE(uspace[3], uspace[4]);
+		*arq = tmp.q;
+	}
+
+	tmp.ul[H] = COMBINE(qspace[1], qspace[2]);
+	tmp.ul[L] = COMBINE(qspace[3], qspace[4]);
+	return (tmp.q);
+}
+
+/*
+ * Return 0, 1, or 2 as a <, =, > b respectively.
+ * Neither a nor b are considered signed.
+ */
+int
+__ucmpdi2(a, b)
+	u_quad_t a, b;
+{
+	union uu aa, bb;
+
+	aa.uq = a;
+	bb.uq = b;
+	return (aa.ul[H] < bb.ul[H] ? 0 : aa.ul[H] > bb.ul[H] ? 2 :
+	    aa.ul[L] < bb.ul[L] ? 0 : aa.ul[L] > bb.ul[L] ? 2 : 1);
+}
+
+/*
+ * Divide two unsigned quads.
+ */
+u_quad_t
+__udivdi3(a, b)
+	u_quad_t a, b;
+{
+
+	return (__qdivrem(a, b, (u_quad_t *)0));
+}
+
+/*
+ * Return remainder after dividing two unsigned quads.
+ */
+u_quad_t
+__umoddi3(a, b)
+	u_quad_t a, b;
+{
+	u_quad_t r;
+
+	(void)__qdivrem(a, b, &r);
+	return (r);
+}
+
+/*
+ * Divide two signed quads.
+ * This function is new in GCC 7.
+ */
+quad_t
+__divmoddi4(a, b, rem)
+	quad_t a, b, *rem;
+{
+	u_quad_t ua, ub, uq, ur;
+	int negq, negr;
+
+	if (a < 0)
+		ua = -(u_quad_t)a, negq = 1, negr = 1;
+	else
+		ua = a, negq = 0, negr = 0;
+	if (b < 0)
+		ub = -(u_quad_t)b, negq ^= 1;
+	else
+		ub = b;
+	uq = __qdivrem(ua, ub, &ur);
+	if (rem)
+		*rem = (negr ? -ur : ur);
+	return (negq ? -uq : uq);
+}
+
+u_quad_t
+__udivmoddi4(u_quad_t a, u_quad_t b, u_quad_t *rem)
+{
+  return __qdivrem(a, b, rem);
+}
+
+#else
+static int __attribute__((unused)) dummy;
+#endif /*deined (_X86_) && !defined (__x86_64__)*/
+
diff --git a/thirdparty/winpthreads/src/misc.c b/thirdparty/winpthreads/src/misc.c
new file mode 100644
index 00000000..16ed488e
--- /dev/null
+++ b/thirdparty/winpthreads/src/misc.c
@@ -0,0 +1,158 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#include "pthread.h"
+#include "windows.h"
+#include "misc.h"
+
+unsigned long long _pthread_time_in_ms(void)
+{
+    FILETIME ft;
+
+    GetSystemTimeAsFileTime(&ft);
+    return (((unsigned long long)ft.dwHighDateTime << 32) + ft.dwLowDateTime
+            - 0x19DB1DED53E8000ULL) / 10000ULL;
+}
+
+unsigned long long _pthread_time_in_ms_from_timespec(const struct timespec *ts)
+{
+    unsigned long long t = (unsigned long long) ts->tv_sec * 1000LL;
+    /* The +999999 is here to ensure that the division always rounds up */
+    t += (unsigned long long) (ts->tv_nsec + 999999) / 1000000;
+
+    return t;
+}
+
+unsigned long long _pthread_rel_time_in_ms(const struct timespec *ts)
+{
+    unsigned long long t1 = _pthread_time_in_ms_from_timespec(ts);
+    unsigned long long t2 = _pthread_time_in_ms();
+
+    /* Prevent underflow */
+    if (t1 < t2) return 0;
+    return t1 - t2;
+}
+
+static unsigned long long
+_pthread_get_tick_count (long long *frequency)
+{
+#if defined (_WIN32_WINNT) && (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
+  (void) frequency; /* unused */
+  return GetTickCount64 ();
+#else
+  LARGE_INTEGER freq, timestamp;
+
+  if (*frequency == 0)
+  {
+    if (QueryPerformanceFrequency (&freq))
+      *frequency = freq.QuadPart;
+    else
+      *frequency = -1;
+  }
+
+  if (*frequency > 0 && QueryPerformanceCounter (&timestamp))
+    return timestamp.QuadPart / (*frequency / 1000);
+
+  /* Fallback */
+  return GetTickCount ();
+#endif
+}
+
+/* A wrapper around WaitForSingleObject() that ensures that
+ * the wait function does not time out before the time
+ * actually runs out. This is needed because WaitForSingleObject()
+ * might have poor accuracy, returning earlier than expected.
+ * On the other hand, returning a bit *later* than expected
+ * is acceptable in a preemptive multitasking environment.
+ */
+unsigned long
+_pthread_wait_for_single_object (void *handle, unsigned long timeout)
+{
+  DWORD result;
+  unsigned long long start_time, end_time;
+  unsigned long wait_time;
+  long long frequency = 0;
+
+  if (timeout == INFINITE || timeout == 0)
+    return WaitForSingleObject ((HANDLE) handle, (DWORD) timeout);
+
+  start_time = _pthread_get_tick_count (&frequency);
+  end_time = start_time + timeout;
+  wait_time = timeout;
+
+  do
+  {
+    unsigned long long current_time;
+
+    result = WaitForSingleObject ((HANDLE) handle, (DWORD) wait_time);
+    if (result != WAIT_TIMEOUT)
+      break;
+
+    current_time = _pthread_get_tick_count (&frequency);
+    if (current_time >= end_time)
+      break;
+
+    wait_time = (DWORD) (end_time - current_time);
+  } while (TRUE);
+
+  return result;
+}
+
+/* A wrapper around WaitForMultipleObjects() that ensures that
+ * the wait function does not time out before the time
+ * actually runs out. This is needed because WaitForMultipleObjects()
+ * might have poor accuracy, returning earlier than expected.
+ * On the other hand, returning a bit *later* than expected
+ * is acceptable in a preemptive multitasking environment.
+ */
+unsigned long
+_pthread_wait_for_multiple_objects (unsigned long count, void **handles, unsigned int all, unsigned long timeout)
+{
+  DWORD result;
+  unsigned long long start_time, end_time;
+  unsigned long wait_time;
+  long long frequency = 0;
+
+  if (timeout == INFINITE || timeout == 0)
+    return WaitForMultipleObjects ((DWORD) count, (HANDLE *) handles, all, (DWORD) timeout);
+
+  start_time = _pthread_get_tick_count (&frequency);
+  end_time = start_time + timeout;
+  wait_time = timeout;
+
+  do
+  {
+    unsigned long long current_time;
+
+    result = WaitForMultipleObjects ((DWORD) count, (HANDLE *) handles, all, (DWORD) wait_time);
+    if (result != WAIT_TIMEOUT)
+      break;
+
+    current_time = _pthread_get_tick_count (&frequency);
+    if (current_time >= end_time)
+      break;
+
+    wait_time = (DWORD) (end_time - current_time);
+  } while (TRUE);
+
+  return result;
+}
diff --git a/thirdparty/winpthreads/src/misc.h b/thirdparty/winpthreads/src/misc.h
new file mode 100644
index 00000000..cdb24268
--- /dev/null
+++ b/thirdparty/winpthreads/src/misc.h
@@ -0,0 +1,114 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef WIN_PTHREADS_MISC_H
+#define WIN_PTHREADS_MISC_H
+
+#include "pthread_compat.h"
+
+#ifndef assert
+
+#ifndef ASSERT_TRACE
+# define ASSERT_TRACE 0
+#else
+# undef ASSERT_TRACE
+# define ASSERT_TRACE 0
+#endif
+
+# define assert(e) \
+   ((e) ? ((ASSERT_TRACE) ? fprintf(stderr, \
+                                    "Assertion succeeded: (%s), file %s, line %d\n", \
+                        #e, __FILE__, (int) __LINE__), \
+                                fflush(stderr) : \
+                             0) : \
+          (fprintf(stderr, "Assertion failed: (%s), file %s, line %d\n", \
+                   #e, __FILE__, (int) __LINE__), exit(1), 0))
+
+# define fixme(e) \
+   ((e) ? ((ASSERT_TRACE) ? fprintf(stderr, \
+                                    "Assertion succeeded: (%s), file %s, line %d\n", \
+                        #e, __FILE__, (int) __LINE__), \
+                                fflush(stderr) : \
+                             0) : \
+          (fprintf(stderr, "FIXME: (%s), file %s, line %d\n", \
+                   #e, __FILE__, (int) __LINE__), 0, 0))
+
+#endif
+
+#define PTR2INT(x)	((int)(uintptr_t)(x))
+
+#if SIZE_MAX>UINT_MAX
+typedef long long LONGBAG;
+#else
+typedef long LONGBAG;
+#endif
+
+#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+#undef GetHandleInformation
+#define GetHandleInformation(h,f)  (1)
+#endif
+
+#define CHECK_HANDLE(h) { DWORD dwFlags; \
+    if (!(h) || ((h) == INVALID_HANDLE_VALUE) || !GetHandleInformation((h), &dwFlags)) \
+    return EINVAL; }
+
+#define CHECK_PTR(p)    if (!(p)) return EINVAL;
+
+#define UPD_RESULT(x,r)    { int _r=(x); r = r ? r : _r; }
+
+#define CHECK_THREAD(t)  { \
+    CHECK_PTR(t); \
+    CHECK_HANDLE(t->h); }
+
+#define CHECK_OBJECT(o, e)  { DWORD dwFlags; \
+    if (!(o)) return e; \
+    if (!((o)->h) || (((o)->h) == INVALID_HANDLE_VALUE) || !GetHandleInformation(((o)->h), &dwFlags)) \
+        return e; }
+
+#define VALID(x)    if (!(p)) return EINVAL;
+
+/* ms can be 64 bit, solve wrap-around issues: */
+static WINPTHREADS_INLINE unsigned long dwMilliSecs(unsigned long long ms)
+{
+  if (ms >= 0xffffffffULL) return 0xfffffffful;
+  return (unsigned long) ms;
+}
+
+#ifndef _mm_pause
+#define _mm_pause()			{__asm__ __volatile__("pause");}
+#endif
+
+#ifndef _ReadWriteBarrier
+#define _ReadWriteBarrier   __sync_synchronize
+#endif
+
+#ifndef YieldProcessor
+#define YieldProcessor      _mm_pause
+#endif
+
+unsigned long long _pthread_time_in_ms(void);
+unsigned long long _pthread_time_in_ms_from_timespec(const struct timespec *ts);
+unsigned long long _pthread_rel_time_in_ms(const struct timespec *ts);
+unsigned long _pthread_wait_for_single_object (void *handle, unsigned long timeout);
+unsigned long _pthread_wait_for_multiple_objects (unsigned long count, void **handles, unsigned int all, unsigned long timeout);
+
+#endif
diff --git a/thirdparty/winpthreads/src/mutex.c b/thirdparty/winpthreads/src/mutex.c
new file mode 100644
index 00000000..c6f26139
--- /dev/null
+++ b/thirdparty/winpthreads/src/mutex.c
@@ -0,0 +1,385 @@
+/*
+   Copyright (c) 2011, 2014 mingw-w64 project
+   Copyright (c) 2015 Intel Corporation
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#include <windows.h>
+#include <stdio.h>
+#include <malloc.h>
+#include <stdbool.h>
+#include "pthread.h"
+#include "misc.h"
+
+typedef enum {
+  Unlocked,        /* Not locked. */
+  Locked,          /* Locked but without waiters. */
+  Waiting,         /* Locked, may have waiters. */
+} mutex_state_t;
+
+typedef enum {
+  Normal,
+  Errorcheck,
+  Recursive,
+} mutex_type_t;
+
+/* The heap-allocated part of a mutex. */
+typedef struct {
+  mutex_state_t state;
+  mutex_type_t type;
+  HANDLE event;       /* Auto-reset event, or NULL if not yet allocated. */
+  unsigned rec_lock;  /* For recursive mutexes, the number of times the
+                         mutex has been locked in excess by the same thread. */
+  volatile DWORD owner;  /* For recursive and error-checking mutexes, the
+                            ID of the owning thread if the mutex is locked. */
+} mutex_impl_t;
+
+/* Whether a mutex is still a static initializer (not a pointer to
+   a mutex_impl_t). */
+static bool
+is_static_initializer(pthread_mutex_t m)
+{
+  /* Treat 0 as a static initializer as well (for normal mutexes),
+     to tolerate sloppy code in libgomp. (We should rather fix that code!) */
+  intptr_t v = (intptr_t)m;
+  return v >= -3 && v <= 0;
+/* Should be simple:
+  return (uintptr_t)m >= (uintptr_t)-3; */
+}
+
+/* Create and return the implementation part of a mutex from a static
+   initialiser. Return NULL on out-of-memory error. */
+static WINPTHREADS_ATTRIBUTE((noinline)) mutex_impl_t *
+mutex_impl_init(pthread_mutex_t *m, mutex_impl_t *mi)
+{
+  mutex_impl_t *new_mi = malloc(sizeof(mutex_impl_t));
+  if (new_mi == NULL)
+    return NULL;
+  new_mi->state = Unlocked;
+  new_mi->type = (mi == (void *)PTHREAD_RECURSIVE_MUTEX_INITIALIZER ? Recursive
+                  : mi == (void *)PTHREAD_ERRORCHECK_MUTEX_INITIALIZER ? Errorcheck
+                  : Normal);
+  new_mi->event = NULL;
+  new_mi->rec_lock = 0;
+  new_mi->owner = (DWORD)-1;
+  if (__sync_bool_compare_and_swap(m, (pthread_mutex_t)mi, (pthread_mutex_t)new_mi)) {
+    return new_mi;
+  } else {
+    /* Someone created the struct before us. */
+    free(new_mi);
+    return (mutex_impl_t *)*m;
+  }
+}
+
+#define likely(cond) __builtin_expect((cond) != 0, 1)
+#define unlikely(cond) __builtin_expect((cond) != 0, 0)
+
+/* Return the implementation part of a mutex, creating it if necessary.
+   Return NULL on out-of-memory error. */
+static inline mutex_impl_t *
+mutex_impl(pthread_mutex_t *m)
+{
+  mutex_impl_t *mi = (mutex_impl_t *)*m;
+  if (is_static_initializer((pthread_mutex_t)mi)) {
+    return mutex_impl_init(m, mi);
+  } else {
+    /* mi cannot be null here; avoid a test in the fast path. */
+    if (mi == NULL)
+      __builtin_unreachable();
+    return mi;
+  }
+}
+
+/* Lock a mutex. Give up after 'timeout' ms (with ETIMEDOUT),
+   or never if timeout=INFINITE. */
+static inline int
+pthread_mutex_lock_intern (pthread_mutex_t *m, DWORD timeout)
+{
+  mutex_impl_t *mi = mutex_impl(m);
+  if (mi == NULL)
+    return ENOMEM;
+
+  mutex_state_t old_state = __sync_lock_test_and_set(&mi->state, Locked);
+  if (unlikely(old_state != Unlocked)) {
+    /* The mutex is already locked. */
+
+    if (mi->type != Normal) {
+      /* Recursive or Errorcheck */
+      if (mi->owner == GetCurrentThreadId()) {
+        /* FIXME: A recursive mutex should not need two atomic ops when locking
+           recursively.  We could rewrite by doing compare-and-swap instead of
+           test-and-set the first time, but it would lead to more code
+           duplication and add a conditional branch to the critical path. */
+        __sync_bool_compare_and_swap(&mi->state, Locked, old_state);
+        if (mi->type == Recursive) {
+          mi->rec_lock++;
+          return 0;
+        } else {
+          /* type == Errorcheck */
+          return EDEADLK;
+        }
+      }
+    }
+
+    /* Make sure there is an event object on which to wait. */
+    if (mi->event == NULL) {
+      /* Make an auto-reset event object. */
+      HANDLE ev = CreateEvent(NULL, false, false, NULL);
+      if (ev == NULL) {
+        switch (GetLastError()) {
+        case ERROR_ACCESS_DENIED:
+          return EPERM;
+        default:
+          return ENOMEM;    /* Probably accurate enough. */
+        }
+      }
+      if (!__sync_bool_compare_and_swap(&mi->event, NULL, ev)) {
+        /* Someone created the event before us. */
+        CloseHandle(ev);
+      }
+    }
+
+    /* At this point, mi->event is non-NULL. */
+
+    while (__sync_lock_test_and_set(&mi->state, Waiting) != Unlocked) {
+      /* For timed locking attempts, it is possible (although unlikely)
+         that we are woken up but someone else grabs the lock before us,
+         and we have to go back to sleep again. In that case, the total
+         wait may be longer than expected. */
+
+      unsigned r = _pthread_wait_for_single_object(mi->event, timeout);
+      switch (r) {
+      case WAIT_TIMEOUT:
+        return ETIMEDOUT;
+      case WAIT_OBJECT_0:
+        break;
+      default:
+        return EINVAL;
+      }
+    }
+  }
+
+  if (mi->type != Normal)
+    mi->owner = GetCurrentThreadId();
+
+  return 0;
+}
+
+int
+pthread_mutex_lock (pthread_mutex_t *m)
+{
+  return pthread_mutex_lock_intern (m, INFINITE);
+}
+
+int pthread_mutex_timedlock(pthread_mutex_t *m, const struct timespec *ts)
+{
+  unsigned long long patience;
+  if (ts != NULL) {
+    unsigned long long end = _pthread_time_in_ms_from_timespec(ts);
+    unsigned long long now = _pthread_time_in_ms();
+    patience = end > now ? end - now : 0;
+    if (patience > 0xffffffff)
+      patience = INFINITE;
+  } else {
+    patience = INFINITE;
+  }
+  return pthread_mutex_lock_intern(m, patience);
+}
+
+int pthread_mutex_unlock(pthread_mutex_t *m)
+{    
+  /* Here m might an initialiser of an error-checking or recursive mutex, in
+     which case the behaviour is well-defined, so we can't skip this check. */
+  mutex_impl_t *mi = mutex_impl(m);
+  if (mi == NULL)
+    return ENOMEM;
+
+  if (unlikely(mi->type != Normal)) {
+    if (mi->state == Unlocked)
+      return EINVAL;
+    if (mi->owner != GetCurrentThreadId())
+      return EPERM;
+    if (mi->rec_lock > 0) {
+      mi->rec_lock--;
+      return 0;
+    }
+    mi->owner = (DWORD)-1;
+  }
+  if (unlikely(__sync_lock_test_and_set(&mi->state, Unlocked) == Waiting)) {
+    if (!SetEvent(mi->event))
+      return EPERM;
+  }
+  return 0;
+}
+
+int pthread_mutex_trylock(pthread_mutex_t *m)
+{
+  mutex_impl_t *mi = mutex_impl(m);
+  if (mi == NULL)
+    return ENOMEM;
+
+  if (__sync_bool_compare_and_swap(&mi->state, Unlocked, Locked)) {
+    if (mi->type != Normal)
+      mi->owner = GetCurrentThreadId();
+    return 0;
+  } else {
+    if (mi->type == Recursive && mi->owner == GetCurrentThreadId()) {
+      mi->rec_lock++;
+      return 0;
+    }
+    return EBUSY;
+  }
+}
+
+int
+pthread_mutex_init (pthread_mutex_t *m, const pthread_mutexattr_t *a)
+{
+  pthread_mutex_t init = PTHREAD_MUTEX_INITIALIZER;
+  if (a != NULL) {
+    int pshared;
+    if (pthread_mutexattr_getpshared(a, &pshared) == 0
+        && pshared == PTHREAD_PROCESS_SHARED)
+      return ENOSYS;
+
+    int type;
+    if (pthread_mutexattr_gettype(a, &type) == 0) {
+      switch (type) {
+      case PTHREAD_MUTEX_ERRORCHECK:
+        init = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER;
+        break;
+      case PTHREAD_MUTEX_RECURSIVE:
+        init = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
+        break;
+      default:
+        init = PTHREAD_MUTEX_INITIALIZER;
+        break;
+      }
+    }
+  }
+  *m = init;
+  return 0;
+}
+
+int pthread_mutex_destroy (pthread_mutex_t *m)
+{
+  mutex_impl_t *mi = (mutex_impl_t *)*m;
+  if (!is_static_initializer((pthread_mutex_t)mi)) {
+    if (mi->event != NULL)
+      CloseHandle(mi->event);
+    free(mi);
+    /* Sabotage attempts to re-use the mutex before initialising it again. */
+    *m = (pthread_mutex_t)NULL;
+  }
+
+  return 0;
+}
+
+int pthread_mutexattr_init(pthread_mutexattr_t *a)
+{
+  *a = PTHREAD_MUTEX_NORMAL | (PTHREAD_PROCESS_PRIVATE << 3);
+  return 0;
+}
+
+int pthread_mutexattr_destroy(pthread_mutexattr_t *a)
+{
+  if (!a)
+    return EINVAL;
+
+  return 0;
+}
+
+int pthread_mutexattr_gettype(const pthread_mutexattr_t *a, int *type)
+{
+  if (!a || !type)
+    return EINVAL;
+	
+  *type = *a & 3;
+  
+  return 0;
+}
+
+int pthread_mutexattr_settype(pthread_mutexattr_t *a, int type)
+{
+    if (!a || (type != PTHREAD_MUTEX_NORMAL && type != PTHREAD_MUTEX_RECURSIVE && type != PTHREAD_MUTEX_ERRORCHECK))
+      return EINVAL;
+    *a &= ~3;
+    *a |= type;
+
+    return 0;
+}
+
+int pthread_mutexattr_getpshared(const pthread_mutexattr_t *a, int *type)
+{
+    if (!a || !type)
+      return EINVAL;
+    *type = (*a & 4 ? PTHREAD_PROCESS_SHARED : PTHREAD_PROCESS_PRIVATE);
+
+    return 0;
+}
+
+int pthread_mutexattr_setpshared(pthread_mutexattr_t * a, int type)
+{
+    int r = 0;
+    if (!a || (type != PTHREAD_PROCESS_SHARED
+	&& type != PTHREAD_PROCESS_PRIVATE))
+      return EINVAL;
+    if (type == PTHREAD_PROCESS_SHARED)
+    {
+      type = PTHREAD_PROCESS_PRIVATE;
+      r = ENOSYS;
+    }
+    type = (type == PTHREAD_PROCESS_SHARED ? 4 : 0);
+
+    *a &= ~4;
+    *a |= type;
+
+    return r;
+}
+
+int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *a, int *type)
+{
+    *type = *a & (8 + 16);
+
+    return 0;
+}
+
+int pthread_mutexattr_setprotocol(pthread_mutexattr_t *a, int type)
+{
+    if ((type & (8 + 16)) != 8 + 16) return EINVAL;
+
+    *a &= ~(8 + 16);
+    *a |= type;
+
+    return 0;
+}
+
+int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *a, int * prio)
+{
+    *prio = *a / PTHREAD_PRIO_MULT;
+    return 0;
+}
+
+int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *a, int prio)
+{
+    *a &= (PTHREAD_PRIO_MULT - 1);
+    *a += prio * PTHREAD_PRIO_MULT;
+
+    return 0;
+}
diff --git a/thirdparty/winpthreads/src/nanosleep.c b/thirdparty/winpthreads/src/nanosleep.c
new file mode 100644
index 00000000..0cce4492
--- /dev/null
+++ b/thirdparty/winpthreads/src/nanosleep.c
@@ -0,0 +1,71 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the w64 mingw-runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#include <errno.h>
+#include <time.h>
+#include <windows.h>
+#include "pthread.h"
+#include "pthread_time.h"
+#include "winpthread_internal.h"
+
+#define POW10_3                 1000
+#define POW10_4                 10000
+#define POW10_6                 1000000
+#define POW10_9                 1000000000
+#define MAX_SLEEP_IN_MS         4294967294UL
+
+/**
+ * Sleep for the specified time.
+ * @param  request The desired amount of time to sleep.
+ * @param  remain The remain amount of time to sleep.
+ * @return If the function succeeds, the return value is 0.
+ *         If the function fails, the return value is -1,
+ *         with errno set to indicate the error.
+ */
+int nanosleep(const struct timespec *request, struct timespec *remain)
+{
+    unsigned long ms, rc = 0;
+    unsigned __int64 u64, want, real;
+
+    union {
+        unsigned __int64 ns100;
+        FILETIME ft;
+    }  _start, _end;
+
+    if (request->tv_sec < 0 || request->tv_nsec < 0 || request->tv_nsec >= POW10_9) {
+        errno = EINVAL;
+        return -1;
+    }
+
+    if (remain != NULL) GetSystemTimeAsFileTime(&_start.ft);
+
+    want = u64 = request->tv_sec * POW10_3 + request->tv_nsec / POW10_6;
+    while (u64 > 0 && rc == 0) {
+        if (u64 >= MAX_SLEEP_IN_MS) ms = MAX_SLEEP_IN_MS;
+        else ms = (unsigned long) u64;
+
+        u64 -= ms;
+        rc = pthread_delay_np_ms(ms);
+    }
+
+    if (rc != 0) { /* WAIT_IO_COMPLETION (192) */
+        if (remain != NULL) {
+            GetSystemTimeAsFileTime(&_end.ft);
+            real = (_end.ns100 - _start.ns100) / POW10_4;
+
+            if (real >= want) u64 = 0;
+            else u64 = want - real;
+
+            remain->tv_sec = u64 / POW10_3;
+            remain->tv_nsec = (long) (u64 % POW10_3) * POW10_6;
+        }
+
+        errno = EINTR;
+        return -1;
+    }
+
+    return 0;
+}
diff --git a/thirdparty/winpthreads/src/ref.c b/thirdparty/winpthreads/src/ref.c
new file mode 100644
index 00000000..0344d457
--- /dev/null
+++ b/thirdparty/winpthreads/src/ref.c
@@ -0,0 +1,34 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#include <windows.h>
+#include <winternl.h>
+#include <stdio.h>
+#include "pthread.h"
+#include "semaphore.h"
+#include "rwlock.h"
+#include "cond.h"
+#include "barrier.h"
+#include "sem.h"
+#include "ref.h"
+#include "misc.h"
+
diff --git a/thirdparty/winpthreads/src/ref.h b/thirdparty/winpthreads/src/ref.h
new file mode 100644
index 00000000..5ca67506
--- /dev/null
+++ b/thirdparty/winpthreads/src/ref.h
@@ -0,0 +1,29 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef WIN_PTHREADS_REF_H
+#define WIN_PTHREADS_REF_H
+#include "pthread.h"
+#include "semaphore.h"
+
+#endif
+
diff --git a/thirdparty/winpthreads/src/rwlock.c b/thirdparty/winpthreads/src/rwlock.c
new file mode 100644
index 00000000..933d4388
--- /dev/null
+++ b/thirdparty/winpthreads/src/rwlock.c
@@ -0,0 +1,533 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#include <windows.h>
+#include <stdio.h>
+#include <malloc.h>
+#include "pthread.h"
+#include "thread.h"
+#include "ref.h"
+#include "rwlock.h"
+#include "misc.h"
+
+static pthread_spinlock_t rwl_global = PTHREAD_SPINLOCK_INITIALIZER;
+
+static WINPTHREADS_ATTRIBUTE((noinline)) int rwlock_static_init(pthread_rwlock_t *rw);
+
+static WINPTHREADS_ATTRIBUTE((noinline)) int rwl_unref(volatile pthread_rwlock_t *rwl, int res)
+{
+    pthread_spin_lock(&rwl_global);
+#ifdef WINPTHREAD_DBG
+    assert((((rwlock_t *)*rwl)->valid == LIFE_RWLOCK) && (((rwlock_t *)*rwl)->busy > 0));
+#endif
+     ((rwlock_t *)*rwl)->busy--;
+    pthread_spin_unlock(&rwl_global);
+    return res;
+}
+
+static WINPTHREADS_ATTRIBUTE((noinline)) int rwl_ref(pthread_rwlock_t *rwl, int f )
+{
+    int r = 0;
+    INIT_RWLOCK(rwl);
+    pthread_spin_lock(&rwl_global);
+
+    if (!rwl || !*rwl || ((rwlock_t *)*rwl)->valid != LIFE_RWLOCK) r = EINVAL;
+    else {
+        ((rwlock_t *)*rwl)->busy ++;
+    }
+
+    pthread_spin_unlock(&rwl_global);
+
+    return r;
+}
+
+static WINPTHREADS_ATTRIBUTE((noinline)) int rwl_ref_unlock(pthread_rwlock_t *rwl )
+{
+    int r = 0;
+
+    pthread_spin_lock(&rwl_global);
+
+    if (!rwl || !*rwl || ((rwlock_t *)*rwl)->valid != LIFE_RWLOCK) r = EINVAL;
+    else if (STATIC_RWL_INITIALIZER(*rwl)) r= EPERM;
+    else {
+        ((rwlock_t *)*rwl)->busy ++;
+    }
+
+    pthread_spin_unlock(&rwl_global);
+
+    return r;
+}
+
+static WINPTHREADS_ATTRIBUTE((noinline)) int rwl_ref_destroy(pthread_rwlock_t *rwl, pthread_rwlock_t *rDestroy )
+{
+    int r = 0;
+
+    *rDestroy = (pthread_rwlock_t)NULL;
+    pthread_spin_lock(&rwl_global);
+    
+    if (!rwl || !*rwl) r = EINVAL;
+    else {
+        rwlock_t *r_ = (rwlock_t *)*rwl;
+        if (STATIC_RWL_INITIALIZER(*rwl)) *rwl = (pthread_rwlock_t)NULL;
+        else if (r_->valid != LIFE_RWLOCK) r = EINVAL;
+        else if (r_->busy) r = EBUSY;
+        else {
+            *rDestroy = *rwl;
+            *rwl = (pthread_rwlock_t)NULL;
+        }
+    }
+
+    pthread_spin_unlock(&rwl_global);
+    return r;
+}
+
+static int rwlock_gain_both_locks(rwlock_t *rwlock)
+{
+  int ret;
+  ret = pthread_mutex_lock(&rwlock->mex);
+  if (ret != 0)
+    return ret;
+  ret = pthread_mutex_lock(&rwlock->mcomplete);
+  if (ret != 0)
+    pthread_mutex_unlock(&rwlock->mex);
+  return ret;
+}
+
+static int rwlock_free_both_locks(rwlock_t *rwlock, int last_fail)
+{
+  int ret, ret2;
+  ret = pthread_mutex_unlock(&rwlock->mcomplete);
+  ret2 = pthread_mutex_unlock(&rwlock->mex);
+  if (last_fail && ret2 != 0)
+    ret = ret2;
+  else if (!last_fail && !ret)
+    ret = ret2;
+  return ret;
+}
+
+#ifdef WINPTHREAD_DBG
+static int print_state = 0;
+void rwl_print_set(int state)
+{
+    print_state = state;
+}
+
+void rwl_print(volatile pthread_rwlock_t *rwl, char *txt)
+{
+    if (!print_state) return;
+    rwlock_t *r = (rwlock_t *)*rwl;
+    if (r == NULL) {
+        printf("RWL%p %d %s\n",(void *)*rwl,(int)GetCurrentThreadId(),txt);
+    } else {
+        printf("RWL%p %d V=%0X B=%d r=%ld w=%ld L=%p %s\n",
+            (void *)*rwl,
+            (int)GetCurrentThreadId(), 
+            (int)r->valid, 
+            (int)r->busy,
+            0L,0L,NULL,txt);
+    }
+}
+#endif
+
+static pthread_spinlock_t cond_locked = PTHREAD_SPINLOCK_INITIALIZER;
+
+static WINPTHREADS_ATTRIBUTE((noinline)) int rwlock_static_init(pthread_rwlock_t *rw)
+{
+  int r;
+  pthread_spin_lock(&cond_locked);
+  if (*rw != PTHREAD_RWLOCK_INITIALIZER)
+  {
+    pthread_spin_unlock(&cond_locked);
+    return EINVAL;
+  }
+  r = pthread_rwlock_init (rw, NULL);
+  pthread_spin_unlock(&cond_locked);
+  
+  return r;
+}
+
+int pthread_rwlock_init (pthread_rwlock_t *rwlock_, const pthread_rwlockattr_t *attr)
+{
+    rwlock_t *rwlock;
+    int r;
+
+    if(!rwlock_)
+      return EINVAL;
+    *rwlock_ = (pthread_rwlock_t)NULL;
+    if ((rwlock = calloc(1, sizeof(*rwlock))) == NULL)
+      return ENOMEM; 
+    rwlock->valid = DEAD_RWLOCK;
+
+    rwlock->nex_count = rwlock->nsh_count = rwlock->ncomplete = 0;
+    if ((r = pthread_mutex_init (&rwlock->mex, NULL)) != 0)
+    {
+        free(rwlock);
+        return r;
+    }
+    if ((r = pthread_mutex_init (&rwlock->mcomplete, NULL)) != 0)
+    {
+      pthread_mutex_destroy(&rwlock->mex);
+      free(rwlock);
+      return r;
+    }
+    if ((r = pthread_cond_init (&rwlock->ccomplete, NULL)) != 0)
+    {
+      pthread_mutex_destroy(&rwlock->mex);
+      pthread_mutex_destroy (&rwlock->mcomplete);
+      free(rwlock);
+      return r;
+    }
+    rwlock->valid = LIFE_RWLOCK;
+    *rwlock_ = (pthread_rwlock_t)rwlock;
+    return r;
+} 
+
+int pthread_rwlock_destroy (pthread_rwlock_t *rwlock_)
+{
+    rwlock_t *rwlock;
+    pthread_rwlock_t rDestroy;
+    int r, r2;
+    
+    pthread_spin_lock(&cond_locked);
+    r = rwl_ref_destroy(rwlock_,&rDestroy);
+    pthread_spin_unlock(&cond_locked);
+    
+    if(r) return r;
+    if(!rDestroy) return 0; /* destroyed a (still) static initialized rwl */
+
+    rwlock = (rwlock_t *)rDestroy;
+    r = rwlock_gain_both_locks (rwlock);
+    if (r != 0)
+    {
+      *rwlock_ = rDestroy;
+      return r;
+    }
+    if (rwlock->nsh_count > rwlock->ncomplete || rwlock->nex_count > 0)
+    {
+      *rwlock_ = rDestroy;
+      r = rwlock_free_both_locks(rwlock, 1);
+      if (!r)
+        r = EBUSY;
+      return r;
+    }
+    rwlock->valid  = DEAD_RWLOCK;
+    r = rwlock_free_both_locks(rwlock, 0);
+    if (r != 0) { *rwlock_ = rDestroy; return r; }
+
+    r = pthread_cond_destroy(&rwlock->ccomplete);
+    r2 = pthread_mutex_destroy(&rwlock->mex);
+    if (!r) r = r2;
+    r2 = pthread_mutex_destroy(&rwlock->mcomplete);
+    if (!r) r = r2;
+    rwlock->valid  = DEAD_RWLOCK;
+    free((void *)rDestroy);
+    return 0;
+} 
+
+int pthread_rwlock_rdlock (pthread_rwlock_t *rwlock_)
+{
+  rwlock_t *rwlock;
+  int ret;
+
+  /* pthread_testcancel(); */
+
+  ret = rwl_ref(rwlock_,0);
+  if(ret != 0) return ret;
+
+  rwlock = (rwlock_t *)*rwlock_;
+
+  ret = pthread_mutex_lock(&rwlock->mex);
+  if (ret != 0) return rwl_unref(rwlock_, ret);
+  InterlockedIncrement((long*)&rwlock->nsh_count);
+  if (rwlock->nsh_count == INT_MAX)
+  {
+    ret = pthread_mutex_lock(&rwlock->mcomplete);
+    if (ret != 0)
+    {
+      pthread_mutex_unlock(&rwlock->mex);
+      return rwl_unref(rwlock_,ret);
+    }
+    rwlock->nsh_count -= rwlock->ncomplete;
+    rwlock->ncomplete = 0;
+    ret = rwlock_free_both_locks(rwlock, 0);
+    return rwl_unref(rwlock_, ret);
+  }
+  ret = pthread_mutex_unlock(&rwlock->mex);
+  return rwl_unref(rwlock_, ret);
+}
+
+int pthread_rwlock_timedrdlock (pthread_rwlock_t *rwlock_, const struct timespec *ts)
+{
+  rwlock_t *rwlock;
+  int ret;
+
+  /* pthread_testcancel(); */
+
+  ret = rwl_ref(rwlock_,0);
+  if(ret != 0) return ret;
+
+  rwlock = (rwlock_t *)*rwlock_;
+  if ((ret = pthread_mutex_timedlock (&rwlock->mex, ts)) != 0)
+      return rwl_unref(rwlock_, ret);
+  InterlockedIncrement(&rwlock->nsh_count);
+  if (rwlock->nsh_count == INT_MAX)
+  {
+    ret = pthread_mutex_timedlock(&rwlock->mcomplete, ts);
+    if (ret != 0)
+    {
+      if (ret == ETIMEDOUT)
+	InterlockedIncrement(&rwlock->ncomplete);
+      pthread_mutex_unlock(&rwlock->mex);
+      return rwl_unref(rwlock_, ret);
+    }
+    rwlock->nsh_count -= rwlock->ncomplete;
+    rwlock->ncomplete = 0;
+    ret = rwlock_free_both_locks(rwlock, 0);
+    return rwl_unref(rwlock_, ret);
+  }
+  ret = pthread_mutex_unlock(&rwlock->mex);
+  return rwl_unref(rwlock_, ret);
+}
+
+int pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock_)
+{
+  rwlock_t *rwlock;
+  int ret;
+
+  ret = rwl_ref(rwlock_,RWL_TRY);
+  if(ret != 0) return ret;
+
+  rwlock = (rwlock_t *)*rwlock_;
+  ret = pthread_mutex_trylock(&rwlock->mex);
+  if (ret != 0)
+      return rwl_unref(rwlock_, ret);
+  InterlockedIncrement(&rwlock->nsh_count);
+  if (rwlock->nsh_count == INT_MAX)
+  {
+    ret = pthread_mutex_lock(&rwlock->mcomplete);
+    if (ret != 0)
+    {
+      pthread_mutex_unlock(&rwlock->mex);
+      return rwl_unref(rwlock_, ret);
+    }
+    rwlock->nsh_count -= rwlock->ncomplete;
+    rwlock->ncomplete = 0;
+    ret = rwlock_free_both_locks(rwlock, 0);
+    return rwl_unref(rwlock_, ret);
+  }
+  ret = pthread_mutex_unlock(&rwlock->mex);
+  return rwl_unref(rwlock_,ret);
+} 
+
+int pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock_)
+{
+  rwlock_t *rwlock;
+  int ret;
+
+  ret = rwl_ref(rwlock_,RWL_TRY);
+  if(ret != 0) return ret;
+
+  rwlock = (rwlock_t *)*rwlock_;
+  ret = pthread_mutex_trylock (&rwlock->mex);
+  if (ret != 0)
+    return rwl_unref(rwlock_, ret);
+  ret = pthread_mutex_trylock(&rwlock->mcomplete);
+  if (ret != 0)
+  {
+    int r1 = pthread_mutex_unlock(&rwlock->mex);
+    if (r1 != 0)
+      ret = r1;
+    return rwl_unref(rwlock_, ret);
+  }
+  if (rwlock->nex_count != 0)
+    return rwl_unref(rwlock_, EBUSY);
+  if (rwlock->ncomplete > 0)
+  {
+    rwlock->nsh_count -= rwlock->ncomplete;
+    rwlock->ncomplete = 0;
+  }
+  if (rwlock->nsh_count > 0)
+  {
+    ret = rwlock_free_both_locks(rwlock, 0);
+    if (!ret)
+      ret = EBUSY;
+    return rwl_unref(rwlock_, ret);
+  }
+  rwlock->nex_count = 1;
+  return rwl_unref(rwlock_, 0);
+} 
+
+int pthread_rwlock_unlock (pthread_rwlock_t *rwlock_)
+{
+  rwlock_t *rwlock;
+  int ret;
+
+  ret = rwl_ref_unlock(rwlock_);
+  if(ret != 0) return ret;
+
+  rwlock = (rwlock_t *)*rwlock_;
+  if (rwlock->nex_count == 0)
+  {
+    ret = pthread_mutex_lock(&rwlock->mcomplete);
+    if (!ret)
+    {
+      int r1;
+      InterlockedIncrement(&rwlock->ncomplete);
+      if (rwlock->ncomplete == 0)
+	ret = pthread_cond_signal(&rwlock->ccomplete);
+      r1 = pthread_mutex_unlock(&rwlock->mcomplete);
+      if (!ret)
+	ret = r1;
+    }
+  }
+  else
+  {
+    InterlockedDecrement(&rwlock->nex_count);
+    ret = rwlock_free_both_locks(rwlock, 0);
+  }
+  return rwl_unref(rwlock_, ret);
+} 
+
+static void st_cancelwrite (void *arg)
+{
+    rwlock_t *rwlock = (rwlock_t *)arg;
+
+    rwlock->nsh_count = - rwlock->ncomplete;
+    rwlock->ncomplete = 0;
+    rwlock_free_both_locks(rwlock, 0);
+}
+
+int pthread_rwlock_wrlock (pthread_rwlock_t *rwlock_)
+{
+  rwlock_t *rwlock;
+  int ret;
+
+  /* pthread_testcancel(); */
+  ret = rwl_ref(rwlock_,0);
+  if(ret != 0) return ret;
+
+  rwlock = (rwlock_t *)*rwlock_;
+  ret = rwlock_gain_both_locks(rwlock);
+  if (ret != 0)
+    return rwl_unref(rwlock_,ret);
+
+  if (rwlock->nex_count == 0)
+  {
+    if (rwlock->ncomplete > 0)
+    {
+      rwlock->nsh_count -= rwlock->ncomplete;
+      rwlock->ncomplete = 0;
+    }
+    if (rwlock->nsh_count > 0)
+    {
+      rwlock->ncomplete = -rwlock->nsh_count;
+      pthread_cleanup_push(st_cancelwrite, (void *) rwlock);
+      do {
+	ret = pthread_cond_wait(&rwlock->ccomplete, &rwlock->mcomplete);
+      } while (!ret && rwlock->ncomplete < 0);
+
+      pthread_cleanup_pop(!ret ? 0 : 1);
+      if (!ret)
+	rwlock->nsh_count = 0;
+    }
+  }
+  if(!ret)
+    InterlockedIncrement((long*)&rwlock->nex_count);
+  return rwl_unref(rwlock_,ret);
+}
+
+int pthread_rwlock_timedwrlock (pthread_rwlock_t *rwlock_, const struct timespec *ts)
+{
+  int ret;
+  rwlock_t *rwlock;
+
+  /* pthread_testcancel(); */
+  if (!rwlock_ || !ts)
+    return EINVAL;
+  if ((ret = rwl_ref(rwlock_,0)) != 0)
+    return ret;
+  rwlock = (rwlock_t *)*rwlock_;
+
+  ret = pthread_mutex_timedlock(&rwlock->mex, ts);
+  if (ret != 0)
+    return rwl_unref(rwlock_,ret);
+  ret = pthread_mutex_timedlock (&rwlock->mcomplete, ts);
+  if (ret != 0)
+  {
+    pthread_mutex_unlock(&rwlock->mex);
+    return rwl_unref(rwlock_,ret);
+  }
+  if (rwlock->nex_count == 0)
+  {
+    if (rwlock->ncomplete > 0)
+    {
+      rwlock->nsh_count -= rwlock->ncomplete;
+      rwlock->ncomplete = 0;
+    }
+    if (rwlock->nsh_count > 0)
+    {
+      rwlock->ncomplete = -rwlock->nsh_count;
+      pthread_cleanup_push(st_cancelwrite, (void *) rwlock);
+      do {
+	ret = pthread_cond_timedwait(&rwlock->ccomplete, &rwlock->mcomplete, ts);
+      } while (rwlock->ncomplete < 0 && !ret);
+      pthread_cleanup_pop(!ret ? 0 : 1);
+
+      if (!ret)
+	rwlock->nsh_count = 0;
+    }
+  }
+  if(!ret)
+    InterlockedIncrement((long*)&rwlock->nex_count);
+  return rwl_unref(rwlock_,ret);
+}
+
+int pthread_rwlockattr_destroy(pthread_rwlockattr_t *a)
+{
+  if (!a)
+    return EINVAL;
+  return 0;
+}
+
+int pthread_rwlockattr_init(pthread_rwlockattr_t *a)
+{
+  if (!a)
+    return EINVAL;
+  *a = PTHREAD_PROCESS_PRIVATE;
+  return 0;
+}
+
+int pthread_rwlockattr_getpshared(pthread_rwlockattr_t *a, int *s)
+{
+  if (!a || !s)
+    return EINVAL;
+  *s = *a;
+  return 0;
+}
+
+int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *a, int s)
+{
+  if (!a || (s != PTHREAD_PROCESS_SHARED && s != PTHREAD_PROCESS_PRIVATE))
+    return EINVAL;
+  *a = s;
+  return 0;
+}
diff --git a/thirdparty/winpthreads/src/rwlock.h b/thirdparty/winpthreads/src/rwlock.h
new file mode 100644
index 00000000..f08b0d37
--- /dev/null
+++ b/thirdparty/winpthreads/src/rwlock.h
@@ -0,0 +1,52 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef WIN_PTHREADS_RWLOCK_H
+#define WIN_PTHREADS_RWLOCK_H
+
+#define LIFE_RWLOCK 0xBAB1F0ED
+#define DEAD_RWLOCK 0xDEADB0EF
+
+#define INIT_RWLOCK(rwl)  { int r; \
+    if (STATIC_RWL_INITIALIZER(*rwl)) { if ((r = rwlock_static_init(rwl))) { if (r != EBUSY) return r; }}}
+
+#define STATIC_RWL_INITIALIZER(x)		((pthread_rwlock_t)(x) == ((pthread_rwlock_t)PTHREAD_RWLOCK_INITIALIZER))
+
+typedef struct rwlock_t rwlock_t;
+struct rwlock_t {
+    unsigned int valid;
+    int busy;
+    LONG nex_count; /* Exclusive access counter.  */
+    LONG nsh_count; /* Shared access counter. */
+    LONG ncomplete; /* Shared completed counter. */
+    pthread_mutex_t mex; /* Exclusive access protection.  */
+    pthread_mutex_t mcomplete; /* Shared completed protection. */
+    pthread_cond_t ccomplete; /* Shared access completed queue.  */
+};
+
+#define RWL_SET	0x01
+#define RWL_TRY	0x02
+
+void rwl_print(volatile pthread_rwlock_t *rwl, char *txt);
+void rwl_print_set(int state);
+
+#endif
diff --git a/thirdparty/winpthreads/src/sched.c b/thirdparty/winpthreads/src/sched.c
new file mode 100644
index 00000000..976bcc10
--- /dev/null
+++ b/thirdparty/winpthreads/src/sched.c
@@ -0,0 +1,218 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#include <windows.h>
+#include <stdio.h>
+#include "pthread.h"
+#include "thread.h"
+
+#include "misc.h"
+
+int sched_get_priority_min(int pol)
+{
+  if (pol < SCHED_MIN || pol > SCHED_MAX) {
+      errno = EINVAL;
+      return -1;
+  }
+
+  return THREAD_PRIORITY_IDLE;
+}
+
+int sched_get_priority_max(int pol)
+{
+  if (pol < SCHED_MIN || pol > SCHED_MAX) {
+      errno = EINVAL;
+      return -1;
+  }
+
+  return THREAD_PRIORITY_TIME_CRITICAL;
+}
+
+int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *p)
+{
+    int r = 0;
+
+    if (attr == NULL || p == NULL) {
+        return EINVAL;
+    }
+    memcpy(&attr->param, p, sizeof (*p));
+    return r;
+}
+
+int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *p)
+{
+    int r = 0;
+
+    if (attr == NULL || p == NULL) {
+        return EINVAL;
+    }
+    memcpy(p, &attr->param, sizeof (*p));
+    return r;
+}
+
+int pthread_attr_setschedpolicy (pthread_attr_t *attr, int pol)
+{
+  if (!attr || pol < SCHED_MIN || pol > SCHED_MAX)
+    return EINVAL;
+  if (pol != SCHED_OTHER)
+    return ENOTSUP;
+  return 0;
+}
+
+int pthread_attr_getschedpolicy (const pthread_attr_t *attr, int *pol)
+{
+  if (!attr || !pol)
+    return EINVAL;
+  *pol = SCHED_OTHER;
+  return 0;
+}
+
+static int pthread_check(pthread_t t)
+{
+  struct _pthread_v *pv;
+
+  if (!t)
+    return ESRCH;
+  pv = __pth_gpointer_locked (t);
+  if (pv->ended == 0)
+    return 0;
+  CHECK_OBJECT(pv, ESRCH);
+  return 0;
+}
+
+int pthread_getschedparam(pthread_t t, int *pol, struct sched_param *p)
+{
+    int r;
+    //if (!t)
+    //  t = pthread_self();
+
+    if ((r = pthread_check(t)) != 0)
+    {
+        return r;
+    }
+
+    if (!p || !pol)
+    {
+        return EINVAL;
+    }
+    *pol = __pth_gpointer_locked (t)->sched_pol;
+    p->sched_priority = __pth_gpointer_locked (t)->sched.sched_priority;
+
+    return 0;
+}
+
+int pthread_setschedparam(pthread_t t, int pol,  const struct sched_param *p)
+{
+  struct _pthread_v *pv;
+    int r, pr = 0;
+    //if (!t.p) t = pthread_self();
+
+    if ((r = pthread_check(t)) != 0)
+        return r;
+
+    if (pol < SCHED_MIN || pol > SCHED_MAX || p == NULL)
+        return EINVAL;
+    if (pol != SCHED_OTHER)
+        return ENOTSUP;
+    pr = p->sched_priority;
+    if (pr < sched_get_priority_min(pol) || pr > sched_get_priority_max(pol))
+      return EINVAL;
+
+    /* See msdn: there are actually 7 priorities:
+    THREAD_PRIORITY_IDLE    -      -15
+    THREAD_PRIORITY_LOWEST          -2
+    THREAD_PRIORITY_BELOW_NORMAL    -1
+    THREAD_PRIORITY_NORMAL           0
+    THREAD_PRIORITY_ABOVE_NORMAL     1
+    THREAD_PRIORITY_HIGHEST          2
+    THREAD_PRIORITY_TIME_CRITICAL   15
+    */
+    if (pr <= THREAD_PRIORITY_IDLE) {
+        pr = THREAD_PRIORITY_IDLE;
+    } else if (pr <= THREAD_PRIORITY_LOWEST) {
+        pr = THREAD_PRIORITY_LOWEST;
+    } else if (pr >= THREAD_PRIORITY_TIME_CRITICAL) {
+        pr = THREAD_PRIORITY_TIME_CRITICAL;
+    } else if (pr >= THREAD_PRIORITY_HIGHEST) {
+        pr = THREAD_PRIORITY_HIGHEST;
+    }
+    pv = __pth_gpointer_locked (t);
+    if (SetThreadPriority(pv->h, pr)) {
+        pv->sched_pol = pol;
+        pv->sched.sched_priority = p->sched_priority;
+    } else
+        r = EINVAL;
+    return r;
+}
+
+int sched_getscheduler(pid_t pid)
+{
+  if (pid != 0)
+  {
+      HANDLE h = NULL;
+      int selfPid = (int) GetCurrentProcessId ();
+
+      if (pid != (pid_t) selfPid && (h = OpenProcess (PROCESS_QUERY_INFORMATION, 0, (DWORD) pid)) == NULL)
+      {
+	  errno = (GetLastError () == (0xFF & ERROR_ACCESS_DENIED)) ? EPERM : ESRCH;
+	  return -1;
+      }
+      if (h)
+	  CloseHandle (h);
+  }
+  return SCHED_OTHER;
+}
+
+int sched_setscheduler(pid_t pid, int pol, const struct sched_param *param)
+{
+  if (!param)
+    {
+      errno = EINVAL;
+      return -1;
+    }
+  if (pid != 0)
+  {
+      HANDLE h = NULL;
+      int selfPid = (int) GetCurrentProcessId ();
+
+      if (pid != (pid_t) selfPid && (h = OpenProcess (PROCESS_SET_INFORMATION, 0, (DWORD) pid)) == NULL)
+      {
+	  errno = (GetLastError () == (0xFF & ERROR_ACCESS_DENIED)) ? EPERM : ESRCH;
+	  return -1;
+      }
+      if (h)
+          CloseHandle (h);
+  }
+
+  if (pol != SCHED_OTHER)
+  {
+      errno = ENOSYS;
+      return -1;
+  }
+  return SCHED_OTHER;
+}
+
+int sched_yield(void)
+{
+  Sleep(0);
+  return 0;
+}
diff --git a/thirdparty/winpthreads/src/sem.c b/thirdparty/winpthreads/src/sem.c
new file mode 100644
index 00000000..81fa8f8e
--- /dev/null
+++ b/thirdparty/winpthreads/src/sem.c
@@ -0,0 +1,354 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#include <windows.h>
+#include <stdio.h>
+#include <malloc.h>
+#include "pthread.h"
+#include "thread.h"
+#include "misc.h"
+#include "semaphore.h"
+#include "sem.h"
+#include "ref.h"
+
+int do_sema_b_wait_intern (HANDLE sema, int nointerrupt, DWORD timeout);
+
+static int
+sem_result (int res)
+{
+  if (res != 0) {
+    errno = res;
+    return -1;
+  }
+  return 0;
+}
+
+int
+sem_init (sem_t *sem, int pshared, unsigned int value)
+{
+  _sem_t *sv;
+
+  if (!sem || value > (unsigned int)SEM_VALUE_MAX)
+    return sem_result (EINVAL);
+  if (pshared != PTHREAD_PROCESS_PRIVATE)
+    return sem_result (EPERM);
+
+  if (!(sv = (sem_t) calloc (1,sizeof (*sv))))
+    return sem_result (ENOMEM);
+
+  sv->value = value;
+  if (pthread_mutex_init (&sv->vlock, NULL) != 0)
+    {
+      free (sv);
+      return sem_result (ENOSPC);
+    }
+  if ((sv->s = CreateSemaphore (NULL, 0, SEM_VALUE_MAX, NULL)) == NULL)
+    {
+      pthread_mutex_destroy (&sv->vlock);
+      free (sv);
+      return sem_result (ENOSPC);
+    }
+
+  sv->valid = LIFE_SEM;
+  *sem = sv;
+  return 0;
+}
+
+int
+sem_destroy (sem_t *sem)
+{
+  int r;
+  _sem_t *sv = NULL;
+
+  if (!sem || (sv = *sem) == NULL)
+    return sem_result (EINVAL);
+  if ((r = pthread_mutex_lock (&sv->vlock)) != 0)
+    return sem_result (r);
+
+#if 0
+  /* We don't wait for destroying a semaphore ...
+     or?  */
+  if (sv->value < 0)
+    {
+      pthread_mutex_unlock (&sv->vlock);
+      return sem_result (EBUSY);
+    }
+#endif
+
+  if (!CloseHandle (sv->s))
+    {
+      pthread_mutex_unlock (&sv->vlock);
+      return sem_result (EINVAL);
+    }
+  *sem = NULL;
+  sv->value = SEM_VALUE_MAX;
+  pthread_mutex_unlock(&sv->vlock);
+  Sleep (0);
+  while (pthread_mutex_destroy (&sv->vlock) == EBUSY)
+    Sleep (0);
+  sv->valid = DEAD_SEM;
+  free (sv);
+  return 0;
+}
+
+static int
+sem_std_enter (sem_t *sem,_sem_t **svp, int do_test)
+{
+  int r;
+  _sem_t *sv;
+
+  if (do_test)
+    pthread_testcancel ();
+  if (!sem)
+    return sem_result (EINVAL);
+  sv = *sem;
+  if (sv == NULL)
+    return sem_result (EINVAL);
+
+  if ((r = pthread_mutex_lock (&sv->vlock)) != 0)
+    return sem_result (r);
+
+  if (*sem == NULL)
+    {
+      pthread_mutex_unlock(&sv->vlock);
+      return sem_result (EINVAL);
+    }
+  *svp = sv;
+  return 0;
+}
+
+int
+sem_trywait (sem_t *sem)
+{
+  _sem_t *sv;
+
+  if (sem_std_enter (sem, &sv, 0) != 0)
+    return -1;
+  if (sv->value <= 0)
+    {
+      pthread_mutex_unlock (&sv->vlock);
+      return sem_result (EAGAIN);
+    }
+  sv->value--;
+  pthread_mutex_unlock (&sv->vlock);
+
+  return 0;
+}
+
+struct sSemTimedWait
+{
+  sem_t *p;
+  int *ret;
+};
+
+static void
+clean_wait_sem (void *s)
+{
+  struct sSemTimedWait *p = (struct sSemTimedWait *) s;
+  _sem_t *sv = NULL;
+
+  if (sem_std_enter (p->p, &sv, 0) != 0)
+    return;
+
+  if (WaitForSingleObject (sv->s, 0) != WAIT_OBJECT_0)
+    InterlockedIncrement (&sv->value);
+  else if (p->ret)
+    p->ret[0] = 0;
+  pthread_mutex_unlock (&sv->vlock);
+}
+
+int
+sem_wait (sem_t *sem)
+{
+  long cur_v;
+  int ret = 0;
+  _sem_t *sv;
+  HANDLE semh;
+  struct sSemTimedWait arg;
+
+  if (sem_std_enter (sem, &sv, 1) != 0)
+    return -1;
+
+  arg.ret = &ret;
+  arg.p = sem;
+  InterlockedDecrement (&sv->value);
+  cur_v = sv->value;
+  semh = sv->s;
+  pthread_mutex_unlock (&sv->vlock);
+
+  if (cur_v >= 0)
+    return 0;
+  else
+    {
+      pthread_cleanup_push (clean_wait_sem, (void *) &arg);
+      ret = do_sema_b_wait_intern (semh, 2, INFINITE);
+      pthread_cleanup_pop (ret);
+      if (ret == EINVAL)
+        return 0;
+    }
+
+  if (!ret)
+    return 0;
+
+  return sem_result (ret);
+}
+
+int
+sem_timedwait (sem_t *sem, const struct timespec *t)
+{
+  int cur_v, ret = 0;
+  DWORD dwr;
+  HANDLE semh;
+  _sem_t *sv;
+  struct sSemTimedWait arg;
+
+  if (!t)
+    return sem_wait (sem);
+  dwr = dwMilliSecs(_pthread_rel_time_in_ms (t));
+
+  if (sem_std_enter (sem, &sv, 1) != 0)
+    return -1;
+
+  arg.ret = &ret;
+  arg.p = sem;
+  InterlockedDecrement (&sv->value);
+  cur_v = sv->value;
+  semh = sv->s;
+  pthread_mutex_unlock(&sv->vlock);
+
+  if (cur_v >= 0)
+    return 0;
+  else
+    {
+      pthread_cleanup_push (clean_wait_sem, (void *) &arg);
+      ret = do_sema_b_wait_intern (semh, 2, dwr);
+      pthread_cleanup_pop (ret);
+      if (ret == EINVAL)
+        return 0;
+    }
+
+  if (!ret)
+    return 0;
+  return sem_result (ret);
+}
+
+int
+sem_post (sem_t *sem)
+{
+  _sem_t *sv;;
+
+  if (sem_std_enter (sem, &sv, 0) != 0)
+    return -1;
+
+  if (sv->value >= SEM_VALUE_MAX)
+    {
+      pthread_mutex_unlock (&sv->vlock);
+      return sem_result (ERANGE);
+    }
+  InterlockedIncrement (&sv->value);
+  if (sv->value > 0 || ReleaseSemaphore (sv->s, 1, NULL))
+    {
+      pthread_mutex_unlock (&sv->vlock);
+      return 0;
+    }
+  InterlockedDecrement (&sv->value);
+  pthread_mutex_unlock (&sv->vlock);
+
+  return sem_result (EINVAL);
+}
+
+int
+sem_post_multiple (sem_t *sem, int count)
+{
+  int waiters_count;
+  _sem_t *sv;;
+
+  if (count <= 0)
+    return sem_result (EINVAL);
+  if (sem_std_enter (sem, &sv, 0) != 0)
+    return -1;
+
+  if (sv->value > (SEM_VALUE_MAX - count))
+  {
+    pthread_mutex_unlock (&sv->vlock);
+    return sem_result (ERANGE);
+  }
+  waiters_count = -sv->value;
+  sv->value += count;
+  /*InterlockedExchangeAdd((long*)&sv->value, (long) count);*/
+  if (waiters_count <= 0
+      || ReleaseSemaphore (sv->s,
+			   (waiters_count < count ? waiters_count
+			   			  : count), NULL))
+  {
+    pthread_mutex_unlock(&sv->vlock);
+    return 0;
+  }
+  /*InterlockedExchangeAdd((long*)&sv->value, -((long) count));*/
+  sv->value -= count;
+  pthread_mutex_unlock(&sv->vlock);
+  return sem_result (EINVAL);
+}
+
+sem_t *
+sem_open (const char *name, int oflag, mode_t mode, unsigned int value)
+{
+  sem_result (ENOSYS);
+  return NULL;
+}
+
+int
+sem_close (sem_t *sem)
+{
+  return sem_result (ENOSYS);
+}
+
+int
+sem_unlink (const char *name)
+{
+  return sem_result (ENOSYS);
+}
+
+int
+sem_getvalue (sem_t *sem, int *sval)
+{
+  _sem_t *sv;
+  int r;
+
+  if (!sval)
+    return sem_result (EINVAL);
+
+  if (!sem || (sv = *sem) == NULL)
+    return sem_result (EINVAL);
+
+  if ((r = pthread_mutex_lock (&sv->vlock)) != 0)
+    return sem_result (r);
+  if (*sem == NULL)
+    {
+      pthread_mutex_unlock (&sv->vlock);
+      return sem_result (EINVAL);
+    }
+
+  *sval = (int) sv->value;
+  pthread_mutex_unlock (&sv->vlock);
+  return 0;  
+}
diff --git a/thirdparty/winpthreads/src/sem.h b/thirdparty/winpthreads/src/sem.h
new file mode 100644
index 00000000..3b3ace7f
--- /dev/null
+++ b/thirdparty/winpthreads/src/sem.h
@@ -0,0 +1,40 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef WIN_SEM
+#define WIN_SEM
+
+#include <windows.h>
+
+#define LIFE_SEM 0xBAB1F00D
+#define DEAD_SEM 0xDEADBEEF
+
+typedef struct _sem_t _sem_t;
+struct _sem_t
+{
+    unsigned int valid;
+    HANDLE s;
+    volatile long value;
+    pthread_mutex_t vlock;
+};
+
+#endif /* WIN_SEM */
diff --git a/thirdparty/winpthreads/src/spinlock.c b/thirdparty/winpthreads/src/spinlock.c
new file mode 100644
index 00000000..c1c60097
--- /dev/null
+++ b/thirdparty/winpthreads/src/spinlock.c
@@ -0,0 +1,86 @@
+/*
+   Copyright (c) 2013 mingw-w64 project
+   Copyright (c) 2015 Intel Corporation
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#include "pthread.h"
+
+#define likely(cond) __builtin_expect((cond) != 0, 1)
+#define unlikely(cond) __builtin_expect((cond) != 0, 0)
+
+/* We use the pthread_spinlock_t itself as a lock:
+   -1 is free, 0 is locked.
+   (This is dictated by PTHREAD_SPINLOCK_INITIALIZER, which we can't change
+   without breaking binary compatibility.) */
+typedef intptr_t spinlock_word_t;
+
+int
+pthread_spin_init (pthread_spinlock_t *lock, int pshared)
+{
+  spinlock_word_t *lk = (spinlock_word_t *)lock;
+  *lk = -1;
+  return 0;
+}
+
+
+int
+pthread_spin_destroy (pthread_spinlock_t *lock)
+{
+  return 0;
+}
+
+int pthread_spin_lock(pthread_spinlock_t *lock)
+{
+    volatile spinlock_word_t *lk = (volatile spinlock_word_t *)lock;
+    while (unlikely(__sync_lock_test_and_set(lk, 0) == 0))
+    {
+        do
+        {
+#if defined(__i386__) || defined(__x86_64__)
+            asm("pause" ::: "memory");
+#elif defined(__arm__) || defined(__aarch64__)
+            asm("wfe" ::: "memory");
+#else
+            #include <time.h>
+            #define BUSY_WAIT_DELAY_NS 1000
+            struct timespec ts = {0, BUSY_WAIT_DELAY_NS};
+            nanosleep(&ts, NULL);
+#endif
+        } while (*lk == 0);
+    }
+    return 0;
+}
+
+int
+pthread_spin_trylock (pthread_spinlock_t *lock)
+{
+  spinlock_word_t *lk = (spinlock_word_t *)lock;
+  return __sync_lock_test_and_set(lk, 0) == 0 ? EBUSY : 0;
+}
+
+
+int
+pthread_spin_unlock (pthread_spinlock_t *lock)
+{
+  volatile spinlock_word_t *lk = (volatile spinlock_word_t *)lock;
+  *lk = -1;
+  return 0;
+}
diff --git a/thirdparty/winpthreads/src/thread.c b/thirdparty/winpthreads/src/thread.c
new file mode 100644
index 00000000..f7aba360
--- /dev/null
+++ b/thirdparty/winpthreads/src/thread.c
@@ -0,0 +1,1885 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#include <windows.h>
+#include <strsafe.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <malloc.h>
+#include <signal.h>
+#include "pthread.h"
+#include "thread.h"
+#include "misc.h"
+#include "winpthread_internal.h"
+
+static _pthread_v *__pthread_self_lite (void);
+
+void (**_pthread_key_dest)(void *) = NULL;
+
+static volatile long _pthread_cancelling;
+static int _pthread_concur;
+
+/* FIXME Will default to zero as needed */
+static pthread_once_t _pthread_tls_once;
+static DWORD _pthread_tls = 0xffffffff;
+
+static pthread_rwlock_t _pthread_key_lock = PTHREAD_RWLOCK_INITIALIZER;
+static unsigned long _pthread_key_max=0L;
+static unsigned long _pthread_key_sch=0L;
+
+static _pthread_v *pthr_root = NULL, *pthr_last = NULL;
+static pthread_mutex_t mtx_pthr_locked = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
+
+static __pthread_idlist *idList = NULL;
+static size_t idListCnt = 0;
+static size_t idListMax = 0;
+static pthread_t idListNextId = 0;
+
+#if !defined(_MSC_VER)
+#define USE_VEH_FOR_MSC_SETTHREADNAME
+#endif
+#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+/* forbidden RemoveVectoredExceptionHandler/AddVectoredExceptionHandler APIs */
+#undef USE_VEH_FOR_MSC_SETTHREADNAME
+#endif
+
+#if defined(USE_VEH_FOR_MSC_SETTHREADNAME)
+static void *SetThreadName_VEH_handle = NULL;
+
+static LONG __stdcall
+SetThreadName_VEH (PEXCEPTION_POINTERS ExceptionInfo)
+{
+  if (ExceptionInfo->ExceptionRecord != NULL &&
+      ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_SET_THREAD_NAME)
+    return EXCEPTION_CONTINUE_EXECUTION;
+
+  return EXCEPTION_CONTINUE_SEARCH;
+}
+#endif
+
+typedef struct _THREADNAME_INFO
+{
+  DWORD  dwType;	/* must be 0x1000 */
+  LPCSTR szName;	/* pointer to name (in user addr space) */
+  DWORD  dwThreadID;	/* thread ID (-1=caller thread) */
+  DWORD  dwFlags;	/* reserved for future use, must be zero */
+} THREADNAME_INFO;
+
+static void
+SetThreadName (DWORD dwThreadID, LPCSTR szThreadName)
+{
+   THREADNAME_INFO info;
+   DWORD infosize;
+
+   info.dwType = 0x1000;
+   info.szName = szThreadName;
+   info.dwThreadID = dwThreadID;
+   info.dwFlags = 0;
+
+   infosize = sizeof (info) / sizeof (ULONG_PTR);
+
+#if defined(_MSC_VER) && !defined (USE_VEH_FOR_MSC_SETTHREADNAME)
+   __try
+     {
+       RaiseException (EXCEPTION_SET_THREAD_NAME, 0, infosize, (ULONG_PTR *)&info);
+     }
+   __except (EXCEPTION_EXECUTE_HANDLER)
+     {
+     }
+#else
+   /* Without a debugger we *must* have an exception handler,
+    * otherwise raising an exception will crash the process.
+    */
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+   if ((!IsDebuggerPresent ()) && (SetThreadName_VEH_handle == NULL))
+#else
+   if (!IsDebuggerPresent ())
+#endif
+     return;
+
+   RaiseException (EXCEPTION_SET_THREAD_NAME, 0, infosize, (ULONG_PTR *) &info);
+#endif
+}
+
+/* Search the list idList for an element with identifier ID.  If
+   found, its associated _pthread_v pointer is returned, otherwise
+   NULL.
+   NOTE: This method is not locked.  */
+static struct _pthread_v *
+__pthread_get_pointer (pthread_t id)
+{
+  size_t l, r, p;
+  if (!idListCnt)
+    return NULL;
+  if (idListCnt == 1)
+    return (idList[0].id == id ? idList[0].ptr : NULL);
+  l = 0; r = idListCnt - 1;
+  while (l <= r)
+  {
+    p = (l + r) >> 1;
+    if (idList[p].id == id)
+      return idList[p].ptr;
+    else if (idList[p].id > id)
+      {
+	if (p == l)
+	  return NULL;
+	r = p - 1;
+      }
+    else
+      {
+	l = p + 1;
+      }
+  }
+
+  return NULL;
+}
+
+static void
+__pth_remove_use_for_key (pthread_key_t key)
+{
+  int i;
+
+  pthread_mutex_lock (&mtx_pthr_locked);
+  for (i = 0; i < idListCnt; i++)
+    {
+      if (idList[i].ptr != NULL
+          && idList[i].ptr->keyval != NULL
+          && key < idList[i].ptr->keymax)
+        {
+	  idList[i].ptr->keyval[key] = NULL;
+	  idList[i].ptr->keyval_set[key] = 0;
+	}
+    }
+  pthread_mutex_unlock (&mtx_pthr_locked);
+}
+
+/* Search the list idList for an element with identifier ID.  If
+   found, its associated _pthread_v pointer is returned, otherwise
+   NULL.
+   NOTE: This method uses lock mtx_pthr_locked.  */
+struct _pthread_v *
+__pth_gpointer_locked (pthread_t id)
+{
+  struct _pthread_v *ret;
+  if (!id)
+    return NULL;
+  pthread_mutex_lock (&mtx_pthr_locked);
+  ret =  __pthread_get_pointer (id);
+  pthread_mutex_unlock (&mtx_pthr_locked);
+  return ret;
+}
+
+/* Registers in the list idList an element with _pthread_v pointer
+   and creates and unique identifier ID.  If successful created the
+   ID of this element is returned, otherwise on failure zero ID gets
+   returned.
+   NOTE: This method is not locked.  */
+static pthread_t
+__pthread_register_pointer (struct _pthread_v *ptr)
+{
+  __pthread_idlist *e;
+  size_t i;
+
+  if (!ptr)
+    return 0;
+  /* Check if a resize of list is necessary.  */
+  if (idListCnt >= idListMax)
+    {
+      if (!idListCnt)
+        {
+	  e = (__pthread_idlist *) malloc (sizeof (__pthread_idlist) * 16);
+	  if (!e)
+	    return 0;
+	  idListMax = 16;
+	  idList = e;
+	}
+      else
+        {
+	  e = (__pthread_idlist *) realloc (idList, sizeof (__pthread_idlist) * (idListMax + 16));
+	  if (!e)
+	    return 0;
+	  idListMax += 16;
+	  idList = e;
+	}
+    }
+  do
+    {
+      ++idListNextId;
+      /* If two MSB are set we reset to id 1.  We need to check here bits
+         to avoid gcc's no-overflow issue on increment.  Additionally we
+         need to handle different size of pthread_t on 32-bit/64-bit.  */
+      if ((idListNextId & ( ((pthread_t) 1) << ((sizeof (pthread_t) * 8) - 2))) != 0)
+        idListNextId = 1;
+    }
+  while (idListNextId == 0 || __pthread_get_pointer (idListNextId));
+  /* We assume insert at end of list.  */
+  i = idListCnt;
+  if (i != 0)
+    {
+      /* Find position we can actual insert sorted.  */
+      while (i > 0 && idList[i - 1].id > idListNextId)
+        --i;
+      if (i != idListCnt)
+	memmove (&idList[i + 1], &idList[i], sizeof (__pthread_idlist) * (idListCnt - i));
+    }
+  idList[i].id = idListNextId;
+  idList[i].ptr = ptr;
+  ++idListCnt;
+  return idListNextId;
+}
+
+/* Deregisters in the list idList an element with identifier ID and
+   returns its _pthread_v pointer on success.  Otherwise NULL is returned.
+   NOTE: This method is not locked.  */
+static struct _pthread_v *
+__pthread_deregister_pointer (pthread_t id)
+{
+  size_t l, r, p;
+  if (!idListCnt)
+    return NULL;
+  l = 0; r = idListCnt - 1;
+  while (l <= r)
+  {
+    p = (l + r) >> 1;
+    if (idList[p].id == id)
+      {
+	struct _pthread_v *ret = idList[p].ptr;
+	p++;
+	if (p < idListCnt)
+	  memmove (&idList[p - 1], &idList[p], sizeof (__pthread_idlist) * (idListCnt - p));
+	--idListCnt;
+	/* Is this last element in list then free list.  */
+	if (idListCnt == 0)
+	{
+	  free (idList);
+	  idListCnt = idListMax = 0;
+	}
+	return ret;
+      }
+    else if (idList[p].id > id)
+      {
+	if (p == l)
+	  return NULL;
+	r = p - 1;
+      }
+    else
+      {
+	l = p + 1;
+      }
+  }
+  return NULL;
+}
+
+/* Save a _pthread_v element for reuse in pool.  */
+static void
+push_pthread_mem (_pthread_v *sv)
+{
+  if (!sv || sv->next != NULL)
+    return;
+  pthread_mutex_lock (&mtx_pthr_locked);
+  if (sv->x != 0)
+    __pthread_deregister_pointer (sv->x);
+  if (sv->keyval)
+    free (sv->keyval);
+  if (sv->keyval_set)
+    free (sv->keyval_set);
+  if (sv->thread_name)
+    free (sv->thread_name);
+  memset (sv, 0, sizeof(struct _pthread_v));
+  if (pthr_last == NULL)
+    pthr_root = pthr_last = sv;
+  else
+  {
+    pthr_last->next = sv;
+    pthr_last = sv;
+  }
+  pthread_mutex_unlock (&mtx_pthr_locked);
+}
+
+/* Get a _pthread_v element from pool, or allocate it.
+   Note the unique identifier is created for the element here, too.  */
+static _pthread_v *
+pop_pthread_mem (void)
+{
+  _pthread_v *r = NULL;
+
+  pthread_mutex_lock (&mtx_pthr_locked);
+  if ((r = pthr_root) == NULL)
+    {
+      if ((r = (_pthread_v *)calloc (1,sizeof(struct _pthread_v))) != NULL)
+	{
+	  r->x = __pthread_register_pointer (r);
+	  if (r->x == 0)
+	    {
+	      free (r);
+	      r = NULL;
+	    }
+	}
+      pthread_mutex_unlock (&mtx_pthr_locked);
+      return r;
+    }
+  r->x = __pthread_register_pointer (r);
+  if (r->x == 0)
+    r = NULL;
+  else
+    {
+      if((pthr_root = r->next) == NULL)
+	pthr_last = NULL;
+
+      r->next = NULL;
+    }
+  pthread_mutex_unlock (&mtx_pthr_locked);
+  return r;
+}
+
+/* Free memory consumed in _pthread_v pointer pool.  */
+static void
+free_pthread_mem (void)
+{
+  _pthread_v *t;
+
+  if (1)
+  return;  
+  pthread_mutex_lock (&mtx_pthr_locked);
+  t = pthr_root;
+  while (t != NULL)
+  {
+    _pthread_v *sv = t;
+    t = t->next;
+    if (sv->x != 0 && sv->ended == 0 && sv->valid != DEAD_THREAD)
+      {
+	pthread_mutex_unlock (&mtx_pthr_locked);
+	pthread_cancel (t->x);
+	Sleep (0);
+	pthread_mutex_lock (&mtx_pthr_locked);
+	t = pthr_root;
+	continue;
+      }
+    else if (sv->x != 0 && sv->valid != DEAD_THREAD)
+      {
+	pthread_mutex_unlock (&mtx_pthr_locked);
+	Sleep (0);
+	pthread_mutex_lock (&mtx_pthr_locked);
+	continue;
+      }
+    if (sv->x != 0)
+      __pthread_deregister_pointer (sv->x);
+    sv->x = 0;
+    free (sv);
+    pthr_root = t;
+  }
+  pthread_mutex_unlock (&mtx_pthr_locked);
+}
+
+static void
+replace_spin_keys (pthread_spinlock_t *old, pthread_spinlock_t new)
+{
+  if (old == NULL)
+    return;
+
+  if (EPERM == pthread_spin_destroy (old))
+    {
+#define THREADERR "Error cleaning up spin_keys for thread "
+#define THREADERR_LEN ((sizeof (THREADERR) / sizeof (*THREADERR)) - 1)
+#define THREADID_LEN THREADERR_LEN + 66 + 1 + 1
+      int i;
+      char thread_id[THREADID_LEN] = THREADERR;
+      _ultoa ((unsigned long) GetCurrentThreadId (), &thread_id[THREADERR_LEN], 10);
+      for (i = THREADERR_LEN; thread_id[i] != '\0' && i < THREADID_LEN - 1; i++)
+        {
+        }
+      if (i < THREADID_LEN - 1)
+        {
+          thread_id[i] = '\n';
+          thread_id[i + 1] = '\0';
+        }
+#undef THREADERR
+#undef THREADERR_LEN
+#undef THREADID_LEN
+      OutputDebugStringA (thread_id);
+      abort ();
+    }
+
+  *old = new;
+}
+
+/* Hook for TLS-based deregistration/registration of thread.  */
+static BOOL WINAPI
+__dyn_tls_pthread (HANDLE hDllHandle, DWORD dwReason, LPVOID lpreserved)
+{
+  _pthread_v *t = NULL;
+  pthread_spinlock_t new_spin_keys = PTHREAD_SPINLOCK_INITIALIZER;
+
+  if (dwReason == DLL_PROCESS_DETACH)
+    {
+#if defined(USE_VEH_FOR_MSC_SETTHREADNAME)
+      if (lpreserved == NULL && SetThreadName_VEH_handle != NULL)
+        {
+          RemoveVectoredExceptionHandler (SetThreadName_VEH_handle);
+          SetThreadName_VEH_handle = NULL;
+        }
+#endif
+      free_pthread_mem ();
+    }
+  else if (dwReason == DLL_PROCESS_ATTACH)
+    {
+#if defined(USE_VEH_FOR_MSC_SETTHREADNAME)
+      SetThreadName_VEH_handle = AddVectoredExceptionHandler (1, &SetThreadName_VEH);
+      /* Can't do anything on error anyway, check for NULL later */
+#endif
+    }
+  else if (dwReason == DLL_THREAD_DETACH)
+    {
+      if (_pthread_tls != 0xffffffff)
+	t = (_pthread_v *)TlsGetValue(_pthread_tls);
+      if (t && t->thread_noposix != 0)
+	{
+	  _pthread_cleanup_dest (t->x);
+	  if (t->h != NULL)
+	    {
+	      CloseHandle (t->h);
+	      if (t->evStart)
+		CloseHandle (t->evStart);
+	      t->evStart = NULL;
+	      t->h = NULL;
+	    }
+	  pthread_mutex_destroy (&t->p_clock);
+	  replace_spin_keys (&t->spin_keys, new_spin_keys);
+	  push_pthread_mem (t);
+	  t = NULL;
+	  TlsSetValue (_pthread_tls, t);
+	}
+      else if (t && t->ended == 0)
+	{
+	  if (t->evStart)
+	    CloseHandle(t->evStart);
+	  t->evStart = NULL;
+	  t->ended = 1;
+	  _pthread_cleanup_dest (t->x);
+	  if ((t->p_state & PTHREAD_CREATE_DETACHED) == PTHREAD_CREATE_DETACHED)
+	    {
+	      t->valid = DEAD_THREAD;
+	      if (t->h != NULL)
+		CloseHandle (t->h);
+	      t->h = NULL;
+	      pthread_mutex_destroy(&t->p_clock);
+	      replace_spin_keys (&t->spin_keys, new_spin_keys);
+	      push_pthread_mem (t);
+	      t = NULL;
+	      TlsSetValue (_pthread_tls, t);
+	      return TRUE;
+	    }
+	  pthread_mutex_destroy(&t->p_clock);
+	  replace_spin_keys (&t->spin_keys, new_spin_keys);
+	}
+      else if (t)
+	{
+	  if (t->evStart)
+	    CloseHandle (t->evStart);
+	  t->evStart = NULL;
+	  pthread_mutex_destroy (&t->p_clock);
+	  replace_spin_keys (&t->spin_keys, new_spin_keys);
+	}
+    }
+  return TRUE;
+}
+
+/* TLS-runtime section variable.  */
+#ifdef _MSC_VER
+#pragma section(".CRT$XLF", shared)
+#endif
+PIMAGE_TLS_CALLBACK WINPTHREADS_ATTRIBUTE((WINPTHREADS_SECTION(".CRT$XLF"))) __xl_f  = (PIMAGE_TLS_CALLBACK) __dyn_tls_pthread;
+#ifdef _MSC_VER
+#pragma data_seg()
+#endif
+
+#ifdef WINPTHREAD_DBG
+static int print_state = 0;
+void thread_print_set (int state)
+{
+  print_state = state;
+}
+
+void
+thread_print (volatile pthread_t t, char *txt)
+{
+    if (!print_state)
+      return;
+    if (!t)
+      printf("T%p %d %s\n",NULL,(int)GetCurrentThreadId(),txt);
+    else
+      {
+	printf("T%p %d V=%0X H=%p %s\n",
+	    __pth_gpointer_locked (t), 
+	    (int)GetCurrentThreadId(), 
+	    (int) (__pth_gpointer_locked (t))->valid, 
+	    (__pth_gpointer_locked (t))->h,
+	    txt
+	    );
+      }
+}
+#endif
+
+/* Internal collect-once structure.  */
+typedef struct collect_once_t {
+  pthread_once_t *o;
+  pthread_mutex_t m;
+  int count;
+  struct collect_once_t *next;
+} collect_once_t;
+
+static collect_once_t *once_obj = NULL;
+
+static pthread_spinlock_t once_global = PTHREAD_SPINLOCK_INITIALIZER;
+
+static collect_once_t *
+enterOnceObject (pthread_once_t *o)
+{
+  collect_once_t *c, *p = NULL;
+  pthread_spin_lock (&once_global);
+  c = once_obj;
+  while (c != NULL && c->o != o)
+    {
+      c = (p = c)->next;
+    }
+  if (!c)
+    {
+      c = (collect_once_t *) calloc(1,sizeof(collect_once_t));
+      c->o = o;
+      c->count = 1;
+      if (!p)
+        once_obj = c;
+      else
+        p->next = c;
+      pthread_mutex_init(&c->m, NULL);
+    }
+  else
+    c->count += 1;
+  pthread_spin_unlock (&once_global);
+  return c;
+}
+
+static void
+leaveOnceObject (collect_once_t *c)
+{
+  collect_once_t *h, *p = NULL;
+  if (!c)
+    return;
+  pthread_spin_lock (&once_global);
+  h = once_obj;
+  while (h != NULL && c != h)
+    h = (p = h)->next;
+
+  if (h)
+    {
+      c->count -= 1;
+      if (c->count == 0)
+	{
+	  pthread_mutex_destroy(&c->m);
+	  if (!p)
+	    once_obj = c->next;
+	  else
+	    p->next = c->next;
+	  free (c);
+	}
+    }
+  else
+    fprintf(stderr, "%p not found?!?!\n", c);
+  pthread_spin_unlock (&once_global);
+}
+
+static void
+_pthread_once_cleanup (void *o)
+{
+  collect_once_t *co = (collect_once_t *) o;
+  pthread_mutex_unlock (&co->m);
+  leaveOnceObject (co);
+}
+
+static int
+_pthread_once_raw (pthread_once_t *o, void (*func)(void))
+{
+  collect_once_t *co;
+  long state = *o;
+
+  CHECK_PTR(o);
+  CHECK_PTR(func);
+
+  if (state == 1)
+    return 0;
+  co = enterOnceObject(o);
+  pthread_mutex_lock(&co->m);
+  if (*o == 0)
+    {
+      func();
+      *o = 1;
+    }
+  else if (*o != 1)
+    fprintf (stderr," once %p is %d\n", o, (int) *o);
+  pthread_mutex_unlock(&co->m);
+  leaveOnceObject(co);
+
+  /* Done */
+  return 0;
+}
+
+/* Unimplemented.  */
+void *
+pthread_timechange_handler_np(void *dummy)
+{
+  return NULL;
+}
+
+/* Compatibility routine for pthread-win32.  It waits for ellapse of
+   interval and additionally checks for possible thread-cancelation.  */
+int
+pthread_delay_np (const struct timespec *interval)
+{
+  DWORD to = (!interval ? 0 : dwMilliSecs (_pthread_time_in_ms_from_timespec (interval)));
+  struct _pthread_v *s = __pthread_self_lite ();
+
+  if (!to)
+    {
+      pthread_testcancel ();
+      Sleep (0);
+      pthread_testcancel ();
+      return 0;
+    }
+  pthread_testcancel ();
+  if (s->evStart)
+    _pthread_wait_for_single_object (s->evStart, to);
+  else
+    Sleep (to);
+  pthread_testcancel ();
+  return 0;
+}
+
+int pthread_delay_np_ms (DWORD to);
+
+int
+pthread_delay_np_ms (DWORD to)
+{
+  struct _pthread_v *s = __pthread_self_lite ();
+
+  if (!to)
+    {
+      pthread_testcancel ();
+      Sleep (0);
+      pthread_testcancel ();
+      return 0;
+    }
+  pthread_testcancel ();
+  if (s->evStart)
+    _pthread_wait_for_single_object (s->evStart, to);
+  else
+    Sleep (to);
+  pthread_testcancel ();
+  return 0;
+}
+
+/* Compatibility routine for pthread-win32.  It returns the
+   amount of available CPUs on system.  */
+int
+pthread_num_processors_np(void) 
+{
+  int r = 0;
+  DWORD_PTR ProcessAffinityMask, SystemAffinityMask;
+
+  if (GetProcessAffinityMask(GetCurrentProcess(), &ProcessAffinityMask, &SystemAffinityMask))
+    {
+      for(; ProcessAffinityMask != 0; ProcessAffinityMask >>= 1)
+	r += (ProcessAffinityMask & 1) != 0;
+    }
+  /* assume at least 1 */
+  return r ? r : 1;
+}
+
+/* Compatiblity routine for pthread-win32.  Allows to set amount of used
+   CPUs for process.  */
+int
+pthread_set_num_processors_np(int n) 
+{
+  DWORD_PTR ProcessAffinityMask, ProcessNewAffinityMask = 0, SystemAffinityMask;
+  int r = 0; 
+  /* need at least 1 */
+  n = n ? n : 1;
+  if (GetProcessAffinityMask (GetCurrentProcess (), &ProcessAffinityMask, &SystemAffinityMask))
+    {
+      for (; ProcessAffinityMask != 0; ProcessAffinityMask >>= 1)
+	{
+	  ProcessNewAffinityMask <<= 1;
+	  if ((ProcessAffinityMask & 1) != 0 && r < n)
+	    {
+	      ProcessNewAffinityMask |= 1;
+	      r++;
+	    }
+	}
+      SetProcessAffinityMask (GetCurrentProcess (),ProcessNewAffinityMask);
+    }
+  return r;
+}
+
+int
+pthread_once (pthread_once_t *o, void (*func)(void))
+{
+  collect_once_t *co;
+  long state = *o;
+
+  CHECK_PTR(o);
+  CHECK_PTR(func);
+
+  if (state == 1)
+    return 0;
+  co = enterOnceObject(o);
+  pthread_mutex_lock(&co->m);
+  if (*o == 0)
+    {
+      pthread_cleanup_push(_pthread_once_cleanup, co);
+      func();
+      pthread_cleanup_pop(0);
+      *o = 1;
+    }
+  else if (*o != 1)
+    fprintf (stderr," once %p is %d\n", o, (int) *o);
+  pthread_mutex_unlock(&co->m);
+  leaveOnceObject(co);
+
+  return 0;
+}
+
+int
+pthread_key_create (pthread_key_t *key, void (* dest)(void *))
+{
+	unsigned int i;
+	long nmax;
+	void (**d)(void *);
+
+	if (!key)
+		return EINVAL;
+
+	pthread_rwlock_wrlock (&_pthread_key_lock);
+
+	for (i = _pthread_key_sch; i < _pthread_key_max; i++)
+	{
+		if (!_pthread_key_dest[i])
+		{
+			*key = i;
+			if (dest)
+				_pthread_key_dest[i] = dest;
+			else
+				_pthread_key_dest[i] = (void(*)(void *))1;
+			pthread_rwlock_unlock (&_pthread_key_lock);
+			return 0;
+		}
+	}
+
+	for (i = 0; i < _pthread_key_sch; i++)
+	{
+		if (!_pthread_key_dest[i])
+		{
+			*key = i;
+			if (dest)
+				_pthread_key_dest[i] = dest;
+			else
+				_pthread_key_dest[i] = (void(*)(void *))1;
+			pthread_rwlock_unlock (&_pthread_key_lock);
+
+			return 0;
+		}
+	}
+
+	if (_pthread_key_max == PTHREAD_KEYS_MAX)
+	{
+		pthread_rwlock_unlock(&_pthread_key_lock);
+		return ENOMEM;
+	}
+
+	nmax = _pthread_key_max * 2;
+	if (nmax == 0)
+		nmax = _pthread_key_max + 1;
+	if (nmax > PTHREAD_KEYS_MAX)
+		nmax = PTHREAD_KEYS_MAX;
+
+	/* No spare room anywhere */
+	d = (void (__cdecl **)(void *))realloc(_pthread_key_dest, nmax * sizeof(*d));
+	if (!d)
+	{
+		pthread_rwlock_unlock (&_pthread_key_lock);
+		return ENOMEM;
+	}
+
+	/* Clear new region */
+	memset ((void *) &d[_pthread_key_max], 0, (nmax-_pthread_key_max)*sizeof(void *));
+
+	/* Use new region */
+	_pthread_key_dest = d;
+	_pthread_key_sch = _pthread_key_max + 1;
+	*key = _pthread_key_max;
+	_pthread_key_max = nmax;
+
+	if (dest)
+		_pthread_key_dest[*key] = dest;
+	else
+		_pthread_key_dest[*key] = (void(*)(void *))1;
+
+	pthread_rwlock_unlock (&_pthread_key_lock);
+	return 0;
+}
+
+int
+pthread_key_delete (pthread_key_t key)
+{
+  if (key >= _pthread_key_max || !_pthread_key_dest)
+    return EINVAL;
+
+  pthread_rwlock_wrlock (&_pthread_key_lock);
+  
+  _pthread_key_dest[key] = NULL;
+
+  /* Start next search from our location */
+  if (_pthread_key_sch > key)
+    _pthread_key_sch = key;
+  /* So now we need to walk the complete list of threads
+     and remove key's reference for it.  */
+  __pth_remove_use_for_key (key);
+
+  pthread_rwlock_unlock (&_pthread_key_lock);
+  return 0;
+}
+
+void *
+pthread_getspecific (pthread_key_t key)
+{
+  DWORD lasterr = GetLastError ();
+  void *r;
+  _pthread_v *t = __pthread_self_lite ();
+  pthread_spin_lock (&t->spin_keys);
+  r = (key >= t->keymax || t->keyval_set[key] == 0 ? NULL : t->keyval[key]);
+  pthread_spin_unlock (&t->spin_keys);
+  SetLastError (lasterr);
+  return r;
+}
+
+int
+pthread_setspecific (pthread_key_t key, const void *value)
+{
+  DWORD lasterr = GetLastError ();
+  _pthread_v *t = __pthread_self_lite ();
+  
+  pthread_spin_lock (&t->spin_keys);
+
+  if (key >= t->keymax)
+    {
+      int keymax = (key + 1);
+      void **kv;
+      unsigned char *kv_set;
+
+      kv = (void **) realloc (t->keyval, keymax * sizeof (void *));
+
+      if (!kv)
+        {
+	  pthread_spin_unlock (&t->spin_keys);
+	  return ENOMEM;
+	}
+      kv_set = (unsigned char *) realloc (t->keyval_set, keymax);
+      if (!kv_set)
+        {
+	  pthread_spin_unlock (&t->spin_keys);
+	  return ENOMEM;
+	}
+
+      /* Clear new region */
+      memset (&kv[t->keymax], 0, (keymax - t->keymax)*sizeof(void *));
+      memset (&kv_set[t->keymax], 0, (keymax - t->keymax));
+
+      t->keyval = kv;
+      t->keyval_set = kv_set;
+      t->keymax = keymax;
+    }
+
+  t->keyval[key] = (void *) value;
+  t->keyval_set[key] = 1;
+  pthread_spin_unlock (&t->spin_keys);
+  SetLastError (lasterr);
+
+  return 0;
+}
+
+int
+pthread_equal (pthread_t t1, pthread_t t2)
+{
+  return (t1 == t2);
+}
+
+void
+pthread_tls_init (void)
+{
+  _pthread_tls = TlsAlloc();
+
+  /* Cannot continue if out of indexes */
+  if (_pthread_tls == TLS_OUT_OF_INDEXES)
+    abort();
+}
+
+void
+_pthread_cleanup_dest (pthread_t t)
+{
+	_pthread_v *tv;
+	unsigned int i, j;
+
+	if (!t)
+		return;
+	tv = __pth_gpointer_locked (t);
+	if (!tv)
+		return;
+
+	for (j = 0; j < PTHREAD_DESTRUCTOR_ITERATIONS; j++)
+	{
+		int flag = 0;
+
+		pthread_spin_lock (&tv->spin_keys);
+		for (i = 0; i < tv->keymax; i++)
+		{
+			void *val = tv->keyval[i];
+
+			if (tv->keyval_set[i])
+			{
+				pthread_rwlock_rdlock (&_pthread_key_lock);
+				if ((uintptr_t) _pthread_key_dest[i] > 1)
+				{
+					/* Call destructor */
+					tv->keyval[i] = NULL;
+					tv->keyval_set[i] = 0;
+					pthread_spin_unlock (&tv->spin_keys);
+					_pthread_key_dest[i](val);
+					pthread_spin_lock (&tv->spin_keys);
+					flag = 1;
+				}
+				else
+				{
+					tv->keyval[i] = NULL;
+					tv->keyval_set[i] = 0;
+				}
+				pthread_rwlock_unlock(&_pthread_key_lock);
+			}
+		}
+		pthread_spin_unlock (&tv->spin_keys);
+		/* Nothing to do? */
+		if (!flag)
+			return;
+	}
+}
+
+static _pthread_v *
+__pthread_self_lite (void)
+{
+  _pthread_v *t;
+  pthread_spinlock_t new_spin_keys = PTHREAD_SPINLOCK_INITIALIZER;
+
+  _pthread_once_raw (&_pthread_tls_once, pthread_tls_init);
+
+  t = (_pthread_v *) TlsGetValue (_pthread_tls);
+  if (t)
+    return t;
+  /* Main thread? */
+  t = (struct _pthread_v *) pop_pthread_mem ();
+
+  /* If cannot initialize main thread, then the only thing we can do is return null pthread_t */
+  if (!__xl_f || !t)
+    return 0;
+
+  t->p_state = PTHREAD_DEFAULT_ATTR /*| PTHREAD_CREATE_DETACHED*/;
+  t->tid = GetCurrentThreadId();
+  t->evStart = CreateEvent (NULL, 1, 0, NULL);
+  t->p_clock = PTHREAD_MUTEX_INITIALIZER;
+  replace_spin_keys (&t->spin_keys, new_spin_keys);
+  t->sched_pol = SCHED_OTHER;
+  t->h = NULL; //GetCurrentThread();
+  if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &t->h, 0, FALSE, DUPLICATE_SAME_ACCESS))
+    abort ();
+  t->sched.sched_priority = GetThreadPriority(t->h);
+  t->ended = 0;
+  t->thread_noposix = 1;
+
+  /* Save for later */
+  if (!TlsSetValue(_pthread_tls, t))
+    abort ();
+  return t;
+}
+
+pthread_t
+pthread_self (void)
+{
+  _pthread_v *t = __pthread_self_lite ();
+
+  if (!t)
+    return 0;
+  return t->x;
+}
+
+/* Internal helper for getting event handle of thread T.  */
+void *
+pthread_getevent (void)
+{
+  _pthread_v *t = __pthread_self_lite ();
+  return (!t ? NULL : t->evStart);
+}
+
+/* Internal helper for getting thread handle of thread T.  */
+void *
+pthread_gethandle (pthread_t t)
+{
+  struct _pthread_v *tv = __pth_gpointer_locked (t);
+  return (!tv ? NULL : tv->h);
+}
+
+/* Internal helper for getting pointer of clean of current thread.  */
+struct _pthread_cleanup **
+pthread_getclean (void)
+{
+  struct _pthread_v *t = __pthread_self_lite ();
+  if (!t) return NULL;
+  return &t->clean;
+}
+
+int
+pthread_get_concurrency (int *val)
+{
+  *val = _pthread_concur;
+  return 0;
+}
+
+int
+pthread_set_concurrency (int val)
+{
+  _pthread_concur = val;
+  return 0;
+}
+
+void
+pthread_exit (void *res)
+{
+  _pthread_v *t = NULL;
+  unsigned rslt = (unsigned) ((intptr_t) res);
+  struct _pthread_v *id = __pthread_self_lite ();
+
+  id->ret_arg = res;
+
+  _pthread_cleanup_dest (id->x);
+  if (id->thread_noposix == 0)
+    longjmp(id->jb, 1);
+
+  /* Make sure we free ourselves if we are detached */
+  if ((t = (_pthread_v *)TlsGetValue(_pthread_tls)) != NULL)
+    {
+      if (!t->h)
+	{
+	  t->valid = DEAD_THREAD;
+	  if (t->evStart)
+	    CloseHandle (t->evStart);
+	  t->evStart = NULL;
+	  rslt = (unsigned) (size_t) t->ret_arg;
+	  push_pthread_mem(t);
+	  t = NULL;
+	  TlsSetValue (_pthread_tls, t);
+	}
+      else
+	{
+	  rslt = (unsigned) (size_t) t->ret_arg;
+	  t->ended = 1;
+	  if (t->evStart)
+	    CloseHandle (t->evStart);
+	  t->evStart = NULL;
+	  if ((t->p_state & PTHREAD_CREATE_DETACHED) == PTHREAD_CREATE_DETACHED)
+	    {
+	      t->valid = DEAD_THREAD;
+	      CloseHandle (t->h);
+	      t->h = NULL;
+	      push_pthread_mem(t);
+	      t = NULL;
+	      TlsSetValue(_pthread_tls, t);
+	    }
+	}
+    }
+  /* Time to die */
+  _endthreadex(rslt);
+}
+
+void
+_pthread_invoke_cancel (void)
+{
+  _pthread_cleanup *pcup;
+  struct _pthread_v *se = __pthread_self_lite ();
+  se->in_cancel = 1;
+  _pthread_setnobreak (1);
+  InterlockedDecrement(&_pthread_cancelling);
+
+  /* Call cancel queue */
+  for (pcup = se->clean; pcup; pcup = pcup->next)
+    {
+      pcup->func((pthread_once_t *)pcup->arg);
+    }
+
+  _pthread_setnobreak (0);
+  pthread_exit(PTHREAD_CANCELED);
+}
+
+int
+__pthread_shallcancel (void)
+{
+  struct _pthread_v *t;
+  if (!_pthread_cancelling)
+    return 0;
+  t = __pthread_self_lite ();
+  if (t == NULL)
+    return 0;
+  if (t->nobreak <= 0 && t->cancelled && (t->p_state & PTHREAD_CANCEL_ENABLE))
+    return 1;
+  return 0;
+}
+
+void
+_pthread_setnobreak (int v)
+{
+  struct _pthread_v *t = __pthread_self_lite ();
+  if (t == NULL)
+    return;
+  if (v > 0)
+    InterlockedIncrement ((long*)&t->nobreak);
+  else
+    InterlockedDecrement((long*)&t->nobreak);
+}
+
+void
+pthread_testcancel (void)
+{
+  struct _pthread_v *self = __pthread_self_lite ();
+
+  if (!self || self->in_cancel)
+    return;
+  if (!_pthread_cancelling)
+    return;
+  pthread_mutex_lock (&self->p_clock);
+
+  if (self->cancelled && (self->p_state & PTHREAD_CANCEL_ENABLE) && self->nobreak <= 0)
+    {
+      self->in_cancel = 1;
+      self->p_state &= ~PTHREAD_CANCEL_ENABLE;
+      if (self->evStart)
+	ResetEvent (self->evStart);
+      pthread_mutex_unlock (&self->p_clock);
+      _pthread_invoke_cancel ();
+    }
+  pthread_mutex_unlock (&self->p_clock);
+}
+
+int
+pthread_cancel (pthread_t t)
+{
+  struct _pthread_v *tv = __pth_gpointer_locked (t);
+
+  if (tv == NULL)
+    return ESRCH;
+  CHECK_OBJECT(tv, ESRCH);
+  /*if (tv->ended) return ESRCH;*/
+  pthread_mutex_lock(&tv->p_clock);
+  if (pthread_equal(pthread_self(), t))
+    {
+      if(tv->cancelled)
+	{
+	  pthread_mutex_unlock(&tv->p_clock);
+	  return (tv->in_cancel ? ESRCH : 0);
+	}
+      tv->cancelled = 1;
+      InterlockedIncrement(&_pthread_cancelling);
+      if(tv->evStart) SetEvent(tv->evStart);
+      if ((tv->p_state & PTHREAD_CANCEL_ASYNCHRONOUS) != 0 && (tv->p_state & PTHREAD_CANCEL_ENABLE) != 0)
+	{
+	  tv->p_state &= ~PTHREAD_CANCEL_ENABLE;
+	  tv->in_cancel = 1;
+	  pthread_mutex_unlock(&tv->p_clock);
+	  _pthread_invoke_cancel();
+	}
+      else
+	pthread_mutex_unlock(&tv->p_clock);
+      return 0;
+    }
+
+  if ((tv->p_state & PTHREAD_CANCEL_ASYNCHRONOUS) != 0 && (tv->p_state & PTHREAD_CANCEL_ENABLE) != 0)
+    {
+      /* Dangerous asynchronous cancelling */
+      CONTEXT ctxt;
+
+      if(tv->in_cancel)
+	{
+	  pthread_mutex_unlock(&tv->p_clock);
+	  return (tv->in_cancel ? ESRCH : 0);
+	}
+      /* Already done? */
+      if(tv->cancelled || tv->in_cancel)
+	{
+	  /* ??? pthread_mutex_unlock (&tv->p_clock); */
+	  return ESRCH;
+	}
+
+      ctxt.ContextFlags = CONTEXT_CONTROL;
+
+      SuspendThread (tv->h);
+      if (WaitForSingleObject (tv->h, 0) == WAIT_TIMEOUT)
+	{
+	  GetThreadContext(tv->h, &ctxt);
+#ifdef _M_X64
+	  ctxt.Rip = (uintptr_t) _pthread_invoke_cancel;
+#elif defined(_M_IX86)
+	  ctxt.Eip = (uintptr_t) _pthread_invoke_cancel;
+#elif defined(_M_ARM) || defined(_M_ARM64)
+	  ctxt.Pc = (uintptr_t) _pthread_invoke_cancel;
+#else
+#error Unsupported architecture
+#endif
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
+	  SetThreadContext (tv->h, &ctxt);
+#endif
+
+	  /* Also try deferred Cancelling */
+	  tv->cancelled = 1;
+	  tv->p_state &= ~PTHREAD_CANCEL_ENABLE;
+	  tv->in_cancel = 1;
+
+	  /* Notify everyone to look */
+	  InterlockedIncrement (&_pthread_cancelling);
+	  if (tv->evStart)
+	    SetEvent (tv->evStart);
+	  pthread_mutex_unlock (&tv->p_clock);
+
+	  ResumeThread (tv->h);
+	}
+    }
+  else
+    {
+      if (tv->cancelled == 0)
+	{
+	  /* Safe deferred Cancelling */
+	  tv->cancelled = 1;
+
+	  /* Notify everyone to look */
+	  InterlockedIncrement (&_pthread_cancelling);
+	  if (tv->evStart)
+	    SetEvent (tv->evStart);
+	}
+      else
+	{
+	  pthread_mutex_unlock (&tv->p_clock);
+	  return (tv->in_cancel ? ESRCH : 0);
+	}
+    }
+  pthread_mutex_unlock (&tv->p_clock);
+  return 0;
+}
+
+/* half-stubbed version as we don't really well support signals */
+int
+pthread_kill (pthread_t t, int sig)
+{
+  struct _pthread_v *tv;
+
+  pthread_mutex_lock (&mtx_pthr_locked);
+  tv = __pthread_get_pointer (t);
+  if (!tv || t != tv->x || tv->in_cancel || tv->ended || tv->h == NULL
+      || tv->h == INVALID_HANDLE_VALUE)
+  {
+    pthread_mutex_unlock (&mtx_pthr_locked);
+    return ESRCH;
+  }
+  pthread_mutex_unlock (&mtx_pthr_locked);
+  if (!sig)
+    return 0;
+  if (sig < SIGINT || sig > NSIG)
+    return EINVAL;
+  return pthread_cancel(t);
+}
+
+unsigned
+_pthread_get_state (const pthread_attr_t *attr, unsigned flag)
+{
+  return (attr->p_state & flag);
+}
+
+int
+_pthread_set_state (pthread_attr_t *attr, unsigned flag, unsigned val)
+{
+  if (~flag & val)
+    return EINVAL;
+  attr->p_state &= ~flag;
+  attr->p_state |= val;
+
+  return 0;
+}
+
+int
+pthread_attr_init (pthread_attr_t *attr)
+{
+  memset (attr, 0, sizeof (pthread_attr_t));
+  attr->p_state = PTHREAD_DEFAULT_ATTR;
+  attr->stack = NULL;
+  attr->s_size = 0;
+  return 0;
+}
+
+int
+pthread_attr_destroy (pthread_attr_t *attr)
+{
+  /* No need to do anything */
+  memset (attr, 0, sizeof(pthread_attr_t));
+  return 0;
+}
+
+int
+pthread_attr_setdetachstate (pthread_attr_t *a, int flag)
+{
+  return _pthread_set_state(a, PTHREAD_CREATE_DETACHED, flag);
+}
+
+int
+pthread_attr_getdetachstate (const pthread_attr_t *a, int *flag)
+{
+  *flag = _pthread_get_state(a, PTHREAD_CREATE_DETACHED);
+  return 0;
+}
+
+int
+pthread_attr_setinheritsched (pthread_attr_t *a, int flag)
+{
+  if (!a || (flag != PTHREAD_INHERIT_SCHED && flag != PTHREAD_EXPLICIT_SCHED))
+    return EINVAL;
+  return _pthread_set_state(a, PTHREAD_INHERIT_SCHED, flag);
+}
+
+int
+pthread_attr_getinheritsched (const pthread_attr_t *a, int *flag)
+{
+  *flag = _pthread_get_state(a, PTHREAD_INHERIT_SCHED);
+  return 0;
+}
+
+int
+pthread_attr_setscope (pthread_attr_t *a, int flag)
+{
+  return _pthread_set_state(a, PTHREAD_SCOPE_SYSTEM, flag);
+}
+
+int
+pthread_attr_getscope (const pthread_attr_t *a, int *flag)
+{
+  *flag = _pthread_get_state(a, PTHREAD_SCOPE_SYSTEM);
+  return 0;
+}
+
+int
+pthread_attr_getstack (const pthread_attr_t *attr, void **stack, size_t *size)
+{
+  *stack = (char *) attr->stack - attr->s_size;
+  *size = attr->s_size;
+  return 0;
+}
+
+int
+pthread_attr_setstack (pthread_attr_t *attr, void *stack, size_t size)
+{
+  attr->s_size = size;
+  attr->stack = (char *) stack + size;
+  return 0;
+}
+
+int
+pthread_attr_getstackaddr (const pthread_attr_t *attr, void **stack)
+{
+  *stack = attr->stack;
+  return 0;
+}
+
+int
+pthread_attr_setstackaddr (pthread_attr_t *attr, void *stack)
+{
+  attr->stack = stack;
+  return 0;
+}
+
+int
+pthread_attr_getstacksize (const pthread_attr_t *attr, size_t *size)
+{
+  *size = attr->s_size;
+  return 0;
+}
+
+int
+pthread_attr_setstacksize (pthread_attr_t *attr, size_t size)
+{
+  attr->s_size = size;
+  return 0;
+}
+
+static void
+test_cancel_locked (pthread_t t)
+{
+  struct _pthread_v *tv = __pth_gpointer_locked (t);
+
+  if (!tv || tv->in_cancel || tv->ended != 0 || (tv->p_state & PTHREAD_CANCEL_ENABLE) == 0)
+    return;
+  if ((tv->p_state & PTHREAD_CANCEL_ASYNCHRONOUS) == 0)
+    return;
+  if (WaitForSingleObject(tv->evStart, 0) != WAIT_OBJECT_0)
+    return;
+  pthread_mutex_unlock (&tv->p_clock);
+  _pthread_invoke_cancel();
+}
+
+int
+pthread_setcancelstate (int state, int *oldstate)
+{
+  _pthread_v *t = __pthread_self_lite ();
+
+  if (!t || (state & PTHREAD_CANCEL_ENABLE) != state)
+    return EINVAL;
+
+  pthread_mutex_lock (&t->p_clock);
+  if (oldstate)
+    *oldstate = t->p_state & PTHREAD_CANCEL_ENABLE;
+  t->p_state &= ~PTHREAD_CANCEL_ENABLE;
+  t->p_state |= state;
+  test_cancel_locked (t->x);
+  pthread_mutex_unlock (&t->p_clock);
+
+  return 0;
+}
+
+int
+pthread_setcanceltype (int type, int *oldtype)
+{
+  _pthread_v *t = __pthread_self_lite ();
+
+  if (!t || (type & PTHREAD_CANCEL_ASYNCHRONOUS) != type)
+    return EINVAL;
+
+  pthread_mutex_lock (&t->p_clock);
+  if (oldtype)
+    *oldtype = t->p_state & PTHREAD_CANCEL_ASYNCHRONOUS;
+  t->p_state &= ~PTHREAD_CANCEL_ASYNCHRONOUS;
+  t->p_state |= type;
+  test_cancel_locked (t->x);
+  pthread_mutex_unlock (&t->p_clock);
+
+  return 0;
+}
+
+void _fpreset (void);
+
+#if defined(__i386__)
+/* Align ESP on 16-byte boundaries. */
+#  if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)
+__attribute__((force_align_arg_pointer))
+#  endif
+#endif
+int
+pthread_create_wrapper (void *args)
+{
+  unsigned rslt = 0;
+  struct _pthread_v *tv = (struct _pthread_v *)args;
+
+  _fpreset();
+
+  pthread_mutex_lock (&mtx_pthr_locked);
+  pthread_mutex_lock (&tv->p_clock);
+  _pthread_once_raw(&_pthread_tls_once, pthread_tls_init);
+  TlsSetValue(_pthread_tls, tv);
+  tv->tid = GetCurrentThreadId();
+  pthread_mutex_unlock (&tv->p_clock);
+
+
+  if (!setjmp(tv->jb))
+    {
+      intptr_t trslt = (intptr_t) 128;
+      /* Provide to this thread a default exception handler.  */
+      #ifdef __SEH__
+	asm ("\t.tl_start:\n");
+      #endif      /* Call function and save return value */
+      pthread_mutex_unlock (&mtx_pthr_locked);
+      if (tv->func)
+        trslt = (intptr_t) tv->func(tv->ret_arg);
+      #ifdef __SEH__
+	asm ("\tnop\n\t.tl_end: nop\n"
+#ifdef __arm__
+	  "\t.seh_handler __C_specific_handler, %except\n"
+#else
+	  "\t.seh_handler __C_specific_handler, @except\n"
+#endif
+	  "\t.seh_handlerdata\n"
+	  "\t.long 1\n"
+	  "\t.rva .tl_start, .tl_end, _gnu_exception_handler ,.tl_end\n"
+	  "\t.text"
+	  );
+      #endif
+      pthread_mutex_lock (&mtx_pthr_locked);
+      tv->ret_arg = (void*) trslt;
+      /* Clean up destructors */
+      _pthread_cleanup_dest(tv->x);
+    }
+  else
+    pthread_mutex_lock (&mtx_pthr_locked);
+
+  pthread_mutex_lock (&tv->p_clock);
+  rslt = (unsigned) (size_t) tv->ret_arg;
+  /* Make sure we free ourselves if we are detached */
+  if (tv->evStart)
+    CloseHandle (tv->evStart);
+  tv->evStart = NULL;
+  if (!tv->h)
+    {
+      tv->valid = DEAD_THREAD;
+      pthread_mutex_unlock (&tv->p_clock);
+      pthread_mutex_destroy (&tv->p_clock);
+      push_pthread_mem (tv);
+      tv = NULL;
+      TlsSetValue (_pthread_tls, tv);
+    }
+  else
+    {
+      pthread_mutex_unlock (&tv->p_clock);
+      pthread_mutex_destroy (&tv->p_clock);
+      /* Reinitialise p_clock, since there may be attempts at
+         destroying it again in __dyn_tls_thread later on. */
+      tv->p_clock = PTHREAD_MUTEX_INITIALIZER;
+      tv->ended = 1;
+    }
+  while (pthread_mutex_unlock (&mtx_pthr_locked) == 0)
+   Sleep (0);
+  _endthreadex (rslt);
+  return rslt;
+}
+
+int
+pthread_create (pthread_t *th, const pthread_attr_t *attr, void *(* func)(void *), void *arg)
+{
+  HANDLE thrd = NULL;
+  int redo = 0;
+  struct _pthread_v *tv;
+  size_t ssize = 0;
+  pthread_spinlock_t new_spin_keys = PTHREAD_SPINLOCK_INITIALIZER;
+
+  if ((tv = pop_pthread_mem ()) == NULL)
+    return EAGAIN;
+
+  if (th)
+    *th = tv->x;
+
+  /* Save data in pthread_t */
+  tv->ended = 0;
+  tv->ret_arg = arg;
+  tv->func = func;
+  tv->p_state = PTHREAD_DEFAULT_ATTR;
+  tv->h = INVALID_HANDLE_VALUE;
+  /* We retry it here a few times, as events are a limited resource ... */
+  do
+    {
+      tv->evStart = CreateEvent (NULL, 1, 0, NULL);
+      if (tv->evStart != NULL)
+	break;
+      Sleep ((!redo ? 0 : 20));
+    }
+  while (++redo <= 4);
+
+  tv->p_clock = PTHREAD_MUTEX_INITIALIZER;
+  replace_spin_keys (&tv->spin_keys, new_spin_keys);
+  tv->valid = LIFE_THREAD;
+  tv->sched.sched_priority = THREAD_PRIORITY_NORMAL;
+  tv->sched_pol = SCHED_OTHER;
+  if (tv->evStart == NULL)
+    {
+      if (th)
+       memset (th, 0, sizeof (pthread_t));
+      push_pthread_mem (tv);
+      return EAGAIN;
+    }
+
+  if (attr)
+    {
+      int inh = 0;
+      tv->p_state = attr->p_state;
+      ssize = attr->s_size;
+      pthread_attr_getinheritsched (attr, &inh);
+      if (inh)
+	{
+	  tv->sched.sched_priority = __pthread_self_lite ()->sched.sched_priority;
+	}
+      else
+	tv->sched.sched_priority = attr->param.sched_priority;
+    }
+
+  /* Make sure tv->h has value of INVALID_HANDLE_VALUE */
+  _ReadWriteBarrier();
+
+  thrd = (HANDLE) _beginthreadex(NULL, ssize, (unsigned int (__stdcall *)(void *))pthread_create_wrapper, tv, 0x4/*CREATE_SUSPEND*/, NULL);
+  if (thrd == INVALID_HANDLE_VALUE)
+    thrd = 0;
+  /* Failed */
+  if (!thrd)
+    {
+      if (tv->evStart)
+	CloseHandle (tv->evStart);
+      pthread_mutex_destroy (&tv->p_clock);
+      replace_spin_keys (&tv->spin_keys, new_spin_keys);
+      tv->evStart = NULL;
+      tv->h = 0;
+      if (th)
+        memset (th, 0, sizeof (pthread_t));
+      push_pthread_mem (tv);
+      return EAGAIN;
+    }
+  {
+    int pr = tv->sched.sched_priority;
+    if (pr <= THREAD_PRIORITY_IDLE) {
+	pr = THREAD_PRIORITY_IDLE;
+    } else if (pr <= THREAD_PRIORITY_LOWEST) {
+	pr = THREAD_PRIORITY_LOWEST;
+    } else if (pr >= THREAD_PRIORITY_TIME_CRITICAL) {
+	pr = THREAD_PRIORITY_TIME_CRITICAL;
+    } else if (pr >= THREAD_PRIORITY_HIGHEST) {
+	pr = THREAD_PRIORITY_HIGHEST;
+    }
+    SetThreadPriority (thrd, pr);
+  }
+  ResetEvent (tv->evStart);
+  if ((tv->p_state & PTHREAD_CREATE_DETACHED) != 0)
+    {
+      tv->h = 0;
+      ResumeThread (thrd);
+      CloseHandle (thrd);
+    }
+  else
+    {
+      tv->h = thrd;
+      ResumeThread (thrd);
+    }
+  Sleep (0);
+  return 0;
+}
+
+int
+pthread_join (pthread_t t, void **res)
+{
+  DWORD dwFlags;
+  struct _pthread_v *tv = __pth_gpointer_locked (t);
+  pthread_spinlock_t new_spin_keys = PTHREAD_SPINLOCK_INITIALIZER;
+
+  if (!tv || tv->h == NULL || !GetHandleInformation(tv->h, &dwFlags))
+    return ESRCH;
+  if ((tv->p_state & PTHREAD_CREATE_DETACHED) != 0)
+    return EINVAL;
+  if (pthread_equal(pthread_self(), t))
+    return EDEADLK;
+
+  /* pthread_testcancel (); */
+  if (tv->ended == 0 || (tv->h != NULL && tv->h != INVALID_HANDLE_VALUE))
+    WaitForSingleObject (tv->h, INFINITE);
+  CloseHandle (tv->h);
+  if (tv->evStart)
+    CloseHandle (tv->evStart);
+  tv->evStart = NULL;
+  /* Obtain return value */
+  if (res)
+    *res = tv->ret_arg;
+  pthread_mutex_destroy (&tv->p_clock);
+  replace_spin_keys (&tv->spin_keys, new_spin_keys);
+  push_pthread_mem (tv);
+
+  return 0;
+}
+
+int
+_pthread_tryjoin (pthread_t t, void **res)
+{
+  DWORD dwFlags;
+  struct _pthread_v *tv;
+  pthread_spinlock_t new_spin_keys = PTHREAD_SPINLOCK_INITIALIZER;
+
+  pthread_mutex_lock (&mtx_pthr_locked);
+  tv = __pthread_get_pointer (t);
+
+  if (!tv || tv->h == NULL || !GetHandleInformation(tv->h, &dwFlags))
+    {
+      pthread_mutex_unlock (&mtx_pthr_locked);
+      return ESRCH;
+    }
+
+  if ((tv->p_state & PTHREAD_CREATE_DETACHED) != 0)
+    {
+      pthread_mutex_unlock (&mtx_pthr_locked);
+      return EINVAL;
+    }
+  if (pthread_equal(pthread_self(), t))
+    {
+      pthread_mutex_unlock (&mtx_pthr_locked);
+      return EDEADLK;
+    }
+  if(tv->ended == 0 && WaitForSingleObject(tv->h, 0))
+    {
+      if (tv->ended == 0)
+        {
+	      pthread_mutex_unlock (&mtx_pthr_locked);
+	      /* pthread_testcancel (); */
+	      return EBUSY;
+	    }
+    }
+  CloseHandle (tv->h);
+  if (tv->evStart)
+    CloseHandle (tv->evStart);
+  tv->evStart = NULL;
+
+  /* Obtain return value */
+  if (res)
+    *res = tv->ret_arg;
+  pthread_mutex_destroy (&tv->p_clock);
+  replace_spin_keys (&tv->spin_keys, new_spin_keys);
+
+  push_pthread_mem (tv);
+
+  pthread_mutex_unlock (&mtx_pthr_locked);
+  /* pthread_testcancel (); */
+  return 0;
+}
+
+int
+pthread_detach (pthread_t t)
+{
+  int r = 0;
+  DWORD dwFlags;
+  struct _pthread_v *tv = __pth_gpointer_locked (t);
+  HANDLE dw;
+  pthread_spinlock_t new_spin_keys = PTHREAD_SPINLOCK_INITIALIZER;
+
+  pthread_mutex_lock (&mtx_pthr_locked);
+  if (!tv || tv->h == NULL || !GetHandleInformation(tv->h, &dwFlags))
+    {
+      pthread_mutex_unlock (&mtx_pthr_locked);
+      return ESRCH;
+    }
+  if ((tv->p_state & PTHREAD_CREATE_DETACHED) != 0)
+    {
+      pthread_mutex_unlock (&mtx_pthr_locked);
+      return EINVAL;
+    }
+  /* if (tv->ended) r = ESRCH; */
+  dw = tv->h;
+  tv->h = 0;
+  tv->p_state |= PTHREAD_CREATE_DETACHED;
+  _ReadWriteBarrier();
+  if (dw)
+    {
+      CloseHandle (dw);
+      if (tv->ended)
+	{
+	  if (tv->evStart)
+	    CloseHandle (tv->evStart);
+	  tv->evStart = NULL;
+	  pthread_mutex_destroy (&tv->p_clock);
+	  replace_spin_keys (&tv->spin_keys, new_spin_keys);
+	  push_pthread_mem (tv);
+	}
+    }
+  pthread_mutex_unlock (&mtx_pthr_locked);
+
+  return r;
+}
+
+static int dummy_concurrency_level = 0;
+
+int
+pthread_getconcurrency (void)
+{
+  return dummy_concurrency_level;
+}
+
+int
+pthread_setconcurrency (int new_level)
+{
+  dummy_concurrency_level = new_level;
+  return 0;
+}
+
+int
+pthread_setname_np (pthread_t thread, const char *name)
+{
+  struct _pthread_v *tv;
+  char *stored_name;
+
+  if (name == NULL)
+    return EINVAL;
+
+  tv = __pth_gpointer_locked (thread);
+  if (!tv || thread != tv->x || tv->in_cancel || tv->ended || tv->h == NULL
+      || tv->h == INVALID_HANDLE_VALUE)
+    return ESRCH;
+
+  stored_name = strdup (name);
+  if (stored_name == NULL)
+    return ENOMEM;
+
+  if (tv->thread_name != NULL)
+    free (tv->thread_name);
+
+  tv->thread_name = stored_name;
+  SetThreadName (tv->tid, name);
+  return 0;
+}
+
+int
+pthread_getname_np (pthread_t thread, char *name, size_t len)
+{
+  HRESULT result;
+  struct _pthread_v *tv;
+
+  if (name == NULL)
+    return EINVAL;
+
+  tv = __pth_gpointer_locked (thread);
+  if (!tv || thread != tv->x || tv->in_cancel || tv->ended || tv->h == NULL
+      || tv->h == INVALID_HANDLE_VALUE)
+    return ESRCH;
+
+  if (len < 1)
+    return ERANGE;
+
+  if (tv->thread_name == NULL)
+    {
+      name[0] = '\0';
+      return 0;
+    }
+
+  if (strlen (tv->thread_name) >= len)
+    return ERANGE;
+
+  result = StringCchCopyNA (name, len, tv->thread_name, len - 1);
+  if (SUCCEEDED (result))
+    return 0;
+
+  return ERANGE;
+}
diff --git a/thirdparty/winpthreads/src/thread.h b/thirdparty/winpthreads/src/thread.h
new file mode 100644
index 00000000..729c5bc6
--- /dev/null
+++ b/thirdparty/winpthreads/src/thread.h
@@ -0,0 +1,79 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef WIN_PTHREAD_H
+#define WIN_PTHREAD_H
+
+#include <windows.h>
+#include <setjmp.h>
+#include "rwlock.h"
+
+#define LIFE_THREAD 0xBAB1F00D
+#define DEAD_THREAD 0xDEADBEEF
+#define EXCEPTION_SET_THREAD_NAME ((DWORD) 0x406D1388)
+
+typedef struct _pthread_v _pthread_v;
+struct _pthread_v
+{
+    unsigned int valid;
+    void *ret_arg;
+    void *(* func)(void *);
+    _pthread_cleanup *clean;
+    int nobreak;
+    HANDLE h;
+    HANDLE evStart;
+    pthread_mutex_t p_clock;
+    int cancelled : 2;
+    int in_cancel : 2;
+    int thread_noposix : 2;
+    unsigned int p_state;
+    unsigned int keymax;
+    void **keyval;
+    unsigned char *keyval_set;
+    char *thread_name;
+    pthread_spinlock_t spin_keys;
+    DWORD tid;
+    int rwlc;
+    pthread_rwlock_t rwlq[RWLS_PER_THREAD];
+    int sched_pol;
+    int ended;
+    struct sched_param sched;
+    jmp_buf jb;
+    struct _pthread_v *next;
+    pthread_t x; /* Internal posix handle.  */
+};
+
+typedef struct __pthread_idlist {
+  struct _pthread_v *ptr;
+  pthread_t id;
+} __pthread_idlist;
+
+int _pthread_tryjoin(pthread_t t, void **res);
+void _pthread_setnobreak(int);
+#ifdef WINPTHREAD_DBG
+void thread_print_set(int state);
+void thread_print(volatile pthread_t t, char *txt);
+#endif
+int  __pthread_shallcancel(void);
+struct _pthread_v *__pth_gpointer_locked (pthread_t id);
+
+#endif
diff --git a/thirdparty/winpthreads/src/version.rc b/thirdparty/winpthreads/src/version.rc
new file mode 100644
index 00000000..43a61176
--- /dev/null
+++ b/thirdparty/winpthreads/src/version.rc
@@ -0,0 +1,62 @@
+/*
+   Copyright (c) 2011 mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#include <winver.h>
+#include "wpth_ver.h"
+
+#define WPTH_VERSIONINFO_NAME "WinPthreadGC\0"
+#ifdef _WIN64
+#define WPTH_VERSIONINFO_COMMENT "GNU C build -- MinGW-w64 64-bit\0"
+#else
+#define WPTH_VERSIONINFO_COMMENT "GNU C build -- MinGW-w64 32-bit\0"
+#endif
+
+VS_VERSION_INFO VERSIONINFO
+  FILEVERSION    WPTH_VERSION
+  PRODUCTVERSION WPTH_VERSION
+  FILEFLAGSMASK  VS_FFI_FILEFLAGSMASK
+  FILEFLAGS      0
+  FILEOS         VOS__WINDOWS32
+  FILETYPE       VFT_DLL
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "FileDescription", "POSIX WinThreads for Windows\0"
+            VALUE "ProductVersion", WPTH_VERSION_STRING
+            VALUE "FileVersion", WPTH_VERSION_STRING
+            VALUE "InternalName", WPTH_VERSIONINFO_NAME
+            VALUE "OriginalFilename", WPTH_VERSIONINFO_NAME
+            VALUE "CompanyName", "MingW-W64 Project. All rights reserved.\0"
+            VALUE "LegalCopyright", "Copyright (C) MingW-W64 Project Members 2010-2011\0"
+            VALUE "Licence", "ZPL\0"
+            VALUE "Info", "http://mingw-w64.sourceforge.net/\0"
+	    VALUE "Comment", WPTH_VERSIONINFO_COMMENT
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
diff --git a/thirdparty/winpthreads/src/winpthread_internal.h b/thirdparty/winpthreads/src/winpthread_internal.h
new file mode 100644
index 00000000..015e6ce9
--- /dev/null
+++ b/thirdparty/winpthreads/src/winpthread_internal.h
@@ -0,0 +1,27 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef WINPTHREAD_INTERNAL_H
+#define WINPTHREAD_INTERNAL_H
+struct _pthread_v * WINPTHREAD_API __pth_gpointer_locked (pthread_t id);
+int pthread_delay_np_ms (DWORD to);
+#endif /*WINPTHREAD_INTERNAL_H*/
diff --git a/thirdparty/winpthreads/src/wpth_ver.h b/thirdparty/winpthreads/src/wpth_ver.h
new file mode 100644
index 00000000..1089a612
--- /dev/null
+++ b/thirdparty/winpthreads/src/wpth_ver.h
@@ -0,0 +1,29 @@
+/*
+   Copyright (c) 2011-2016  mingw-w64 project
+
+   Permission is hereby granted, free of charge, to any person obtaining a
+   copy of this software and associated documentation files (the "Software"),
+   to deal in the Software without restriction, including without limitation
+   the rights to use, copy, modify, merge, publish, distribute, sublicense,
+   and/or sell copies of the Software, and to permit persons to whom the
+   Software is furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+   DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef __WPTHREADS_VERSION__
+#define __WPTHREADS_VERSION__
+
+#define WPTH_VERSION 1,0,0,0
+#define WPTH_VERSION_STRING "1, 0, 0, 0\0"
+
+#endif

From 3f6a3b490047498efb2ea78ca655cfe331480b6d Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 15 Jun 2023 14:17:01 -0700
Subject: [PATCH 20/71] Remove pthread library and run format.

---
 SCsub                                         |   37 +-
 config.py                                     |    1 -
 generate_builtin_api.py                       |   79 +-
 thirdparty/winpthreads/COPYING                |   57 -
 thirdparty/winpthreads/README                 |   10 -
 thirdparty/winpthreads/include/pthread.h      |  685 ------
 .../winpthreads/include/pthread_compat.h      |   86 -
 .../winpthreads/include/pthread_signal.h      |   29 -
 thirdparty/winpthreads/include/pthread_time.h |  102 -
 .../winpthreads/include/pthread_unistd.h      |  192 --
 thirdparty/winpthreads/include/sched.h        |   83 -
 thirdparty/winpthreads/include/semaphore.h    |   85 -
 thirdparty/winpthreads/src/barrier.c          |  246 ---
 thirdparty/winpthreads/src/barrier.h          |   49 -
 thirdparty/winpthreads/src/clock.c            |  286 ---
 thirdparty/winpthreads/src/cond.c             |  755 -------
 thirdparty/winpthreads/src/cond.h             |   61 -
 .../winpthreads/src/libgcc/dll_dependency.S   |   90 -
 thirdparty/winpthreads/src/libgcc/dll_math.c  |  586 -----
 thirdparty/winpthreads/src/misc.c             |  158 --
 thirdparty/winpthreads/src/misc.h             |  114 -
 thirdparty/winpthreads/src/mutex.c            |  385 ----
 thirdparty/winpthreads/src/nanosleep.c        |   71 -
 thirdparty/winpthreads/src/ref.c              |   34 -
 thirdparty/winpthreads/src/ref.h              |   29 -
 thirdparty/winpthreads/src/rwlock.c           |  533 -----
 thirdparty/winpthreads/src/rwlock.h           |   52 -
 thirdparty/winpthreads/src/sched.c            |  218 --
 thirdparty/winpthreads/src/sem.c              |  354 ----
 thirdparty/winpthreads/src/sem.h              |   40 -
 thirdparty/winpthreads/src/spinlock.c         |   86 -
 thirdparty/winpthreads/src/thread.c           | 1885 -----------------
 thirdparty/winpthreads/src/thread.h           |   79 -
 thirdparty/winpthreads/src/version.rc         |   62 -
 .../winpthreads/src/winpthread_internal.h     |   27 -
 thirdparty/winpthreads/src/wpth_ver.h         |   29 -
 36 files changed, 87 insertions(+), 7588 deletions(-)
 delete mode 100644 thirdparty/winpthreads/COPYING
 delete mode 100644 thirdparty/winpthreads/README
 delete mode 100644 thirdparty/winpthreads/include/pthread.h
 delete mode 100644 thirdparty/winpthreads/include/pthread_compat.h
 delete mode 100644 thirdparty/winpthreads/include/pthread_signal.h
 delete mode 100644 thirdparty/winpthreads/include/pthread_time.h
 delete mode 100644 thirdparty/winpthreads/include/pthread_unistd.h
 delete mode 100644 thirdparty/winpthreads/include/sched.h
 delete mode 100644 thirdparty/winpthreads/include/semaphore.h
 delete mode 100644 thirdparty/winpthreads/src/barrier.c
 delete mode 100644 thirdparty/winpthreads/src/barrier.h
 delete mode 100644 thirdparty/winpthreads/src/clock.c
 delete mode 100644 thirdparty/winpthreads/src/cond.c
 delete mode 100644 thirdparty/winpthreads/src/cond.h
 delete mode 100644 thirdparty/winpthreads/src/libgcc/dll_dependency.S
 delete mode 100644 thirdparty/winpthreads/src/libgcc/dll_math.c
 delete mode 100644 thirdparty/winpthreads/src/misc.c
 delete mode 100644 thirdparty/winpthreads/src/misc.h
 delete mode 100644 thirdparty/winpthreads/src/mutex.c
 delete mode 100644 thirdparty/winpthreads/src/nanosleep.c
 delete mode 100644 thirdparty/winpthreads/src/ref.c
 delete mode 100644 thirdparty/winpthreads/src/ref.h
 delete mode 100644 thirdparty/winpthreads/src/rwlock.c
 delete mode 100644 thirdparty/winpthreads/src/rwlock.h
 delete mode 100644 thirdparty/winpthreads/src/sched.c
 delete mode 100644 thirdparty/winpthreads/src/sem.c
 delete mode 100644 thirdparty/winpthreads/src/sem.h
 delete mode 100644 thirdparty/winpthreads/src/spinlock.c
 delete mode 100644 thirdparty/winpthreads/src/thread.c
 delete mode 100644 thirdparty/winpthreads/src/thread.h
 delete mode 100644 thirdparty/winpthreads/src/version.rc
 delete mode 100644 thirdparty/winpthreads/src/winpthread_internal.h
 delete mode 100644 thirdparty/winpthreads/src/wpth_ver.h

diff --git a/SCsub b/SCsub
index 9f9c7826..8cfb5b11 100644
--- a/SCsub
+++ b/SCsub
@@ -7,6 +7,7 @@ env_module = env_modules.Clone()
 JS_ENGINE = "quickjs"
 TOOLS = "editor" == env_module["target"]
 
+
 def open_file(path, mode):
     if platform.python_version() > "3":
         return open(path, mode, encoding="utf8")
@@ -31,7 +32,9 @@ def dump_text_file_to_cpp(file):
 if JS_ENGINE == "quickjs":
     import generate_builtin_api
 
-    generate_builtin_api.generate_api_json(os.path.join(GetLaunchDir(), "modules", os.path.basename(os.getcwd())))
+    generate_builtin_api.generate_api_json(
+        os.path.join(GetLaunchDir(), "modules", os.path.basename(os.getcwd()))
+    )
     import thirdparty.quickjs.builtin_binding_generator
 
     thirdparty.quickjs.builtin_binding_generator.generate_builtin_bindings()
@@ -43,10 +46,12 @@ if JS_ENGINE == "quickjs":
         env_module.Append(CPPDEFINES={"QUICKJS_WITH_DEBUGGER": 1})
     env_module.Append(CPPPATH=["thirdparty/quickjs/quickjs"])
     env_module.Append(CPPPATH=["thirdparty/quickjs"])
-    
+
     if TOOLS:
         env_module.add_source_files(env.modules_sources, "tools/editor_tools.cpp")
-    env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp")
+    env_module.add_source_files(
+        env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp"
+    )
     env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/*.cpp")
     env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs/*.c")
 
@@ -55,7 +60,7 @@ if JS_ENGINE == "quickjs":
     else:
         env_module.Append(CXXFLAGS=["-std=c++20"])
 
- 
+
 # Binding script to run at engine initializing
 with open("misc/godot.binding_script.gen.cpp", "w") as f:
     text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "../javascript_binder.h"\nString JavaScriptBinder::BINDING_SCRIPT_CONTENT = \n${source};'
@@ -70,14 +75,24 @@ sources = [
 ]
 
 if TOOLS:
-    base_text = (
-        '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
-    )
+    base_text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
     tool_fns = {
-        "tools/godot.d.ts.gen.cpp": ("BUILTIN_DECLARATION_TEXT", dump_text_file_to_cpp("misc/godot.d.ts")),
-        "tools/tsconfig.json.gen.cpp": ("TSCONFIG_CONTENT", dump_text_file_to_cpp("misc/tsconfig.json")),
-        "tools/decorators.ts.gen.cpp": ("TS_DECORATORS_CONTENT", dump_text_file_to_cpp("misc/decorators.ts")),
-        "tools/package.json.gen.cpp": ("PACKAGE_JSON_CONTENT", dump_text_file_to_cpp("misc/package.json")),
+        "tools/godot.d.ts.gen.cpp": (
+            "BUILTIN_DECLARATION_TEXT",
+            dump_text_file_to_cpp("misc/godot.d.ts"),
+        ),
+        "tools/tsconfig.json.gen.cpp": (
+            "TSCONFIG_CONTENT",
+            dump_text_file_to_cpp("misc/tsconfig.json"),
+        ),
+        "tools/decorators.ts.gen.cpp": (
+            "TS_DECORATORS_CONTENT",
+            dump_text_file_to_cpp("misc/decorators.ts"),
+        ),
+        "tools/package.json.gen.cpp": (
+            "PACKAGE_JSON_CONTENT",
+            dump_text_file_to_cpp("misc/package.json"),
+        ),
     }
     for fn, subs in tool_fns.items():
         with open_file(fn, "w") as fh:
diff --git a/config.py b/config.py
index c62e9428..e9f39c99 100644
--- a/config.py
+++ b/config.py
@@ -6,7 +6,6 @@ def configure(env):
     pass
 
 
-
 def get_doc_classes():
     return [
         "JavaScript",
diff --git a/generate_builtin_api.py b/generate_builtin_api.py
index d7da70c2..de9ae130 100755
--- a/generate_builtin_api.py
+++ b/generate_builtin_api.py
@@ -57,72 +57,97 @@
 }
 
 METHOD_OP_EQUALS = {
-    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "arguments": [
+        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
+    ],
     "name": "equals",
     "native_method": "operator==",
     "return": "boolean",
 }
 
 METHOD_OP_ADD = {
-    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "arguments": [
+        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
+    ],
     "name": "add",
     "native_method": "operator+",
     "return": "${class_name}",
 }
 
 METHOD_OP_ADD_ASSIGN = {
-    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "arguments": [
+        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
+    ],
     "name": "add_assign",
     "native_method": "operator+=",
     "return": "this",
 }
 
 METHOD_OP_SUB = {
-    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "arguments": [
+        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
+    ],
     "name": "subtract",
     "native_method": "operator-",
     "return": "${class_name}",
 }
 
 METHOD_OP_SUB_ASSIGN = {
-    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "arguments": [
+        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
+    ],
     "name": "subtract_assign",
     "native_method": "operator-=",
     "return": "this",
 }
 
 METHOD_OP_MUL = {
-    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "arguments": [
+        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
+    ],
     "name": "multiply",
     "native_method": "operator*",
     "return": "${class_name}",
 }
 
 METHOD_OP_MUL_ASSIGN = {
-    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "arguments": [
+        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
+    ],
     "name": "multiply_assign",
     "native_method": "operator*=",
     "return": "this",
 }
 
 METHOD_OP_DIV = {
-    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "arguments": [
+        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
+    ],
     "name": "multiply",
     "native_method": "operator/",
     "return": "${class_name}",
 }
 
 METHOD_OP_DIV_ASSIGN = {
-    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "arguments": [
+        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
+    ],
     "name": "multiply_assign",
     "native_method": "operator/=",
     "return": "this",
 }
 
-METHOD_OP_NEG = {"arguments": [], "name": "negate", "native_method": "operator-", "return": "${class_name}"}
+METHOD_OP_NEG = {
+    "arguments": [],
+    "name": "negate",
+    "native_method": "operator-",
+    "return": "${class_name}",
+}
 
 METHOD_OP_LESS = {
-    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "arguments": [
+        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
+    ],
     "name": "less",
     "native_method": "operator<",
     "return": "boolean",
@@ -130,14 +155,18 @@
 
 
 METHOD_OP_LESS_EQAUL = {
-    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
+    "arguments": [
+        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
+    ],
     "name": "less_equal",
     "native_method": "operator<=",
     "return": "boolean",
 }
 
 METHOD_PACKED_ARRAY_GET = {
-    "arguments": [{"default_value": None, "has_default_value": False, "type": "number"}],
+    "arguments": [
+        {"default_value": None, "has_default_value": False, "type": "number"}
+    ],
     "name": "get",
     "native_method": "operator[]",
     "return": "Variant",
@@ -312,11 +341,17 @@ def parse_class(cls):
             continue  # ignore constructors
         if class_name in IGNORED_PROPS and method_name in IGNORED_PROPS[class_name]:
             continue  # ignored methods
-        if class_name == "PackedByteArray" and method_name.startswith("encode_") or method_name.startswith("decode_"):
+        if (
+            class_name == "PackedByteArray"
+            and method_name.startswith("encode_")
+            or method_name.startswith("decode_")
+        ):
             continue  # ignore decode/encode methods
         if class_name == "PackedByteArray" and method_name == "get_string_from_wchar":
             continue
-        return_type = m.find("return").attrib["type"] if m.find("return") != None else "void"
+        return_type = (
+            m.find("return").attrib["type"] if m.find("return") != None else "void"
+        )
         if return_type in TYPE_MAP:
             return_type = TYPE_MAP[return_type]
         arguments = []
@@ -324,14 +359,20 @@ def parse_class(cls):
             dictArg = dict(arg.attrib)
             if "dictArg" in dictArg:
                 dictArg.pop("index")
-            dictArg["default_value"] = dictArg["default"] if "default" in dictArg else None
+            dictArg["default_value"] = (
+                dictArg["default"] if "default" in dictArg else None
+            )
             if "default" in dictArg:
                 dictArg.pop("default")
             type = dictArg["type"]
             if type in TYPE_MAP:
                 type = TYPE_MAP[type]
             arguments.append(
-                {"type": type, "default_value": dictArg["default_value"], "has_default_value": "default" in dictArg}
+                {
+                    "type": type,
+                    "default_value": dictArg["default_value"],
+                    "has_default_value": "default" in dictArg,
+                }
             )
         methods.append(
             {
@@ -374,7 +415,9 @@ def generate_api_json(MODULE_DIR):
         tree = ET.parse(open(os.path.join(DOCS_DIR, cls + ".xml"), "r"))
         data = tree.getroot()
         classes.append(parse_class(data))
-    json.dump(classes, open(OUTPUT_FILE, "w"), ensure_ascii=False, indent=2, sort_keys=True)
+    json.dump(
+        classes, open(OUTPUT_FILE, "w"), ensure_ascii=False, indent=2, sort_keys=True
+    )
 
 
 if __name__ == "__main__":
diff --git a/thirdparty/winpthreads/COPYING b/thirdparty/winpthreads/COPYING
deleted file mode 100644
index 35077012..00000000
--- a/thirdparty/winpthreads/COPYING
+++ /dev/null
@@ -1,57 +0,0 @@
-Copyright (c) 2011 mingw-w64 project
-
-Permission is hereby granted, free of charge, to any person obtaining a
-copy of this software and associated documentation files (the "Software"),
-to deal in the Software without restriction, including without limitation
-the rights to use, copy, modify, merge, publish, distribute, sublicense,
-and/or sell copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
-
-/*
- * Parts of this library are derived by:
- *
- * Posix Threads library for Microsoft Windows
- *
- * Use at own risk, there is no implied warranty to this code.
- * It uses undocumented features of Microsoft Windows that can change
- * at any time in the future.
- *
- * (C) 2010 Lockless Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- *
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- *  * Neither the name of Lockless Inc. nor the names of its contributors may be
- *    used to endorse or promote products derived from this software without
- *    specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AN
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- */
diff --git a/thirdparty/winpthreads/README b/thirdparty/winpthreads/README
deleted file mode 100644
index 55922f00..00000000
--- a/thirdparty/winpthreads/README
+++ /dev/null
@@ -1,10 +0,0 @@
-The Winpthreads Library
------------------------
-
-This library provides POSIX threading APIs for mingw-w64.
-
-For maximum compatibility, winpthreads headers expose APIs without the
-`dllimport` attribute by default. If your program is linked against the
-DLL, you may define the `WINPTHREADS_USE_DLLIMPORT` macro to add the
-`dllimport` attribute to all APIs, which makes function calls to them a
-bit more efficient.
diff --git a/thirdparty/winpthreads/include/pthread.h b/thirdparty/winpthreads/include/pthread.h
deleted file mode 100644
index 6ea4f018..00000000
--- a/thirdparty/winpthreads/include/pthread.h
+++ /dev/null
@@ -1,685 +0,0 @@
-/*
-   Copyright (c) 2011-2016 mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-/*
- * Parts of this library are derived by:
- *
- * Posix Threads library for Microsoft Windows
- *
- * Use at own risk, there is no implied warranty to this code.
- * It uses undocumented features of Microsoft Windows that can change
- * at any time in the future.
- *
- * (C) 2010 Lockless Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- *
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- *  * Neither the name of Lockless Inc. nor the names of its contributors may be
- *    used to endorse or promote products derived from this software without
- *    specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AN
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef WIN_PTHREADS_H
-#define WIN_PTHREADS_H
-
-#include <stddef.h>
-#include <errno.h>
-#include <sys/types.h>
-
-#include <process.h>
-#include <limits.h>
-#include <signal.h>
-#include <time.h>
-
-#include <sys/timeb.h>
-
-#include "pthread_compat.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define __WINPTHREADS_VERSION_MAJOR 0
-#define __WINPTHREADS_VERSION_MINOR 5
-#define __WINPTHREADS_VERSION_PATCHLEVEL 0
-
-/* MSB 8-bit major version, 8-bit minor version, 16-bit patch level.  */
-#define __WINPTHREADS_VERSION 0x00050000
-
-#if defined(IN_WINPTHREAD)
-#  if defined(DLL_EXPORT)
-#    define WINPTHREAD_API  __declspec(dllexport)  /* building the DLL  */
-#  else
-#    define WINPTHREAD_API  /* building the static library  */
-#  endif
-#else
-#  if defined(WINPTHREADS_USE_DLLIMPORT)
-#    define WINPTHREAD_API  __declspec(dllimport)  /* user wants explicit `dllimport`  */
-#  else
-#    define WINPTHREAD_API  /* the default; auto imported in case of DLL  */
-#  endif
-#endif
-
-/* #define WINPTHREAD_DBG 1 */
-
-/* Compatibility stuff: */
-#define RWLS_PER_THREAD						8
-
-/* Error-codes.  */
-#ifndef ETIMEDOUT
-#define ETIMEDOUT	138
-#endif
-#ifndef ENOTSUP
-#define ENOTSUP		129
-#endif
-#ifndef EWOULDBLOCK
-#define EWOULDBLOCK	140
-#endif
-
-/* pthread specific defines.  */
-
-#define PTHREAD_CANCEL_DISABLE 0
-#define PTHREAD_CANCEL_ENABLE 0x01
-
-#define PTHREAD_CANCEL_DEFERRED 0
-#define PTHREAD_CANCEL_ASYNCHRONOUS 0x02
-
-#define PTHREAD_CREATE_JOINABLE 0
-#define PTHREAD_CREATE_DETACHED 0x04
-
-#define PTHREAD_EXPLICIT_SCHED 0
-#define PTHREAD_INHERIT_SCHED 0x08
-
-#define PTHREAD_SCOPE_PROCESS 0
-#define PTHREAD_SCOPE_SYSTEM 0x10
-
-#define PTHREAD_DEFAULT_ATTR (PTHREAD_CANCEL_ENABLE)
-
-#define PTHREAD_CANCELED ((void *) (intptr_t) 0xDEADBEEF)
-
-#define _PTHREAD_NULL_THREAD ((pthread_t) 0)
-
-#define PTHREAD_ONCE_INIT 0
-
-#define PTHREAD_DESTRUCTOR_ITERATIONS 256
-#define PTHREAD_KEYS_MAX (1<<20)
-
-#define PTHREAD_MUTEX_NORMAL 0
-#define PTHREAD_MUTEX_ERRORCHECK 1
-#define PTHREAD_MUTEX_RECURSIVE 2
-#define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
-
-#define PTHREAD_MUTEX_SHARED 1
-#define PTHREAD_MUTEX_PRIVATE 0
-
-#define PTHREAD_PRIO_NONE 0
-#define PTHREAD_PRIO_INHERIT 8
-#define PTHREAD_PRIO_PROTECT 16
-#define PTHREAD_PRIO_MULT 32
-#define PTHREAD_PROCESS_SHARED 1
-#define PTHREAD_PROCESS_PRIVATE 0
-
-#define PTHREAD_MUTEX_FAST_NP		PTHREAD_MUTEX_NORMAL
-#define PTHREAD_MUTEX_TIMED_NP		PTHREAD_MUTEX_FAST_NP
-#define PTHREAD_MUTEX_ADAPTIVE_NP	PTHREAD_MUTEX_FAST_NP
-#define PTHREAD_MUTEX_ERRORCHECK_NP	PTHREAD_MUTEX_ERRORCHECK
-#define PTHREAD_MUTEX_RECURSIVE_NP	PTHREAD_MUTEX_RECURSIVE
-
-void * WINPTHREAD_API pthread_timechange_handler_np(void * dummy);
-int    WINPTHREAD_API pthread_delay_np (const struct timespec *interval);
-int    WINPTHREAD_API pthread_num_processors_np(void);
-int    WINPTHREAD_API pthread_set_num_processors_np(int n);
-
-#define PTHREAD_BARRIER_SERIAL_THREAD 1
-
-/* maximum number of times a read lock may be obtained */
-#define	MAX_READ_LOCKS		(INT_MAX - 1)
-
-/* No fork() in windows - so ignore this */
-#define pthread_atfork(F1,F2,F3) 0
-
-/* unsupported stuff: */
-#define pthread_mutex_getprioceiling(M, P) ENOTSUP
-#define pthread_mutex_setprioceiling(M, P) ENOTSUP
-#define pthread_getcpuclockid(T, C) ENOTSUP
-#define pthread_attr_getguardsize(A, S) ENOTSUP
-#define pthread_attr_setgaurdsize(A, S) ENOTSUP
-
-typedef long pthread_once_t;
-typedef unsigned pthread_mutexattr_t;
-typedef unsigned pthread_key_t;
-typedef void *pthread_barrierattr_t;
-typedef int pthread_condattr_t;
-typedef int pthread_rwlockattr_t;
-
-/*
-struct _pthread_v;
-
-typedef struct pthread_t {
-  struct _pthread_v *p;
-  int x;
-} pthread_t;
-*/
-
-typedef uintptr_t pthread_t;
-
-typedef struct _pthread_cleanup _pthread_cleanup;
-struct _pthread_cleanup
-{
-    void (*func)(void *);
-    void *arg;
-    _pthread_cleanup *next;
-};
-
-#define pthread_cleanup_push(F, A)\
-{\
-    const _pthread_cleanup _pthread_cup = {(F), (A), *pthread_getclean()};\
-    __sync_synchronize();\
-    *pthread_getclean() = (_pthread_cleanup *) &_pthread_cup;\
-    __sync_synchronize()
-
-/* Note that if async cancelling is used, then there is a race here */
-#define pthread_cleanup_pop(E)\
-    (*pthread_getclean() = _pthread_cup.next, ((E) ? (_pthread_cup.func((pthread_once_t *)_pthread_cup.arg)) : (void)0));}
-
-#ifndef SCHED_OTHER
-/* Some POSIX realtime extensions, mostly stubbed */
-#define SCHED_OTHER     0
-#define SCHED_FIFO      1
-#define SCHED_RR        2
-#define SCHED_MIN       SCHED_OTHER
-#define SCHED_MAX       SCHED_RR
-
-struct sched_param {
-  int sched_priority;
-};
-
-int WINPTHREAD_API sched_yield(void);
-int WINPTHREAD_API sched_get_priority_min(int pol);
-int WINPTHREAD_API sched_get_priority_max(int pol);
-int WINPTHREAD_API sched_getscheduler(pid_t pid);
-int WINPTHREAD_API sched_setscheduler(pid_t pid, int pol, const struct sched_param *param);
-
-#endif
-
-typedef struct pthread_attr_t pthread_attr_t;
-struct pthread_attr_t
-{
-    unsigned p_state;
-    void *stack;
-    size_t s_size;
-    struct sched_param param;
-};
-
-int WINPTHREAD_API pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *param);
-int WINPTHREAD_API pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *param);
-int WINPTHREAD_API pthread_getschedparam(pthread_t thread, int *pol, struct sched_param *param);
-int WINPTHREAD_API pthread_setschedparam(pthread_t thread, int pol, const struct sched_param *param);
-int WINPTHREAD_API pthread_attr_setschedpolicy (pthread_attr_t *attr, int pol);
-int WINPTHREAD_API pthread_attr_getschedpolicy (const pthread_attr_t *attr, int *pol);
-
-/* synchronization objects */
-typedef intptr_t pthread_spinlock_t;
-typedef intptr_t pthread_mutex_t;
-typedef intptr_t pthread_cond_t;
-typedef intptr_t pthread_rwlock_t;
-typedef void	*pthread_barrier_t;
-
-#define PTHREAD_MUTEX_NORMAL 0
-#define PTHREAD_MUTEX_ERRORCHECK 1
-#define PTHREAD_MUTEX_RECURSIVE 2
-
-#define GENERIC_INITIALIZER				-1
-#define GENERIC_ERRORCHECK_INITIALIZER			-2
-#define GENERIC_RECURSIVE_INITIALIZER			-3
-#define GENERIC_NORMAL_INITIALIZER			-1
-#define PTHREAD_MUTEX_INITIALIZER			(pthread_mutex_t)GENERIC_INITIALIZER
-#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER		(pthread_mutex_t)GENERIC_RECURSIVE_INITIALIZER
-#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER		(pthread_mutex_t)GENERIC_ERRORCHECK_INITIALIZER
-#define PTHREAD_NORMAL_MUTEX_INITIALIZER		(pthread_mutex_t)GENERIC_NORMAL_INITIALIZER
-#define PTHREAD_DEFAULT_MUTEX_INITIALIZER		PTHREAD_NORMAL_MUTEX_INITIALIZER
-#define PTHREAD_COND_INITIALIZER			(pthread_cond_t)GENERIC_INITIALIZER
-#define PTHREAD_RWLOCK_INITIALIZER			(pthread_rwlock_t)GENERIC_INITIALIZER
-#define PTHREAD_SPINLOCK_INITIALIZER			(pthread_spinlock_t)GENERIC_INITIALIZER
-
-extern void WINPTHREAD_API (**_pthread_key_dest)(void *);
-int         WINPTHREAD_API pthread_key_create(pthread_key_t *key, void (* dest)(void *));
-int         WINPTHREAD_API pthread_key_delete(pthread_key_t key);
-void *      WINPTHREAD_API pthread_getspecific(pthread_key_t key);
-int         WINPTHREAD_API pthread_setspecific(pthread_key_t key, const void *value);
-
-pthread_t WINPTHREAD_API pthread_self(void);
-int       WINPTHREAD_API pthread_once(pthread_once_t *o, void (*func)(void));
-void      WINPTHREAD_API pthread_testcancel(void);
-int       WINPTHREAD_API pthread_equal(pthread_t t1, pthread_t t2);
-void      WINPTHREAD_API pthread_tls_init(void);
-void      WINPTHREAD_API _pthread_cleanup_dest(pthread_t t);
-int       WINPTHREAD_API pthread_get_concurrency(int *val);
-int       WINPTHREAD_API pthread_set_concurrency(int val);
-void      WINPTHREAD_API pthread_exit(void *res);
-void      WINPTHREAD_API _pthread_invoke_cancel(void);
-int       WINPTHREAD_API pthread_cancel(pthread_t t);
-int       WINPTHREAD_API pthread_kill(pthread_t t, int sig);
-unsigned  WINPTHREAD_API _pthread_get_state(const pthread_attr_t *attr, unsigned flag);
-int       WINPTHREAD_API _pthread_set_state(pthread_attr_t *attr, unsigned flag, unsigned val);
-int       WINPTHREAD_API pthread_setcancelstate(int state, int *oldstate);
-int       WINPTHREAD_API pthread_setcanceltype(int type, int *oldtype);
-int       WINPTHREAD_API pthread_create_wrapper(void *args);
-int       WINPTHREAD_API pthread_create(pthread_t *th, const pthread_attr_t *attr, void *(* func)(void *), void *arg);
-int       WINPTHREAD_API pthread_join(pthread_t t, void **res);
-int       WINPTHREAD_API pthread_detach(pthread_t t);
-int       WINPTHREAD_API pthread_setname_np(pthread_t thread, const char *name);
-int       WINPTHREAD_API pthread_getname_np(pthread_t thread, char *name, size_t len);
-
-
-int WINPTHREAD_API pthread_rwlock_init(pthread_rwlock_t *rwlock_, const pthread_rwlockattr_t *attr);
-int WINPTHREAD_API pthread_rwlock_wrlock(pthread_rwlock_t *l);
-int WINPTHREAD_API pthread_rwlock_timedwrlock(pthread_rwlock_t *rwlock, const struct timespec *ts);
-int WINPTHREAD_API pthread_rwlock_rdlock(pthread_rwlock_t *l);
-int WINPTHREAD_API pthread_rwlock_timedrdlock(pthread_rwlock_t *l, const struct timespec *ts);
-int WINPTHREAD_API pthread_rwlock_unlock(pthread_rwlock_t *l);
-int WINPTHREAD_API pthread_rwlock_tryrdlock(pthread_rwlock_t *l);
-int WINPTHREAD_API pthread_rwlock_trywrlock(pthread_rwlock_t *l);
-int WINPTHREAD_API pthread_rwlock_destroy (pthread_rwlock_t *l);
-
-int WINPTHREAD_API pthread_cond_init(pthread_cond_t *cv, const pthread_condattr_t *a);
-int WINPTHREAD_API pthread_cond_destroy(pthread_cond_t *cv);
-int WINPTHREAD_API pthread_cond_signal (pthread_cond_t *cv);
-int WINPTHREAD_API pthread_cond_broadcast (pthread_cond_t *cv);
-int WINPTHREAD_API pthread_cond_wait (pthread_cond_t *cv, pthread_mutex_t *external_mutex);
-int WINPTHREAD_API pthread_cond_timedwait(pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct timespec *t);
-int WINPTHREAD_API pthread_cond_timedwait_relative_np(pthread_cond_t *cv, pthread_mutex_t *external_mutex, const struct timespec *t);
-
-int WINPTHREAD_API pthread_mutex_lock(pthread_mutex_t *m);
-int WINPTHREAD_API pthread_mutex_timedlock(pthread_mutex_t *m, const struct timespec *ts);
-int WINPTHREAD_API pthread_mutex_unlock(pthread_mutex_t *m);
-int WINPTHREAD_API pthread_mutex_trylock(pthread_mutex_t *m);
-int WINPTHREAD_API pthread_mutex_init(pthread_mutex_t *m, const pthread_mutexattr_t *a);
-int WINPTHREAD_API pthread_mutex_destroy(pthread_mutex_t *m);
-
-int WINPTHREAD_API pthread_barrier_destroy(pthread_barrier_t *b);
-int WINPTHREAD_API pthread_barrier_init(pthread_barrier_t *b, const void *attr, unsigned int count);
-int WINPTHREAD_API pthread_barrier_wait(pthread_barrier_t *b);
-
-int WINPTHREAD_API pthread_spin_init(pthread_spinlock_t *l, int pshared);
-int WINPTHREAD_API pthread_spin_destroy(pthread_spinlock_t *l);
-/* No-fair spinlock due to lack of knowledge of thread number.  */
-int WINPTHREAD_API pthread_spin_lock(pthread_spinlock_t *l);
-int WINPTHREAD_API pthread_spin_trylock(pthread_spinlock_t *l);
-int WINPTHREAD_API pthread_spin_unlock(pthread_spinlock_t *l);
-
-int WINPTHREAD_API pthread_attr_init(pthread_attr_t *attr);
-int WINPTHREAD_API pthread_attr_destroy(pthread_attr_t *attr);
-int WINPTHREAD_API pthread_attr_setdetachstate(pthread_attr_t *a, int flag);
-int WINPTHREAD_API pthread_attr_getdetachstate(const pthread_attr_t *a, int *flag);
-int WINPTHREAD_API pthread_attr_setinheritsched(pthread_attr_t *a, int flag);
-int WINPTHREAD_API pthread_attr_getinheritsched(const pthread_attr_t *a, int *flag);
-int WINPTHREAD_API pthread_attr_setscope(pthread_attr_t *a, int flag);
-int WINPTHREAD_API pthread_attr_getscope(const pthread_attr_t *a, int *flag);
-int WINPTHREAD_API pthread_attr_getstack(const pthread_attr_t *attr, void **stack, size_t *size);
-int WINPTHREAD_API pthread_attr_setstack(pthread_attr_t *attr, void *stack, size_t size);
-int WINPTHREAD_API pthread_attr_getstackaddr(const pthread_attr_t *attr, void **stack);
-int WINPTHREAD_API pthread_attr_setstackaddr(pthread_attr_t *attr, void *stack);
-int WINPTHREAD_API pthread_attr_getstacksize(const pthread_attr_t *attr, size_t *size);
-int WINPTHREAD_API pthread_attr_setstacksize(pthread_attr_t *attr, size_t size);
-
-int WINPTHREAD_API pthread_mutexattr_init(pthread_mutexattr_t *a);
-int WINPTHREAD_API pthread_mutexattr_destroy(pthread_mutexattr_t *a);
-int WINPTHREAD_API pthread_mutexattr_gettype(const pthread_mutexattr_t *a, int *type);
-int WINPTHREAD_API pthread_mutexattr_settype(pthread_mutexattr_t *a, int type);
-int WINPTHREAD_API pthread_mutexattr_getpshared(const pthread_mutexattr_t *a, int *type);
-int WINPTHREAD_API pthread_mutexattr_setpshared(pthread_mutexattr_t * a, int type);
-int WINPTHREAD_API pthread_mutexattr_getprotocol(const pthread_mutexattr_t *a, int *type);
-int WINPTHREAD_API pthread_mutexattr_setprotocol(pthread_mutexattr_t *a, int type);
-int WINPTHREAD_API pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *a, int * prio);
-int WINPTHREAD_API pthread_mutexattr_setprioceiling(pthread_mutexattr_t *a, int prio);
-int WINPTHREAD_API pthread_getconcurrency(void);
-int WINPTHREAD_API pthread_setconcurrency(int new_level);
-
-int WINPTHREAD_API pthread_condattr_destroy(pthread_condattr_t *a);
-int WINPTHREAD_API pthread_condattr_init(pthread_condattr_t *a);
-int WINPTHREAD_API pthread_condattr_getpshared(const pthread_condattr_t *a, int *s);
-int WINPTHREAD_API pthread_condattr_setpshared(pthread_condattr_t *a, int s);
-
-#ifndef __clockid_t_defined
-typedef int clockid_t;
-#define __clockid_t_defined 1
-#endif  /* __clockid_t_defined */
-
-int WINPTHREAD_API pthread_condattr_getclock (const pthread_condattr_t *attr,
-       clockid_t *clock_id);
-int WINPTHREAD_API pthread_condattr_setclock(pthread_condattr_t *attr,
-       clockid_t clock_id);
-int WINPTHREAD_API __pthread_clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *rqtp, struct timespec *rmtp);
-
-int WINPTHREAD_API pthread_barrierattr_init(void **attr);
-int WINPTHREAD_API pthread_barrierattr_destroy(void **attr);
-int WINPTHREAD_API pthread_barrierattr_setpshared(void **attr, int s);
-int WINPTHREAD_API pthread_barrierattr_getpshared(void **attr, int *s);
-
-/* Private extensions for analysis and internal use.  */
-struct _pthread_cleanup ** WINPTHREAD_API pthread_getclean (void);
-void *                     WINPTHREAD_API pthread_gethandle (pthread_t t);
-void *                     WINPTHREAD_API pthread_getevent (void);
-
-unsigned long long         WINPTHREAD_API _pthread_rel_time_in_ms(const struct timespec *ts);
-unsigned long long         WINPTHREAD_API _pthread_time_in_ms(void);
-unsigned long long         WINPTHREAD_API _pthread_time_in_ms_from_timespec(const struct timespec *ts);
-int                        WINPTHREAD_API _pthread_tryjoin (pthread_t t, void **res);
-int                        WINPTHREAD_API pthread_rwlockattr_destroy(pthread_rwlockattr_t *a);
-int                        WINPTHREAD_API pthread_rwlockattr_getpshared(pthread_rwlockattr_t *a, int *s);
-int                        WINPTHREAD_API pthread_rwlockattr_init(pthread_rwlockattr_t *a);
-int                        WINPTHREAD_API pthread_rwlockattr_setpshared(pthread_rwlockattr_t *a, int s);
-
-#ifndef SIG_BLOCK
-#define SIG_BLOCK 0
-#endif
-#ifndef SIG_UNBLOCK
-#define SIG_UNBLOCK 1
-#endif
-#ifndef SIG_SETMASK
-#define SIG_SETMASK 2
-#endif
-
-#include <pthread_unistd.h>
-
-#undef _POSIX_THREAD_DESTRUCTOR_ITERATIONS
-#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS     PTHREAD_DESTRUCTOR_ITERATIONS
-
-#undef _POSIX_THREAD_KEYS_MAX
-#define _POSIX_THREAD_KEYS_MAX                  PTHREAD_KEYS_MAX
-
-#undef PTHREAD_THREADS_MAX
-#define PTHREAD_THREADS_MAX                     2019
-
-#undef _POSIX_SEM_NSEMS_MAX
-#define _POSIX_SEM_NSEMS_MAX                    256
-
-#undef SEM_NSEMS_MAX
-#define SEM_NSEMS_MAX                           1024
-
-/* Wrap cancellation points.  */
-#ifdef __WINPTRHEAD_ENABLE_WRAP_API
-#define accept(...) (pthread_testcancel(), accept(__VA_ARGS__))
-#define aio_suspend(...) (pthread_testcancel(), aio_suspend(__VA_ARGS__))
-#define clock_nanosleep(...) (pthread_testcancel(), clock_nanosleep(__VA_ARGS__))
-#define close(...) (pthread_testcancel(), close(__VA_ARGS__))
-#define connect(...) (pthread_testcancel(), connect(__VA_ARGS__))
-#define creat(...) (pthread_testcancel(), creat(__VA_ARGS__))
-#define fcntl(...) (pthread_testcancel(), fcntl(__VA_ARGS__))
-#define fdatasync(...) (pthread_testcancel(), fdatasync(__VA_ARGS__))
-#define fsync(...) (pthread_testcancel(), fsync(__VA_ARGS__))
-#define getmsg(...) (pthread_testcancel(), getmsg(__VA_ARGS__))
-#define getpmsg(...) (pthread_testcancel(), getpmsg(__VA_ARGS__))
-#define lockf(...) (pthread_testcancel(), lockf(__VA_ARGS__))
-#define mg_receive(...) (pthread_testcancel(), mg_receive(__VA_ARGS__))
-#define mg_send(...) (pthread_testcancel(), mg_send(__VA_ARGS__))
-#define mg_timedreceive(...) (pthread_testcancel(), mg_timedreceive(__VA_ARGS__))
-#define mg_timessend(...) (pthread_testcancel(), mg_timedsend(__VA_ARGS__))
-#define msgrcv(...) (pthread_testcancel(), msgrecv(__VA_ARGS__))
-#define msgsnd(...) (pthread_testcancel(), msgsnd(__VA_ARGS__))
-#define msync(...) (pthread_testcancel(), msync(__VA_ARGS__))
-#define nanosleep(...) (pthread_testcancel(), nanosleep(__VA_ARGS__))
-#define open(...) (pthread_testcancel(), open(__VA_ARGS__))
-#define pause(...) (pthread_testcancel(), pause(__VA_ARGS__))
-#define poll(...) (pthread_testcancel(), poll(__VA_ARGS__))
-#define pread(...) (pthread_testcancel(), pread(__VA_ARGS__))
-#define pselect(...) (pthread_testcancel(), pselect(__VA_ARGS__))
-#define putmsg(...) (pthread_testcancel(), putmsg(__VA_ARGS__))
-#define putpmsg(...) (pthread_testcancel(), putpmsg(__VA_ARGS__))
-#define pwrite(...) (pthread_testcancel(), pwrite(__VA_ARGS__))
-#define read(...) (pthread_testcancel(), read(__VA_ARGS__))
-#define readv(...) (pthread_testcancel(), readv(__VA_ARGS__))
-#define recv(...) (pthread_testcancel(), recv(__VA_ARGS__))
-#define recvfrom(...) (pthread_testcancel(), recvfrom(__VA_ARGS__))
-#define recvmsg(...) (pthread_testcancel(), recvmsg(__VA_ARGS__))
-#define select(...) (pthread_testcancel(), select(__VA_ARGS__))
-#define sem_timedwait(...) (pthread_testcancel(), sem_timedwait(__VA_ARGS__))
-#define sem_wait(...) (pthread_testcancel(), sem_wait(__VA_ARGS__))
-#define send(...) (pthread_testcancel(), send(__VA_ARGS__))
-#define sendmsg(...) (pthread_testcancel(), sendmsg(__VA_ARGS__))
-#define sendto(...) (pthread_testcancel(), sendto(__VA_ARGS__))
-#define sigpause(...) (pthread_testcancel(), sigpause(__VA_ARGS__))
-#define sigsuspend(...) (pthread_testcancel(), sigsuspend(__VA_ARGS__))
-#define sigwait(...) (pthread_testcancel(), sigwait(__VA_ARGS__))
-#define sigwaitinfo(...) (pthread_testcancel(), sigwaitinfo(__VA_ARGS__))
-#define sleep(...) (pthread_testcancel(), sleep(__VA_ARGS__))
-//#define Sleep(...) (pthread_testcancel(), Sleep(__VA_ARGS__))
-#define system(...) (pthread_testcancel(), system(__VA_ARGS__))
-#define access(...) (pthread_testcancel(), access(__VA_ARGS__))
-#define asctime(...) (pthread_testcancel(), asctime(__VA_ARGS__))
-#define catclose(...) (pthread_testcancel(), catclose(__VA_ARGS__))
-#define catgets(...) (pthread_testcancel(), catgets(__VA_ARGS__))
-#define catopen(...) (pthread_testcancel(), catopen(__VA_ARGS__))
-#define closedir(...) (pthread_testcancel(), closedir(__VA_ARGS__))
-#define closelog(...) (pthread_testcancel(), closelog(__VA_ARGS__))
-#define ctermid(...) (pthread_testcancel(), ctermid(__VA_ARGS__))
-#define ctime(...) (pthread_testcancel(), ctime(__VA_ARGS__))
-#define dbm_close(...) (pthread_testcancel(), dbm_close(__VA_ARGS__))
-#define dbm_delete(...) (pthread_testcancel(), dbm_delete(__VA_ARGS__))
-#define dbm_fetch(...) (pthread_testcancel(), dbm_fetch(__VA_ARGS__))
-#define dbm_nextkey(...) (pthread_testcancel(), dbm_nextkey(__VA_ARGS__))
-#define dbm_open(...) (pthread_testcancel(), dbm_open(__VA_ARGS__))
-#define dbm_store(...) (pthread_testcancel(), dbm_store(__VA_ARGS__))
-#define dlclose(...) (pthread_testcancel(), dlclose(__VA_ARGS__))
-#define dlopen(...) (pthread_testcancel(), dlopen(__VA_ARGS__))
-#define endgrent(...) (pthread_testcancel(), endgrent(__VA_ARGS__))
-#define endhostent(...) (pthread_testcancel(), endhostent(__VA_ARGS__))
-#define endnetent(...) (pthread_testcancel(), endnetent(__VA_ARGS__))
-#define endprotoent(...) (pthread_testcancel(), endprotoend(__VA_ARGS__))
-#define endpwent(...) (pthread_testcancel(), endpwent(__VA_ARGS__))
-#define endservent(...) (pthread_testcancel(), endservent(__VA_ARGS__))
-#define endutxent(...) (pthread_testcancel(), endutxent(__VA_ARGS__))
-#define fclose(...) (pthread_testcancel(), fclose(__VA_ARGS__))
-#define fflush(...) (pthread_testcancel(), fflush(__VA_ARGS__))
-#define fgetc(...) (pthread_testcancel(), fgetc(__VA_ARGS__))
-#define fgetpos(...) (pthread_testcancel(), fgetpos(__VA_ARGS__))
-#define fgets(...) (pthread_testcancel(), fgets(__VA_ARGS__))
-#define fgetwc(...) (pthread_testcancel(), fgetwc(__VA_ARGS__))
-#define fgetws(...) (pthread_testcancel(), fgetws(__VA_ARGS__))
-#define fmtmsg(...) (pthread_testcancel(), fmtmsg(__VA_ARGS__))
-#define fopen(...) (pthread_testcancel(), fopen(__VA_ARGS__))
-#define fpathconf(...) (pthread_testcancel(), fpathconf(__VA_ARGS__))
-#define fprintf(...) (pthread_testcancel(), fprintf(__VA_ARGS__))
-#define fputc(...) (pthread_testcancel(), fputc(__VA_ARGS__))
-#define fputs(...) (pthread_testcancel(), fputs(__VA_ARGS__))
-#define fputwc(...) (pthread_testcancel(), fputwc(__VA_ARGS__))
-#define fputws(...) (pthread_testcancel(), fputws(__VA_ARGS__))
-#define fread(...) (pthread_testcancel(), fread(__VA_ARGS__))
-#define freopen(...) (pthread_testcancel(), freopen(__VA_ARGS__))
-#define fscanf(...) (pthread_testcancel(), fscanf(__VA_ARGS__))
-#define fseek(...) (pthread_testcancel(), fseek(__VA_ARGS__))
-#define fseeko(...) (pthread_testcancel(), fseeko(__VA_ARGS__))
-#define fsetpos(...) (pthread_testcancel(), fsetpos(__VA_ARGS__))
-#define fstat(...) (pthread_testcancel(), fstat(__VA_ARGS__))
-#define ftell(...) (pthread_testcancel(), ftell(__VA_ARGS__))
-#define ftello(...) (pthread_testcancel(), ftello(__VA_ARGS__))
-#define ftw(...) (pthread_testcancel(), ftw(__VA_ARGS__))
-#define fwprintf(...) (pthread_testcancel(), fwprintf(__VA_ARGS__))
-#define fwrite(...) (pthread_testcancel(), fwrite(__VA_ARGS__))
-#define fwscanf(...) (pthread_testcancel(), fwscanf(__VA_ARGS__))
-#define getaddrinfo(...) (pthread_testcancel(), getaddrinfo(__VA_ARGS__))
-#define getc(...) (pthread_testcancel(), getc(__VA_ARGS__))
-#define getc_unlocked(...) (pthread_testcancel(), getc_unlocked(__VA_ARGS__))
-#define getchar(...) (pthread_testcancel(), getchar(__VA_ARGS__))
-#define getchar_unlocked(...) (pthread_testcancel(), getchar_unlocked(__VA_ARGS__))
-#define getcwd(...) (pthread_testcancel(), getcwd(__VA_ARGS__))
-#define getdate(...) (pthread_testcancel(), getdate(__VA_ARGS__))
-#define getgrent(...) (pthread_testcancel(), getgrent(__VA_ARGS__))
-#define getgrgid(...) (pthread_testcancel(), getgrgid(__VA_ARGS__))
-#define getgrgid_r(...) (pthread_testcancel(), getgrgid_r(__VA_ARGS__))
-#define gergrnam(...) (pthread_testcancel(), getgrnam(__VA_ARGS__))
-#define getgrnam_r(...) (pthread_testcancel(), getgrnam_r(__VA_ARGS__))
-#define gethostbyaddr(...) (pthread_testcancel(), gethostbyaddr(__VA_ARGS__))
-#define gethostbyname(...) (pthread_testcancel(), gethostbyname(__VA_ARGS__))
-#define gethostent(...) (pthread_testcancel(), gethostent(__VA_ARGS__))
-#define gethostid(...) (pthread_testcancel(), gethostid(__VA_ARGS__))
-#define gethostname(...) (pthread_testcancel(), gethostname(__VA_ARGS__))
-#define getlogin(...) (pthread_testcancel(), getlogin(__VA_ARGS__))
-#define getlogin_r(...) (pthread_testcancel(), getlogin_r(__VA_ARGS__))
-#define getnameinfo(...) (pthread_testcancel(), getnameinfo(__VA_ARGS__))
-#define getnetbyaddr(...) (pthread_testcancel(), getnetbyaddr(__VA_ARGS__))
-#define getnetbyname(...) (pthread_testcancel(), getnetbyname(__VA_ARGS__))
-#define getnetent(...) (pthread_testcancel(), getnetent(__VA_ARGS__))
-#define getopt(...) (pthread_testcancel(), getopt(__VA_ARGS__))
-#define getprotobyname(...) (pthread_testcancel(), getprotobyname(__VA_ARGS__))
-#define getprotobynumber(...) (pthread_testcancel(), getprotobynumber(__VA_ARGS__))
-#define getprotoent(...) (pthread_testcancel(), getprotoent(__VA_ARGS__))
-#define getpwent(...) (pthread_testcancel(), getpwent(__VA_ARGS__))
-#define getpwnam(...) (pthread_testcancel(), getpwnam(__VA_ARGS__))
-#define getpwnam_r(...) (pthread_testcancel(), getpwnam_r(__VA_ARGS__))
-#define getpwuid(...) (pthread_testcancel(), getpwuid(__VA_ARGS__))
-#define getpwuid_r(...) (pthread_testcancel(), getpwuid_r(__VA_ARGS__))
-#define gets(...) (pthread_testcancel(), gets(__VA_ARGS__))
-#define getservbyname(...) (pthread_testcancel(), getservbyname(__VA_ARGS__))
-#define getservbyport(...) (pthread_testcancel(), getservbyport(__VA_ARGS__))
-#define getservent(...) (pthread_testcancel(), getservent(__VA_ARGS__))
-#define getutxent(...) (pthread_testcancel(), getutxent(__VA_ARGS__))
-#define getutxid(...) (pthread_testcancel(), getutxid(__VA_ARGS__))
-#define getutxline(...) (pthread_testcancel(), getutxline(__VA_ARGS__))
-#undef getwc
-#define getwc(...) (pthread_testcancel(), getwc(__VA_ARGS__))
-#undef getwchar
-#define getwchar(...) (pthread_testcancel(), getwchar(__VA_ARGS__))
-#define getwd(...) (pthread_testcancel(), getwd(__VA_ARGS__))
-#define glob(...) (pthread_testcancel(), glob(__VA_ARGS__))
-#define iconv_close(...) (pthread_testcancel(), iconv_close(__VA_ARGS__))
-#define iconv_open(...) (pthread_testcancel(), iconv_open(__VA_ARGS__))
-#define ioctl(...) (pthread_testcancel(), ioctl(__VA_ARGS__))
-#define link(...) (pthread_testcancel(), link(__VA_ARGS__))
-#define localtime(...) (pthread_testcancel(), localtime(__VA_ARGS__))
-#define lseek(...) (pthread_testcancel(), lseek(__VA_ARGS__))
-#define lstat(...) (pthread_testcancel(), lstat(__VA_ARGS__))
-#define mkstemp(...) (pthread_testcancel(), mkstemp(__VA_ARGS__))
-#define nftw(...) (pthread_testcancel(), nftw(__VA_ARGS__))
-#define opendir(...) (pthread_testcancel(), opendir(__VA_ARGS__))
-#define openlog(...) (pthread_testcancel(), openlog(__VA_ARGS__))
-#define pathconf(...) (pthread_testcancel(), pathconf(__VA_ARGS__))
-#define pclose(...) (pthread_testcancel(), pclose(__VA_ARGS__))
-#define perror(...) (pthread_testcancel(), perror(__VA_ARGS__))
-#define popen(...) (pthread_testcancel(), popen(__VA_ARGS__))
-#define posix_fadvise(...) (pthread_testcancel(), posix_fadvise(__VA_ARGS__))
-#define posix_fallocate(...) (pthread_testcancel(), posix_fallocate(__VA_ARGS__))
-#define posix_madvise(...) (pthread_testcancel(), posix_madvise(__VA_ARGS__))
-#define posix_openpt(...) (pthread_testcancel(), posix_openpt(__VA_ARGS__))
-#define posix_spawn(...) (pthread_testcancel(), posix_spawn(__VA_ARGS__))
-#define posix_spawnp(...) (pthread_testcancel(), posix_spawnp(__VA_ARGS__))
-#define posix_trace_clear(...) (pthread_testcancel(), posix_trace_clear(__VA_ARGS__))
-#define posix_trace_close(...) (pthread_testcancel(), posix_trace_close(__VA_ARGS__))
-#define posix_trace_create(...) (pthread_testcancel(), posix_trace_create(__VA_ARGS__))
-#define posix_trace_create_withlog(...) (pthread_testcancel(), posix_trace_create_withlog(__VA_ARGS__))
-#define posix_trace_eventtypelist_getne(...) (pthread_testcancel(), posix_trace_eventtypelist_getne(__VA_ARGS__))
-#define posix_trace_eventtypelist_rewin(...) (pthread_testcancel(), posix_trace_eventtypelist_rewin(__VA_ARGS__))
-#define posix_trace_flush(...) (pthread_testcancel(), posix_trace_flush(__VA_ARGS__))
-#define posix_trace_get_attr(...) (pthread_testcancel(), posix_trace_get_attr(__VA_ARGS__))
-#define posix_trace_get_filter(...) (pthread_testcancel(), posix_trace_get_filter(__VA_ARGS__))
-#define posix_trace_get_status(...) (pthread_testcancel(), posix_trace_get_status(__VA_ARGS__))
-#define posix_trace_getnext_event(...) (pthread_testcancel(), posix_trace_getnext_event(__VA_ARGS__))
-#define posix_trace_open(...) (pthread_testcancel(), posix_trace_open(__VA_ARGS__))
-#define posix_trace_rewind(...) (pthread_testcancel(), posix_trace_rewind(__VA_ARGS__))
-#define posix_trace_setfilter(...) (pthread_testcancel(), posix_trace_setfilter(__VA_ARGS__))
-#define posix_trace_shutdown(...) (pthread_testcancel(), posix_trace_shutdown(__VA_ARGS__))
-#define posix_trace_timedgetnext_event(...) (pthread_testcancel(), posix_trace_timedgetnext_event(__VA_ARGS__))
-#define posix_typed_mem_open(...) (pthread_testcancel(), posix_typed_mem_open(__VA_ARGS__))
-#define printf(...) (pthread_testcancel(), printf(__VA_ARGS__))
-#define putc(...) (pthread_testcancel(), putc(__VA_ARGS__))
-#define putc_unlocked(...) (pthread_testcancel(), putc_unlocked(__VA_ARGS__))
-#define putchar(...) (pthread_testcancel(), putchar(__VA_ARGS__))
-#define putchar_unlocked(...) (pthread_testcancel(), putchar_unlocked(__VA_ARGS__))
-#define puts(...) (pthread_testcancel(), puts(__VA_ARGS__))
-#define pututxline(...) (pthread_testcancel(), pututxline(__VA_ARGS__))
-#undef putwc
-#define putwc(...) (pthread_testcancel(), putwc(__VA_ARGS__))
-#undef putwchar
-#define putwchar(...) (pthread_testcancel(), putwchar(__VA_ARGS__))
-#define readdir(...) (pthread_testcancel(), readdir(__VA_ARSG__))
-#define readdir_r(...) (pthread_testcancel(), readdir_r(__VA_ARGS__))
-#define remove(...) (pthread_testcancel(), remove(__VA_ARGS__))
-#define rename(...) (pthread_testcancel(), rename(__VA_ARGS__))
-#define rewind(...) (pthread_testcancel(), rewind(__VA_ARGS__))
-#define rewinddir(...) (pthread_testcancel(), rewinddir(__VA_ARGS__))
-#define scanf(...) (pthread_testcancel(), scanf(__VA_ARGS__))
-#define seekdir(...) (pthread_testcancel(), seekdir(__VA_ARGS__))
-#define semop(...) (pthread_testcancel(), semop(__VA_ARGS__))
-#define setgrent(...) (pthread_testcancel(), setgrent(__VA_ARGS__))
-#define sethostent(...) (pthread_testcancel(), sethostemt(__VA_ARGS__))
-#define setnetent(...) (pthread_testcancel(), setnetent(__VA_ARGS__))
-#define setprotoent(...) (pthread_testcancel(), setprotoent(__VA_ARGS__))
-#define setpwent(...) (pthread_testcancel(), setpwent(__VA_ARGS__))
-#define setservent(...) (pthread_testcancel(), setservent(__VA_ARGS__))
-#define setutxent(...) (pthread_testcancel(), setutxent(__VA_ARGS__))
-#define stat(...) (pthread_testcancel(), stat(__VA_ARGS__))
-#define strerror(...) (pthread_testcancel(), strerror(__VA_ARGS__))
-#define strerror_r(...) (pthread_testcancel(), strerror_r(__VA_ARGS__))
-#define strftime(...) (pthread_testcancel(), strftime(__VA_ARGS__))
-#define symlink(...) (pthread_testcancel(), symlink(__VA_ARGS__))
-#define sync(...) (pthread_testcancel(), sync(__VA_ARGS__))
-#define syslog(...) (pthread_testcancel(), syslog(__VA_ARGS__))
-#define tmpfile(...) (pthread_testcancel(), tmpfile(__VA_ARGS__))
-#define tmpnam(...) (pthread_testcancel(), tmpnam(__VA_ARGS__))
-#define ttyname(...) (pthread_testcancel(), ttyname(__VA_ARGS__))
-#define ttyname_r(...) (pthread_testcancel(), ttyname_r(__VA_ARGS__))
-#define tzset(...) (pthread_testcancel(), tzset(__VA_ARGS__))
-#define ungetc(...) (pthread_testcancel(), ungetc(__VA_ARGS__))
-#define ungetwc(...) (pthread_testcancel(), ungetwc(__VA_ARGS__))
-#define unlink(...) (pthread_testcancel(), unlink(__VA_ARGS__))
-#define vfprintf(...) (pthread_testcancel(), vfprintf(__VA_ARGS__))
-#define vfwprintf(...) (pthread_testcancel(), vfwprintf(__VA_ARGS__))
-#define vprintf(...) (pthread_testcancel(), vprintf(__VA_ARGS__))
-#define vwprintf(...) (pthread_testcancel(), vwprintf(__VA_ARGS__))
-#define wcsftime(...) (pthread_testcancel(), wcsftime(__VA_ARGS__))
-#define wordexp(...) (pthread_testcancel(), wordexp(__VA_ARGS__))
-#define wprintf(...) (pthread_testcancel(), wprintf(__VA_ARGS__))
-#define wscanf(...) (pthread_testcancel(), wscanf(__VA_ARGS__))
-#endif
-
-/* We deal here with a gcc issue for posix threading on Windows.
-   We would need to change here gcc's gthr-posix.h header, but this
-   got rejected.  So we deal it within this header.  */
-#ifdef _GTHREAD_USE_MUTEX_INIT_FUNC
-#undef _GTHREAD_USE_MUTEX_INIT_FUNC
-#endif
-#define _GTHREAD_USE_MUTEX_INIT_FUNC 1
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* WIN_PTHREADS_H */
diff --git a/thirdparty/winpthreads/include/pthread_compat.h b/thirdparty/winpthreads/include/pthread_compat.h
deleted file mode 100644
index 63f5f495..00000000
--- a/thirdparty/winpthreads/include/pthread_compat.h
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-/*
- * Parts of this library are derived by:
- *
- * Posix Threads library for Microsoft Windows
- *
- * Use at own risk, there is no implied warranty to this code.
- * It uses undocumented features of Microsoft Windows that can change
- * at any time in the future.
- *
- * (C) 2010 Lockless Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- *
- *
- *  * Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- *  * Neither the name of Lockless Inc. nor the names of its contributors may be
- *    used to endorse or promote products derived from this software without
- *    specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AN
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
- * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef WIN_PTHREADS_PTHREAD_COMPAT_H
-#define WIN_PTHREADS_PTHREAD_COMPAT_H
-
-#ifdef __GNUC__
-
-#define WINPTHREADS_INLINE inline
-#define WINPTHREADS_ATTRIBUTE(X) __attribute__(X)
-#define WINPTHREADS_SECTION(X) __section__(X)
-
-#elif _MSC_VER
-
-#include "pthread_time.h"
-
-#ifdef _WIN64
-typedef __int64 pid_t;
-#else
-typedef int     pid_t;
-#endif
-typedef int clockid_t;
-
-#define WINPTHREADS_INLINE __inline
-#define WINPTHREADS_ATTRIBUTE(X) __declspec X
-#define WINPTHREADS_SECTION(X) allocate(X)
-
-#endif
-
-#endif
diff --git a/thirdparty/winpthreads/include/pthread_signal.h b/thirdparty/winpthreads/include/pthread_signal.h
deleted file mode 100644
index 42a50ae0..00000000
--- a/thirdparty/winpthreads/include/pthread_signal.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-   Copyright (c) 2013-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef WIN_PTHREADS_SIGNAL_H
-#define WIN_PTHREADS_SIGNAL_H
-
-/* Windows has rudimentary signals support.  */
-#define pthread_sigmask(H, S1, S2) 0
-
-#endif /* WIN_PTHREADS_SIGNAL_H */
diff --git a/thirdparty/winpthreads/include/pthread_time.h b/thirdparty/winpthreads/include/pthread_time.h
deleted file mode 100644
index 7818b114..00000000
--- a/thirdparty/winpthreads/include/pthread_time.h
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#include <sys/timeb.h>
-
-#ifndef WIN_PTHREADS_TIME_H
-#define WIN_PTHREADS_TIME_H
-
-/* Posix timers are supported */
-#ifndef _POSIX_TIMERS
-#define _POSIX_TIMERS           200809L
-#endif
-
-/* Monotonic clocks are available.  */
-#ifndef _POSIX_MONOTONIC_CLOCK
-#define _POSIX_MONOTONIC_CLOCK  200809L
-#endif
-
-/* CPU-time clocks are available.  */
-#ifndef _POSIX_CPUTIME
-#define _POSIX_CPUTIME          200809L
-#endif
-
-/* Clock support in threads are available.  */
-#ifndef _POSIX_THREAD_CPUTIME
-#define _POSIX_THREAD_CPUTIME   200809L
-#endif
-
-#ifndef __clockid_t_defined
-typedef int clockid_t;
-#define __clockid_t_defined 1
-#endif  /* __clockid_t_defined */
-
-#ifndef TIMER_ABSTIME
-#define TIMER_ABSTIME   1
-#endif
-
-#ifndef CLOCK_REALTIME
-#define CLOCK_REALTIME              0
-#endif
-
-#ifndef CLOCK_MONOTONIC
-#define CLOCK_MONOTONIC             1
-#endif
-
-#ifndef CLOCK_PROCESS_CPUTIME_ID
-#define CLOCK_PROCESS_CPUTIME_ID    2
-#endif
-
-#ifndef CLOCK_THREAD_CPUTIME_ID
-#define CLOCK_THREAD_CPUTIME_ID     3
-#endif
-
-#ifndef CLOCK_REALTIME_COARSE
-#define CLOCK_REALTIME_COARSE       4
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Make sure we provide default for WINPTHREAD_API, if not defined.  */
-#pragma push_macro("WINPTHREAD_API")
-#ifndef WINPTHREAD_API
-#define WINPTHREAD_API
-#endif
-
-/* These should really be dllimport'ed if using winpthread dll */
-int __cdecl WINPTHREAD_API nanosleep(const struct timespec *request, struct timespec *remain);
-
-int __cdecl WINPTHREAD_API clock_nanosleep(clockid_t clock_id, int flags, const struct timespec *request, struct timespec *remain);
-int __cdecl WINPTHREAD_API clock_getres(clockid_t clock_id, struct timespec *res);
-int __cdecl WINPTHREAD_API clock_gettime(clockid_t clock_id, struct timespec *tp);
-int __cdecl WINPTHREAD_API clock_settime(clockid_t clock_id, const struct timespec *tp);
-
-#pragma pop_macro("WINPTHREAD_API")
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* WIN_PTHREADS_TIME_H */
-
diff --git a/thirdparty/winpthreads/include/pthread_unistd.h b/thirdparty/winpthreads/include/pthread_unistd.h
deleted file mode 100644
index 64693534..00000000
--- a/thirdparty/winpthreads/include/pthread_unistd.h
+++ /dev/null
@@ -1,192 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef WIN_PTHREADS_UNISTD_H
-#define WIN_PTHREADS_UNISTD_H
-
-/* Set defines described by the POSIX Threads Extension (1003.1c-1995) */
-/* _SC_THREADS
-  Basic support for POSIX threads is available. The functions
-
-  pthread_atfork(),
-  pthread_attr_destroy(),
-  pthread_attr_getdetachstate(),
-  pthread_attr_getschedparam(),
-  pthread_attr_init(),
-  pthread_attr_setdetachstate(),
-  pthread_attr_setschedparam(),
-  pthread_cancel(),
-  pthread_cleanup_push(),
-  pthread_cleanup_pop(),
-  pthread_cond_broadcast(),
-  pthread_cond_destroy(),
-  pthread_cond_init(),
-  pthread_cond_signal(),
-  pthread_cond_timedwait(),
-  pthread_cond_wait(),
-  pthread_condattr_destroy(),
-  pthread_condattr_init(),
-  pthread_create(),
-  pthread_detach(),
-  pthread_equal(),
-  pthread_exit(),
-  pthread_getspecific(),
-  pthread_join(,
-  pthread_key_create(),
-  pthread_key_delete(),
-  pthread_mutex_destroy(),
-  pthread_mutex_init(),
-  pthread_mutex_lock(),
-  pthread_mutex_trylock(),
-  pthread_mutex_unlock(),
-  pthread_mutexattr_destroy(),
-  pthread_mutexattr_init(),
-  pthread_once(),
-  pthread_rwlock_destroy(),
-  pthread_rwlock_init(),
-  pthread_rwlock_rdlock(),
-  pthread_rwlock_tryrdlock(),
-  pthread_rwlock_trywrlock(),
-  pthread_rwlock_unlock(),
-  pthread_rwlock_wrlock(),
-  pthread_rwlockattr_destroy(),
-  pthread_rwlockattr_init(),
-  pthread_self(),
-  pthread_setcancelstate(),
-  pthread_setcanceltype(),
-  pthread_setspecific(),
-  pthread_testcancel()
-
-  are present. */
-#undef _POSIX_THREADS
-#define _POSIX_THREADS 200112L
-
-/* _SC_READER_WRITER_LOCKS
-  This option implies the _POSIX_THREADS option. Conversely, under
-  POSIX 1003.1-2001 the _POSIX_THREADS option implies this option.
-
-  The functions
-  pthread_rwlock_destroy(),
-  pthread_rwlock_init(),
-  pthread_rwlock_rdlock(),
-  pthread_rwlock_tryrdlock(),
-  pthread_rwlock_trywrlock(),
-  pthread_rwlock_unlock(),
-  pthread_rwlock_wrlock(),
-  pthread_rwlockattr_destroy(),
-  pthread_rwlockattr_init()
-
-  are present.
-*/
-#undef _POSIX_READER_WRITER_LOCKS
-#define _POSIX_READER_WRITER_LOCKS 200112L
-
-/* _SC_SPIN_LOCKS
-  This option implies the _POSIX_THREADS and _POSIX_THREAD_SAFE_FUNCTIONS
-  options. The functions
-
-  pthread_spin_destroy(),
-  pthread_spin_init(),
-  pthread_spin_lock(),
-  pthread_spin_trylock(),
-  pthread_spin_unlock()
-
-  are present. */
-#undef _POSIX_SPIN_LOCKS
-#define _POSIX_SPIN_LOCKS 200112L
-
-/* _SC_BARRIERS
-  This option implies the _POSIX_THREADS and _POSIX_THREAD_SAFE_FUNCTIONS
-  options. The functions
-
-  pthread_barrier_destroy(),
-  pthread_barrier_init(),
-  pthread_barrier_wait(),
-  pthread_barrierattr_destroy(),
-  pthread_barrierattr_init()
-
-  are present.
-*/
-#undef _POSIX_BARRIERS
-#define _POSIX_BARRIERS 200112L
-
-/* _SC_TIMEOUTS
-  The functions
-
-  mq_timedreceive(), - not supported
-  mq_timedsend(), - not supported
-  posix_trace_timedgetnext_event(), - not supported
-  pthread_mutex_timedlock(),
-  pthread_rwlock_timedrdlock(),
-  pthread_rwlock_timedwrlock(),
-  sem_timedwait(),
-
-  are present. */
-#undef _POSIX_TIMEOUTS
-#define _POSIX_TIMEOUTS 200112L
-
-/* _SC_TIMERS - not supported
-  The functions
-
-  clock_getres(),
-  clock_gettime(),
-  clock_settime(),
-  nanosleep(),
-  timer_create(),
-  timer_delete(),
-  timer_gettime(),
-  timer_getoverrun(),
-  timer_settime()
-
-  are present.  */
-/* #undef _POSIX_TIMERS */
-
-/* _SC_CLOCK_SELECTION
-   This option implies the _POSIX_TIMERS option. The functions
-
-   pthread_condattr_getclock(),
-   pthread_condattr_setclock(),
-   clock_nanosleep()
-
-   are present.
-*/
-#undef _POSIX_CLOCK_SELECTION
-#define _POSIX_CLOCK_SELECTION 200112
-
-/* _SC_SEMAPHORES
-  The include file <semaphore.h> is present. The functions
-
-  sem_close(),
-  sem_destroy(),
-  sem_getvalue(),
-  sem_init(),
-  sem_open(),
-  sem_post(),
-  sem_trywait(),
-  sem_unlink(),
-  sem_wait()
-
-  are present. */
-#undef _POSIX_SEMAPHORES
-#define _POSIX_SEMAPHORES 200112
-
-#endif /* WIN_PTHREADS_UNISTD_H */
diff --git a/thirdparty/winpthreads/include/sched.h b/thirdparty/winpthreads/include/sched.h
deleted file mode 100644
index b5756a95..00000000
--- a/thirdparty/winpthreads/include/sched.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#include <stddef.h>
-#include <errno.h>
-#include <sys/types.h>
-
-#include <process.h>
-#include <limits.h>
-#include <signal.h>
-
-#include <sys/timeb.h>
-
-#ifndef WIN_PTHREADS_SCHED_H
-#define WIN_PTHREADS_SCHED_H
-
-#ifndef SCHED_OTHER
-/* Some POSIX realtime extensions, mostly stubbed */
-#define SCHED_OTHER     0
-#define SCHED_FIFO      1
-#define SCHED_RR        2
-#define SCHED_MIN       SCHED_OTHER
-#define SCHED_MAX       SCHED_RR
-
-struct sched_param {
-  int sched_priority;
-};
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if defined(IN_WINPTHREAD)
-#  if defined(DLL_EXPORT) && !defined(WINPTHREAD_EXPORT_ALL_DEBUG)
-#    define WINPTHREAD_SCHED_API  __declspec(dllexport)  /* building the DLL  */
-#  else
-#    define WINPTHREAD_SCHED_API  /* building the static library  */
-#  endif
-#else
-#  if defined(WINPTHREADS_USE_DLLIMPORT)
-#    define WINPTHREAD_SCHED_API  __declspec(dllimport)  /* user wants explicit `dllimport`  */
-#  else
-#    define WINPTHREAD_SCHED_API  /* the default; auto imported in case of DLL  */
-#  endif
-#endif
-
-int WINPTHREAD_SCHED_API sched_yield(void);
-int WINPTHREAD_SCHED_API sched_get_priority_min(int pol);
-int WINPTHREAD_SCHED_API sched_get_priority_max(int pol);
-int WINPTHREAD_SCHED_API sched_getscheduler(pid_t pid);
-int WINPTHREAD_SCHED_API sched_setscheduler(pid_t pid, int pol, const struct sched_param *param);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-#ifndef sched_rr_get_interval
-#define sched_rr_get_interval(_p, _i) \
-  ( errno = ENOTSUP, (int) -1 )
-#endif
-
-#endif /* WIN_PTHREADS_SCHED_H */
diff --git a/thirdparty/winpthreads/include/semaphore.h b/thirdparty/winpthreads/include/semaphore.h
deleted file mode 100644
index 6fa417f0..00000000
--- a/thirdparty/winpthreads/include/semaphore.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef WIN_PTHREADS_SEMAPHORE_H
-#define WIN_PTHREADS_SEMAPHORE_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#if defined(IN_WINPTHREAD)
-#  if defined(DLL_EXPORT) && !defined(WINPTHREAD_EXPORT_ALL_DEBUG)
-#    define WINPTHREAD_SEMA_API  __declspec(dllexport)  /* building the DLL  */
-#  else
-#    define WINPTHREAD_SEMA_API  /* building the static library  */
-#  endif
-#else
-#  if defined(WINPTHREADS_USE_DLLIMPORT)
-#    define WINPTHREAD_SEMA_API  __declspec(dllimport)  /* user wants explicit `dllimport`  */
-#  else
-#    define WINPTHREAD_SEMA_API  /* the default; auto imported in case of DLL  */
-#  endif
-#endif
-
-/* Set this to 0 to disable it */
-#define USE_SEM_CriticalSection_SpinCount	100
-
-#define SEM_VALUE_MAX   INT_MAX
-
-#ifndef _MODE_T_
-#define	_MODE_T_
-typedef unsigned short mode_t;
-#endif
-
-typedef void		*sem_t;
-
-#define SEM_FAILED 		NULL
-
-int WINPTHREAD_SEMA_API sem_init(sem_t * sem, int pshared, unsigned int value);
-
-int WINPTHREAD_SEMA_API sem_destroy(sem_t *sem);
-
-int WINPTHREAD_SEMA_API sem_trywait(sem_t *sem);
-
-int WINPTHREAD_SEMA_API sem_wait(sem_t *sem);
-
-int WINPTHREAD_SEMA_API sem_timedwait(sem_t * sem, const struct timespec *t);
-
-int WINPTHREAD_SEMA_API sem_post(sem_t *sem);
-
-int WINPTHREAD_SEMA_API sem_post_multiple(sem_t *sem, int count);
-
-/* yes, it returns a semaphore (or SEM_FAILED) */
-sem_t * WINPTHREAD_SEMA_API sem_open(const char * name, int oflag, mode_t mode, unsigned int value);
-
-int WINPTHREAD_SEMA_API sem_close(sem_t * sem);
-
-int WINPTHREAD_SEMA_API sem_unlink(const char * name);
-
-int WINPTHREAD_SEMA_API sem_getvalue(sem_t * sem, int * sval);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* WIN_PTHREADS_SEMAPHORE_H */
diff --git a/thirdparty/winpthreads/src/barrier.c b/thirdparty/winpthreads/src/barrier.c
deleted file mode 100644
index 95b2252a..00000000
--- a/thirdparty/winpthreads/src/barrier.c
+++ /dev/null
@@ -1,246 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#include <windows.h>
-#include <stdio.h>
-#include <malloc.h>
-#include "pthread.h"
-#include "barrier.h"
-#include "ref.h" 
-#include "misc.h"
-
-static pthread_spinlock_t barrier_global = PTHREAD_SPINLOCK_INITIALIZER;
-
-static WINPTHREADS_ATTRIBUTE((noinline)) int
-barrier_unref(volatile pthread_barrier_t *barrier, int res)
-{
-    pthread_spin_lock(&barrier_global);
-#ifdef WINPTHREAD_DBG
-    assert((((barrier_t *)*barrier)->valid == LIFE_BARRIER) && (((barrier_t *)*barrier)->busy > 0));
-#endif
-     ((barrier_t *)*barrier)->busy -= 1;
-    pthread_spin_unlock(&barrier_global);
-    return res;
-}
-
-static WINPTHREADS_ATTRIBUTE((noinline)) int barrier_ref(volatile pthread_barrier_t *barrier)
-{
-    int r = 0;
-    pthread_spin_lock(&barrier_global);
-
-    if (!barrier || !*barrier || ((barrier_t *)*barrier)->valid != LIFE_BARRIER) r = EINVAL;
-    else {
-        ((barrier_t *)*barrier)->busy += 1;
-    }
-
-    pthread_spin_unlock(&barrier_global);
-
-    return r;
-}
-
-static WINPTHREADS_ATTRIBUTE((noinline))  int
-barrier_ref_destroy(volatile pthread_barrier_t *barrier, pthread_barrier_t *bDestroy)
-{
-    int r = 0;
-
-    *bDestroy = NULL;
-    pthread_spin_lock(&barrier_global);
-    
-    if (!barrier || !*barrier || ((barrier_t *)*barrier)->valid != LIFE_BARRIER) r = EINVAL;
-    else {
-        barrier_t *b_ = (barrier_t *)*barrier;
-        if (b_->busy) r = EBUSY;
-        else {
-            *bDestroy = *barrier;
-            *barrier = NULL;
-        }
-    }
-
-    pthread_spin_unlock(&barrier_global);
-    return r;
-}
-
-static WINPTHREADS_ATTRIBUTE((noinline)) void
-barrier_ref_set (volatile pthread_barrier_t *barrier, void *v)
-{
-  pthread_spin_lock(&barrier_global);
-  *barrier = v;
-  pthread_spin_unlock(&barrier_global);
-}
-
-int pthread_barrier_destroy(pthread_barrier_t *b_)
-{
-    pthread_barrier_t bDestroy;
-    barrier_t *b;
-    int r;
-    
-    while ((r = barrier_ref_destroy(b_,&bDestroy)) == EBUSY)
-      Sleep(0);
-    
-    if (r)
-      return r;
-
-    b = (barrier_t *)bDestroy;
-    
-    pthread_mutex_lock(&b->m);
-
-    if (sem_destroy(&b->sems[0]) != 0)
-    {
-        /* Could this happen? */
-        *b_ = bDestroy;
-        pthread_mutex_unlock (&b->m);
-        return EBUSY;
-    }
-    if (sem_destroy(&b->sems[1]) != 0)
-    {
-      sem_init (&b->sems[0], b->share, 0);
-      *b_ = bDestroy;
-      pthread_mutex_unlock (&b->m);
-      return -1;
-    }
-    pthread_mutex_unlock(&b->m);
-    if(pthread_mutex_destroy(&b->m) != 0) {
-     sem_init (&b->sems[0], b->share, 0);
-     sem_init (&b->sems[1], b->share, 0);
-     *b_ = bDestroy;
-     return -1;
-    }
-    b->valid = DEAD_BARRIER;
-    free(bDestroy);
-    return 0;
-
-}
-
-int
-pthread_barrier_init (pthread_barrier_t *b_, const void *attr,
-		      unsigned int count)
-{
-    barrier_t *b;
-
-    if (!count || !b_)
-      return EINVAL;
-
-    if (!(b = (pthread_barrier_t)calloc(1,sizeof(*b))))
-       return ENOMEM;
-    if (!attr || *((int **)attr) == NULL)
-      b->share = PTHREAD_PROCESS_PRIVATE;
-    else
-      memcpy (&b->share, *((void **) attr), sizeof (int));
-    b->total = count;
-    b->count = count;
-    b->valid = LIFE_BARRIER;
-    b->sel = 0;
-
-    if (pthread_mutex_init(&b->m, NULL) != 0)
-    {
-      free (b);
-      return ENOMEM;
-    }
-
-    if (sem_init(&b->sems[0], b->share, 0) != 0)
-    {
-       pthread_mutex_destroy(&b->m);
-       free (b);
-       return ENOMEM;
-    }
-    if (sem_init(&b->sems[1], b->share, 0) != 0)
-    {
-       pthread_mutex_destroy(&b->m);
-       sem_destroy(&b->sems[0]);
-       free (b);
-       return ENOMEM;
-    }
-    barrier_ref_set (b_,b);
-
-    return 0;
-}
-
-int pthread_barrier_wait(pthread_barrier_t *b_)
-{
-  long sel;
-  int r, e, rslt;
-  barrier_t *b;
-
-  r = barrier_ref(b_);
-  if(r) return r;
-
-  b = (barrier_t *)*b_;
-
-  if ((r = pthread_mutex_lock(&b->m))) return  barrier_unref(b_,EINVAL);
-  sel = b->sel;
-  InterlockedDecrement((long*)&b->total);
-  if (b->total == 0)
-  {
-    b->total = b->count;
-    b->sel = (sel != 0 ? 0 : 1);
-    e = 1;
-    rslt = PTHREAD_BARRIER_SERIAL_THREAD;
-    r = (b->count > 1 ? sem_post_multiple (&b->sems[sel], b->count - 1) : 0);
-  }
-  else { e = 0; rslt= 0; }
-  pthread_mutex_unlock(&b->m);
-  if (!e)
-    r = sem_wait(&b->sems[sel]);
-
-  if (!r) r = rslt;
-  return barrier_unref(b_,r);
-}
-
-int pthread_barrierattr_init(void **attr)
-{
-  int *p;
-
-  if (!(p = (int *) calloc (1, sizeof (int))))
-    return ENOMEM;
-
-  *p = PTHREAD_PROCESS_PRIVATE;
-  *attr = p;
-
-  return 0;
-}
-
-int pthread_barrierattr_destroy(void **attr)
-{
-  void *p;
-  if (!attr || (p = *attr) == NULL)
-    return EINVAL;
-  *attr = NULL;
-  free (p);
-  return 0;
-}
-
-int pthread_barrierattr_setpshared(void **attr, int s)
-{
-  if (!attr || *attr == NULL
-      || (s != PTHREAD_PROCESS_SHARED && s != PTHREAD_PROCESS_PRIVATE))
-    return EINVAL;
-  memcpy (*attr, &s, sizeof (int));
-  return 0;
-}
-
-int pthread_barrierattr_getpshared(void **attr, int *s)
-{
-  if (!attr || !s || *attr == NULL)
-    return EINVAL;
-  memcpy (s, *attr, sizeof (int));
-  return 0;
-}
diff --git a/thirdparty/winpthreads/src/barrier.h b/thirdparty/winpthreads/src/barrier.h
deleted file mode 100644
index b3e2146e..00000000
--- a/thirdparty/winpthreads/src/barrier.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef WIN_PTHREADS_BARRIER_H
-#define WIN_PTHREADS_BARRIER_H
-
-#define LIFE_BARRIER 0xBAB1FEED
-#define DEAD_BARRIER 0xDEADB00F
-
-#define _PTHREAD_BARRIER_FLAG (1<<30)
-
-#define CHECK_BARRIER(b)  { \
-    if (!(b) || ( ((barrier_t *)(*b))->valid != (unsigned int)LIFE_BARRIER ) ) return EINVAL; }
-
-#include "../include/semaphore.h"
-
-typedef struct barrier_t barrier_t;
-struct barrier_t
-{
-    int valid;
-    int busy;
-    int count;
-    int total;
-    int share;
-    long sel;
-    pthread_mutex_t m;
-    sem_t sems[2];
-};
-
-#endif
diff --git a/thirdparty/winpthreads/src/clock.c b/thirdparty/winpthreads/src/clock.c
deleted file mode 100644
index 25d351b6..00000000
--- a/thirdparty/winpthreads/src/clock.c
+++ /dev/null
@@ -1,286 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the w64 mingw-runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-
-#include <errno.h>
-#include <stdint.h>
-#include <time.h>
-#include <windows.h>
-#include <stdatomic.h>
-#ifndef IN_WINPTHREAD
-#define IN_WINPTHREAD 1
-#endif
-#include "pthread.h"
-#include "pthread_time.h"
-
-#define POW10_7                 10000000
-#define POW10_9                 1000000000
-
-/* Number of 100ns-seconds between the beginning of the Windows epoch
- * (Jan. 1, 1601) and the Unix epoch (Jan. 1, 1970)
- */
-#define DELTA_EPOCH_IN_100NS    INT64_C(116444736000000000)
-
-static WINPTHREADS_INLINE int lc_set_errno(int result)
-{
-    if (result != 0) {
-        errno = result;
-        return -1;
-    }
-    return 0;
-}
-
-typedef void (WINAPI * GetSystemTimeAsFileTime_t)(LPFILETIME);
-static GetSystemTimeAsFileTime_t GetSystemTimeAsFileTime_p /* = 0 */;
-
-static GetSystemTimeAsFileTime_t try_load_GetSystemPreciseTimeAsFileTime()
-{
-    /* Use GetSystemTimePreciseAsFileTime() if available (Windows 8 or later) */
-    GetSystemTimeAsFileTime_t get_time = (GetSystemTimeAsFileTime_t)(intptr_t)GetProcAddress(
-        GetModuleHandle("kernel32.dll"),
-        "GetSystemTimePreciseAsFileTime"); /* <1us precision on Windows 10 */
-    if (get_time == NULL) {
-        get_time = GetSystemTimeAsFileTime; /* >15ms precision on Windows 10 */
-    }
-
-    _InterlockedExchangePointer((PVOID volatile *)&GetSystemTimeAsFileTime_p, get_time);
-    return get_time;
-}
-
-static WINPTHREADS_INLINE GetSystemTimeAsFileTime_t load_GetSystemTimeBestAsFileTime() {
-    static _Atomic(GetSystemTimeAsFileTime_t) GetSystemTimeAsFileTime_p;
-    atomic_init(&GetSystemTimeAsFileTime_p, NULL);
-    GetSystemTimeAsFileTime_t get_time =
-        atomic_load_explicit(&GetSystemTimeAsFileTime_p, memory_order_relaxed);
-    if (get_time == NULL) {
-        get_time = try_load_GetSystemPreciseTimeAsFileTime();
-        atomic_store_explicit(&GetSystemTimeAsFileTime_p, get_time, memory_order_relaxed);
-    }
-    return get_time;
-}
-
-/**
- * Get the resolution of the specified clock clock_id and
- * stores it in the struct timespec pointed to by res.
- * @param  clock_id The clock_id argument is the identifier of the particular
- *         clock on which to act. The following clocks are supported:
- * <pre>
- *     CLOCK_REALTIME  System-wide real-time clock. Setting this clock
- *                 requires appropriate privileges.
- *     CLOCK_MONOTONIC Clock that cannot be set and represents monotonic
- *                 time since some unspecified starting point.
- *     CLOCK_PROCESS_CPUTIME_ID High-resolution per-process timer from the CPU.
- *     CLOCK_THREAD_CPUTIME_ID  Thread-specific CPU-time clock.
- * </pre>
- * @param  res The pointer to a timespec structure to receive the time
- *         resolution.
- * @return If the function succeeds, the return value is 0.
- *         If the function fails, the return value is -1,
- *         with errno set to indicate the error.
- */
-int clock_getres(clockid_t clock_id, struct timespec *res)
-{
-    clockid_t id = clock_id;
-
-    if (id == CLOCK_REALTIME && load_GetSystemTimeBestAsFileTime() == GetSystemTimeAsFileTime)
-        id = CLOCK_REALTIME_COARSE; /* GetSystemTimePreciseAsFileTime() not available */
-
-    switch(id) {
-    case CLOCK_REALTIME:
-    case CLOCK_MONOTONIC:
-        {
-            LARGE_INTEGER pf;
-
-            if (QueryPerformanceFrequency(&pf) == 0)
-                return lc_set_errno(EINVAL);
-
-            res->tv_sec = 0;
-            res->tv_nsec = (int) ((POW10_9 + (pf.QuadPart >> 1)) / pf.QuadPart);
-            if (res->tv_nsec < 1)
-                res->tv_nsec = 1;
-
-            return 0;
-        }
-
-    case CLOCK_REALTIME_COARSE:
-    case CLOCK_PROCESS_CPUTIME_ID:
-    case CLOCK_THREAD_CPUTIME_ID:
-        {
-            DWORD   timeAdjustment, timeIncrement;
-            BOOL    isTimeAdjustmentDisabled;
-
-            (void) GetSystemTimeAdjustment(&timeAdjustment, &timeIncrement, &isTimeAdjustmentDisabled);
-            res->tv_sec = 0;
-            res->tv_nsec = timeIncrement * 100;
-
-            return 0;
-        }
-    default:
-        break;
-    }
-
-    return lc_set_errno(EINVAL);
-}
-
-/**
- * Get the time of the specified clock clock_id and stores it in the struct
- * timespec pointed to by tp.
- * @param  clock_id The clock_id argument is the identifier of the particular
- *         clock on which to act. The following clocks are supported:
- * <pre>
- *     CLOCK_REALTIME  System-wide real-time clock. Setting this clock
- *                 requires appropriate privileges.
- *     CLOCK_MONOTONIC Clock that cannot be set and represents monotonic
- *                 time since some unspecified starting point.
- *     CLOCK_PROCESS_CPUTIME_ID High-resolution per-process timer from the CPU.
- *     CLOCK_THREAD_CPUTIME_ID  Thread-specific CPU-time clock.
- * </pre>
- * @param  tp The pointer to a timespec structure to receive the time.
- * @return If the function succeeds, the return value is 0.
- *         If the function fails, the return value is -1,
- *         with errno set to indicate the error.
- */
-int clock_gettime(clockid_t clock_id, struct timespec *tp)
-{
-    unsigned __int64 t;
-    LARGE_INTEGER pf, pc;
-    union {
-        unsigned __int64 u64;
-        FILETIME ft;
-    }  ct, et, kt, ut;
-
-    switch(clock_id) {
-    case CLOCK_REALTIME:
-        {
-            load_GetSystemTimeBestAsFileTime()(&ct.ft);
-            t = ct.u64 - DELTA_EPOCH_IN_100NS;
-            tp->tv_sec = t / POW10_7;
-            tp->tv_nsec = ((int) (t % POW10_7)) * 100;
-
-            return 0;
-        }
-
-    case CLOCK_REALTIME_COARSE:
-        {
-            GetSystemTimeAsFileTime(&ct.ft);
-            t = ct.u64 - DELTA_EPOCH_IN_100NS;
-            tp->tv_sec = t / POW10_7;
-            tp->tv_nsec = ((int) (t % POW10_7)) * 100;
-
-            return 0;
-        }
-
-    case CLOCK_MONOTONIC:
-        {
-            if (QueryPerformanceFrequency(&pf) == 0)
-                return lc_set_errno(EINVAL);
-
-            if (QueryPerformanceCounter(&pc) == 0)
-                return lc_set_errno(EINVAL);
-
-            tp->tv_sec = pc.QuadPart / pf.QuadPart;
-            tp->tv_nsec = (int) (((pc.QuadPart % pf.QuadPart) * POW10_9 + (pf.QuadPart >> 1)) / pf.QuadPart);
-            if (tp->tv_nsec >= POW10_9) {
-                tp->tv_sec ++;
-                tp->tv_nsec -= POW10_9;
-            }
-
-            return 0;
-        }
-
-    case CLOCK_PROCESS_CPUTIME_ID:
-        {
-        if(0 == GetProcessTimes(GetCurrentProcess(), &ct.ft, &et.ft, &kt.ft, &ut.ft))
-            return lc_set_errno(EINVAL);
-        t = kt.u64 + ut.u64;
-        tp->tv_sec = t / POW10_7;
-        tp->tv_nsec = ((int) (t % POW10_7)) * 100;
-
-        return 0;
-        }
-
-    case CLOCK_THREAD_CPUTIME_ID: 
-        {
-            if(0 == GetThreadTimes(GetCurrentThread(), &ct.ft, &et.ft, &kt.ft, &ut.ft))
-                return lc_set_errno(EINVAL);
-            t = kt.u64 + ut.u64;
-            tp->tv_sec = t / POW10_7;
-            tp->tv_nsec = ((int) (t % POW10_7)) * 100;
-
-            return 0;
-        }
-
-    default:
-        break;
-    }
-
-    return lc_set_errno(EINVAL);
-}
-
-/**
- * Sleep for the specified time.
- * @param  clock_id This argument should always be CLOCK_REALTIME (0).
- * @param  flags 0 for relative sleep interval, others for absolute waking up.
- * @param  request The desired sleep interval or absolute waking up time.
- * @param  remain The remain amount of time to sleep.
- *         The current implemention just ignore it.
- * @return If the function succeeds, the return value is 0.
- *         If the function fails, the return value is -1,
- *         with errno set to indicate the error.
- */
-int clock_nanosleep(clockid_t clock_id, int flags,
-                           const struct timespec *request,
-                           struct timespec *remain)
-{
-    struct timespec tp;
-
-    if (clock_id != CLOCK_REALTIME)
-        return lc_set_errno(EINVAL);
-
-    if (flags == 0)
-        return nanosleep(request, remain);
-
-    /* TIMER_ABSTIME = 1 */
-    clock_gettime(CLOCK_REALTIME, &tp);
-
-    tp.tv_sec = request->tv_sec - tp.tv_sec;
-    tp.tv_nsec = request->tv_nsec - tp.tv_nsec;
-    if (tp.tv_nsec < 0) {
-        tp.tv_nsec += POW10_9;
-        tp.tv_sec --;
-    }
-
-    return nanosleep(&tp, remain);
-}
-
-/**
- * Set the time of the specified clock clock_id.
- * @param  clock_id This argument should always be CLOCK_REALTIME (0).
- * @param  tp The requested time.
- * @return If the function succeeds, the return value is 0.
- *         If the function fails, the return value is -1,
- *         with errno set to indicate the error.
- */
-int clock_settime(clockid_t clock_id, const struct timespec *tp)
-{
-    SYSTEMTIME st;
-
-    union {
-        unsigned __int64 u64;
-        FILETIME ft;
-    }  t;
-
-    if (clock_id != CLOCK_REALTIME)
-        return lc_set_errno(EINVAL);
-
-    t.u64 = tp->tv_sec * (__int64) POW10_7 + tp->tv_nsec / 100 + DELTA_EPOCH_IN_100NS;
-    if (FileTimeToSystemTime(&t.ft, &st) == 0)
-        return lc_set_errno(EINVAL);
-
-    if (SetSystemTime(&st) == 0)
-        return lc_set_errno(EPERM);
-
-    return 0;
-}
diff --git a/thirdparty/winpthreads/src/cond.c b/thirdparty/winpthreads/src/cond.c
deleted file mode 100644
index d50f85b4..00000000
--- a/thirdparty/winpthreads/src/cond.c
+++ /dev/null
@@ -1,755 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-/*
- * Posix Condition Variables for Microsoft Windows.
- * 22-9-2010 Partly based on the ACE framework implementation.
- */
-#include <windows.h>
-#include <stdio.h>
-#include <malloc.h>
-#include <time.h>
-#include "pthread.h"
-#include "pthread_time.h"
-#include "ref.h"
-#include "cond.h"
-#include "thread.h"
-#include "misc.h"
-#include "winpthread_internal.h"
-
-#include "pthread_compat.h"
-
-int __pthread_shallcancel (void);
-
-static int do_sema_b_wait (HANDLE sema, int nointerrupt, DWORD timeout,CRITICAL_SECTION *cs, LONG *val);
-static int do_sema_b_release(HANDLE sema, LONG count,CRITICAL_SECTION *cs, LONG *val);
-static void cleanup_wait(void *arg);
-
-typedef struct sCondWaitHelper {
-    cond_t *c;
-    pthread_mutex_t *external_mutex;
-    int *r;
-} sCondWaitHelper;
-
-int do_sema_b_wait_intern (HANDLE sema, int nointerrupt, DWORD timeout);
-
-#ifdef WINPTHREAD_DBG
-static int print_state = 0;
-static FILE *fo;
-void cond_print_set(int state, FILE *f)
-{
-    if (f) fo = f;
-    if (!fo) fo = stdout;
-    print_state = state;
-}
-
-void cond_print(volatile pthread_cond_t *c, char *txt)
-{
-    if (!print_state) return;
-    cond_t *c_ = (cond_t *)*c;
-    if (c_ == NULL) {
-        fprintf(fo,"C%p %d %s\n",(void *)*c,(int)GetCurrentThreadId(),txt);
-    } else {
-        fprintf(fo,"C%p %d V=%0X w=%ld %s\n",
-            (void *)*c,
-            (int)GetCurrentThreadId(), 
-            (int)c_->valid, 
-            c_->waiters_count_,
-            txt
-            );
-    }
-}
-#endif
-
-static pthread_spinlock_t cond_locked = PTHREAD_SPINLOCK_INITIALIZER;
-
-static int
-cond_static_init (pthread_cond_t *c)
-{
-  int r = 0;
-  
-  pthread_spin_lock (&cond_locked);
-  if (c == NULL)
-    r = EINVAL;
-  else if (*c == PTHREAD_COND_INITIALIZER)
-    r = pthread_cond_init (c, NULL);
-  else
-    /* We assume someone was faster ... */
-    r = 0;
-  pthread_spin_unlock (&cond_locked);
-  return r;
-}
-
-int
-pthread_condattr_destroy (pthread_condattr_t *a)
-{
-  if (!a)
-    return EINVAL;
-   *a = 0;
-   return 0;
-}
-
-int
-pthread_condattr_init (pthread_condattr_t *a)
-{
-  if (!a)
-    return EINVAL;
-  *a = 0;
-  return 0;
-}
-
-int
-pthread_condattr_getpshared (const pthread_condattr_t *a, int *s)
-{
-  if (!a || !s)
-    return EINVAL;
-  *s = *a;
-  return 0;
-}
-
-int
-pthread_condattr_getclock (const pthread_condattr_t *a, clockid_t *clock_id)
-{
-  if (!a || !clock_id)
-    return EINVAL;
-  *clock_id = 0;
-  return 0;
-}
-
-int
-pthread_condattr_setclock(pthread_condattr_t *a, clockid_t clock_id)
-{
-  if (!a || clock_id != 0)
-    return EINVAL;
-  return 0;
-}
-
-int
-__pthread_clock_nanosleep (clockid_t clock_id, int flags, const struct timespec *rqtp,
-			   struct timespec *rmtp)
-{
-  unsigned long long tick, tick2;
-  unsigned long long delay;
-  DWORD dw;
-
-  if (clock_id != CLOCK_REALTIME
-      && clock_id != CLOCK_MONOTONIC
-      && clock_id != CLOCK_PROCESS_CPUTIME_ID)
-   return EINVAL;
-  if ((flags & TIMER_ABSTIME) != 0)
-    delay = _pthread_rel_time_in_ms (rqtp);
-  else
-    delay = _pthread_time_in_ms_from_timespec (rqtp);
-  do
-    {
-      dw = (DWORD) (delay >= 99999ULL ? 99999ULL : delay);
-      tick = _pthread_time_in_ms ();
-      pthread_delay_np_ms (dw);
-      tick2 = _pthread_time_in_ms ();
-      tick2 -= tick;
-      if (tick2 >= delay)
-        delay = 0;
-      else
-        delay -= tick2;
-    }
-  while (delay != 0ULL);
-  if (rmtp)
-    memset (rmtp, 0, sizeof (*rmtp));
-  return 0;
-}
-
-int
-pthread_condattr_setpshared (pthread_condattr_t *a, int s)
-{
-  if (!a || (s != PTHREAD_PROCESS_SHARED && s != PTHREAD_PROCESS_PRIVATE))
-    return EINVAL;
-  if (s == PTHREAD_PROCESS_SHARED)
-    {
-       *a = PTHREAD_PROCESS_PRIVATE;
-       return ENOSYS;
-    }
-  *a = s;
-  return 0;
-}
-
-int
-pthread_cond_init (pthread_cond_t *c, const pthread_condattr_t *a)
-{
-  cond_t *_c;
-  int r = 0;
-
-  if (!c)
-    return EINVAL;
-  if (a && *a == PTHREAD_PROCESS_SHARED)
-    return ENOSYS;
-
-  if ( !(_c = calloc(1,sizeof(*_c))) ) {
-      return ENOMEM; 
-  }
-  _c->valid  = DEAD_COND;
-  _c->busy = 0;
-  _c->waiters_count_ = 0;
-  _c->waiters_count_gone_ = 0;
-  _c->waiters_count_unblock_ = 0;
-
-  _c->sema_q = CreateSemaphore (NULL,       /* no security */
-      0,          /* initially 0 */
-      0x7fffffff, /* max count */
-      NULL);      /* unnamed  */
-  _c->sema_b =  CreateSemaphore (NULL,       /* no security */
-      0,          /* initially 0 */
-      0x7fffffff, /* max count */
-      NULL);  
-  if (_c->sema_q == NULL || _c->sema_b == NULL) {
-      if (_c->sema_q != NULL)
-	CloseHandle (_c->sema_q);
-      if (_c->sema_b != NULL)
-	CloseHandle (_c->sema_b);
-      free (_c);
-      r = EAGAIN;
-  } else {
-      InitializeCriticalSection(&_c->waiters_count_lock_);
-      InitializeCriticalSection(&_c->waiters_b_lock_);
-      InitializeCriticalSection(&_c->waiters_q_lock_);
-      _c->value_q = 0;
-      _c->value_b = 1;
-  }
-  if (!r)
-    {
-      _c->valid = LIFE_COND;
-      *c = (pthread_cond_t)_c;
-    }
-  else
-    *c = (pthread_cond_t)NULL;
-  return r;
-}
-
-int
-pthread_cond_destroy (pthread_cond_t *c)
-{
-  cond_t *_c;
-  int r;
-  if (!c || !*c)
-    return EINVAL;
-  if (*c == PTHREAD_COND_INITIALIZER)
-    {
-      pthread_spin_lock (&cond_locked);
-      if (*c == PTHREAD_COND_INITIALIZER)
-      {
-	*c = (pthread_cond_t)NULL;
-	r = 0;
-      }
-      else
-	r = EBUSY;
-      pthread_spin_unlock (&cond_locked);
-      return r;
-    }
-  _c = (cond_t *) *c;
-  r = do_sema_b_wait(_c->sema_b, 0, INFINITE,&_c->waiters_b_lock_,&_c->value_b);
-  if (r != 0)
-    return r;
-  if (!TryEnterCriticalSection (&_c->waiters_count_lock_))
-    {
-       do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
-       return EBUSY;
-    }
-  if (_c->waiters_count_ > _c->waiters_count_gone_)
-    {
-      r = do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
-      if (!r) r = EBUSY;
-      LeaveCriticalSection(&_c->waiters_count_lock_);
-      return r;
-    }
-  *c = (pthread_cond_t)NULL;
-  do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
-
-  if (!CloseHandle (_c->sema_q) && !r)
-    r = EINVAL;
-  if (!CloseHandle (_c->sema_b) && !r)
-    r = EINVAL;
-  LeaveCriticalSection (&_c->waiters_count_lock_);
-  DeleteCriticalSection(&_c->waiters_count_lock_);
-  DeleteCriticalSection(&_c->waiters_b_lock_);
-  DeleteCriticalSection(&_c->waiters_q_lock_);
-  _c->valid  = DEAD_COND;
-  free(_c);
-  return 0;
-}
-
-int
-pthread_cond_signal (pthread_cond_t *c)
-{
-  cond_t *_c;
-  int r;
-
-  if (!c || !*c)
-    return EINVAL;
-  _c = (cond_t *)*c;
-  if (_c == (cond_t *)PTHREAD_COND_INITIALIZER)
-    return 0;
-  else if (_c->valid != (unsigned int)LIFE_COND)
-    return EINVAL;
-
-  EnterCriticalSection (&_c->waiters_count_lock_);
-  /* If there aren't any waiters, then this is a no-op.   */
-  if (_c->waiters_count_unblock_ != 0)
-    {
-      if (_c->waiters_count_ == 0)
-      {
-	LeaveCriticalSection (&_c->waiters_count_lock_);
-	/* pthread_testcancel(); */
-	return 0;
-      }
-      _c->waiters_count_ -= 1;
-      _c->waiters_count_unblock_ += 1;
-    }
-  else if (_c->waiters_count_ > _c->waiters_count_gone_)
-    {
-      r = do_sema_b_wait (_c->sema_b, 1, INFINITE,&_c->waiters_b_lock_,&_c->value_b);
-      if (r != 0)
-      {
-	LeaveCriticalSection (&_c->waiters_count_lock_);
-	/* pthread_testcancel(); */
-	return r;
-      }
-      if (_c->waiters_count_gone_ != 0)
-      {
-	_c->waiters_count_ -= _c->waiters_count_gone_;
-	_c->waiters_count_gone_ = 0;
-      }
-      _c->waiters_count_ -= 1;
-      _c->waiters_count_unblock_ = 1;
-    }
-  else
-    {
-      LeaveCriticalSection (&_c->waiters_count_lock_);
-      /* pthread_testcancel(); */
-      return 0;
-    }
-  LeaveCriticalSection (&_c->waiters_count_lock_);
-  r = do_sema_b_release(_c->sema_q, 1,&_c->waiters_q_lock_,&_c->value_q);
-  /* pthread_testcancel(); */
-  return r;
-}
-
-int
-pthread_cond_broadcast (pthread_cond_t *c)
-{
-  cond_t *_c;
-  int r;
-  int relCnt = 0;    
-
-  if (!c || !*c)
-    return EINVAL;
-  _c = (cond_t *)*c;
-  if (_c == (cond_t*)PTHREAD_COND_INITIALIZER)
-    return 0;
-  else if (_c->valid != (unsigned int)LIFE_COND)
-    return EINVAL;
-
-  EnterCriticalSection (&_c->waiters_count_lock_);
-  /* If there aren't any waiters, then this is a no-op.   */
-  if (_c->waiters_count_unblock_ != 0)
-    {
-      if (_c->waiters_count_ == 0)
-      {
-	LeaveCriticalSection (&_c->waiters_count_lock_);
-	/* pthread_testcancel(); */
-	return 0;
-      }
-      relCnt = _c->waiters_count_;
-      _c->waiters_count_ = 0;
-      _c->waiters_count_unblock_ += relCnt;
-    }
-  else if (_c->waiters_count_ > _c->waiters_count_gone_)
-    {
-      r = do_sema_b_wait (_c->sema_b, 1, INFINITE,&_c->waiters_b_lock_,&_c->value_b);
-      if (r != 0)
-      {
-	LeaveCriticalSection (&_c->waiters_count_lock_);
-	/* pthread_testcancel(); */
-	return r;
-      }
-      if (_c->waiters_count_gone_ != 0)
-      {
-	_c->waiters_count_ -= _c->waiters_count_gone_;
-	_c->waiters_count_gone_ = 0;
-      }
-      relCnt = _c->waiters_count_;
-      _c->waiters_count_ = 0;
-      _c->waiters_count_unblock_ = relCnt;
-    }
-  else
-    {
-      LeaveCriticalSection (&_c->waiters_count_lock_);
-      /* pthread_testcancel(); */
-      return 0;
-    }
-  LeaveCriticalSection (&_c->waiters_count_lock_);
-  r = do_sema_b_release(_c->sema_q, relCnt,&_c->waiters_q_lock_,&_c->value_q);
-  /* pthread_testcancel(); */
-  return r;
-}
-
-int
-pthread_cond_wait (pthread_cond_t *c, pthread_mutex_t *external_mutex)
-{
-  sCondWaitHelper ch;
-  cond_t *_c;
-  int r;
-
-  /* pthread_testcancel(); */
-
-  if (!c || *c == (pthread_cond_t)NULL)
-    return EINVAL;
-  _c = (cond_t *)*c;
-  if (*c == PTHREAD_COND_INITIALIZER)
-  {
-    r = cond_static_init(c);
-    if (r != 0 && r != EBUSY)
-      return r;
-    _c = (cond_t *) *c;
-  } else if (_c->valid != (unsigned int)LIFE_COND)
-    return EINVAL;
-
-tryagain:
-  r = do_sema_b_wait (_c->sema_b, 0, INFINITE,&_c->waiters_b_lock_,&_c->value_b);
-  if (r != 0)
-    return r;
-
-  if (!TryEnterCriticalSection (&_c->waiters_count_lock_))
-  {
-    r = do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
-    if (r != 0)
-      return r;
-    sched_yield();
-    goto tryagain;
-  }
-
-  _c->waiters_count_++;
-  LeaveCriticalSection(&_c->waiters_count_lock_);
-  r = do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
-  if (r != 0)
-    return r;
-
-  ch.c = _c;
-  ch.r = &r;
-  ch.external_mutex = external_mutex;
-
-  pthread_cleanup_push(cleanup_wait, (void *) &ch);
-  r = pthread_mutex_unlock(external_mutex);
-  if (!r)
-    r = do_sema_b_wait (_c->sema_q, 0, INFINITE,&_c->waiters_q_lock_,&_c->value_q);
-
-  pthread_cleanup_pop(1);
-  return r;
-}
-
-static int
-pthread_cond_timedwait_impl (pthread_cond_t *c, pthread_mutex_t *external_mutex, const struct timespec *t, int rel)
-{
-  sCondWaitHelper ch;
-  DWORD dwr;
-  int r;
-  cond_t *_c;
-
-  /* pthread_testcancel(); */
-
-  if (!c || !*c)
-    return EINVAL;
-  _c = (cond_t *)*c;
-  if (_c == (cond_t *)PTHREAD_COND_INITIALIZER)
-  {
-    r = cond_static_init(c);
-    if (r && r != EBUSY)
-      return r;
-    _c = (cond_t *) *c;
-  } else if ((_c)->valid != (unsigned int)LIFE_COND)
-    return EINVAL;
-
-  if (rel == 0)
-  {
-    dwr = dwMilliSecs(_pthread_rel_time_in_ms(t));
-  }
-  else
-  {
-    dwr = dwMilliSecs(_pthread_time_in_ms_from_timespec(t));
-  }
-
-tryagain:
-  r = do_sema_b_wait (_c->sema_b, 0, INFINITE,&_c->waiters_b_lock_,&_c->value_b);
-  if (r != 0)
-    return r;
-
-  if (!TryEnterCriticalSection (&_c->waiters_count_lock_))
-  {
-    r = do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
-    if (r != 0)
-      return r;
-    sched_yield();
-    goto tryagain;
-  }
-
-  _c->waiters_count_++;
-  LeaveCriticalSection(&_c->waiters_count_lock_);
-  r = do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
-  if (r != 0)
-    return r;
-
-  ch.c = _c;
-  ch.r = &r;
-  ch.external_mutex = external_mutex;
-  {
-    pthread_cleanup_push(cleanup_wait, (void *) &ch);
-
-    r = pthread_mutex_unlock(external_mutex);
-    if (!r)
-      r = do_sema_b_wait (_c->sema_q, 0, dwr,&_c->waiters_q_lock_,&_c->value_q);
-
-    pthread_cleanup_pop(1);
-  }
-  return r;
-}
-
-int
-pthread_cond_timedwait(pthread_cond_t *c, pthread_mutex_t *m, const struct timespec *t)
-{
-  return pthread_cond_timedwait_impl(c, m, t, 0);
-}
-
-int
-pthread_cond_timedwait_relative_np(pthread_cond_t *c, pthread_mutex_t *m, const struct timespec *t)
-{
-  return pthread_cond_timedwait_impl(c, m, t, 1);
-}
-
-static void
-cleanup_wait (void *arg)
-{
-  int n, r;
-  sCondWaitHelper *ch = (sCondWaitHelper *) arg;
-  cond_t *_c;
-
-  _c = ch->c;
-  EnterCriticalSection (&_c->waiters_count_lock_);
-  n = _c->waiters_count_unblock_;
-  if (n != 0)
-    _c->waiters_count_unblock_ -= 1;
-  else if ((INT_MAX/2) - 1 == _c->waiters_count_gone_)
-  {
-    _c->waiters_count_gone_ += 1;
-    r = do_sema_b_wait (_c->sema_b, 1, INFINITE,&_c->waiters_b_lock_,&_c->value_b);
-    if (r != 0)
-    {
-      LeaveCriticalSection(&_c->waiters_count_lock_);
-      ch->r[0] = r;
-      return;
-    }
-    _c->waiters_count_ -= _c->waiters_count_gone_;
-    r = do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
-    if (r != 0)
-    {
-      LeaveCriticalSection(&_c->waiters_count_lock_);
-      ch->r[0] = r;
-      return;
-    }
-    _c->waiters_count_gone_ = 0;
-  }
-  else
-    _c->waiters_count_gone_ += 1;
-  LeaveCriticalSection (&_c->waiters_count_lock_);
-
-  if (n == 1)
-  {
-    r = do_sema_b_release (_c->sema_b, 1,&_c->waiters_b_lock_,&_c->value_b);
-    if (r != 0)
-    {
-      ch->r[0] = r;
-      return;
-    }
-  }
-  r = pthread_mutex_lock(ch->external_mutex);
-  if (r != 0)
-    ch->r[0] = r;
-}
-
-static int
-do_sema_b_wait (HANDLE sema, int nointerrupt, DWORD timeout,CRITICAL_SECTION *cs, LONG *val)
-{
-  int r;
-  LONG v;
-  EnterCriticalSection(cs);
-  InterlockedDecrement(val);
-  v = val[0];
-  LeaveCriticalSection(cs);
-  if (v >= 0)
-    return 0;
-  r = do_sema_b_wait_intern (sema, nointerrupt, timeout);
-  EnterCriticalSection(cs);
-  if (r != 0)
-    InterlockedIncrement(val);
-  LeaveCriticalSection(cs);
-  return r;
-}
-
-int
-do_sema_b_wait_intern (HANDLE sema, int nointerrupt, DWORD timeout)
-{
-  HANDLE arr[2];
-  DWORD maxH = 1;
-  int r = 0;
-  DWORD res, dt;
-  if (nointerrupt == 1)
-  {
-    res = _pthread_wait_for_single_object(sema, timeout);
-    switch (res) {
-    case WAIT_TIMEOUT:
-	r = ETIMEDOUT;
-	break;
-    case WAIT_ABANDONED:
-	r = EPERM;
-	break;
-    case WAIT_OBJECT_0:
-	break;
-    default:
-	/*We can only return EINVAL though it might not be posix compliant  */
-	r = EINVAL;
-    }
-    if (r != 0 && r != EINVAL && WaitForSingleObject(sema, 0) == WAIT_OBJECT_0)
-      r = 0;
-    return r;
-  }
-  arr[0] = sema;
-  arr[1] = (HANDLE) pthread_getevent ();
-  if (arr[1] != NULL) maxH += 1;
-  if (maxH == 2)
-  {
-redo:
-      res = _pthread_wait_for_multiple_objects(maxH, arr, 0, timeout);
-      switch (res) {
-      case WAIT_TIMEOUT:
-	  r = ETIMEDOUT;
-	  break;
-      case (WAIT_OBJECT_0 + 1):
-          ResetEvent(arr[1]);
-          if (nointerrupt != 2)
-	    {
-            pthread_testcancel();
-            return EINVAL;
-	    }
-	  pthread_testcancel ();
-	  goto redo;
-      case WAIT_ABANDONED:
-	  r = EPERM;
-	  break;
-      case WAIT_OBJECT_0:
-          r = 0;
-	  break;
-      default:
-	  /*We can only return EINVAL though it might not be posix compliant  */
-	  r = EINVAL;
-      }
-      if (r != 0 && r != EINVAL && WaitForSingleObject(arr[0], 0) == WAIT_OBJECT_0)
-	r = 0;
-      if (r != 0 && nointerrupt != 2 && __pthread_shallcancel ())
-	return EINVAL;
-      return r;
-  }
-  if (timeout == INFINITE)
-  {
-    do {
-      res = _pthread_wait_for_single_object(sema, 40);
-      switch (res) {
-      case WAIT_TIMEOUT:
-	  r = ETIMEDOUT;
-	  break;
-      case WAIT_ABANDONED:
-	  r = EPERM;
-	  break;
-      case WAIT_OBJECT_0:
-          r = 0;
-	  break;
-      default:
-	  /*We can only return EINVAL though it might not be posix compliant  */
-	  r = EINVAL;
-      }
-      if (r != 0 && __pthread_shallcancel ())
-      {
-	if (nointerrupt != 2)
-	  pthread_testcancel();
-	return EINVAL;
-      }
-    } while (r == ETIMEDOUT);
-    if (r != 0 && r != EINVAL && WaitForSingleObject(sema, 0) == WAIT_OBJECT_0)
-      r = 0;
-    return r;
-  }
-  dt = 20;
-  do {
-    if (dt > timeout) dt = timeout;
-    res = _pthread_wait_for_single_object(sema, dt);
-    switch (res) {
-    case WAIT_TIMEOUT:
-	r = ETIMEDOUT;
-	break;
-    case WAIT_ABANDONED:
-	r = EPERM;
-	break;
-    case WAIT_OBJECT_0:
-	r = 0;
-	break;
-    default:
-	/*We can only return EINVAL though it might not be posix compliant  */
-	r = EINVAL;
-    }
-    timeout -= dt;
-    if (timeout != 0 && r != 0 && __pthread_shallcancel ())
-      return EINVAL;
-  } while (r == ETIMEDOUT && timeout != 0);
-  if (r != 0 && r == ETIMEDOUT && WaitForSingleObject(sema, 0) == WAIT_OBJECT_0)
-    r = 0;
-  if (r != 0 && nointerrupt != 2)
-    pthread_testcancel();
-  return r;
-}
-
-static int
-do_sema_b_release(HANDLE sema, LONG count,CRITICAL_SECTION *cs, LONG *val)
-{
-  int wc;
-  EnterCriticalSection(cs);
-  if (((long long) val[0] + (long long) count) > (long long) 0x7fffffffLL)
-  {
-    LeaveCriticalSection(cs);
-    return ERANGE;
-  }
-  wc = -val[0];
-  InterlockedExchangeAdd(val, count);
-  if (wc <= 0 || ReleaseSemaphore(sema, (wc < count ? wc : count), NULL))
-  {
-    LeaveCriticalSection(cs);
-    return 0;
-  }
-  InterlockedExchangeAdd(val, -count);
-  LeaveCriticalSection(cs);
-  return EINVAL;  
-}
diff --git a/thirdparty/winpthreads/src/cond.h b/thirdparty/winpthreads/src/cond.h
deleted file mode 100644
index c70d3114..00000000
--- a/thirdparty/winpthreads/src/cond.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef WIN_PTHREADS_COND_H
-#define WIN_PTHREADS_COND_H
-
-#include <windows.h>
-
-#define CHECK_COND(c)  { \
-    if (!(c) || !*c || (*c == PTHREAD_COND_INITIALIZER) \
-        || ( ((cond_t *)(*c))->valid != (unsigned int)LIFE_COND ) ) \
-        return EINVAL; }
-
-#define LIFE_COND 0xC0BAB1FD
-#define DEAD_COND 0xC0DEADBF
-
-#define STATIC_COND_INITIALIZER(x)		((pthread_cond_t)(x) == ((pthread_cond_t)PTHREAD_COND_INITIALIZER))
-
-typedef struct cond_t cond_t;
-struct cond_t
-{
-    unsigned int valid;   
-    int busy;
-    LONG waiters_count_; /* Number of waiting threads.  */
-    LONG waiters_count_unblock_; /* Number of waiting threads whitch can be unblocked.  */
-    LONG waiters_count_gone_; /* Number of waiters which are gone.  */
-    CRITICAL_SECTION waiters_count_lock_; /* Serialize access to <waiters_count_>.  */
-    CRITICAL_SECTION waiters_q_lock_; /* Serialize access to sema_q.  */
-    LONG value_q;
-    CRITICAL_SECTION waiters_b_lock_; /* Serialize access to sema_b.  */
-    LONG value_b;
-    HANDLE sema_q; /* Semaphore used to queue up threads waiting for the condition to
-                 become signaled.  */
-    HANDLE sema_b; /* Semaphore used to queue up threads waiting for the condition which
-                 became signaled.  */
-};
-
-void cond_print_set(int state, FILE *f);
-
-void cond_print(volatile pthread_cond_t *c, char *txt);
-
-#endif
diff --git a/thirdparty/winpthreads/src/libgcc/dll_dependency.S b/thirdparty/winpthreads/src/libgcc/dll_dependency.S
deleted file mode 100644
index 0496e940..00000000
--- a/thirdparty/winpthreads/src/libgcc/dll_dependency.S
+++ /dev/null
@@ -1,90 +0,0 @@
-/* Implementation for gcc's internal stack-allocation routines.  */
-#if defined(__i386__) || defined(__x86_64__)
-.global ___chkstk
-.global	__alloca
-
-.global ___chkstk_ms
-___chkstk_ms:
-#ifdef _WIN64
-	pushq	%rax
-	pushq	%rcx
-	cmpq	$0x1000, %rax
-	leaq	24(%rsp), %rcx
-	jb	.Lchkstk_ms_end
-.Lchkstk_ms_loop:
-	subq	$0x1000, %rcx
-	subq	$0x1000, %rax
-	orq	$0x0, (%rcx)
-	cmpq	$0x1000, %rax
-	ja	.Lchkstk_ms_loop
-.Lchkstk_ms_end:
-	subq	%rax, %rcx
-	orq	$0x0, (%rcx)
-	popq	%rcx
-	popq	%rax
-	ret
-#else
-	pushl	%eax
-	pushl	%ecx
-	cmpl	$0x1000, %eax
-	leal	12(%esp), %ecx
-	jb	chkstk_ms_end
-chkstk_ms_loop:
-	subl	$0x1000, %ecx
-	subl	$0x1000, %eax
-	orl	$0x0, (%ecx)
-	cmpl	$0x1000, %eax
-	ja	chkstk_ms_loop
-chkstk_ms_end:
-	subl	%eax, %ecx
-	orl	$0x0, (%ecx)
-	popl	%ecx
-	popl	%eax
-	ret
-#endif
-
-#ifdef _WIN64
-__alloca:
-	movq	%rcx, %rax
-.align	4
-___chkstk:
-	popq	%r11
-	movq	%rsp, %r10
-	cmpq	$0x1000, %rax
-	jb	.Lchkstk_end
-.Lchkstk_loop:
-	subq	$0x1000, %r10
-	subq	$0x1000, %rax
-	orl	$0x0, (%r10)
-	cmpq	$0x1000, %rax
-	ja	.Lchkstk_loop
-.Lchkstk_end:
-	subq	%rax, %r10
-	movq	%rsp, %rax
-	orl	$0x0, (%r10)
-	movq	%r10, %rsp
-	pushq	%r11
-	ret
-#else
-___chkstk:
-__alloca:
-	pushl	%ecx
-	leal	8(%esp), %ecx
-	cmpl	$0x1000, %eax		/* > 4k ?*/
-	jb	chkstk_end
-chkstk_loop:
-	subl	$0x1000, %ecx
-	subl	$0x1000, %eax
-	orl	$0x0, (%ecx)
-	cmpl	$0x1000, %eax
-	ja	chkstk_loop
-chkstk_end:
-	subl	%eax, %ecx	   
-	orl	$0x0, (%ecx)
-	movl	%esp, %eax
-	movl	%ecx, %esp
-	movl	(%eax), %ecx
-	pushl	4(%eax)
-	ret
-#endif
-#endif
diff --git a/thirdparty/winpthreads/src/libgcc/dll_math.c b/thirdparty/winpthreads/src/libgcc/dll_math.c
deleted file mode 100644
index 77bb1fea..00000000
--- a/thirdparty/winpthreads/src/libgcc/dll_math.c
+++ /dev/null
@@ -1,586 +0,0 @@
-/*-
- * Copyright (c) 1992, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This software was developed by the Computer Systems Engineering group
- * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
- * contributed to Berkeley.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#ifndef _LIBKERN_QUAD_H_
-#define	_LIBKERN_QUAD_H_
-
-/*
- * Quad arithmetic.
- *
- * This library makes the following assumptions:
- *
- *  - The type long long (aka quad_t) exists.
- *
- *  - A quad variable is exactly twice as long as `long'.
- *
- *  - The machine's arithmetic is two's complement.
- *
- * This library can provide 128-bit arithmetic on a machine with 128-bit
- * quads and 64-bit longs, for instance, or 96-bit arithmetic on machines
- * with 48-bit longs.
- */
-/*
-#include <sys/cdefs.h>
-#include <sys/types.h>
-#include <sys/limits.h>
-#include <sys/syslimits.h>
-*/
-
-#include <limits.h>
-typedef long long quad_t;
-typedef unsigned long long u_quad_t;
-typedef unsigned long u_long;
-#define CHAR_BIT __CHAR_BIT__
-
-/*
- * Define the order of 32-bit words in 64-bit words.
- * For little endian only.
- */
-#define _QUAD_HIGHWORD 1
-#define _QUAD_LOWWORD 0
-
-/*
- * Depending on the desired operation, we view a `long long' (aka quad_t) in
- * one or more of the following formats.
- */
-union uu {
-	quad_t	q;		/* as a (signed) quad */
-	quad_t	uq;		/* as an unsigned quad */
-	long	sl[2];		/* as two signed longs */
-	u_long	ul[2];		/* as two unsigned longs */
-};
-
-/*
- * Define high and low longwords.
- */
-#define	H		_QUAD_HIGHWORD
-#define	L		_QUAD_LOWWORD
-
-/*
- * Total number of bits in a quad_t and in the pieces that make it up.
- * These are used for shifting, and also below for halfword extraction
- * and assembly.
- */
-#define	QUAD_BITS	(sizeof(quad_t) * CHAR_BIT)
-#define	LONG_BITS	(sizeof(long) * CHAR_BIT)
-#define	HALF_BITS	(sizeof(long) * CHAR_BIT / 2)
-
-/*
- * Extract high and low shortwords from longword, and move low shortword of
- * longword to upper half of long, i.e., produce the upper longword of
- * ((quad_t)(x) << (number_of_bits_in_long/2)).  (`x' must actually be u_long.)
- *
- * These are used in the multiply code, to split a longword into upper
- * and lower halves, and to reassemble a product as a quad_t, shifted left
- * (sizeof(long)*CHAR_BIT/2).
- */
-#define	HHALF(x)	((x) >> HALF_BITS)
-#define	LHALF(x)	((x) & ((1 << HALF_BITS) - 1))
-#define	LHUP(x)		((x) << HALF_BITS)
-
-typedef unsigned int	qshift_t;
-
-quad_t		__ashldi3(quad_t, qshift_t);
-quad_t		__ashrdi3(quad_t, qshift_t);
-int		__cmpdi2(quad_t a, quad_t b);
-quad_t		__divdi3(quad_t a, quad_t b);
-quad_t		__lshrdi3(quad_t, qshift_t);
-quad_t		__moddi3(quad_t a, quad_t b);
-u_quad_t	__qdivrem(u_quad_t u, u_quad_t v, u_quad_t *rem);
-u_quad_t	__udivdi3(u_quad_t a, u_quad_t b);
-u_quad_t	__umoddi3(u_quad_t a, u_quad_t b);
-int		__ucmpdi2(u_quad_t a, u_quad_t b);
-quad_t	__divmoddi4(quad_t a, quad_t b, quad_t *rem);
-u_quad_t	__udivmoddi4(u_quad_t a, u_quad_t b, u_quad_t *rem);
-
-#endif /* !_LIBKERN_QUAD_H_ */
-
-#if defined (_X86_) && !defined (__x86_64__)
-/*
- * Shift a (signed) quad value left (arithmetic shift left).
- * This is the same as logical shift left!
- */
-quad_t
-__ashldi3(a, shift)
-	quad_t a;
-	qshift_t shift;
-{
-	union uu aa;
-
-	aa.q = a;
-	if (shift >= LONG_BITS) {
-		aa.ul[H] = shift >= QUAD_BITS ? 0 :
-		    aa.ul[L] << (shift - LONG_BITS);
-		aa.ul[L] = 0;
-	} else if (shift > 0) {
-		aa.ul[H] = (aa.ul[H] << shift) |
-		    (aa.ul[L] >> (LONG_BITS - shift));
-		aa.ul[L] <<= shift;
-	}
-	return (aa.q);
-}
-
-/*
- * Shift a (signed) quad value right (arithmetic shift right).
- */
-quad_t
-__ashrdi3(a, shift)
-	quad_t a;
-	qshift_t shift;
-{
-	union uu aa;
-
-	aa.q = a;
-	if (shift >= LONG_BITS) {
-		long s;
-
-		/*
-		 * Smear bits rightward using the machine's right-shift
-		 * method, whether that is sign extension or zero fill,
-		 * to get the `sign word' s.  Note that shifting by
-		 * LONG_BITS is undefined, so we shift (LONG_BITS-1),
-		 * then 1 more, to get our answer.
-		 */
-		s = (aa.sl[H] >> (LONG_BITS - 1)) >> 1;
-		aa.ul[L] = shift >= QUAD_BITS ? s :
-		    aa.sl[H] >> (shift - LONG_BITS);
-		aa.ul[H] = s;
-	} else if (shift > 0) {
-		aa.ul[L] = (aa.ul[L] >> shift) |
-		    (aa.ul[H] << (LONG_BITS - shift));
-		aa.sl[H] >>= shift;
-	}
-	return (aa.q);
-}
-
-/*
- * Return 0, 1, or 2 as a <, =, > b respectively.
- * Both a and b are considered signed---which means only the high word is
- * signed.
- */
-int
-__cmpdi2(a, b)
-	quad_t a, b;
-{
-	union uu aa, bb;
-
-	aa.q = a;
-	bb.q = b;
-	return (aa.sl[H] < bb.sl[H] ? 0 : aa.sl[H] > bb.sl[H] ? 2 :
-	    aa.ul[L] < bb.ul[L] ? 0 : aa.ul[L] > bb.ul[L] ? 2 : 1);
-}
-
-/*
- * Divide two signed quads.
- * ??? if -1/2 should produce -1 on this machine, this code is wrong
- */
-quad_t
-__divdi3(a, b)
-	quad_t a, b;
-{
-	u_quad_t ua, ub, uq;
-	int neg;
-
-	if (a < 0)
-		ua = -(u_quad_t)a, neg = 1;
-	else
-		ua = a, neg = 0;
-	if (b < 0)
-		ub = -(u_quad_t)b, neg ^= 1;
-	else
-		ub = b;
-	uq = __qdivrem(ua, ub, (u_quad_t *)0);
-	return (neg ? -uq : uq);
-}
-
-/*
- * Shift an (unsigned) quad value right (logical shift right).
- */
-quad_t
-__lshrdi3(a, shift)
-	quad_t a;
-	qshift_t shift;
-{
-	union uu aa;
-
-	aa.q = a;
-	if (shift >= LONG_BITS) {
-		aa.ul[L] = shift >= QUAD_BITS ? 0 :
-		    aa.ul[H] >> (shift - LONG_BITS);
-		aa.ul[H] = 0;
-	} else if (shift > 0) {
-		aa.ul[L] = (aa.ul[L] >> shift) |
-		    (aa.ul[H] << (LONG_BITS - shift));
-		aa.ul[H] >>= shift;
-	}
-	return (aa.q);
-}
-
-/*
- * Return remainder after dividing two signed quads.
- *
- * XXX
- * If -1/2 should produce -1 on this machine, this code is wrong.
- */
-quad_t
-__moddi3(a, b)
-	quad_t a, b;
-{
-	u_quad_t ua, ub, ur;
-	int neg;
-
-	if (a < 0)
-		ua = -(u_quad_t)a, neg = 1;
-	else
-		ua = a, neg = 0;
-	if (b < 0)
-		ub = -(u_quad_t)b;
-	else
-		ub = b;
-	(void)__qdivrem(ua, ub, &ur);
-	return (neg ? -ur : ur);
-}
-
-
-/*
- * Multiprecision divide.  This algorithm is from Knuth vol. 2 (2nd ed),
- * section 4.3.1, pp. 257--259.
- */
-
-#define	B	(1 << HALF_BITS)	/* digit base */
-
-/* Combine two `digits' to make a single two-digit number. */
-#define	COMBINE(a, b) (((u_long)(a) << HALF_BITS) | (b))
-
-/* select a type for digits in base B: use unsigned short if they fit */
-#if ULONG_MAX == 0xffffffff && USHRT_MAX >= 0xffff
-typedef unsigned short digit;
-#else
-typedef u_long digit;
-#endif
-
-/*
- * Shift p[0]..p[len] left `sh' bits, ignoring any bits that
- * `fall out' the left (there never will be any such anyway).
- * We may assume len >= 0.  NOTE THAT THIS WRITES len+1 DIGITS.
- */
-static void
-__shl(register digit *p, register int len, register int sh)
-{
-	register int i;
-
-	for (i = 0; i < len; i++)
-		p[i] = LHALF(p[i] << sh) | (p[i + 1] >> (HALF_BITS - sh));
-	p[i] = LHALF(p[i] << sh);
-}
-
-/*
- * __qdivrem(u, v, rem) returns u/v and, optionally, sets *rem to u%v.
- *
- * We do this in base 2-sup-HALF_BITS, so that all intermediate products
- * fit within u_long.  As a consequence, the maximum length dividend and
- * divisor are 4 `digits' in this base (they are shorter if they have
- * leading zeros).
- */
-u_quad_t
-__qdivrem(uq, vq, arq)
-	u_quad_t uq, vq, *arq;
-{
-	union uu tmp;
-	digit *u, *v, *q;
-	register digit v1, v2;
-	u_long qhat, rhat, t;
-	int m, n, d, j, i;
-	digit uspace[5], vspace[5], qspace[5];
-
-	/*
-	 * Take care of special cases: divide by zero, and u < v.
-	 */
-	if (vq == 0) {
-		/* divide by zero. */
-		static volatile const unsigned int zero = 0;
-
-		tmp.ul[H] = tmp.ul[L] = 1 / zero;
-		if (arq)
-			*arq = uq;
-		return (tmp.q);
-	}
-	if (uq < vq) {
-		if (arq)
-			*arq = uq;
-		return (0);
-	}
-	u = &uspace[0];
-	v = &vspace[0];
-	q = &qspace[0];
-
-	/*
-	 * Break dividend and divisor into digits in base B, then
-	 * count leading zeros to determine m and n.  When done, we
-	 * will have:
-	 *	u = (u[1]u[2]...u[m+n]) sub B
-	 *	v = (v[1]v[2]...v[n]) sub B
-	 *	v[1] != 0
-	 *	1 < n <= 4 (if n = 1, we use a different division algorithm)
-	 *	m >= 0 (otherwise u < v, which we already checked)
-	 *	m + n = 4
-	 * and thus
-	 *	m = 4 - n <= 2
-	 */
-	tmp.uq = uq;
-	u[0] = 0;
-	u[1] = HHALF(tmp.ul[H]);
-	u[2] = LHALF(tmp.ul[H]);
-	u[3] = HHALF(tmp.ul[L]);
-	u[4] = LHALF(tmp.ul[L]);
-	tmp.uq = vq;
-	v[1] = HHALF(tmp.ul[H]);
-	v[2] = LHALF(tmp.ul[H]);
-	v[3] = HHALF(tmp.ul[L]);
-	v[4] = LHALF(tmp.ul[L]);
-	for (n = 4; v[1] == 0; v++) {
-		if (--n == 1) {
-			u_long rbj;	/* r*B+u[j] (not root boy jim) */
-			digit q1, q2, q3, q4;
-
-			/*
-			 * Change of plan, per exercise 16.
-			 *	r = 0;
-			 *	for j = 1..4:
-			 *		q[j] = floor((r*B + u[j]) / v),
-			 *		r = (r*B + u[j]) % v;
-			 * We unroll this completely here.
-			 */
-			t = v[2];	/* nonzero, by definition */
-			q1 = u[1] / t;
-			rbj = COMBINE(u[1] % t, u[2]);
-			q2 = rbj / t;
-			rbj = COMBINE(rbj % t, u[3]);
-			q3 = rbj / t;
-			rbj = COMBINE(rbj % t, u[4]);
-			q4 = rbj / t;
-			if (arq)
-				*arq = rbj % t;
-			tmp.ul[H] = COMBINE(q1, q2);
-			tmp.ul[L] = COMBINE(q3, q4);
-			return (tmp.q);
-		}
-	}
-
-	/*
-	 * By adjusting q once we determine m, we can guarantee that
-	 * there is a complete four-digit quotient at &qspace[1] when
-	 * we finally stop.
-	 */
-	for (m = 4 - n; u[1] == 0; u++)
-		m--;
-	for (i = 4 - m; --i >= 0;)
-		q[i] = 0;
-	q += 4 - m;
-
-	/*
-	 * Here we run Program D, translated from MIX to C and acquiring
-	 * a few minor changes.
-	 *
-	 * D1: choose multiplier 1 << d to ensure v[1] >= B/2.
-	 */
-	d = 0;
-	for (t = v[1]; t < B / 2; t <<= 1)
-		d++;
-	if (d > 0) {
-		__shl(&u[0], m + n, d);		/* u <<= d */
-		__shl(&v[1], n - 1, d);		/* v <<= d */
-	}
-	/*
-	 * D2: j = 0.
-	 */
-	j = 0;
-	v1 = v[1];	/* for D3 -- note that v[1..n] are constant */
-	v2 = v[2];	/* for D3 */
-	do {
-		register digit uj0, uj1, uj2;
-
-		/*
-		 * D3: Calculate qhat (\^q, in TeX notation).
-		 * Let qhat = min((u[j]*B + u[j+1])/v[1], B-1), and
-		 * let rhat = (u[j]*B + u[j+1]) mod v[1].
-		 * While rhat < B and v[2]*qhat > rhat*B+u[j+2],
-		 * decrement qhat and increase rhat correspondingly.
-		 * Note that if rhat >= B, v[2]*qhat < rhat*B.
-		 */
-		uj0 = u[j + 0];	/* for D3 only -- note that u[j+...] change */
-		uj1 = u[j + 1];	/* for D3 only */
-		uj2 = u[j + 2];	/* for D3 only */
-		if (uj0 == v1) {
-			qhat = B;
-			rhat = uj1;
-			goto qhat_too_big;
-		} else {
-			u_long nn = COMBINE(uj0, uj1);
-			qhat = nn / v1;
-			rhat = nn % v1;
-		}
-		while (v2 * qhat > COMBINE(rhat, uj2)) {
-	qhat_too_big:
-			qhat--;
-			if ((rhat += v1) >= B)
-				break;
-		}
-		/*
-		 * D4: Multiply and subtract.
-		 * The variable `t' holds any borrows across the loop.
-		 * We split this up so that we do not require v[0] = 0,
-		 * and to eliminate a final special case.
-		 */
-		for (t = 0, i = n; i > 0; i--) {
-			t = u[i + j] - v[i] * qhat - t;
-			u[i + j] = LHALF(t);
-			t = (B - HHALF(t)) & (B - 1);
-		}
-		t = u[j] - t;
-		u[j] = LHALF(t);
-		/*
-		 * D5: test remainder.
-		 * There is a borrow if and only if HHALF(t) is nonzero;
-		 * in that (rare) case, qhat was too large (by exactly 1).
-		 * Fix it by adding v[1..n] to u[j..j+n].
-		 */
-		if (HHALF(t)) {
-			qhat--;
-			for (t = 0, i = n; i > 0; i--) { /* D6: add back. */
-				t += u[i + j] + v[i];
-				u[i + j] = LHALF(t);
-				t = HHALF(t);
-			}
-			u[j] = LHALF(u[j] + t);
-		}
-		q[j] = qhat;
-	} while (++j <= m);		/* D7: loop on j. */
-
-	/*
-	 * If caller wants the remainder, we have to calculate it as
-	 * u[m..m+n] >> d (this is at most n digits and thus fits in
-	 * u[m+1..m+n], but we may need more source digits).
-	 */
-	if (arq) {
-		if (d) {
-			for (i = m + n; i > m; --i)
-				u[i] = (u[i] >> d) |
-				    LHALF(u[i - 1] << (HALF_BITS - d));
-			u[i] = 0;
-		}
-		tmp.ul[H] = COMBINE(uspace[1], uspace[2]);
-		tmp.ul[L] = COMBINE(uspace[3], uspace[4]);
-		*arq = tmp.q;
-	}
-
-	tmp.ul[H] = COMBINE(qspace[1], qspace[2]);
-	tmp.ul[L] = COMBINE(qspace[3], qspace[4]);
-	return (tmp.q);
-}
-
-/*
- * Return 0, 1, or 2 as a <, =, > b respectively.
- * Neither a nor b are considered signed.
- */
-int
-__ucmpdi2(a, b)
-	u_quad_t a, b;
-{
-	union uu aa, bb;
-
-	aa.uq = a;
-	bb.uq = b;
-	return (aa.ul[H] < bb.ul[H] ? 0 : aa.ul[H] > bb.ul[H] ? 2 :
-	    aa.ul[L] < bb.ul[L] ? 0 : aa.ul[L] > bb.ul[L] ? 2 : 1);
-}
-
-/*
- * Divide two unsigned quads.
- */
-u_quad_t
-__udivdi3(a, b)
-	u_quad_t a, b;
-{
-
-	return (__qdivrem(a, b, (u_quad_t *)0));
-}
-
-/*
- * Return remainder after dividing two unsigned quads.
- */
-u_quad_t
-__umoddi3(a, b)
-	u_quad_t a, b;
-{
-	u_quad_t r;
-
-	(void)__qdivrem(a, b, &r);
-	return (r);
-}
-
-/*
- * Divide two signed quads.
- * This function is new in GCC 7.
- */
-quad_t
-__divmoddi4(a, b, rem)
-	quad_t a, b, *rem;
-{
-	u_quad_t ua, ub, uq, ur;
-	int negq, negr;
-
-	if (a < 0)
-		ua = -(u_quad_t)a, negq = 1, negr = 1;
-	else
-		ua = a, negq = 0, negr = 0;
-	if (b < 0)
-		ub = -(u_quad_t)b, negq ^= 1;
-	else
-		ub = b;
-	uq = __qdivrem(ua, ub, &ur);
-	if (rem)
-		*rem = (negr ? -ur : ur);
-	return (negq ? -uq : uq);
-}
-
-u_quad_t
-__udivmoddi4(u_quad_t a, u_quad_t b, u_quad_t *rem)
-{
-  return __qdivrem(a, b, rem);
-}
-
-#else
-static int __attribute__((unused)) dummy;
-#endif /*deined (_X86_) && !defined (__x86_64__)*/
-
diff --git a/thirdparty/winpthreads/src/misc.c b/thirdparty/winpthreads/src/misc.c
deleted file mode 100644
index 16ed488e..00000000
--- a/thirdparty/winpthreads/src/misc.c
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#include "pthread.h"
-#include "windows.h"
-#include "misc.h"
-
-unsigned long long _pthread_time_in_ms(void)
-{
-    FILETIME ft;
-
-    GetSystemTimeAsFileTime(&ft);
-    return (((unsigned long long)ft.dwHighDateTime << 32) + ft.dwLowDateTime
-            - 0x19DB1DED53E8000ULL) / 10000ULL;
-}
-
-unsigned long long _pthread_time_in_ms_from_timespec(const struct timespec *ts)
-{
-    unsigned long long t = (unsigned long long) ts->tv_sec * 1000LL;
-    /* The +999999 is here to ensure that the division always rounds up */
-    t += (unsigned long long) (ts->tv_nsec + 999999) / 1000000;
-
-    return t;
-}
-
-unsigned long long _pthread_rel_time_in_ms(const struct timespec *ts)
-{
-    unsigned long long t1 = _pthread_time_in_ms_from_timespec(ts);
-    unsigned long long t2 = _pthread_time_in_ms();
-
-    /* Prevent underflow */
-    if (t1 < t2) return 0;
-    return t1 - t2;
-}
-
-static unsigned long long
-_pthread_get_tick_count (long long *frequency)
-{
-#if defined (_WIN32_WINNT) && (_WIN32_WINNT >= _WIN32_WINNT_VISTA)
-  (void) frequency; /* unused */
-  return GetTickCount64 ();
-#else
-  LARGE_INTEGER freq, timestamp;
-
-  if (*frequency == 0)
-  {
-    if (QueryPerformanceFrequency (&freq))
-      *frequency = freq.QuadPart;
-    else
-      *frequency = -1;
-  }
-
-  if (*frequency > 0 && QueryPerformanceCounter (&timestamp))
-    return timestamp.QuadPart / (*frequency / 1000);
-
-  /* Fallback */
-  return GetTickCount ();
-#endif
-}
-
-/* A wrapper around WaitForSingleObject() that ensures that
- * the wait function does not time out before the time
- * actually runs out. This is needed because WaitForSingleObject()
- * might have poor accuracy, returning earlier than expected.
- * On the other hand, returning a bit *later* than expected
- * is acceptable in a preemptive multitasking environment.
- */
-unsigned long
-_pthread_wait_for_single_object (void *handle, unsigned long timeout)
-{
-  DWORD result;
-  unsigned long long start_time, end_time;
-  unsigned long wait_time;
-  long long frequency = 0;
-
-  if (timeout == INFINITE || timeout == 0)
-    return WaitForSingleObject ((HANDLE) handle, (DWORD) timeout);
-
-  start_time = _pthread_get_tick_count (&frequency);
-  end_time = start_time + timeout;
-  wait_time = timeout;
-
-  do
-  {
-    unsigned long long current_time;
-
-    result = WaitForSingleObject ((HANDLE) handle, (DWORD) wait_time);
-    if (result != WAIT_TIMEOUT)
-      break;
-
-    current_time = _pthread_get_tick_count (&frequency);
-    if (current_time >= end_time)
-      break;
-
-    wait_time = (DWORD) (end_time - current_time);
-  } while (TRUE);
-
-  return result;
-}
-
-/* A wrapper around WaitForMultipleObjects() that ensures that
- * the wait function does not time out before the time
- * actually runs out. This is needed because WaitForMultipleObjects()
- * might have poor accuracy, returning earlier than expected.
- * On the other hand, returning a bit *later* than expected
- * is acceptable in a preemptive multitasking environment.
- */
-unsigned long
-_pthread_wait_for_multiple_objects (unsigned long count, void **handles, unsigned int all, unsigned long timeout)
-{
-  DWORD result;
-  unsigned long long start_time, end_time;
-  unsigned long wait_time;
-  long long frequency = 0;
-
-  if (timeout == INFINITE || timeout == 0)
-    return WaitForMultipleObjects ((DWORD) count, (HANDLE *) handles, all, (DWORD) timeout);
-
-  start_time = _pthread_get_tick_count (&frequency);
-  end_time = start_time + timeout;
-  wait_time = timeout;
-
-  do
-  {
-    unsigned long long current_time;
-
-    result = WaitForMultipleObjects ((DWORD) count, (HANDLE *) handles, all, (DWORD) wait_time);
-    if (result != WAIT_TIMEOUT)
-      break;
-
-    current_time = _pthread_get_tick_count (&frequency);
-    if (current_time >= end_time)
-      break;
-
-    wait_time = (DWORD) (end_time - current_time);
-  } while (TRUE);
-
-  return result;
-}
diff --git a/thirdparty/winpthreads/src/misc.h b/thirdparty/winpthreads/src/misc.h
deleted file mode 100644
index cdb24268..00000000
--- a/thirdparty/winpthreads/src/misc.h
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef WIN_PTHREADS_MISC_H
-#define WIN_PTHREADS_MISC_H
-
-#include "pthread_compat.h"
-
-#ifndef assert
-
-#ifndef ASSERT_TRACE
-# define ASSERT_TRACE 0
-#else
-# undef ASSERT_TRACE
-# define ASSERT_TRACE 0
-#endif
-
-# define assert(e) \
-   ((e) ? ((ASSERT_TRACE) ? fprintf(stderr, \
-                                    "Assertion succeeded: (%s), file %s, line %d\n", \
-                        #e, __FILE__, (int) __LINE__), \
-                                fflush(stderr) : \
-                             0) : \
-          (fprintf(stderr, "Assertion failed: (%s), file %s, line %d\n", \
-                   #e, __FILE__, (int) __LINE__), exit(1), 0))
-
-# define fixme(e) \
-   ((e) ? ((ASSERT_TRACE) ? fprintf(stderr, \
-                                    "Assertion succeeded: (%s), file %s, line %d\n", \
-                        #e, __FILE__, (int) __LINE__), \
-                                fflush(stderr) : \
-                             0) : \
-          (fprintf(stderr, "FIXME: (%s), file %s, line %d\n", \
-                   #e, __FILE__, (int) __LINE__), 0, 0))
-
-#endif
-
-#define PTR2INT(x)	((int)(uintptr_t)(x))
-
-#if SIZE_MAX>UINT_MAX
-typedef long long LONGBAG;
-#else
-typedef long LONGBAG;
-#endif
-
-#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-#undef GetHandleInformation
-#define GetHandleInformation(h,f)  (1)
-#endif
-
-#define CHECK_HANDLE(h) { DWORD dwFlags; \
-    if (!(h) || ((h) == INVALID_HANDLE_VALUE) || !GetHandleInformation((h), &dwFlags)) \
-    return EINVAL; }
-
-#define CHECK_PTR(p)    if (!(p)) return EINVAL;
-
-#define UPD_RESULT(x,r)    { int _r=(x); r = r ? r : _r; }
-
-#define CHECK_THREAD(t)  { \
-    CHECK_PTR(t); \
-    CHECK_HANDLE(t->h); }
-
-#define CHECK_OBJECT(o, e)  { DWORD dwFlags; \
-    if (!(o)) return e; \
-    if (!((o)->h) || (((o)->h) == INVALID_HANDLE_VALUE) || !GetHandleInformation(((o)->h), &dwFlags)) \
-        return e; }
-
-#define VALID(x)    if (!(p)) return EINVAL;
-
-/* ms can be 64 bit, solve wrap-around issues: */
-static WINPTHREADS_INLINE unsigned long dwMilliSecs(unsigned long long ms)
-{
-  if (ms >= 0xffffffffULL) return 0xfffffffful;
-  return (unsigned long) ms;
-}
-
-#ifndef _mm_pause
-#define _mm_pause()			{__asm__ __volatile__("pause");}
-#endif
-
-#ifndef _ReadWriteBarrier
-#define _ReadWriteBarrier   __sync_synchronize
-#endif
-
-#ifndef YieldProcessor
-#define YieldProcessor      _mm_pause
-#endif
-
-unsigned long long _pthread_time_in_ms(void);
-unsigned long long _pthread_time_in_ms_from_timespec(const struct timespec *ts);
-unsigned long long _pthread_rel_time_in_ms(const struct timespec *ts);
-unsigned long _pthread_wait_for_single_object (void *handle, unsigned long timeout);
-unsigned long _pthread_wait_for_multiple_objects (unsigned long count, void **handles, unsigned int all, unsigned long timeout);
-
-#endif
diff --git a/thirdparty/winpthreads/src/mutex.c b/thirdparty/winpthreads/src/mutex.c
deleted file mode 100644
index c6f26139..00000000
--- a/thirdparty/winpthreads/src/mutex.c
+++ /dev/null
@@ -1,385 +0,0 @@
-/*
-   Copyright (c) 2011, 2014 mingw-w64 project
-   Copyright (c) 2015 Intel Corporation
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#include <windows.h>
-#include <stdio.h>
-#include <malloc.h>
-#include <stdbool.h>
-#include "pthread.h"
-#include "misc.h"
-
-typedef enum {
-  Unlocked,        /* Not locked. */
-  Locked,          /* Locked but without waiters. */
-  Waiting,         /* Locked, may have waiters. */
-} mutex_state_t;
-
-typedef enum {
-  Normal,
-  Errorcheck,
-  Recursive,
-} mutex_type_t;
-
-/* The heap-allocated part of a mutex. */
-typedef struct {
-  mutex_state_t state;
-  mutex_type_t type;
-  HANDLE event;       /* Auto-reset event, or NULL if not yet allocated. */
-  unsigned rec_lock;  /* For recursive mutexes, the number of times the
-                         mutex has been locked in excess by the same thread. */
-  volatile DWORD owner;  /* For recursive and error-checking mutexes, the
-                            ID of the owning thread if the mutex is locked. */
-} mutex_impl_t;
-
-/* Whether a mutex is still a static initializer (not a pointer to
-   a mutex_impl_t). */
-static bool
-is_static_initializer(pthread_mutex_t m)
-{
-  /* Treat 0 as a static initializer as well (for normal mutexes),
-     to tolerate sloppy code in libgomp. (We should rather fix that code!) */
-  intptr_t v = (intptr_t)m;
-  return v >= -3 && v <= 0;
-/* Should be simple:
-  return (uintptr_t)m >= (uintptr_t)-3; */
-}
-
-/* Create and return the implementation part of a mutex from a static
-   initialiser. Return NULL on out-of-memory error. */
-static WINPTHREADS_ATTRIBUTE((noinline)) mutex_impl_t *
-mutex_impl_init(pthread_mutex_t *m, mutex_impl_t *mi)
-{
-  mutex_impl_t *new_mi = malloc(sizeof(mutex_impl_t));
-  if (new_mi == NULL)
-    return NULL;
-  new_mi->state = Unlocked;
-  new_mi->type = (mi == (void *)PTHREAD_RECURSIVE_MUTEX_INITIALIZER ? Recursive
-                  : mi == (void *)PTHREAD_ERRORCHECK_MUTEX_INITIALIZER ? Errorcheck
-                  : Normal);
-  new_mi->event = NULL;
-  new_mi->rec_lock = 0;
-  new_mi->owner = (DWORD)-1;
-  if (__sync_bool_compare_and_swap(m, (pthread_mutex_t)mi, (pthread_mutex_t)new_mi)) {
-    return new_mi;
-  } else {
-    /* Someone created the struct before us. */
-    free(new_mi);
-    return (mutex_impl_t *)*m;
-  }
-}
-
-#define likely(cond) __builtin_expect((cond) != 0, 1)
-#define unlikely(cond) __builtin_expect((cond) != 0, 0)
-
-/* Return the implementation part of a mutex, creating it if necessary.
-   Return NULL on out-of-memory error. */
-static inline mutex_impl_t *
-mutex_impl(pthread_mutex_t *m)
-{
-  mutex_impl_t *mi = (mutex_impl_t *)*m;
-  if (is_static_initializer((pthread_mutex_t)mi)) {
-    return mutex_impl_init(m, mi);
-  } else {
-    /* mi cannot be null here; avoid a test in the fast path. */
-    if (mi == NULL)
-      __builtin_unreachable();
-    return mi;
-  }
-}
-
-/* Lock a mutex. Give up after 'timeout' ms (with ETIMEDOUT),
-   or never if timeout=INFINITE. */
-static inline int
-pthread_mutex_lock_intern (pthread_mutex_t *m, DWORD timeout)
-{
-  mutex_impl_t *mi = mutex_impl(m);
-  if (mi == NULL)
-    return ENOMEM;
-
-  mutex_state_t old_state = __sync_lock_test_and_set(&mi->state, Locked);
-  if (unlikely(old_state != Unlocked)) {
-    /* The mutex is already locked. */
-
-    if (mi->type != Normal) {
-      /* Recursive or Errorcheck */
-      if (mi->owner == GetCurrentThreadId()) {
-        /* FIXME: A recursive mutex should not need two atomic ops when locking
-           recursively.  We could rewrite by doing compare-and-swap instead of
-           test-and-set the first time, but it would lead to more code
-           duplication and add a conditional branch to the critical path. */
-        __sync_bool_compare_and_swap(&mi->state, Locked, old_state);
-        if (mi->type == Recursive) {
-          mi->rec_lock++;
-          return 0;
-        } else {
-          /* type == Errorcheck */
-          return EDEADLK;
-        }
-      }
-    }
-
-    /* Make sure there is an event object on which to wait. */
-    if (mi->event == NULL) {
-      /* Make an auto-reset event object. */
-      HANDLE ev = CreateEvent(NULL, false, false, NULL);
-      if (ev == NULL) {
-        switch (GetLastError()) {
-        case ERROR_ACCESS_DENIED:
-          return EPERM;
-        default:
-          return ENOMEM;    /* Probably accurate enough. */
-        }
-      }
-      if (!__sync_bool_compare_and_swap(&mi->event, NULL, ev)) {
-        /* Someone created the event before us. */
-        CloseHandle(ev);
-      }
-    }
-
-    /* At this point, mi->event is non-NULL. */
-
-    while (__sync_lock_test_and_set(&mi->state, Waiting) != Unlocked) {
-      /* For timed locking attempts, it is possible (although unlikely)
-         that we are woken up but someone else grabs the lock before us,
-         and we have to go back to sleep again. In that case, the total
-         wait may be longer than expected. */
-
-      unsigned r = _pthread_wait_for_single_object(mi->event, timeout);
-      switch (r) {
-      case WAIT_TIMEOUT:
-        return ETIMEDOUT;
-      case WAIT_OBJECT_0:
-        break;
-      default:
-        return EINVAL;
-      }
-    }
-  }
-
-  if (mi->type != Normal)
-    mi->owner = GetCurrentThreadId();
-
-  return 0;
-}
-
-int
-pthread_mutex_lock (pthread_mutex_t *m)
-{
-  return pthread_mutex_lock_intern (m, INFINITE);
-}
-
-int pthread_mutex_timedlock(pthread_mutex_t *m, const struct timespec *ts)
-{
-  unsigned long long patience;
-  if (ts != NULL) {
-    unsigned long long end = _pthread_time_in_ms_from_timespec(ts);
-    unsigned long long now = _pthread_time_in_ms();
-    patience = end > now ? end - now : 0;
-    if (patience > 0xffffffff)
-      patience = INFINITE;
-  } else {
-    patience = INFINITE;
-  }
-  return pthread_mutex_lock_intern(m, patience);
-}
-
-int pthread_mutex_unlock(pthread_mutex_t *m)
-{    
-  /* Here m might an initialiser of an error-checking or recursive mutex, in
-     which case the behaviour is well-defined, so we can't skip this check. */
-  mutex_impl_t *mi = mutex_impl(m);
-  if (mi == NULL)
-    return ENOMEM;
-
-  if (unlikely(mi->type != Normal)) {
-    if (mi->state == Unlocked)
-      return EINVAL;
-    if (mi->owner != GetCurrentThreadId())
-      return EPERM;
-    if (mi->rec_lock > 0) {
-      mi->rec_lock--;
-      return 0;
-    }
-    mi->owner = (DWORD)-1;
-  }
-  if (unlikely(__sync_lock_test_and_set(&mi->state, Unlocked) == Waiting)) {
-    if (!SetEvent(mi->event))
-      return EPERM;
-  }
-  return 0;
-}
-
-int pthread_mutex_trylock(pthread_mutex_t *m)
-{
-  mutex_impl_t *mi = mutex_impl(m);
-  if (mi == NULL)
-    return ENOMEM;
-
-  if (__sync_bool_compare_and_swap(&mi->state, Unlocked, Locked)) {
-    if (mi->type != Normal)
-      mi->owner = GetCurrentThreadId();
-    return 0;
-  } else {
-    if (mi->type == Recursive && mi->owner == GetCurrentThreadId()) {
-      mi->rec_lock++;
-      return 0;
-    }
-    return EBUSY;
-  }
-}
-
-int
-pthread_mutex_init (pthread_mutex_t *m, const pthread_mutexattr_t *a)
-{
-  pthread_mutex_t init = PTHREAD_MUTEX_INITIALIZER;
-  if (a != NULL) {
-    int pshared;
-    if (pthread_mutexattr_getpshared(a, &pshared) == 0
-        && pshared == PTHREAD_PROCESS_SHARED)
-      return ENOSYS;
-
-    int type;
-    if (pthread_mutexattr_gettype(a, &type) == 0) {
-      switch (type) {
-      case PTHREAD_MUTEX_ERRORCHECK:
-        init = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER;
-        break;
-      case PTHREAD_MUTEX_RECURSIVE:
-        init = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
-        break;
-      default:
-        init = PTHREAD_MUTEX_INITIALIZER;
-        break;
-      }
-    }
-  }
-  *m = init;
-  return 0;
-}
-
-int pthread_mutex_destroy (pthread_mutex_t *m)
-{
-  mutex_impl_t *mi = (mutex_impl_t *)*m;
-  if (!is_static_initializer((pthread_mutex_t)mi)) {
-    if (mi->event != NULL)
-      CloseHandle(mi->event);
-    free(mi);
-    /* Sabotage attempts to re-use the mutex before initialising it again. */
-    *m = (pthread_mutex_t)NULL;
-  }
-
-  return 0;
-}
-
-int pthread_mutexattr_init(pthread_mutexattr_t *a)
-{
-  *a = PTHREAD_MUTEX_NORMAL | (PTHREAD_PROCESS_PRIVATE << 3);
-  return 0;
-}
-
-int pthread_mutexattr_destroy(pthread_mutexattr_t *a)
-{
-  if (!a)
-    return EINVAL;
-
-  return 0;
-}
-
-int pthread_mutexattr_gettype(const pthread_mutexattr_t *a, int *type)
-{
-  if (!a || !type)
-    return EINVAL;
-	
-  *type = *a & 3;
-  
-  return 0;
-}
-
-int pthread_mutexattr_settype(pthread_mutexattr_t *a, int type)
-{
-    if (!a || (type != PTHREAD_MUTEX_NORMAL && type != PTHREAD_MUTEX_RECURSIVE && type != PTHREAD_MUTEX_ERRORCHECK))
-      return EINVAL;
-    *a &= ~3;
-    *a |= type;
-
-    return 0;
-}
-
-int pthread_mutexattr_getpshared(const pthread_mutexattr_t *a, int *type)
-{
-    if (!a || !type)
-      return EINVAL;
-    *type = (*a & 4 ? PTHREAD_PROCESS_SHARED : PTHREAD_PROCESS_PRIVATE);
-
-    return 0;
-}
-
-int pthread_mutexattr_setpshared(pthread_mutexattr_t * a, int type)
-{
-    int r = 0;
-    if (!a || (type != PTHREAD_PROCESS_SHARED
-	&& type != PTHREAD_PROCESS_PRIVATE))
-      return EINVAL;
-    if (type == PTHREAD_PROCESS_SHARED)
-    {
-      type = PTHREAD_PROCESS_PRIVATE;
-      r = ENOSYS;
-    }
-    type = (type == PTHREAD_PROCESS_SHARED ? 4 : 0);
-
-    *a &= ~4;
-    *a |= type;
-
-    return r;
-}
-
-int pthread_mutexattr_getprotocol(const pthread_mutexattr_t *a, int *type)
-{
-    *type = *a & (8 + 16);
-
-    return 0;
-}
-
-int pthread_mutexattr_setprotocol(pthread_mutexattr_t *a, int type)
-{
-    if ((type & (8 + 16)) != 8 + 16) return EINVAL;
-
-    *a &= ~(8 + 16);
-    *a |= type;
-
-    return 0;
-}
-
-int pthread_mutexattr_getprioceiling(const pthread_mutexattr_t *a, int * prio)
-{
-    *prio = *a / PTHREAD_PRIO_MULT;
-    return 0;
-}
-
-int pthread_mutexattr_setprioceiling(pthread_mutexattr_t *a, int prio)
-{
-    *a &= (PTHREAD_PRIO_MULT - 1);
-    *a += prio * PTHREAD_PRIO_MULT;
-
-    return 0;
-}
diff --git a/thirdparty/winpthreads/src/nanosleep.c b/thirdparty/winpthreads/src/nanosleep.c
deleted file mode 100644
index 0cce4492..00000000
--- a/thirdparty/winpthreads/src/nanosleep.c
+++ /dev/null
@@ -1,71 +0,0 @@
-/**
- * This file has no copyright assigned and is placed in the Public Domain.
- * This file is part of the w64 mingw-runtime package.
- * No warranty is given; refer to the file DISCLAIMER.PD within this package.
- */
-
-#include <errno.h>
-#include <time.h>
-#include <windows.h>
-#include "pthread.h"
-#include "pthread_time.h"
-#include "winpthread_internal.h"
-
-#define POW10_3                 1000
-#define POW10_4                 10000
-#define POW10_6                 1000000
-#define POW10_9                 1000000000
-#define MAX_SLEEP_IN_MS         4294967294UL
-
-/**
- * Sleep for the specified time.
- * @param  request The desired amount of time to sleep.
- * @param  remain The remain amount of time to sleep.
- * @return If the function succeeds, the return value is 0.
- *         If the function fails, the return value is -1,
- *         with errno set to indicate the error.
- */
-int nanosleep(const struct timespec *request, struct timespec *remain)
-{
-    unsigned long ms, rc = 0;
-    unsigned __int64 u64, want, real;
-
-    union {
-        unsigned __int64 ns100;
-        FILETIME ft;
-    }  _start, _end;
-
-    if (request->tv_sec < 0 || request->tv_nsec < 0 || request->tv_nsec >= POW10_9) {
-        errno = EINVAL;
-        return -1;
-    }
-
-    if (remain != NULL) GetSystemTimeAsFileTime(&_start.ft);
-
-    want = u64 = request->tv_sec * POW10_3 + request->tv_nsec / POW10_6;
-    while (u64 > 0 && rc == 0) {
-        if (u64 >= MAX_SLEEP_IN_MS) ms = MAX_SLEEP_IN_MS;
-        else ms = (unsigned long) u64;
-
-        u64 -= ms;
-        rc = pthread_delay_np_ms(ms);
-    }
-
-    if (rc != 0) { /* WAIT_IO_COMPLETION (192) */
-        if (remain != NULL) {
-            GetSystemTimeAsFileTime(&_end.ft);
-            real = (_end.ns100 - _start.ns100) / POW10_4;
-
-            if (real >= want) u64 = 0;
-            else u64 = want - real;
-
-            remain->tv_sec = u64 / POW10_3;
-            remain->tv_nsec = (long) (u64 % POW10_3) * POW10_6;
-        }
-
-        errno = EINTR;
-        return -1;
-    }
-
-    return 0;
-}
diff --git a/thirdparty/winpthreads/src/ref.c b/thirdparty/winpthreads/src/ref.c
deleted file mode 100644
index 0344d457..00000000
--- a/thirdparty/winpthreads/src/ref.c
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#include <windows.h>
-#include <winternl.h>
-#include <stdio.h>
-#include "pthread.h"
-#include "semaphore.h"
-#include "rwlock.h"
-#include "cond.h"
-#include "barrier.h"
-#include "sem.h"
-#include "ref.h"
-#include "misc.h"
-
diff --git a/thirdparty/winpthreads/src/ref.h b/thirdparty/winpthreads/src/ref.h
deleted file mode 100644
index 5ca67506..00000000
--- a/thirdparty/winpthreads/src/ref.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef WIN_PTHREADS_REF_H
-#define WIN_PTHREADS_REF_H
-#include "pthread.h"
-#include "semaphore.h"
-
-#endif
-
diff --git a/thirdparty/winpthreads/src/rwlock.c b/thirdparty/winpthreads/src/rwlock.c
deleted file mode 100644
index 933d4388..00000000
--- a/thirdparty/winpthreads/src/rwlock.c
+++ /dev/null
@@ -1,533 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#include <windows.h>
-#include <stdio.h>
-#include <malloc.h>
-#include "pthread.h"
-#include "thread.h"
-#include "ref.h"
-#include "rwlock.h"
-#include "misc.h"
-
-static pthread_spinlock_t rwl_global = PTHREAD_SPINLOCK_INITIALIZER;
-
-static WINPTHREADS_ATTRIBUTE((noinline)) int rwlock_static_init(pthread_rwlock_t *rw);
-
-static WINPTHREADS_ATTRIBUTE((noinline)) int rwl_unref(volatile pthread_rwlock_t *rwl, int res)
-{
-    pthread_spin_lock(&rwl_global);
-#ifdef WINPTHREAD_DBG
-    assert((((rwlock_t *)*rwl)->valid == LIFE_RWLOCK) && (((rwlock_t *)*rwl)->busy > 0));
-#endif
-     ((rwlock_t *)*rwl)->busy--;
-    pthread_spin_unlock(&rwl_global);
-    return res;
-}
-
-static WINPTHREADS_ATTRIBUTE((noinline)) int rwl_ref(pthread_rwlock_t *rwl, int f )
-{
-    int r = 0;
-    INIT_RWLOCK(rwl);
-    pthread_spin_lock(&rwl_global);
-
-    if (!rwl || !*rwl || ((rwlock_t *)*rwl)->valid != LIFE_RWLOCK) r = EINVAL;
-    else {
-        ((rwlock_t *)*rwl)->busy ++;
-    }
-
-    pthread_spin_unlock(&rwl_global);
-
-    return r;
-}
-
-static WINPTHREADS_ATTRIBUTE((noinline)) int rwl_ref_unlock(pthread_rwlock_t *rwl )
-{
-    int r = 0;
-
-    pthread_spin_lock(&rwl_global);
-
-    if (!rwl || !*rwl || ((rwlock_t *)*rwl)->valid != LIFE_RWLOCK) r = EINVAL;
-    else if (STATIC_RWL_INITIALIZER(*rwl)) r= EPERM;
-    else {
-        ((rwlock_t *)*rwl)->busy ++;
-    }
-
-    pthread_spin_unlock(&rwl_global);
-
-    return r;
-}
-
-static WINPTHREADS_ATTRIBUTE((noinline)) int rwl_ref_destroy(pthread_rwlock_t *rwl, pthread_rwlock_t *rDestroy )
-{
-    int r = 0;
-
-    *rDestroy = (pthread_rwlock_t)NULL;
-    pthread_spin_lock(&rwl_global);
-    
-    if (!rwl || !*rwl) r = EINVAL;
-    else {
-        rwlock_t *r_ = (rwlock_t *)*rwl;
-        if (STATIC_RWL_INITIALIZER(*rwl)) *rwl = (pthread_rwlock_t)NULL;
-        else if (r_->valid != LIFE_RWLOCK) r = EINVAL;
-        else if (r_->busy) r = EBUSY;
-        else {
-            *rDestroy = *rwl;
-            *rwl = (pthread_rwlock_t)NULL;
-        }
-    }
-
-    pthread_spin_unlock(&rwl_global);
-    return r;
-}
-
-static int rwlock_gain_both_locks(rwlock_t *rwlock)
-{
-  int ret;
-  ret = pthread_mutex_lock(&rwlock->mex);
-  if (ret != 0)
-    return ret;
-  ret = pthread_mutex_lock(&rwlock->mcomplete);
-  if (ret != 0)
-    pthread_mutex_unlock(&rwlock->mex);
-  return ret;
-}
-
-static int rwlock_free_both_locks(rwlock_t *rwlock, int last_fail)
-{
-  int ret, ret2;
-  ret = pthread_mutex_unlock(&rwlock->mcomplete);
-  ret2 = pthread_mutex_unlock(&rwlock->mex);
-  if (last_fail && ret2 != 0)
-    ret = ret2;
-  else if (!last_fail && !ret)
-    ret = ret2;
-  return ret;
-}
-
-#ifdef WINPTHREAD_DBG
-static int print_state = 0;
-void rwl_print_set(int state)
-{
-    print_state = state;
-}
-
-void rwl_print(volatile pthread_rwlock_t *rwl, char *txt)
-{
-    if (!print_state) return;
-    rwlock_t *r = (rwlock_t *)*rwl;
-    if (r == NULL) {
-        printf("RWL%p %d %s\n",(void *)*rwl,(int)GetCurrentThreadId(),txt);
-    } else {
-        printf("RWL%p %d V=%0X B=%d r=%ld w=%ld L=%p %s\n",
-            (void *)*rwl,
-            (int)GetCurrentThreadId(), 
-            (int)r->valid, 
-            (int)r->busy,
-            0L,0L,NULL,txt);
-    }
-}
-#endif
-
-static pthread_spinlock_t cond_locked = PTHREAD_SPINLOCK_INITIALIZER;
-
-static WINPTHREADS_ATTRIBUTE((noinline)) int rwlock_static_init(pthread_rwlock_t *rw)
-{
-  int r;
-  pthread_spin_lock(&cond_locked);
-  if (*rw != PTHREAD_RWLOCK_INITIALIZER)
-  {
-    pthread_spin_unlock(&cond_locked);
-    return EINVAL;
-  }
-  r = pthread_rwlock_init (rw, NULL);
-  pthread_spin_unlock(&cond_locked);
-  
-  return r;
-}
-
-int pthread_rwlock_init (pthread_rwlock_t *rwlock_, const pthread_rwlockattr_t *attr)
-{
-    rwlock_t *rwlock;
-    int r;
-
-    if(!rwlock_)
-      return EINVAL;
-    *rwlock_ = (pthread_rwlock_t)NULL;
-    if ((rwlock = calloc(1, sizeof(*rwlock))) == NULL)
-      return ENOMEM; 
-    rwlock->valid = DEAD_RWLOCK;
-
-    rwlock->nex_count = rwlock->nsh_count = rwlock->ncomplete = 0;
-    if ((r = pthread_mutex_init (&rwlock->mex, NULL)) != 0)
-    {
-        free(rwlock);
-        return r;
-    }
-    if ((r = pthread_mutex_init (&rwlock->mcomplete, NULL)) != 0)
-    {
-      pthread_mutex_destroy(&rwlock->mex);
-      free(rwlock);
-      return r;
-    }
-    if ((r = pthread_cond_init (&rwlock->ccomplete, NULL)) != 0)
-    {
-      pthread_mutex_destroy(&rwlock->mex);
-      pthread_mutex_destroy (&rwlock->mcomplete);
-      free(rwlock);
-      return r;
-    }
-    rwlock->valid = LIFE_RWLOCK;
-    *rwlock_ = (pthread_rwlock_t)rwlock;
-    return r;
-} 
-
-int pthread_rwlock_destroy (pthread_rwlock_t *rwlock_)
-{
-    rwlock_t *rwlock;
-    pthread_rwlock_t rDestroy;
-    int r, r2;
-    
-    pthread_spin_lock(&cond_locked);
-    r = rwl_ref_destroy(rwlock_,&rDestroy);
-    pthread_spin_unlock(&cond_locked);
-    
-    if(r) return r;
-    if(!rDestroy) return 0; /* destroyed a (still) static initialized rwl */
-
-    rwlock = (rwlock_t *)rDestroy;
-    r = rwlock_gain_both_locks (rwlock);
-    if (r != 0)
-    {
-      *rwlock_ = rDestroy;
-      return r;
-    }
-    if (rwlock->nsh_count > rwlock->ncomplete || rwlock->nex_count > 0)
-    {
-      *rwlock_ = rDestroy;
-      r = rwlock_free_both_locks(rwlock, 1);
-      if (!r)
-        r = EBUSY;
-      return r;
-    }
-    rwlock->valid  = DEAD_RWLOCK;
-    r = rwlock_free_both_locks(rwlock, 0);
-    if (r != 0) { *rwlock_ = rDestroy; return r; }
-
-    r = pthread_cond_destroy(&rwlock->ccomplete);
-    r2 = pthread_mutex_destroy(&rwlock->mex);
-    if (!r) r = r2;
-    r2 = pthread_mutex_destroy(&rwlock->mcomplete);
-    if (!r) r = r2;
-    rwlock->valid  = DEAD_RWLOCK;
-    free((void *)rDestroy);
-    return 0;
-} 
-
-int pthread_rwlock_rdlock (pthread_rwlock_t *rwlock_)
-{
-  rwlock_t *rwlock;
-  int ret;
-
-  /* pthread_testcancel(); */
-
-  ret = rwl_ref(rwlock_,0);
-  if(ret != 0) return ret;
-
-  rwlock = (rwlock_t *)*rwlock_;
-
-  ret = pthread_mutex_lock(&rwlock->mex);
-  if (ret != 0) return rwl_unref(rwlock_, ret);
-  InterlockedIncrement((long*)&rwlock->nsh_count);
-  if (rwlock->nsh_count == INT_MAX)
-  {
-    ret = pthread_mutex_lock(&rwlock->mcomplete);
-    if (ret != 0)
-    {
-      pthread_mutex_unlock(&rwlock->mex);
-      return rwl_unref(rwlock_,ret);
-    }
-    rwlock->nsh_count -= rwlock->ncomplete;
-    rwlock->ncomplete = 0;
-    ret = rwlock_free_both_locks(rwlock, 0);
-    return rwl_unref(rwlock_, ret);
-  }
-  ret = pthread_mutex_unlock(&rwlock->mex);
-  return rwl_unref(rwlock_, ret);
-}
-
-int pthread_rwlock_timedrdlock (pthread_rwlock_t *rwlock_, const struct timespec *ts)
-{
-  rwlock_t *rwlock;
-  int ret;
-
-  /* pthread_testcancel(); */
-
-  ret = rwl_ref(rwlock_,0);
-  if(ret != 0) return ret;
-
-  rwlock = (rwlock_t *)*rwlock_;
-  if ((ret = pthread_mutex_timedlock (&rwlock->mex, ts)) != 0)
-      return rwl_unref(rwlock_, ret);
-  InterlockedIncrement(&rwlock->nsh_count);
-  if (rwlock->nsh_count == INT_MAX)
-  {
-    ret = pthread_mutex_timedlock(&rwlock->mcomplete, ts);
-    if (ret != 0)
-    {
-      if (ret == ETIMEDOUT)
-	InterlockedIncrement(&rwlock->ncomplete);
-      pthread_mutex_unlock(&rwlock->mex);
-      return rwl_unref(rwlock_, ret);
-    }
-    rwlock->nsh_count -= rwlock->ncomplete;
-    rwlock->ncomplete = 0;
-    ret = rwlock_free_both_locks(rwlock, 0);
-    return rwl_unref(rwlock_, ret);
-  }
-  ret = pthread_mutex_unlock(&rwlock->mex);
-  return rwl_unref(rwlock_, ret);
-}
-
-int pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock_)
-{
-  rwlock_t *rwlock;
-  int ret;
-
-  ret = rwl_ref(rwlock_,RWL_TRY);
-  if(ret != 0) return ret;
-
-  rwlock = (rwlock_t *)*rwlock_;
-  ret = pthread_mutex_trylock(&rwlock->mex);
-  if (ret != 0)
-      return rwl_unref(rwlock_, ret);
-  InterlockedIncrement(&rwlock->nsh_count);
-  if (rwlock->nsh_count == INT_MAX)
-  {
-    ret = pthread_mutex_lock(&rwlock->mcomplete);
-    if (ret != 0)
-    {
-      pthread_mutex_unlock(&rwlock->mex);
-      return rwl_unref(rwlock_, ret);
-    }
-    rwlock->nsh_count -= rwlock->ncomplete;
-    rwlock->ncomplete = 0;
-    ret = rwlock_free_both_locks(rwlock, 0);
-    return rwl_unref(rwlock_, ret);
-  }
-  ret = pthread_mutex_unlock(&rwlock->mex);
-  return rwl_unref(rwlock_,ret);
-} 
-
-int pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock_)
-{
-  rwlock_t *rwlock;
-  int ret;
-
-  ret = rwl_ref(rwlock_,RWL_TRY);
-  if(ret != 0) return ret;
-
-  rwlock = (rwlock_t *)*rwlock_;
-  ret = pthread_mutex_trylock (&rwlock->mex);
-  if (ret != 0)
-    return rwl_unref(rwlock_, ret);
-  ret = pthread_mutex_trylock(&rwlock->mcomplete);
-  if (ret != 0)
-  {
-    int r1 = pthread_mutex_unlock(&rwlock->mex);
-    if (r1 != 0)
-      ret = r1;
-    return rwl_unref(rwlock_, ret);
-  }
-  if (rwlock->nex_count != 0)
-    return rwl_unref(rwlock_, EBUSY);
-  if (rwlock->ncomplete > 0)
-  {
-    rwlock->nsh_count -= rwlock->ncomplete;
-    rwlock->ncomplete = 0;
-  }
-  if (rwlock->nsh_count > 0)
-  {
-    ret = rwlock_free_both_locks(rwlock, 0);
-    if (!ret)
-      ret = EBUSY;
-    return rwl_unref(rwlock_, ret);
-  }
-  rwlock->nex_count = 1;
-  return rwl_unref(rwlock_, 0);
-} 
-
-int pthread_rwlock_unlock (pthread_rwlock_t *rwlock_)
-{
-  rwlock_t *rwlock;
-  int ret;
-
-  ret = rwl_ref_unlock(rwlock_);
-  if(ret != 0) return ret;
-
-  rwlock = (rwlock_t *)*rwlock_;
-  if (rwlock->nex_count == 0)
-  {
-    ret = pthread_mutex_lock(&rwlock->mcomplete);
-    if (!ret)
-    {
-      int r1;
-      InterlockedIncrement(&rwlock->ncomplete);
-      if (rwlock->ncomplete == 0)
-	ret = pthread_cond_signal(&rwlock->ccomplete);
-      r1 = pthread_mutex_unlock(&rwlock->mcomplete);
-      if (!ret)
-	ret = r1;
-    }
-  }
-  else
-  {
-    InterlockedDecrement(&rwlock->nex_count);
-    ret = rwlock_free_both_locks(rwlock, 0);
-  }
-  return rwl_unref(rwlock_, ret);
-} 
-
-static void st_cancelwrite (void *arg)
-{
-    rwlock_t *rwlock = (rwlock_t *)arg;
-
-    rwlock->nsh_count = - rwlock->ncomplete;
-    rwlock->ncomplete = 0;
-    rwlock_free_both_locks(rwlock, 0);
-}
-
-int pthread_rwlock_wrlock (pthread_rwlock_t *rwlock_)
-{
-  rwlock_t *rwlock;
-  int ret;
-
-  /* pthread_testcancel(); */
-  ret = rwl_ref(rwlock_,0);
-  if(ret != 0) return ret;
-
-  rwlock = (rwlock_t *)*rwlock_;
-  ret = rwlock_gain_both_locks(rwlock);
-  if (ret != 0)
-    return rwl_unref(rwlock_,ret);
-
-  if (rwlock->nex_count == 0)
-  {
-    if (rwlock->ncomplete > 0)
-    {
-      rwlock->nsh_count -= rwlock->ncomplete;
-      rwlock->ncomplete = 0;
-    }
-    if (rwlock->nsh_count > 0)
-    {
-      rwlock->ncomplete = -rwlock->nsh_count;
-      pthread_cleanup_push(st_cancelwrite, (void *) rwlock);
-      do {
-	ret = pthread_cond_wait(&rwlock->ccomplete, &rwlock->mcomplete);
-      } while (!ret && rwlock->ncomplete < 0);
-
-      pthread_cleanup_pop(!ret ? 0 : 1);
-      if (!ret)
-	rwlock->nsh_count = 0;
-    }
-  }
-  if(!ret)
-    InterlockedIncrement((long*)&rwlock->nex_count);
-  return rwl_unref(rwlock_,ret);
-}
-
-int pthread_rwlock_timedwrlock (pthread_rwlock_t *rwlock_, const struct timespec *ts)
-{
-  int ret;
-  rwlock_t *rwlock;
-
-  /* pthread_testcancel(); */
-  if (!rwlock_ || !ts)
-    return EINVAL;
-  if ((ret = rwl_ref(rwlock_,0)) != 0)
-    return ret;
-  rwlock = (rwlock_t *)*rwlock_;
-
-  ret = pthread_mutex_timedlock(&rwlock->mex, ts);
-  if (ret != 0)
-    return rwl_unref(rwlock_,ret);
-  ret = pthread_mutex_timedlock (&rwlock->mcomplete, ts);
-  if (ret != 0)
-  {
-    pthread_mutex_unlock(&rwlock->mex);
-    return rwl_unref(rwlock_,ret);
-  }
-  if (rwlock->nex_count == 0)
-  {
-    if (rwlock->ncomplete > 0)
-    {
-      rwlock->nsh_count -= rwlock->ncomplete;
-      rwlock->ncomplete = 0;
-    }
-    if (rwlock->nsh_count > 0)
-    {
-      rwlock->ncomplete = -rwlock->nsh_count;
-      pthread_cleanup_push(st_cancelwrite, (void *) rwlock);
-      do {
-	ret = pthread_cond_timedwait(&rwlock->ccomplete, &rwlock->mcomplete, ts);
-      } while (rwlock->ncomplete < 0 && !ret);
-      pthread_cleanup_pop(!ret ? 0 : 1);
-
-      if (!ret)
-	rwlock->nsh_count = 0;
-    }
-  }
-  if(!ret)
-    InterlockedIncrement((long*)&rwlock->nex_count);
-  return rwl_unref(rwlock_,ret);
-}
-
-int pthread_rwlockattr_destroy(pthread_rwlockattr_t *a)
-{
-  if (!a)
-    return EINVAL;
-  return 0;
-}
-
-int pthread_rwlockattr_init(pthread_rwlockattr_t *a)
-{
-  if (!a)
-    return EINVAL;
-  *a = PTHREAD_PROCESS_PRIVATE;
-  return 0;
-}
-
-int pthread_rwlockattr_getpshared(pthread_rwlockattr_t *a, int *s)
-{
-  if (!a || !s)
-    return EINVAL;
-  *s = *a;
-  return 0;
-}
-
-int pthread_rwlockattr_setpshared(pthread_rwlockattr_t *a, int s)
-{
-  if (!a || (s != PTHREAD_PROCESS_SHARED && s != PTHREAD_PROCESS_PRIVATE))
-    return EINVAL;
-  *a = s;
-  return 0;
-}
diff --git a/thirdparty/winpthreads/src/rwlock.h b/thirdparty/winpthreads/src/rwlock.h
deleted file mode 100644
index f08b0d37..00000000
--- a/thirdparty/winpthreads/src/rwlock.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef WIN_PTHREADS_RWLOCK_H
-#define WIN_PTHREADS_RWLOCK_H
-
-#define LIFE_RWLOCK 0xBAB1F0ED
-#define DEAD_RWLOCK 0xDEADB0EF
-
-#define INIT_RWLOCK(rwl)  { int r; \
-    if (STATIC_RWL_INITIALIZER(*rwl)) { if ((r = rwlock_static_init(rwl))) { if (r != EBUSY) return r; }}}
-
-#define STATIC_RWL_INITIALIZER(x)		((pthread_rwlock_t)(x) == ((pthread_rwlock_t)PTHREAD_RWLOCK_INITIALIZER))
-
-typedef struct rwlock_t rwlock_t;
-struct rwlock_t {
-    unsigned int valid;
-    int busy;
-    LONG nex_count; /* Exclusive access counter.  */
-    LONG nsh_count; /* Shared access counter. */
-    LONG ncomplete; /* Shared completed counter. */
-    pthread_mutex_t mex; /* Exclusive access protection.  */
-    pthread_mutex_t mcomplete; /* Shared completed protection. */
-    pthread_cond_t ccomplete; /* Shared access completed queue.  */
-};
-
-#define RWL_SET	0x01
-#define RWL_TRY	0x02
-
-void rwl_print(volatile pthread_rwlock_t *rwl, char *txt);
-void rwl_print_set(int state);
-
-#endif
diff --git a/thirdparty/winpthreads/src/sched.c b/thirdparty/winpthreads/src/sched.c
deleted file mode 100644
index 976bcc10..00000000
--- a/thirdparty/winpthreads/src/sched.c
+++ /dev/null
@@ -1,218 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#include <windows.h>
-#include <stdio.h>
-#include "pthread.h"
-#include "thread.h"
-
-#include "misc.h"
-
-int sched_get_priority_min(int pol)
-{
-  if (pol < SCHED_MIN || pol > SCHED_MAX) {
-      errno = EINVAL;
-      return -1;
-  }
-
-  return THREAD_PRIORITY_IDLE;
-}
-
-int sched_get_priority_max(int pol)
-{
-  if (pol < SCHED_MIN || pol > SCHED_MAX) {
-      errno = EINVAL;
-      return -1;
-  }
-
-  return THREAD_PRIORITY_TIME_CRITICAL;
-}
-
-int pthread_attr_setschedparam(pthread_attr_t *attr, const struct sched_param *p)
-{
-    int r = 0;
-
-    if (attr == NULL || p == NULL) {
-        return EINVAL;
-    }
-    memcpy(&attr->param, p, sizeof (*p));
-    return r;
-}
-
-int pthread_attr_getschedparam(const pthread_attr_t *attr, struct sched_param *p)
-{
-    int r = 0;
-
-    if (attr == NULL || p == NULL) {
-        return EINVAL;
-    }
-    memcpy(p, &attr->param, sizeof (*p));
-    return r;
-}
-
-int pthread_attr_setschedpolicy (pthread_attr_t *attr, int pol)
-{
-  if (!attr || pol < SCHED_MIN || pol > SCHED_MAX)
-    return EINVAL;
-  if (pol != SCHED_OTHER)
-    return ENOTSUP;
-  return 0;
-}
-
-int pthread_attr_getschedpolicy (const pthread_attr_t *attr, int *pol)
-{
-  if (!attr || !pol)
-    return EINVAL;
-  *pol = SCHED_OTHER;
-  return 0;
-}
-
-static int pthread_check(pthread_t t)
-{
-  struct _pthread_v *pv;
-
-  if (!t)
-    return ESRCH;
-  pv = __pth_gpointer_locked (t);
-  if (pv->ended == 0)
-    return 0;
-  CHECK_OBJECT(pv, ESRCH);
-  return 0;
-}
-
-int pthread_getschedparam(pthread_t t, int *pol, struct sched_param *p)
-{
-    int r;
-    //if (!t)
-    //  t = pthread_self();
-
-    if ((r = pthread_check(t)) != 0)
-    {
-        return r;
-    }
-
-    if (!p || !pol)
-    {
-        return EINVAL;
-    }
-    *pol = __pth_gpointer_locked (t)->sched_pol;
-    p->sched_priority = __pth_gpointer_locked (t)->sched.sched_priority;
-
-    return 0;
-}
-
-int pthread_setschedparam(pthread_t t, int pol,  const struct sched_param *p)
-{
-  struct _pthread_v *pv;
-    int r, pr = 0;
-    //if (!t.p) t = pthread_self();
-
-    if ((r = pthread_check(t)) != 0)
-        return r;
-
-    if (pol < SCHED_MIN || pol > SCHED_MAX || p == NULL)
-        return EINVAL;
-    if (pol != SCHED_OTHER)
-        return ENOTSUP;
-    pr = p->sched_priority;
-    if (pr < sched_get_priority_min(pol) || pr > sched_get_priority_max(pol))
-      return EINVAL;
-
-    /* See msdn: there are actually 7 priorities:
-    THREAD_PRIORITY_IDLE    -      -15
-    THREAD_PRIORITY_LOWEST          -2
-    THREAD_PRIORITY_BELOW_NORMAL    -1
-    THREAD_PRIORITY_NORMAL           0
-    THREAD_PRIORITY_ABOVE_NORMAL     1
-    THREAD_PRIORITY_HIGHEST          2
-    THREAD_PRIORITY_TIME_CRITICAL   15
-    */
-    if (pr <= THREAD_PRIORITY_IDLE) {
-        pr = THREAD_PRIORITY_IDLE;
-    } else if (pr <= THREAD_PRIORITY_LOWEST) {
-        pr = THREAD_PRIORITY_LOWEST;
-    } else if (pr >= THREAD_PRIORITY_TIME_CRITICAL) {
-        pr = THREAD_PRIORITY_TIME_CRITICAL;
-    } else if (pr >= THREAD_PRIORITY_HIGHEST) {
-        pr = THREAD_PRIORITY_HIGHEST;
-    }
-    pv = __pth_gpointer_locked (t);
-    if (SetThreadPriority(pv->h, pr)) {
-        pv->sched_pol = pol;
-        pv->sched.sched_priority = p->sched_priority;
-    } else
-        r = EINVAL;
-    return r;
-}
-
-int sched_getscheduler(pid_t pid)
-{
-  if (pid != 0)
-  {
-      HANDLE h = NULL;
-      int selfPid = (int) GetCurrentProcessId ();
-
-      if (pid != (pid_t) selfPid && (h = OpenProcess (PROCESS_QUERY_INFORMATION, 0, (DWORD) pid)) == NULL)
-      {
-	  errno = (GetLastError () == (0xFF & ERROR_ACCESS_DENIED)) ? EPERM : ESRCH;
-	  return -1;
-      }
-      if (h)
-	  CloseHandle (h);
-  }
-  return SCHED_OTHER;
-}
-
-int sched_setscheduler(pid_t pid, int pol, const struct sched_param *param)
-{
-  if (!param)
-    {
-      errno = EINVAL;
-      return -1;
-    }
-  if (pid != 0)
-  {
-      HANDLE h = NULL;
-      int selfPid = (int) GetCurrentProcessId ();
-
-      if (pid != (pid_t) selfPid && (h = OpenProcess (PROCESS_SET_INFORMATION, 0, (DWORD) pid)) == NULL)
-      {
-	  errno = (GetLastError () == (0xFF & ERROR_ACCESS_DENIED)) ? EPERM : ESRCH;
-	  return -1;
-      }
-      if (h)
-          CloseHandle (h);
-  }
-
-  if (pol != SCHED_OTHER)
-  {
-      errno = ENOSYS;
-      return -1;
-  }
-  return SCHED_OTHER;
-}
-
-int sched_yield(void)
-{
-  Sleep(0);
-  return 0;
-}
diff --git a/thirdparty/winpthreads/src/sem.c b/thirdparty/winpthreads/src/sem.c
deleted file mode 100644
index 81fa8f8e..00000000
--- a/thirdparty/winpthreads/src/sem.c
+++ /dev/null
@@ -1,354 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#include <windows.h>
-#include <stdio.h>
-#include <malloc.h>
-#include "pthread.h"
-#include "thread.h"
-#include "misc.h"
-#include "semaphore.h"
-#include "sem.h"
-#include "ref.h"
-
-int do_sema_b_wait_intern (HANDLE sema, int nointerrupt, DWORD timeout);
-
-static int
-sem_result (int res)
-{
-  if (res != 0) {
-    errno = res;
-    return -1;
-  }
-  return 0;
-}
-
-int
-sem_init (sem_t *sem, int pshared, unsigned int value)
-{
-  _sem_t *sv;
-
-  if (!sem || value > (unsigned int)SEM_VALUE_MAX)
-    return sem_result (EINVAL);
-  if (pshared != PTHREAD_PROCESS_PRIVATE)
-    return sem_result (EPERM);
-
-  if (!(sv = (sem_t) calloc (1,sizeof (*sv))))
-    return sem_result (ENOMEM);
-
-  sv->value = value;
-  if (pthread_mutex_init (&sv->vlock, NULL) != 0)
-    {
-      free (sv);
-      return sem_result (ENOSPC);
-    }
-  if ((sv->s = CreateSemaphore (NULL, 0, SEM_VALUE_MAX, NULL)) == NULL)
-    {
-      pthread_mutex_destroy (&sv->vlock);
-      free (sv);
-      return sem_result (ENOSPC);
-    }
-
-  sv->valid = LIFE_SEM;
-  *sem = sv;
-  return 0;
-}
-
-int
-sem_destroy (sem_t *sem)
-{
-  int r;
-  _sem_t *sv = NULL;
-
-  if (!sem || (sv = *sem) == NULL)
-    return sem_result (EINVAL);
-  if ((r = pthread_mutex_lock (&sv->vlock)) != 0)
-    return sem_result (r);
-
-#if 0
-  /* We don't wait for destroying a semaphore ...
-     or?  */
-  if (sv->value < 0)
-    {
-      pthread_mutex_unlock (&sv->vlock);
-      return sem_result (EBUSY);
-    }
-#endif
-
-  if (!CloseHandle (sv->s))
-    {
-      pthread_mutex_unlock (&sv->vlock);
-      return sem_result (EINVAL);
-    }
-  *sem = NULL;
-  sv->value = SEM_VALUE_MAX;
-  pthread_mutex_unlock(&sv->vlock);
-  Sleep (0);
-  while (pthread_mutex_destroy (&sv->vlock) == EBUSY)
-    Sleep (0);
-  sv->valid = DEAD_SEM;
-  free (sv);
-  return 0;
-}
-
-static int
-sem_std_enter (sem_t *sem,_sem_t **svp, int do_test)
-{
-  int r;
-  _sem_t *sv;
-
-  if (do_test)
-    pthread_testcancel ();
-  if (!sem)
-    return sem_result (EINVAL);
-  sv = *sem;
-  if (sv == NULL)
-    return sem_result (EINVAL);
-
-  if ((r = pthread_mutex_lock (&sv->vlock)) != 0)
-    return sem_result (r);
-
-  if (*sem == NULL)
-    {
-      pthread_mutex_unlock(&sv->vlock);
-      return sem_result (EINVAL);
-    }
-  *svp = sv;
-  return 0;
-}
-
-int
-sem_trywait (sem_t *sem)
-{
-  _sem_t *sv;
-
-  if (sem_std_enter (sem, &sv, 0) != 0)
-    return -1;
-  if (sv->value <= 0)
-    {
-      pthread_mutex_unlock (&sv->vlock);
-      return sem_result (EAGAIN);
-    }
-  sv->value--;
-  pthread_mutex_unlock (&sv->vlock);
-
-  return 0;
-}
-
-struct sSemTimedWait
-{
-  sem_t *p;
-  int *ret;
-};
-
-static void
-clean_wait_sem (void *s)
-{
-  struct sSemTimedWait *p = (struct sSemTimedWait *) s;
-  _sem_t *sv = NULL;
-
-  if (sem_std_enter (p->p, &sv, 0) != 0)
-    return;
-
-  if (WaitForSingleObject (sv->s, 0) != WAIT_OBJECT_0)
-    InterlockedIncrement (&sv->value);
-  else if (p->ret)
-    p->ret[0] = 0;
-  pthread_mutex_unlock (&sv->vlock);
-}
-
-int
-sem_wait (sem_t *sem)
-{
-  long cur_v;
-  int ret = 0;
-  _sem_t *sv;
-  HANDLE semh;
-  struct sSemTimedWait arg;
-
-  if (sem_std_enter (sem, &sv, 1) != 0)
-    return -1;
-
-  arg.ret = &ret;
-  arg.p = sem;
-  InterlockedDecrement (&sv->value);
-  cur_v = sv->value;
-  semh = sv->s;
-  pthread_mutex_unlock (&sv->vlock);
-
-  if (cur_v >= 0)
-    return 0;
-  else
-    {
-      pthread_cleanup_push (clean_wait_sem, (void *) &arg);
-      ret = do_sema_b_wait_intern (semh, 2, INFINITE);
-      pthread_cleanup_pop (ret);
-      if (ret == EINVAL)
-        return 0;
-    }
-
-  if (!ret)
-    return 0;
-
-  return sem_result (ret);
-}
-
-int
-sem_timedwait (sem_t *sem, const struct timespec *t)
-{
-  int cur_v, ret = 0;
-  DWORD dwr;
-  HANDLE semh;
-  _sem_t *sv;
-  struct sSemTimedWait arg;
-
-  if (!t)
-    return sem_wait (sem);
-  dwr = dwMilliSecs(_pthread_rel_time_in_ms (t));
-
-  if (sem_std_enter (sem, &sv, 1) != 0)
-    return -1;
-
-  arg.ret = &ret;
-  arg.p = sem;
-  InterlockedDecrement (&sv->value);
-  cur_v = sv->value;
-  semh = sv->s;
-  pthread_mutex_unlock(&sv->vlock);
-
-  if (cur_v >= 0)
-    return 0;
-  else
-    {
-      pthread_cleanup_push (clean_wait_sem, (void *) &arg);
-      ret = do_sema_b_wait_intern (semh, 2, dwr);
-      pthread_cleanup_pop (ret);
-      if (ret == EINVAL)
-        return 0;
-    }
-
-  if (!ret)
-    return 0;
-  return sem_result (ret);
-}
-
-int
-sem_post (sem_t *sem)
-{
-  _sem_t *sv;;
-
-  if (sem_std_enter (sem, &sv, 0) != 0)
-    return -1;
-
-  if (sv->value >= SEM_VALUE_MAX)
-    {
-      pthread_mutex_unlock (&sv->vlock);
-      return sem_result (ERANGE);
-    }
-  InterlockedIncrement (&sv->value);
-  if (sv->value > 0 || ReleaseSemaphore (sv->s, 1, NULL))
-    {
-      pthread_mutex_unlock (&sv->vlock);
-      return 0;
-    }
-  InterlockedDecrement (&sv->value);
-  pthread_mutex_unlock (&sv->vlock);
-
-  return sem_result (EINVAL);
-}
-
-int
-sem_post_multiple (sem_t *sem, int count)
-{
-  int waiters_count;
-  _sem_t *sv;;
-
-  if (count <= 0)
-    return sem_result (EINVAL);
-  if (sem_std_enter (sem, &sv, 0) != 0)
-    return -1;
-
-  if (sv->value > (SEM_VALUE_MAX - count))
-  {
-    pthread_mutex_unlock (&sv->vlock);
-    return sem_result (ERANGE);
-  }
-  waiters_count = -sv->value;
-  sv->value += count;
-  /*InterlockedExchangeAdd((long*)&sv->value, (long) count);*/
-  if (waiters_count <= 0
-      || ReleaseSemaphore (sv->s,
-			   (waiters_count < count ? waiters_count
-			   			  : count), NULL))
-  {
-    pthread_mutex_unlock(&sv->vlock);
-    return 0;
-  }
-  /*InterlockedExchangeAdd((long*)&sv->value, -((long) count));*/
-  sv->value -= count;
-  pthread_mutex_unlock(&sv->vlock);
-  return sem_result (EINVAL);
-}
-
-sem_t *
-sem_open (const char *name, int oflag, mode_t mode, unsigned int value)
-{
-  sem_result (ENOSYS);
-  return NULL;
-}
-
-int
-sem_close (sem_t *sem)
-{
-  return sem_result (ENOSYS);
-}
-
-int
-sem_unlink (const char *name)
-{
-  return sem_result (ENOSYS);
-}
-
-int
-sem_getvalue (sem_t *sem, int *sval)
-{
-  _sem_t *sv;
-  int r;
-
-  if (!sval)
-    return sem_result (EINVAL);
-
-  if (!sem || (sv = *sem) == NULL)
-    return sem_result (EINVAL);
-
-  if ((r = pthread_mutex_lock (&sv->vlock)) != 0)
-    return sem_result (r);
-  if (*sem == NULL)
-    {
-      pthread_mutex_unlock (&sv->vlock);
-      return sem_result (EINVAL);
-    }
-
-  *sval = (int) sv->value;
-  pthread_mutex_unlock (&sv->vlock);
-  return 0;  
-}
diff --git a/thirdparty/winpthreads/src/sem.h b/thirdparty/winpthreads/src/sem.h
deleted file mode 100644
index 3b3ace7f..00000000
--- a/thirdparty/winpthreads/src/sem.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef WIN_SEM
-#define WIN_SEM
-
-#include <windows.h>
-
-#define LIFE_SEM 0xBAB1F00D
-#define DEAD_SEM 0xDEADBEEF
-
-typedef struct _sem_t _sem_t;
-struct _sem_t
-{
-    unsigned int valid;
-    HANDLE s;
-    volatile long value;
-    pthread_mutex_t vlock;
-};
-
-#endif /* WIN_SEM */
diff --git a/thirdparty/winpthreads/src/spinlock.c b/thirdparty/winpthreads/src/spinlock.c
deleted file mode 100644
index c1c60097..00000000
--- a/thirdparty/winpthreads/src/spinlock.c
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
-   Copyright (c) 2013 mingw-w64 project
-   Copyright (c) 2015 Intel Corporation
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#include "pthread.h"
-
-#define likely(cond) __builtin_expect((cond) != 0, 1)
-#define unlikely(cond) __builtin_expect((cond) != 0, 0)
-
-/* We use the pthread_spinlock_t itself as a lock:
-   -1 is free, 0 is locked.
-   (This is dictated by PTHREAD_SPINLOCK_INITIALIZER, which we can't change
-   without breaking binary compatibility.) */
-typedef intptr_t spinlock_word_t;
-
-int
-pthread_spin_init (pthread_spinlock_t *lock, int pshared)
-{
-  spinlock_word_t *lk = (spinlock_word_t *)lock;
-  *lk = -1;
-  return 0;
-}
-
-
-int
-pthread_spin_destroy (pthread_spinlock_t *lock)
-{
-  return 0;
-}
-
-int pthread_spin_lock(pthread_spinlock_t *lock)
-{
-    volatile spinlock_word_t *lk = (volatile spinlock_word_t *)lock;
-    while (unlikely(__sync_lock_test_and_set(lk, 0) == 0))
-    {
-        do
-        {
-#if defined(__i386__) || defined(__x86_64__)
-            asm("pause" ::: "memory");
-#elif defined(__arm__) || defined(__aarch64__)
-            asm("wfe" ::: "memory");
-#else
-            #include <time.h>
-            #define BUSY_WAIT_DELAY_NS 1000
-            struct timespec ts = {0, BUSY_WAIT_DELAY_NS};
-            nanosleep(&ts, NULL);
-#endif
-        } while (*lk == 0);
-    }
-    return 0;
-}
-
-int
-pthread_spin_trylock (pthread_spinlock_t *lock)
-{
-  spinlock_word_t *lk = (spinlock_word_t *)lock;
-  return __sync_lock_test_and_set(lk, 0) == 0 ? EBUSY : 0;
-}
-
-
-int
-pthread_spin_unlock (pthread_spinlock_t *lock)
-{
-  volatile spinlock_word_t *lk = (volatile spinlock_word_t *)lock;
-  *lk = -1;
-  return 0;
-}
diff --git a/thirdparty/winpthreads/src/thread.c b/thirdparty/winpthreads/src/thread.c
deleted file mode 100644
index f7aba360..00000000
--- a/thirdparty/winpthreads/src/thread.c
+++ /dev/null
@@ -1,1885 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#include <windows.h>
-#include <strsafe.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <malloc.h>
-#include <signal.h>
-#include "pthread.h"
-#include "thread.h"
-#include "misc.h"
-#include "winpthread_internal.h"
-
-static _pthread_v *__pthread_self_lite (void);
-
-void (**_pthread_key_dest)(void *) = NULL;
-
-static volatile long _pthread_cancelling;
-static int _pthread_concur;
-
-/* FIXME Will default to zero as needed */
-static pthread_once_t _pthread_tls_once;
-static DWORD _pthread_tls = 0xffffffff;
-
-static pthread_rwlock_t _pthread_key_lock = PTHREAD_RWLOCK_INITIALIZER;
-static unsigned long _pthread_key_max=0L;
-static unsigned long _pthread_key_sch=0L;
-
-static _pthread_v *pthr_root = NULL, *pthr_last = NULL;
-static pthread_mutex_t mtx_pthr_locked = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
-
-static __pthread_idlist *idList = NULL;
-static size_t idListCnt = 0;
-static size_t idListMax = 0;
-static pthread_t idListNextId = 0;
-
-#if !defined(_MSC_VER)
-#define USE_VEH_FOR_MSC_SETTHREADNAME
-#endif
-#if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-/* forbidden RemoveVectoredExceptionHandler/AddVectoredExceptionHandler APIs */
-#undef USE_VEH_FOR_MSC_SETTHREADNAME
-#endif
-
-#if defined(USE_VEH_FOR_MSC_SETTHREADNAME)
-static void *SetThreadName_VEH_handle = NULL;
-
-static LONG __stdcall
-SetThreadName_VEH (PEXCEPTION_POINTERS ExceptionInfo)
-{
-  if (ExceptionInfo->ExceptionRecord != NULL &&
-      ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_SET_THREAD_NAME)
-    return EXCEPTION_CONTINUE_EXECUTION;
-
-  return EXCEPTION_CONTINUE_SEARCH;
-}
-#endif
-
-typedef struct _THREADNAME_INFO
-{
-  DWORD  dwType;	/* must be 0x1000 */
-  LPCSTR szName;	/* pointer to name (in user addr space) */
-  DWORD  dwThreadID;	/* thread ID (-1=caller thread) */
-  DWORD  dwFlags;	/* reserved for future use, must be zero */
-} THREADNAME_INFO;
-
-static void
-SetThreadName (DWORD dwThreadID, LPCSTR szThreadName)
-{
-   THREADNAME_INFO info;
-   DWORD infosize;
-
-   info.dwType = 0x1000;
-   info.szName = szThreadName;
-   info.dwThreadID = dwThreadID;
-   info.dwFlags = 0;
-
-   infosize = sizeof (info) / sizeof (ULONG_PTR);
-
-#if defined(_MSC_VER) && !defined (USE_VEH_FOR_MSC_SETTHREADNAME)
-   __try
-     {
-       RaiseException (EXCEPTION_SET_THREAD_NAME, 0, infosize, (ULONG_PTR *)&info);
-     }
-   __except (EXCEPTION_EXECUTE_HANDLER)
-     {
-     }
-#else
-   /* Without a debugger we *must* have an exception handler,
-    * otherwise raising an exception will crash the process.
-    */
-#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-   if ((!IsDebuggerPresent ()) && (SetThreadName_VEH_handle == NULL))
-#else
-   if (!IsDebuggerPresent ())
-#endif
-     return;
-
-   RaiseException (EXCEPTION_SET_THREAD_NAME, 0, infosize, (ULONG_PTR *) &info);
-#endif
-}
-
-/* Search the list idList for an element with identifier ID.  If
-   found, its associated _pthread_v pointer is returned, otherwise
-   NULL.
-   NOTE: This method is not locked.  */
-static struct _pthread_v *
-__pthread_get_pointer (pthread_t id)
-{
-  size_t l, r, p;
-  if (!idListCnt)
-    return NULL;
-  if (idListCnt == 1)
-    return (idList[0].id == id ? idList[0].ptr : NULL);
-  l = 0; r = idListCnt - 1;
-  while (l <= r)
-  {
-    p = (l + r) >> 1;
-    if (idList[p].id == id)
-      return idList[p].ptr;
-    else if (idList[p].id > id)
-      {
-	if (p == l)
-	  return NULL;
-	r = p - 1;
-      }
-    else
-      {
-	l = p + 1;
-      }
-  }
-
-  return NULL;
-}
-
-static void
-__pth_remove_use_for_key (pthread_key_t key)
-{
-  int i;
-
-  pthread_mutex_lock (&mtx_pthr_locked);
-  for (i = 0; i < idListCnt; i++)
-    {
-      if (idList[i].ptr != NULL
-          && idList[i].ptr->keyval != NULL
-          && key < idList[i].ptr->keymax)
-        {
-	  idList[i].ptr->keyval[key] = NULL;
-	  idList[i].ptr->keyval_set[key] = 0;
-	}
-    }
-  pthread_mutex_unlock (&mtx_pthr_locked);
-}
-
-/* Search the list idList for an element with identifier ID.  If
-   found, its associated _pthread_v pointer is returned, otherwise
-   NULL.
-   NOTE: This method uses lock mtx_pthr_locked.  */
-struct _pthread_v *
-__pth_gpointer_locked (pthread_t id)
-{
-  struct _pthread_v *ret;
-  if (!id)
-    return NULL;
-  pthread_mutex_lock (&mtx_pthr_locked);
-  ret =  __pthread_get_pointer (id);
-  pthread_mutex_unlock (&mtx_pthr_locked);
-  return ret;
-}
-
-/* Registers in the list idList an element with _pthread_v pointer
-   and creates and unique identifier ID.  If successful created the
-   ID of this element is returned, otherwise on failure zero ID gets
-   returned.
-   NOTE: This method is not locked.  */
-static pthread_t
-__pthread_register_pointer (struct _pthread_v *ptr)
-{
-  __pthread_idlist *e;
-  size_t i;
-
-  if (!ptr)
-    return 0;
-  /* Check if a resize of list is necessary.  */
-  if (idListCnt >= idListMax)
-    {
-      if (!idListCnt)
-        {
-	  e = (__pthread_idlist *) malloc (sizeof (__pthread_idlist) * 16);
-	  if (!e)
-	    return 0;
-	  idListMax = 16;
-	  idList = e;
-	}
-      else
-        {
-	  e = (__pthread_idlist *) realloc (idList, sizeof (__pthread_idlist) * (idListMax + 16));
-	  if (!e)
-	    return 0;
-	  idListMax += 16;
-	  idList = e;
-	}
-    }
-  do
-    {
-      ++idListNextId;
-      /* If two MSB are set we reset to id 1.  We need to check here bits
-         to avoid gcc's no-overflow issue on increment.  Additionally we
-         need to handle different size of pthread_t on 32-bit/64-bit.  */
-      if ((idListNextId & ( ((pthread_t) 1) << ((sizeof (pthread_t) * 8) - 2))) != 0)
-        idListNextId = 1;
-    }
-  while (idListNextId == 0 || __pthread_get_pointer (idListNextId));
-  /* We assume insert at end of list.  */
-  i = idListCnt;
-  if (i != 0)
-    {
-      /* Find position we can actual insert sorted.  */
-      while (i > 0 && idList[i - 1].id > idListNextId)
-        --i;
-      if (i != idListCnt)
-	memmove (&idList[i + 1], &idList[i], sizeof (__pthread_idlist) * (idListCnt - i));
-    }
-  idList[i].id = idListNextId;
-  idList[i].ptr = ptr;
-  ++idListCnt;
-  return idListNextId;
-}
-
-/* Deregisters in the list idList an element with identifier ID and
-   returns its _pthread_v pointer on success.  Otherwise NULL is returned.
-   NOTE: This method is not locked.  */
-static struct _pthread_v *
-__pthread_deregister_pointer (pthread_t id)
-{
-  size_t l, r, p;
-  if (!idListCnt)
-    return NULL;
-  l = 0; r = idListCnt - 1;
-  while (l <= r)
-  {
-    p = (l + r) >> 1;
-    if (idList[p].id == id)
-      {
-	struct _pthread_v *ret = idList[p].ptr;
-	p++;
-	if (p < idListCnt)
-	  memmove (&idList[p - 1], &idList[p], sizeof (__pthread_idlist) * (idListCnt - p));
-	--idListCnt;
-	/* Is this last element in list then free list.  */
-	if (idListCnt == 0)
-	{
-	  free (idList);
-	  idListCnt = idListMax = 0;
-	}
-	return ret;
-      }
-    else if (idList[p].id > id)
-      {
-	if (p == l)
-	  return NULL;
-	r = p - 1;
-      }
-    else
-      {
-	l = p + 1;
-      }
-  }
-  return NULL;
-}
-
-/* Save a _pthread_v element for reuse in pool.  */
-static void
-push_pthread_mem (_pthread_v *sv)
-{
-  if (!sv || sv->next != NULL)
-    return;
-  pthread_mutex_lock (&mtx_pthr_locked);
-  if (sv->x != 0)
-    __pthread_deregister_pointer (sv->x);
-  if (sv->keyval)
-    free (sv->keyval);
-  if (sv->keyval_set)
-    free (sv->keyval_set);
-  if (sv->thread_name)
-    free (sv->thread_name);
-  memset (sv, 0, sizeof(struct _pthread_v));
-  if (pthr_last == NULL)
-    pthr_root = pthr_last = sv;
-  else
-  {
-    pthr_last->next = sv;
-    pthr_last = sv;
-  }
-  pthread_mutex_unlock (&mtx_pthr_locked);
-}
-
-/* Get a _pthread_v element from pool, or allocate it.
-   Note the unique identifier is created for the element here, too.  */
-static _pthread_v *
-pop_pthread_mem (void)
-{
-  _pthread_v *r = NULL;
-
-  pthread_mutex_lock (&mtx_pthr_locked);
-  if ((r = pthr_root) == NULL)
-    {
-      if ((r = (_pthread_v *)calloc (1,sizeof(struct _pthread_v))) != NULL)
-	{
-	  r->x = __pthread_register_pointer (r);
-	  if (r->x == 0)
-	    {
-	      free (r);
-	      r = NULL;
-	    }
-	}
-      pthread_mutex_unlock (&mtx_pthr_locked);
-      return r;
-    }
-  r->x = __pthread_register_pointer (r);
-  if (r->x == 0)
-    r = NULL;
-  else
-    {
-      if((pthr_root = r->next) == NULL)
-	pthr_last = NULL;
-
-      r->next = NULL;
-    }
-  pthread_mutex_unlock (&mtx_pthr_locked);
-  return r;
-}
-
-/* Free memory consumed in _pthread_v pointer pool.  */
-static void
-free_pthread_mem (void)
-{
-  _pthread_v *t;
-
-  if (1)
-  return;  
-  pthread_mutex_lock (&mtx_pthr_locked);
-  t = pthr_root;
-  while (t != NULL)
-  {
-    _pthread_v *sv = t;
-    t = t->next;
-    if (sv->x != 0 && sv->ended == 0 && sv->valid != DEAD_THREAD)
-      {
-	pthread_mutex_unlock (&mtx_pthr_locked);
-	pthread_cancel (t->x);
-	Sleep (0);
-	pthread_mutex_lock (&mtx_pthr_locked);
-	t = pthr_root;
-	continue;
-      }
-    else if (sv->x != 0 && sv->valid != DEAD_THREAD)
-      {
-	pthread_mutex_unlock (&mtx_pthr_locked);
-	Sleep (0);
-	pthread_mutex_lock (&mtx_pthr_locked);
-	continue;
-      }
-    if (sv->x != 0)
-      __pthread_deregister_pointer (sv->x);
-    sv->x = 0;
-    free (sv);
-    pthr_root = t;
-  }
-  pthread_mutex_unlock (&mtx_pthr_locked);
-}
-
-static void
-replace_spin_keys (pthread_spinlock_t *old, pthread_spinlock_t new)
-{
-  if (old == NULL)
-    return;
-
-  if (EPERM == pthread_spin_destroy (old))
-    {
-#define THREADERR "Error cleaning up spin_keys for thread "
-#define THREADERR_LEN ((sizeof (THREADERR) / sizeof (*THREADERR)) - 1)
-#define THREADID_LEN THREADERR_LEN + 66 + 1 + 1
-      int i;
-      char thread_id[THREADID_LEN] = THREADERR;
-      _ultoa ((unsigned long) GetCurrentThreadId (), &thread_id[THREADERR_LEN], 10);
-      for (i = THREADERR_LEN; thread_id[i] != '\0' && i < THREADID_LEN - 1; i++)
-        {
-        }
-      if (i < THREADID_LEN - 1)
-        {
-          thread_id[i] = '\n';
-          thread_id[i + 1] = '\0';
-        }
-#undef THREADERR
-#undef THREADERR_LEN
-#undef THREADID_LEN
-      OutputDebugStringA (thread_id);
-      abort ();
-    }
-
-  *old = new;
-}
-
-/* Hook for TLS-based deregistration/registration of thread.  */
-static BOOL WINAPI
-__dyn_tls_pthread (HANDLE hDllHandle, DWORD dwReason, LPVOID lpreserved)
-{
-  _pthread_v *t = NULL;
-  pthread_spinlock_t new_spin_keys = PTHREAD_SPINLOCK_INITIALIZER;
-
-  if (dwReason == DLL_PROCESS_DETACH)
-    {
-#if defined(USE_VEH_FOR_MSC_SETTHREADNAME)
-      if (lpreserved == NULL && SetThreadName_VEH_handle != NULL)
-        {
-          RemoveVectoredExceptionHandler (SetThreadName_VEH_handle);
-          SetThreadName_VEH_handle = NULL;
-        }
-#endif
-      free_pthread_mem ();
-    }
-  else if (dwReason == DLL_PROCESS_ATTACH)
-    {
-#if defined(USE_VEH_FOR_MSC_SETTHREADNAME)
-      SetThreadName_VEH_handle = AddVectoredExceptionHandler (1, &SetThreadName_VEH);
-      /* Can't do anything on error anyway, check for NULL later */
-#endif
-    }
-  else if (dwReason == DLL_THREAD_DETACH)
-    {
-      if (_pthread_tls != 0xffffffff)
-	t = (_pthread_v *)TlsGetValue(_pthread_tls);
-      if (t && t->thread_noposix != 0)
-	{
-	  _pthread_cleanup_dest (t->x);
-	  if (t->h != NULL)
-	    {
-	      CloseHandle (t->h);
-	      if (t->evStart)
-		CloseHandle (t->evStart);
-	      t->evStart = NULL;
-	      t->h = NULL;
-	    }
-	  pthread_mutex_destroy (&t->p_clock);
-	  replace_spin_keys (&t->spin_keys, new_spin_keys);
-	  push_pthread_mem (t);
-	  t = NULL;
-	  TlsSetValue (_pthread_tls, t);
-	}
-      else if (t && t->ended == 0)
-	{
-	  if (t->evStart)
-	    CloseHandle(t->evStart);
-	  t->evStart = NULL;
-	  t->ended = 1;
-	  _pthread_cleanup_dest (t->x);
-	  if ((t->p_state & PTHREAD_CREATE_DETACHED) == PTHREAD_CREATE_DETACHED)
-	    {
-	      t->valid = DEAD_THREAD;
-	      if (t->h != NULL)
-		CloseHandle (t->h);
-	      t->h = NULL;
-	      pthread_mutex_destroy(&t->p_clock);
-	      replace_spin_keys (&t->spin_keys, new_spin_keys);
-	      push_pthread_mem (t);
-	      t = NULL;
-	      TlsSetValue (_pthread_tls, t);
-	      return TRUE;
-	    }
-	  pthread_mutex_destroy(&t->p_clock);
-	  replace_spin_keys (&t->spin_keys, new_spin_keys);
-	}
-      else if (t)
-	{
-	  if (t->evStart)
-	    CloseHandle (t->evStart);
-	  t->evStart = NULL;
-	  pthread_mutex_destroy (&t->p_clock);
-	  replace_spin_keys (&t->spin_keys, new_spin_keys);
-	}
-    }
-  return TRUE;
-}
-
-/* TLS-runtime section variable.  */
-#ifdef _MSC_VER
-#pragma section(".CRT$XLF", shared)
-#endif
-PIMAGE_TLS_CALLBACK WINPTHREADS_ATTRIBUTE((WINPTHREADS_SECTION(".CRT$XLF"))) __xl_f  = (PIMAGE_TLS_CALLBACK) __dyn_tls_pthread;
-#ifdef _MSC_VER
-#pragma data_seg()
-#endif
-
-#ifdef WINPTHREAD_DBG
-static int print_state = 0;
-void thread_print_set (int state)
-{
-  print_state = state;
-}
-
-void
-thread_print (volatile pthread_t t, char *txt)
-{
-    if (!print_state)
-      return;
-    if (!t)
-      printf("T%p %d %s\n",NULL,(int)GetCurrentThreadId(),txt);
-    else
-      {
-	printf("T%p %d V=%0X H=%p %s\n",
-	    __pth_gpointer_locked (t), 
-	    (int)GetCurrentThreadId(), 
-	    (int) (__pth_gpointer_locked (t))->valid, 
-	    (__pth_gpointer_locked (t))->h,
-	    txt
-	    );
-      }
-}
-#endif
-
-/* Internal collect-once structure.  */
-typedef struct collect_once_t {
-  pthread_once_t *o;
-  pthread_mutex_t m;
-  int count;
-  struct collect_once_t *next;
-} collect_once_t;
-
-static collect_once_t *once_obj = NULL;
-
-static pthread_spinlock_t once_global = PTHREAD_SPINLOCK_INITIALIZER;
-
-static collect_once_t *
-enterOnceObject (pthread_once_t *o)
-{
-  collect_once_t *c, *p = NULL;
-  pthread_spin_lock (&once_global);
-  c = once_obj;
-  while (c != NULL && c->o != o)
-    {
-      c = (p = c)->next;
-    }
-  if (!c)
-    {
-      c = (collect_once_t *) calloc(1,sizeof(collect_once_t));
-      c->o = o;
-      c->count = 1;
-      if (!p)
-        once_obj = c;
-      else
-        p->next = c;
-      pthread_mutex_init(&c->m, NULL);
-    }
-  else
-    c->count += 1;
-  pthread_spin_unlock (&once_global);
-  return c;
-}
-
-static void
-leaveOnceObject (collect_once_t *c)
-{
-  collect_once_t *h, *p = NULL;
-  if (!c)
-    return;
-  pthread_spin_lock (&once_global);
-  h = once_obj;
-  while (h != NULL && c != h)
-    h = (p = h)->next;
-
-  if (h)
-    {
-      c->count -= 1;
-      if (c->count == 0)
-	{
-	  pthread_mutex_destroy(&c->m);
-	  if (!p)
-	    once_obj = c->next;
-	  else
-	    p->next = c->next;
-	  free (c);
-	}
-    }
-  else
-    fprintf(stderr, "%p not found?!?!\n", c);
-  pthread_spin_unlock (&once_global);
-}
-
-static void
-_pthread_once_cleanup (void *o)
-{
-  collect_once_t *co = (collect_once_t *) o;
-  pthread_mutex_unlock (&co->m);
-  leaveOnceObject (co);
-}
-
-static int
-_pthread_once_raw (pthread_once_t *o, void (*func)(void))
-{
-  collect_once_t *co;
-  long state = *o;
-
-  CHECK_PTR(o);
-  CHECK_PTR(func);
-
-  if (state == 1)
-    return 0;
-  co = enterOnceObject(o);
-  pthread_mutex_lock(&co->m);
-  if (*o == 0)
-    {
-      func();
-      *o = 1;
-    }
-  else if (*o != 1)
-    fprintf (stderr," once %p is %d\n", o, (int) *o);
-  pthread_mutex_unlock(&co->m);
-  leaveOnceObject(co);
-
-  /* Done */
-  return 0;
-}
-
-/* Unimplemented.  */
-void *
-pthread_timechange_handler_np(void *dummy)
-{
-  return NULL;
-}
-
-/* Compatibility routine for pthread-win32.  It waits for ellapse of
-   interval and additionally checks for possible thread-cancelation.  */
-int
-pthread_delay_np (const struct timespec *interval)
-{
-  DWORD to = (!interval ? 0 : dwMilliSecs (_pthread_time_in_ms_from_timespec (interval)));
-  struct _pthread_v *s = __pthread_self_lite ();
-
-  if (!to)
-    {
-      pthread_testcancel ();
-      Sleep (0);
-      pthread_testcancel ();
-      return 0;
-    }
-  pthread_testcancel ();
-  if (s->evStart)
-    _pthread_wait_for_single_object (s->evStart, to);
-  else
-    Sleep (to);
-  pthread_testcancel ();
-  return 0;
-}
-
-int pthread_delay_np_ms (DWORD to);
-
-int
-pthread_delay_np_ms (DWORD to)
-{
-  struct _pthread_v *s = __pthread_self_lite ();
-
-  if (!to)
-    {
-      pthread_testcancel ();
-      Sleep (0);
-      pthread_testcancel ();
-      return 0;
-    }
-  pthread_testcancel ();
-  if (s->evStart)
-    _pthread_wait_for_single_object (s->evStart, to);
-  else
-    Sleep (to);
-  pthread_testcancel ();
-  return 0;
-}
-
-/* Compatibility routine for pthread-win32.  It returns the
-   amount of available CPUs on system.  */
-int
-pthread_num_processors_np(void) 
-{
-  int r = 0;
-  DWORD_PTR ProcessAffinityMask, SystemAffinityMask;
-
-  if (GetProcessAffinityMask(GetCurrentProcess(), &ProcessAffinityMask, &SystemAffinityMask))
-    {
-      for(; ProcessAffinityMask != 0; ProcessAffinityMask >>= 1)
-	r += (ProcessAffinityMask & 1) != 0;
-    }
-  /* assume at least 1 */
-  return r ? r : 1;
-}
-
-/* Compatiblity routine for pthread-win32.  Allows to set amount of used
-   CPUs for process.  */
-int
-pthread_set_num_processors_np(int n) 
-{
-  DWORD_PTR ProcessAffinityMask, ProcessNewAffinityMask = 0, SystemAffinityMask;
-  int r = 0; 
-  /* need at least 1 */
-  n = n ? n : 1;
-  if (GetProcessAffinityMask (GetCurrentProcess (), &ProcessAffinityMask, &SystemAffinityMask))
-    {
-      for (; ProcessAffinityMask != 0; ProcessAffinityMask >>= 1)
-	{
-	  ProcessNewAffinityMask <<= 1;
-	  if ((ProcessAffinityMask & 1) != 0 && r < n)
-	    {
-	      ProcessNewAffinityMask |= 1;
-	      r++;
-	    }
-	}
-      SetProcessAffinityMask (GetCurrentProcess (),ProcessNewAffinityMask);
-    }
-  return r;
-}
-
-int
-pthread_once (pthread_once_t *o, void (*func)(void))
-{
-  collect_once_t *co;
-  long state = *o;
-
-  CHECK_PTR(o);
-  CHECK_PTR(func);
-
-  if (state == 1)
-    return 0;
-  co = enterOnceObject(o);
-  pthread_mutex_lock(&co->m);
-  if (*o == 0)
-    {
-      pthread_cleanup_push(_pthread_once_cleanup, co);
-      func();
-      pthread_cleanup_pop(0);
-      *o = 1;
-    }
-  else if (*o != 1)
-    fprintf (stderr," once %p is %d\n", o, (int) *o);
-  pthread_mutex_unlock(&co->m);
-  leaveOnceObject(co);
-
-  return 0;
-}
-
-int
-pthread_key_create (pthread_key_t *key, void (* dest)(void *))
-{
-	unsigned int i;
-	long nmax;
-	void (**d)(void *);
-
-	if (!key)
-		return EINVAL;
-
-	pthread_rwlock_wrlock (&_pthread_key_lock);
-
-	for (i = _pthread_key_sch; i < _pthread_key_max; i++)
-	{
-		if (!_pthread_key_dest[i])
-		{
-			*key = i;
-			if (dest)
-				_pthread_key_dest[i] = dest;
-			else
-				_pthread_key_dest[i] = (void(*)(void *))1;
-			pthread_rwlock_unlock (&_pthread_key_lock);
-			return 0;
-		}
-	}
-
-	for (i = 0; i < _pthread_key_sch; i++)
-	{
-		if (!_pthread_key_dest[i])
-		{
-			*key = i;
-			if (dest)
-				_pthread_key_dest[i] = dest;
-			else
-				_pthread_key_dest[i] = (void(*)(void *))1;
-			pthread_rwlock_unlock (&_pthread_key_lock);
-
-			return 0;
-		}
-	}
-
-	if (_pthread_key_max == PTHREAD_KEYS_MAX)
-	{
-		pthread_rwlock_unlock(&_pthread_key_lock);
-		return ENOMEM;
-	}
-
-	nmax = _pthread_key_max * 2;
-	if (nmax == 0)
-		nmax = _pthread_key_max + 1;
-	if (nmax > PTHREAD_KEYS_MAX)
-		nmax = PTHREAD_KEYS_MAX;
-
-	/* No spare room anywhere */
-	d = (void (__cdecl **)(void *))realloc(_pthread_key_dest, nmax * sizeof(*d));
-	if (!d)
-	{
-		pthread_rwlock_unlock (&_pthread_key_lock);
-		return ENOMEM;
-	}
-
-	/* Clear new region */
-	memset ((void *) &d[_pthread_key_max], 0, (nmax-_pthread_key_max)*sizeof(void *));
-
-	/* Use new region */
-	_pthread_key_dest = d;
-	_pthread_key_sch = _pthread_key_max + 1;
-	*key = _pthread_key_max;
-	_pthread_key_max = nmax;
-
-	if (dest)
-		_pthread_key_dest[*key] = dest;
-	else
-		_pthread_key_dest[*key] = (void(*)(void *))1;
-
-	pthread_rwlock_unlock (&_pthread_key_lock);
-	return 0;
-}
-
-int
-pthread_key_delete (pthread_key_t key)
-{
-  if (key >= _pthread_key_max || !_pthread_key_dest)
-    return EINVAL;
-
-  pthread_rwlock_wrlock (&_pthread_key_lock);
-  
-  _pthread_key_dest[key] = NULL;
-
-  /* Start next search from our location */
-  if (_pthread_key_sch > key)
-    _pthread_key_sch = key;
-  /* So now we need to walk the complete list of threads
-     and remove key's reference for it.  */
-  __pth_remove_use_for_key (key);
-
-  pthread_rwlock_unlock (&_pthread_key_lock);
-  return 0;
-}
-
-void *
-pthread_getspecific (pthread_key_t key)
-{
-  DWORD lasterr = GetLastError ();
-  void *r;
-  _pthread_v *t = __pthread_self_lite ();
-  pthread_spin_lock (&t->spin_keys);
-  r = (key >= t->keymax || t->keyval_set[key] == 0 ? NULL : t->keyval[key]);
-  pthread_spin_unlock (&t->spin_keys);
-  SetLastError (lasterr);
-  return r;
-}
-
-int
-pthread_setspecific (pthread_key_t key, const void *value)
-{
-  DWORD lasterr = GetLastError ();
-  _pthread_v *t = __pthread_self_lite ();
-  
-  pthread_spin_lock (&t->spin_keys);
-
-  if (key >= t->keymax)
-    {
-      int keymax = (key + 1);
-      void **kv;
-      unsigned char *kv_set;
-
-      kv = (void **) realloc (t->keyval, keymax * sizeof (void *));
-
-      if (!kv)
-        {
-	  pthread_spin_unlock (&t->spin_keys);
-	  return ENOMEM;
-	}
-      kv_set = (unsigned char *) realloc (t->keyval_set, keymax);
-      if (!kv_set)
-        {
-	  pthread_spin_unlock (&t->spin_keys);
-	  return ENOMEM;
-	}
-
-      /* Clear new region */
-      memset (&kv[t->keymax], 0, (keymax - t->keymax)*sizeof(void *));
-      memset (&kv_set[t->keymax], 0, (keymax - t->keymax));
-
-      t->keyval = kv;
-      t->keyval_set = kv_set;
-      t->keymax = keymax;
-    }
-
-  t->keyval[key] = (void *) value;
-  t->keyval_set[key] = 1;
-  pthread_spin_unlock (&t->spin_keys);
-  SetLastError (lasterr);
-
-  return 0;
-}
-
-int
-pthread_equal (pthread_t t1, pthread_t t2)
-{
-  return (t1 == t2);
-}
-
-void
-pthread_tls_init (void)
-{
-  _pthread_tls = TlsAlloc();
-
-  /* Cannot continue if out of indexes */
-  if (_pthread_tls == TLS_OUT_OF_INDEXES)
-    abort();
-}
-
-void
-_pthread_cleanup_dest (pthread_t t)
-{
-	_pthread_v *tv;
-	unsigned int i, j;
-
-	if (!t)
-		return;
-	tv = __pth_gpointer_locked (t);
-	if (!tv)
-		return;
-
-	for (j = 0; j < PTHREAD_DESTRUCTOR_ITERATIONS; j++)
-	{
-		int flag = 0;
-
-		pthread_spin_lock (&tv->spin_keys);
-		for (i = 0; i < tv->keymax; i++)
-		{
-			void *val = tv->keyval[i];
-
-			if (tv->keyval_set[i])
-			{
-				pthread_rwlock_rdlock (&_pthread_key_lock);
-				if ((uintptr_t) _pthread_key_dest[i] > 1)
-				{
-					/* Call destructor */
-					tv->keyval[i] = NULL;
-					tv->keyval_set[i] = 0;
-					pthread_spin_unlock (&tv->spin_keys);
-					_pthread_key_dest[i](val);
-					pthread_spin_lock (&tv->spin_keys);
-					flag = 1;
-				}
-				else
-				{
-					tv->keyval[i] = NULL;
-					tv->keyval_set[i] = 0;
-				}
-				pthread_rwlock_unlock(&_pthread_key_lock);
-			}
-		}
-		pthread_spin_unlock (&tv->spin_keys);
-		/* Nothing to do? */
-		if (!flag)
-			return;
-	}
-}
-
-static _pthread_v *
-__pthread_self_lite (void)
-{
-  _pthread_v *t;
-  pthread_spinlock_t new_spin_keys = PTHREAD_SPINLOCK_INITIALIZER;
-
-  _pthread_once_raw (&_pthread_tls_once, pthread_tls_init);
-
-  t = (_pthread_v *) TlsGetValue (_pthread_tls);
-  if (t)
-    return t;
-  /* Main thread? */
-  t = (struct _pthread_v *) pop_pthread_mem ();
-
-  /* If cannot initialize main thread, then the only thing we can do is return null pthread_t */
-  if (!__xl_f || !t)
-    return 0;
-
-  t->p_state = PTHREAD_DEFAULT_ATTR /*| PTHREAD_CREATE_DETACHED*/;
-  t->tid = GetCurrentThreadId();
-  t->evStart = CreateEvent (NULL, 1, 0, NULL);
-  t->p_clock = PTHREAD_MUTEX_INITIALIZER;
-  replace_spin_keys (&t->spin_keys, new_spin_keys);
-  t->sched_pol = SCHED_OTHER;
-  t->h = NULL; //GetCurrentThread();
-  if (!DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &t->h, 0, FALSE, DUPLICATE_SAME_ACCESS))
-    abort ();
-  t->sched.sched_priority = GetThreadPriority(t->h);
-  t->ended = 0;
-  t->thread_noposix = 1;
-
-  /* Save for later */
-  if (!TlsSetValue(_pthread_tls, t))
-    abort ();
-  return t;
-}
-
-pthread_t
-pthread_self (void)
-{
-  _pthread_v *t = __pthread_self_lite ();
-
-  if (!t)
-    return 0;
-  return t->x;
-}
-
-/* Internal helper for getting event handle of thread T.  */
-void *
-pthread_getevent (void)
-{
-  _pthread_v *t = __pthread_self_lite ();
-  return (!t ? NULL : t->evStart);
-}
-
-/* Internal helper for getting thread handle of thread T.  */
-void *
-pthread_gethandle (pthread_t t)
-{
-  struct _pthread_v *tv = __pth_gpointer_locked (t);
-  return (!tv ? NULL : tv->h);
-}
-
-/* Internal helper for getting pointer of clean of current thread.  */
-struct _pthread_cleanup **
-pthread_getclean (void)
-{
-  struct _pthread_v *t = __pthread_self_lite ();
-  if (!t) return NULL;
-  return &t->clean;
-}
-
-int
-pthread_get_concurrency (int *val)
-{
-  *val = _pthread_concur;
-  return 0;
-}
-
-int
-pthread_set_concurrency (int val)
-{
-  _pthread_concur = val;
-  return 0;
-}
-
-void
-pthread_exit (void *res)
-{
-  _pthread_v *t = NULL;
-  unsigned rslt = (unsigned) ((intptr_t) res);
-  struct _pthread_v *id = __pthread_self_lite ();
-
-  id->ret_arg = res;
-
-  _pthread_cleanup_dest (id->x);
-  if (id->thread_noposix == 0)
-    longjmp(id->jb, 1);
-
-  /* Make sure we free ourselves if we are detached */
-  if ((t = (_pthread_v *)TlsGetValue(_pthread_tls)) != NULL)
-    {
-      if (!t->h)
-	{
-	  t->valid = DEAD_THREAD;
-	  if (t->evStart)
-	    CloseHandle (t->evStart);
-	  t->evStart = NULL;
-	  rslt = (unsigned) (size_t) t->ret_arg;
-	  push_pthread_mem(t);
-	  t = NULL;
-	  TlsSetValue (_pthread_tls, t);
-	}
-      else
-	{
-	  rslt = (unsigned) (size_t) t->ret_arg;
-	  t->ended = 1;
-	  if (t->evStart)
-	    CloseHandle (t->evStart);
-	  t->evStart = NULL;
-	  if ((t->p_state & PTHREAD_CREATE_DETACHED) == PTHREAD_CREATE_DETACHED)
-	    {
-	      t->valid = DEAD_THREAD;
-	      CloseHandle (t->h);
-	      t->h = NULL;
-	      push_pthread_mem(t);
-	      t = NULL;
-	      TlsSetValue(_pthread_tls, t);
-	    }
-	}
-    }
-  /* Time to die */
-  _endthreadex(rslt);
-}
-
-void
-_pthread_invoke_cancel (void)
-{
-  _pthread_cleanup *pcup;
-  struct _pthread_v *se = __pthread_self_lite ();
-  se->in_cancel = 1;
-  _pthread_setnobreak (1);
-  InterlockedDecrement(&_pthread_cancelling);
-
-  /* Call cancel queue */
-  for (pcup = se->clean; pcup; pcup = pcup->next)
-    {
-      pcup->func((pthread_once_t *)pcup->arg);
-    }
-
-  _pthread_setnobreak (0);
-  pthread_exit(PTHREAD_CANCELED);
-}
-
-int
-__pthread_shallcancel (void)
-{
-  struct _pthread_v *t;
-  if (!_pthread_cancelling)
-    return 0;
-  t = __pthread_self_lite ();
-  if (t == NULL)
-    return 0;
-  if (t->nobreak <= 0 && t->cancelled && (t->p_state & PTHREAD_CANCEL_ENABLE))
-    return 1;
-  return 0;
-}
-
-void
-_pthread_setnobreak (int v)
-{
-  struct _pthread_v *t = __pthread_self_lite ();
-  if (t == NULL)
-    return;
-  if (v > 0)
-    InterlockedIncrement ((long*)&t->nobreak);
-  else
-    InterlockedDecrement((long*)&t->nobreak);
-}
-
-void
-pthread_testcancel (void)
-{
-  struct _pthread_v *self = __pthread_self_lite ();
-
-  if (!self || self->in_cancel)
-    return;
-  if (!_pthread_cancelling)
-    return;
-  pthread_mutex_lock (&self->p_clock);
-
-  if (self->cancelled && (self->p_state & PTHREAD_CANCEL_ENABLE) && self->nobreak <= 0)
-    {
-      self->in_cancel = 1;
-      self->p_state &= ~PTHREAD_CANCEL_ENABLE;
-      if (self->evStart)
-	ResetEvent (self->evStart);
-      pthread_mutex_unlock (&self->p_clock);
-      _pthread_invoke_cancel ();
-    }
-  pthread_mutex_unlock (&self->p_clock);
-}
-
-int
-pthread_cancel (pthread_t t)
-{
-  struct _pthread_v *tv = __pth_gpointer_locked (t);
-
-  if (tv == NULL)
-    return ESRCH;
-  CHECK_OBJECT(tv, ESRCH);
-  /*if (tv->ended) return ESRCH;*/
-  pthread_mutex_lock(&tv->p_clock);
-  if (pthread_equal(pthread_self(), t))
-    {
-      if(tv->cancelled)
-	{
-	  pthread_mutex_unlock(&tv->p_clock);
-	  return (tv->in_cancel ? ESRCH : 0);
-	}
-      tv->cancelled = 1;
-      InterlockedIncrement(&_pthread_cancelling);
-      if(tv->evStart) SetEvent(tv->evStart);
-      if ((tv->p_state & PTHREAD_CANCEL_ASYNCHRONOUS) != 0 && (tv->p_state & PTHREAD_CANCEL_ENABLE) != 0)
-	{
-	  tv->p_state &= ~PTHREAD_CANCEL_ENABLE;
-	  tv->in_cancel = 1;
-	  pthread_mutex_unlock(&tv->p_clock);
-	  _pthread_invoke_cancel();
-	}
-      else
-	pthread_mutex_unlock(&tv->p_clock);
-      return 0;
-    }
-
-  if ((tv->p_state & PTHREAD_CANCEL_ASYNCHRONOUS) != 0 && (tv->p_state & PTHREAD_CANCEL_ENABLE) != 0)
-    {
-      /* Dangerous asynchronous cancelling */
-      CONTEXT ctxt;
-
-      if(tv->in_cancel)
-	{
-	  pthread_mutex_unlock(&tv->p_clock);
-	  return (tv->in_cancel ? ESRCH : 0);
-	}
-      /* Already done? */
-      if(tv->cancelled || tv->in_cancel)
-	{
-	  /* ??? pthread_mutex_unlock (&tv->p_clock); */
-	  return ESRCH;
-	}
-
-      ctxt.ContextFlags = CONTEXT_CONTROL;
-
-      SuspendThread (tv->h);
-      if (WaitForSingleObject (tv->h, 0) == WAIT_TIMEOUT)
-	{
-	  GetThreadContext(tv->h, &ctxt);
-#ifdef _M_X64
-	  ctxt.Rip = (uintptr_t) _pthread_invoke_cancel;
-#elif defined(_M_IX86)
-	  ctxt.Eip = (uintptr_t) _pthread_invoke_cancel;
-#elif defined(_M_ARM) || defined(_M_ARM64)
-	  ctxt.Pc = (uintptr_t) _pthread_invoke_cancel;
-#else
-#error Unsupported architecture
-#endif
-#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
-	  SetThreadContext (tv->h, &ctxt);
-#endif
-
-	  /* Also try deferred Cancelling */
-	  tv->cancelled = 1;
-	  tv->p_state &= ~PTHREAD_CANCEL_ENABLE;
-	  tv->in_cancel = 1;
-
-	  /* Notify everyone to look */
-	  InterlockedIncrement (&_pthread_cancelling);
-	  if (tv->evStart)
-	    SetEvent (tv->evStart);
-	  pthread_mutex_unlock (&tv->p_clock);
-
-	  ResumeThread (tv->h);
-	}
-    }
-  else
-    {
-      if (tv->cancelled == 0)
-	{
-	  /* Safe deferred Cancelling */
-	  tv->cancelled = 1;
-
-	  /* Notify everyone to look */
-	  InterlockedIncrement (&_pthread_cancelling);
-	  if (tv->evStart)
-	    SetEvent (tv->evStart);
-	}
-      else
-	{
-	  pthread_mutex_unlock (&tv->p_clock);
-	  return (tv->in_cancel ? ESRCH : 0);
-	}
-    }
-  pthread_mutex_unlock (&tv->p_clock);
-  return 0;
-}
-
-/* half-stubbed version as we don't really well support signals */
-int
-pthread_kill (pthread_t t, int sig)
-{
-  struct _pthread_v *tv;
-
-  pthread_mutex_lock (&mtx_pthr_locked);
-  tv = __pthread_get_pointer (t);
-  if (!tv || t != tv->x || tv->in_cancel || tv->ended || tv->h == NULL
-      || tv->h == INVALID_HANDLE_VALUE)
-  {
-    pthread_mutex_unlock (&mtx_pthr_locked);
-    return ESRCH;
-  }
-  pthread_mutex_unlock (&mtx_pthr_locked);
-  if (!sig)
-    return 0;
-  if (sig < SIGINT || sig > NSIG)
-    return EINVAL;
-  return pthread_cancel(t);
-}
-
-unsigned
-_pthread_get_state (const pthread_attr_t *attr, unsigned flag)
-{
-  return (attr->p_state & flag);
-}
-
-int
-_pthread_set_state (pthread_attr_t *attr, unsigned flag, unsigned val)
-{
-  if (~flag & val)
-    return EINVAL;
-  attr->p_state &= ~flag;
-  attr->p_state |= val;
-
-  return 0;
-}
-
-int
-pthread_attr_init (pthread_attr_t *attr)
-{
-  memset (attr, 0, sizeof (pthread_attr_t));
-  attr->p_state = PTHREAD_DEFAULT_ATTR;
-  attr->stack = NULL;
-  attr->s_size = 0;
-  return 0;
-}
-
-int
-pthread_attr_destroy (pthread_attr_t *attr)
-{
-  /* No need to do anything */
-  memset (attr, 0, sizeof(pthread_attr_t));
-  return 0;
-}
-
-int
-pthread_attr_setdetachstate (pthread_attr_t *a, int flag)
-{
-  return _pthread_set_state(a, PTHREAD_CREATE_DETACHED, flag);
-}
-
-int
-pthread_attr_getdetachstate (const pthread_attr_t *a, int *flag)
-{
-  *flag = _pthread_get_state(a, PTHREAD_CREATE_DETACHED);
-  return 0;
-}
-
-int
-pthread_attr_setinheritsched (pthread_attr_t *a, int flag)
-{
-  if (!a || (flag != PTHREAD_INHERIT_SCHED && flag != PTHREAD_EXPLICIT_SCHED))
-    return EINVAL;
-  return _pthread_set_state(a, PTHREAD_INHERIT_SCHED, flag);
-}
-
-int
-pthread_attr_getinheritsched (const pthread_attr_t *a, int *flag)
-{
-  *flag = _pthread_get_state(a, PTHREAD_INHERIT_SCHED);
-  return 0;
-}
-
-int
-pthread_attr_setscope (pthread_attr_t *a, int flag)
-{
-  return _pthread_set_state(a, PTHREAD_SCOPE_SYSTEM, flag);
-}
-
-int
-pthread_attr_getscope (const pthread_attr_t *a, int *flag)
-{
-  *flag = _pthread_get_state(a, PTHREAD_SCOPE_SYSTEM);
-  return 0;
-}
-
-int
-pthread_attr_getstack (const pthread_attr_t *attr, void **stack, size_t *size)
-{
-  *stack = (char *) attr->stack - attr->s_size;
-  *size = attr->s_size;
-  return 0;
-}
-
-int
-pthread_attr_setstack (pthread_attr_t *attr, void *stack, size_t size)
-{
-  attr->s_size = size;
-  attr->stack = (char *) stack + size;
-  return 0;
-}
-
-int
-pthread_attr_getstackaddr (const pthread_attr_t *attr, void **stack)
-{
-  *stack = attr->stack;
-  return 0;
-}
-
-int
-pthread_attr_setstackaddr (pthread_attr_t *attr, void *stack)
-{
-  attr->stack = stack;
-  return 0;
-}
-
-int
-pthread_attr_getstacksize (const pthread_attr_t *attr, size_t *size)
-{
-  *size = attr->s_size;
-  return 0;
-}
-
-int
-pthread_attr_setstacksize (pthread_attr_t *attr, size_t size)
-{
-  attr->s_size = size;
-  return 0;
-}
-
-static void
-test_cancel_locked (pthread_t t)
-{
-  struct _pthread_v *tv = __pth_gpointer_locked (t);
-
-  if (!tv || tv->in_cancel || tv->ended != 0 || (tv->p_state & PTHREAD_CANCEL_ENABLE) == 0)
-    return;
-  if ((tv->p_state & PTHREAD_CANCEL_ASYNCHRONOUS) == 0)
-    return;
-  if (WaitForSingleObject(tv->evStart, 0) != WAIT_OBJECT_0)
-    return;
-  pthread_mutex_unlock (&tv->p_clock);
-  _pthread_invoke_cancel();
-}
-
-int
-pthread_setcancelstate (int state, int *oldstate)
-{
-  _pthread_v *t = __pthread_self_lite ();
-
-  if (!t || (state & PTHREAD_CANCEL_ENABLE) != state)
-    return EINVAL;
-
-  pthread_mutex_lock (&t->p_clock);
-  if (oldstate)
-    *oldstate = t->p_state & PTHREAD_CANCEL_ENABLE;
-  t->p_state &= ~PTHREAD_CANCEL_ENABLE;
-  t->p_state |= state;
-  test_cancel_locked (t->x);
-  pthread_mutex_unlock (&t->p_clock);
-
-  return 0;
-}
-
-int
-pthread_setcanceltype (int type, int *oldtype)
-{
-  _pthread_v *t = __pthread_self_lite ();
-
-  if (!t || (type & PTHREAD_CANCEL_ASYNCHRONOUS) != type)
-    return EINVAL;
-
-  pthread_mutex_lock (&t->p_clock);
-  if (oldtype)
-    *oldtype = t->p_state & PTHREAD_CANCEL_ASYNCHRONOUS;
-  t->p_state &= ~PTHREAD_CANCEL_ASYNCHRONOUS;
-  t->p_state |= type;
-  test_cancel_locked (t->x);
-  pthread_mutex_unlock (&t->p_clock);
-
-  return 0;
-}
-
-void _fpreset (void);
-
-#if defined(__i386__)
-/* Align ESP on 16-byte boundaries. */
-#  if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2)
-__attribute__((force_align_arg_pointer))
-#  endif
-#endif
-int
-pthread_create_wrapper (void *args)
-{
-  unsigned rslt = 0;
-  struct _pthread_v *tv = (struct _pthread_v *)args;
-
-  _fpreset();
-
-  pthread_mutex_lock (&mtx_pthr_locked);
-  pthread_mutex_lock (&tv->p_clock);
-  _pthread_once_raw(&_pthread_tls_once, pthread_tls_init);
-  TlsSetValue(_pthread_tls, tv);
-  tv->tid = GetCurrentThreadId();
-  pthread_mutex_unlock (&tv->p_clock);
-
-
-  if (!setjmp(tv->jb))
-    {
-      intptr_t trslt = (intptr_t) 128;
-      /* Provide to this thread a default exception handler.  */
-      #ifdef __SEH__
-	asm ("\t.tl_start:\n");
-      #endif      /* Call function and save return value */
-      pthread_mutex_unlock (&mtx_pthr_locked);
-      if (tv->func)
-        trslt = (intptr_t) tv->func(tv->ret_arg);
-      #ifdef __SEH__
-	asm ("\tnop\n\t.tl_end: nop\n"
-#ifdef __arm__
-	  "\t.seh_handler __C_specific_handler, %except\n"
-#else
-	  "\t.seh_handler __C_specific_handler, @except\n"
-#endif
-	  "\t.seh_handlerdata\n"
-	  "\t.long 1\n"
-	  "\t.rva .tl_start, .tl_end, _gnu_exception_handler ,.tl_end\n"
-	  "\t.text"
-	  );
-      #endif
-      pthread_mutex_lock (&mtx_pthr_locked);
-      tv->ret_arg = (void*) trslt;
-      /* Clean up destructors */
-      _pthread_cleanup_dest(tv->x);
-    }
-  else
-    pthread_mutex_lock (&mtx_pthr_locked);
-
-  pthread_mutex_lock (&tv->p_clock);
-  rslt = (unsigned) (size_t) tv->ret_arg;
-  /* Make sure we free ourselves if we are detached */
-  if (tv->evStart)
-    CloseHandle (tv->evStart);
-  tv->evStart = NULL;
-  if (!tv->h)
-    {
-      tv->valid = DEAD_THREAD;
-      pthread_mutex_unlock (&tv->p_clock);
-      pthread_mutex_destroy (&tv->p_clock);
-      push_pthread_mem (tv);
-      tv = NULL;
-      TlsSetValue (_pthread_tls, tv);
-    }
-  else
-    {
-      pthread_mutex_unlock (&tv->p_clock);
-      pthread_mutex_destroy (&tv->p_clock);
-      /* Reinitialise p_clock, since there may be attempts at
-         destroying it again in __dyn_tls_thread later on. */
-      tv->p_clock = PTHREAD_MUTEX_INITIALIZER;
-      tv->ended = 1;
-    }
-  while (pthread_mutex_unlock (&mtx_pthr_locked) == 0)
-   Sleep (0);
-  _endthreadex (rslt);
-  return rslt;
-}
-
-int
-pthread_create (pthread_t *th, const pthread_attr_t *attr, void *(* func)(void *), void *arg)
-{
-  HANDLE thrd = NULL;
-  int redo = 0;
-  struct _pthread_v *tv;
-  size_t ssize = 0;
-  pthread_spinlock_t new_spin_keys = PTHREAD_SPINLOCK_INITIALIZER;
-
-  if ((tv = pop_pthread_mem ()) == NULL)
-    return EAGAIN;
-
-  if (th)
-    *th = tv->x;
-
-  /* Save data in pthread_t */
-  tv->ended = 0;
-  tv->ret_arg = arg;
-  tv->func = func;
-  tv->p_state = PTHREAD_DEFAULT_ATTR;
-  tv->h = INVALID_HANDLE_VALUE;
-  /* We retry it here a few times, as events are a limited resource ... */
-  do
-    {
-      tv->evStart = CreateEvent (NULL, 1, 0, NULL);
-      if (tv->evStart != NULL)
-	break;
-      Sleep ((!redo ? 0 : 20));
-    }
-  while (++redo <= 4);
-
-  tv->p_clock = PTHREAD_MUTEX_INITIALIZER;
-  replace_spin_keys (&tv->spin_keys, new_spin_keys);
-  tv->valid = LIFE_THREAD;
-  tv->sched.sched_priority = THREAD_PRIORITY_NORMAL;
-  tv->sched_pol = SCHED_OTHER;
-  if (tv->evStart == NULL)
-    {
-      if (th)
-       memset (th, 0, sizeof (pthread_t));
-      push_pthread_mem (tv);
-      return EAGAIN;
-    }
-
-  if (attr)
-    {
-      int inh = 0;
-      tv->p_state = attr->p_state;
-      ssize = attr->s_size;
-      pthread_attr_getinheritsched (attr, &inh);
-      if (inh)
-	{
-	  tv->sched.sched_priority = __pthread_self_lite ()->sched.sched_priority;
-	}
-      else
-	tv->sched.sched_priority = attr->param.sched_priority;
-    }
-
-  /* Make sure tv->h has value of INVALID_HANDLE_VALUE */
-  _ReadWriteBarrier();
-
-  thrd = (HANDLE) _beginthreadex(NULL, ssize, (unsigned int (__stdcall *)(void *))pthread_create_wrapper, tv, 0x4/*CREATE_SUSPEND*/, NULL);
-  if (thrd == INVALID_HANDLE_VALUE)
-    thrd = 0;
-  /* Failed */
-  if (!thrd)
-    {
-      if (tv->evStart)
-	CloseHandle (tv->evStart);
-      pthread_mutex_destroy (&tv->p_clock);
-      replace_spin_keys (&tv->spin_keys, new_spin_keys);
-      tv->evStart = NULL;
-      tv->h = 0;
-      if (th)
-        memset (th, 0, sizeof (pthread_t));
-      push_pthread_mem (tv);
-      return EAGAIN;
-    }
-  {
-    int pr = tv->sched.sched_priority;
-    if (pr <= THREAD_PRIORITY_IDLE) {
-	pr = THREAD_PRIORITY_IDLE;
-    } else if (pr <= THREAD_PRIORITY_LOWEST) {
-	pr = THREAD_PRIORITY_LOWEST;
-    } else if (pr >= THREAD_PRIORITY_TIME_CRITICAL) {
-	pr = THREAD_PRIORITY_TIME_CRITICAL;
-    } else if (pr >= THREAD_PRIORITY_HIGHEST) {
-	pr = THREAD_PRIORITY_HIGHEST;
-    }
-    SetThreadPriority (thrd, pr);
-  }
-  ResetEvent (tv->evStart);
-  if ((tv->p_state & PTHREAD_CREATE_DETACHED) != 0)
-    {
-      tv->h = 0;
-      ResumeThread (thrd);
-      CloseHandle (thrd);
-    }
-  else
-    {
-      tv->h = thrd;
-      ResumeThread (thrd);
-    }
-  Sleep (0);
-  return 0;
-}
-
-int
-pthread_join (pthread_t t, void **res)
-{
-  DWORD dwFlags;
-  struct _pthread_v *tv = __pth_gpointer_locked (t);
-  pthread_spinlock_t new_spin_keys = PTHREAD_SPINLOCK_INITIALIZER;
-
-  if (!tv || tv->h == NULL || !GetHandleInformation(tv->h, &dwFlags))
-    return ESRCH;
-  if ((tv->p_state & PTHREAD_CREATE_DETACHED) != 0)
-    return EINVAL;
-  if (pthread_equal(pthread_self(), t))
-    return EDEADLK;
-
-  /* pthread_testcancel (); */
-  if (tv->ended == 0 || (tv->h != NULL && tv->h != INVALID_HANDLE_VALUE))
-    WaitForSingleObject (tv->h, INFINITE);
-  CloseHandle (tv->h);
-  if (tv->evStart)
-    CloseHandle (tv->evStart);
-  tv->evStart = NULL;
-  /* Obtain return value */
-  if (res)
-    *res = tv->ret_arg;
-  pthread_mutex_destroy (&tv->p_clock);
-  replace_spin_keys (&tv->spin_keys, new_spin_keys);
-  push_pthread_mem (tv);
-
-  return 0;
-}
-
-int
-_pthread_tryjoin (pthread_t t, void **res)
-{
-  DWORD dwFlags;
-  struct _pthread_v *tv;
-  pthread_spinlock_t new_spin_keys = PTHREAD_SPINLOCK_INITIALIZER;
-
-  pthread_mutex_lock (&mtx_pthr_locked);
-  tv = __pthread_get_pointer (t);
-
-  if (!tv || tv->h == NULL || !GetHandleInformation(tv->h, &dwFlags))
-    {
-      pthread_mutex_unlock (&mtx_pthr_locked);
-      return ESRCH;
-    }
-
-  if ((tv->p_state & PTHREAD_CREATE_DETACHED) != 0)
-    {
-      pthread_mutex_unlock (&mtx_pthr_locked);
-      return EINVAL;
-    }
-  if (pthread_equal(pthread_self(), t))
-    {
-      pthread_mutex_unlock (&mtx_pthr_locked);
-      return EDEADLK;
-    }
-  if(tv->ended == 0 && WaitForSingleObject(tv->h, 0))
-    {
-      if (tv->ended == 0)
-        {
-	      pthread_mutex_unlock (&mtx_pthr_locked);
-	      /* pthread_testcancel (); */
-	      return EBUSY;
-	    }
-    }
-  CloseHandle (tv->h);
-  if (tv->evStart)
-    CloseHandle (tv->evStart);
-  tv->evStart = NULL;
-
-  /* Obtain return value */
-  if (res)
-    *res = tv->ret_arg;
-  pthread_mutex_destroy (&tv->p_clock);
-  replace_spin_keys (&tv->spin_keys, new_spin_keys);
-
-  push_pthread_mem (tv);
-
-  pthread_mutex_unlock (&mtx_pthr_locked);
-  /* pthread_testcancel (); */
-  return 0;
-}
-
-int
-pthread_detach (pthread_t t)
-{
-  int r = 0;
-  DWORD dwFlags;
-  struct _pthread_v *tv = __pth_gpointer_locked (t);
-  HANDLE dw;
-  pthread_spinlock_t new_spin_keys = PTHREAD_SPINLOCK_INITIALIZER;
-
-  pthread_mutex_lock (&mtx_pthr_locked);
-  if (!tv || tv->h == NULL || !GetHandleInformation(tv->h, &dwFlags))
-    {
-      pthread_mutex_unlock (&mtx_pthr_locked);
-      return ESRCH;
-    }
-  if ((tv->p_state & PTHREAD_CREATE_DETACHED) != 0)
-    {
-      pthread_mutex_unlock (&mtx_pthr_locked);
-      return EINVAL;
-    }
-  /* if (tv->ended) r = ESRCH; */
-  dw = tv->h;
-  tv->h = 0;
-  tv->p_state |= PTHREAD_CREATE_DETACHED;
-  _ReadWriteBarrier();
-  if (dw)
-    {
-      CloseHandle (dw);
-      if (tv->ended)
-	{
-	  if (tv->evStart)
-	    CloseHandle (tv->evStart);
-	  tv->evStart = NULL;
-	  pthread_mutex_destroy (&tv->p_clock);
-	  replace_spin_keys (&tv->spin_keys, new_spin_keys);
-	  push_pthread_mem (tv);
-	}
-    }
-  pthread_mutex_unlock (&mtx_pthr_locked);
-
-  return r;
-}
-
-static int dummy_concurrency_level = 0;
-
-int
-pthread_getconcurrency (void)
-{
-  return dummy_concurrency_level;
-}
-
-int
-pthread_setconcurrency (int new_level)
-{
-  dummy_concurrency_level = new_level;
-  return 0;
-}
-
-int
-pthread_setname_np (pthread_t thread, const char *name)
-{
-  struct _pthread_v *tv;
-  char *stored_name;
-
-  if (name == NULL)
-    return EINVAL;
-
-  tv = __pth_gpointer_locked (thread);
-  if (!tv || thread != tv->x || tv->in_cancel || tv->ended || tv->h == NULL
-      || tv->h == INVALID_HANDLE_VALUE)
-    return ESRCH;
-
-  stored_name = strdup (name);
-  if (stored_name == NULL)
-    return ENOMEM;
-
-  if (tv->thread_name != NULL)
-    free (tv->thread_name);
-
-  tv->thread_name = stored_name;
-  SetThreadName (tv->tid, name);
-  return 0;
-}
-
-int
-pthread_getname_np (pthread_t thread, char *name, size_t len)
-{
-  HRESULT result;
-  struct _pthread_v *tv;
-
-  if (name == NULL)
-    return EINVAL;
-
-  tv = __pth_gpointer_locked (thread);
-  if (!tv || thread != tv->x || tv->in_cancel || tv->ended || tv->h == NULL
-      || tv->h == INVALID_HANDLE_VALUE)
-    return ESRCH;
-
-  if (len < 1)
-    return ERANGE;
-
-  if (tv->thread_name == NULL)
-    {
-      name[0] = '\0';
-      return 0;
-    }
-
-  if (strlen (tv->thread_name) >= len)
-    return ERANGE;
-
-  result = StringCchCopyNA (name, len, tv->thread_name, len - 1);
-  if (SUCCEEDED (result))
-    return 0;
-
-  return ERANGE;
-}
diff --git a/thirdparty/winpthreads/src/thread.h b/thirdparty/winpthreads/src/thread.h
deleted file mode 100644
index 729c5bc6..00000000
--- a/thirdparty/winpthreads/src/thread.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef WIN_PTHREAD_H
-#define WIN_PTHREAD_H
-
-#include <windows.h>
-#include <setjmp.h>
-#include "rwlock.h"
-
-#define LIFE_THREAD 0xBAB1F00D
-#define DEAD_THREAD 0xDEADBEEF
-#define EXCEPTION_SET_THREAD_NAME ((DWORD) 0x406D1388)
-
-typedef struct _pthread_v _pthread_v;
-struct _pthread_v
-{
-    unsigned int valid;
-    void *ret_arg;
-    void *(* func)(void *);
-    _pthread_cleanup *clean;
-    int nobreak;
-    HANDLE h;
-    HANDLE evStart;
-    pthread_mutex_t p_clock;
-    int cancelled : 2;
-    int in_cancel : 2;
-    int thread_noposix : 2;
-    unsigned int p_state;
-    unsigned int keymax;
-    void **keyval;
-    unsigned char *keyval_set;
-    char *thread_name;
-    pthread_spinlock_t spin_keys;
-    DWORD tid;
-    int rwlc;
-    pthread_rwlock_t rwlq[RWLS_PER_THREAD];
-    int sched_pol;
-    int ended;
-    struct sched_param sched;
-    jmp_buf jb;
-    struct _pthread_v *next;
-    pthread_t x; /* Internal posix handle.  */
-};
-
-typedef struct __pthread_idlist {
-  struct _pthread_v *ptr;
-  pthread_t id;
-} __pthread_idlist;
-
-int _pthread_tryjoin(pthread_t t, void **res);
-void _pthread_setnobreak(int);
-#ifdef WINPTHREAD_DBG
-void thread_print_set(int state);
-void thread_print(volatile pthread_t t, char *txt);
-#endif
-int  __pthread_shallcancel(void);
-struct _pthread_v *__pth_gpointer_locked (pthread_t id);
-
-#endif
diff --git a/thirdparty/winpthreads/src/version.rc b/thirdparty/winpthreads/src/version.rc
deleted file mode 100644
index 43a61176..00000000
--- a/thirdparty/winpthreads/src/version.rc
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
-   Copyright (c) 2011 mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#include <winver.h>
-#include "wpth_ver.h"
-
-#define WPTH_VERSIONINFO_NAME "WinPthreadGC\0"
-#ifdef _WIN64
-#define WPTH_VERSIONINFO_COMMENT "GNU C build -- MinGW-w64 64-bit\0"
-#else
-#define WPTH_VERSIONINFO_COMMENT "GNU C build -- MinGW-w64 32-bit\0"
-#endif
-
-VS_VERSION_INFO VERSIONINFO
-  FILEVERSION    WPTH_VERSION
-  PRODUCTVERSION WPTH_VERSION
-  FILEFLAGSMASK  VS_FFI_FILEFLAGSMASK
-  FILEFLAGS      0
-  FILEOS         VOS__WINDOWS32
-  FILETYPE       VFT_DLL
-BEGIN
-    BLOCK "StringFileInfo"
-    BEGIN
-        BLOCK "040904b0"
-        BEGIN
-            VALUE "FileDescription", "POSIX WinThreads for Windows\0"
-            VALUE "ProductVersion", WPTH_VERSION_STRING
-            VALUE "FileVersion", WPTH_VERSION_STRING
-            VALUE "InternalName", WPTH_VERSIONINFO_NAME
-            VALUE "OriginalFilename", WPTH_VERSIONINFO_NAME
-            VALUE "CompanyName", "MingW-W64 Project. All rights reserved.\0"
-            VALUE "LegalCopyright", "Copyright (C) MingW-W64 Project Members 2010-2011\0"
-            VALUE "Licence", "ZPL\0"
-            VALUE "Info", "http://mingw-w64.sourceforge.net/\0"
-	    VALUE "Comment", WPTH_VERSIONINFO_COMMENT
-        END
-    END
-    BLOCK "VarFileInfo"
-    BEGIN
-        VALUE "Translation", 0x409, 1200
-    END
-END
-
diff --git a/thirdparty/winpthreads/src/winpthread_internal.h b/thirdparty/winpthreads/src/winpthread_internal.h
deleted file mode 100644
index 015e6ce9..00000000
--- a/thirdparty/winpthreads/src/winpthread_internal.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef WINPTHREAD_INTERNAL_H
-#define WINPTHREAD_INTERNAL_H
-struct _pthread_v * WINPTHREAD_API __pth_gpointer_locked (pthread_t id);
-int pthread_delay_np_ms (DWORD to);
-#endif /*WINPTHREAD_INTERNAL_H*/
diff --git a/thirdparty/winpthreads/src/wpth_ver.h b/thirdparty/winpthreads/src/wpth_ver.h
deleted file mode 100644
index 1089a612..00000000
--- a/thirdparty/winpthreads/src/wpth_ver.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-   Copyright (c) 2011-2016  mingw-w64 project
-
-   Permission is hereby granted, free of charge, to any person obtaining a
-   copy of this software and associated documentation files (the "Software"),
-   to deal in the Software without restriction, including without limitation
-   the rights to use, copy, modify, merge, publish, distribute, sublicense,
-   and/or sell copies of the Software, and to permit persons to whom the
-   Software is furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-*/
-
-#ifndef __WPTHREADS_VERSION__
-#define __WPTHREADS_VERSION__
-
-#define WPTH_VERSION 1,0,0,0
-#define WPTH_VERSION_STRING "1, 0, 0, 0\0"
-
-#endif

From e54756000ebde9ce8b5b535bbf5b9ec1fc92daa3 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 15 Jun 2023 14:26:36 -0700
Subject: [PATCH 21/71] Format binding generator.

---
 .../quickjs/builtin_binding_generator.py      | 211 ++++++++++++------
 1 file changed, 143 insertions(+), 68 deletions(-)

diff --git a/thirdparty/quickjs/builtin_binding_generator.py b/thirdparty/quickjs/builtin_binding_generator.py
index 2ca05276..8f3ea0de 100644
--- a/thirdparty/quickjs/builtin_binding_generator.py
+++ b/thirdparty/quickjs/builtin_binding_generator.py
@@ -122,9 +122,7 @@ def apply_pattern(template, values):
 
 def generate_constructor(cls):
     TemplateConstructorName = "${class}_constructor"
-    TemplateConstructorDeclare = (
-        "static JSValue ${class}_constructor(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv);\n"
-    )
+    TemplateConstructorDeclare = "static JSValue ${class}_constructor(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv);\n"
     TemplateConstructor = """
 static JSValue ${func}(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv) {
 	${class} tmp;
@@ -427,51 +425,94 @@ def generate_constructor(cls):
 """,
         "PackedByteArray": apply_pattern(
             TemplatePackedArrays,
-            {"class": "PackedByteArray", "type": "Variant::PACKED_BYTE_ARRAY", "element": "uint8_t"},
+            {
+                "class": "PackedByteArray",
+                "type": "Variant::PACKED_BYTE_ARRAY",
+                "element": "uint8_t",
+            },
         ),
         "PackedInt32Array": apply_pattern(
             TemplatePackedArrays,
-            {"class": "PackedInt32Array", "type": "Variant::PACKED_INT32_ARRAY", "element": "int32_t"},
+            {
+                "class": "PackedInt32Array",
+                "type": "Variant::PACKED_INT32_ARRAY",
+                "element": "int32_t",
+            },
         ),
         "PackedInt64Array": apply_pattern(
             TemplatePackedArrays,
-            {"class": "PackedInt64Array", "type": "Variant::PACKED_INT64_ARRAY", "element": "int64_t"},
+            {
+                "class": "PackedInt64Array",
+                "type": "Variant::PACKED_INT64_ARRAY",
+                "element": "int64_t",
+            },
         ),
         "PackedFloat32Array": apply_pattern(
             TemplatePackedArrays,
-            {"class": "PackedFloat32Array", "type": "Variant::PACKED32_FLOAT_ARRAY", "element": "real_t"},
+            {
+                "class": "PackedFloat32Array",
+                "type": "Variant::PACKED32_FLOAT_ARRAY",
+                "element": "real_t",
+            },
         ),
         "PackedFloat64Array": apply_pattern(
             TemplatePackedArrays,
-            {"class": "PackedFloat64Array", "type": "Variant::PACKED64_FLOAT_ARRAY", "element": "real_t"},
+            {
+                "class": "PackedFloat64Array",
+                "type": "Variant::PACKED64_FLOAT_ARRAY",
+                "element": "real_t",
+            },
         ),
         "PackedVector2Array": apply_pattern(
             TemplatePackedArrays,
-            {"class": "PackedVector2Array", "type": "Variant::PACKED_VECTOR2_ARRAY", "element": "Vector2"},
+            {
+                "class": "PackedVector2Array",
+                "type": "Variant::PACKED_VECTOR2_ARRAY",
+                "element": "Vector2",
+            },
         ),
         "PackedVector3Array": apply_pattern(
             TemplatePackedArrays,
-            {"class": "PackedVector3Array", "type": "Variant::PACKED_VECTOR3_ARRAY", "element": "Vector3"},
+            {
+                "class": "PackedVector3Array",
+                "type": "Variant::PACKED_VECTOR3_ARRAY",
+                "element": "Vector3",
+            },
         ),
         "PackedColorArray": apply_pattern(
             TemplatePackedArrays,
-            {"class": "PackedColorArray", "type": "Variant::PACKED_COLOR_ARRAY", "element": "Color"},
+            {
+                "class": "PackedColorArray",
+                "type": "Variant::PACKED_COLOR_ARRAY",
+                "element": "Color",
+            },
         ),
         "PackedStringArray": apply_pattern(
             TemplateSimplePackedArrays,
-            {"class": "PackedStringArray", "type": "Variant::PACKED_STRING_ARRAY", "element": "String"},
+            {
+                "class": "PackedStringArray",
+                "type": "Variant::PACKED_STRING_ARRAY",
+                "element": "String",
+            },
         ),
     }
     class_name = cls["name"]
     constructor_name = apply_pattern(TemplateConstructorName, {"class": class_name})
-    constructor_declare = apply_pattern(TemplateConstructorDeclare, {"class": class_name})
+    constructor_declare = apply_pattern(
+        TemplateConstructorDeclare, {"class": class_name}
+    )
 
     initializer = ""
     if class_name in ConstructorInitializers:
         initializer = ConstructorInitializers[class_name]
     constructor = apply_pattern(
         TemplateConstructor,
-        {"class": class_name, "type": VariantTypes[class_name], "func": constructor_name, "initializer": initializer},
+        {
+            "class": class_name,
+            "type": VariantTypes[class_name],
+            "func": constructor_name,
+            "initializer": initializer,
+        },
     )
     return constructor_name, constructor_declare, constructor
 
@@ -513,9 +554,7 @@ def generate_members(cls):
 #endif
 				ptr->${native} = ${value};
 				break;"""
-        TemplateItemBinding = (
-            '\tbinder->get_builtin_binder().register_property(${type}, "${name}", getter, setter, ${index});\n'
-        )
+        TemplateItemBinding = '\tbinder->get_builtin_binder().register_property(${type}, "${name}", getter, setter, ${index});\n'
         getters = ""
         setters = ""
         bindings = ""
@@ -529,7 +568,12 @@ def generate_members(cls):
                 {
                     "index": str(i),
                     "value": apply_pattern(
-                        GodotToJSTemplates[type], {"arg": apply_pattern("ptr->${native}", {"native": native_name})}
+                        GodotToJSTemplates[type],
+                        {
+                            "arg": apply_pattern(
+                                "ptr->${native}", {"native": native_name}
+                            )
+                        },
                     ),
                 },
             )
@@ -542,18 +586,28 @@ def generate_members(cls):
                     "type": VariantTypes[type],
                     "type_name": type,
                     "class": class_name,
-                    "value": apply_pattern(JSToGodotTemplates[type], {"arg": "argv[0]"}),
+                    "value": apply_pattern(
+                        JSToGodotTemplates[type], {"arg": "argv[0]"}
+                    ),
                 },
             )
             bindings += apply_pattern(
-                TemplateItemBinding, {"index": str(i), "name": name, "type": VariantTypes[class_name]}
+                TemplateItemBinding,
+                {"index": str(i), "name": name, "type": VariantTypes[class_name]},
             )
         return apply_pattern(
             Template,
-            {"class": class_name, "getters": getters, "setters": setters, "bindings": bindings, "validation": ""},
+            {
+                "class": class_name,
+                "getters": getters,
+                "setters": setters,
+                "bindings": bindings,
+                "validation": "",
+            },
         )
+
     def generate_methods(cls):
-            TemplateMethod = """
+        TemplateMethod = """
         binder->get_builtin_binder().register_method(
             ${type},
             "${name}",
@@ -565,64 +619,77 @@ def generate_methods(cls):
                 return ${return};
             },
             ${argc});"""
-            TemplateArgDeclare = """
+        TemplateArgDeclare = """
         #ifdef DEBUG_METHODS_ENABLED
                 ERR_FAIL_COND_V(!QuickJSBinder::validate_type(ctx, ${type}, argv[${index}]), JS_ThrowTypeError(ctx, "${type_name} expected for argument ${index} of ${class}.${name}"));
         #endif
                 const ${godot_type} &arg${index} = ${arg};
         """
-            TemplateReturnValue = "${godot_type} ret = "
-            bindings = ""
-            for m in cls["methods"]:
-                args = ""
-                arg_declares = ""
-                for i in range(len(m["arguments"])):
-                    arg = m["arguments"][i]
-                    arg_type = arg["type"]
-                    arg_declares += apply_pattern(
-                        TemplateArgDeclare,
-                        {
-                            "index": str(i),
-                            "type": VariantTypes[arg_type],
-                            "type_name": arg_type,
-                            "class": class_name,
-                            "name": m["name"],
-                            "arg": apply_pattern(JSToGodotTemplates[arg_type], {"arg": "argv[" + str(i) + "]"}),
-                            "godot_type": GodotTypeNames[arg_type],
-                        },
-                    )
-                    if i > 0:
-                        args += ", "
-                    args += "arg" + str(i)
-                CallTemplate = (
-                    ""
-                    if m["return"] == "void"
-                    else (apply_pattern(TemplateReturnValue, {"godot_type": GodotTypeNames[m["return"]]}))
-                ) + "ptr->${native_method}(${args});"
-                call = apply_pattern(CallTemplate, {"native_method": m["native_method"], "args": args})
-                bindings += apply_pattern(
-                    TemplateMethod,
+        TemplateReturnValue = "${godot_type} ret = "
+        bindings = ""
+        for m in cls["methods"]:
+            args = ""
+            arg_declares = ""
+            for i in range(len(m["arguments"])):
+                arg = m["arguments"][i]
+                arg_type = arg["type"]
+                arg_declares += apply_pattern(
+                    TemplateArgDeclare,
                     {
+                        "index": str(i),
+                        "type": VariantTypes[arg_type],
+                        "type_name": arg_type,
                         "class": class_name,
-                        "type": VariantTypes[class_name],
                         "name": m["name"],
-                        "call": call,
-                        "arg_declares": arg_declares,
-                        "argc": str(len(m["arguments"])),
-                        "return": "JS_UNDEFINED"
-                        if m["return"] == "void"
-                        else apply_pattern(GodotToJSTemplates[m["return"]], {"arg": "ret"}),
+                        "arg": apply_pattern(
+                            JSToGodotTemplates[arg_type],
+                            {"arg": "argv[" + str(i) + "]"},
+                        ),
+                        "godot_type": GodotTypeNames[arg_type],
                     },
                 )
-            return bindings
-        
+                if i > 0:
+                    args += ", "
+                args += "arg" + str(i)
+            CallTemplate = (
+                ""
+                if m["return"] == "void"
+                else (
+                    apply_pattern(
+                        TemplateReturnValue, {"godot_type": GodotTypeNames[m["return"]]}
+                    )
+                )
+            ) + "ptr->${native_method}(${args});"
+            call = apply_pattern(
+                CallTemplate, {"native_method": m["native_method"], "args": args}
+            )
+            bindings += apply_pattern(
+                TemplateMethod,
+                {
+                    "class": class_name,
+                    "type": VariantTypes[class_name],
+                    "name": m["name"],
+                    "call": call,
+                    "arg_declares": arg_declares,
+                    "argc": str(len(m["arguments"])),
+                    "return": "JS_UNDEFINED"
+                    if m["return"] == "void"
+                    else apply_pattern(GodotToJSTemplates[m["return"]], {"arg": "ret"}),
+                },
+            )
+        return bindings
 
     def generate_constants(cls):
         ConstTemplate = '\tbinder->get_builtin_binder().register_constant(${type}, "${name}", ${value});\n'
         bindings = ""
         for c in cls["constants"]:
             bindings += apply_pattern(
-                ConstTemplate, {"name": c["name"], "type": VariantTypes[class_name], "value": c["value"]}
+                ConstTemplate,
+                {
+                    "name": c["name"],
+                    "type": VariantTypes[class_name],
+                    "value": c["value"],
+                },
             )
         return bindings
 
@@ -686,7 +753,9 @@ def genertate_operators(cls):
                 CallTemplate = (
                     ""
                     if o["return"] == "void"
-                    else apply_pattern(TemplateReturnValue, {"godot_type": GodotTypeNames[o["return"]]})
+                    else apply_pattern(
+                        TemplateReturnValue, {"godot_type": GodotTypeNames[o["return"]]}
+                    )
                 ) + "ptr->${op}(${args});"
                 call = apply_pattern(CallTemplate, {"op": op, "args": args})
                 bindings += apply_pattern(
@@ -700,7 +769,9 @@ def genertate_operators(cls):
                         "target_declare": target_declare,
                         "return": "JS_UNDEFINED"
                         if o["return"] == "void"
-                        else apply_pattern(GodotToJSTemplates[o["return"]], {"arg": "ret"}),
+                        else apply_pattern(
+                            GodotToJSTemplates[o["return"]], {"arg": "ret"}
+                        ),
                         "argc": str(argc),
                     },
                 )
@@ -740,7 +811,9 @@ def genertate_operators(cls):
 
 
 def generate_class_bind_action(cls, constructor):
-    Template = '\tregister_builtin_class(${type}, "${class}", ${constructor}, ${argc});\n'
+    Template = (
+        '\tregister_builtin_class(${type}, "${class}", ${constructor}, ${argc});\n'
+    )
     return apply_pattern(
         Template,
         {
@@ -782,7 +855,9 @@ def generate_builtin_bindings():
         definitions += constructor
         bindings += generate_class_bind_action(cls, constructor_name)
 
-        property_declare, property_defines, property_bind = generate_property_bindings(cls)
+        property_declare, property_defines, property_bind = generate_property_bindings(
+            cls
+        )
         declarations += property_declare
         definitions += property_defines
         bindings += property_bind

From 7655597225ae7972d71ec7f55d25f22257d5e4a5 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 15 Jun 2023 14:47:09 -0700
Subject: [PATCH 22/71] Apply formatting.

---
 .github/workflows/linux_builds.yml |   2 +-
 javascript_binder.h                | 270 +++++-----
 javascript_gc_handler.h            | 364 +++++++-------
 javascript_language.cpp            | 782 ++++++++++++++---------------
 misc/binding_script.js             |  38 +-
 tests/UnitTest.js                  |   2 +-
 6 files changed, 729 insertions(+), 729 deletions(-)

diff --git a/.github/workflows/linux_builds.yml b/.github/workflows/linux_builds.yml
index afa4ac04..b56575e9 100644
--- a/.github/workflows/linux_builds.yml
+++ b/.github/workflows/linux_builds.yml
@@ -215,4 +215,4 @@ jobs:
       uses: ./.github/actions/upload-artifact
       if: ${{ matrix.artifact }}
       with:
-        name: ${{ matrix.cache-name }}
\ No newline at end of file
+        name: ${{ matrix.cache-name }}
diff --git a/javascript_binder.h b/javascript_binder.h
index 2d73e054..4bb88b3f 100644
--- a/javascript_binder.h
+++ b/javascript_binder.h
@@ -1,135 +1,135 @@
-/**************************************************************************/
-/*  javascript_binder.h                                                   */
-/**************************************************************************/
-/*                         This file is part of:                          */
-/*                             GODOT ENGINE                               */
-/*                        https://godotengine.org                         */
-/**************************************************************************/
-/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
-/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
-/*                                                                        */
-/* Permission is hereby granted, free of charge, to any person obtaining  */
-/* a copy of this software and associated documentation files (the        */
-/* "Software"), to deal in the Software without restriction, including    */
-/* without limitation the rights to use, copy, modify, merge, publish,    */
-/* distribute, sublicense, and/or sell copies of the Software, and to     */
-/* permit persons to whom the Software is furnished to do so, subject to  */
-/* the following conditions:                                              */
-/*                                                                        */
-/* The above copyright notice and this permission notice shall be         */
-/* included in all copies or substantial portions of the Software.        */
-/*                                                                        */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
-/**************************************************************************/
-
-#ifndef JAVASCRIPT_BINDER_H
-#define JAVASCRIPT_BINDER_H
-
-#include "core/os/thread.h"
-#include "javascript_gc_handler.h"
-
-typedef JavaScriptGCHandler JSMethodInfo;
-
-struct JavaScriptProperyInfo : public PropertyInfo {
-	Variant default_value;
-};
-
-struct JavaScriptError {
-	int line;
-	int column;
-	String message;
-	String file;
-	Vector<String> stack;
-};
-
-struct BasicJavaScriptClassInfo {
-	bool tool;
-	StringName class_name;
-	String icon_path;
-	const ClassDB::ClassInfo *native_class;
-	HashMap<StringName, MethodInfo> signals;
-	HashMap<StringName, MethodInfo> methods;
-	HashMap<StringName, JavaScriptProperyInfo> properties;
-};
-
-struct JavaScriptClassInfo : public BasicJavaScriptClassInfo {
-	JavaScriptGCHandler constructor;
-	JavaScriptGCHandler prototype;
-};
-
-struct GlobalNumberConstant {
-	StringName name;
-	double_t value;
-};
-
-struct JavaScriptStackInfo {
-	int line;
-	String file;
-	String function;
-};
-
-class JavaScriptBinder {
-protected:
-	// Path ==> JavaScript Class
-	HashMap<String, JavaScriptClassInfo> javascript_classes;
-	HashMap<int64_t, JavaScriptGCHandler> frame_callbacks;
-	HashSet<int64_t> canceled_frame_callbacks;
-	static String BINDING_SCRIPT_CONTENT;
-
-public:
-	enum EvalType {
-		EVAL_TYPE_MODULE,
-		EVAL_TYPE_GLOBAL,
-	};
-
-	JavaScriptBinder() {}
-	virtual ~JavaScriptBinder(){};
-
-	virtual JavaScriptBinder *get_context_binder(void *p_context) = 0;
-	virtual Thread::ID get_thread_id() const = 0;
-
-	virtual void clear_classes() { javascript_classes.clear(); }
-
-	virtual void initialize() = 0;
-	virtual void uninitialize() = 0;
-	virtual void language_finalize() = 0;
-	virtual void frame() = 0;
-
-	virtual JavaScriptGCHandler *alloc_object_binding_data(Object *p_object) = 0;
-	virtual void free_object_binding_data(JavaScriptGCHandler *p_gc_handle) = 0;
-	virtual void godot_refcount_incremented(JavaScriptGCHandler *p_gc_handle) = 0;
-	virtual bool godot_refcount_decremented(JavaScriptGCHandler *p_gc_handle) = 0;
-
-	virtual Error eval_string(const String &p_source, EvalType type, const String &p_path, JavaScriptGCHandler &r_ret) = 0;
-	virtual Error safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, JavaScriptGCHandler &r_ret) = 0;
-	virtual String error_to_string(const JavaScriptError &p_error) = 0;
-	virtual Error get_stacks(List<JavaScriptStackInfo> &r_stacks) = 0;
-	virtual String get_backtrace_message(const List<JavaScriptStackInfo> &stacks) = 0;
-
-	virtual Error compile_to_bytecode(const String &p_code, const String &p_file, Vector<uint8_t> &r_bytecode) = 0;
-	virtual Error load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, JavaScriptGCHandler *r_module) = 0;
-	virtual const JavaScriptClassInfo *parse_javascript_class(const String &p_code, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) = 0;
-	virtual const JavaScriptClassInfo *parse_javascript_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) = 0;
-
-	virtual JavaScriptGCHandler create_js_instance_for_godot_object(const JavaScriptClassInfo *p_class, Object *p_object) = 0;
-	virtual bool get_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) = 0;
-	virtual bool set_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) = 0;
-	virtual bool has_method(const JavaScriptGCHandler &p_object, const StringName &p_name) = 0;
-	virtual bool has_signal(const JavaScriptClassInfo *p_class, const StringName &p_signal) = 0;
-	virtual bool validate(const String &p_code, const String &p_path, JavaScriptError *r_error) = 0;
-
-	virtual Variant call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) = 0;
-	virtual Variant call(const JavaScriptGCHandler &p_fuction, const JavaScriptGCHandler &p_target, const Variant **p_args, int p_argcount, Callable::CallError &r_error) = 0;
-
-#ifdef TOOLS_ENABLED
-	virtual const Dictionary &get_modified_api() const = 0;
-#endif
-};
-
-#endif // JAVASCRIPT_BINDER_H
+/**************************************************************************/
+/*  javascript_binder.h                                                   */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef JAVASCRIPT_BINDER_H
+#define JAVASCRIPT_BINDER_H
+
+#include "core/os/thread.h"
+#include "javascript_gc_handler.h"
+
+typedef JavaScriptGCHandler JSMethodInfo;
+
+struct JavaScriptProperyInfo : public PropertyInfo {
+	Variant default_value;
+};
+
+struct JavaScriptError {
+	int line;
+	int column;
+	String message;
+	String file;
+	Vector<String> stack;
+};
+
+struct BasicJavaScriptClassInfo {
+	bool tool;
+	StringName class_name;
+	String icon_path;
+	const ClassDB::ClassInfo *native_class;
+	HashMap<StringName, MethodInfo> signals;
+	HashMap<StringName, MethodInfo> methods;
+	HashMap<StringName, JavaScriptProperyInfo> properties;
+};
+
+struct JavaScriptClassInfo : public BasicJavaScriptClassInfo {
+	JavaScriptGCHandler constructor;
+	JavaScriptGCHandler prototype;
+};
+
+struct GlobalNumberConstant {
+	StringName name;
+	double_t value;
+};
+
+struct JavaScriptStackInfo {
+	int line;
+	String file;
+	String function;
+};
+
+class JavaScriptBinder {
+protected:
+	// Path ==> JavaScript Class
+	HashMap<String, JavaScriptClassInfo> javascript_classes;
+	HashMap<int64_t, JavaScriptGCHandler> frame_callbacks;
+	HashSet<int64_t> canceled_frame_callbacks;
+	static String BINDING_SCRIPT_CONTENT;
+
+public:
+	enum EvalType {
+		EVAL_TYPE_MODULE,
+		EVAL_TYPE_GLOBAL,
+	};
+
+	JavaScriptBinder() {}
+	virtual ~JavaScriptBinder(){};
+
+	virtual JavaScriptBinder *get_context_binder(void *p_context) = 0;
+	virtual Thread::ID get_thread_id() const = 0;
+
+	virtual void clear_classes() { javascript_classes.clear(); }
+
+	virtual void initialize() = 0;
+	virtual void uninitialize() = 0;
+	virtual void language_finalize() = 0;
+	virtual void frame() = 0;
+
+	virtual JavaScriptGCHandler *alloc_object_binding_data(Object *p_object) = 0;
+	virtual void free_object_binding_data(JavaScriptGCHandler *p_gc_handle) = 0;
+	virtual void godot_refcount_incremented(JavaScriptGCHandler *p_gc_handle) = 0;
+	virtual bool godot_refcount_decremented(JavaScriptGCHandler *p_gc_handle) = 0;
+
+	virtual Error eval_string(const String &p_source, EvalType type, const String &p_path, JavaScriptGCHandler &r_ret) = 0;
+	virtual Error safe_eval_text(const String &p_source, EvalType type, const String &p_path, String &r_error, JavaScriptGCHandler &r_ret) = 0;
+	virtual String error_to_string(const JavaScriptError &p_error) = 0;
+	virtual Error get_stacks(List<JavaScriptStackInfo> &r_stacks) = 0;
+	virtual String get_backtrace_message(const List<JavaScriptStackInfo> &stacks) = 0;
+
+	virtual Error compile_to_bytecode(const String &p_code, const String &p_file, Vector<uint8_t> &r_bytecode) = 0;
+	virtual Error load_bytecode(const Vector<uint8_t> &p_bytecode, const String &p_file, JavaScriptGCHandler *r_module) = 0;
+	virtual const JavaScriptClassInfo *parse_javascript_class(const String &p_code, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) = 0;
+	virtual const JavaScriptClassInfo *parse_javascript_class(const Vector<uint8_t> &p_bytecode, const String &p_path, bool ignore_cacehe, JavaScriptError *r_error) = 0;
+
+	virtual JavaScriptGCHandler create_js_instance_for_godot_object(const JavaScriptClassInfo *p_class, Object *p_object) = 0;
+	virtual bool get_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, Variant &r_ret) = 0;
+	virtual bool set_instance_property(const JavaScriptGCHandler &p_object, const StringName &p_name, const Variant &p_value) = 0;
+	virtual bool has_method(const JavaScriptGCHandler &p_object, const StringName &p_name) = 0;
+	virtual bool has_signal(const JavaScriptClassInfo *p_class, const StringName &p_signal) = 0;
+	virtual bool validate(const String &p_code, const String &p_path, JavaScriptError *r_error) = 0;
+
+	virtual Variant call_method(const JavaScriptGCHandler &p_object, const StringName &p_method, const Variant **p_args, int p_argcount, Callable::CallError &r_error) = 0;
+	virtual Variant call(const JavaScriptGCHandler &p_fuction, const JavaScriptGCHandler &p_target, const Variant **p_args, int p_argcount, Callable::CallError &r_error) = 0;
+
+#ifdef TOOLS_ENABLED
+	virtual const Dictionary &get_modified_api() const = 0;
+#endif
+};
+
+#endif // JAVASCRIPT_BINDER_H
diff --git a/javascript_gc_handler.h b/javascript_gc_handler.h
index a207d5c7..8b111136 100644
--- a/javascript_gc_handler.h
+++ b/javascript_gc_handler.h
@@ -1,182 +1,182 @@
-/**************************************************************************/
-/*  javascript_gc_handler.h                                               */
-/**************************************************************************/
-/*                         This file is part of:                          */
-/*                             GODOT ENGINE                               */
-/*                        https://godotengine.org                         */
-/**************************************************************************/
-/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
-/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
-/*                                                                        */
-/* Permission is hereby granted, free of charge, to any person obtaining  */
-/* a copy of this software and associated documentation files (the        */
-/* "Software"), to deal in the Software without restriction, including    */
-/* without limitation the rights to use, copy, modify, merge, publish,    */
-/* distribute, sublicense, and/or sell copies of the Software, and to     */
-/* permit persons to whom the Software is furnished to do so, subject to  */
-/* the following conditions:                                              */
-/*                                                                        */
-/* The above copyright notice and this permission notice shall be         */
-/* included in all copies or substantial portions of the Software.        */
-/*                                                                        */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
-/**************************************************************************/
-
-#ifndef JAVASCRIPT_GC_HANDLER_H
-#define JAVASCRIPT_GC_HANDLER_H
-
-#include "core/object/object.h"
-#include "core/object/ref_counted.h"
-#include "core/variant/variant.h"
-
-#define PROTOTYPE_LITERAL "prototype"
-#define PROTO_LITERAL "__proto__"
-#define TO_STRING_LITERAL "toString"
-#define JS_CLASS_NAME_LITERAL "class_name"
-#define GODOT_OBJECT_NAME "godot"
-
-struct JavaScriptGCHandler {
-	enum {
-		FLAG_NONE = 0,
-		FLAG_ATOMIC_VALUE = 1 << 1,
-		FLAG_BUILTIN_CLASS = 1 << 2,
-		FLAG_OBJECT = 1 << 3,
-		FLAG_REF_COUNTED = 1 << 4,
-		FLAG_FINALIZED = 1 << 5,
-		FLAG_TRANSFERABLE = 1 << 6,
-	};
-	Variant::Type type;
-	uint8_t flags;
-	void *context;
-	void *javascript_object;
-	union {
-		Object *godot_object;
-		void *godot_builtin_object_ptr;
-		void *native_ptr;
-	};
-
-	_FORCE_INLINE_ Variant get_value() const {
-		switch (type) {
-			case Variant::OBJECT:
-				return godot_object;
-			case Variant::VECTOR2:
-				return *(static_cast<Vector2 *>(godot_builtin_object_ptr));
-			case Variant::RECT2:
-				return *(static_cast<Rect2 *>(godot_builtin_object_ptr));
-			case Variant::QUATERNION:
-				return *(static_cast<Quaternion *>(godot_builtin_object_ptr));
-			case Variant::COLOR:
-				return *(static_cast<Color *>(godot_builtin_object_ptr));
-			case Variant::RID:
-				return *(static_cast<RID *>(godot_builtin_object_ptr));
-			case Variant::TRANSFORM3D:
-				return *(static_cast<Transform3D *>(godot_builtin_object_ptr));
-			case Variant::TRANSFORM2D:
-				return *(static_cast<Transform2D *>(godot_builtin_object_ptr));
-			case Variant::BASIS:
-				return *(static_cast<Basis *>(godot_builtin_object_ptr));
-			case Variant::VECTOR3:
-				return *(static_cast<Vector3 *>(godot_builtin_object_ptr));
-			case Variant::PLANE:
-				return *(static_cast<Plane *>(godot_builtin_object_ptr));
-			case Variant::AABB:
-				return *(static_cast<AABB *>(godot_builtin_object_ptr));
-			case Variant::PACKED_INT32_ARRAY:
-				return *(static_cast<PackedInt32Array *>(godot_builtin_object_ptr));
-			case Variant::PACKED_INT64_ARRAY:
-				return *(static_cast<PackedInt64Array *>(godot_builtin_object_ptr));
-			case Variant::PACKED_BYTE_ARRAY:
-				return *(static_cast<PackedByteArray *>(godot_builtin_object_ptr));
-			case Variant::PACKED_FLOAT32_ARRAY:
-				return *(static_cast<PackedFloat32Array *>(godot_builtin_object_ptr));
-			case Variant::PACKED_FLOAT64_ARRAY:
-				return *(static_cast<PackedFloat64Array *>(godot_builtin_object_ptr));
-			case Variant::PACKED_COLOR_ARRAY:
-				return *(static_cast<PackedColorArray *>(godot_builtin_object_ptr));
-			case Variant::PACKED_STRING_ARRAY:
-				return *(static_cast<PackedStringArray *>(godot_builtin_object_ptr));
-			case Variant::PACKED_VECTOR2_ARRAY:
-				return *(static_cast<PackedVector2Array *>(godot_builtin_object_ptr));
-			case Variant::PACKED_VECTOR3_ARRAY:
-				return *(static_cast<PackedVector3Array *>(godot_builtin_object_ptr));
-			default:
-				return Variant();
-		}
-		return Variant();
-	}
-
-	_FORCE_INLINE_ Object *get_godot_object() {
-		if (flags & FLAG_OBJECT) {
-			return godot_object;
-		}
-		return nullptr;
-	}
-
-	_FORCE_INLINE_ Vector2 *getVector2() const { return static_cast<Vector2 *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Rect2 *getRect2() const { return static_cast<Rect2 *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Color *getColor() const { return static_cast<Color *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ AABB *getAABB() const { return static_cast<AABB *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Vector3 *getVector3() const { return static_cast<Vector3 *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Transform2D *getTransform2D() const { return static_cast<Transform2D *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Transform3D *getTransform3D() const { return static_cast<Transform3D *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Basis *getBasis() const { return static_cast<Basis *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ RID *getRID() const { return static_cast<RID *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Plane *getPlane() const { return static_cast<Plane *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ Quaternion *getQuaternion() const { return static_cast<Quaternion *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedInt32Array *getPackedInt32Array() const { return static_cast<PackedInt32Array *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedInt64Array *getPackedInt64Array() const { return static_cast<PackedInt64Array *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedByteArray *getPackedByteArray() const { return static_cast<PackedByteArray *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedFloat32Array *getPackedFloat32Array() const { return static_cast<PackedFloat32Array *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedFloat64Array *getPackedFloat64Array() const { return static_cast<PackedFloat64Array *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedStringArray *getPackedStringArray() const { return static_cast<PackedStringArray *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedColorArray *getPackedColorArray() const { return static_cast<PackedColorArray *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedVector2Array *getPackedVector2Array() const { return static_cast<PackedVector2Array *>(godot_builtin_object_ptr); }
-	_FORCE_INLINE_ PackedVector3Array *getPackedVector3Array() const { return static_cast<PackedVector3Array *>(godot_builtin_object_ptr); }
-
-	_FORCE_INLINE_ bool is_object() const {
-		return flags & FLAG_OBJECT;
-	}
-
-	_FORCE_INLINE_ bool is_ref_counted() const {
-		return flags & FLAG_REF_COUNTED;
-	}
-
-	_FORCE_INLINE_ bool is_transferable() const {
-		return flags & FLAG_TRANSFERABLE;
-	}
-
-	_FORCE_INLINE_ bool is_atomic_type() const {
-		return flags & FLAG_ATOMIC_VALUE;
-	}
-
-	_FORCE_INLINE_ bool is_finalized() const {
-		return flags & FLAG_FINALIZED;
-	}
-
-	_FORCE_INLINE_ bool is_valid_javascript_object() const {
-		return context != NULL && javascript_object != NULL && !is_finalized();
-	}
-
-	_FORCE_INLINE_ void clear() {
-		type = Variant::NIL;
-		godot_object = NULL;
-		javascript_object = NULL;
-		context = NULL;
-	}
-
-	JavaScriptGCHandler() {
-		type = Variant::NIL;
-		flags = FLAG_NONE;
-		godot_object = NULL;
-		javascript_object = NULL;
-		context = NULL;
-	}
-};
-
-#endif // JAVASCRIPT_GC_HANDLER_H
+/**************************************************************************/
+/*  javascript_gc_handler.h                                               */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#ifndef JAVASCRIPT_GC_HANDLER_H
+#define JAVASCRIPT_GC_HANDLER_H
+
+#include "core/object/object.h"
+#include "core/object/ref_counted.h"
+#include "core/variant/variant.h"
+
+#define PROTOTYPE_LITERAL "prototype"
+#define PROTO_LITERAL "__proto__"
+#define TO_STRING_LITERAL "toString"
+#define JS_CLASS_NAME_LITERAL "class_name"
+#define GODOT_OBJECT_NAME "godot"
+
+struct JavaScriptGCHandler {
+	enum {
+		FLAG_NONE = 0,
+		FLAG_ATOMIC_VALUE = 1 << 1,
+		FLAG_BUILTIN_CLASS = 1 << 2,
+		FLAG_OBJECT = 1 << 3,
+		FLAG_REF_COUNTED = 1 << 4,
+		FLAG_FINALIZED = 1 << 5,
+		FLAG_TRANSFERABLE = 1 << 6,
+	};
+	Variant::Type type;
+	uint8_t flags;
+	void *context;
+	void *javascript_object;
+	union {
+		Object *godot_object;
+		void *godot_builtin_object_ptr;
+		void *native_ptr;
+	};
+
+	_FORCE_INLINE_ Variant get_value() const {
+		switch (type) {
+			case Variant::OBJECT:
+				return godot_object;
+			case Variant::VECTOR2:
+				return *(static_cast<Vector2 *>(godot_builtin_object_ptr));
+			case Variant::RECT2:
+				return *(static_cast<Rect2 *>(godot_builtin_object_ptr));
+			case Variant::QUATERNION:
+				return *(static_cast<Quaternion *>(godot_builtin_object_ptr));
+			case Variant::COLOR:
+				return *(static_cast<Color *>(godot_builtin_object_ptr));
+			case Variant::RID:
+				return *(static_cast<RID *>(godot_builtin_object_ptr));
+			case Variant::TRANSFORM3D:
+				return *(static_cast<Transform3D *>(godot_builtin_object_ptr));
+			case Variant::TRANSFORM2D:
+				return *(static_cast<Transform2D *>(godot_builtin_object_ptr));
+			case Variant::BASIS:
+				return *(static_cast<Basis *>(godot_builtin_object_ptr));
+			case Variant::VECTOR3:
+				return *(static_cast<Vector3 *>(godot_builtin_object_ptr));
+			case Variant::PLANE:
+				return *(static_cast<Plane *>(godot_builtin_object_ptr));
+			case Variant::AABB:
+				return *(static_cast<AABB *>(godot_builtin_object_ptr));
+			case Variant::PACKED_INT32_ARRAY:
+				return *(static_cast<PackedInt32Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_INT64_ARRAY:
+				return *(static_cast<PackedInt64Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_BYTE_ARRAY:
+				return *(static_cast<PackedByteArray *>(godot_builtin_object_ptr));
+			case Variant::PACKED_FLOAT32_ARRAY:
+				return *(static_cast<PackedFloat32Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_FLOAT64_ARRAY:
+				return *(static_cast<PackedFloat64Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_COLOR_ARRAY:
+				return *(static_cast<PackedColorArray *>(godot_builtin_object_ptr));
+			case Variant::PACKED_STRING_ARRAY:
+				return *(static_cast<PackedStringArray *>(godot_builtin_object_ptr));
+			case Variant::PACKED_VECTOR2_ARRAY:
+				return *(static_cast<PackedVector2Array *>(godot_builtin_object_ptr));
+			case Variant::PACKED_VECTOR3_ARRAY:
+				return *(static_cast<PackedVector3Array *>(godot_builtin_object_ptr));
+			default:
+				return Variant();
+		}
+		return Variant();
+	}
+
+	_FORCE_INLINE_ Object *get_godot_object() {
+		if (flags & FLAG_OBJECT) {
+			return godot_object;
+		}
+		return nullptr;
+	}
+
+	_FORCE_INLINE_ Vector2 *getVector2() const { return static_cast<Vector2 *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Rect2 *getRect2() const { return static_cast<Rect2 *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Color *getColor() const { return static_cast<Color *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ AABB *getAABB() const { return static_cast<AABB *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Vector3 *getVector3() const { return static_cast<Vector3 *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Transform2D *getTransform2D() const { return static_cast<Transform2D *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Transform3D *getTransform3D() const { return static_cast<Transform3D *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Basis *getBasis() const { return static_cast<Basis *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ RID *getRID() const { return static_cast<RID *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Plane *getPlane() const { return static_cast<Plane *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ Quaternion *getQuaternion() const { return static_cast<Quaternion *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedInt32Array *getPackedInt32Array() const { return static_cast<PackedInt32Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedInt64Array *getPackedInt64Array() const { return static_cast<PackedInt64Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedByteArray *getPackedByteArray() const { return static_cast<PackedByteArray *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedFloat32Array *getPackedFloat32Array() const { return static_cast<PackedFloat32Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedFloat64Array *getPackedFloat64Array() const { return static_cast<PackedFloat64Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedStringArray *getPackedStringArray() const { return static_cast<PackedStringArray *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedColorArray *getPackedColorArray() const { return static_cast<PackedColorArray *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedVector2Array *getPackedVector2Array() const { return static_cast<PackedVector2Array *>(godot_builtin_object_ptr); }
+	_FORCE_INLINE_ PackedVector3Array *getPackedVector3Array() const { return static_cast<PackedVector3Array *>(godot_builtin_object_ptr); }
+
+	_FORCE_INLINE_ bool is_object() const {
+		return flags & FLAG_OBJECT;
+	}
+
+	_FORCE_INLINE_ bool is_ref_counted() const {
+		return flags & FLAG_REF_COUNTED;
+	}
+
+	_FORCE_INLINE_ bool is_transferable() const {
+		return flags & FLAG_TRANSFERABLE;
+	}
+
+	_FORCE_INLINE_ bool is_atomic_type() const {
+		return flags & FLAG_ATOMIC_VALUE;
+	}
+
+	_FORCE_INLINE_ bool is_finalized() const {
+		return flags & FLAG_FINALIZED;
+	}
+
+	_FORCE_INLINE_ bool is_valid_javascript_object() const {
+		return context != NULL && javascript_object != NULL && !is_finalized();
+	}
+
+	_FORCE_INLINE_ void clear() {
+		type = Variant::NIL;
+		godot_object = NULL;
+		javascript_object = NULL;
+		context = NULL;
+	}
+
+	JavaScriptGCHandler() {
+		type = Variant::NIL;
+		flags = FLAG_NONE;
+		godot_object = NULL;
+		javascript_object = NULL;
+		context = NULL;
+	}
+};
+
+#endif // JAVASCRIPT_GC_HANDLER_H
diff --git a/javascript_language.cpp b/javascript_language.cpp
index 180844d1..ae69e781 100644
--- a/javascript_language.cpp
+++ b/javascript_language.cpp
@@ -1,391 +1,391 @@
-/**************************************************************************/
-/*  javascript_language.cpp                                               */
-/**************************************************************************/
-/*                         This file is part of:                          */
-/*                             GODOT ENGINE                               */
-/*                        https://godotengine.org                         */
-/**************************************************************************/
-/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
-/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
-/*                                                                        */
-/* Permission is hereby granted, free of charge, to any person obtaining  */
-/* a copy of this software and associated documentation files (the        */
-/* "Software"), to deal in the Software without restriction, including    */
-/* without limitation the rights to use, copy, modify, merge, publish,    */
-/* distribute, sublicense, and/or sell copies of the Software, and to     */
-/* permit persons to whom the Software is furnished to do so, subject to  */
-/* the following conditions:                                              */
-/*                                                                        */
-/* The above copyright notice and this permission notice shall be         */
-/* included in all copies or substantial portions of the Software.        */
-/*                                                                        */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
-/**************************************************************************/
-
-#include "javascript_language.h"
-#include "core/io/file_access.h"
-#include "core/object/class_db.h"
-
-#include "javascript_binder.h"
-#include "quickjs_binder.h"
-
-JavaScriptLanguage *JavaScriptLanguage::singleton = nullptr;
-
-namespace JavaScriptInstanceBindingCallbacks {
-
-static void *create_callback(void *p_token, void *p_instance) {
-	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
-		return binder->alloc_object_binding_data(static_cast<Object *>(p_instance));
-	}
-	return nullptr;
-}
-
-static void free_callback(void *p_token, void *p_instance, void *p_binding) {
-	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
-		return binder->free_object_binding_data(static_cast<JavaScriptGCHandler *>(p_binding));
-	}
-}
-
-static GDExtensionBool reference_callback(void *p_token, void *p_binding, GDExtensionBool p_reference) {
-	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
-		if (p_reference) {
-			binder->godot_refcount_incremented(static_cast<JavaScriptGCHandler *>(p_binding));
-			return false;
-		} else {
-			return binder->godot_refcount_decremented(static_cast<JavaScriptGCHandler *>(p_binding));
-		}
-	}
-	return true;
-}
-
-} // namespace JavaScriptInstanceBindingCallbacks
-
-JavaScriptLanguage::JavaScriptLanguage() {
-	ERR_FAIL_COND(singleton);
-	singleton = this;
-	main_binder = memnew(QuickJSBinder);
-	callable_middleman = memnew(CallableMiddleman);
-	instance_binding_callbacks.create_callback = JavaScriptInstanceBindingCallbacks::create_callback;
-	instance_binding_callbacks.free_callback = JavaScriptInstanceBindingCallbacks::free_callback;
-	instance_binding_callbacks.reference_callback = JavaScriptInstanceBindingCallbacks::reference_callback;
-}
-
-JavaScriptLanguage::~JavaScriptLanguage() {
-	memdelete(main_binder);
-	memdelete(callable_middleman);
-}
-
-void JavaScriptLanguage::init() {
-	ERR_FAIL_NULL(main_binder);
-	main_binder->initialize();
-	execute_file("modules/javascript/tests/UnitTest.js");
-}
-
-void JavaScriptLanguage::finish() {
-	ERR_FAIL_NULL(main_binder);
-	main_binder->uninitialize();
-	main_binder->language_finalize();
-}
-
-Error JavaScriptLanguage::execute_file(const String &p_path) {
-	ERR_FAIL_NULL_V(main_binder, ERR_BUG);
-	Error err;
-	String code = FileAccess::get_file_as_string(p_path, &err);
-	if (err == OK) {
-		JavaScriptGCHandler eval_ret;
-		err = main_binder->eval_string(code, JavaScriptBinder::EVAL_TYPE_GLOBAL, p_path, eval_ret);
-	}
-	return err;
-}
-
-void JavaScriptLanguage::get_reserved_words(List<String> *p_words) const {
-	static const char *_reserved_words[] = {
-		"null",
-		"false",
-		"true",
-		"if",
-		"else",
-		"return",
-		"var",
-		"this",
-		"delete",
-		"void",
-		"typeof",
-		"new",
-		"in",
-		"instanceof",
-		"do",
-		"while",
-		"for",
-		"break",
-		"continue",
-		"switch",
-		"case",
-		"default",
-		"throw",
-		"try",
-		"catch",
-		"finally",
-		"function",
-		"debugger",
-		"with",
-		"class",
-		"const",
-		"enum",
-		"export",
-		"default",
-		"extends",
-		"import",
-		"super",
-		"implements",
-		"interface",
-		"let",
-		"package",
-		"private",
-		"protected",
-		"public",
-		"static",
-		"yield",
-		"await",
-		"prototype",
-		"constructor",
-		"get",
-		"set",
-		"of",
-		"__proto__",
-		"undefined",
-		"number",
-		"boolean",
-		"string",
-		"object",
-		"symbol",
-		"arguments",
-		"join",
-		"global",
-		"as",
-		"from",
-		"default",
-		"*",
-		"then",
-		"resolve",
-		"reject",
-		"promise",
-		"proxy",
-		"revoke",
-		"async",
-		"globalThis",
-		"Object",
-		"Array",
-		"Error",
-		"Number",
-		"String",
-		"Boolean",
-		"Symbol",
-		"Arguments",
-		"Math",
-		"JSON",
-		"Date",
-		"Function",
-		"GeneratorFunction",
-		"ForInIterator",
-		"RegExp",
-		"ArrayBuffer",
-		"SharedArrayBuffer",
-		"Uint8ClampedArray",
-		"Int8Array",
-		"Uint8Array",
-		"Int16Array",
-		"Uint16Array",
-		"Int32Array",
-		"Uint32Array",
-		"BigInt64Array",
-		"BigUint64Array",
-		"Float32Array",
-		"Float64Array",
-		"DataView",
-		"Map",
-		"Set",
-		"WeakMap",
-		"WeakSet",
-		"Generator",
-		"Proxy",
-		"Promise",
-		0
-	};
-
-	const char **w = _reserved_words;
-
-	while (*w) {
-		p_words->push_back(*w);
-		w++;
-	}
-}
-
-bool JavaScriptLanguage::is_control_flow_keyword(String p_keyword) const {
-	return p_keyword == "if" ||
-			p_keyword == "else" ||
-			p_keyword == "return" ||
-			p_keyword == "do" ||
-			p_keyword == "while" ||
-			p_keyword == "for" ||
-			p_keyword == "break" ||
-			p_keyword == "continue" ||
-			p_keyword == "switch" ||
-			p_keyword == "case" ||
-			p_keyword == "throw" ||
-			p_keyword == "try" ||
-			p_keyword == "catch" ||
-			p_keyword == "finally";
-}
-
-void JavaScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
-	p_delimiters->push_back("//"); // single-line comment
-	p_delimiters->push_back("/* */"); // delimited comment
-}
-
-void JavaScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
-	p_delimiters->push_back("' '");
-	p_delimiters->push_back("\" \"");
-	p_delimiters->push_back("` `");
-}
-
-Ref<Script> JavaScriptLanguage::make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const {
-	Ref<JavaScript> script;
-	script.instantiate();
-	String src = p_template.replace("%BASE%", p_base_class_name).replace("%CLASS%", p_class_name);
-	script->set_source_code(src);
-	return script;
-}
-
-Vector<ScriptLanguage::ScriptTemplate> JavaScriptLanguage::get_built_in_templates(StringName p_object) {
-	Vector<ScriptLanguage::ScriptTemplate> templates;
-#ifdef TOOLS_ENABLED
-	constexpr size_t len = 2;
-	static const struct ScriptLanguage::ScriptTemplate TEMPLATES[len] = {
-		{ "Node",
-				"Default",
-				"Base template for Node with default Godot cycle methods",
-				"export default class %CLASS% extends " GODOT_OBJECT_NAME ".%BASE% {\n"
-				"    \n"
-				"    constructor() {\n"
-				"        super();\n"
-				"    }\n"
-				"    \n"
-				"    // Called when the node enters the scene tree for the first time.\n"
-				"    _ready() {\n"
-				"        \n"
-				"    }\n"
-				"    \n"
-				"    // Called every frame. 'delta' is the elapsed time since the previous frame.\n"
-				"    _process(delta) {\n"
-				"        \n"
-				"    }\n"
-				"}\n" },
-		{ "Object",
-				"Empty",
-				"Empty template suitable for all Objects",
-				"export default class %CLASS% extends " GODOT_OBJECT_NAME ".%BASE% {\n"
-				"    \n"
-				"    // Declare member variables here. Examples:\n"
-				"    a = 2;\n"
-				"    b = \"text\";\n"
-				"    \n"
-				"    constructor() {\n"
-				"        super();\n"
-				"    }\n"
-				"    \n"
-				"}\n" },
-	};
-
-	for (int i = 0; i < len; i++) {
-		if (TEMPLATES[i].inherit == p_object) {
-			templates.append(TEMPLATES[i]);
-		}
-	}
-#endif
-
-	return templates;
-}
-
-bool JavaScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptError> *r_errors, List<Warning> *r_warnings, HashSet<int> *r_safe_lines) const {
-	JavaScriptError script_error;
-	bool ret = main_binder->validate(p_script, p_path, &script_error);
-	if (!ret) {
-		ScriptError se;
-		se.line = script_error.line;
-		se.column = script_error.column;
-		se.message = script_error.message;
-		r_errors->push_back(se);
-	}
-	return ret;
-}
-
-Script *JavaScriptLanguage::create_script() const {
-	return memnew(JavaScript);
-}
-
-void JavaScriptLanguage::reload_all_scripts() {
-#ifdef TOOLS_ENABLED
-	for (const Ref<JavaScript> &s : scripts) {
-		reload_script(s, true);
-	}
-#endif
-}
-
-void JavaScriptLanguage::reload_script(const Ref<Script> &p_script, bool p_soft_reload) {
-	Ref<JavaScript> s = p_script;
-	if (s.is_valid()) {
-		Error err = OK;
-		Ref<JavaScriptModule> module = ResourceFormatLoaderJavaScriptModule::load_static(s->get_script_path(), "", &err);
-		ERR_FAIL_COND_MSG(err != OK, ("Cannot load script file '" + s->get_script_path() + "'."));
-		s->set_source_code(module->get_source_code());
-		err = s->reload(p_soft_reload);
-		ERR_FAIL_COND_MSG(err != OK, "Parse source code from file '" + s->get_script_path() + "' failed.");
-	}
-}
-
-void JavaScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
-	p_extensions->push_back(EXT_JSMODULE);
-	p_extensions->push_back(EXT_JSCLASS);
-	p_extensions->push_back(EXT_JSON);
-}
-
-void JavaScriptLanguage::frame() {
-	main_binder->frame();
-}
-
-String JavaScriptLanguage::globalize_relative_path(const String &p_relative, const String &p_base_dir) {
-	String file = p_relative;
-	if (file.begins_with(".")) {
-		String base_dir = p_base_dir;
-		while (base_dir.ends_with(".")) {
-			if (base_dir.ends_with("..")) {
-				base_dir = base_dir.get_base_dir().get_base_dir();
-			} else {
-				base_dir = base_dir.get_base_dir();
-			}
-		}
-		String file_path = file;
-		while (file_path.begins_with(".")) {
-			if (file_path.begins_with("../")) {
-				base_dir = base_dir.get_base_dir();
-				file_path = file_path.substr(3);
-			} else if (file_path.begins_with("./")) {
-				file_path = file_path.substr(2);
-			} else {
-				file_path = file_path.get_basename();
-				break;
-			}
-		}
-		if (!base_dir.ends_with("/"))
-			base_dir += "/";
-		file = base_dir + file_path;
-	}
-	return file;
-}
+/**************************************************************************/
+/*  javascript_language.cpp                                               */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "javascript_language.h"
+#include "core/io/file_access.h"
+#include "core/object/class_db.h"
+
+#include "javascript_binder.h"
+#include "quickjs_binder.h"
+
+JavaScriptLanguage *JavaScriptLanguage::singleton = nullptr;
+
+namespace JavaScriptInstanceBindingCallbacks {
+
+static void *create_callback(void *p_token, void *p_instance) {
+	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+		return binder->alloc_object_binding_data(static_cast<Object *>(p_instance));
+	}
+	return nullptr;
+}
+
+static void free_callback(void *p_token, void *p_instance, void *p_binding) {
+	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+		return binder->free_object_binding_data(static_cast<JavaScriptGCHandler *>(p_binding));
+	}
+}
+
+static GDExtensionBool reference_callback(void *p_token, void *p_binding, GDExtensionBool p_reference) {
+	if (JavaScriptBinder *binder = JavaScriptLanguage::get_singleton()->get_thread_binder(Thread::get_caller_id())) {
+		if (p_reference) {
+			binder->godot_refcount_incremented(static_cast<JavaScriptGCHandler *>(p_binding));
+			return false;
+		} else {
+			return binder->godot_refcount_decremented(static_cast<JavaScriptGCHandler *>(p_binding));
+		}
+	}
+	return true;
+}
+
+} // namespace JavaScriptInstanceBindingCallbacks
+
+JavaScriptLanguage::JavaScriptLanguage() {
+	ERR_FAIL_COND(singleton);
+	singleton = this;
+	main_binder = memnew(QuickJSBinder);
+	callable_middleman = memnew(CallableMiddleman);
+	instance_binding_callbacks.create_callback = JavaScriptInstanceBindingCallbacks::create_callback;
+	instance_binding_callbacks.free_callback = JavaScriptInstanceBindingCallbacks::free_callback;
+	instance_binding_callbacks.reference_callback = JavaScriptInstanceBindingCallbacks::reference_callback;
+}
+
+JavaScriptLanguage::~JavaScriptLanguage() {
+	memdelete(main_binder);
+	memdelete(callable_middleman);
+}
+
+void JavaScriptLanguage::init() {
+	ERR_FAIL_NULL(main_binder);
+	main_binder->initialize();
+	execute_file("modules/javascript/tests/UnitTest.js");
+}
+
+void JavaScriptLanguage::finish() {
+	ERR_FAIL_NULL(main_binder);
+	main_binder->uninitialize();
+	main_binder->language_finalize();
+}
+
+Error JavaScriptLanguage::execute_file(const String &p_path) {
+	ERR_FAIL_NULL_V(main_binder, ERR_BUG);
+	Error err;
+	String code = FileAccess::get_file_as_string(p_path, &err);
+	if (err == OK) {
+		JavaScriptGCHandler eval_ret;
+		err = main_binder->eval_string(code, JavaScriptBinder::EVAL_TYPE_GLOBAL, p_path, eval_ret);
+	}
+	return err;
+}
+
+void JavaScriptLanguage::get_reserved_words(List<String> *p_words) const {
+	static const char *_reserved_words[] = {
+		"null",
+		"false",
+		"true",
+		"if",
+		"else",
+		"return",
+		"var",
+		"this",
+		"delete",
+		"void",
+		"typeof",
+		"new",
+		"in",
+		"instanceof",
+		"do",
+		"while",
+		"for",
+		"break",
+		"continue",
+		"switch",
+		"case",
+		"default",
+		"throw",
+		"try",
+		"catch",
+		"finally",
+		"function",
+		"debugger",
+		"with",
+		"class",
+		"const",
+		"enum",
+		"export",
+		"default",
+		"extends",
+		"import",
+		"super",
+		"implements",
+		"interface",
+		"let",
+		"package",
+		"private",
+		"protected",
+		"public",
+		"static",
+		"yield",
+		"await",
+		"prototype",
+		"constructor",
+		"get",
+		"set",
+		"of",
+		"__proto__",
+		"undefined",
+		"number",
+		"boolean",
+		"string",
+		"object",
+		"symbol",
+		"arguments",
+		"join",
+		"global",
+		"as",
+		"from",
+		"default",
+		"*",
+		"then",
+		"resolve",
+		"reject",
+		"promise",
+		"proxy",
+		"revoke",
+		"async",
+		"globalThis",
+		"Object",
+		"Array",
+		"Error",
+		"Number",
+		"String",
+		"Boolean",
+		"Symbol",
+		"Arguments",
+		"Math",
+		"JSON",
+		"Date",
+		"Function",
+		"GeneratorFunction",
+		"ForInIterator",
+		"RegExp",
+		"ArrayBuffer",
+		"SharedArrayBuffer",
+		"Uint8ClampedArray",
+		"Int8Array",
+		"Uint8Array",
+		"Int16Array",
+		"Uint16Array",
+		"Int32Array",
+		"Uint32Array",
+		"BigInt64Array",
+		"BigUint64Array",
+		"Float32Array",
+		"Float64Array",
+		"DataView",
+		"Map",
+		"Set",
+		"WeakMap",
+		"WeakSet",
+		"Generator",
+		"Proxy",
+		"Promise",
+		0
+	};
+
+	const char **w = _reserved_words;
+
+	while (*w) {
+		p_words->push_back(*w);
+		w++;
+	}
+}
+
+bool JavaScriptLanguage::is_control_flow_keyword(String p_keyword) const {
+	return p_keyword == "if" ||
+			p_keyword == "else" ||
+			p_keyword == "return" ||
+			p_keyword == "do" ||
+			p_keyword == "while" ||
+			p_keyword == "for" ||
+			p_keyword == "break" ||
+			p_keyword == "continue" ||
+			p_keyword == "switch" ||
+			p_keyword == "case" ||
+			p_keyword == "throw" ||
+			p_keyword == "try" ||
+			p_keyword == "catch" ||
+			p_keyword == "finally";
+}
+
+void JavaScriptLanguage::get_comment_delimiters(List<String> *p_delimiters) const {
+	p_delimiters->push_back("//"); // single-line comment
+	p_delimiters->push_back("/* */"); // delimited comment
+}
+
+void JavaScriptLanguage::get_string_delimiters(List<String> *p_delimiters) const {
+	p_delimiters->push_back("' '");
+	p_delimiters->push_back("\" \"");
+	p_delimiters->push_back("` `");
+}
+
+Ref<Script> JavaScriptLanguage::make_template(const String &p_template, const String &p_class_name, const String &p_base_class_name) const {
+	Ref<JavaScript> script;
+	script.instantiate();
+	String src = p_template.replace("%BASE%", p_base_class_name).replace("%CLASS%", p_class_name);
+	script->set_source_code(src);
+	return script;
+}
+
+Vector<ScriptLanguage::ScriptTemplate> JavaScriptLanguage::get_built_in_templates(StringName p_object) {
+	Vector<ScriptLanguage::ScriptTemplate> templates;
+#ifdef TOOLS_ENABLED
+	constexpr size_t len = 2;
+	static const struct ScriptLanguage::ScriptTemplate TEMPLATES[len] = {
+		{ "Node",
+				"Default",
+				"Base template for Node with default Godot cycle methods",
+				"export default class %CLASS% extends " GODOT_OBJECT_NAME ".%BASE% {\n"
+				"    \n"
+				"    constructor() {\n"
+				"        super();\n"
+				"    }\n"
+				"    \n"
+				"    // Called when the node enters the scene tree for the first time.\n"
+				"    _ready() {\n"
+				"        \n"
+				"    }\n"
+				"    \n"
+				"    // Called every frame. 'delta' is the elapsed time since the previous frame.\n"
+				"    _process(delta) {\n"
+				"        \n"
+				"    }\n"
+				"}\n" },
+		{ "Object",
+				"Empty",
+				"Empty template suitable for all Objects",
+				"export default class %CLASS% extends " GODOT_OBJECT_NAME ".%BASE% {\n"
+				"    \n"
+				"    // Declare member variables here. Examples:\n"
+				"    a = 2;\n"
+				"    b = \"text\";\n"
+				"    \n"
+				"    constructor() {\n"
+				"        super();\n"
+				"    }\n"
+				"    \n"
+				"}\n" },
+	};
+
+	for (int i = 0; i < len; i++) {
+		if (TEMPLATES[i].inherit == p_object) {
+			templates.append(TEMPLATES[i]);
+		}
+	}
+#endif
+
+	return templates;
+}
+
+bool JavaScriptLanguage::validate(const String &p_script, const String &p_path, List<String> *r_functions, List<ScriptError> *r_errors, List<Warning> *r_warnings, HashSet<int> *r_safe_lines) const {
+	JavaScriptError script_error;
+	bool ret = main_binder->validate(p_script, p_path, &script_error);
+	if (!ret) {
+		ScriptError se;
+		se.line = script_error.line;
+		se.column = script_error.column;
+		se.message = script_error.message;
+		r_errors->push_back(se);
+	}
+	return ret;
+}
+
+Script *JavaScriptLanguage::create_script() const {
+	return memnew(JavaScript);
+}
+
+void JavaScriptLanguage::reload_all_scripts() {
+#ifdef TOOLS_ENABLED
+	for (const Ref<JavaScript> &s : scripts) {
+		reload_script(s, true);
+	}
+#endif
+}
+
+void JavaScriptLanguage::reload_script(const Ref<Script> &p_script, bool p_soft_reload) {
+	Ref<JavaScript> s = p_script;
+	if (s.is_valid()) {
+		Error err = OK;
+		Ref<JavaScriptModule> module = ResourceFormatLoaderJavaScriptModule::load_static(s->get_script_path(), "", &err);
+		ERR_FAIL_COND_MSG(err != OK, ("Cannot load script file '" + s->get_script_path() + "'."));
+		s->set_source_code(module->get_source_code());
+		err = s->reload(p_soft_reload);
+		ERR_FAIL_COND_MSG(err != OK, "Parse source code from file '" + s->get_script_path() + "' failed.");
+	}
+}
+
+void JavaScriptLanguage::get_recognized_extensions(List<String> *p_extensions) const {
+	p_extensions->push_back(EXT_JSMODULE);
+	p_extensions->push_back(EXT_JSCLASS);
+	p_extensions->push_back(EXT_JSON);
+}
+
+void JavaScriptLanguage::frame() {
+	main_binder->frame();
+}
+
+String JavaScriptLanguage::globalize_relative_path(const String &p_relative, const String &p_base_dir) {
+	String file = p_relative;
+	if (file.begins_with(".")) {
+		String base_dir = p_base_dir;
+		while (base_dir.ends_with(".")) {
+			if (base_dir.ends_with("..")) {
+				base_dir = base_dir.get_base_dir().get_base_dir();
+			} else {
+				base_dir = base_dir.get_base_dir();
+			}
+		}
+		String file_path = file;
+		while (file_path.begins_with(".")) {
+			if (file_path.begins_with("../")) {
+				base_dir = base_dir.get_base_dir();
+				file_path = file_path.substr(3);
+			} else if (file_path.begins_with("./")) {
+				file_path = file_path.substr(2);
+			} else {
+				file_path = file_path.get_basename();
+				break;
+			}
+		}
+		if (!base_dir.ends_with("/"))
+			base_dir += "/";
+		file = base_dir + file_path;
+	}
+	return file;
+}
diff --git a/misc/binding_script.js b/misc/binding_script.js
index 54bead50..d32a6844 100644
--- a/misc/binding_script.js
+++ b/misc/binding_script.js
@@ -1,8 +1,8 @@
 // (function start_script_binding() {
-	
+
 // 	const GodotAnonymousConnectionManager = new(class GodotAnonymousConnectionManager extends godot.RefCounted {
 // 		anonymous_connection_index = 0;
-		
+
 // 		get_slot_id(emitter, signal, target) {
 // 			return `__${emitter.get_instance_id()}:${signal}:${target.get_instance_id()}__`;
 // 		}
@@ -11,7 +11,7 @@
 // 			return `__anonymous_slot:${this.anonymous_connection_index++}`;
 // 		}
 // 	})();
-	
+
 // 	const godot_object_connect = godot.Object.prototype.connect;
 // 	Object.defineProperty(godot.Object.prototype, 'connect', {
 // 		// Object.prototype.connect(signal_name, target, method, params, flags)
@@ -19,7 +19,7 @@
 // 			if (args.length < 2) throw new Error('2 or more arguments expected');
 // 			let signal = args[0];
 // 			if (typeof signal !== 'string' || !signal) throw new Error('signal name expected for argument #0');
-			
+
 // 			let offset = 0;
 // 			let target = null;
 // 			let method = null;
@@ -27,7 +27,7 @@
 // 			let target_caller = null;
 // 			let params = [];
 // 			let flags = 0;
-			
+
 // 			if (typeof args[1] === 'function') {
 // 				offset = -1;
 // 				target = GodotAnonymousConnectionManager;
@@ -52,7 +52,7 @@
 // 				if (typeof p === 'number')
 // 					flags = p;
 // 			}
-			
+
 // 			if (typeof method === 'string' && method.length) {
 // 				method_name = method;
 // 			} else if (typeof method === 'function') {
@@ -69,14 +69,14 @@
 // 			} else {
 // 				throw new Error('method name or function expected for signal method');
 // 			}
-			
+
 // 			// console.log("connect", this, signal, target, method_name, params, flags);
 // 			return godot_object_connect.apply(this, [signal, target, method_name, params, flags]);
 // 		},
 // 		writable: false,
 // 		configurable: true
 // 	});
-	
+
 // 	const godot_object_disconnect = godot.Object.prototype.disconnect;
 // 	Object.defineProperty(godot.Object.prototype, 'disconnect', {
 // 		// Object.prototype.disconnect(signal_name, target, method)
@@ -84,12 +84,12 @@
 // 			if (args.length < 2) throw new Error('2 or more arguments expected');
 // 			let signal = args[0];
 // 			if (typeof signal !== 'string' || !signal) throw new Error('signal name expected for argument #0');
-			
+
 // 			let target = null;
 // 			let method_name = null;
 // 			let method = null;
 // 			let slot_id = undefined;
-			
+
 // 			if (typeof args[1] === 'function') {
 // 				target = GodotAnonymousConnectionManager;
 // 				method = args[1];
@@ -102,7 +102,7 @@
 // 			} else {
 // 				throw new Error('method name or function expected');
 // 			}
-			
+
 // 			if (typeof method === 'string' && method) {
 // 				method_name = method;
 // 			} else if (typeof method === 'function') {
@@ -112,7 +112,7 @@
 // 			} else {
 // 				throw new Error('method name or function expected');
 // 			}
-			
+
 // 			if (slot_id) {
 // 				if (typeof target[method_name] !== 'undefined') {
 // 					target[method_name] = undefined;
@@ -126,7 +126,7 @@
 // 		writable: false,
 // 		configurable: true
 // 	});
-	
+
 // 	const godot_object_is_connected = godot.Object.prototype.is_connected;
 // 	Object.defineProperty(godot.Object.prototype, 'is_connected', {
 // 		// Object.prototype.is_connected(signal_name, target, method)
@@ -134,12 +134,12 @@
 // 			if (args.length < 3) throw new Error('3 arguments expected');
 // 			let signal = args[0];
 // 			if (typeof signal !== 'string' || !signal) throw new Error('signal name expected for argument #1');
-			
+
 // 			let target = null;
 // 			let method = null;
 // 			let method_name = null;
 // 			let slot_id = undefined;
-			
+
 // 			if (typeof args[1] === 'function') {
 // 				target = GodotAnonymousConnectionManager;
 // 				method = args[1];
@@ -152,7 +152,7 @@
 // 			} else {
 // 				throw new Error('method name or function expected for argument #2');
 // 			}
-			
+
 // 			if (typeof method === 'string') {
 // 				method_name = method;
 // 			} else if (typeof method === 'function') {
@@ -161,13 +161,13 @@
 // 			} else {
 // 				throw new Error('method name or function expected');
 // 			}
-			
+
 // 			return godot_object_is_connected.apply(this, [signal, target, method_name]);
 // 		},
 // 		writable: false,
 // 		configurable: true
 // 	});
-	
+
 // 	function godot_yield(target, signal) {
 // 		return new Promise(function(resolve, reject) {
 // 			function callback(...args) {
@@ -181,7 +181,7 @@
 // 			target.connect(signal, GodotAnonymousConnectionManager, callback, [], godot.Object.CONNECT_ONESHOT);
 // 		});
 // 	}
-	
+
 // 	Object.defineProperty(godot, 'yield', {
 // 		value: godot_yield,
 // 		writable: false,
diff --git a/tests/UnitTest.js b/tests/UnitTest.js
index 6954d6e7..c9699d38 100644
--- a/tests/UnitTest.js
+++ b/tests/UnitTest.js
@@ -97,4 +97,4 @@ async function run() {
 	const logFunc = passed == count ? console.log : console.warn;
 	logFunc(`Test complete: ${passed}/${count} passed`);
 }
-const _ = run(); // QuickJS BUG ? 返回的是一个 Promise 对象，不赋给临时变量，会导致 Promise 对象无法被 GC 
+const _ = run(); // QuickJS BUG ? 返回的是一个 Promise 对象，不赋给临时变量，会导致 Promise 对象无法被 GC

From 53f40519d176575dccb762c520cbb5e5b7bec423 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 15 Jun 2023 14:48:23 -0700
Subject: [PATCH 23/71] Apply python formatting.

---
 SCsub                                         | 12 ++--
 generate_builtin_api.py                       | 66 +++++--------------
 .../quickjs/builtin_binding_generator.py      | 48 +++++---------
 3 files changed, 36 insertions(+), 90 deletions(-)

diff --git a/SCsub b/SCsub
index 8cfb5b11..d825ed96 100644
--- a/SCsub
+++ b/SCsub
@@ -32,9 +32,7 @@ def dump_text_file_to_cpp(file):
 if JS_ENGINE == "quickjs":
     import generate_builtin_api
 
-    generate_builtin_api.generate_api_json(
-        os.path.join(GetLaunchDir(), "modules", os.path.basename(os.getcwd()))
-    )
+    generate_builtin_api.generate_api_json(os.path.join(GetLaunchDir(), "modules", os.path.basename(os.getcwd())))
     import thirdparty.quickjs.builtin_binding_generator
 
     thirdparty.quickjs.builtin_binding_generator.generate_builtin_bindings()
@@ -49,9 +47,7 @@ if JS_ENGINE == "quickjs":
 
     if TOOLS:
         env_module.add_source_files(env.modules_sources, "tools/editor_tools.cpp")
-    env_module.add_source_files(
-        env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp"
-    )
+    env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp")
     env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/*.cpp")
     env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs/*.c")
 
@@ -75,7 +71,9 @@ sources = [
 ]
 
 if TOOLS:
-    base_text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
+    base_text = (
+        '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
+    )
     tool_fns = {
         "tools/godot.d.ts.gen.cpp": (
             "BUILTIN_DECLARATION_TEXT",
diff --git a/generate_builtin_api.py b/generate_builtin_api.py
index de9ae130..839d5560 100755
--- a/generate_builtin_api.py
+++ b/generate_builtin_api.py
@@ -57,81 +57,63 @@
 }
 
 METHOD_OP_EQUALS = {
-    "arguments": [
-        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
-    ],
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
     "name": "equals",
     "native_method": "operator==",
     "return": "boolean",
 }
 
 METHOD_OP_ADD = {
-    "arguments": [
-        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
-    ],
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
     "name": "add",
     "native_method": "operator+",
     "return": "${class_name}",
 }
 
 METHOD_OP_ADD_ASSIGN = {
-    "arguments": [
-        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
-    ],
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
     "name": "add_assign",
     "native_method": "operator+=",
     "return": "this",
 }
 
 METHOD_OP_SUB = {
-    "arguments": [
-        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
-    ],
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
     "name": "subtract",
     "native_method": "operator-",
     "return": "${class_name}",
 }
 
 METHOD_OP_SUB_ASSIGN = {
-    "arguments": [
-        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
-    ],
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
     "name": "subtract_assign",
     "native_method": "operator-=",
     "return": "this",
 }
 
 METHOD_OP_MUL = {
-    "arguments": [
-        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
-    ],
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
     "name": "multiply",
     "native_method": "operator*",
     "return": "${class_name}",
 }
 
 METHOD_OP_MUL_ASSIGN = {
-    "arguments": [
-        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
-    ],
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
     "name": "multiply_assign",
     "native_method": "operator*=",
     "return": "this",
 }
 
 METHOD_OP_DIV = {
-    "arguments": [
-        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
-    ],
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
     "name": "multiply",
     "native_method": "operator/",
     "return": "${class_name}",
 }
 
 METHOD_OP_DIV_ASSIGN = {
-    "arguments": [
-        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
-    ],
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
     "name": "multiply_assign",
     "native_method": "operator/=",
     "return": "this",
@@ -145,9 +127,7 @@
 }
 
 METHOD_OP_LESS = {
-    "arguments": [
-        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
-    ],
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
     "name": "less",
     "native_method": "operator<",
     "return": "boolean",
@@ -155,18 +135,14 @@
 
 
 METHOD_OP_LESS_EQAUL = {
-    "arguments": [
-        {"default_value": None, "has_default_value": False, "type": "${class_name}"}
-    ],
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "${class_name}"}],
     "name": "less_equal",
     "native_method": "operator<=",
     "return": "boolean",
 }
 
 METHOD_PACKED_ARRAY_GET = {
-    "arguments": [
-        {"default_value": None, "has_default_value": False, "type": "number"}
-    ],
+    "arguments": [{"default_value": None, "has_default_value": False, "type": "number"}],
     "name": "get",
     "native_method": "operator[]",
     "return": "Variant",
@@ -341,17 +317,11 @@ def parse_class(cls):
             continue  # ignore constructors
         if class_name in IGNORED_PROPS and method_name in IGNORED_PROPS[class_name]:
             continue  # ignored methods
-        if (
-            class_name == "PackedByteArray"
-            and method_name.startswith("encode_")
-            or method_name.startswith("decode_")
-        ):
+        if class_name == "PackedByteArray" and method_name.startswith("encode_") or method_name.startswith("decode_"):
             continue  # ignore decode/encode methods
         if class_name == "PackedByteArray" and method_name == "get_string_from_wchar":
             continue
-        return_type = (
-            m.find("return").attrib["type"] if m.find("return") != None else "void"
-        )
+        return_type = m.find("return").attrib["type"] if m.find("return") != None else "void"
         if return_type in TYPE_MAP:
             return_type = TYPE_MAP[return_type]
         arguments = []
@@ -359,9 +329,7 @@ def parse_class(cls):
             dictArg = dict(arg.attrib)
             if "dictArg" in dictArg:
                 dictArg.pop("index")
-            dictArg["default_value"] = (
-                dictArg["default"] if "default" in dictArg else None
-            )
+            dictArg["default_value"] = dictArg["default"] if "default" in dictArg else None
             if "default" in dictArg:
                 dictArg.pop("default")
             type = dictArg["type"]
@@ -415,9 +383,7 @@ def generate_api_json(MODULE_DIR):
         tree = ET.parse(open(os.path.join(DOCS_DIR, cls + ".xml"), "r"))
         data = tree.getroot()
         classes.append(parse_class(data))
-    json.dump(
-        classes, open(OUTPUT_FILE, "w"), ensure_ascii=False, indent=2, sort_keys=True
-    )
+    json.dump(classes, open(OUTPUT_FILE, "w"), ensure_ascii=False, indent=2, sort_keys=True)
 
 
 if __name__ == "__main__":
diff --git a/thirdparty/quickjs/builtin_binding_generator.py b/thirdparty/quickjs/builtin_binding_generator.py
index 8f3ea0de..1e54ff7e 100644
--- a/thirdparty/quickjs/builtin_binding_generator.py
+++ b/thirdparty/quickjs/builtin_binding_generator.py
@@ -122,7 +122,9 @@ def apply_pattern(template, values):
 
 def generate_constructor(cls):
     TemplateConstructorName = "${class}_constructor"
-    TemplateConstructorDeclare = "static JSValue ${class}_constructor(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv);\n"
+    TemplateConstructorDeclare = (
+        "static JSValue ${class}_constructor(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv);\n"
+    )
     TemplateConstructor = """
 static JSValue ${func}(JSContext *ctx, JSValueConst new_target, int argc, JSValueConst *argv) {
 	${class} tmp;
@@ -498,9 +500,7 @@ def generate_constructor(cls):
     }
     class_name = cls["name"]
     constructor_name = apply_pattern(TemplateConstructorName, {"class": class_name})
-    constructor_declare = apply_pattern(
-        TemplateConstructorDeclare, {"class": class_name}
-    )
+    constructor_declare = apply_pattern(TemplateConstructorDeclare, {"class": class_name})
 
     initializer = ""
     if class_name in ConstructorInitializers:
@@ -554,7 +554,9 @@ def generate_members(cls):
 #endif
 				ptr->${native} = ${value};
 				break;"""
-        TemplateItemBinding = '\tbinder->get_builtin_binder().register_property(${type}, "${name}", getter, setter, ${index});\n'
+        TemplateItemBinding = (
+            '\tbinder->get_builtin_binder().register_property(${type}, "${name}", getter, setter, ${index});\n'
+        )
         getters = ""
         setters = ""
         bindings = ""
@@ -569,11 +571,7 @@ def generate_members(cls):
                     "index": str(i),
                     "value": apply_pattern(
                         GodotToJSTemplates[type],
-                        {
-                            "arg": apply_pattern(
-                                "ptr->${native}", {"native": native_name}
-                            )
-                        },
+                        {"arg": apply_pattern("ptr->${native}", {"native": native_name})},
                     ),
                 },
             )
@@ -586,9 +584,7 @@ def generate_members(cls):
                     "type": VariantTypes[type],
                     "type_name": type,
                     "class": class_name,
-                    "value": apply_pattern(
-                        JSToGodotTemplates[type], {"arg": "argv[0]"}
-                    ),
+                    "value": apply_pattern(JSToGodotTemplates[type], {"arg": "argv[0]"}),
                 },
             )
             bindings += apply_pattern(
@@ -654,15 +650,9 @@ def generate_methods(cls):
             CallTemplate = (
                 ""
                 if m["return"] == "void"
-                else (
-                    apply_pattern(
-                        TemplateReturnValue, {"godot_type": GodotTypeNames[m["return"]]}
-                    )
-                )
+                else (apply_pattern(TemplateReturnValue, {"godot_type": GodotTypeNames[m["return"]]}))
             ) + "ptr->${native_method}(${args});"
-            call = apply_pattern(
-                CallTemplate, {"native_method": m["native_method"], "args": args}
-            )
+            call = apply_pattern(CallTemplate, {"native_method": m["native_method"], "args": args})
             bindings += apply_pattern(
                 TemplateMethod,
                 {
@@ -753,9 +743,7 @@ def genertate_operators(cls):
                 CallTemplate = (
                     ""
                     if o["return"] == "void"
-                    else apply_pattern(
-                        TemplateReturnValue, {"godot_type": GodotTypeNames[o["return"]]}
-                    )
+                    else apply_pattern(TemplateReturnValue, {"godot_type": GodotTypeNames[o["return"]]})
                 ) + "ptr->${op}(${args});"
                 call = apply_pattern(CallTemplate, {"op": op, "args": args})
                 bindings += apply_pattern(
@@ -769,9 +757,7 @@ def genertate_operators(cls):
                         "target_declare": target_declare,
                         "return": "JS_UNDEFINED"
                         if o["return"] == "void"
-                        else apply_pattern(
-                            GodotToJSTemplates[o["return"]], {"arg": "ret"}
-                        ),
+                        else apply_pattern(GodotToJSTemplates[o["return"]], {"arg": "ret"}),
                         "argc": str(argc),
                     },
                 )
@@ -811,9 +797,7 @@ def genertate_operators(cls):
 
 
 def generate_class_bind_action(cls, constructor):
-    Template = (
-        '\tregister_builtin_class(${type}, "${class}", ${constructor}, ${argc});\n'
-    )
+    Template = '\tregister_builtin_class(${type}, "${class}", ${constructor}, ${argc});\n'
     return apply_pattern(
         Template,
         {
@@ -855,9 +839,7 @@ def generate_builtin_bindings():
         definitions += constructor
         bindings += generate_class_bind_action(cls, constructor_name)
 
-        property_declare, property_defines, property_bind = generate_property_bindings(
-            cls
-        )
+        property_declare, property_defines, property_bind = generate_property_bindings(cls)
         declarations += property_declare
         definitions += property_defines
         bindings += property_bind

From bcaa41417f27d17f8bc8918ae495f3fa3f1e7fb4 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 15 Jun 2023 15:05:14 -0700
Subject: [PATCH 24/71] Add a condition to avoid building javascript on msvc.

---
 config.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config.py b/config.py
index e9f39c99..951e814f 100644
--- a/config.py
+++ b/config.py
@@ -1,5 +1,5 @@
 def can_build(env, platform):
-    return True
+    return not (platform == "windows" and not env["use_mingw"])
 
 
 def configure(env):

From e3e97ba4558714802bdd16088312272f414247d4 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 15 Jun 2023 15:07:05 -0700
Subject: [PATCH 25/71] Disable unit tests.

---
 tests/{UnitTest.js => UnitTest.js.disabled} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename tests/{UnitTest.js => UnitTest.js.disabled} (100%)

diff --git a/tests/UnitTest.js b/tests/UnitTest.js.disabled
similarity index 100%
rename from tests/UnitTest.js
rename to tests/UnitTest.js.disabled

From 4dad3639da32c9bca1f5092fee1816e47ba2023e Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 15 Jun 2023 15:09:40 -0700
Subject: [PATCH 26/71] Remove c++ version check.

---
 SCsub | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/SCsub b/SCsub
index d825ed96..fefc8dea 100644
--- a/SCsub
+++ b/SCsub
@@ -51,11 +51,6 @@ if JS_ENGINE == "quickjs":
     env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/*.cpp")
     env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs/*.c")
 
-    if env.msvc:
-        env.Append(CXXFLAGS=["/std:c++latest"])
-    else:
-        env_module.Append(CXXFLAGS=["-std=c++20"])
-
 
 # Binding script to run at engine initializing
 with open("misc/godot.binding_script.gen.cpp", "w") as f:

From 537e2b4d8de315fdb2776d6a68c16e26e3ca40e8 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 15 Jun 2023 15:18:07 -0700
Subject: [PATCH 27/71] Avoid extras.

---
 thirdparty/quickjs/quickjs_binder.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/thirdparty/quickjs/quickjs_binder.cpp b/thirdparty/quickjs/quickjs_binder.cpp
index 9093c398..518b7632 100644
--- a/thirdparty/quickjs/quickjs_binder.cpp
+++ b/thirdparty/quickjs/quickjs_binder.cpp
@@ -338,7 +338,6 @@ Variant QuickJSBinder::var_to_variant(JSContext *ctx, JSValue p_val) {
 
 JSValue QuickJSBinder::godot_builtin_function(JSContext *ctx, JSValue this_val, int argc, JSValue *argv, int magic) {
 	Variant ret;
-	Callable::CallError err;
 	String err_msg;
 #if 0 // TODO: builtin functions
 	Expression::BuiltinFunc func = (Expression::BuiltinFunc)magic;

From 5261a4f38acc43d030115db6a6383f0c96b02d4d Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 15 Jun 2023 15:31:56 -0700
Subject: [PATCH 28/71] Only build windows and linux.

---
 config.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config.py b/config.py
index 951e814f..e8b390f5 100644
--- a/config.py
+++ b/config.py
@@ -1,5 +1,5 @@
 def can_build(env, platform):
-    return not (platform == "windows" and not env["use_mingw"])
+    return (platform == "windows" and env["use_mingw"]) or platform == "linux"
 
 
 def configure(env):

From 1c753617ee63ee4aab5372e52a60bf056107fe80 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Sat, 17 Jun 2023 17:46:12 -0700
Subject: [PATCH 29/71] Move versions back to 4.0.

---
 doc_classes/JavaScript.xml       | 2 +-
 doc_classes/JavaScriptModule.xml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc_classes/JavaScript.xml b/doc_classes/JavaScript.xml
index ca3f4659..b7ef4413 100644
--- a/doc_classes/JavaScript.xml
+++ b/doc_classes/JavaScript.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<class name="JavaScript" inherits="Script" version="4.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
+<class name="JavaScript" inherits="Script" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
 	<brief_description>
 		A JavaScript script resource for creating and managing JavaScript scripts in Godot.
 	</brief_description>
diff --git a/doc_classes/JavaScriptModule.xml b/doc_classes/JavaScriptModule.xml
index c9f1c7f9..607cfaad 100644
--- a/doc_classes/JavaScriptModule.xml
+++ b/doc_classes/JavaScriptModule.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<class name="JavaScriptModule" inherits="Resource" version="4.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
+<class name="JavaScriptModule" inherits="Resource" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
 	<brief_description>
 		A JavaScript module resource for managing JavaScript source code and bytecode.
 	</brief_description>

From 9dabb2206e3208785de6e69d3178489c4e07621d Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Sun, 18 Jun 2023 09:04:43 -0700
Subject: [PATCH 30/71] Fix error in includes.

---
 tools/editor_tools.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/editor_tools.h b/tools/editor_tools.h
index de095523..d6ca4443 100644
--- a/tools/editor_tools.h
+++ b/tools/editor_tools.h
@@ -31,7 +31,7 @@
 #ifndef EDITOR_TOOLS_H
 #define EDITOR_TOOLS_H
 
-#include "editor/gui/editor_file_dialog.h"
+#include "editor/editor_file_dialog.h"
 #include "editor/editor_node.h"
 #include "editor/editor_plugin.h"
 

From f430ed20bdcd2e585e7c8758f04a6c3ae8a4bbfe Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Sun, 18 Jun 2023 10:01:20 -0700
Subject: [PATCH 31/71] Handle cases that aren't supported.

---
 thirdparty/quickjs/quickjs/cutils.h | 2 +-
 tools/editor_tools.h                | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/thirdparty/quickjs/quickjs/cutils.h b/thirdparty/quickjs/quickjs/cutils.h
index 09be07a9..a7384f38 100644
--- a/thirdparty/quickjs/quickjs/cutils.h
+++ b/thirdparty/quickjs/quickjs/cutils.h
@@ -31,7 +31,7 @@
 /* set if CPU is big endian */
 #undef WORDS_BIGENDIAN
 
-#if defined(_MSC_VER) || !defined(__MINGW32__)
+#if (defined(_MSC_VER) || !defined(__MINGW32__)) && !defined(LINUX_ENABLED)
 #define likely(x)       (x)
 #define unlikely(x)     (x)
 #define force_inline __forceinline
diff --git a/tools/editor_tools.h b/tools/editor_tools.h
index de095523..d6ca4443 100644
--- a/tools/editor_tools.h
+++ b/tools/editor_tools.h
@@ -31,7 +31,7 @@
 #ifndef EDITOR_TOOLS_H
 #define EDITOR_TOOLS_H
 
-#include "editor/gui/editor_file_dialog.h"
+#include "editor/editor_file_dialog.h"
 #include "editor/editor_node.h"
 #include "editor/editor_plugin.h"
 

From 245f8d0048009c89adc2d89ba5dac080291c5859 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Sun, 18 Jun 2023 10:35:48 -0700
Subject: [PATCH 32/71] Update scons.

---
 config.py                           | 2 +-
 thirdparty/quickjs/quickjs/cutils.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/config.py b/config.py
index e8b390f5..6e8d6202 100644
--- a/config.py
+++ b/config.py
@@ -1,5 +1,5 @@
 def can_build(env, platform):
-    return (platform == "windows" and env["use_mingw"]) or platform == "linux"
+    return (platform == "windows" and env["use_mingw"]) or platform == "linux" or platform == "macos"
 
 
 def configure(env):
diff --git a/thirdparty/quickjs/quickjs/cutils.h b/thirdparty/quickjs/quickjs/cutils.h
index a7384f38..a7839984 100644
--- a/thirdparty/quickjs/quickjs/cutils.h
+++ b/thirdparty/quickjs/quickjs/cutils.h
@@ -31,7 +31,7 @@
 /* set if CPU is big endian */
 #undef WORDS_BIGENDIAN
 
-#if (defined(_MSC_VER) || !defined(__MINGW32__)) && !defined(LINUX_ENABLED)
+#if (defined(_MSC_VER) || !defined(__MINGW32__)) && !defined(LINUX_ENABLED) && !defined(MACOS_ENABLED)
 #define likely(x)       (x)
 #define unlikely(x)     (x)
 #define force_inline __forceinline

From 166c7967dabab178626c2ae53f83a748be144517 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Mon, 19 Jun 2023 14:05:28 -0700
Subject: [PATCH 33/71] Force a tag.

---
 .github/workflows/android_builds.yml    | 2 +-
 .github/workflows/ios_builds.yml        | 2 +-
 .github/workflows/javascript_builds.yml | 2 +-
 .github/workflows/linux_builds.yml      | 2 +-
 .github/workflows/macos_builds.yml      | 2 +-
 .github/workflows/server_builds.yml     | 2 +-
 .github/workflows/windows_builds.yml    | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/android_builds.yml b/.github/workflows/android_builds.yml
index 3506752c..1a4f5d04 100644
--- a/.github/workflows/android_builds.yml
+++ b/.github/workflows/android_builds.yml
@@ -3,7 +3,7 @@ name: 🤖 Android Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: "4.0"
+  GODOT_BASE_BRANCH: "4.0.3-stable"
   SCONSFLAGS: verbose=yes warnings=extra debug_symbols=no module_text_server_fb_enabled=yes
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-android
diff --git a/.github/workflows/ios_builds.yml b/.github/workflows/ios_builds.yml
index 43a3575f..7ee1db6a 100644
--- a/.github/workflows/ios_builds.yml
+++ b/.github/workflows/ios_builds.yml
@@ -3,7 +3,7 @@ name: 🍏 iOS Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: "4.0"
+  GODOT_BASE_BRANCH: "4.0.3-stable"
   SCONSFLAGS: verbose=yes warnings=extra debug_symbols=no module_text_server_fb_enabled=yes
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-ios
diff --git a/.github/workflows/javascript_builds.yml b/.github/workflows/javascript_builds.yml
index c7f2af2c..17d79222 100644
--- a/.github/workflows/javascript_builds.yml
+++ b/.github/workflows/javascript_builds.yml
@@ -3,7 +3,7 @@ name: 🌐 JavaScript Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: "4.0"
+  GODOT_BASE_BRANCH: "4.0.3-stable"
   SCONSFLAGS: verbose=yes warnings=extra debug_symbols=no
   EM_VERSION: 3.1.18
   EM_CACHE_FOLDER: "emsdk-cache"
diff --git a/.github/workflows/linux_builds.yml b/.github/workflows/linux_builds.yml
index b56575e9..67f44914 100644
--- a/.github/workflows/linux_builds.yml
+++ b/.github/workflows/linux_builds.yml
@@ -3,7 +3,7 @@ name: 🐧 Linux Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: "4.0"
+  GODOT_BASE_BRANCH: "4.0.3-stable"
   SCONSFLAGS: '  verbose=yes warnings=extra module_text_server_fb_enabled=yes  '
   DOTNET_NOLOGO: true
   DOTNET_CLI_TELEMETRY_OPTOUT: true
diff --git a/.github/workflows/macos_builds.yml b/.github/workflows/macos_builds.yml
index 4ae295a6..c815f72f 100644
--- a/.github/workflows/macos_builds.yml
+++ b/.github/workflows/macos_builds.yml
@@ -3,7 +3,7 @@ name: 🍎 macOS Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: "4.0"
+  GODOT_BASE_BRANCH: "4.0.3-stable"
   SCONSFLAGS: verbose=yes warnings=extra module_text_server_fb_enabled=yes
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-macos
diff --git a/.github/workflows/server_builds.yml b/.github/workflows/server_builds.yml
index 04fd1e6d..dbbe9ffe 100644
--- a/.github/workflows/server_builds.yml
+++ b/.github/workflows/server_builds.yml
@@ -3,7 +3,7 @@ name: ☁ Server Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: "4.0"
+  GODOT_BASE_BRANCH: "4.0.3-stable"
   SCONSFLAGS: '  verbose=yes warnings=extra module_text_server_fb_enabled=yes  '
   DOTNET_NOLOGO: true
   DOTNET_CLI_TELEMETRY_OPTOUT: true
diff --git a/.github/workflows/windows_builds.yml b/.github/workflows/windows_builds.yml
index 68a7304a..5469b2b1 100644
--- a/.github/workflows/windows_builds.yml
+++ b/.github/workflows/windows_builds.yml
@@ -3,7 +3,7 @@ name: 🏁 Windows Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: "4.0"
+  GODOT_BASE_BRANCH: "4.0.3-stable"
   SCONSFLAGS: '  use_mingw=yes  debug_symbols=no verbose=yes warnings=extra module_text_server_fb_enabled=yes'
   SCONS_CACHE_MSVC_CONFIG: true
 concurrency:

From 17caa75173e72341f2ca7b737e4637897859af6c Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Mon, 19 Jun 2023 14:20:45 -0700
Subject: [PATCH 34/71] Switch to match master.

---
 .github/workflows/android_builds.yml    | 2 +-
 .github/workflows/ios_builds.yml        | 2 +-
 .github/workflows/javascript_builds.yml | 2 +-
 .github/workflows/linux_builds.yml      | 2 +-
 .github/workflows/macos_builds.yml      | 2 +-
 .github/workflows/server_builds.yml     | 2 +-
 .github/workflows/windows_builds.yml    | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/android_builds.yml b/.github/workflows/android_builds.yml
index 1a4f5d04..3fac8e4a 100644
--- a/.github/workflows/android_builds.yml
+++ b/.github/workflows/android_builds.yml
@@ -3,7 +3,7 @@ name: 🤖 Android Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: "4.0.3-stable"
+  GODOT_BASE_BRANCH: "master"
   SCONSFLAGS: verbose=yes warnings=extra debug_symbols=no module_text_server_fb_enabled=yes
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-android
diff --git a/.github/workflows/ios_builds.yml b/.github/workflows/ios_builds.yml
index 7ee1db6a..57f33824 100644
--- a/.github/workflows/ios_builds.yml
+++ b/.github/workflows/ios_builds.yml
@@ -3,7 +3,7 @@ name: 🍏 iOS Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: "4.0.3-stable"
+  GODOT_BASE_BRANCH: "master"
   SCONSFLAGS: verbose=yes warnings=extra debug_symbols=no module_text_server_fb_enabled=yes
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-ios
diff --git a/.github/workflows/javascript_builds.yml b/.github/workflows/javascript_builds.yml
index 17d79222..7fc8b824 100644
--- a/.github/workflows/javascript_builds.yml
+++ b/.github/workflows/javascript_builds.yml
@@ -3,7 +3,7 @@ name: 🌐 JavaScript Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: "4.0.3-stable"
+  GODOT_BASE_BRANCH: "master"
   SCONSFLAGS: verbose=yes warnings=extra debug_symbols=no
   EM_VERSION: 3.1.18
   EM_CACHE_FOLDER: "emsdk-cache"
diff --git a/.github/workflows/linux_builds.yml b/.github/workflows/linux_builds.yml
index 67f44914..6b3c5ea0 100644
--- a/.github/workflows/linux_builds.yml
+++ b/.github/workflows/linux_builds.yml
@@ -3,7 +3,7 @@ name: 🐧 Linux Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: "4.0.3-stable"
+  GODOT_BASE_BRANCH: "master"
   SCONSFLAGS: '  verbose=yes warnings=extra module_text_server_fb_enabled=yes  '
   DOTNET_NOLOGO: true
   DOTNET_CLI_TELEMETRY_OPTOUT: true
diff --git a/.github/workflows/macos_builds.yml b/.github/workflows/macos_builds.yml
index c815f72f..5a20132d 100644
--- a/.github/workflows/macos_builds.yml
+++ b/.github/workflows/macos_builds.yml
@@ -3,7 +3,7 @@ name: 🍎 macOS Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: "4.0.3-stable"
+  GODOT_BASE_BRANCH: "master"
   SCONSFLAGS: verbose=yes warnings=extra module_text_server_fb_enabled=yes
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-macos
diff --git a/.github/workflows/server_builds.yml b/.github/workflows/server_builds.yml
index dbbe9ffe..ca88b2fd 100644
--- a/.github/workflows/server_builds.yml
+++ b/.github/workflows/server_builds.yml
@@ -3,7 +3,7 @@ name: ☁ Server Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: "4.0.3-stable"
+  GODOT_BASE_BRANCH: "master"
   SCONSFLAGS: '  verbose=yes warnings=extra module_text_server_fb_enabled=yes  '
   DOTNET_NOLOGO: true
   DOTNET_CLI_TELEMETRY_OPTOUT: true
diff --git a/.github/workflows/windows_builds.yml b/.github/workflows/windows_builds.yml
index 5469b2b1..7cab8484 100644
--- a/.github/workflows/windows_builds.yml
+++ b/.github/workflows/windows_builds.yml
@@ -3,7 +3,7 @@ name: 🏁 Windows Builds
 - push
 - pull_request
 env:
-  GODOT_BASE_BRANCH: "4.0.3-stable"
+  GODOT_BASE_BRANCH: "master"
   SCONSFLAGS: '  use_mingw=yes  debug_symbols=no verbose=yes warnings=extra module_text_server_fb_enabled=yes'
   SCONS_CACHE_MSVC_CONFIG: true
 concurrency:

From 23ba457407732d6f14b8fbf9f9ad21daa583b995 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Mon, 19 Jun 2023 14:48:31 -0700
Subject: [PATCH 35/71] Update build scripts.

---
 .github/CODEOWNERS                         | 180 +++++++++
 .github/ISSUE_TEMPLATE/bug_report.yml      |  59 +++
 .github/ISSUE_TEMPLATE/config.yml          |  14 +
 .github/PULL_REQUEST_TEMPLATE.md           |   7 +
 .github/actions/godot-build/action.yml     |  57 +--
 .github/actions/godot-cache/action.yml     |  25 +-
 .github/actions/godot-deps/action.yml      |  43 +--
 .github/actions/upload-artifact/action.yml |  18 +-
 .github/workflows/android_builds.yml       | 118 +++---
 .github/workflows/ios_builds.yml           |  73 ++--
 .github/workflows/javascript_builds.yml    |  58 ---
 .github/workflows/linux_builds.yml         | 410 +++++++++++----------
 .github/workflows/macos_builds.yml         | 131 +++----
 .github/workflows/on_tag.yml               |  73 ----
 .github/workflows/runner.yml               |  41 +++
 .github/workflows/server_builds.yml        |  76 ----
 .github/workflows/static_checks.yml        | 110 ++++++
 .github/workflows/web_builds.yml           |  60 +++
 .github/workflows/windows_builds.yml       | 137 +++----
 19 files changed, 979 insertions(+), 711 deletions(-)
 create mode 100644 .github/CODEOWNERS
 create mode 100644 .github/ISSUE_TEMPLATE/bug_report.yml
 create mode 100644 .github/ISSUE_TEMPLATE/config.yml
 create mode 100644 .github/PULL_REQUEST_TEMPLATE.md
 delete mode 100644 .github/workflows/javascript_builds.yml
 delete mode 100644 .github/workflows/on_tag.yml
 create mode 100644 .github/workflows/runner.yml
 delete mode 100644 .github/workflows/server_builds.yml
 create mode 100644 .github/workflows/static_checks.yml
 create mode 100644 .github/workflows/web_builds.yml

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 00000000..031582bc
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1,180 @@
+# Lines starting with '#' are comments.
+# Each line is a file pattern followed by one or more owners.
+# Owners can be @users, @org/teams or emails
+
+# Buildsystem
+
+.*                                  @godotengine/buildsystem
+.github/                            @godotengine/buildsystem
+*.py                                @godotengine/buildsystem
+SConstruct                          @godotengine/buildsystem
+SCsub                               @godotengine/buildsystem
+
+# Core
+
+/core/                              @godotengine/core
+/core/crypto/                       @godotengine/network
+/core/debugger/                     @godotengine/debugger
+/core/extension/                    @godotengine/gdextension
+/core/input/                        @godotengine/input
+
+# Doc
+
+/doc/                               @godotengine/documentation
+doc_classes/*                       @godotengine/documentation
+
+# Drivers
+
+## Audio
+/drivers/alsa/                      @godotengine/audio
+/drivers/alsamidi/                  @godotengine/audio
+/drivers/coreaudio/                 @godotengine/audio
+/drivers/coremidi/                  @godotengine/audio
+/drivers/pulseaudio/                @godotengine/audio
+/drivers/wasapi/                    @godotengine/audio
+/drivers/winmidi/                   @godotengine/audio
+/drivers/xaudio2/                   @godotengine/audio
+
+## Rendering
+/drivers/dummy/                     @godotengine/rendering
+/drivers/gles3/                     @godotengine/rendering
+/drivers/spirv-reflect/             @godotengine/rendering
+/drivers/vulkan/                    @godotengine/rendering
+
+## OS
+/drivers/unix/                      @godotengine/_platforms
+/drivers/windows/                   @godotengine/windows
+
+## Misc
+/drivers/png/                       @godotengine/import
+
+# Editor
+
+/editor/*debugger*                  @godotengine/debugger
+/editor/icons/                      @godotengine/usability
+/editor/import/                     @godotengine/import
+/editor/plugins/*2d_*.*             @godotengine/2d-editor
+/editor/plugins/*3d_*.*             @godotengine/3d-editor
+/editor/plugins/script_*.*          @godotengine/script-editor
+/editor/plugins/*shader*.*          @godotengine/shaders
+/editor/code_editor.*               @godotengine/script-editor
+/editor/*dock*.*                    @godotengine/docks
+/editor/*shader*.*                  @godotengine/shaders
+
+# Main
+
+/main/                              @godotengine/core
+
+# Misc
+
+/misc/                              @godotengine/buildsystem
+
+# Modules
+
+## Audio (+ video)
+/modules/minimp3/                   @godotengine/audio
+/modules/ogg/                       @godotengine/audio
+/modules/opus/                      @godotengine/audio
+/modules/theora/                    @godotengine/audio
+/modules/vorbis/                    @godotengine/audio
+/modules/webm/                      @godotengine/audio
+
+## Import
+/modules/basis_universal/           @godotengine/import
+/modules/bmp/                       @godotengine/import
+/modules/cvtt/                      @godotengine/import
+/modules/dds/                       @godotengine/import
+/modules/etc/                       @godotengine/import
+/modules/fbx/                       @godotengine/import
+/modules/gltf/                      @godotengine/import
+/modules/hdr/                       @godotengine/import
+/modules/jpg/                       @godotengine/import
+/modules/pvr/                       @godotengine/import
+/modules/squish/                    @godotengine/import
+/modules/svg/                       @godotengine/import
+/modules/tga/                       @godotengine/import
+/modules/tinyexr/                   @godotengine/import
+/modules/webp/                      @godotengine/import
+
+## Network
+/modules/enet/                      @godotengine/network
+/modules/mbedtls/                   @godotengine/network
+/modules/upnp/                      @godotengine/network
+/modules/webrtc/                    @godotengine/network
+/modules/websocket/                 @godotengine/network
+
+## Rendering
+/modules/denoise/                   @godotengine/rendering
+/modules/glslang/                   @godotengine/rendering
+/modules/lightmapper_rd/            @godotengine/rendering
+/modules/meshoptimizer/             @godotengine/rendering
+/modules/vhacd/                     @godotengine/rendering
+/modules/xatlas_unwrap/             @godotengine/rendering
+
+## Scripting
+/modules/gdscript/                  @godotengine/gdscript
+/modules/jsonrpc/                   @godotengine/gdscript
+/modules/mono/                      @godotengine/dotnet
+
+## Text
+/modules/freetype/                  @godotengine/buildsystem
+/modules/text_server_adv/           @godotengine/gui-nodes
+/modules/text_server_fb/            @godotengine/gui-nodes
+
+## XR
+/modules/camera/                    @godotengine/xr
+/modules/gdextension/xr/            @godotengine/xr
+/modules/mobile_vr/                 @godotengine/xr
+/modules/webxr/                     @godotengine/xr
+
+## Misc
+/modules/bullet/                    @godotengine/physics
+/modules/csg/                       @godotengine/3d-nodes
+/modules/gdnavigation/              @godotengine/navigation
+/modules/gridmap/                   @godotengine/3d-nodes
+/modules/opensimplex/               @godotengine/3d-nodes
+/modules/regex/                     @godotengine/core
+
+# Platform
+
+/platform/android/                  @godotengine/android
+/platform/ios/                      @godotengine/ios
+/platform/javascript/               @godotengine/html5
+/platform/linuxbsd/                 @godotengine/linux-bsd
+/platform/macos/                    @godotengine/macos
+/platform/uwp/                      @godotengine/uwp
+/platform/windows/                  @godotengine/windows
+
+# Scene
+
+/scene/2d/                          @godotengine/2d-nodes
+/scene/3d/                          @godotengine/3d-nodes
+/scene/animation/                   @godotengine/animation
+/scene/audio/                       @godotengine/audio
+/scene/debugger/                    @godotengine/debugger
+/scene/gui/                         @godotengine/gui-nodes
+/scene/main/                        @godotengine/core
+/scene/resources/default_theme/     @godotengine/gui-nodes
+/scene/resources/font.*             @godotengine/gui-nodes
+/scene/resources/text_line.*        @godotengine/gui-nodes
+/scene/resources/text_paragraph.*   @godotengine/gui-nodes
+/scene/resources/visual_shader*.*   @godotengine/shaders
+
+# Servers
+
+/servers/audio*                     @godotengine/audio
+/servers/camera*                    @godotengine/xr
+/servers/display_server.*           @godotengine/_platforms
+/servers/navigation_server*.*       @godotengine/navigation
+/servers/physics*                   @godotengine/physics
+/servers/rendering*                 @godotengine/rendering
+/servers/text_server.*              @godotengine/gui-nodes
+/servers/xr*                        @godotengine/xr
+
+# Tests
+
+/tests/                             @godotengine/tests
+
+# Thirdparty
+
+/thirdparty/                        @godotengine/buildsystem
diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
new file mode 100644
index 00000000..0b4abac1
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -0,0 +1,59 @@
+name: Bug report
+description: Report a bug in Godot
+body:
+
+- type: markdown
+  attributes:
+    value: |
+      - Read our [CONTRIBUTING.md guide](https://github.com/godotengine/godot/blob/master/CONTRIBUTING.md#reporting-bugs) on reporting bugs.
+      - Write a descriptive issue title above.
+      - Search [open](https://github.com/godotengine/godot/issues) and [closed](https://github.com/godotengine/godot/issues?q=is%3Aissue+is%3Aclosed) issues to ensure it has not already been reported.
+      - Verify that you are using a [supported Godot version](https://docs.godotengine.org/en/stable/about/release_policy.html).
+
+- type: input
+  attributes:
+    label: Godot version
+    description: >
+      Specify the Git commit hash if using a development or non-official build.
+      If you use a custom build, please test if your issue is reproducible in official builds too.
+    placeholder: 3.3.stable, 4.0.dev (3041becc6)
+  validations:
+    required: true
+
+- type: input
+  attributes:
+    label: System information
+    description: |
+      Specify the OS version, and when relevant hardware information.
+      For graphics-related issues, specify the GPU model, driver version, and the rendering backend (GLES2, GLES3, Vulkan).
+    placeholder: Windows 10, GLES3, Intel HD Graphics 620 (27.20.100.9616)
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Issue description
+    description: |
+      Describe your issue briefly. What doesn't work, and how do you expect it to work instead?
+      You can include images or videos with drag and drop, and format code blocks or logs with <code>```</code> tags.
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Steps to reproduce
+    description: |
+      List of steps or sample code that reproduces the issue. Having reproducible issues is a prerequisite for contributors to be able to solve them.
+      If you include a minimal reproduction project below, you can detail how to use it here.
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Minimal reproduction project
+    description: |
+      A small Godot project which reproduces the issue, with no unnecessary files included. Be sure to not include the `.godot` folder in the archive (but keep `project.godot`).
+      Required, unless the reproduction steps are trivial and don't require any project files to be followed. In this case, write "N/A" in the field.
+      Drag and drop a ZIP archive to upload it. **Do not select another field until the project is done uploading.**
+  validations:
+    required: true
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 00000000..f787bec0
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,14 @@
+blank_issues_enabled: false
+
+contact_links:
+  - name: Godot proposals
+    url: https://github.com/godotengine/godot-proposals
+    about: Please submit feature proposals on the Godot proposals repository, not here.
+
+  - name: Godot documentation repository
+    url: https://github.com/godotengine/godot-docs
+    about: Please report issues with documentation on the Godot documentation repository, not here.
+
+  - name: Godot community channels
+    url: https://godotengine.org/community
+    about: Please ask for technical support on one of the other community channels, not here.
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 00000000..8dc712c7
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,7 @@
+<!--
+Please target the `master` branch in priority.
+PRs can target `3.x` if the same change was done in `master`, or is not relevant there.
+
+Relevant fixes are cherry-picked for stable branches as needed by maintainers.
+You can mention in the description if the change is compatible with `3.x`.
+-->
diff --git a/.github/actions/godot-build/action.yml b/.github/actions/godot-build/action.yml
index 564f40d9..377480b1 100644
--- a/.github/actions/godot-build/action.yml
+++ b/.github/actions/godot-build/action.yml
@@ -2,52 +2,35 @@ name: Build Godot
 description: Build Godot with the provided options.
 inputs:
   target:
-    description: The scons target (debug/editor/release).
-    default: editor
-  tools:
-    description: If tools are to be built.
-    default: false
+    description: Build target (editor, template_release, template_debug).
+    default: "editor"
   tests:
-    description: If tests are to be built.
+    description: Unit tests.
     default: false
   platform:
-    description: The Godot platform to build.
+    description: Target platform.
     required: false
   sconsflags:
-    default: ''
+    default: ""
   scons-cache:
     description: The scons cache path.
-    default: ${{ github.workspace }}/.scons-cache/
+    default: "${{ github.workspace }}/.scons-cache/"
   scons-cache-limit:
     description: The scons cache size limit.
+    # actions/cache has 10 GiB limit, and GitHub runners have a 14 GiB disk.
+    # Limit to 7 GiB to avoid having the extracted cache fill the disk.
     default: 7168
-  shell:
-    description: the shell to run this under
-    default: sh
 runs:
-  using: composite
+  using: "composite"
   steps:
-  - name: Scons Build
-    shell: sh
-    env:
-      SCONSFLAGS: ${{ inputs.sconsflags }}
-      SCONS_CACHE: ${{ inputs.scons-cache }}
-      SCONS_CACHE_LIMIT: ${{ inputs.scons-cache-limit }}
-    run: |
-      echo "Building with flags:" ${{ env.SCONSFLAGS }}
-      if [ "${{ inputs.target }}" != "editor" ]; then rm -rf editor; fi  # Ensure we don't include editor code.
-      scons platform=${{ inputs.platform }} target=${{ inputs.target }} tools=${{ inputs.tools }} tests=${{ inputs.tests }} --jobs=2 ${{ env.SCONSFLAGS }}
-      ls -l bin/
-    if: inputs.shell == 'sh'
-  - name: Scons Build
-    shell: msys2 {0}
-    env:
-      SCONSFLAGS: ${{ inputs.sconsflags }}
-      SCONS_CACHE: ${{ inputs.scons-cache }}
-      SCONS_CACHE_LIMIT: ${{ inputs.scons-cache-limit }}
-    run: |
-      echo "Building with flags:" ${{ env.SCONSFLAGS }}
-      if [ "${{ inputs.target }}" != "editor" ]; then rm -rf editor; rm -rf tools; fi  # Ensure we don't include editor code.
-      scons platform=${{ inputs.platform }} target=${{ inputs.target }} tools=${{ inputs.tools }} tests=${{ inputs.tests }} --jobs=2 ${{ env.SCONSFLAGS }}
-      ls -l bin/
-    if: inputs.shell == 'msys2 {0}'
+    - name: Scons Build
+      shell: sh
+      env:
+          SCONSFLAGS: ${{ inputs.sconsflags }}
+          SCONS_CACHE: ${{ inputs.scons-cache }}
+          SCONS_CACHE_LIMIT: ${{ inputs.scons-cache-limit }}
+      run: |
+        echo "Building with flags:" platform=${{ inputs.platform }} target=${{ inputs.target }} tests=${{ inputs.tests }} ${{ env.SCONSFLAGS }}
+        if [ "${{ inputs.target }}" != "editor" ]; then rm -rf editor; fi  # Ensure we don't include editor code.
+        scons platform=${{ inputs.platform }} target=${{ inputs.target }} tests=${{ inputs.tests }} ${{ env.SCONSFLAGS }}
+        ls -l bin/
diff --git a/.github/actions/godot-cache/action.yml b/.github/actions/godot-cache/action.yml
index 72ed281d..2d7afc85 100644
--- a/.github/actions/godot-cache/action.yml
+++ b/.github/actions/godot-cache/action.yml
@@ -3,19 +3,20 @@ description: Setup Godot build cache.
 inputs:
   cache-name:
     description: The cache base name (job name by default).
-    default: ${{github.job}}
+    default: "${{github.job}}"
   scons-cache:
     description: The scons cache path.
-    default: ${{github.workspace}}/.scons-cache/
+    default: "${{github.workspace}}/.scons-cache/"
 runs:
-  using: composite
+  using: "composite"
   steps:
-  - name: Load .scons_cache directory
-    uses: actions/cache@v2
-    with:
-      path: ${{inputs.scons-cache}}
-      key: ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}-${{github.sha}}
-      restore-keys: |
-        ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}-${{github.sha}}
-        ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}
-        ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}
+    # Upload cache on completion and check it out now
+    - name: Load .scons_cache directory
+      uses: actions/cache@v3
+      with:
+        path: ${{inputs.scons-cache}}
+        key: ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}-${{github.sha}}
+        restore-keys: |
+          ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}-${{github.sha}}
+          ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}-${{github.ref}}
+          ${{inputs.cache-name}}-${{env.GODOT_BASE_BRANCH}}
diff --git a/.github/actions/godot-deps/action.yml b/.github/actions/godot-deps/action.yml
index 1d7347bc..38731db5 100644
--- a/.github/actions/godot-deps/action.yml
+++ b/.github/actions/godot-deps/action.yml
@@ -3,32 +3,25 @@ description: Setup python, install the pip version of scons.
 inputs:
   python-version:
     description: The python version to use.
-    default: 3.x
+    default: "3.x"
   python-arch:
     description: The python architecture.
-    default: x64
-  shell:
-    description: the shell to run this under
-    default: sh
+    default: "x64"
 runs:
-  using: composite
+  using: "composite"
   steps:
-  - name: Set up Python 3.x
-    uses: actions/setup-python@v2
-    with:
-      python-version: ${{ inputs.python-version }}
-      architecture: ${{ inputs.python-arch }}
-  - name: Setup scons
-    shell: sh
-    run: |
-      python -c "import sys; print(sys.version)"
-      python -m pip install scons
-      scons --version
-    if: inputs.shell == 'sh'
-  - name: Setup scons
-    shell: msys2 {0}
-    run: |
-      python -c "import sys; print(sys.version)"
-      python -m pip install scons
-      scons --version
-    if: inputs.shell == 'msys2 {0}'
+    # Use python 3.x release (works cross platform)
+    - name: Set up Python 3.x
+      uses: actions/setup-python@v4
+      with:
+        # Semantic version range syntax or exact version of a Python version
+        python-version: ${{ inputs.python-version }}
+        # Optional - x64 or x86 architecture, defaults to x64
+        architecture: ${{ inputs.python-arch }}
+
+    - name: Setup scons
+      shell: bash
+      run: |
+        python -c "import sys; print(sys.version)"
+        python -m pip install scons==4.4.0
+        scons --version
diff --git a/.github/actions/upload-artifact/action.yml b/.github/actions/upload-artifact/action.yml
index 820273b1..ae0e634c 100644
--- a/.github/actions/upload-artifact/action.yml
+++ b/.github/actions/upload-artifact/action.yml
@@ -3,17 +3,17 @@ description: Upload the Godot artifact.
 inputs:
   name:
     description: The artifact name.
-    default: ${{ github.job }}
+    default: "${{ github.job }}"
   path:
     description: The path to upload.
     required: true
-    default: bin/*
+    default: "bin/*"
 runs:
-  using: composite
+  using: "composite"
   steps:
-  - name: Upload Godot Artifact
-    uses: actions/upload-artifact@v2
-    with:
-      name: ${{ inputs.name }}
-      path: ${{ inputs.path }}
-      retention-days: 14
+    - name: Upload Godot Artifact
+      uses: actions/upload-artifact@v3
+      with:
+        name: ${{ inputs.name }}
+        path: ${{ inputs.path }}
+        retention-days: 14
diff --git a/.github/workflows/android_builds.yml b/.github/workflows/android_builds.yml
index 3fac8e4a..42125db9 100644
--- a/.github/workflows/android_builds.yml
+++ b/.github/workflows/android_builds.yml
@@ -1,65 +1,69 @@
 name: 🤖 Android Builds
-'on':
-- push
-- pull_request
+on:
+  workflow_call:
+
+# Global Settings
 env:
-  GODOT_BASE_BRANCH: "master"
-  SCONSFLAGS: verbose=yes warnings=extra debug_symbols=no module_text_server_fb_enabled=yes
+  # Used for the cache key. Add version suffix to force clean build.
+  GODOT_BASE_BRANCH: '4.0'
+  SCONSFLAGS: verbose=yes warnings=extra werror=yes debug_symbols=no module_text_server_fb_enabled=yes
+
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-android
   cancel-in-progress: true
+
 jobs:
   android-template:
-    runs-on: ubuntu-20.04
-    name: Template (target=release, tools=no)
+    runs-on: "ubuntu-20.04"
+    name: Template (target=template_release)
+
     steps:
-    - name: Checkout Godot
-      uses: actions/checkout@v2
-      with:
-        repository: godotengine/godot
-        ref: ${{ env.GODOT_BASE_BRANCH }}
-    - name: Checkout ECMAScript
-      uses: actions/checkout@v2
-      with:
-        path: ${{github.workspace}}/modules/javascript/
-    - name: Make apt sources.list use the default Ubuntu repositories
-      run: |
-        # sudo rm -f /etc/apt/sources.list.d/*
-        # sudo cp -f misc/ci/sources.list /etc/apt/sources.list
-        sudo apt-get update
-    - name: Set up Java 11
-      uses: actions/setup-java@v3
-      with:
-        distribution: temurin
-        java-version: 11
-    - name: Setup Godot build cache
-      uses: ./.github/actions/godot-cache
-      continue-on-error: true
-    - name: Setup python and scons
-      uses: ./modules/javascript/.github/actions/godot-deps
-      with:
-        shell: sh
-    - name: Compilation (armv7)
-      uses: ./modules/javascript/.github/actions/godot-build
-      with:
-        sconsflags: ${{ env.SCONSFLAGS }} android_arch=armv7
-        platform: android
-        target: template_release
-        tools: false
-        shell: sh
-    - name: Compilation (arm64v8)
-      uses: ./modules/javascript/.github/actions/godot-build
-      with:
-        sconsflags: ${{ env.SCONSFLAGS }} android_arch=arm64v8
-        platform: android
-        target: template_release
-        tools: false
-        shell: sh
-    - name: Generate Godot templates
-      run: |
-        cd platform/android/java
-        ./gradlew generateGodotTemplates
-        cd ../../..
-        ls -l bin/
-    - name: Upload artifact
-      uses: ./.github/actions/upload-artifact
+      - name: Checkout Godot
+        uses: actions/checkout@v2
+        with:
+          repository: godotengine/godot
+          ref: ${{ env.GODOT_BASE_BRANCH }}
+
+      - name: Checkout ECMAScript
+        uses: actions/checkout@v2
+        with:
+          path: ${{github.workspace}}/modules/javascript/
+
+      - name: Set up Java 11
+        uses: actions/setup-java@v3
+        with:
+          distribution: temurin
+          java-version: 11
+
+      - name: Setup Godot build cache
+        uses: ./.github/actions/godot-cache
+        continue-on-error: true
+
+      - name: Setup python and scons
+        uses: ./.github/actions/godot-deps
+
+      - name: Compilation (arm32)
+        uses: ./.github/actions/godot-build
+        with:
+          sconsflags: ${{ env.SCONSFLAGS }} arch=arm32
+          platform: android
+          target: template_release
+          tests: false
+
+      - name: Compilation (arm64)
+        uses: ./.github/actions/godot-build
+        with:
+          sconsflags: ${{ env.SCONSFLAGS }} arch=arm64
+          platform: android
+          target: template_release
+          tests: false
+
+      - name: Generate Godot templates
+        run: |
+          cd platform/android/java
+          ./gradlew generateGodotTemplates
+          cd ../../..
+          ls -l bin/
+
+      - name: Upload artifact
+        uses: ./.github/actions/upload-artifact
diff --git a/.github/workflows/ios_builds.yml b/.github/workflows/ios_builds.yml
index 57f33824..78c05c78 100644
--- a/.github/workflows/ios_builds.yml
+++ b/.github/workflows/ios_builds.yml
@@ -1,41 +1,48 @@
 name: 🍏 iOS Builds
-'on':
-- push
-- pull_request
+on:
+  workflow_call:
+
+# Global Settings
 env:
-  GODOT_BASE_BRANCH: "master"
-  SCONSFLAGS: verbose=yes warnings=extra debug_symbols=no module_text_server_fb_enabled=yes
+  # Used for the cache key. Add version suffix to force clean build.
+  GODOT_BASE_BRANCH: '4.0'
+  SCONSFLAGS: verbose=yes warnings=extra werror=yes debug_symbols=no module_text_server_fb_enabled=yes
+
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-ios
   cancel-in-progress: true
+
 jobs:
   ios-template:
-    runs-on: macos-latest
-    name: Template (target=release, tools=no)
+    runs-on: "macos-latest"
+    name: Template (target=template_release)
+
     steps:
-    - name: Checkout Godot
-      uses: actions/checkout@v2
-      with:
-        repository: godotengine/godot
-        ref: ${{ env.GODOT_BASE_BRANCH }}
-    - name: Checkout ECMAScript
-      uses: actions/checkout@v2
-      with:
-        path: ${{github.workspace}}/modules/javascript/
-    - name: Setup Godot build cache
-      uses: ./.github/actions/godot-cache
-      continue-on-error: true
-    - name: Setup python and scons
-      uses: ./modules/javascript/.github/actions/godot-deps
-      with:
-        shell: sh
-    - name: Compilation (armv7)
-      uses: ./modules/javascript/.github/actions/godot-build
-      with:
-        sconsflags: ${{ env.SCONSFLAGS }}
-        platform: ios
-        target: template_release
-        tools: false
-        shell: sh
-    - name: Upload artifact
-      uses: ./.github/actions/upload-artifact
+      - name: Checkout Godot
+        uses: actions/checkout@v2
+        with:
+          repository: godotengine/godot
+          ref: ${{ env.GODOT_BASE_BRANCH }}
+
+      - name: Checkout ECMAScript
+        uses: actions/checkout@v2
+        with:
+          path: ${{github.workspace}}/modules/javascript/
+
+      - name: Setup Godot build cache
+        uses: ./.github/actions/godot-cache
+        continue-on-error: true
+
+      - name: Setup python and scons
+        uses: ./.github/actions/godot-deps
+
+      - name: Compilation (arm64)
+        uses: ./.github/actions/godot-build
+        with:
+          sconsflags: ${{ env.SCONSFLAGS }}
+          platform: ios
+          target: template_release
+          tests: false
+
+      - name: Upload artifact
+        uses: ./.github/actions/upload-artifact
diff --git a/.github/workflows/javascript_builds.yml b/.github/workflows/javascript_builds.yml
deleted file mode 100644
index 7fc8b824..00000000
--- a/.github/workflows/javascript_builds.yml
+++ /dev/null
@@ -1,58 +0,0 @@
-name: 🌐 JavaScript Builds
-'on':
-- push
-- pull_request
-env:
-  GODOT_BASE_BRANCH: "master"
-  SCONSFLAGS: verbose=yes warnings=extra debug_symbols=no
-  EM_VERSION: 3.1.18
-  EM_CACHE_FOLDER: "emsdk-cache"
-
-concurrency:
-  group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-javascript
-  cancel-in-progress: true
-jobs:
-  javascript-template:
-    runs-on: ubuntu-20.04
-    name: Template (target=release, tools=no)
-    steps:
-    - name: Checkout Godot
-      uses: actions/checkout@v2
-      with:
-        repository: godotengine/godot
-        ref: ${{ env.GODOT_BASE_BRANCH }}
-    - name: Checkout ECMAScript
-      uses: actions/checkout@v2
-      with:
-        path: ${{github.workspace}}/modules/javascript/
-    - name: Load Emscripten cache
-      id: javascript-template-emscripten-cache
-      uses: actions/cache@v2
-      with:
-        path: ${{env.EM_CACHE_FOLDER}}
-        key: ${{env.EM_VERSION}}-${{github.job}}
-    - name: Set up Emscripten latest
-      uses: mymindstorm/setup-emsdk@v12
-      with:
-        version: ${{env.EM_VERSION}}
-        actions-cache-folder: ${{env.EM_CACHE_FOLDER}}
-    - name: Verify Emscripten setup
-      run: |
-        emcc -v
-    - name: Setup Godot build cache
-      uses: ./.github/actions/godot-cache
-      continue-on-error: true
-    - name: Setup python and scons
-      uses: ./modules/javascript/.github/actions/godot-deps
-      with:
-        shell: sh
-    - name: Compilation
-      uses: ./modules/javascript/.github/actions/godot-build
-      with:
-        sconsflags: ${{ env.SCONSFLAGS }}
-        platform: web
-        target: template_release
-        tools: falsed
-        shell: sh
-    - name: Upload artifact
-      uses: ./.github/actions/upload-artifact
diff --git a/.github/workflows/linux_builds.yml b/.github/workflows/linux_builds.yml
index 6b3c5ea0..b1ee98cc 100644
--- a/.github/workflows/linux_builds.yml
+++ b/.github/workflows/linux_builds.yml
@@ -1,218 +1,224 @@
 name: 🐧 Linux Builds
-'on':
-- push
-- pull_request
+on:
+  workflow_call:
+
+# Global Settings
 env:
-  GODOT_BASE_BRANCH: "master"
-  SCONSFLAGS: '  verbose=yes warnings=extra module_text_server_fb_enabled=yes  '
+  # Used for the cache key, and godot-cpp checkout. Add version suffix to force clean build.
+  GODOT_BASE_BRANCH: '4.0'
+  SCONSFLAGS: verbose=yes warnings=extra werror=yes module_text_server_fb_enabled=yes
   DOTNET_NOLOGO: true
   DOTNET_CLI_TELEMETRY_OPTOUT: true
 
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-linux
   cancel-in-progress: true
+
 jobs:
   build-linux:
-    runs-on: ubuntu-20.04
+    runs-on: "ubuntu-20.04"
     name: ${{ matrix.name }}
     strategy:
       fail-fast: false
       matrix:
         include:
-        - name: Editor w/ Mono (target=editor, tools=yes)
-          cache-name: linux-editor-mono
-          target: editor
-          tests: false # Disabled due freeze caused by mix Mono build and CI
-          tools: true
-          sconsflags: module_mono_enabled=yes
-          doc-test: true
-          bin: "./bin/godot.linuxbsd.editor.x86_64.mono"
-          build-mono: true
-          proj-conv: true
-          artifact: true
-        - name: Editor with doubles and GCC sanitizers (target=editor, tests=yes, dev_build=yes, precision=double, use_asan=yes, use_ubsan=yes, linker=gold)
-          cache-name: linux-editor-double-sanitizers
-          target: editor
-          tests: true
-          # Debug symbols disabled as they're huge on this build and we hit the 14 GB limit for runners.
-          sconsflags: dev_build=yes debug_symbols=no precision=double use_asan=yes use_ubsan=yes linker=gold
-          proj-test: true
-          # Can be turned off for PRs that intentionally break compat with godot-cpp,
-          # until both the upstream PR and the matching godot-cpp changes are merged.
-          godot-cpp-test: true
-          bin: "./bin/godot.linuxbsd.editor.dev.double.x86_64.san"
-          build-mono: false
-          # Skip 2GiB artifact speeding up action.
-          artifact: false
-        - name: Template w/ Mono (target=template_release)
-          cache-name: linux-template-mono
-          target: template_release
-          tests: false
-          sconsflags: module_mono_enabled=yes
-          build-mono: false
-          artifact: true
-
-        - name: Minimal template (target=template_release, everything disabled)
-          cache-name: linux-template-minimal
-          target: template_release
-          tests: false
-          sconsflags: modules_enabled_by_default=no disable_3d=yes disable_advanced_gui=yes deprecated=no
+          - name: Editor w/ Mono (target=editor)
+            cache-name: linux-editor-mono
+            target: editor
+            tests: false # Disabled due freeze caused by mix Mono build and CI
+            sconsflags: module_mono_enabled=yes
+            doc-test: true
+            bin: "./bin/godot.linuxbsd.editor.x86_64.mono"
+            build-mono: true
+            proj-conv: true
+            artifact: true
+
+          - name: Editor with doubles and GCC sanitizers (target=editor, tests=yes, dev_build=yes, precision=double, use_asan=yes, use_ubsan=yes, linker=gold)
+            cache-name: linux-editor-double-sanitizers
+            target: editor
+            tests: true
+            # Debug symbols disabled as they're huge on this build and we hit the 14 GB limit for runners.
+            sconsflags: dev_build=yes debug_symbols=no precision=double use_asan=yes use_ubsan=yes linker=gold
+            proj-test: true
+            # Can be turned off for PRs that intentionally break compat with godot-cpp,
+            # until both the upstream PR and the matching godot-cpp changes are merged.
+            godot-cpp-test: true
+            bin: "./bin/godot.linuxbsd.editor.dev.double.x86_64.san"
+            build-mono: false
+            # Skip 2GiB artifact speeding up action.
+            artifact: false
+
+          - name: Editor with clang sanitizers (target=editor, tests=yes, dev_build=yes, use_asan=yes, use_ubsan=yes, use_llvm=yes, linker=lld)
+            cache-name: linux-editor-llvm-sanitizers
+            target: editor
+            tests: true
+            sconsflags: dev_build=yes use_asan=yes use_ubsan=yes use_llvm=yes linker=lld
+            bin: "./bin/godot.linuxbsd.editor.dev.x86_64.llvm.san"
+            build-mono: false
+            # Skip 2GiB artifact speeding up action.
+            artifact: false
+
+          - name: Template w/ Mono (target=template_release)
+            cache-name: linux-template-mono
+            target: template_release
+            tests: false
+            sconsflags: module_mono_enabled=yes
+            build-mono: false
+            artifact: true
+
+          - name: Minimal template (target=template_release, everything disabled)
+            cache-name: linux-template-minimal
+            target: template_release
+            tests: false
+            sconsflags: modules_enabled_by_default=no disable_3d=yes disable_advanced_gui=yes deprecated=no minizip=no
+            artifact: true
+
     steps:
-    - name: Checkout Godot
-      uses: actions/checkout@v2
-      with:
-        repository: godotengine/godot
-        ref: ${{ env.GODOT_BASE_BRANCH }}
-    - name: Checkout ECMAScript
-      uses: actions/checkout@v2
-      with:
-        path: ${{github.workspace}}/modules/javascript/
-    # Need newer mesa for lavapipe to work properly.
-    - name: Linux dependencies for tests
-      if: ${{ matrix.proj-test }}
-      run: |
-        sudo rm -f /etc/apt/sources.list.d/microsoft-prod.list
-        sudo add-apt-repository ppa:kisak/kisak-mesa
-        sudo apt-get install -qq mesa-vulkan-drivers
-    - name: Linux dependencies
-      shell: bash
-      run: |
-        # Azure repositories are not reliable, we need to prevent azure giving us packages.
-        # sudo rm -f /etc/apt/sources.list.d/*
-        # sudo cp -f misc/ci/sources.list /etc/apt/sources.list
-        sudo apt-get update
-        # The actual dependencies
-        sudo apt-get install build-essential pkg-config libx11-dev libxcursor-dev \
-            libxinerama-dev libgl1-mesa-dev libglu-dev libasound2-dev libpulse-dev \
-            libdbus-1-dev libudev-dev libxi-dev libxrandr-dev yasm xvfb wget unzip
-    - name: Setup Godot build cache
-      uses: ./.github/actions/godot-cache
-      with:
-        cache-name: ${{ matrix.cache-name }}
-      continue-on-error: true
-    - name: Setup python and scons
-      uses: ./modules/javascript/.github/actions/godot-deps
-      with:
-        shell: sh
-
-    - name: Set up .NET Sdk
-      uses: actions/setup-dotnet@v2
-      if: ${{ matrix.build-mono }}
-      with:
-        dotnet-version: '6.0.x'
-
-    - name: Setup GCC problem matcher
-      uses: ammaraskar/gcc-problem-matcher@master
-
-    - name: Compilation
-      uses: ./modules/javascript/.github/actions/godot-build
-      with:
-        sconsflags: ${{ env.SCONSFLAGS }} ${{ matrix.sconsflags }}
-        platform: linuxbsd
-        target: ${{ matrix.target }}
-        tools: ${{ matrix.tools }}
-        tests: ${{ matrix.tests }}
-        shell: sh
-
-    - name: Generate C# glue
-      if: ${{ matrix.build-mono }}
-      run: |
-        ${{ matrix.bin }} --headless --generate-mono-glue ./modules/mono/glue || true
-
-    - name: Build .NET solutions
-      if: ${{ matrix.build-mono }}
-      run: |
-        ./modules/mono/build_scripts/build_assemblies.py --godot-output-dir=./bin --godot-platform=linuxbsd
-
-    # Execute unit tests for the editor
-    - name: Unit tests
-      if: ${{ matrix.tests }}
-      run: |
-        ${{ matrix.bin }} --version
-        ${{ matrix.bin }} --help
-        ${{ matrix.bin }} --test --headless
-
-    # Check class reference
-    # - name: Check for class reference updates
-    #   if: ${{ matrix.doc-test }}
-    #   run: |
-    #     echo "Running --doctool to see if this changes the public API without updating the documentation."
-    #     echo -e "If a diff is shown, it means that your code/doc changes are incomplete and you should update the class reference with --doctool.\n\n"
-    #     ${{ matrix.bin }} --doctool --headless 2>&1 > /dev/null || true
-    #     git diff --color --exit-code && ! git ls-files --others --exclude-standard | sed -e 's/^/New doc file missing in PR: /' | grep 'xml$'
-
-    # Test 3.x -> 4.x project converter
-    # - name: Test project converter
-    #   if: ${{ matrix.proj-conv }}
-    #   run: |
-    #     mkdir converter_test
-    #     cd converter_test
-    #     touch project.godot
-    #     ../${{ matrix.bin }} --headless --validate-conversion-3to4
-    #     cd ..
-    #     rm converter_test -rf
-
-    # # Download and extract zip archive with project, folder is renamed to be able to easy change used project
-    # - name: Download test project
-    #   if: ${{ matrix.proj-test }}
-    #   run: |
-    #     wget https://github.com/godotengine/regression-test-project/archive/4.0.zip
-    #     unzip 4.0.zip
-    #     mv "regression-test-project-4.0" "test_project"
-
-    # # Editor is quite complicated piece of software, so it is easy to introduce bug here
-    # - name: Open and close editor (Vulkan)
-    #   if: ${{ matrix.proj-test }}
-    #   run: |
-    #     xvfb-run ${{ matrix.bin }} --audio-driver Dummy --editor --quit --path test_project 2>&1 | tee sanitizers_log.txt || true
-    #     misc/scripts/check_ci_log.py sanitizers_log.txt
-
-    # - name: Open and close editor (GLES3)
-    #   if: ${{ matrix.proj-test }}
-    #   run: |
-    #     DRI_PRIME=0 xvfb-run ${{ matrix.bin }} --audio-driver Dummy --rendering-driver opengl3 --editor --quit --path test_project 2>&1 | tee sanitizers_log.txt || true
-    #     misc/scripts/check_ci_log.py sanitizers_log.txt
-
-    # # Run test project
-    # - name: Run project
-    #   if: ${{ matrix.proj-test }}
-    #   run: |
-    #     xvfb-run ${{ matrix.bin }} 40 --audio-driver Dummy --path test_project 2>&1 | tee sanitizers_log.txt || true
-    #     misc/scripts/check_ci_log.py sanitizers_log.txt
-
-    # # Checkout godot-cpp
-    # - name: Checkout godot-cpp
-    #   if: ${{ matrix.godot-cpp-test }}
-    #   uses: actions/checkout@v3
-    #   with:
-    #     repository: godotengine/godot-cpp
-    #     submodules: 'recursive'
-    #     path: 'godot-cpp'
-
-    # # Dump GDExtension interface and API
-    # - name: Dump GDExtension interface and API for godot-cpp build
-    #   if: ${{ matrix.godot-cpp-test }}
-    #   run: |
-    #     ${{ matrix.bin }} --headless --dump-gdextension-interface --dump-extension-api
-    #     cp -f gdextension_interface.h godot-cpp/gdextension/
-    #     cp -f extension_api.json godot-cpp/gdextension/
-
-    # # Build godot-cpp test extension
-    # - name: Build godot-cpp test extension
-    #   if: ${{ matrix.godot-cpp-test }}
-    #   run: |
-    #     cd godot-cpp/test
-    #     scons target=template_debug dev_build=yes
-    #     cd ../..
-
-    - name: Prepare artifact
-      if: ${{ matrix.artifact }}
-      run: |
-        strip bin/godot.*
-        chmod +x bin/godot.*
-
-    - name: Upload artifact
-      uses: ./.github/actions/upload-artifact
-      if: ${{ matrix.artifact }}
-      with:
-        name: ${{ matrix.cache-name }}
+      - name: Checkout Godot
+        uses: actions/checkout@v2
+        with:
+          repository: godotengine/godot
+          ref: ${{ env.GODOT_BASE_BRANCH }}
+
+      - name: Checkout ECMAScript
+        uses: actions/checkout@v2
+        with:
+          path: ${{github.workspace}}/modules/javascript/
+
+      # Need newer mesa for lavapipe to work properly.
+      - name: Linux dependencies for tests
+        if: ${{ matrix.proj-test }}
+        run: |
+          sudo rm -f /etc/apt/sources.list.d/microsoft-prod.list
+          sudo add-apt-repository ppa:kisak/kisak-mesa
+          sudo apt-get install -qq mesa-vulkan-drivers
+
+      - name: Setup Godot build cache
+        uses: ./.github/actions/godot-cache
+        with:
+          cache-name: ${{ matrix.cache-name }}
+        continue-on-error: true
+
+      - name: Setup python and scons
+        uses: ./.github/actions/godot-deps
+
+      - name: Set up .NET Sdk
+        uses: actions/setup-dotnet@v2
+        if: ${{ matrix.build-mono }}
+        with:
+          dotnet-version: '6.0.x'
+
+      - name: Setup GCC problem matcher
+        uses: ammaraskar/gcc-problem-matcher@master
+
+      - name: Compilation
+        uses: ./.github/actions/godot-build
+        with:
+          sconsflags: ${{ env.SCONSFLAGS }} ${{ matrix.sconsflags }}
+          platform: linuxbsd
+          target: ${{ matrix.target }}
+          tests: ${{ matrix.tests }}
+
+      - name: Generate C# glue
+        if: ${{ matrix.build-mono }}
+        run: |
+          ${{ matrix.bin }} --headless --generate-mono-glue ./modules/mono/glue || true
+
+      - name: Build .NET solutions
+        if: ${{ matrix.build-mono }}
+        run: |
+          ./modules/mono/build_scripts/build_assemblies.py --godot-output-dir=./bin --godot-platform=linuxbsd
+
+      # Execute unit tests for the editor
+      - name: Unit tests
+        if: ${{ matrix.tests }}
+        run: |
+          ${{ matrix.bin }} --version
+          ${{ matrix.bin }} --help
+          ${{ matrix.bin }} --test --headless
+
+      # Check class reference
+      - name: Check for class reference updates
+        if: ${{ matrix.doc-test }}
+        run: |
+          echo "Running --doctool to see if this changes the public API without updating the documentation."
+          echo -e "If a diff is shown, it means that your code/doc changes are incomplete and you should update the class reference with --doctool.\n\n"
+          ${{ matrix.bin }} --doctool --headless 2>&1 > /dev/null || true
+          git diff --color --exit-code && ! git ls-files --others --exclude-standard | sed -e 's/^/New doc file missing in PR: /' | grep 'xml$'
+
+      # Test 3.x -> 4.x project converter
+      - name: Test project converter
+        if: ${{ matrix.proj-conv }}
+        run: |
+          mkdir converter_test
+          cd converter_test
+          touch project.godot
+          ../${{ matrix.bin }} --headless --validate-conversion-3to4
+          cd ..
+          rm converter_test -rf
+
+      # Download and extract zip archive with project, folder is renamed to be able to easy change used project
+      - name: Download test project
+        if: ${{ matrix.proj-test }}
+        run: |
+          wget https://github.com/godotengine/regression-test-project/archive/4.0.zip
+          unzip 4.0.zip
+          mv "regression-test-project-4.0" "test_project"
+
+      # Editor is quite complicated piece of software, so it is easy to introduce bug here
+      - name: Open and close editor (Vulkan)
+        if: ${{ matrix.proj-test }}
+        run: |
+          xvfb-run ${{ matrix.bin }} --audio-driver Dummy --editor --quit --path test_project 2>&1 | tee sanitizers_log.txt || true
+          misc/scripts/check_ci_log.py sanitizers_log.txt
+
+      - name: Open and close editor (GLES3)
+        if: ${{ matrix.proj-test }}
+        run: |
+          DRI_PRIME=0 xvfb-run ${{ matrix.bin }} --audio-driver Dummy --rendering-driver opengl3 --editor --quit --path test_project 2>&1 | tee sanitizers_log.txt || true
+          misc/scripts/check_ci_log.py sanitizers_log.txt
+
+      # Run test project
+      - name: Run project
+        if: ${{ matrix.proj-test }}
+        run: |
+          xvfb-run ${{ matrix.bin }} 40 --audio-driver Dummy --path test_project 2>&1 | tee sanitizers_log.txt || true
+          misc/scripts/check_ci_log.py sanitizers_log.txt
+
+      # Checkout godot-cpp
+      - name: Checkout godot-cpp
+        if: ${{ matrix.godot-cpp-test }}
+        uses: actions/checkout@v3
+        with:
+          repository: godotengine/godot-cpp
+          ref: ${{ env.GODOT_BASE_BRANCH }}
+          submodules: 'recursive'
+          path: 'godot-cpp'
+
+      # Dump GDExtension interface and API
+      - name: Dump GDExtension interface and API for godot-cpp build
+        if: ${{ matrix.godot-cpp-test }}
+        run: |
+          ${{ matrix.bin }} --headless --dump-gdextension-interface --dump-extension-api
+          cp -f gdextension_interface.h godot-cpp/gdextension/
+          cp -f extension_api.json godot-cpp/gdextension/
+
+      # Build godot-cpp test extension
+      - name: Build godot-cpp test extension
+        if: ${{ matrix.godot-cpp-test }}
+        run: |
+          cd godot-cpp/test
+          scons target=template_debug dev_build=yes
+          cd ../..
+
+      - name: Prepare artifact
+        if: ${{ matrix.artifact }}
+        run: |
+          strip bin/godot.*
+          chmod +x bin/godot.*
+
+      - name: Upload artifact
+        uses: ./.github/actions/upload-artifact
+        if: ${{ matrix.artifact }}
+        with:
+          name: ${{ matrix.cache-name }}
diff --git a/.github/workflows/macos_builds.yml b/.github/workflows/macos_builds.yml
index 5a20132d..7cb31994 100644
--- a/.github/workflows/macos_builds.yml
+++ b/.github/workflows/macos_builds.yml
@@ -1,79 +1,84 @@
 name: 🍎 macOS Builds
-'on':
-- push
-- pull_request
+on:
+  workflow_call:
+
+# Global Settings
 env:
-  GODOT_BASE_BRANCH: "master"
-  SCONSFLAGS: verbose=yes warnings=extra module_text_server_fb_enabled=yes
+  # Used for the cache key. Add version suffix to force clean build.
+  GODOT_BASE_BRANCH: '4.0'
+  SCONSFLAGS: verbose=yes warnings=extra werror=yes module_text_server_fb_enabled=yes
+
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-macos
   cancel-in-progress: true
+
 jobs:
   build-macos:
-    runs-on: macos-latest
+    runs-on: "macos-latest"
     name: ${{ matrix.name }}
     strategy:
       fail-fast: false
       matrix:
         include:
-        - name: Editor (target=editor, tools=yes)
-          cache-name: macos-editor
-          target: editor
-          tools: true
-          tests: false
-          bin: ./bin/godot.osx.opt.tools.64
-        - name: Template (target=release, tools=no)
-          cache-name: macos-template
-          target: template_release
-          tests: false
-          sconsflags: debug_symbols=no
-          tools: false
+          - name: Editor (target=editor, tests=yes)
+            cache-name: macos-editor
+            target: editor
+            tests: true
+            bin: "./bin/godot.macos.editor.x86_64"
+
+          - name: Template (target=template_release)
+            cache-name: macos-template
+            target: template_release
+            tests: false
+            sconsflags: debug_symbols=no
+
     steps:
-    - name: Checkout Godot
-      uses: actions/checkout@v2
-      with:
-        repository: godotengine/godot
-        ref: ${{ env.GODOT_BASE_BRANCH }}
-    - name: Checkout ECMAScript
-      uses: actions/checkout@v2
-      with:
-        path: ${{github.workspace}}/modules/javascript/
-    - name: Setup Godot build cache
-      uses: ./.github/actions/godot-cache
-      with:
-        cache-name: ${{ matrix.cache-name }}
-      continue-on-error: true
-    - name: Setup python and scons
-      uses: ./modules/javascript/.github/actions/godot-deps
-      with:
-        shell: sh
-    - name: Setup Vulkan SDK
-      run: |
-        sh misc/scripts/install_vulkan_sdk_macos.sh
-    - name: Compilation
-      uses: ./modules/javascript/.github/actions/godot-build
-      with:
-        sconsflags: ${{ env.SCONSFLAGS }}
-        platform: macos
-        target: ${{ matrix.target }}
-        tests: ${{ matrix.tests }}
-        tools: ${{ matrix.tools }}
-        shell: sh
+      - name: Checkout Godot
+        uses: actions/checkout@v2
+        with:
+          repository: godotengine/godot
+          ref: ${{ env.GODOT_BASE_BRANCH }}
+
+      - name: Checkout ECMAScript
+        uses: actions/checkout@v2
+        with:
+          path: ${{github.workspace}}/modules/javascript/
+
+      - name: Setup Godot build cache
+        uses: ./.github/actions/godot-cache
+        with:
+          cache-name: ${{ matrix.cache-name }}
+        continue-on-error: true
+
+      - name: Setup python and scons
+        uses: ./.github/actions/godot-deps
+
+      - name: Setup Vulkan SDK
+        run: |
+          sh misc/scripts/install_vulkan_sdk_macos.sh
+
+      - name: Compilation
+        uses: ./.github/actions/godot-build
+        with:
+          sconsflags: ${{ env.SCONSFLAGS }}
+          platform: macos
+          target: ${{ matrix.target }}
+          tests: ${{ matrix.tests }}
 
-    # Execute unit tests for the editor
-    - name: Unit tests
-      if: ${{ matrix.tests }}
-      run: |
-        ${{ matrix.bin }} --version
-        ${{ matrix.bin }} --help
-        ${{ matrix.bin }} --test
+      # Execute unit tests for the editor
+      - name: Unit tests
+        if: ${{ matrix.tests }}
+        run: |
+          ${{ matrix.bin }} --version
+          ${{ matrix.bin }} --help
+          ${{ matrix.bin }} --test
 
-    - name: Prepare artifact
-      run: |
-        strip bin/godot.*
-        chmod +x bin/godot.*
+      - name: Prepare artifact
+        run: |
+          strip bin/godot.*
+          chmod +x bin/godot.*
 
-    - name: Upload artifact
-      uses: ./.github/actions/upload-artifact
-      with:
-        name: ${{ matrix.cache-name }}
+      - name: Upload artifact
+        uses: ./.github/actions/upload-artifact
+        with:
+          name: ${{ matrix.cache-name }}
diff --git a/.github/workflows/on_tag.yml b/.github/workflows/on_tag.yml
deleted file mode 100644
index 3fd76b41..00000000
--- a/.github/workflows/on_tag.yml
+++ /dev/null
@@ -1,73 +0,0 @@
-name: 🚢 Publish release
-'on':
-  push:
-    tags:
-    - '*'
-jobs:
-  collect-template:
-    runs-on: ubuntu-latest
-    steps:
-    - name: download artifacts
-      uses: actions/github-script@v6
-      if: startsWith(github.ref, 'refs/tags')
-      with:
-        script: |-
-          var total_slept = 0;
-          var downloaded_files = [];
-          var seen_completed_wfs = [];
-          var expected_to_see = 7;
-          while (total_slept < 7200000 && seen_completed_wfs.length < expected_to_see) {
-              var all_workflows = await github.rest.actions.listWorkflowRunsForRepo({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-              });
-              console.log("Expecting to download from " + expected_to_see + " workflows, currently at " + seen_completed_wfs.length + ". Have already downloaded " + downloaded_files.length + " files as " + downloaded_files);
-              for (const workflow of all_workflows.data.workflow_runs) {
-                  if (workflow.head_sha == "${{ github.sha }}") {
-                      console.log("found " + workflow.name + " " + workflow.status);
-                      if (workflow.status == "completed") {
-                          if (seen_completed_wfs.includes(workflow.name)) {continue;}
-                          if (workflow.conclusion == "success") {
-                              var artifacts = await github.rest.actions.listWorkflowRunArtifacts({
-                                  owner: context.repo.owner,
-                                  repo: context.repo.repo,
-                                  run_id: workflow.id,
-                                  per_page: 100,
-                              });
-                              for (const artifact of artifacts.data.artifacts) {
-                                  var fn = '${{github.workspace}}/' + artifact.name + '.zip';
-                                  if (downloaded_files.includes(fn)) {continue;}
-                                  var download = await github.rest.actions.downloadArtifact({
-                                      owner: context.repo.owner,
-                                      repo: context.repo.repo,
-                                      artifact_id: artifact.id,
-                                      archive_format: 'zip',
-                                  });
-                                  var fs = require('fs');
-                                  fs.writeFileSync(fn, Buffer.from(download.data));
-                                  downloaded_files.push(fn);
-                              }
-                              seen_completed_wfs.push(workflow.name);
-                          }
-                      }
-                  }
-              }
-              if (seen_completed_wfs.length < expected_to_see) {
-                  console.log("sleeping " + 300000);
-                  await new Promise(r => setTimeout(r, 300000));
-                  total_slept = total_slept + 300000;
-                  console.log("done sleeping " + 300000);
-              }
-          }
-          console.log(downloaded_files);
-    - name: show dir
-      run: ls -R
-    - name: Upload binaries to release
-      uses: svenstaro/upload-release-action@v2
-      if: startsWith(github.ref, 'refs/tags')
-      with:
-        repo_token: ${{ secrets.GITHUB_TOKEN }}
-        file: '*.zip'
-        tag: ${{ github.ref }}
-        overwrite: 'true'
-        file_glob: 'true'
diff --git a/.github/workflows/runner.yml b/.github/workflows/runner.yml
new file mode 100644
index 00000000..be255b54
--- /dev/null
+++ b/.github/workflows/runner.yml
@@ -0,0 +1,41 @@
+name: 🔗 GHA
+on: [push, pull_request]
+
+concurrency:
+  group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-runner
+  cancel-in-progress: true
+
+jobs:
+  static-checks:
+    name: 📊 Static checks
+    uses: ./.github/workflows/static_checks.yml
+
+  android-build:
+    name: 🤖 Android
+    needs: static-checks
+    uses: ./.github/workflows/android_builds.yml
+
+  ios-build:
+    name: 🍏 iOS
+    needs: static-checks
+    uses: ./.github/workflows/ios_builds.yml
+
+  linux-build:
+    name: 🐧 Linux
+    needs: static-checks
+    uses: ./.github/workflows/linux_builds.yml
+
+  macos-build:
+    name: 🍎 macOS
+    needs: static-checks
+    uses: ./.github/workflows/macos_builds.yml
+
+  windows-build:
+    name: 🏁 Windows
+    needs: static-checks
+    uses: ./.github/workflows/windows_builds.yml
+
+  web-build:
+    name: 🌐 Web
+    needs: static-checks
+    uses: ./.github/workflows/web_builds.yml
diff --git a/.github/workflows/server_builds.yml b/.github/workflows/server_builds.yml
deleted file mode 100644
index ca88b2fd..00000000
--- a/.github/workflows/server_builds.yml
+++ /dev/null
@@ -1,76 +0,0 @@
-name: ☁ Server Builds
-'on':
-- push
-- pull_request
-env:
-  GODOT_BASE_BRANCH: "master"
-  SCONSFLAGS: '  verbose=yes warnings=extra module_text_server_fb_enabled=yes  '
-  DOTNET_NOLOGO: true
-  DOTNET_CLI_TELEMETRY_OPTOUT: true
-
-concurrency:
-  group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-server
-  cancel-in-progress: true
-jobs:
-  build-server:
-    runs-on: ubuntu-20.04
-    name: ${{ matrix.name }}
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-        - name: Linux Headless w/ Mono (target=editor, tools=yes)
-          cache-name: server-editor-mono
-          target: editor
-          tests: false # Disabled due freeze caused by mix Mono build and CI
-          tools: true
-          sconsflags: module_mono_enabled=yes mono_static=yes mono_glue=no
-          bin: ./bin/godot.x11.opt.tools.64.mono
-          build-mono: true
-          artifact: true
-        - name: Linux Server w/ Mono (target=release, tools=no)
-          cache-name: server-template-mono
-          target: template_release
-          tests: false # Disabled due freeze caused by mix Mono build and CI
-          tools: false
-          sconsflags: module_mono_enabled=yes mono_static=yes mono_glue=no
-          build-mono: true
-          artifact: true
-    steps:
-    - name: Checkout Godot
-      uses: actions/checkout@v2
-      with:
-        repository: godotengine/godot
-        ref: ${{ env.GODOT_BASE_BRANCH }}
-    - name: Checkout ECMAScript
-      uses: actions/checkout@v2
-      with:
-        path: ${{github.workspace}}/modules/javascript/
-    - name: Linux dependencies
-      shell: bash
-      run: |
-        # Azure repositories are not reliable, we need to prevent azure giving us packages.
-        # sudo rm -f /etc/apt/sources.list.d/*
-        # sudo cp -f misc/ci/sources.list /etc/apt/sources.list
-        sudo apt-get update
-        # The actual dependencies
-        sudo apt-get install build-essential pkg-config libx11-dev libxcursor-dev \
-            libxinerama-dev libgl1-mesa-dev libglu-dev libasound2-dev libpulse-dev \
-            libdbus-1-dev libudev-dev libxi-dev libxrandr-dev yasm xvfb wget unzip
-    - name: Setup Godot build cache
-      uses: ./.github/actions/godot-cache
-      with:
-        cache-name: ${{ matrix.cache-name }}
-      continue-on-error: true
-    - name: Setup python and scons
-      uses: ./modules/javascript/.github/actions/godot-deps
-      with:
-        shell: sh
-    - name: Compilation
-      uses: ./modules/javascript/.github/actions/godot-build
-      with:
-        sconsflags: ${{ env.SCONSFLAGS }} ${{ matrix.sconsflags }}
-        platform: linuxbsd
-        target: ${{ matrix.target }}
-        tools: ${{ matrix.tools }}
-        shell: sh
diff --git a/.github/workflows/static_checks.yml b/.github/workflows/static_checks.yml
new file mode 100644
index 00000000..84066808
--- /dev/null
+++ b/.github/workflows/static_checks.yml
@@ -0,0 +1,110 @@
+name: 📊 Static Checks
+on:
+  workflow_call:
+
+concurrency:
+  group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-static
+  cancel-in-progress: true
+
+jobs:
+  static-checks:
+    name: Code style, file formatting, and docs
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 2
+
+      - name: Install APT dependencies
+        uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: dos2unix libxml2-utils moreutils
+
+      - name: Install Python dependencies and general setup
+        run: |
+          pip3 install black==22.3.0 pytest==7.1.2 mypy==0.971
+          git config diff.wsErrorHighlight all
+
+      - name: Get changed files
+        id: changed-files
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          if [ "${{ github.event_name }}" == "pull_request" ]; then
+            files=$(gh pr diff ${{ github.event.pull_request.number }} --name-only)
+          elif [ "${{ github.event_name }}" == "push" -a "${{ github.event.forced }}" == "false" -a "${{ github.event.created }}" == "false" ]; then
+            files=$(git diff-tree --no-commit-id --name-only -r ${{ github.event.before }}..${{ github.event.after }} 2> /dev/null || true)
+          fi
+          echo "$files" >> changed.txt
+          cat changed.txt
+          files=$(echo "$files" | grep -v 'thirdparty' | xargs -I {} sh -c 'echo "./{}"' | tr '\n' ' ')
+          echo "CHANGED_FILES=$files" >> $GITHUB_ENV
+
+      - name: File formatting checks (file_format.sh)
+        run: |
+          bash ./misc/scripts/file_format.sh changed.txt
+
+      - name: Header guards formatting checks (header_guards.sh)
+        run: |
+          bash ./misc/scripts/header_guards.sh changed.txt
+
+      - name: Python style checks via black (black_format.sh)
+        run: |
+          if grep -qE '\.py$|SConstruct|SCsub' changed.txt || [ -z "$(cat changed.txt)" ]; then
+            bash ./misc/scripts/black_format.sh
+          else
+            echo "Skipping Python formatting as no Python files were changed."
+          fi
+
+      - name: Python scripts static analysis (mypy_check.sh)
+        run: |
+          if grep -qE '\.py$|SConstruct|SCsub' changed.txt || [ -z "$(cat changed.txt)" ]; then
+            bash ./misc/scripts/mypy_check.sh
+          else
+            echo "Skipping Python static analysis as no Python files were changed."
+          fi
+
+      - name: Python builders checks via pytest (pytest_builders.sh)
+        run: |
+          bash ./misc/scripts/pytest_builders.sh
+
+      - name: JavaScript style and documentation checks via ESLint and JSDoc
+        run: |
+          if grep -q "platform/web" changed.txt || [ -z "$(cat changed.txt)" ]; then
+            cd platform/web
+            npm ci
+            npm run lint
+            npm run docs -- -d dry-run
+          else
+            echo "Skipping JavaScript formatting as no Web/JS files were changed."
+          fi
+
+      - name: Class reference schema checks
+        run: |
+          xmllint --noout --schema doc/class.xsd doc/classes/*.xml modules/*/doc_classes/*.xml
+
+      - name: Documentation checks
+        run: |
+          doc/tools/make_rst.py --dry-run --color doc/classes modules
+
+      - name: Style checks via clang-format (clang_format.sh)
+        run: |
+          clang-format --version
+          bash ./misc/scripts/clang_format.sh changed.txt
+
+      - name: Style checks via dotnet format (dotnet_format.sh)
+        run: |
+          if grep -q "modules/mono" changed.txt || [ -z "$(cat changed.txt)" ]; then
+            bash ./misc/scripts/dotnet_format.sh
+          else
+            echo "Skipping dotnet format as no C# files were changed."
+          fi
+
+      - name: Spell checks via codespell
+        if: github.event_name == 'pull_request' && env.CHANGED_FILES != ''
+        uses: codespell-project/actions-codespell@v1
+        with:
+          skip: "./bin,./thirdparty,*.desktop,*.gen.*,*.po,*.pot,*.rc,./AUTHORS.md,./COPYRIGHT.txt,./DONORS.md,./core/input/gamecontrollerdb.txt,./core/string/locales.h,./editor/project_converter_3_to_4.cpp,./misc/scripts/codespell.sh,./platform/android/java/lib/src/com,./platform/web/node_modules,./platform/web/package-lock.json"
+          ignore_words_list: "curvelinear,doubleclick,expct,findn,gird,hel,inout,lod,nd,numer,ot,te,vai"
+          path: ${{ env.CHANGED_FILES }}
diff --git a/.github/workflows/web_builds.yml b/.github/workflows/web_builds.yml
new file mode 100644
index 00000000..12b32b8d
--- /dev/null
+++ b/.github/workflows/web_builds.yml
@@ -0,0 +1,60 @@
+name: 🌐 Web Builds
+on:
+  workflow_call:
+
+# Global Settings
+env:
+  # Used for the cache key. Add version suffix to force clean build.
+  GODOT_BASE_BRANCH: '4.0'
+  SCONSFLAGS: verbose=yes warnings=extra werror=yes debug_symbols=no
+  EM_VERSION: 3.1.18
+  EM_CACHE_FOLDER: "emsdk-cache"
+
+concurrency:
+  group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-web
+  cancel-in-progress: true
+
+jobs:
+  web-template:
+    runs-on: "ubuntu-20.04"
+    name: Template (target=template_release)
+
+    steps:
+      - name: Checkout Godot
+        uses: actions/checkout@v2
+        with:
+          repository: godotengine/godot
+          ref: ${{ env.GODOT_BASE_BRANCH }}
+
+      - name: Checkout ECMAScript
+        uses: actions/checkout@v2
+        with:
+          path: ${{github.workspace}}/modules/javascript/
+
+      - name: Set up Emscripten latest
+        uses: mymindstorm/setup-emsdk@v12
+        with:
+          version: ${{env.EM_VERSION}}
+          actions-cache-folder: ${{env.EM_CACHE_FOLDER}}
+
+      - name: Verify Emscripten setup
+        run: |
+          emcc -v
+
+      - name: Setup Godot build cache
+        uses: ./.github/actions/godot-cache
+        continue-on-error: true
+
+      - name: Setup python and scons
+        uses: ./.github/actions/godot-deps
+
+      - name: Compilation
+        uses: ./.github/actions/godot-build
+        with:
+          sconsflags: ${{ env.SCONSFLAGS }}
+          platform: web
+          target: template_release
+          tests: false
+
+      - name: Upload artifact
+        uses: ./.github/actions/upload-artifact
diff --git a/.github/workflows/windows_builds.yml b/.github/workflows/windows_builds.yml
index 7cab8484..67af76e3 100644
--- a/.github/workflows/windows_builds.yml
+++ b/.github/workflows/windows_builds.yml
@@ -1,82 +1,87 @@
 name: 🏁 Windows Builds
-'on':
-- push
-- pull_request
+on:
+  workflow_call:
+
+# Global Settings
+# SCONS_CACHE for windows must be set in the build environment
 env:
-  GODOT_BASE_BRANCH: "master"
-  SCONSFLAGS: '  use_mingw=yes  debug_symbols=no verbose=yes warnings=extra module_text_server_fb_enabled=yes'
+  # Used for the cache key. Add version suffix to force clean build.
+  GODOT_BASE_BRANCH: '4.0'
+  SCONSFLAGS: verbose=yes warnings=extra werror=yes module_text_server_fb_enabled=yes
   SCONS_CACHE_MSVC_CONFIG: true
+
 concurrency:
   group: ci-${{github.actor}}-${{github.head_ref || github.run_number}}-${{github.ref}}-windows
   cancel-in-progress: true
+
 jobs:
   build-windows:
-    runs-on: windows-latest
+    # Windows 10 with latest image
+    runs-on: "windows-latest"
     name: ${{ matrix.name }}
     strategy:
       fail-fast: false
       matrix:
         include:
-        - name: Editor (target=editor, tools=yes)
-          cache-name: windows-editor
-          target: editor
-          tests: false
-          tools: true
-          bin: ./bin/godot.windows.opt.tools.64.exe
-        - name: Template (target=release, tools=no)
-          cache-name: windows-template
-          target: template_release
-          tools: false
-          tests: false
-          sconsflags: debug_symbols=no
+          - name: Editor (target=editor, tests=yes)
+            cache-name: windows-editor
+            target: editor
+            tests: true
+            # Skip debug symbols, they're way too big with MSVC.
+            sconsflags: debug_symbols=no vsproj=yes
+            bin: "./bin/godot.windows.editor.x86_64.exe"
+
+          - name: Template (target=template_release)
+            cache-name: windows-template
+            target: template_release
+            tests: false
+            sconsflags: debug_symbols=no
+
     steps:
-    - name: setup-msys2
-      uses: msys2/setup-msys2@v2
-      with:
-        msystem: MINGW64
-        update: true
-        install: mingw-w64-x86_64-gcc
-    - name: update mingw2
-      run: pacman -Syu --needed --noconfirm mingw-w64-x86_64-python3-pip mingw-w64-x86_64-gcc
-        mingw-w64-i686-python3-pip mingw-w64-i686-gcc make
-    - name: update scons
-      run: pip3 install scons
-    - name: Checkout Godot
-      uses: actions/checkout@v2
-      with:
-        repository: godotengine/godot
-        ref: ${{ env.GODOT_BASE_BRANCH }}
-    - name: Checkout ECMAScript
-      uses: actions/checkout@v2
-      with:
-        path: ${{github.workspace}}/modules/javascript/
-    - name: Setup Godot build cache
-      uses: ./.github/actions/godot-cache
-      with:
-        cache-name: ${{ matrix.cache-name }}
-      continue-on-error: true
-    - name: Setup python and scons
-      uses: ./modules/javascript/.github/actions/godot-deps
-      with:
-        shell: msys2 {0}
+      - name: Checkout Godot
+        uses: actions/checkout@v2
+        with:
+          repository: godotengine/godot
+          ref: ${{ env.GODOT_BASE_BRANCH }}
+
+      - name: Checkout ECMAScript
+        uses: actions/checkout@v2
+        with:
+          path: ${{github.workspace}}/modules/javascript/
+
+      - name: Setup Godot build cache
+        uses: ./.github/actions/godot-cache
+        with:
+          cache-name: ${{ matrix.cache-name }}
+        continue-on-error: true
+
+      - name: Setup python and scons
+        uses: ./.github/actions/godot-deps
+
+      - name: Setup MSVC problem matcher
+        uses: ammaraskar/msvc-problem-matcher@master
+
+      - name: Compilation
+        uses: ./.github/actions/godot-build
+        with:
+          sconsflags: ${{ env.SCONSFLAGS }} ${{ matrix.sconsflags }}
+          platform: windows
+          target: ${{ matrix.target }}
+          tests: ${{ matrix.tests }}
+
+      # Execute unit tests for the editor
+      - name: Unit tests
+        if: ${{ matrix.tests }}
+        run: |
+          ${{ matrix.bin }} --version
+          ${{ matrix.bin }} --help
+          ${{ matrix.bin }} --test
 
-    - name: Setup MSVC problem matcher
-      uses: ammaraskar/msvc-problem-matcher@master
+      - name: Prepare artifact
+        run: |
+          Remove-Item bin/* -Include *.exp,*.lib,*.pdb -Force
 
-    - name: Compilation
-      uses: ./modules/javascript/.github/actions/godot-build
-      with:
-        sconsflags: ${{ env.SCONSFLAGS }} ${{ matrix.sconsflags }}
-        platform: windows
-        target: ${{ matrix.target }}
-        tests: ${{ matrix.tests }}
-        tools: ${{ matrix.tools }}
-        scons-cache-limit: 3072
-        shell: msys2 {0}
-    - name: Upload artifact
-      uses: ./.github/actions/upload-artifact
-      with:
-        name: ${{ matrix.cache-name }}
-    defaults:
-      run:
-        shell: msys2 {0}
+      - name: Upload artifact
+        uses: ./.github/actions/upload-artifact
+        with:
+          name: ${{ matrix.cache-name }}

From 0919fc3e9a5f92c3418dd390b70b1756b503ece3 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Mon, 19 Jun 2023 14:57:25 -0700
Subject: [PATCH 36/71] Add pthread for mingw.

---
 SCsub | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/SCsub b/SCsub
index fefc8dea..65fef2a7 100644
--- a/SCsub
+++ b/SCsub
@@ -7,6 +7,10 @@ env_module = env_modules.Clone()
 JS_ENGINE = "quickjs"
 TOOLS = "editor" == env_module["target"]
 
+if env["platform"] == "windows":
+    if env["CC"] == "gcc" or (env["CC"] == "clang" and env["use_llvm"]):
+        env.Append(LIBS=["pthread"])
+
 
 def open_file(path, mode):
     if platform.python_version() > "3":

From 78dbf97f662f11d491d53b35ca947a6d9efb9e36 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Mon, 19 Jun 2023 14:59:33 -0700
Subject: [PATCH 37/71] If use mingw, use pthread.

---
 SCsub | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/SCsub b/SCsub
index 65fef2a7..0b810ab3 100644
--- a/SCsub
+++ b/SCsub
@@ -8,7 +8,7 @@ JS_ENGINE = "quickjs"
 TOOLS = "editor" == env_module["target"]
 
 if env["platform"] == "windows":
-    if env["CC"] == "gcc" or (env["CC"] == "clang" and env["use_llvm"]):
+    if env["use_mingw"]:
         env.Append(LIBS=["pthread"])
 
 

From eca30e62191704a41d034c908c56a0837e5051c9 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Mon, 19 Jun 2023 15:15:59 -0700
Subject: [PATCH 38/71] Restore file format.

---
 misc/scripts/file_format.sh | 89 +++++++++++++++++++++++++++++++++++++
 1 file changed, 89 insertions(+)
 create mode 100644 misc/scripts/file_format.sh

diff --git a/misc/scripts/file_format.sh b/misc/scripts/file_format.sh
new file mode 100644
index 00000000..94a3affb
--- /dev/null
+++ b/misc/scripts/file_format.sh
@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+
+# This script ensures proper POSIX text file formatting and a few other things.
+# This is supplementary to clang_format.sh and black_format.sh, but should be
+# run before them.
+
+# We need dos2unix and isutf8.
+if [ ! -x "$(command -v dos2unix)" -o ! -x "$(command -v isutf8)" ]; then
+    printf "Install 'dos2unix' and 'isutf8' (moreutils package) to use this script.\n"
+    exit 1
+fi
+
+set -uo pipefail
+
+if [ $# -eq 0 ]; then
+    # Loop through all code files tracked by Git.
+    mapfile -d '' files < <(git grep -zIl '')
+else
+    # $1 should be a file listing file paths to process. Used in CI.
+    mapfile -d ' ' < <(cat "$1")
+fi
+
+for f in "${files[@]}"; do
+    # Exclude some types of files.
+    if [[ "$f" == *"csproj" ]]; then
+        continue
+    elif [[ "$f" == *"sln" ]]; then
+        continue
+    elif [[ "$f" == *".bat" ]]; then
+        continue
+    elif [[ "$f" == *".out" ]]; then
+        # GDScript integration testing files.
+        continue
+    elif [[ "$f" == *"patch" ]]; then
+        continue
+    elif [[ "$f" == *"pot" ]]; then
+        continue
+    elif [[ "$f" == *"po" ]]; then
+        continue
+    elif [[ "$f" == "thirdparty/"* ]]; then
+        continue
+    elif [[ "$f" == *"/thirdparty/"* ]]; then
+        continue
+    elif [[ "$f" == "platform/android/java/lib/src/com/google"* ]]; then
+        continue
+    elif [[ "$f" == *"-so_wrap."* ]]; then
+        continue
+    elif [[ "$f" == *".test.txt" ]]; then
+        continue
+    fi
+    # Ensure that files are UTF-8 formatted.
+    isutf8 "$f" >> utf8-validation.txt 2>&1
+    # Ensure that files have LF line endings and do not contain a BOM.
+    dos2unix "$f" 2> /dev/null
+    # Remove trailing space characters and ensures that files end
+    # with newline characters. -l option handles newlines conveniently.
+    perl -i -ple 's/\s*$//g' "$f"
+done
+
+diff=$(git diff --color)
+
+if [ ! -s utf8-validation.txt ] && [ -z "$diff" ] ; then
+    # If no UTF-8 violations were collected (the file is empty) and
+    # no diff has been generated all is OK, clean up, and exit.
+    printf "\e[1;32m*** Files in this commit comply with the file formatting rules.\e[0m\n"
+    rm -f utf8-validation.txt
+    exit 0
+fi
+
+if [ -s utf8-validation.txt ]
+then
+    # If the file has content and is not empty, violations
+    # detected, notify the user, clean up, and exit.
+    printf "\n\e[1;33m*** The following files contain invalid UTF-8 character sequences:\e[0m\n\n"
+    cat utf8-validation.txt
+fi
+
+rm -f utf8-validation.txt
+
+if [ ! -z "$diff" ]
+then
+    # A diff has been created, notify the user, clean up, and exit.
+    printf "\n\e[1;33m*** The following changes must be made to comply with the formatting rules:\e[0m\n\n"
+    # Perl commands replace trailing spaces with `·` and tabs with `<TAB>`.
+    printf "$diff\n" | perl -pe 's/(.*[^ ])( +)(\e\[m)$/my $spaces="·" x length($2); sprintf("$1$spaces$3")/ge' | perl -pe 's/(.*[^\t])(\t+)(\e\[m)$/my $tabs="<TAB>" x length($2); sprintf("$1$tabs$3")/ge'
+fi
+
+printf "\n\e[1;91m*** Please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\e[0m\n"
+exit 1

From a91c1f48f13a6157993d7bc486c92511d7b2791a Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Mon, 19 Jun 2023 15:18:40 -0700
Subject: [PATCH 39/71] Restore header guards too.

---
 misc/scripts/header_guards.sh | 87 +++++++++++++++++++++++++++++++++++
 1 file changed, 87 insertions(+)
 create mode 100644 misc/scripts/header_guards.sh

diff --git a/misc/scripts/header_guards.sh b/misc/scripts/header_guards.sh
new file mode 100644
index 00000000..1f8aa615
--- /dev/null
+++ b/misc/scripts/header_guards.sh
@@ -0,0 +1,87 @@
+#!/bin/bash
+
+if [ ! -f "version.py" ]; then
+  echo "Warning: This script is intended to be run from the root of the Godot repository."
+  echo "Some of the paths checks may not work as intended from a different folder."
+fi
+
+if [ $# -eq 0 ]; then
+    # Loop through all code files tracked by Git.
+    files=$(find -name "thirdparty" -prune -o -name "*.h" -print | sed "s@^\./@@g")
+else
+    # $1 should be a file listing file paths to process. Used in CI.
+    files=$(cat "$1" | grep -v "thirdparty/" | grep -E "\.h$" | sed "s@^\./@@g")
+fi
+
+files_invalid_guard=""
+
+for file in $files; do
+  # Skip *.gen.h and *-so_wrap.h, they're generated.
+  if [[ "$file" == *".gen.h" || "$file" == *"-so_wrap.h" ]]; then continue; fi
+  # Has important define before normal header guards.
+  if [[ "$file" == *"thread.h" || "$file" == *"platform_config.h" ]]; then continue; fi
+  # Obj-C files don't use header guards.
+  if grep -q "#import " "$file"; then continue; fi
+
+  bname=$(basename $file .h)
+
+  # Add custom prefix or suffix for generic filenames with a well-defined namespace.
+
+  prefix=
+  if [[ "$file" == "modules/"*"/register_types.h" ]]; then
+    module=$(echo $file | sed "s@.*modules/\([^/]*\).*@\1@")
+    prefix="${module^^}_"
+  fi
+  if [[ "$file" == "platform/"*"/api/api.h" || "$file" == "platform/"*"/export/"* ]]; then
+    platform=$(echo $file | sed "s@.*platform/\([^/]*\).*@\1@")
+    prefix="${platform^^}_"
+  fi
+  if [[ "$file" == "modules/mono/utils/"* && "$bname" != *"mono"* ]]; then prefix="MONO_"; fi
+  if [[ "$file" == "servers/rendering/storage/utilities.h" ]]; then prefix="RENDERER_"; fi
+
+  suffix=
+  if [[ "$file" == *"dummy"* && "$bname" != *"dummy"* ]]; then suffix="_DUMMY"; fi
+  if [[ "$file" == *"gles3"* && "$bname" != *"gles3"* ]]; then suffix="_GLES3"; fi
+  if [[ "$file" == *"renderer_rd"* && "$bname" != *"rd"* ]]; then suffix="_RD"; fi
+  if [[ "$file" == *"ustring.h" ]]; then suffix="_GODOT"; fi
+
+  # ^^ is bash builtin for UPPERCASE.
+  guard="${prefix}${bname^^}${suffix}_H"
+
+  # Replaces guards to use computed name.
+  # We also add some \n to make sure there's a proper separation.
+  sed -i $file -e "0,/ifndef/s/#ifndef.*/\n#ifndef $guard/"
+  sed -i $file -e "0,/define/s/#define.*/#define $guard\n/"
+  sed -i $file -e "$ s/#endif.*/\n#endif \/\/ $guard/"
+  # Removes redundant \n added before, if they weren't needed.
+  sed -i $file -e "/^$/N;/^\n$/D"
+
+  # Check that first ifndef (should be header guard) is at the expected position.
+  # If not it can mean we have some code before the guard that should be after.
+  # "31" is the expected line with the copyright header.
+  first_ifndef=$(grep -n -m 1 "ifndef" $file | sed 's/\([0-9]*\).*/\1/')
+  if [[ "$first_ifndef" != "31" ]]; then
+    files_invalid_guard+="$file\n"
+  fi
+done
+
+if [[ ! -z "$files_invalid_guard" ]]; then
+  echo -e "The following files were found to have potentially invalid header guard:\n"
+  echo -e "$files_invalid_guard"
+fi
+
+diff=$(git diff --color)
+
+# If no diff has been generated all is OK, clean up, and exit.
+if [ -z "$diff" ] ; then
+    printf "\e[1;32m*** Files in this commit comply with the header guards formatting rules.\e[0m\n"
+    exit 0
+fi
+
+# A diff has been created, notify the user, clean up, and exit.
+printf "\n\e[1;33m*** The following changes must be made to comply with the formatting rules:\e[0m\n\n"
+# Perl commands replace trailing spaces with `·` and tabs with `<TAB>`.
+printf "$diff\n" | perl -pe 's/(.*[^ ])( +)(\e\[m)$/my $spaces="·" x length($2); sprintf("$1$spaces$3")/ge' | perl -pe 's/(.*[^\t])(\t+)(\e\[m)$/my $tabs="<TAB>" x length($2); sprintf("$1$tabs$3")/ge'
+
+printf "\n\e[1;91m*** Please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\e[0m\n"
+exit 1

From fdd5180ab8382e020d8d1558702a0daad2eb0598 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Mon, 19 Jun 2023 15:24:15 -0700
Subject: [PATCH 40/71] Fix include guards style.

---
 register_types.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/register_types.h b/register_types.h
index 18785d49..885dc929 100644
--- a/register_types.h
+++ b/register_types.h
@@ -28,11 +28,11 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
 /**************************************************************************/
 
-#ifndef JAVASCRIPT_REGISTER_TYPES_H
-#define JAVASCRIPT_REGISTER_TYPES_H
+#ifndef REGISTER_TYPES_H
+#define REGISTER_TYPES_H
 
 #include "modules/register_module_types.h"
 void initialize_javascript_module(ModuleInitializationLevel p_level);
 void uninitialize_javascript_module(ModuleInitializationLevel p_level);
 
-#endif // JAVASCRIPT_REGISTER_TYPES_H
+#endif // REGISTER_TYPES_H

From 8d976e49913fb85afb9dd5378aa8727b1a545a13 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Mon, 19 Jun 2023 15:25:43 -0700
Subject: [PATCH 41/71] Restore black format.

---
 misc/scripts/black_format.sh | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 misc/scripts/black_format.sh

diff --git a/misc/scripts/black_format.sh b/misc/scripts/black_format.sh
new file mode 100644
index 00000000..3a64284e
--- /dev/null
+++ b/misc/scripts/black_format.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+# This script runs black on all Python files in the repo.
+
+set -uo pipefail
+
+# Apply black.
+echo -e "Formatting Python files..."
+PY_FILES=$(git ls-files -- '*SConstruct' '*SCsub' '*.py' ':!:.git/*' ':!:thirdparty/*')
+black -l 120 $PY_FILES
+
+diff=$(git diff --color)
+
+# If no diff has been generated all is OK, clean up, and exit.
+if [ -z "$diff" ] ; then
+    printf "\e[1;32m*** Files in this commit comply with the black style rules.\e[0m\n"
+    exit 0
+fi
+
+# A diff has been created, notify the user, clean up, and exit.
+printf "\n\e[1;33m*** The following changes must be made to comply with the formatting rules:\e[0m\n\n"
+# Perl commands replace trailing spaces with `·` and tabs with `<TAB>`.
+printf "$diff\n" | perl -pe 's/(.*[^ ])( +)(\e\[m)$/my $spaces="·" x length($2); sprintf("$1$spaces$3")/ge' | perl -pe 's/(.*[^\t])(\t+)(\e\[m)$/my $tabs="<TAB>" x length($2); sprintf("$1$tabs$3")/ge'
+
+printf "\n\e[1;91m*** Please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\e[0m\n"
+exit 1

From f4bc58166e52d21fa04475f7544455da5ec37bc6 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Mon, 19 Jun 2023 15:26:53 -0700
Subject: [PATCH 42/71] Restore all the scripts.

---
 misc/scripts/check_ci_log.py             | 67 +++++++++++++++++
 misc/scripts/clang_format.sh             | 53 +++++++++++++
 misc/scripts/clang_tidy.sh               | 33 ++++++++
 misc/scripts/codespell.sh                |  8 ++
 misc/scripts/copyright_headers.py        | 95 ++++++++++++++++++++++++
 misc/scripts/dotnet_format.sh            | 37 +++++++++
 misc/scripts/install_vulkan_sdk_macos.sh | 22 ++++++
 misc/scripts/make_icons.sh               | 26 +++++++
 misc/scripts/make_tarball.sh             | 66 ++++++++++++++++
 misc/scripts/mypy.ini                    | 11 +++
 misc/scripts/mypy_check.sh               |  6 ++
 misc/scripts/pytest_builders.sh          |  5 ++
 12 files changed, 429 insertions(+)
 create mode 100644 misc/scripts/check_ci_log.py
 create mode 100644 misc/scripts/clang_format.sh
 create mode 100644 misc/scripts/clang_tidy.sh
 create mode 100644 misc/scripts/codespell.sh
 create mode 100644 misc/scripts/copyright_headers.py
 create mode 100644 misc/scripts/dotnet_format.sh
 create mode 100644 misc/scripts/install_vulkan_sdk_macos.sh
 create mode 100644 misc/scripts/make_icons.sh
 create mode 100644 misc/scripts/make_tarball.sh
 create mode 100644 misc/scripts/mypy.ini
 create mode 100644 misc/scripts/mypy_check.sh
 create mode 100644 misc/scripts/pytest_builders.sh

diff --git a/misc/scripts/check_ci_log.py b/misc/scripts/check_ci_log.py
new file mode 100644
index 00000000..1e5a12ee
--- /dev/null
+++ b/misc/scripts/check_ci_log.py
@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import sys
+
+if len(sys.argv) < 2:
+    print("ERROR: You must run program with file name as argument.")
+    sys.exit(50)
+
+fname = sys.argv[1]
+
+fileread = open(fname.strip(), "r")
+file_contents = fileread.read()
+
+# If find "ERROR: AddressSanitizer:", then happens invalid read or write
+# This is critical bug, so we need to fix this as fast as possible
+
+if file_contents.find("ERROR: AddressSanitizer:") != -1:
+    print("FATAL ERROR: An incorrectly used memory was found.")
+    sys.exit(51)
+
+# There is also possible, that program crashed with or without backtrace.
+
+if (
+    file_contents.find("Program crashed with signal") != -1
+    or file_contents.find("Dumping the backtrace") != -1
+    or file_contents.find("Segmentation fault (core dumped)") != -1
+    or file_contents.find("Aborted (core dumped)") != -1
+    or file_contents.find("terminate called without an active exception") != -1
+):
+    print("FATAL ERROR: Godot has been crashed.")
+    sys.exit(52)
+
+# Finding memory leaks in Godot is quite difficult, because we need to take into
+# account leaks also in external libraries. They are usually provided without
+# debugging symbols, so the leak report from it usually has only 2/3 lines,
+# so searching for 5 element - "#4 0x" - should correctly detect the vast
+# majority of memory leaks
+
+if file_contents.find("ERROR: LeakSanitizer:") != -1:
+    if file_contents.find("#4 0x") != -1:
+        print("ERROR: Memory leak was found")
+        sys.exit(53)
+
+# It may happen that Godot detects leaking nodes/resources and removes them, so
+# this possibility should also be handled as a potential error, even if
+# LeakSanitizer doesn't report anything
+
+if file_contents.find("ObjectDB instances leaked at exit") != -1:
+    print("ERROR: Memory leak was found")
+    sys.exit(54)
+
+# In test project may be put several assert functions which will control if
+# project is executed with right parameters etc. which normally will not stop
+# execution of project
+
+if file_contents.find("Assertion failed") != -1:
+    print("ERROR: Assertion failed in project, check execution log for more info")
+    sys.exit(55)
+
+# For now Godot leaks a lot of rendering stuff so for now we just show info
+# about it and this needs to be re-enabled after fixing this memory leaks.
+
+if file_contents.find("were leaked") != -1 or file_contents.find("were never freed") != -1:
+    print("WARNING: Memory leak was found")
+
+sys.exit(0)
diff --git a/misc/scripts/clang_format.sh b/misc/scripts/clang_format.sh
new file mode 100644
index 00000000..74a8e1a8
--- /dev/null
+++ b/misc/scripts/clang_format.sh
@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+
+# This script runs clang-format and fixes copyright headers on all relevant files in the repo.
+# This is the primary script responsible for fixing style violations.
+
+set -uo pipefail
+
+if [ $# -eq 0 ]; then
+    # Loop through all code files tracked by Git.
+    files=$(git ls-files -- '*.c' '*.h' '*.cpp' '*.hpp' '*.cc' '*.hh' '*.cxx' '*.m' '*.mm' '*.inc' '*.java' '*.glsl' \
+                ':!:.git/*' ':!:thirdparty/*' ':!:*/thirdparty/*' ':!:platform/android/java/lib/src/com/google/*' \
+                ':!:*-so_wrap.*' ':!:tests/python_build/*')
+else
+    # $1 should be a file listing file paths to process. Used in CI.
+    files=$(cat "$1" | grep -v "thirdparty/" | grep -E "\.(c|h|cpp|hpp|cc|hh|cxx|m|mm|inc|java|glsl)$" | grep -v "platform/android/java/lib/src/com/google/" | grep -v "\-so_wrap\." | grep -v "tests/python_build/")
+fi
+
+if [ ! -z "$files" ]; then
+    clang-format --Wno-error=unknown -i $files
+fi
+
+# Fix copyright headers, but not all files get them.
+for f in $files; do
+    if [[ "$f" == *"inc" ]]; then
+        continue
+    elif [[ "$f" == *"glsl" ]]; then
+        continue
+    elif [[ "$f" == "platform/android/java/lib/src/org/godotengine/godot/gl/GLSurfaceView"* ]]; then
+        continue
+    elif [[ "$f" == "platform/android/java/lib/src/org/godotengine/godot/gl/EGLLogWrapper"* ]]; then
+        continue
+    elif [[ "$f" == "platform/android/java/lib/src/org/godotengine/godot/utils/ProcessPhoenix"* ]]; then
+        continue
+    fi
+
+    python misc/scripts/copyright_headers.py "$f"
+done
+
+diff=$(git diff --color)
+
+# If no diff has been generated all is OK, clean up, and exit.
+if [ -z "$diff" ] ; then
+    printf "\e[1;32m*** Files in this commit comply with the clang-format style rules.\e[0m\n"
+    exit 0
+fi
+
+# A diff has been created, notify the user, clean up, and exit.
+printf "\n\e[1;33m*** The following changes must be made to comply with the formatting rules:\e[0m\n\n"
+# Perl commands replace trailing spaces with `·` and tabs with `<TAB>`.
+printf "$diff\n" | perl -pe 's/(.*[^ ])( +)(\e\[m)$/my $spaces="·" x length($2); sprintf("$1$spaces$3")/ge' | perl -pe 's/(.*[^\t])(\t+)(\e\[m)$/my $tabs="<TAB>" x length($2); sprintf("$1$tabs$3")/ge'
+
+printf "\n\e[1;91m*** Please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\e[0m\n"
+exit 1
diff --git a/misc/scripts/clang_tidy.sh b/misc/scripts/clang_tidy.sh
new file mode 100644
index 00000000..c4811b90
--- /dev/null
+++ b/misc/scripts/clang_tidy.sh
@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+
+# This script runs clang-tidy on all relevant files in the repo.
+# This is more thorough than clang-format and thus slower; it should only be run manually.
+
+set -uo pipefail
+
+# Loops through all code files tracked by Git.
+git ls-files -- '*.c' '*.h' '*.cpp' '*.hpp' '*.cc' '*.hh' '*.cxx' '*.m' '*.mm' '*.inc' '*.java' '*.glsl' \
+                ':!:.git/*' ':!:thirdparty/*' ':!:platform/android/java/lib/src/com/google/*' ':!:*-so_wrap.*' |
+while read -r f; do
+    # Run clang-tidy.
+    clang-tidy --quiet --fix "$f" &> /dev/null
+
+    # Run clang-format. This also fixes the output of clang-tidy.
+    clang-format --Wno-error=unknown -i "$f"
+done
+
+diff=$(git diff --color)
+
+# If no diff has been generated all is OK, clean up, and exit.
+if [ -z "$diff" ] ; then
+    printf "\e[1;32m*** Files in this commit comply with the clang-tidy style rules.\e[0m\n"
+    exit 0
+fi
+
+# A diff has been created, notify the user, clean up, and exit.
+printf "\n\e[1;33m*** The following changes must be made to comply with the formatting rules:\e[0m\n\n"
+# Perl commands replace trailing spaces with `·` and tabs with `<TAB>`.
+printf "$diff\n" | perl -pe 's/(.*[^ ])( +)(\e\[m)$/my $spaces="·" x length($2); sprintf("$1$spaces$3")/ge' | perl -pe 's/(.*[^\t])(\t+)(\e\[m)$/my $tabs="<TAB>" x length($2); sprintf("$1$tabs$3")/ge'
+
+printf "\n\e[1;91m*** Please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\e[0m\n"
+exit 1
diff --git a/misc/scripts/codespell.sh b/misc/scripts/codespell.sh
new file mode 100644
index 00000000..d15b6593
--- /dev/null
+++ b/misc/scripts/codespell.sh
@@ -0,0 +1,8 @@
+#!/bin/sh
+SKIP_LIST="./.*,./**/.*,./bin,./thirdparty,*.desktop,*.gen.*,*.po,*.pot,*.rc,./AUTHORS.md,./COPYRIGHT.txt,./DONORS.md,"
+SKIP_LIST+="./core/input/gamecontrollerdb.txt,./core/string/locales.h,./editor/renames_map_3_to_4.cpp,./misc/scripts/codespell.sh,"
+SKIP_LIST+="./platform/android/java/lib/src/com,./platform/web/node_modules,./platform/web/package-lock.json,"
+
+IGNORE_LIST="curvelinear,doubleclick,expct,findn,gird,hel,inout,lod,nd,numer,ot,te,vai"
+
+codespell -w -q 3 -S "${SKIP_LIST}" -L "${IGNORE_LIST}" --builtin "clear,rare,en-GB_to_en-US"
diff --git a/misc/scripts/copyright_headers.py b/misc/scripts/copyright_headers.py
new file mode 100644
index 00000000..a5e2f0c0
--- /dev/null
+++ b/misc/scripts/copyright_headers.py
@@ -0,0 +1,95 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import sys
+
+header = """\
+/**************************************************************************/
+/*  $filename                                                             */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+"""
+
+fname = sys.argv[1]
+
+# Handle replacing $filename with actual filename and keep alignment
+fsingle = fname.strip()
+if fsingle.find("/") != -1:
+    fsingle = fsingle[fsingle.rfind("/") + 1 :]
+rep_fl = "$filename"
+rep_fi = fsingle
+len_fl = len(rep_fl)
+len_fi = len(rep_fi)
+# Pad with spaces to keep alignment
+if len_fi < len_fl:
+    for x in range(len_fl - len_fi):
+        rep_fi += " "
+elif len_fl < len_fi:
+    for x in range(len_fi - len_fl):
+        rep_fl += " "
+if header.find(rep_fl) != -1:
+    text = header.replace(rep_fl, rep_fi)
+else:
+    text = header.replace("$filename", fsingle)
+text += "\n"
+
+# We now have the proper header, so we want to ignore the one in the original file
+# and potentially empty lines and badly formatted lines, while keeping comments that
+# come after the header, and then keep everything non-header unchanged.
+# To do so, we skip empty lines that may be at the top in a first pass.
+# In a second pass, we skip all consecutive comment lines starting with "/*",
+# then we can append the rest (step 2).
+
+fileread = open(fname.strip(), "r")
+line = fileread.readline()
+header_done = False
+
+while line.strip() == "":  # Skip empty lines at the top
+    line = fileread.readline()
+
+if line.find("/**********") == -1:  # Godot header starts this way
+    # Maybe starting with a non-Godot comment, abort header magic
+    header_done = True
+
+while not header_done:  # Handle header now
+    if line.find("/*") != 0:  # No more starting with a comment
+        header_done = True
+        if line.strip() != "":
+            text += line
+    line = fileread.readline()
+
+while line != "":  # Dump everything until EOF
+    text += line
+    line = fileread.readline()
+
+fileread.close()
+
+# Write
+filewrite = open(fname.strip(), "w")
+filewrite.write(text)
+filewrite.close()
diff --git a/misc/scripts/dotnet_format.sh b/misc/scripts/dotnet_format.sh
new file mode 100644
index 00000000..cac00f5c
--- /dev/null
+++ b/misc/scripts/dotnet_format.sh
@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+
+# This script runs dotnet format on all relevant files in the repo.
+# This is the primary script responsible for fixing style violations in C# files.
+
+set -uo pipefail
+
+# Create dummy generated files.
+echo "<Project />" > modules/mono/SdkPackageVersions.props
+mkdir -p modules/mono/glue/GodotSharp/GodotSharp/Generated
+echo "<Project />" > modules/mono/glue/GodotSharp/GodotSharp/Generated/GeneratedIncludes.props
+mkdir -p modules/mono/glue/GodotSharp/GodotSharpEditor/Generated
+echo "<Project />" > modules/mono/glue/GodotSharp/GodotSharpEditor/Generated/GeneratedIncludes.props
+
+# Loops through all C# projects tracked by Git.
+git ls-files -- '*.csproj' \
+                ':!:.git/*' ':!:thirdparty/*' ':!:platform/android/java/lib/src/com/google/*' ':!:*-so_wrap.*' |
+while read -r f; do
+    # Run dotnet format.
+    dotnet format "$f"
+done
+
+diff=$(git diff --color)
+
+# If no diff has been generated all is OK, clean up, and exit.
+if [ -z "$diff" ] ; then
+    printf "\e[1;32m*** Files in this commit comply with the dotnet format style rules.\e[0m\n"
+    exit 0
+fi
+
+# A diff has been created, notify the user, clean up, and exit.
+printf "\n\e[1;33m*** The following changes must be made to comply with the formatting rules:\e[0m\n\n"
+# Perl commands replace trailing spaces with `·` and tabs with `<TAB>`.
+printf "$diff\n" | perl -pe 's/(.*[^ ])( +)(\e\[m)$/my $spaces="·" x length($2); sprintf("$1$spaces$3")/ge' | perl -pe 's/(.*[^\t])(\t+)(\e\[m)$/my $tabs="<TAB>" x length($2); sprintf("$1$tabs$3")/ge'
+
+printf "\n\e[1;91m*** Please fix your commit(s) with 'git commit --amend' or 'git rebase -i <hash>'\e[0m\n"
+exit 1
diff --git a/misc/scripts/install_vulkan_sdk_macos.sh b/misc/scripts/install_vulkan_sdk_macos.sh
new file mode 100644
index 00000000..17d567f2
--- /dev/null
+++ b/misc/scripts/install_vulkan_sdk_macos.sh
@@ -0,0 +1,22 @@
+#!/usr/bin/env sh
+
+set -euo pipefail
+IFS=$'\n\t'
+
+# Download and install the Vulkan SDK.
+curl -L "https://sdk.lunarg.com/sdk/download/latest/mac/vulkan-sdk.dmg" -o /tmp/vulkan-sdk.dmg
+hdiutil attach /tmp/vulkan-sdk.dmg -mountpoint /Volumes/vulkan-sdk
+/Volumes/vulkan-sdk/InstallVulkan.app/Contents/MacOS/InstallVulkan \
+    --accept-licenses --default-answer --confirm-command install
+
+cnt=5
+until hdiutil detach -force /Volumes/vulkan-sdk
+do
+   [[ cnt -eq "0" ]] && break
+   sleep 1
+   ((cnt--))
+done
+
+rm -f /tmp/vulkan-sdk.dmg
+
+echo 'Vulkan SDK installed successfully! You can now build Godot by running "scons".'
diff --git a/misc/scripts/make_icons.sh b/misc/scripts/make_icons.sh
new file mode 100644
index 00000000..cbb92660
--- /dev/null
+++ b/misc/scripts/make_icons.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+# Generate .ico, .icns and .zip set of icons for Steam
+
+# Make icons with transparent backgrounds and all sizes
+for s in 16 24 32 48 64 128 256 512 1024; do
+  convert -resize ${s}x$s -antialias \
+          -background transparent \
+          ../../icon.svg icon$s.png
+done
+
+# 16px tga file for library
+convert icon16.png icon16.tga
+
+# zip for Linux
+zip godot-icons.zip icon*.png
+
+# ico for Windows
+# Not including biggest ones or it blows up in size
+icotool -c -o godot-icon.ico icon{16,24,32,48,64,128,256}.png
+
+# icns for macOS
+# Only some sizes: https://iconhandbook.co.uk/reference/chart/osx/
+png2icns godot-icon.icns icon{16,32,128,256,512,1024}.png
+
+rm -f icon*.png
diff --git a/misc/scripts/make_tarball.sh b/misc/scripts/make_tarball.sh
new file mode 100644
index 00000000..9e02b80a
--- /dev/null
+++ b/misc/scripts/make_tarball.sh
@@ -0,0 +1,66 @@
+#!/bin/sh
+
+if [ ! -e "version.py" ]; then
+  echo "This script should be ran from the root folder of the Godot repository."
+  exit 1
+fi
+
+while getopts "h?sv:g:" opt; do
+  case "$opt" in
+  h|\?)
+    echo "Usage: $0 [OPTIONS...]"
+    echo
+    echo "  -s script friendly file name (godot.tar.gz)"
+    echo "  -v godot version for file name (e.g. 4.0-stable)"
+    echo "  -g git treeish to archive (e.g. master)"
+    echo
+    exit 1
+    ;;
+  s)
+    script_friendly_name=1
+    ;;
+  v)
+    godot_version=$OPTARG
+    ;;
+  g)
+    git_treeish=$OPTARG
+    ;;
+  esac
+done
+
+if [ ! -z "$git_treeish" ]; then
+  HEAD=$(git rev-parse $git_treeish)
+else
+  HEAD=$(git rev-parse HEAD)
+fi
+
+if [ ! -z "$script_friendly_name" ]; then
+  NAME=godot
+else
+  if [ ! -z "$godot_version" ]; then
+    NAME=godot-$godot_version
+  else
+    NAME=godot-$HEAD
+  fi
+fi
+
+CURDIR=$(pwd)
+TMPDIR=$(mktemp -d -t godot-XXXXXX)
+
+echo "Generating tarball for revision $HEAD with folder name '$NAME'."
+echo
+echo "The tarball will be written to the parent folder:"
+echo "    $(dirname $CURDIR)/$NAME.tar.gz"
+
+git archive $HEAD --prefix=$NAME/ -o $TMPDIR/$NAME.tar
+
+# Adding custom .git/HEAD to tarball so that we can generate VERSION_HASH.
+cd $TMPDIR
+mkdir -p $NAME/.git
+echo $HEAD > $NAME/.git/HEAD
+tar -uf $NAME.tar $NAME
+
+cd $CURDIR
+gzip -c $TMPDIR/$NAME.tar > ../$NAME.tar.gz
+
+rm -rf $TMPDIR
diff --git a/misc/scripts/mypy.ini b/misc/scripts/mypy.ini
new file mode 100644
index 00000000..c1ea695c
--- /dev/null
+++ b/misc/scripts/mypy.ini
@@ -0,0 +1,11 @@
+[mypy]
+ignore_missing_imports = true
+disallow_any_generics = True
+pretty = True
+show_column_numbers = True
+warn_redundant_casts = True
+warn_return_any = True
+warn_unreachable = True
+
+namespace_packages = True
+explicit_package_bases = True
diff --git a/misc/scripts/mypy_check.sh b/misc/scripts/mypy_check.sh
new file mode 100644
index 00000000..2a06486d
--- /dev/null
+++ b/misc/scripts/mypy_check.sh
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+set -uo pipefail
+
+echo -e "Python: mypy static analysis..."
+mypy --config-file=./misc/scripts/mypy.ini .
diff --git a/misc/scripts/pytest_builders.sh b/misc/scripts/pytest_builders.sh
new file mode 100644
index 00000000..eb2ddbcd
--- /dev/null
+++ b/misc/scripts/pytest_builders.sh
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -uo pipefail
+
+echo "Running Python checks for builder system"
+pytest ./tests/python_build

From 48305baf06fbfe2c4af7a33daeff366bda8fa97d Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Mon, 19 Jun 2023 15:31:42 -0700
Subject: [PATCH 43/71] Add python build.

---
 tests/python_build/conftest.py                | 26 +++++++++
 .../fixtures/gles3/_included.glsl             |  1 +
 .../fixtures/gles3/vertex_fragment.glsl       | 34 ++++++++++++
 .../gles3/vertex_fragment_expected_full.glsl  | 51 ++++++++++++++++++
 .../gles3/vertex_fragment_expected_parts.json | 53 +++++++++++++++++++
 .../python_build/fixtures/glsl/_included.glsl |  1 +
 tests/python_build/fixtures/glsl/compute.glsl | 12 +++++
 .../fixtures/glsl/compute_expected_full.glsl  |  8 +++
 .../fixtures/glsl/compute_expected_parts.json |  3 ++
 .../fixtures/glsl/vertex_fragment.glsl        | 32 +++++++++++
 .../glsl/vertex_fragment_expected_full.glsl   |  8 +++
 .../glsl/vertex_fragment_expected_parts.json  |  3 ++
 .../fixtures/rd_glsl/_included.glsl           |  1 +
 .../fixtures/rd_glsl/compute.glsl             | 13 +++++
 .../rd_glsl/compute_expected_full.glsl        | 20 +++++++
 .../rd_glsl/compute_expected_parts.json       | 28 ++++++++++
 .../fixtures/rd_glsl/vertex_fragment.glsl     | 25 +++++++++
 .../vertex_fragment_expected_full.glsl        | 23 ++++++++
 .../vertex_fragment_expected_parts.json       | 40 ++++++++++++++
 tests/python_build/test_gles3_builder.py      | 31 +++++++++++
 tests/python_build/test_glsl_builder.py       | 37 +++++++++++++
 21 files changed, 450 insertions(+)
 create mode 100644 tests/python_build/conftest.py
 create mode 100644 tests/python_build/fixtures/gles3/_included.glsl
 create mode 100644 tests/python_build/fixtures/gles3/vertex_fragment.glsl
 create mode 100644 tests/python_build/fixtures/gles3/vertex_fragment_expected_full.glsl
 create mode 100644 tests/python_build/fixtures/gles3/vertex_fragment_expected_parts.json
 create mode 100644 tests/python_build/fixtures/glsl/_included.glsl
 create mode 100644 tests/python_build/fixtures/glsl/compute.glsl
 create mode 100644 tests/python_build/fixtures/glsl/compute_expected_full.glsl
 create mode 100644 tests/python_build/fixtures/glsl/compute_expected_parts.json
 create mode 100644 tests/python_build/fixtures/glsl/vertex_fragment.glsl
 create mode 100644 tests/python_build/fixtures/glsl/vertex_fragment_expected_full.glsl
 create mode 100644 tests/python_build/fixtures/glsl/vertex_fragment_expected_parts.json
 create mode 100644 tests/python_build/fixtures/rd_glsl/_included.glsl
 create mode 100644 tests/python_build/fixtures/rd_glsl/compute.glsl
 create mode 100644 tests/python_build/fixtures/rd_glsl/compute_expected_full.glsl
 create mode 100644 tests/python_build/fixtures/rd_glsl/compute_expected_parts.json
 create mode 100644 tests/python_build/fixtures/rd_glsl/vertex_fragment.glsl
 create mode 100644 tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_full.glsl
 create mode 100644 tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_parts.json
 create mode 100644 tests/python_build/test_gles3_builder.py
 create mode 100644 tests/python_build/test_glsl_builder.py

diff --git a/tests/python_build/conftest.py b/tests/python_build/conftest.py
new file mode 100644
index 00000000..61723092
--- /dev/null
+++ b/tests/python_build/conftest.py
@@ -0,0 +1,26 @@
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+CWD = Path(__file__).parent
+ROOT = CWD.parent.parent
+# append directory with build files to sys.path to import them
+sys.path.append(str(ROOT))
+
+
+@pytest.fixture
+def shader_files(request):
+    shader_path = request.param
+
+    res = {
+        "path_input": str(CWD / "fixtures" / f"{shader_path}.glsl"),
+        "path_output": str(CWD / "fixtures" / f"{shader_path}.glsl.gen.h"),
+        "path_expected_full": str(CWD / "fixtures" / f"{shader_path}_expected_full.glsl"),
+        "path_expected_parts": str(CWD / "fixtures" / f"{shader_path}_expected_parts.json"),
+    }
+    yield res
+
+    if not os.getenv("PYTEST_KEEP_GENERATED_FILES"):
+        os.remove(res["path_output"])
diff --git a/tests/python_build/fixtures/gles3/_included.glsl b/tests/python_build/fixtures/gles3/_included.glsl
new file mode 100644
index 00000000..adf5f702
--- /dev/null
+++ b/tests/python_build/fixtures/gles3/_included.glsl
@@ -0,0 +1 @@
+#define M_PI 3.14159265359
diff --git a/tests/python_build/fixtures/gles3/vertex_fragment.glsl b/tests/python_build/fixtures/gles3/vertex_fragment.glsl
new file mode 100644
index 00000000..3004e22f
--- /dev/null
+++ b/tests/python_build/fixtures/gles3/vertex_fragment.glsl
@@ -0,0 +1,34 @@
+#include "_included.glsl"
+
+#[modes]
+
+mode_ninepatch = #define USE_NINEPATCH
+
+#[specializations]
+
+DISABLE_LIGHTING = false
+
+#[vertex]
+
+precision highp float;
+precision highp int;
+
+layout(location = 0) in highp vec3 vertex;
+
+out highp vec4 position_interp;
+
+void main() {
+	position_interp = vec4(vertex.x,1,0,1);
+}
+
+#[fragment]
+
+precision highp float;
+precision highp int;
+
+in highp vec4 position_interp;
+
+void main() {
+	highp float depth = ((position_interp.z / position_interp.w) + 1.0);
+	frag_color = vec4(depth);
+}
diff --git a/tests/python_build/fixtures/gles3/vertex_fragment_expected_full.glsl b/tests/python_build/fixtures/gles3/vertex_fragment_expected_full.glsl
new file mode 100644
index 00000000..58ddd08c
--- /dev/null
+++ b/tests/python_build/fixtures/gles3/vertex_fragment_expected_full.glsl
@@ -0,0 +1,51 @@
+/* WARNING, THIS FILE WAS GENERATED, DO NOT EDIT */
+#ifndef VERTEX_FRAGMENT_GLSL_GEN_HGLES3_GLES3
+#define VERTEX_FRAGMENT_GLSL_GEN_HGLES3_GLES3
+
+
+#include "drivers/gles3/shader_gles3.h"
+
+
+class VertexFragmentShaderGLES3 : public ShaderGLES3 {
+
+public:
+
+	enum ShaderVariant {
+		MODE_NINEPATCH,
+	};
+
+	enum Specializations {
+		DISABLE_LIGHTING=1,
+	};
+
+	_FORCE_INLINE_ bool version_bind_shader(RID p_version,ShaderVariant p_variant,uint64_t p_specialization=0) { return _version_bind_shader(p_version,p_variant,p_specialization); }
+
+protected:
+
+	virtual void _init() override {
+
+		static const char **_uniform_strings=nullptr;
+		static const char* _variant_defines[]={
+			"#define USE_NINEPATCH",
+		};
+
+		static TexUnitPair *_texunit_pairs=nullptr;
+		static UBOPair *_ubo_pairs=nullptr;
+		static Specialization _spec_pairs[]={
+			{"DISABLE_LIGHTING",false},
+		};
+
+		static const Feedback* _feedbacks=nullptr;
+		static const char _vertex_code[]={
+10,112,114,101,99,105,115,105,111,110,32,104,105,103,104,112,32,102,108,111,97,116,59,10,112,114,101,99,105,115,105,111,110,32,104,105,103,104,112,32,105,110,116,59,10,10,108,97,121,111,117,116,40,108,111,99,97,116,105,111,110,32,61,32,48,41,32,105,110,32,104,105,103,104,112,32,118,101,99,51,32,118,101,114,116,101,120,59,10,10,111,117,116,32,104,105,103,104,112,32,118,101,99,52,32,112,111,115,105,116,105,111,110,95,105,110,116,101,114,112,59,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,9,112,111,115,105,116,105,111,110,95,105,110,116,101,114,112,32,61,32,118,101,99,52,40,118,101,114,116,101,120,46,120,44,49,44,48,44,49,41,59,10,125,10,10,		0};
+
+		static const char _fragment_code[]={
+10,112,114,101,99,105,115,105,111,110,32,104,105,103,104,112,32,102,108,111,97,116,59,10,112,114,101,99,105,115,105,111,110,32,104,105,103,104,112,32,105,110,116,59,10,10,105,110,32,104,105,103,104,112,32,118,101,99,52,32,112,111,115,105,116,105,111,110,95,105,110,116,101,114,112,59,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,9,104,105,103,104,112,32,102,108,111,97,116,32,100,101,112,116,104,32,61,32,40,40,112,111,115,105,116,105,111,110,95,105,110,116,101,114,112,46,122,32,47,32,112,111,115,105,116,105,111,110,95,105,110,116,101,114,112,46,119,41,32,43,32,49,46,48,41,59,10,9,102,114,97,103,95,99,111,108,111,114,32,61,32,118,101,99,52,40,100,101,112,116,104,41,59,10,125,10,		0};
+
+		_setup(_vertex_code,_fragment_code,"VertexFragmentShaderGLES3",0,_uniform_strings,0,_ubo_pairs,0,_feedbacks,0,_texunit_pairs,1,_spec_pairs,1,_variant_defines);
+	}
+
+};
+
+#endif
+
diff --git a/tests/python_build/fixtures/gles3/vertex_fragment_expected_parts.json b/tests/python_build/fixtures/gles3/vertex_fragment_expected_parts.json
new file mode 100644
index 00000000..5ac8092a
--- /dev/null
+++ b/tests/python_build/fixtures/gles3/vertex_fragment_expected_parts.json
@@ -0,0 +1,53 @@
+{
+  "vertex_lines": [
+	"",
+	"precision highp float;",
+	"precision highp int;",
+	"",
+	"layout(location = 0) in highp vec3 vertex;",
+	"",
+	"out highp vec4 position_interp;",
+	"",
+	"void main() {",
+	"\tposition_interp = vec4(vertex.x,1,0,1);",
+	"}",
+	""
+  ],
+  "fragment_lines": [
+	"",
+	"precision highp float;",
+	"precision highp int;",
+	"",
+	"in highp vec4 position_interp;",
+	"",
+	"void main() {",
+	"\thighp float depth = ((position_interp.z / position_interp.w) + 1.0);",
+	"\tfrag_color = vec4(depth);",
+	"}"
+  ],
+  "uniforms": [],
+  "fbos": [],
+  "texunits": [],
+  "texunit_names": [],
+  "ubos": [],
+  "ubo_names": [],
+  "feedbacks": [],
+  "vertex_included_files": [],
+  "fragment_included_files": [],
+  "reading": "fragment",
+  "line_offset": 33,
+  "vertex_offset": 10,
+  "fragment_offset": 23,
+  "variant_defines": [
+	"#define USE_NINEPATCH"
+  ],
+  "variant_names": [
+	"MODE_NINEPATCH"
+  ],
+  "specialization_names": [
+	"DISABLE_LIGHTING"
+  ],
+  "specialization_values": [
+	" false\n"
+  ]
+}
diff --git a/tests/python_build/fixtures/glsl/_included.glsl b/tests/python_build/fixtures/glsl/_included.glsl
new file mode 100644
index 00000000..adf5f702
--- /dev/null
+++ b/tests/python_build/fixtures/glsl/_included.glsl
@@ -0,0 +1 @@
+#define M_PI 3.14159265359
diff --git a/tests/python_build/fixtures/glsl/compute.glsl b/tests/python_build/fixtures/glsl/compute.glsl
new file mode 100644
index 00000000..e81f48d4
--- /dev/null
+++ b/tests/python_build/fixtures/glsl/compute.glsl
@@ -0,0 +1,12 @@
+#[compute]
+
+#version 450
+
+#VERSION_DEFINES
+
+
+#include "_included.glsl"
+
+void main() {
+	vec3 static_light = vec3(0, 1, 0);
+}
diff --git a/tests/python_build/fixtures/glsl/compute_expected_full.glsl b/tests/python_build/fixtures/glsl/compute_expected_full.glsl
new file mode 100644
index 00000000..b937d732
--- /dev/null
+++ b/tests/python_build/fixtures/glsl/compute_expected_full.glsl
@@ -0,0 +1,8 @@
+/* WARNING, THIS FILE WAS GENERATED, DO NOT EDIT */
+#ifndef COMPUTE_SHADER_GLSL_RAW_H
+#define COMPUTE_SHADER_GLSL_RAW_H
+
+static const char compute_shader_glsl[] = {
+    35,91,99,111,109,112,117,116,101,93,10,10,35,118,101,114,115,105,111,110,32,52,53,48,10,10,35,86,69,82,83,73,79,78,95,68,69,70,73,78,69,83,10,10,10,35,100,101,102,105,110,101,32,77,95,80,73,32,51,46,49,52,49,53,57,50,54,53,51,53,57,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,9,118,101,99,51,32,115,116,97,116,105,99,95,108,105,103,104,116,32,61,32,118,101,99,51,40,48,44,32,49,44,32,48,41,59,10,125,10,0
+};
+#endif
diff --git a/tests/python_build/fixtures/glsl/compute_expected_parts.json b/tests/python_build/fixtures/glsl/compute_expected_parts.json
new file mode 100644
index 00000000..025c568a
--- /dev/null
+++ b/tests/python_build/fixtures/glsl/compute_expected_parts.json
@@ -0,0 +1,3 @@
+{
+  "code": "#[compute]\n\n#version 450\n\n#VERSION_DEFINES\n\n\n#define M_PI 3.14159265359\n\nvoid main() {\n\tvec3 static_light = vec3(0, 1, 0);\n}\n"
+}
diff --git a/tests/python_build/fixtures/glsl/vertex_fragment.glsl b/tests/python_build/fixtures/glsl/vertex_fragment.glsl
new file mode 100644
index 00000000..0bdce783
--- /dev/null
+++ b/tests/python_build/fixtures/glsl/vertex_fragment.glsl
@@ -0,0 +1,32 @@
+#[versions]
+
+lines = "#define MODE_LINES";
+
+#[vertex]
+
+#version 450
+
+#VERSION_DEFINES
+
+layout(location = 0) out vec3 uv_interp;
+
+void main() {
+
+#ifdef MODE_LINES
+	uv_interp = vec3(0,0,1);
+#endif
+}
+
+#[fragment]
+
+#version 450
+
+#VERSION_DEFINES
+
+#include "_included.glsl"
+
+layout(location = 0) out vec4 dst_color;
+
+void main() {
+	dst_color = vec4(1,1,0,0);
+}
diff --git a/tests/python_build/fixtures/glsl/vertex_fragment_expected_full.glsl b/tests/python_build/fixtures/glsl/vertex_fragment_expected_full.glsl
new file mode 100644
index 00000000..3f53a17f
--- /dev/null
+++ b/tests/python_build/fixtures/glsl/vertex_fragment_expected_full.glsl
@@ -0,0 +1,8 @@
+/* WARNING, THIS FILE WAS GENERATED, DO NOT EDIT */
+#ifndef VERTEX_FRAGMENT_SHADER_GLSL_RAW_H
+#define VERTEX_FRAGMENT_SHADER_GLSL_RAW_H
+
+static const char vertex_fragment_shader_glsl[] = {
+    35,91,118,101,114,115,105,111,110,115,93,10,10,108,105,110,101,115,32,61,32,34,35,100,101,102,105,110,101,32,77,79,68,69,95,76,73,78,69,83,34,59,10,10,35,91,118,101,114,116,101,120,93,10,10,35,118,101,114,115,105,111,110,32,52,53,48,10,10,35,86,69,82,83,73,79,78,95,68,69,70,73,78,69,83,10,10,108,97,121,111,117,116,40,108,111,99,97,116,105,111,110,32,61,32,48,41,32,111,117,116,32,118,101,99,51,32,117,118,95,105,110,116,101,114,112,59,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,10,35,105,102,100,101,102,32,77,79,68,69,95,76,73,78,69,83,10,9,117,118,95,105,110,116,101,114,112,32,61,32,118,101,99,51,40,48,44,48,44,49,41,59,10,35,101,110,100,105,102,10,125,10,10,35,91,102,114,97,103,109,101,110,116,93,10,10,35,118,101,114,115,105,111,110,32,52,53,48,10,10,35,86,69,82,83,73,79,78,95,68,69,70,73,78,69,83,10,10,35,100,101,102,105,110,101,32,77,95,80,73,32,51,46,49,52,49,53,57,50,54,53,51,53,57,10,10,108,97,121,111,117,116,40,108,111,99,97,116,105,111,110,32,61,32,48,41,32,111,117,116,32,118,101,99,52,32,100,115,116,95,99,111,108,111,114,59,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,9,100,115,116,95,99,111,108,111,114,32,61,32,118,101,99,52,40,49,44,49,44,48,44,48,41,59,10,125,10,0
+};
+#endif
diff --git a/tests/python_build/fixtures/glsl/vertex_fragment_expected_parts.json b/tests/python_build/fixtures/glsl/vertex_fragment_expected_parts.json
new file mode 100644
index 00000000..38312367
--- /dev/null
+++ b/tests/python_build/fixtures/glsl/vertex_fragment_expected_parts.json
@@ -0,0 +1,3 @@
+{
+  "code": "#[versions]\n\nlines = \"#define MODE_LINES\";\n\n#[vertex]\n\n#version 450\n\n#VERSION_DEFINES\n\nlayout(location = 0) out vec3 uv_interp;\n\nvoid main() {\n\n#ifdef MODE_LINES\n\tuv_interp = vec3(0,0,1);\n#endif\n}\n\n#[fragment]\n\n#version 450\n\n#VERSION_DEFINES\n\n#define M_PI 3.14159265359\n\nlayout(location = 0) out vec4 dst_color;\n\nvoid main() {\n\tdst_color = vec4(1,1,0,0);\n}\n"
+}
diff --git a/tests/python_build/fixtures/rd_glsl/_included.glsl b/tests/python_build/fixtures/rd_glsl/_included.glsl
new file mode 100644
index 00000000..adf5f702
--- /dev/null
+++ b/tests/python_build/fixtures/rd_glsl/_included.glsl
@@ -0,0 +1 @@
+#define M_PI 3.14159265359
diff --git a/tests/python_build/fixtures/rd_glsl/compute.glsl b/tests/python_build/fixtures/rd_glsl/compute.glsl
new file mode 100644
index 00000000..66fbbeb4
--- /dev/null
+++ b/tests/python_build/fixtures/rd_glsl/compute.glsl
@@ -0,0 +1,13 @@
+#[compute]
+
+#version 450
+
+#VERSION_DEFINES
+
+#define BLOCK_SIZE 8
+
+#include "_included.glsl"
+
+void main() {
+	uint t = BLOCK_SIZE + 1;
+}
diff --git a/tests/python_build/fixtures/rd_glsl/compute_expected_full.glsl b/tests/python_build/fixtures/rd_glsl/compute_expected_full.glsl
new file mode 100644
index 00000000..b59923e2
--- /dev/null
+++ b/tests/python_build/fixtures/rd_glsl/compute_expected_full.glsl
@@ -0,0 +1,20 @@
+/* WARNING, THIS FILE WAS GENERATED, DO NOT EDIT */
+#ifndef COMPUTE_GLSL_GEN_H_RD
+#define COMPUTE_GLSL_GEN_H_RD
+
+#include "servers/rendering/renderer_rd/shader_rd.h"
+
+class ComputeShaderRD : public ShaderRD {
+
+public:
+
+	ComputeShaderRD() {
+
+		static const char _compute_code[] = {
+10,35,118,101,114,115,105,111,110,32,52,53,48,10,10,35,86,69,82,83,73,79,78,95,68,69,70,73,78,69,83,10,10,35,100,101,102,105,110,101,32,66,76,79,67,75,95,83,73,90,69,32,56,10,10,35,100,101,102,105,110,101,32,77,95,80,73,32,51,46,49,52,49,53,57,50,54,53,51,53,57,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,9,117,105,110,116,32,116,32,61,32,66,76,79,67,75,95,83,73,90,69,32,43,32,49,59,10,125,10,0
+		};
+		setup(nullptr, nullptr, _compute_code, "ComputeShaderRD");
+	}
+};
+
+#endif
diff --git a/tests/python_build/fixtures/rd_glsl/compute_expected_parts.json b/tests/python_build/fixtures/rd_glsl/compute_expected_parts.json
new file mode 100644
index 00000000..26ba9e4f
--- /dev/null
+++ b/tests/python_build/fixtures/rd_glsl/compute_expected_parts.json
@@ -0,0 +1,28 @@
+{
+  "vertex_lines": [],
+  "fragment_lines": [],
+  "compute_lines": [
+	"",
+	"#version 450",
+	"",
+	"#VERSION_DEFINES",
+	"",
+	"#define BLOCK_SIZE 8",
+	"",
+	"#define M_PI 3.14159265359",
+	"",
+	"void main() {",
+	"\tuint t = BLOCK_SIZE + 1;",
+	"}"
+  ],
+  "vertex_included_files": [],
+  "fragment_included_files": [],
+  "compute_included_files": [
+	"tests/python_build/fixtures/rd_glsl/_included.glsl"
+  ],
+  "reading": "compute",
+  "line_offset": 13,
+  "vertex_offset": 0,
+  "fragment_offset": 0,
+  "compute_offset": 1
+}
diff --git a/tests/python_build/fixtures/rd_glsl/vertex_fragment.glsl b/tests/python_build/fixtures/rd_glsl/vertex_fragment.glsl
new file mode 100644
index 00000000..27be08a8
--- /dev/null
+++ b/tests/python_build/fixtures/rd_glsl/vertex_fragment.glsl
@@ -0,0 +1,25 @@
+#[vertex]
+
+#version 450
+
+#VERSION_DEFINES
+
+#include "_included.glsl"
+
+layout(location = 0) out vec2 uv_interp;
+
+void main() {
+	uv_interp = vec2(0, 1);
+}
+
+#[fragment]
+
+#version 450
+
+#VERSION_DEFINES
+
+layout(location = 0) in vec2 uv_interp;
+
+void main() {
+	uv_interp = vec2(1, 0);
+}
diff --git a/tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_full.glsl b/tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_full.glsl
new file mode 100644
index 00000000..ff804dbf
--- /dev/null
+++ b/tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_full.glsl
@@ -0,0 +1,23 @@
+/* WARNING, THIS FILE WAS GENERATED, DO NOT EDIT */
+#ifndef VERTEX_FRAGMENT_GLSL_GEN_H_RD
+#define VERTEX_FRAGMENT_GLSL_GEN_H_RD
+
+#include "servers/rendering/renderer_rd/shader_rd.h"
+
+class VertexFragmentShaderRD : public ShaderRD {
+
+public:
+
+	VertexFragmentShaderRD() {
+
+		static const char _vertex_code[] = {
+10,35,118,101,114,115,105,111,110,32,52,53,48,10,10,35,86,69,82,83,73,79,78,95,68,69,70,73,78,69,83,10,10,35,100,101,102,105,110,101,32,77,95,80,73,32,51,46,49,52,49,53,57,50,54,53,51,53,57,10,10,108,97,121,111,117,116,40,108,111,99,97,116,105,111,110,32,61,32,48,41,32,111,117,116,32,118,101,99,50,32,117,118,95,105,110,116,101,114,112,59,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,9,117,118,95,105,110,116,101,114,112,32,61,32,118,101,99,50,40,48,44,32,49,41,59,10,125,10,10,0
+		};
+		static const char _fragment_code[] = {
+10,35,118,101,114,115,105,111,110,32,52,53,48,10,10,35,86,69,82,83,73,79,78,95,68,69,70,73,78,69,83,10,10,108,97,121,111,117,116,40,108,111,99,97,116,105,111,110,32,61,32,48,41,32,105,110,32,118,101,99,50,32,117,118,95,105,110,116,101,114,112,59,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,9,117,118,95,105,110,116,101,114,112,32,61,32,118,101,99,50,40,49,44,32,48,41,59,10,125,10,0
+		};
+		setup(_vertex_code, _fragment_code, nullptr, "VertexFragmentShaderRD");
+	}
+};
+
+#endif
diff --git a/tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_parts.json b/tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_parts.json
new file mode 100644
index 00000000..dbf833ed
--- /dev/null
+++ b/tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_parts.json
@@ -0,0 +1,40 @@
+{
+  "vertex_lines": [
+	"",
+	"#version 450",
+	"",
+	"#VERSION_DEFINES",
+	"",
+	"#define M_PI 3.14159265359",
+	"",
+	"layout(location = 0) out vec2 uv_interp;",
+	"",
+	"void main() {",
+	"\tuv_interp = vec2(0, 1);",
+	"}",
+	""
+  ],
+  "fragment_lines": [
+	"",
+	"#version 450",
+	"",
+	"#VERSION_DEFINES",
+	"",
+	"layout(location = 0) in vec2 uv_interp;",
+	"",
+	"void main() {",
+	"\tuv_interp = vec2(1, 0);",
+	"}"
+  ],
+  "compute_lines": [],
+  "vertex_included_files": [
+	"tests/python_build/fixtures/rd_glsl/_included.glsl"
+  ],
+  "fragment_included_files": [],
+  "compute_included_files": [],
+  "reading": "fragment",
+  "line_offset": 25,
+  "vertex_offset": 1,
+  "fragment_offset": 15,
+  "compute_offset": 0
+}
diff --git a/tests/python_build/test_gles3_builder.py b/tests/python_build/test_gles3_builder.py
new file mode 100644
index 00000000..861e0b84
--- /dev/null
+++ b/tests/python_build/test_gles3_builder.py
@@ -0,0 +1,31 @@
+import json
+
+import pytest
+
+from gles3_builders import build_gles3_header, GLES3HeaderStruct
+
+
+@pytest.mark.parametrize(
+    ["shader_files", "builder", "header_struct"],
+    [
+        ("gles3/vertex_fragment", build_gles3_header, GLES3HeaderStruct),
+    ],
+    indirect=["shader_files"],
+)
+def test_gles3_builder(shader_files, builder, header_struct):
+    header = header_struct()
+
+    builder(shader_files["path_input"], "drivers/gles3/shader_gles3.h", "GLES3", header_data=header)
+
+    with open(shader_files["path_expected_parts"], "r") as f:
+        expected_parts = json.load(f)
+        assert expected_parts == header.__dict__
+
+    with open(shader_files["path_output"], "r") as f:
+        actual_output = f.read()
+        assert actual_output
+
+    with open(shader_files["path_expected_full"], "r") as f:
+        expected_output = f.read()
+
+    assert actual_output == expected_output
diff --git a/tests/python_build/test_glsl_builder.py b/tests/python_build/test_glsl_builder.py
new file mode 100644
index 00000000..b9dcef48
--- /dev/null
+++ b/tests/python_build/test_glsl_builder.py
@@ -0,0 +1,37 @@
+import json
+
+import pytest
+
+from glsl_builders import build_raw_header, RAWHeaderStruct, build_rd_header, RDHeaderStruct
+
+
+@pytest.mark.parametrize(
+    [
+        "shader_files",
+        "builder",
+        "header_struct",
+    ],
+    [
+        ("glsl/vertex_fragment", build_raw_header, RAWHeaderStruct),
+        ("glsl/compute", build_raw_header, RAWHeaderStruct),
+        ("rd_glsl/vertex_fragment", build_rd_header, RDHeaderStruct),
+        ("rd_glsl/compute", build_rd_header, RDHeaderStruct),
+    ],
+    indirect=["shader_files"],
+)
+def test_glsl_builder(shader_files, builder, header_struct):
+    header = header_struct()
+    builder(shader_files["path_input"], header_data=header)
+
+    with open(shader_files["path_expected_parts"], "r") as f:
+        expected_parts = json.load(f)
+        assert expected_parts == header.__dict__
+
+    with open(shader_files["path_output"], "r") as f:
+        actual_output = f.read()
+        assert actual_output
+
+    with open(shader_files["path_expected_full"], "r") as f:
+        expected_output = f.read()
+
+    assert actual_output == expected_output

From 01abd786d9f21876fb5cba197bfc86732d754e18 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Mon, 19 Jun 2023 15:33:53 -0700
Subject: [PATCH 44/71] Remove python tests.

---
 .github/workflows/static_checks.yml           |  4 --
 tests/python_build/conftest.py                | 26 ---------
 .../fixtures/gles3/_included.glsl             |  1 -
 .../fixtures/gles3/vertex_fragment.glsl       | 34 ------------
 .../gles3/vertex_fragment_expected_full.glsl  | 51 ------------------
 .../gles3/vertex_fragment_expected_parts.json | 53 -------------------
 .../python_build/fixtures/glsl/_included.glsl |  1 -
 tests/python_build/fixtures/glsl/compute.glsl | 12 -----
 .../fixtures/glsl/compute_expected_full.glsl  |  8 ---
 .../fixtures/glsl/compute_expected_parts.json |  3 --
 .../fixtures/glsl/vertex_fragment.glsl        | 32 -----------
 .../glsl/vertex_fragment_expected_full.glsl   |  8 ---
 .../glsl/vertex_fragment_expected_parts.json  |  3 --
 .../fixtures/rd_glsl/_included.glsl           |  1 -
 .../fixtures/rd_glsl/compute.glsl             | 13 -----
 .../rd_glsl/compute_expected_full.glsl        | 20 -------
 .../rd_glsl/compute_expected_parts.json       | 28 ----------
 .../fixtures/rd_glsl/vertex_fragment.glsl     | 25 ---------
 .../vertex_fragment_expected_full.glsl        | 23 --------
 .../vertex_fragment_expected_parts.json       | 40 --------------
 tests/python_build/test_gles3_builder.py      | 31 -----------
 tests/python_build/test_glsl_builder.py       | 37 -------------
 22 files changed, 454 deletions(-)
 delete mode 100644 tests/python_build/conftest.py
 delete mode 100644 tests/python_build/fixtures/gles3/_included.glsl
 delete mode 100644 tests/python_build/fixtures/gles3/vertex_fragment.glsl
 delete mode 100644 tests/python_build/fixtures/gles3/vertex_fragment_expected_full.glsl
 delete mode 100644 tests/python_build/fixtures/gles3/vertex_fragment_expected_parts.json
 delete mode 100644 tests/python_build/fixtures/glsl/_included.glsl
 delete mode 100644 tests/python_build/fixtures/glsl/compute.glsl
 delete mode 100644 tests/python_build/fixtures/glsl/compute_expected_full.glsl
 delete mode 100644 tests/python_build/fixtures/glsl/compute_expected_parts.json
 delete mode 100644 tests/python_build/fixtures/glsl/vertex_fragment.glsl
 delete mode 100644 tests/python_build/fixtures/glsl/vertex_fragment_expected_full.glsl
 delete mode 100644 tests/python_build/fixtures/glsl/vertex_fragment_expected_parts.json
 delete mode 100644 tests/python_build/fixtures/rd_glsl/_included.glsl
 delete mode 100644 tests/python_build/fixtures/rd_glsl/compute.glsl
 delete mode 100644 tests/python_build/fixtures/rd_glsl/compute_expected_full.glsl
 delete mode 100644 tests/python_build/fixtures/rd_glsl/compute_expected_parts.json
 delete mode 100644 tests/python_build/fixtures/rd_glsl/vertex_fragment.glsl
 delete mode 100644 tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_full.glsl
 delete mode 100644 tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_parts.json
 delete mode 100644 tests/python_build/test_gles3_builder.py
 delete mode 100644 tests/python_build/test_glsl_builder.py

diff --git a/.github/workflows/static_checks.yml b/.github/workflows/static_checks.yml
index 84066808..de5c17fc 100644
--- a/.github/workflows/static_checks.yml
+++ b/.github/workflows/static_checks.yml
@@ -65,10 +65,6 @@ jobs:
             echo "Skipping Python static analysis as no Python files were changed."
           fi
 
-      - name: Python builders checks via pytest (pytest_builders.sh)
-        run: |
-          bash ./misc/scripts/pytest_builders.sh
-
       - name: JavaScript style and documentation checks via ESLint and JSDoc
         run: |
           if grep -q "platform/web" changed.txt || [ -z "$(cat changed.txt)" ]; then
diff --git a/tests/python_build/conftest.py b/tests/python_build/conftest.py
deleted file mode 100644
index 61723092..00000000
--- a/tests/python_build/conftest.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import os
-import sys
-from pathlib import Path
-
-import pytest
-
-CWD = Path(__file__).parent
-ROOT = CWD.parent.parent
-# append directory with build files to sys.path to import them
-sys.path.append(str(ROOT))
-
-
-@pytest.fixture
-def shader_files(request):
-    shader_path = request.param
-
-    res = {
-        "path_input": str(CWD / "fixtures" / f"{shader_path}.glsl"),
-        "path_output": str(CWD / "fixtures" / f"{shader_path}.glsl.gen.h"),
-        "path_expected_full": str(CWD / "fixtures" / f"{shader_path}_expected_full.glsl"),
-        "path_expected_parts": str(CWD / "fixtures" / f"{shader_path}_expected_parts.json"),
-    }
-    yield res
-
-    if not os.getenv("PYTEST_KEEP_GENERATED_FILES"):
-        os.remove(res["path_output"])
diff --git a/tests/python_build/fixtures/gles3/_included.glsl b/tests/python_build/fixtures/gles3/_included.glsl
deleted file mode 100644
index adf5f702..00000000
--- a/tests/python_build/fixtures/gles3/_included.glsl
+++ /dev/null
@@ -1 +0,0 @@
-#define M_PI 3.14159265359
diff --git a/tests/python_build/fixtures/gles3/vertex_fragment.glsl b/tests/python_build/fixtures/gles3/vertex_fragment.glsl
deleted file mode 100644
index 3004e22f..00000000
--- a/tests/python_build/fixtures/gles3/vertex_fragment.glsl
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "_included.glsl"
-
-#[modes]
-
-mode_ninepatch = #define USE_NINEPATCH
-
-#[specializations]
-
-DISABLE_LIGHTING = false
-
-#[vertex]
-
-precision highp float;
-precision highp int;
-
-layout(location = 0) in highp vec3 vertex;
-
-out highp vec4 position_interp;
-
-void main() {
-	position_interp = vec4(vertex.x,1,0,1);
-}
-
-#[fragment]
-
-precision highp float;
-precision highp int;
-
-in highp vec4 position_interp;
-
-void main() {
-	highp float depth = ((position_interp.z / position_interp.w) + 1.0);
-	frag_color = vec4(depth);
-}
diff --git a/tests/python_build/fixtures/gles3/vertex_fragment_expected_full.glsl b/tests/python_build/fixtures/gles3/vertex_fragment_expected_full.glsl
deleted file mode 100644
index 58ddd08c..00000000
--- a/tests/python_build/fixtures/gles3/vertex_fragment_expected_full.glsl
+++ /dev/null
@@ -1,51 +0,0 @@
-/* WARNING, THIS FILE WAS GENERATED, DO NOT EDIT */
-#ifndef VERTEX_FRAGMENT_GLSL_GEN_HGLES3_GLES3
-#define VERTEX_FRAGMENT_GLSL_GEN_HGLES3_GLES3
-
-
-#include "drivers/gles3/shader_gles3.h"
-
-
-class VertexFragmentShaderGLES3 : public ShaderGLES3 {
-
-public:
-
-	enum ShaderVariant {
-		MODE_NINEPATCH,
-	};
-
-	enum Specializations {
-		DISABLE_LIGHTING=1,
-	};
-
-	_FORCE_INLINE_ bool version_bind_shader(RID p_version,ShaderVariant p_variant,uint64_t p_specialization=0) { return _version_bind_shader(p_version,p_variant,p_specialization); }
-
-protected:
-
-	virtual void _init() override {
-
-		static const char **_uniform_strings=nullptr;
-		static const char* _variant_defines[]={
-			"#define USE_NINEPATCH",
-		};
-
-		static TexUnitPair *_texunit_pairs=nullptr;
-		static UBOPair *_ubo_pairs=nullptr;
-		static Specialization _spec_pairs[]={
-			{"DISABLE_LIGHTING",false},
-		};
-
-		static const Feedback* _feedbacks=nullptr;
-		static const char _vertex_code[]={
-10,112,114,101,99,105,115,105,111,110,32,104,105,103,104,112,32,102,108,111,97,116,59,10,112,114,101,99,105,115,105,111,110,32,104,105,103,104,112,32,105,110,116,59,10,10,108,97,121,111,117,116,40,108,111,99,97,116,105,111,110,32,61,32,48,41,32,105,110,32,104,105,103,104,112,32,118,101,99,51,32,118,101,114,116,101,120,59,10,10,111,117,116,32,104,105,103,104,112,32,118,101,99,52,32,112,111,115,105,116,105,111,110,95,105,110,116,101,114,112,59,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,9,112,111,115,105,116,105,111,110,95,105,110,116,101,114,112,32,61,32,118,101,99,52,40,118,101,114,116,101,120,46,120,44,49,44,48,44,49,41,59,10,125,10,10,		0};
-
-		static const char _fragment_code[]={
-10,112,114,101,99,105,115,105,111,110,32,104,105,103,104,112,32,102,108,111,97,116,59,10,112,114,101,99,105,115,105,111,110,32,104,105,103,104,112,32,105,110,116,59,10,10,105,110,32,104,105,103,104,112,32,118,101,99,52,32,112,111,115,105,116,105,111,110,95,105,110,116,101,114,112,59,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,9,104,105,103,104,112,32,102,108,111,97,116,32,100,101,112,116,104,32,61,32,40,40,112,111,115,105,116,105,111,110,95,105,110,116,101,114,112,46,122,32,47,32,112,111,115,105,116,105,111,110,95,105,110,116,101,114,112,46,119,41,32,43,32,49,46,48,41,59,10,9,102,114,97,103,95,99,111,108,111,114,32,61,32,118,101,99,52,40,100,101,112,116,104,41,59,10,125,10,		0};
-
-		_setup(_vertex_code,_fragment_code,"VertexFragmentShaderGLES3",0,_uniform_strings,0,_ubo_pairs,0,_feedbacks,0,_texunit_pairs,1,_spec_pairs,1,_variant_defines);
-	}
-
-};
-
-#endif
-
diff --git a/tests/python_build/fixtures/gles3/vertex_fragment_expected_parts.json b/tests/python_build/fixtures/gles3/vertex_fragment_expected_parts.json
deleted file mode 100644
index 5ac8092a..00000000
--- a/tests/python_build/fixtures/gles3/vertex_fragment_expected_parts.json
+++ /dev/null
@@ -1,53 +0,0 @@
-{
-  "vertex_lines": [
-	"",
-	"precision highp float;",
-	"precision highp int;",
-	"",
-	"layout(location = 0) in highp vec3 vertex;",
-	"",
-	"out highp vec4 position_interp;",
-	"",
-	"void main() {",
-	"\tposition_interp = vec4(vertex.x,1,0,1);",
-	"}",
-	""
-  ],
-  "fragment_lines": [
-	"",
-	"precision highp float;",
-	"precision highp int;",
-	"",
-	"in highp vec4 position_interp;",
-	"",
-	"void main() {",
-	"\thighp float depth = ((position_interp.z / position_interp.w) + 1.0);",
-	"\tfrag_color = vec4(depth);",
-	"}"
-  ],
-  "uniforms": [],
-  "fbos": [],
-  "texunits": [],
-  "texunit_names": [],
-  "ubos": [],
-  "ubo_names": [],
-  "feedbacks": [],
-  "vertex_included_files": [],
-  "fragment_included_files": [],
-  "reading": "fragment",
-  "line_offset": 33,
-  "vertex_offset": 10,
-  "fragment_offset": 23,
-  "variant_defines": [
-	"#define USE_NINEPATCH"
-  ],
-  "variant_names": [
-	"MODE_NINEPATCH"
-  ],
-  "specialization_names": [
-	"DISABLE_LIGHTING"
-  ],
-  "specialization_values": [
-	" false\n"
-  ]
-}
diff --git a/tests/python_build/fixtures/glsl/_included.glsl b/tests/python_build/fixtures/glsl/_included.glsl
deleted file mode 100644
index adf5f702..00000000
--- a/tests/python_build/fixtures/glsl/_included.glsl
+++ /dev/null
@@ -1 +0,0 @@
-#define M_PI 3.14159265359
diff --git a/tests/python_build/fixtures/glsl/compute.glsl b/tests/python_build/fixtures/glsl/compute.glsl
deleted file mode 100644
index e81f48d4..00000000
--- a/tests/python_build/fixtures/glsl/compute.glsl
+++ /dev/null
@@ -1,12 +0,0 @@
-#[compute]
-
-#version 450
-
-#VERSION_DEFINES
-
-
-#include "_included.glsl"
-
-void main() {
-	vec3 static_light = vec3(0, 1, 0);
-}
diff --git a/tests/python_build/fixtures/glsl/compute_expected_full.glsl b/tests/python_build/fixtures/glsl/compute_expected_full.glsl
deleted file mode 100644
index b937d732..00000000
--- a/tests/python_build/fixtures/glsl/compute_expected_full.glsl
+++ /dev/null
@@ -1,8 +0,0 @@
-/* WARNING, THIS FILE WAS GENERATED, DO NOT EDIT */
-#ifndef COMPUTE_SHADER_GLSL_RAW_H
-#define COMPUTE_SHADER_GLSL_RAW_H
-
-static const char compute_shader_glsl[] = {
-    35,91,99,111,109,112,117,116,101,93,10,10,35,118,101,114,115,105,111,110,32,52,53,48,10,10,35,86,69,82,83,73,79,78,95,68,69,70,73,78,69,83,10,10,10,35,100,101,102,105,110,101,32,77,95,80,73,32,51,46,49,52,49,53,57,50,54,53,51,53,57,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,9,118,101,99,51,32,115,116,97,116,105,99,95,108,105,103,104,116,32,61,32,118,101,99,51,40,48,44,32,49,44,32,48,41,59,10,125,10,0
-};
-#endif
diff --git a/tests/python_build/fixtures/glsl/compute_expected_parts.json b/tests/python_build/fixtures/glsl/compute_expected_parts.json
deleted file mode 100644
index 025c568a..00000000
--- a/tests/python_build/fixtures/glsl/compute_expected_parts.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-  "code": "#[compute]\n\n#version 450\n\n#VERSION_DEFINES\n\n\n#define M_PI 3.14159265359\n\nvoid main() {\n\tvec3 static_light = vec3(0, 1, 0);\n}\n"
-}
diff --git a/tests/python_build/fixtures/glsl/vertex_fragment.glsl b/tests/python_build/fixtures/glsl/vertex_fragment.glsl
deleted file mode 100644
index 0bdce783..00000000
--- a/tests/python_build/fixtures/glsl/vertex_fragment.glsl
+++ /dev/null
@@ -1,32 +0,0 @@
-#[versions]
-
-lines = "#define MODE_LINES";
-
-#[vertex]
-
-#version 450
-
-#VERSION_DEFINES
-
-layout(location = 0) out vec3 uv_interp;
-
-void main() {
-
-#ifdef MODE_LINES
-	uv_interp = vec3(0,0,1);
-#endif
-}
-
-#[fragment]
-
-#version 450
-
-#VERSION_DEFINES
-
-#include "_included.glsl"
-
-layout(location = 0) out vec4 dst_color;
-
-void main() {
-	dst_color = vec4(1,1,0,0);
-}
diff --git a/tests/python_build/fixtures/glsl/vertex_fragment_expected_full.glsl b/tests/python_build/fixtures/glsl/vertex_fragment_expected_full.glsl
deleted file mode 100644
index 3f53a17f..00000000
--- a/tests/python_build/fixtures/glsl/vertex_fragment_expected_full.glsl
+++ /dev/null
@@ -1,8 +0,0 @@
-/* WARNING, THIS FILE WAS GENERATED, DO NOT EDIT */
-#ifndef VERTEX_FRAGMENT_SHADER_GLSL_RAW_H
-#define VERTEX_FRAGMENT_SHADER_GLSL_RAW_H
-
-static const char vertex_fragment_shader_glsl[] = {
-    35,91,118,101,114,115,105,111,110,115,93,10,10,108,105,110,101,115,32,61,32,34,35,100,101,102,105,110,101,32,77,79,68,69,95,76,73,78,69,83,34,59,10,10,35,91,118,101,114,116,101,120,93,10,10,35,118,101,114,115,105,111,110,32,52,53,48,10,10,35,86,69,82,83,73,79,78,95,68,69,70,73,78,69,83,10,10,108,97,121,111,117,116,40,108,111,99,97,116,105,111,110,32,61,32,48,41,32,111,117,116,32,118,101,99,51,32,117,118,95,105,110,116,101,114,112,59,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,10,35,105,102,100,101,102,32,77,79,68,69,95,76,73,78,69,83,10,9,117,118,95,105,110,116,101,114,112,32,61,32,118,101,99,51,40,48,44,48,44,49,41,59,10,35,101,110,100,105,102,10,125,10,10,35,91,102,114,97,103,109,101,110,116,93,10,10,35,118,101,114,115,105,111,110,32,52,53,48,10,10,35,86,69,82,83,73,79,78,95,68,69,70,73,78,69,83,10,10,35,100,101,102,105,110,101,32,77,95,80,73,32,51,46,49,52,49,53,57,50,54,53,51,53,57,10,10,108,97,121,111,117,116,40,108,111,99,97,116,105,111,110,32,61,32,48,41,32,111,117,116,32,118,101,99,52,32,100,115,116,95,99,111,108,111,114,59,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,9,100,115,116,95,99,111,108,111,114,32,61,32,118,101,99,52,40,49,44,49,44,48,44,48,41,59,10,125,10,0
-};
-#endif
diff --git a/tests/python_build/fixtures/glsl/vertex_fragment_expected_parts.json b/tests/python_build/fixtures/glsl/vertex_fragment_expected_parts.json
deleted file mode 100644
index 38312367..00000000
--- a/tests/python_build/fixtures/glsl/vertex_fragment_expected_parts.json
+++ /dev/null
@@ -1,3 +0,0 @@
-{
-  "code": "#[versions]\n\nlines = \"#define MODE_LINES\";\n\n#[vertex]\n\n#version 450\n\n#VERSION_DEFINES\n\nlayout(location = 0) out vec3 uv_interp;\n\nvoid main() {\n\n#ifdef MODE_LINES\n\tuv_interp = vec3(0,0,1);\n#endif\n}\n\n#[fragment]\n\n#version 450\n\n#VERSION_DEFINES\n\n#define M_PI 3.14159265359\n\nlayout(location = 0) out vec4 dst_color;\n\nvoid main() {\n\tdst_color = vec4(1,1,0,0);\n}\n"
-}
diff --git a/tests/python_build/fixtures/rd_glsl/_included.glsl b/tests/python_build/fixtures/rd_glsl/_included.glsl
deleted file mode 100644
index adf5f702..00000000
--- a/tests/python_build/fixtures/rd_glsl/_included.glsl
+++ /dev/null
@@ -1 +0,0 @@
-#define M_PI 3.14159265359
diff --git a/tests/python_build/fixtures/rd_glsl/compute.glsl b/tests/python_build/fixtures/rd_glsl/compute.glsl
deleted file mode 100644
index 66fbbeb4..00000000
--- a/tests/python_build/fixtures/rd_glsl/compute.glsl
+++ /dev/null
@@ -1,13 +0,0 @@
-#[compute]
-
-#version 450
-
-#VERSION_DEFINES
-
-#define BLOCK_SIZE 8
-
-#include "_included.glsl"
-
-void main() {
-	uint t = BLOCK_SIZE + 1;
-}
diff --git a/tests/python_build/fixtures/rd_glsl/compute_expected_full.glsl b/tests/python_build/fixtures/rd_glsl/compute_expected_full.glsl
deleted file mode 100644
index b59923e2..00000000
--- a/tests/python_build/fixtures/rd_glsl/compute_expected_full.glsl
+++ /dev/null
@@ -1,20 +0,0 @@
-/* WARNING, THIS FILE WAS GENERATED, DO NOT EDIT */
-#ifndef COMPUTE_GLSL_GEN_H_RD
-#define COMPUTE_GLSL_GEN_H_RD
-
-#include "servers/rendering/renderer_rd/shader_rd.h"
-
-class ComputeShaderRD : public ShaderRD {
-
-public:
-
-	ComputeShaderRD() {
-
-		static const char _compute_code[] = {
-10,35,118,101,114,115,105,111,110,32,52,53,48,10,10,35,86,69,82,83,73,79,78,95,68,69,70,73,78,69,83,10,10,35,100,101,102,105,110,101,32,66,76,79,67,75,95,83,73,90,69,32,56,10,10,35,100,101,102,105,110,101,32,77,95,80,73,32,51,46,49,52,49,53,57,50,54,53,51,53,57,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,9,117,105,110,116,32,116,32,61,32,66,76,79,67,75,95,83,73,90,69,32,43,32,49,59,10,125,10,0
-		};
-		setup(nullptr, nullptr, _compute_code, "ComputeShaderRD");
-	}
-};
-
-#endif
diff --git a/tests/python_build/fixtures/rd_glsl/compute_expected_parts.json b/tests/python_build/fixtures/rd_glsl/compute_expected_parts.json
deleted file mode 100644
index 26ba9e4f..00000000
--- a/tests/python_build/fixtures/rd_glsl/compute_expected_parts.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
-  "vertex_lines": [],
-  "fragment_lines": [],
-  "compute_lines": [
-	"",
-	"#version 450",
-	"",
-	"#VERSION_DEFINES",
-	"",
-	"#define BLOCK_SIZE 8",
-	"",
-	"#define M_PI 3.14159265359",
-	"",
-	"void main() {",
-	"\tuint t = BLOCK_SIZE + 1;",
-	"}"
-  ],
-  "vertex_included_files": [],
-  "fragment_included_files": [],
-  "compute_included_files": [
-	"tests/python_build/fixtures/rd_glsl/_included.glsl"
-  ],
-  "reading": "compute",
-  "line_offset": 13,
-  "vertex_offset": 0,
-  "fragment_offset": 0,
-  "compute_offset": 1
-}
diff --git a/tests/python_build/fixtures/rd_glsl/vertex_fragment.glsl b/tests/python_build/fixtures/rd_glsl/vertex_fragment.glsl
deleted file mode 100644
index 27be08a8..00000000
--- a/tests/python_build/fixtures/rd_glsl/vertex_fragment.glsl
+++ /dev/null
@@ -1,25 +0,0 @@
-#[vertex]
-
-#version 450
-
-#VERSION_DEFINES
-
-#include "_included.glsl"
-
-layout(location = 0) out vec2 uv_interp;
-
-void main() {
-	uv_interp = vec2(0, 1);
-}
-
-#[fragment]
-
-#version 450
-
-#VERSION_DEFINES
-
-layout(location = 0) in vec2 uv_interp;
-
-void main() {
-	uv_interp = vec2(1, 0);
-}
diff --git a/tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_full.glsl b/tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_full.glsl
deleted file mode 100644
index ff804dbf..00000000
--- a/tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_full.glsl
+++ /dev/null
@@ -1,23 +0,0 @@
-/* WARNING, THIS FILE WAS GENERATED, DO NOT EDIT */
-#ifndef VERTEX_FRAGMENT_GLSL_GEN_H_RD
-#define VERTEX_FRAGMENT_GLSL_GEN_H_RD
-
-#include "servers/rendering/renderer_rd/shader_rd.h"
-
-class VertexFragmentShaderRD : public ShaderRD {
-
-public:
-
-	VertexFragmentShaderRD() {
-
-		static const char _vertex_code[] = {
-10,35,118,101,114,115,105,111,110,32,52,53,48,10,10,35,86,69,82,83,73,79,78,95,68,69,70,73,78,69,83,10,10,35,100,101,102,105,110,101,32,77,95,80,73,32,51,46,49,52,49,53,57,50,54,53,51,53,57,10,10,108,97,121,111,117,116,40,108,111,99,97,116,105,111,110,32,61,32,48,41,32,111,117,116,32,118,101,99,50,32,117,118,95,105,110,116,101,114,112,59,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,9,117,118,95,105,110,116,101,114,112,32,61,32,118,101,99,50,40,48,44,32,49,41,59,10,125,10,10,0
-		};
-		static const char _fragment_code[] = {
-10,35,118,101,114,115,105,111,110,32,52,53,48,10,10,35,86,69,82,83,73,79,78,95,68,69,70,73,78,69,83,10,10,108,97,121,111,117,116,40,108,111,99,97,116,105,111,110,32,61,32,48,41,32,105,110,32,118,101,99,50,32,117,118,95,105,110,116,101,114,112,59,10,10,118,111,105,100,32,109,97,105,110,40,41,32,123,10,9,117,118,95,105,110,116,101,114,112,32,61,32,118,101,99,50,40,49,44,32,48,41,59,10,125,10,0
-		};
-		setup(_vertex_code, _fragment_code, nullptr, "VertexFragmentShaderRD");
-	}
-};
-
-#endif
diff --git a/tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_parts.json b/tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_parts.json
deleted file mode 100644
index dbf833ed..00000000
--- a/tests/python_build/fixtures/rd_glsl/vertex_fragment_expected_parts.json
+++ /dev/null
@@ -1,40 +0,0 @@
-{
-  "vertex_lines": [
-	"",
-	"#version 450",
-	"",
-	"#VERSION_DEFINES",
-	"",
-	"#define M_PI 3.14159265359",
-	"",
-	"layout(location = 0) out vec2 uv_interp;",
-	"",
-	"void main() {",
-	"\tuv_interp = vec2(0, 1);",
-	"}",
-	""
-  ],
-  "fragment_lines": [
-	"",
-	"#version 450",
-	"",
-	"#VERSION_DEFINES",
-	"",
-	"layout(location = 0) in vec2 uv_interp;",
-	"",
-	"void main() {",
-	"\tuv_interp = vec2(1, 0);",
-	"}"
-  ],
-  "compute_lines": [],
-  "vertex_included_files": [
-	"tests/python_build/fixtures/rd_glsl/_included.glsl"
-  ],
-  "fragment_included_files": [],
-  "compute_included_files": [],
-  "reading": "fragment",
-  "line_offset": 25,
-  "vertex_offset": 1,
-  "fragment_offset": 15,
-  "compute_offset": 0
-}
diff --git a/tests/python_build/test_gles3_builder.py b/tests/python_build/test_gles3_builder.py
deleted file mode 100644
index 861e0b84..00000000
--- a/tests/python_build/test_gles3_builder.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import json
-
-import pytest
-
-from gles3_builders import build_gles3_header, GLES3HeaderStruct
-
-
-@pytest.mark.parametrize(
-    ["shader_files", "builder", "header_struct"],
-    [
-        ("gles3/vertex_fragment", build_gles3_header, GLES3HeaderStruct),
-    ],
-    indirect=["shader_files"],
-)
-def test_gles3_builder(shader_files, builder, header_struct):
-    header = header_struct()
-
-    builder(shader_files["path_input"], "drivers/gles3/shader_gles3.h", "GLES3", header_data=header)
-
-    with open(shader_files["path_expected_parts"], "r") as f:
-        expected_parts = json.load(f)
-        assert expected_parts == header.__dict__
-
-    with open(shader_files["path_output"], "r") as f:
-        actual_output = f.read()
-        assert actual_output
-
-    with open(shader_files["path_expected_full"], "r") as f:
-        expected_output = f.read()
-
-    assert actual_output == expected_output
diff --git a/tests/python_build/test_glsl_builder.py b/tests/python_build/test_glsl_builder.py
deleted file mode 100644
index b9dcef48..00000000
--- a/tests/python_build/test_glsl_builder.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import json
-
-import pytest
-
-from glsl_builders import build_raw_header, RAWHeaderStruct, build_rd_header, RDHeaderStruct
-
-
-@pytest.mark.parametrize(
-    [
-        "shader_files",
-        "builder",
-        "header_struct",
-    ],
-    [
-        ("glsl/vertex_fragment", build_raw_header, RAWHeaderStruct),
-        ("glsl/compute", build_raw_header, RAWHeaderStruct),
-        ("rd_glsl/vertex_fragment", build_rd_header, RDHeaderStruct),
-        ("rd_glsl/compute", build_rd_header, RDHeaderStruct),
-    ],
-    indirect=["shader_files"],
-)
-def test_glsl_builder(shader_files, builder, header_struct):
-    header = header_struct()
-    builder(shader_files["path_input"], header_data=header)
-
-    with open(shader_files["path_expected_parts"], "r") as f:
-        expected_parts = json.load(f)
-        assert expected_parts == header.__dict__
-
-    with open(shader_files["path_output"], "r") as f:
-        actual_output = f.read()
-        assert actual_output
-
-    with open(shader_files["path_expected_full"], "r") as f:
-        expected_output = f.read()
-
-    assert actual_output == expected_output

From f648c5ba6bd42bae87e164edd79401b8cd40e2d7 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Mon, 19 Jun 2023 15:35:17 -0700
Subject: [PATCH 45/71] Disabled a few builds.

---
 .../workflows/{android_builds.yml => android_builds.yml.disabled} | 0
 .github/workflows/{ios_builds.yml => ios_builds.yml.disabled}     | 0
 .github/workflows/{web_builds.yml => web_builds.yml.disabled}     | 0
 3 files changed, 0 insertions(+), 0 deletions(-)
 rename .github/workflows/{android_builds.yml => android_builds.yml.disabled} (100%)
 rename .github/workflows/{ios_builds.yml => ios_builds.yml.disabled} (100%)
 rename .github/workflows/{web_builds.yml => web_builds.yml.disabled} (100%)

diff --git a/.github/workflows/android_builds.yml b/.github/workflows/android_builds.yml.disabled
similarity index 100%
rename from .github/workflows/android_builds.yml
rename to .github/workflows/android_builds.yml.disabled
diff --git a/.github/workflows/ios_builds.yml b/.github/workflows/ios_builds.yml.disabled
similarity index 100%
rename from .github/workflows/ios_builds.yml
rename to .github/workflows/ios_builds.yml.disabled
diff --git a/.github/workflows/web_builds.yml b/.github/workflows/web_builds.yml.disabled
similarity index 100%
rename from .github/workflows/web_builds.yml
rename to .github/workflows/web_builds.yml.disabled

From 5b66370959c927833997112042018ad61b03dc2a Mon Sep 17 00:00:00 2001
From: jaune <jaunelacouleur@gmail.com>
Date: Sat, 19 Aug 2023 17:15:13 +0200
Subject: [PATCH 46/71] feat: add icons

---
 icons/JavaScript.svg         | 3 +++
 icons/JavaScriptInternal.svg | 3 +++
 icons/README.md              | 1 +
 3 files changed, 7 insertions(+)
 create mode 100644 icons/JavaScript.svg
 create mode 100644 icons/JavaScriptInternal.svg
 create mode 100644 icons/README.md

diff --git a/icons/JavaScript.svg b/icons/JavaScript.svg
new file mode 100644
index 00000000..14e0906e
--- /dev/null
+++ b/icons/JavaScript.svg
@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M0 0H16V16H0V0ZM11.924 7.26997C11.3491 7.31559 10.867 7.52244 10.508 7.87833C10.1384 8.24487 9.96202 8.69202 9.96202 9.25932C9.96202 10.108 10.3103 10.7011 11.0875 11.1711C11.2852 11.2897 11.5544 11.419 12.0198 11.6198C12.654 11.892 12.8898 12.0213 13.0403 12.1825C13.2259 12.3818 13.2776 12.6996 13.1605 12.943C13.1377 12.9901 13.0784 13.0692 13.0251 13.1224C12.8457 13.3034 12.5628 13.3992 12.2115 13.3992C11.6183 13.3992 11.1757 13.1559 10.8198 12.6297C10.7711 12.5597 10.727 12.5019 10.721 12.5019C10.7073 12.5019 9.54986 13.1696 9.52552 13.1924C9.51031 13.2061 9.52248 13.238 9.58179 13.3354C10.0442 14.1141 10.7666 14.5703 11.743 14.7011C11.9985 14.7361 12.4776 14.7346 12.7225 14.7011C13.3369 14.6145 13.7978 14.4107 14.1552 14.0639C14.5354 13.6973 14.7225 13.2228 14.7225 12.6281C14.7225 12.2479 14.6601 11.9513 14.5187 11.6578C14.4213 11.457 14.324 11.3217 14.1567 11.1513C13.8358 10.8259 13.4206 10.5795 12.5917 10.2236C11.9651 9.95438 11.7552 9.83879 11.6168 9.69126C11.4845 9.54982 11.4282 9.38404 11.4403 9.17719C11.451 9.01293 11.4966 8.90191 11.597 8.79392C11.7415 8.63727 11.9088 8.57187 12.1673 8.57339C12.4609 8.57339 12.651 8.64944 12.8442 8.84411C12.9126 8.91103 13.0008 9.01902 13.0419 9.08442C13.089 9.15894 13.124 9.20001 13.1362 9.19544C13.1757 9.17871 14.2814 8.46388 14.2814 8.45324C14.2814 8.44715 14.2251 8.35894 14.1567 8.25552C14.0107 8.03651 13.7476 7.76274 13.5666 7.64259C13.232 7.42054 12.8746 7.30647 12.4031 7.27149C12.1719 7.25324 12.1415 7.25324 11.924 7.26997ZM7.18484 12.7224L7.1894 10.0335L7.19548 7.34601H7.93921H8.68446V10.0426C8.68446 11.8312 8.67837 12.7818 8.66925 12.8669C8.5643 13.708 8.16735 14.2738 7.49054 14.5475C6.92628 14.7742 6.1567 14.7924 5.55746 14.5932C4.99016 14.4046 4.51868 13.9939 4.24643 13.451L4.20081 13.3597L4.80157 12.9947C5.1316 12.7954 5.40689 12.6297 5.41297 12.6266C5.41754 12.6251 5.45708 12.6844 5.50119 12.7574C5.77343 13.2228 6.00765 13.3886 6.39852 13.3871C6.67229 13.3856 6.83655 13.3323 6.9643 13.2046C7.05556 13.1133 7.10727 13.0145 7.15138 12.8487L7.18484 12.7224Z" fill="#E0E0E0"/>
+</svg>
diff --git a/icons/JavaScriptInternal.svg b/icons/JavaScriptInternal.svg
new file mode 100644
index 00000000..d1d0e67c
--- /dev/null
+++ b/icons/JavaScriptInternal.svg
@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M1 1H15V15H1V1ZM0 0H1H15H16V1V15V16H15H1H0V15V1V0ZM11.924 7.26997C11.3491 7.31559 10.867 7.52244 10.508 7.87833C10.1384 8.24487 9.96202 8.69202 9.96202 9.25932C9.96202 10.108 10.3103 10.7011 11.0875 11.1711C11.2852 11.2897 11.5544 11.419 12.0198 11.6198C12.654 11.892 12.8898 12.0213 13.0403 12.1825C13.2259 12.3818 13.2776 12.6996 13.1605 12.943C13.1377 12.9901 13.0784 13.0692 13.0251 13.1224C12.8457 13.3034 12.5628 13.3992 12.2115 13.3992C11.6183 13.3992 11.1757 13.1559 10.8198 12.6297C10.7711 12.5597 10.727 12.5019 10.721 12.5019C10.7073 12.5019 9.54986 13.1696 9.52552 13.1924C9.51031 13.2061 9.52248 13.238 9.58179 13.3354C10.0442 14.1141 10.7666 14.5703 11.743 14.7011C11.9985 14.7361 12.4776 14.7346 12.7225 14.7011C13.3369 14.6145 13.7978 14.4107 14.1552 14.0639C14.5354 13.6973 14.7225 13.2228 14.7225 12.6281C14.7225 12.2479 14.6601 11.9513 14.5187 11.6578C14.4213 11.457 14.324 11.3217 14.1567 11.1513C13.8358 10.8259 13.4206 10.5795 12.5917 10.2236C11.9651 9.95438 11.7552 9.83879 11.6168 9.69126C11.4845 9.54982 11.4282 9.38404 11.4403 9.17719C11.451 9.01293 11.4966 8.90191 11.597 8.79392C11.7415 8.63727 11.9088 8.57187 12.1673 8.57339C12.4609 8.57339 12.651 8.64944 12.8442 8.84411C12.9126 8.91103 13.0008 9.01902 13.0419 9.08442C13.089 9.15894 13.124 9.20001 13.1362 9.19544C13.1757 9.17871 14.2814 8.46388 14.2814 8.45324C14.2814 8.44715 14.2251 8.35894 14.1567 8.25552C14.0107 8.03651 13.7476 7.76274 13.5666 7.64259C13.232 7.42054 12.8746 7.30647 12.4031 7.27149C12.1719 7.25324 12.1415 7.25324 11.924 7.26997ZM7.1894 10.0335L7.18484 12.7224L7.15138 12.8487C7.10727 13.0145 7.05556 13.1133 6.9643 13.2046C6.83655 13.3323 6.67229 13.3856 6.39852 13.3871C6.00765 13.3886 5.77343 13.2228 5.50119 12.7574C5.45708 12.6844 5.41754 12.6251 5.41297 12.6266C5.40689 12.6297 5.1316 12.7954 4.80157 12.9947L4.20081 13.3597L4.24643 13.451C4.51868 13.9939 4.99016 14.4046 5.55746 14.5932C6.1567 14.7924 6.92628 14.7742 7.49054 14.5475C8.16735 14.2738 8.5643 13.708 8.66925 12.8669C8.67837 12.7818 8.68446 11.8312 8.68446 10.0426V7.34601H7.93921H7.19548L7.1894 10.0335Z" fill="#E0E0E0"/>
+</svg>
diff --git a/icons/README.md b/icons/README.md
new file mode 100644
index 00000000..58e7cac5
--- /dev/null
+++ b/icons/README.md
@@ -0,0 +1 @@
+icon source https://commons.wikimedia.org/wiki/File:Unofficial_JavaScript_logo.svg

From 2911768e99d03c41e7aaf23cb26469eae03f77a6 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Mon, 19 Jun 2023 15:35:17 -0700
Subject: [PATCH 47/71] Revert "Disabled a few builds."

This reverts commit f648c5ba6bd42bae87e164edd79401b8cd40e2d7.
---
 .../workflows/{android_builds.yml.disabled => android_builds.yml} | 0
 .github/workflows/{ios_builds.yml.disabled => ios_builds.yml}     | 0
 .github/workflows/{web_builds.yml.disabled => web_builds.yml}     | 0
 3 files changed, 0 insertions(+), 0 deletions(-)
 rename .github/workflows/{android_builds.yml.disabled => android_builds.yml} (100%)
 rename .github/workflows/{ios_builds.yml.disabled => ios_builds.yml} (100%)
 rename .github/workflows/{web_builds.yml.disabled => web_builds.yml} (100%)

diff --git a/.github/workflows/android_builds.yml.disabled b/.github/workflows/android_builds.yml
similarity index 100%
rename from .github/workflows/android_builds.yml.disabled
rename to .github/workflows/android_builds.yml
diff --git a/.github/workflows/ios_builds.yml.disabled b/.github/workflows/ios_builds.yml
similarity index 100%
rename from .github/workflows/ios_builds.yml.disabled
rename to .github/workflows/ios_builds.yml
diff --git a/.github/workflows/web_builds.yml.disabled b/.github/workflows/web_builds.yml
similarity index 100%
rename from .github/workflows/web_builds.yml.disabled
rename to .github/workflows/web_builds.yml

From d3ebf6864a4f37df447b027fa1b2b27a5237505d Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Sun, 20 Aug 2023 12:20:23 -0700
Subject: [PATCH 48/71] Update XML file paths for JavaScript and
 JavaScriptModule classes

---
 doc_classes/JavaScript.xml       | 2 +-
 doc_classes/JavaScriptModule.xml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc_classes/JavaScript.xml b/doc_classes/JavaScript.xml
index b7ef4413..b70cb7ad 100644
--- a/doc_classes/JavaScript.xml
+++ b/doc_classes/JavaScript.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<class name="JavaScript" inherits="Script" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
+<class name="JavaScript" inherits="Script" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
 	<brief_description>
 		A JavaScript script resource for creating and managing JavaScript scripts in Godot.
 	</brief_description>
diff --git a/doc_classes/JavaScriptModule.xml b/doc_classes/JavaScriptModule.xml
index 607cfaad..e8249976 100644
--- a/doc_classes/JavaScriptModule.xml
+++ b/doc_classes/JavaScriptModule.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<class name="JavaScriptModule" inherits="Resource" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
+<class name="JavaScriptModule" inherits="Resource" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
 	<brief_description>
 		A JavaScript module resource for managing JavaScript source code and bytecode.
 	</brief_description>

From 007e94a10865d29aa37aff44c7469f38d8a4e4a1 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Sun, 20 Aug 2023 13:11:06 -0700
Subject: [PATCH 49/71] Refactor JavaScript bindings and fix file paths

---
 SCsub                                         | 25 ++++++++++---------
 javascript_language.cpp                       |  2 +-
 register_types.cpp                            |  2 +-
 thirdparty/quickjs/quickjs/quickjs-debugger.c |  2 +-
 thirdparty/quickjs/quickjs_binder.cpp         |  5 ++--
 thirdparty/quickjs/quickjs_builtin_binder.cpp |  1 -
 thirdparty/quickjs/quickjs_callable.cpp       |  3 +--
 thirdparty/quickjs/quickjs_callable.h         |  5 +++-
 tools/editor_tools.h                          |  2 +-
 9 files changed, 24 insertions(+), 23 deletions(-)

diff --git a/SCsub b/SCsub
index 0b810ab3..acc56354 100644
--- a/SCsub
+++ b/SCsub
@@ -41,19 +41,20 @@ if JS_ENGINE == "quickjs":
 
     thirdparty.quickjs.builtin_binding_generator.generate_builtin_bindings()
     version = open("thirdparty/quickjs/quickjs/VERSION.txt", "r").read().split("\n")[0]
-    env_module.Append(CPPDEFINES={"QUICKJS_CONFIG_VERSION": '"' + version + '"'})
-    env_module.Append(CPPDEFINES=["CONFIG_BIGNUM"])
-    if "release" not in (env_module["target"] or ""):
-        env_module.Append(CPPDEFINES={"DUMP_LEAKS": 1})
-        env_module.Append(CPPDEFINES={"QUICKJS_WITH_DEBUGGER": 1})
-    env_module.Append(CPPPATH=["thirdparty/quickjs/quickjs"])
-    env_module.Append(CPPPATH=["thirdparty/quickjs"])
-
+    quickjs_env = env_modules.Clone()
+    quickjs_env.Append(CPPDEFINES={"QUICKJS_CONFIG_VERSION": '"' + version + '"'})
+    quickjs_env.Append(CPPDEFINES=["CONFIG_BIGNUM"])
+    if "release" not in (quickjs_env["target"] or ""):
+        quickjs_env.Append(CPPDEFINES={"DUMP_LEAKS": 1})
+        quickjs_env.Append(CPPDEFINES={"QUICKJS_WITH_DEBUGGER": 1})
+    quickjs_env.Append(CPPPATH=["thirdparty/quickjs/quickjs"])
+    quickjs_env.Append(CPPPATH=["thirdparty/quickjs"])
+    quickjs_env.disable_warnings()
     if TOOLS:
-        env_module.add_source_files(env.modules_sources, "tools/editor_tools.cpp")
-    env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp")
-    env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/*.cpp")
-    env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs/*.c")
+        quickjs_env.add_source_files(env.modules_sources, "tools/editor_tools.cpp")    
+    quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp")
+    quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/*.cpp")
+    quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs/*.c")
 
 
 # Binding script to run at engine initializing
diff --git a/javascript_language.cpp b/javascript_language.cpp
index ae69e781..382f7740 100644
--- a/javascript_language.cpp
+++ b/javascript_language.cpp
@@ -33,7 +33,7 @@
 #include "core/object/class_db.h"
 
 #include "javascript_binder.h"
-#include "quickjs_binder.h"
+#include "thirdparty/quickjs/quickjs_binder.h"
 
 JavaScriptLanguage *JavaScriptLanguage::singleton = nullptr;
 
diff --git a/register_types.cpp b/register_types.cpp
index 1ca45654..b055a364 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -52,7 +52,7 @@ class EditorExportJavaScript : public EditorExportPlugin {
 			return;
 		}
 	}
-	virtual String _get_name() const override { return "JavaScript"; }
+	virtual String get_name() const override { return "JavaScript"; }
 };
 
 #endif
diff --git a/thirdparty/quickjs/quickjs/quickjs-debugger.c b/thirdparty/quickjs/quickjs/quickjs-debugger.c
index f7557064..94246f47 100644
--- a/thirdparty/quickjs/quickjs/quickjs-debugger.c
+++ b/thirdparty/quickjs/quickjs/quickjs-debugger.c
@@ -144,7 +144,7 @@ static void js_debugger_get_variable_type(JSContext *ctx,
 
         JSObject *p = JS_VALUE_GET_OBJ(var_val);
         // todo: xor the the two dwords to get a better hash?
-        uint32_t pl = (uint32_t)p;
+        uintptr_t pl = (uintptr_t)p;
         JSValue found = JS_GetPropertyUint32(ctx, state->variable_pointers, pl);
         if (JS_IsUndefined(found)) {
             reference = state->variable_reference_count++;
diff --git a/thirdparty/quickjs/quickjs_binder.cpp b/thirdparty/quickjs/quickjs_binder.cpp
index 518b7632..c517228b 100644
--- a/thirdparty/quickjs/quickjs_binder.cpp
+++ b/thirdparty/quickjs/quickjs_binder.cpp
@@ -11,9 +11,8 @@
 #include "editor/editor_settings.h"
 #endif
 
-#include "javascript.h"
-#include "javascript_instance.h"
-#include "javascript_language.h"
+#include "../../javascript_instance.h"
+#include "../../javascript_language.h"
 #include "quickjs_binder.h"
 #include "quickjs_callable.h"
 #include "quickjs_worker.h"
diff --git a/thirdparty/quickjs/quickjs_builtin_binder.cpp b/thirdparty/quickjs/quickjs_builtin_binder.cpp
index 34aa19d8..d06e65e7 100644
--- a/thirdparty/quickjs/quickjs_builtin_binder.cpp
+++ b/thirdparty/quickjs/quickjs_builtin_binder.cpp
@@ -5,7 +5,6 @@
 
 #include <cstring>
 
-#include "javascript_binder.h"
 #include "quickjs_binder.h"
 #include "quickjs_builtin_binder.h"
 
diff --git a/thirdparty/quickjs/quickjs_callable.cpp b/thirdparty/quickjs/quickjs_callable.cpp
index 07336d54..99f7b825 100644
--- a/thirdparty/quickjs/quickjs_callable.cpp
+++ b/thirdparty/quickjs/quickjs_callable.cpp
@@ -1,9 +1,8 @@
 #include "quickjs_callable.h"
-#include "javascript_language.h"
 #include "quickjs/quickjs.h"
-
 #include "quickjs_binder.h"
 #include "quickjs_builtin_binder.h"
+#include "../../javascript_language.h"
 
 bool QuickJSCallable::compare_equal(const CallableCustom *p_a, const CallableCustom *p_b) {
 	const QuickJSCallable *a = static_cast<const QuickJSCallable *>(p_a);
diff --git a/thirdparty/quickjs/quickjs_callable.h b/thirdparty/quickjs/quickjs_callable.h
index 48050cd2..7b2b2d55 100644
--- a/thirdparty/quickjs/quickjs_callable.h
+++ b/thirdparty/quickjs/quickjs_callable.h
@@ -1,6 +1,9 @@
 #ifndef QUICKJS_CALLABLE_H
 #define QUICKJS_CALLABLE_H
-#include "javascript_callable.h"
+
+#include "core/variant/callable.h"
+#include "../../javascript_callable.h"
+
 #include "quickjs/quickjs.h"
 
 #if !defined(JS_NAN_BOXING)
diff --git a/tools/editor_tools.h b/tools/editor_tools.h
index d6ca4443..de095523 100644
--- a/tools/editor_tools.h
+++ b/tools/editor_tools.h
@@ -31,7 +31,7 @@
 #ifndef EDITOR_TOOLS_H
 #define EDITOR_TOOLS_H
 
-#include "editor/editor_file_dialog.h"
+#include "editor/gui/editor_file_dialog.h"
 #include "editor/editor_node.h"
 #include "editor/editor_plugin.h"
 

From dfbdf573089ff2913523be3c3d7d397eb1f3b1a1 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Sun, 20 Aug 2023 13:36:22 -0700
Subject: [PATCH 50/71] Format SCsub.

---
 SCsub | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/SCsub b/SCsub
index acc56354..83daf0f6 100644
--- a/SCsub
+++ b/SCsub
@@ -36,7 +36,9 @@ def dump_text_file_to_cpp(file):
 if JS_ENGINE == "quickjs":
     import generate_builtin_api
 
-    generate_builtin_api.generate_api_json(os.path.join(GetLaunchDir(), "modules", os.path.basename(os.getcwd())))
+    generate_builtin_api.generate_api_json(
+        os.path.join(GetLaunchDir(), "modules", os.path.basename(os.getcwd()))
+    )
     import thirdparty.quickjs.builtin_binding_generator
 
     thirdparty.quickjs.builtin_binding_generator.generate_builtin_bindings()
@@ -51,8 +53,10 @@ if JS_ENGINE == "quickjs":
     quickjs_env.Append(CPPPATH=["thirdparty/quickjs"])
     quickjs_env.disable_warnings()
     if TOOLS:
-        quickjs_env.add_source_files(env.modules_sources, "tools/editor_tools.cpp")    
-    quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp")
+        quickjs_env.add_source_files(env.modules_sources, "tools/editor_tools.cpp")
+    quickjs_env.add_source_files(
+        env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp"
+    )
     quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/*.cpp")
     quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs/*.c")
 
@@ -71,9 +75,7 @@ sources = [
 ]
 
 if TOOLS:
-    base_text = (
-        '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
-    )
+    base_text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
     tool_fns = {
         "tools/godot.d.ts.gen.cpp": (
             "BUILTIN_DECLARATION_TEXT",

From 0fe880e87a0ce376356fc8dfaf23c3add533595c Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Sun, 20 Aug 2023 13:38:27 -0700
Subject: [PATCH 51/71] Update the readme.

---
 README.md | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/README.md b/README.md
index 0261ca5d..a57f7b4d 100644
--- a/README.md
+++ b/README.md
@@ -282,10 +282,6 @@ You can try demos in the [ECMAScriptDemos](https://github.com/Geequlim/ECMAScrip
 ## Developer notes
 
 - This package is not compatible with MSVC, you will get build errors in quickjs.
-- To update the github actions scripts we have the file `build_github_actions.py`. This script will copy the actions from the godot repo (usually at `../../`) and modify them to fix the requirements of quickjs and this repo.
-  \*\* If you are updating this repo's compatibility, you should run that script (a brief description is at the top of the script) and it will re-create the actions `.yml` files for you.
 - The script also build the `on_tag.yml` script which automates the github release publishing.
   \*\* The `on_tag.yml` functionality tries to sleep until all jobs with the same `sha` are completed. It should be fine to run whenever, but depending on how github actions culls long running jobs you might want to make sure that all/(most of) the builds look good before tagging.
-- Linux ubsan asan build woes:
-- The godot repo has ubsan and asan builds that we can't build from. Currently we skip them (get removed via the `build_github_actions.py` script).
 - They should definitely be fixed & enabled at some point, **so please submit a PR if you have any ideas of how to do that!**

From 1bb9edff3b4caffb5e5163cf9625e807cd9f21b3 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Sun, 20 Aug 2023 13:56:18 -0700
Subject: [PATCH 52/71] Format black_format.sh and SCsub scripts

---
 SCsub                        | 12 +++++-------
 misc/scripts/black_format.sh |  0
 2 files changed, 5 insertions(+), 7 deletions(-)
 mode change 100644 => 100755 misc/scripts/black_format.sh

diff --git a/SCsub b/SCsub
index 83daf0f6..347ab56a 100644
--- a/SCsub
+++ b/SCsub
@@ -36,9 +36,7 @@ def dump_text_file_to_cpp(file):
 if JS_ENGINE == "quickjs":
     import generate_builtin_api
 
-    generate_builtin_api.generate_api_json(
-        os.path.join(GetLaunchDir(), "modules", os.path.basename(os.getcwd()))
-    )
+    generate_builtin_api.generate_api_json(os.path.join(GetLaunchDir(), "modules", os.path.basename(os.getcwd())))
     import thirdparty.quickjs.builtin_binding_generator
 
     thirdparty.quickjs.builtin_binding_generator.generate_builtin_bindings()
@@ -54,9 +52,7 @@ if JS_ENGINE == "quickjs":
     quickjs_env.disable_warnings()
     if TOOLS:
         quickjs_env.add_source_files(env.modules_sources, "tools/editor_tools.cpp")
-    quickjs_env.add_source_files(
-        env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp"
-    )
+    quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp")
     quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/*.cpp")
     quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs/*.c")
 
@@ -75,7 +71,9 @@ sources = [
 ]
 
 if TOOLS:
-    base_text = '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
+    base_text = (
+        '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
+    )
     tool_fns = {
         "tools/godot.d.ts.gen.cpp": (
             "BUILTIN_DECLARATION_TEXT",
diff --git a/misc/scripts/black_format.sh b/misc/scripts/black_format.sh
old mode 100644
new mode 100755

From 0b9283be497f9002263cf8e16af213efce6d5de1 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Sun, 20 Aug 2023 13:57:36 -0700
Subject: [PATCH 53/71] Add XML schema for class documentation

---
 doc/class.xsd | 278 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 278 insertions(+)
 create mode 100644 doc/class.xsd

diff --git a/doc/class.xsd b/doc/class.xsd
new file mode 100644
index 00000000..22821ac7
--- /dev/null
+++ b/doc/class.xsd
@@ -0,0 +1,278 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" xmlns:xs="http://www.w3.org/2001/XMLSchema">
+	<xs:element name="class">
+		<xs:complexType>
+			<xs:sequence>
+				<xs:element type="xs:string" name="brief_description" />
+				<xs:element type="xs:string" name="description" />
+				<xs:element name="tutorials">
+					<xs:complexType>
+						<xs:sequence>
+							<xs:element name="link" maxOccurs="unbounded" minOccurs="0">
+								<xs:complexType>
+									<xs:simpleContent>
+										<xs:extension base="xs:string">
+											<xs:attribute type="xs:string" name="title" use="optional" />
+										</xs:extension>
+									</xs:simpleContent>
+								</xs:complexType>
+							</xs:element>
+						</xs:sequence>
+					</xs:complexType>
+				</xs:element>
+				<xs:element name="constructors" minOccurs="0">
+					<xs:complexType>
+						<xs:sequence>
+							<xs:element name="constructor" maxOccurs="unbounded" minOccurs="0">
+								<xs:complexType>
+									<xs:sequence>
+										<xs:element name="return" minOccurs="0">
+											<xs:complexType>
+												<xs:sequence>
+													<xs:sequence />
+												</xs:sequence>
+												<xs:attribute type="xs:string" name="type" />
+												<xs:attribute type="xs:string" name="enum" use="optional" />
+												<xs:attribute type="xs:boolean" name="is_bitfield" use="optional" />
+											</xs:complexType>
+										</xs:element>
+										<xs:element name="param" maxOccurs="unbounded" minOccurs="0">
+											<xs:complexType>
+												<xs:sequence>
+													<xs:sequence />
+												</xs:sequence>
+												<xs:attribute type="xs:byte" name="index" />
+												<xs:attribute type="xs:string" name="name" />
+												<xs:attribute type="xs:string" name="type" />
+												<xs:attribute type="xs:string" name="enum" use="optional" />
+												<xs:attribute type="xs:boolean" name="is_bitfield" use="optional" />
+												<xs:attribute type="xs:string" name="default" use="optional" />
+											</xs:complexType>
+										</xs:element>
+										<xs:element type="xs:string" name="description" />
+									</xs:sequence>
+									<xs:attribute type="xs:string" name="name" use="optional" />
+									<xs:attribute type="xs:string" name="qualifiers" use="optional" />
+								</xs:complexType>
+							</xs:element>
+						</xs:sequence>
+					</xs:complexType>
+				</xs:element>
+				<xs:element name="methods" minOccurs="0">
+					<xs:complexType>
+						<xs:sequence>
+							<xs:element name="method" maxOccurs="unbounded" minOccurs="0">
+								<xs:complexType>
+									<xs:sequence>
+										<xs:element name="return" minOccurs="0">
+											<xs:complexType>
+												<xs:sequence>
+													<xs:sequence />
+												</xs:sequence>
+												<xs:attribute type="xs:string" name="type" />
+												<xs:attribute type="xs:string" name="enum" use="optional" />
+												<xs:attribute type="xs:boolean" name="is_bitfield" use="optional" />
+											</xs:complexType>
+										</xs:element>
+										<xs:element name="returns_error" maxOccurs="unbounded" minOccurs="0">
+											<xs:complexType>
+												<xs:sequence>
+													<xs:sequence />
+												</xs:sequence>
+												<xs:attribute type="xs:byte" name="number" />
+											</xs:complexType>
+										</xs:element>
+										<xs:element name="param" maxOccurs="unbounded" minOccurs="0">
+											<xs:complexType>
+												<xs:sequence>
+													<xs:sequence />
+												</xs:sequence>
+												<xs:attribute type="xs:byte" name="index" />
+												<xs:attribute type="xs:string" name="name" />
+												<xs:attribute type="xs:string" name="type" />
+												<xs:attribute type="xs:string" name="enum" use="optional" />
+												<xs:attribute type="xs:boolean" name="is_bitfield" use="optional" />
+												<xs:attribute type="xs:string" name="default" use="optional" />
+											</xs:complexType>
+										</xs:element>
+										<xs:element type="xs:string" name="description" />
+									</xs:sequence>
+									<xs:attribute type="xs:string" name="name" use="optional" />
+									<xs:attribute type="xs:string" name="qualifiers" use="optional" />
+									<xs:attribute type="xs:boolean" name="is_deprecated" use="optional" />
+									<xs:attribute type="xs:boolean" name="is_experimental" use="optional" />
+								</xs:complexType>
+							</xs:element>
+						</xs:sequence>
+					</xs:complexType>
+				</xs:element>
+				<xs:element name="members" minOccurs="0">
+					<xs:complexType>
+						<xs:choice maxOccurs="unbounded" minOccurs="0">
+							<xs:element name="member">
+								<xs:complexType>
+									<xs:simpleContent>
+										<xs:extension base="xs:string">
+											<xs:attribute type="xs:string" name="name" />
+											<xs:attribute type="xs:string" name="type" />
+											<xs:attribute type="xs:string" name="setter" />
+											<xs:attribute type="xs:string" name="getter" />
+											<xs:attribute type="xs:string" name="overrides" use="optional" />
+											<xs:attribute type="xs:string" name="enum" use="optional" />
+											<xs:attribute type="xs:boolean" name="is_bitfield" use="optional" />
+											<xs:attribute type="xs:string" name="default" use="optional" />
+											<xs:attribute type="xs:boolean" name="is_deprecated" use="optional" />
+											<xs:attribute type="xs:boolean" name="is_experimental" use="optional" />
+										</xs:extension>
+									</xs:simpleContent>
+								</xs:complexType>
+							</xs:element>
+						</xs:choice>
+					</xs:complexType>
+				</xs:element>
+				<xs:element name="signals" minOccurs="0">
+					<xs:complexType>
+						<xs:sequence>
+							<xs:element name="signal" maxOccurs="unbounded" minOccurs="0">
+								<xs:complexType>
+									<xs:sequence>
+										<xs:element name="param" maxOccurs="unbounded" minOccurs="0">
+											<xs:complexType>
+												<xs:sequence>
+													<xs:sequence />
+												</xs:sequence>
+												<xs:attribute type="xs:byte" name="index" />
+												<xs:attribute type="xs:string" name="name" />
+												<xs:attribute type="xs:string" name="type" />
+											</xs:complexType>
+										</xs:element>
+										<xs:element type="xs:string" name="description" />
+									</xs:sequence>
+									<xs:attribute type="xs:string" name="name" use="optional" />
+								</xs:complexType>
+							</xs:element>
+						</xs:sequence>
+					</xs:complexType>
+				</xs:element>
+				<xs:element name="constants" minOccurs="0">
+					<xs:complexType>
+						<xs:sequence>
+							<xs:element name="constant" maxOccurs="unbounded" minOccurs="0">
+								<xs:complexType>
+									<xs:simpleContent>
+										<xs:extension base="xs:string">
+											<xs:attribute type="xs:string" name="name" />
+											<xs:attribute type="xs:string" name="value" />
+											<xs:attribute type="xs:string" name="enum" use="optional" />
+											<xs:attribute type="xs:boolean" name="is_bitfield" use="optional" />
+											<xs:attribute type="xs:boolean" name="is_deprecated" use="optional" />
+											<xs:attribute type="xs:boolean" name="is_experimental" use="optional" />
+										</xs:extension>
+									</xs:simpleContent>
+								</xs:complexType>
+							</xs:element>
+						</xs:sequence>
+					</xs:complexType>
+				</xs:element>
+				<xs:element name="annotations" minOccurs="0">
+					<xs:complexType>
+						<xs:sequence>
+							<xs:element name="annotation" maxOccurs="unbounded" minOccurs="0">
+								<xs:complexType>
+									<xs:sequence>
+										<xs:element name="return" minOccurs="0">
+											<xs:complexType>
+												<xs:sequence>
+													<xs:sequence />
+												</xs:sequence>
+												<xs:attribute type="xs:string" name="type" />
+												<xs:attribute type="xs:string" name="enum" use="optional" />
+												<xs:attribute type="xs:boolean" name="is_bitfield" use="optional" />
+											</xs:complexType>
+										</xs:element>
+										<xs:element name="param" maxOccurs="unbounded" minOccurs="0">
+											<xs:complexType>
+												<xs:sequence>
+													<xs:sequence />
+												</xs:sequence>
+												<xs:attribute type="xs:byte" name="index" />
+												<xs:attribute type="xs:string" name="name" />
+												<xs:attribute type="xs:string" name="type" />
+												<xs:attribute type="xs:string" name="enum" use="optional" />
+												<xs:attribute type="xs:boolean" name="is_bitfield" use="optional" />
+												<xs:attribute type="xs:string" name="default" use="optional" />
+											</xs:complexType>
+										</xs:element>
+										<xs:element type="xs:string" name="description" />
+									</xs:sequence>
+									<xs:attribute type="xs:string" name="name" use="optional" />
+									<xs:attribute type="xs:string" name="qualifiers" use="optional" />
+								</xs:complexType>
+							</xs:element>
+						</xs:sequence>
+					</xs:complexType>
+				</xs:element>
+				<xs:element name="theme_items" minOccurs="0">
+					<xs:complexType>
+						<xs:sequence>
+							<xs:element name="theme_item" maxOccurs="unbounded" minOccurs="0">
+								<xs:complexType>
+									<xs:simpleContent>
+										<xs:extension base="xs:string">
+											<xs:attribute type="xs:string" name="name" />
+											<xs:attribute type="xs:string" name="data_type" />
+											<xs:attribute type="xs:string" name="type" />
+											<xs:attribute type="xs:string" name="default" use="optional" />
+										</xs:extension>
+									</xs:simpleContent>
+								</xs:complexType>
+							</xs:element>
+						</xs:sequence>
+					</xs:complexType>
+				</xs:element>
+				<xs:element name="operators" minOccurs="0">
+					<xs:complexType>
+						<xs:sequence>
+							<xs:element name="operator" maxOccurs="unbounded" minOccurs="0">
+								<xs:complexType>
+									<xs:sequence>
+										<xs:element name="return" minOccurs="0">
+											<xs:complexType>
+												<xs:sequence>
+													<xs:sequence />
+												</xs:sequence>
+												<xs:attribute type="xs:string" name="type" />
+												<xs:attribute type="xs:string" name="enum" use="optional" />
+												<xs:attribute type="xs:boolean" name="is_bitfield" use="optional" />
+											</xs:complexType>
+										</xs:element>
+										<xs:element name="param" maxOccurs="unbounded" minOccurs="0">
+											<xs:complexType>
+												<xs:sequence>
+													<xs:sequence />
+												</xs:sequence>
+												<xs:attribute type="xs:byte" name="index" />
+												<xs:attribute type="xs:string" name="name" />
+												<xs:attribute type="xs:string" name="type" />
+												<xs:attribute type="xs:string" name="enum" use="optional" />
+												<xs:attribute type="xs:boolean" name="is_bitfield" use="optional" />
+												<xs:attribute type="xs:string" name="default" use="optional" />
+											</xs:complexType>
+										</xs:element>
+										<xs:element type="xs:string" name="description" />
+									</xs:sequence>
+									<xs:attribute type="xs:string" name="name" use="optional" />
+									<xs:attribute type="xs:string" name="qualifiers" use="optional" />
+								</xs:complexType>
+							</xs:element>
+						</xs:sequence>
+					</xs:complexType>
+				</xs:element>
+			</xs:sequence>
+			<xs:attribute type="xs:string" name="name" />
+			<xs:attribute type="xs:string" name="inherits" />
+			<xs:attribute type="xs:boolean" name="is_deprecated" use="optional" />
+			<xs:attribute type="xs:boolean" name="is_experimental" use="optional" />
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

From 5fd3ce9723f0fee8a3ec7fa9952f5259484214d8 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Sun, 20 Aug 2023 15:08:59 -0700
Subject: [PATCH 54/71] Refactor static checks workflow

Remove xsd check.
---
 .github/workflows/static_checks.yml | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/.github/workflows/static_checks.yml b/.github/workflows/static_checks.yml
index de5c17fc..a22f7565 100644
--- a/.github/workflows/static_checks.yml
+++ b/.github/workflows/static_checks.yml
@@ -76,10 +76,6 @@ jobs:
             echo "Skipping JavaScript formatting as no Web/JS files were changed."
           fi
 
-      - name: Class reference schema checks
-        run: |
-          xmllint --noout --schema doc/class.xsd doc/classes/*.xml modules/*/doc_classes/*.xml
-
       - name: Documentation checks
         run: |
           doc/tools/make_rst.py --dry-run --color doc/classes modules

From d5a9cf72a296c04c5637f0ff7c40165686a35280 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Sun, 20 Aug 2023 15:12:57 -0700
Subject: [PATCH 55/71] Refactor static checks workflow

---
 .github/workflows/static_checks.yml | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/.github/workflows/static_checks.yml b/.github/workflows/static_checks.yml
index a22f7565..f5981e8a 100644
--- a/.github/workflows/static_checks.yml
+++ b/.github/workflows/static_checks.yml
@@ -76,10 +76,6 @@ jobs:
             echo "Skipping JavaScript formatting as no Web/JS files were changed."
           fi
 
-      - name: Documentation checks
-        run: |
-          doc/tools/make_rst.py --dry-run --color doc/classes modules
-
       - name: Style checks via clang-format (clang_format.sh)
         run: |
           clang-format --version

From 6177b3eb722a0912b341c2c4c4dd647c650b4ee8 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 06:48:45 -0700
Subject: [PATCH 56/71] Add .clang-format and .clang-tidy configuration files

---
 .clang-format | 199 ++++++++++++++++++++++++++++++++++++++++++++++++++
 .clang-tidy   |  47 ++++++++++++
 2 files changed, 246 insertions(+)
 create mode 100644 .clang-format
 create mode 100644 .clang-tidy

diff --git a/.clang-format b/.clang-format
new file mode 100644
index 00000000..1df6c35b
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,199 @@
+# Commented out parameters are those with the same value as base LLVM style.
+# We can uncomment them if we want to change their value, or enforce the
+# chosen value in case the base style changes (last sync: Clang 14.0).
+---
+### General config, applies to all languages ###
+BasedOnStyle:  LLVM
+AccessModifierOffset: -4
+AlignAfterOpenBracket: DontAlign
+# AlignArrayOfStructures: None
+# AlignConsecutiveMacros: None
+# AlignConsecutiveAssignments: None
+# AlignConsecutiveBitFields: None
+# AlignConsecutiveDeclarations: None
+# AlignEscapedNewlines: Right
+AlignOperands:   DontAlign
+AlignTrailingComments: false
+# AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: false
+# AllowShortEnumsOnASingleLine: true
+# AllowShortBlocksOnASingleLine: Never
+# AllowShortCaseLabelsOnASingleLine: false
+# AllowShortFunctionsOnASingleLine: All
+# AllowShortLambdasOnASingleLine: All
+# AllowShortIfStatementsOnASingleLine: Never
+# AllowShortLoopsOnASingleLine: false
+# AlwaysBreakAfterDefinitionReturnType: None
+# AlwaysBreakAfterReturnType: None
+# AlwaysBreakBeforeMultilineStrings: false
+# AlwaysBreakTemplateDeclarations: MultiLine
+# AttributeMacros:
+#   - __capability
+# BinPackArguments: true
+# BinPackParameters: true
+# BraceWrapping:
+#   AfterCaseLabel:  false
+#   AfterClass:      false
+#   AfterControlStatement: Never
+#   AfterEnum:       false
+#   AfterFunction:   false
+#   AfterNamespace:  false
+#   AfterObjCDeclaration: false
+#   AfterStruct:     false
+#   AfterUnion:      false
+#   AfterExternBlock: false
+#   BeforeCatch:     false
+#   BeforeElse:      false
+#   BeforeLambdaBody: false
+#   BeforeWhile:     false
+#   IndentBraces:    false
+#   SplitEmptyFunction: true
+#   SplitEmptyRecord: true
+#   SplitEmptyNamespace: true
+# BreakBeforeBinaryOperators: None
+# BreakBeforeConceptDeclarations: true
+# BreakBeforeBraces: Attach
+# BreakBeforeInheritanceComma: false
+# BreakInheritanceList: BeforeColon
+# BreakBeforeTernaryOperators: true
+# BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: AfterColon
+# BreakStringLiterals: true
+ColumnLimit:     0
+# CommentPragmas:  '^ IWYU pragma:'
+# QualifierAlignment: Leave
+# CompactNamespaces: false
+ConstructorInitializerIndentWidth: 8
+ContinuationIndentWidth: 8
+Cpp11BracedListStyle: false
+# DeriveLineEnding: true
+# DerivePointerAlignment: false
+# DisableFormat:   false
+# EmptyLineAfterAccessModifier: Never
+# EmptyLineBeforeAccessModifier: LogicalBlock
+# ExperimentalAutoDetectBinPacking: false
+# PackConstructorInitializers: BinPack
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+# AllowAllConstructorInitializersOnNextLine: true
+# FixNamespaceComments: true
+# ForEachMacros:
+#   - foreach
+#   - Q_FOREACH
+#   - BOOST_FOREACH
+# IfMacros:
+#   - KJ_IF_MAYBE
+# IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '".*"'
+    Priority:        1
+  - Regex:           '^<.*\.h>'
+    Priority:        2
+  - Regex:           '^<.*'
+    Priority:        3
+# IncludeIsMainRegex: '(Test)?$'
+# IncludeIsMainSourceRegex: ''
+# IndentAccessModifiers: false
+IndentCaseLabels: true
+# IndentCaseBlocks: false
+# IndentGotoLabels: true
+# IndentPPDirectives: None
+# IndentExternBlock: AfterExternBlock
+# IndentRequires:  false
+IndentWidth:     4
+# IndentWrappedFunctionNames: false
+# InsertTrailingCommas: None
+# JavaScriptQuotes: Leave
+# JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: false
+# LambdaBodyIndentation: Signature
+# MacroBlockBegin: ''
+# MacroBlockEnd:   ''
+# MaxEmptyLinesToKeep: 1
+# NamespaceIndentation: None
+# PenaltyBreakAssignment: 2
+# PenaltyBreakBeforeFirstCallParameter: 19
+# PenaltyBreakComment: 300
+# PenaltyBreakFirstLessLess: 120
+# PenaltyBreakOpenParenthesis: 0
+# PenaltyBreakString: 1000
+# PenaltyBreakTemplateDeclaration: 10
+# PenaltyExcessCharacter: 1000000
+# PenaltyReturnTypeOnItsOwnLine: 60
+# PenaltyIndentedWhitespace: 0
+# PointerAlignment: Right
+# PPIndentWidth:   -1
+# ReferenceAlignment: Pointer
+# ReflowComments:  true
+# RemoveBracesLLVM: false
+# SeparateDefinitionBlocks: Leave
+# ShortNamespaceLines: 1
+# SortIncludes:    CaseSensitive
+# SortJavaStaticImport: Before
+# SortUsingDeclarations: true
+# SpaceAfterCStyleCast: false
+# SpaceAfterLogicalNot: false
+# SpaceAfterTemplateKeyword: true
+# SpaceBeforeAssignmentOperators: true
+# SpaceBeforeCaseColon: false
+# SpaceBeforeCpp11BracedList: false
+# SpaceBeforeCtorInitializerColon: true
+# SpaceBeforeInheritanceColon: true
+# SpaceBeforeParens: ControlStatements
+# SpaceBeforeParensOptions:
+#   AfterControlStatements: true
+#   AfterForeachMacros: true
+#   AfterFunctionDefinitionName: false
+#   AfterFunctionDeclarationName: false
+#   AfterIfMacros:   true
+#   AfterOverloadedOperator: false
+#   BeforeNonEmptyParentheses: false
+# SpaceAroundPointerQualifiers: Default
+# SpaceBeforeRangeBasedForLoopColon: true
+# SpaceInEmptyBlock: false
+# SpaceInEmptyParentheses: false
+# SpacesBeforeTrailingComments: 1
+# SpacesInAngles:  Never
+# SpacesInConditionalStatement: false
+# SpacesInContainerLiterals: true
+# SpacesInCStyleCastParentheses: false
+## Godot TODO: We'll want to use a min of 1, but we need to see how to fix
+## our comment capitalization at the same time.
+SpacesInLineCommentPrefix:
+  Minimum:         0
+  Maximum:         -1
+# SpacesInParentheses: false
+# SpacesInSquareBrackets: false
+# SpaceBeforeSquareBrackets: false
+# BitFieldColonSpacing: Both
+# StatementAttributeLikeMacros:
+#   - Q_EMIT
+# StatementMacros:
+#   - Q_UNUSED
+#   - QT_REQUIRE_VERSION
+TabWidth:        4
+# UseCRLF:         false
+UseTab:          Always
+# WhitespaceSensitiveMacros:
+#   - STRINGIZE
+#   - PP_STRINGIZE
+#   - BOOST_PP_STRINGIZE
+#   - NS_SWIFT_NAME
+#   - CF_SWIFT_NAME
+---
+### C++ specific config ###
+Language:        Cpp
+Standard:        c++17
+---
+### ObjC specific config ###
+Language:        ObjC
+# ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 4
+# ObjCBreakBeforeNestedBlockParam: true
+# ObjCSpaceAfterProperty: false
+# ObjCSpaceBeforeProtocolList: true
+---
+### Java specific config ###
+Language:        Java
+# BreakAfterJavaFieldAnnotations: false
+JavaImportGroups: ['org.godotengine', 'android', 'androidx', 'com.android', 'com.google', 'java', 'javax']
+...
diff --git a/.clang-tidy b/.clang-tidy
new file mode 100644
index 00000000..659b9101
--- /dev/null
+++ b/.clang-tidy
@@ -0,0 +1,47 @@
+---
+Checks: 'clang-diagnostic-*,clang-analyzer-*,-*,cppcoreguidelines-pro-type-member-init,modernize-redundant-void-arg,modernize-use-bool-literals,modernize-use-default-member-init,modernize-use-nullptr,readability-braces-around-statements,readability-redundant-member-init'
+WarningsAsErrors: ''
+HeaderFilterRegex: ''
+AnalyzeTemporaryDtors: false
+FormatStyle: none
+CheckOptions:
+  - key:             cert-dcl16-c.NewSuffixes
+    value:           'L;LL;LU;LLU'
+  - key:             cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField
+    value:           '0'
+  - key:             cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors
+    value:           '1'
+  - key:             cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic
+    value:           '1'
+  - key:             cppcoreguidelines-pro-type-member-init.IgnoreArrays
+    value:           '1'
+  - key:             cppcoreguidelines-pro-type-member-init.UseAssignment
+    value:           '1'
+  - key:             google-readability-function-size.StatementThreshold
+    value:           '800'
+  - key:             google-readability-namespace-comments.ShortNamespaceLines
+    value:           '10'
+  - key:             google-readability-namespace-comments.SpacesBeforeComments
+    value:           '2'
+  - key:             modernize-loop-convert.MaxCopySize
+    value:           '16'
+  - key:             modernize-loop-convert.MinConfidence
+    value:           reasonable
+  - key:             modernize-loop-convert.NamingStyle
+    value:           CamelCase
+  - key:             modernize-pass-by-value.IncludeStyle
+    value:           llvm
+  - key:             modernize-replace-auto-ptr.IncludeStyle
+    value:           llvm
+  - key:             modernize-use-bool-literals.IgnoreMacros
+    value:           '0'
+  - key:             modernize-use-default-member-init.IgnoreMacros
+    value:           '0'
+  - key:             modernize-use-default-member-init.UseAssignment
+    value:           '1'
+  - key:             modernize-use-nullptr.NullMacros
+    value:           'NULL'
+  - key:             readability-braces-around-statements.ShortStatementLines
+    value:           '0'
+...
+

From 94d95b5e70e93fc39c583473395df41501450636 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 06:57:08 -0700
Subject: [PATCH 57/71] Apply formatting.

---
 quickjs/quickjs_callable.cpp | 35 +++++++++++++++++++++++++++++++++--
 quickjs/quickjs_callable.h   | 30 ++++++++++++++++++++++++++++++
 tools/editor_tools.h         |  2 +-
 3 files changed, 64 insertions(+), 3 deletions(-)

diff --git a/quickjs/quickjs_callable.cpp b/quickjs/quickjs_callable.cpp
index 7f8cef8e..037fd5b2 100644
--- a/quickjs/quickjs_callable.cpp
+++ b/quickjs/quickjs_callable.cpp
@@ -1,7 +1,37 @@
+/**************************************************************************/
+/*  quickjs_callable.cpp                                                  */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
 #include "quickjs_callable.h"
+#include "../../quickjs_binder.h"
 #include "../javascript_language.h"
 #include "quickjs/quickjs.h"
-#include "../../quickjs_binder.h"
 
 bool QuickJSCallable::compare_equal(const CallableCustom *p_a, const CallableCustom *p_b) {
 	const QuickJSCallable *a = static_cast<const QuickJSCallable *>(p_a);
@@ -23,7 +53,8 @@ QuickJSCallable::QuickJSCallable(JSContext *ctx, const JSValue &p_value) {
 	js_function.javascript_object = JS_VALUE_GET_PTR(v);
 }
 
-QuickJSCallable::QuickJSCallable(const JavaScriptGCHandler &p_function) : JavaScriptCallable(p_function) {
+QuickJSCallable::QuickJSCallable(const JavaScriptGCHandler &p_function) :
+		JavaScriptCallable(p_function) {
 	JSValue js_func = JS_MKPTR(JS_TAG_OBJECT, p_function.javascript_object);
 	JSContext *ctx = static_cast<JSContext *>(p_function.context);
 	ERR_FAIL_COND(JS_IsFunction(ctx, js_func));
diff --git a/quickjs/quickjs_callable.h b/quickjs/quickjs_callable.h
index 061a370a..45ac1761 100644
--- a/quickjs/quickjs_callable.h
+++ b/quickjs/quickjs_callable.h
@@ -1,3 +1,33 @@
+/**************************************************************************/
+/*  quickjs_callable.h                                                    */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
 #ifndef QUICKJS_CALLABLE_H
 #define QUICKJS_CALLABLE_H
 #include "../javascript_callable.h"
diff --git a/tools/editor_tools.h b/tools/editor_tools.h
index de095523..6b38fcc8 100644
--- a/tools/editor_tools.h
+++ b/tools/editor_tools.h
@@ -31,9 +31,9 @@
 #ifndef EDITOR_TOOLS_H
 #define EDITOR_TOOLS_H
 
-#include "editor/gui/editor_file_dialog.h"
 #include "editor/editor_node.h"
 #include "editor/editor_plugin.h"
+#include "editor/gui/editor_file_dialog.h"
 
 class DocTools;
 class EditorFileDialog;

From 76692da555de5c43043270a0da41fd8ea9e0d22e Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 07:05:58 -0700
Subject: [PATCH 58/71] Apply whitespace change.

---
 quickjs/quickjs_callable.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/quickjs/quickjs_callable.h b/quickjs/quickjs_callable.h
index 45ac1761..809b93b2 100644
--- a/quickjs/quickjs_callable.h
+++ b/quickjs/quickjs_callable.h
@@ -30,6 +30,7 @@
 
 #ifndef QUICKJS_CALLABLE_H
 #define QUICKJS_CALLABLE_H
+
 #include "../javascript_callable.h"
 #include "quickjs/quickjs.h"
 

From 3863950f0030ac8f6db298b1c681cab35c847475 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 07:09:02 -0700
Subject: [PATCH 59/71] Run spell checker.

---
 misc/decorators.ts                    |  2 +-
 misc/godot.d.ts                       |  4 ++--
 tests/UnitTest.js.disabled            | 16 ++++++++--------
 thirdparty/quickjs/quickjs_binder.cpp |  2 +-
 tools/editor_tools.cpp                |  2 +-
 5 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/misc/decorators.ts b/misc/decorators.ts
index 560383f9..dc2bc9ff 100644
--- a/misc/decorators.ts
+++ b/misc/decorators.ts
@@ -1,6 +1,6 @@
 /**
  * Expose as a godot class.
- * An class object is created and attached automaticly when construct an instance from this class
+ * An class object is created and attached automatically when construct an instance from this class
  */
 export function gdclass<T extends godot.Object>(target: new() => T) {
     const id = gdclass['internal_class_id'] = gdclass['internal_class_id'] ? gdclass['internal_class_id'] + 1 : 1;
diff --git a/misc/godot.d.ts b/misc/godot.d.ts
index 26a5326c..5066a2b1 100644
--- a/misc/godot.d.ts
+++ b/misc/godot.d.ts
@@ -56,7 +56,7 @@ declare module globalThis {
 	 *
 	 * Workers run in another global context that is different from the current context.
 	 *
-	 * You can run whatever code you like inside the worker thread. All of the godot API are avaliable inside workers.
+	 * You can run whatever code you like inside the worker thread. All of the godot API are available inside workers.
 	 *
 	 * Data is sent between workers and the main thread via a system of messages — both sides send their messages using the `postMessage()` method, and respond to messages via the `onmessage` event handler (the message is contained within the Message event's data attribute.) The data is copied rather than shared.
 	 *
@@ -81,7 +81,7 @@ declare module globalThis {
 		/**
 		 * Sends a message to the worker's inner scope. This accepts a single parameter, which is the data to send to the worker.
 		 * @param message The object to deliver to the worker; this will be in the data field in the event delivered to the `onmessage` handler.
-		 * @note The data cannot be instance of `godot.Object` or any other JavaScript object conains functions.
+		 * @note The data cannot be instance of `godot.Object` or any other JavaScript object contains functions.
 		 */
 		postMessage(message: any): void;
 
diff --git a/tests/UnitTest.js.disabled b/tests/UnitTest.js.disabled
index c9699d38..57773554 100644
--- a/tests/UnitTest.js.disabled
+++ b/tests/UnitTest.js.disabled
@@ -29,7 +29,7 @@ test('Object.prototype.connect', () => {
 
 	let obj = new godot.Object();
 	obj.connect('script_changed', (...args)=> {
-		console.log(`signal 'script_changed' emited with:`, ...args);
+		console.log(`signal 'script_changed' emitted with:`, ...args);
 		ok = true;
 	});
 	obj.emit_signal('script_changed', 123, 'hello');
@@ -39,19 +39,19 @@ test('Object.prototype.connect', () => {
 
 
 // --------------------------- Unit Test Implementation ------------------------
-function test(description, blcok, group = 'default') {
+function test(description, block, group = 'default') {
 	const entries = TEST_ENTRIES.get(group) || [];
-	entries.push({ description, blcok });
+	entries.push({ description, block });
 	TEST_ENTRIES.set(group, entries);
 }
 function runEntry(entry) {
 	return new Promise((resolve, reject) => {
-		switch (typeof (entry.blcok)) {
+		switch (typeof (entry.block)) {
 			case 'boolean':
-				return resolve(entry.blcok);
+				return resolve(entry.block);
 			case 'function': {
 				try {
-					resolve(entry.blcok());
+					resolve(entry.block());
 				} catch (error) {
 					console.error(error);
 					resolve(false);
@@ -59,8 +59,8 @@ function runEntry(entry) {
 			}
 			break;
 			case 'object':
-				if (entry.blcok instanceof Promise) {
-					entry.blcok.then(() => {
+				if (entry.block instanceof Promise) {
+					entry.block.then(() => {
 						resolve(true);
 					}).catch(err => {
 						resolve(false);
diff --git a/thirdparty/quickjs/quickjs_binder.cpp b/thirdparty/quickjs/quickjs_binder.cpp
index c517228b..757e1cb7 100644
--- a/thirdparty/quickjs/quickjs_binder.cpp
+++ b/thirdparty/quickjs/quickjs_binder.cpp
@@ -686,7 +686,7 @@ JSModuleDef *QuickJSBinder::js_module_loader(JSContext *ctx, const char *module_
 			module.hash = hash_var.hash();
 			module.module = m;
 			module.res = res;
-			module.res->reference(); // Avoid auto release as module don't release automaticly
+			module.res->reference(); // Avoid auto release as module don't release automatically
 			module.res_value = val;
 			module.flags = MODULE_FLAG_RESOURCE;
 			module.module = m;
diff --git a/tools/editor_tools.cpp b/tools/editor_tools.cpp
index 06294b1c..cc443f23 100644
--- a/tools/editor_tools.cpp
+++ b/tools/editor_tools.cpp
@@ -680,7 +680,7 @@ void JavaScriptPlugin::_export_typescript_declare_file(const String &p_path) {
 
 void JavaScriptPlugin::_export_enumeration_binding_file(const String &p_path) {
 	_export_typescript_declare_file("");
-	String file_content = "// Tool generated file DO NOT modify mannually\n"
+	String file_content = "// Tool generated file DO NOT modify manually\n"
 						  "// Add this script as first autoload to your project to bind enumerations for release build of godot engine\n"
 						  "\n"
 						  "if (!godot.DEBUG_ENABLED) {\n"

From ec74bb0564ee7a329a7d21b6e6f0eaee7e0748a6 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 07:14:03 -0700
Subject: [PATCH 60/71] Refactor platform condition in config.py

---
 config.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config.py b/config.py
index 6e8d6202..951e814f 100644
--- a/config.py
+++ b/config.py
@@ -1,5 +1,5 @@
 def can_build(env, platform):
-    return (platform == "windows" and env["use_mingw"]) or platform == "linux" or platform == "macos"
+    return not (platform == "windows" and not env["use_mingw"])
 
 
 def configure(env):

From 5bf37c68b5b7cec0aacb1659565d25ad4eb48818 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 07:15:23 -0700
Subject: [PATCH 61/71] Remove JavaScript style checks

---
 .github/workflows/static_checks.yml | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/.github/workflows/static_checks.yml b/.github/workflows/static_checks.yml
index f5981e8a..a004c269 100644
--- a/.github/workflows/static_checks.yml
+++ b/.github/workflows/static_checks.yml
@@ -65,17 +65,6 @@ jobs:
             echo "Skipping Python static analysis as no Python files were changed."
           fi
 
-      - name: JavaScript style and documentation checks via ESLint and JSDoc
-        run: |
-          if grep -q "platform/web" changed.txt || [ -z "$(cat changed.txt)" ]; then
-            cd platform/web
-            npm ci
-            npm run lint
-            npm run docs -- -d dry-run
-          else
-            echo "Skipping JavaScript formatting as no Web/JS files were changed."
-          fi
-
       - name: Style checks via clang-format (clang_format.sh)
         run: |
           clang-format --version

From 71c670461ed8769e9f25e56eaff570a90e554711 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 07:25:41 -0700
Subject: [PATCH 62/71] Update JSValue typedef in quickjs.h to avoid error.

---
 thirdparty/quickjs/quickjs/quickjs.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/thirdparty/quickjs/quickjs/quickjs.h b/thirdparty/quickjs/quickjs/quickjs.h
index 6d130152..4b2636b0 100644
--- a/thirdparty/quickjs/quickjs/quickjs.h
+++ b/thirdparty/quickjs/quickjs/quickjs.h
@@ -135,7 +135,7 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
 
 #elif defined(JS_NAN_BOXING)
 
-typedef uint64_t JSValue;
+// typedef uint64_t JSValue;
 
 #define JSValueConst JSValue
 

From 8d86711eb6a0c37d775fb1e86ecc4944c71f041a Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 07:28:47 -0700
Subject: [PATCH 63/71] Support MSVC builds without error in Github Actions.

Co-Authored-By: jaune <jaunelacouleur@gmail.com>
---
 SCsub                                         |  12 ++-
 config.py                                     |   4 +-
 register_types.cpp                            |   2 +-
 thirdparty/quickjs/quickjs/cutils.h           |  47 ++++++++
 thirdparty/quickjs/quickjs/quickjs-debugger.c |   6 +-
 thirdparty/quickjs/quickjs/quickjs.c          | 101 ++++++++++++------
 thirdparty/quickjs/quickjs/quickjs.h          |  28 ++++-
 thirdparty/quickjs/quickjs_binder.cpp         |   6 +-
 thirdparty/quickjs/quickjs_binder.h           |   2 +-
 9 files changed, 161 insertions(+), 47 deletions(-)

diff --git a/SCsub b/SCsub
index 347ab56a..69aef7f1 100644
--- a/SCsub
+++ b/SCsub
@@ -46,7 +46,8 @@ if JS_ENGINE == "quickjs":
     quickjs_env.Append(CPPDEFINES=["CONFIG_BIGNUM"])
     if "release" not in (quickjs_env["target"] or ""):
         quickjs_env.Append(CPPDEFINES={"DUMP_LEAKS": 1})
-        quickjs_env.Append(CPPDEFINES={"QUICKJS_WITH_DEBUGGER": 1})
+        if not env.msvc:
+            env_module.Append(CPPDEFINES={"QUICKJS_WITH_DEBUGGER": 1})
     quickjs_env.Append(CPPPATH=["thirdparty/quickjs/quickjs"])
     quickjs_env.Append(CPPPATH=["thirdparty/quickjs"])
     quickjs_env.disable_warnings()
@@ -54,8 +55,15 @@ if JS_ENGINE == "quickjs":
         quickjs_env.add_source_files(env.modules_sources, "tools/editor_tools.cpp")
     quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp")
     quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/*.cpp")
-    quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs/*.c")
 
+    env_thirdparty = quickjs_env.Clone()
+    if env.msvc:
+        env_thirdparty.AppendUnique(CCFLAGS=["/TC"])
+
+        # TODO: find a better way to remove /std:c++17
+        del env_thirdparty["CCFLAGS"][0]
+        env_thirdparty.Prepend(CCFLAGS=["/std:c11"])
+    env_thirdparty.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs/*.c")
 
 # Binding script to run at engine initializing
 with open("misc/godot.binding_script.gen.cpp", "w") as f:
diff --git a/config.py b/config.py
index 951e814f..930b9851 100644
--- a/config.py
+++ b/config.py
@@ -1,6 +1,6 @@
 def can_build(env, platform):
-    return not (platform == "windows" and not env["use_mingw"])
-
+    return True
+    
 
 def configure(env):
     pass
diff --git a/register_types.cpp b/register_types.cpp
index b055a364..1ca45654 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -52,7 +52,7 @@ class EditorExportJavaScript : public EditorExportPlugin {
 			return;
 		}
 	}
-	virtual String get_name() const override { return "JavaScript"; }
+	virtual String _get_name() const override { return "JavaScript"; }
 };
 
 #endif
diff --git a/thirdparty/quickjs/quickjs/cutils.h b/thirdparty/quickjs/quickjs/cutils.h
index a7839984..b0c7a262 100644
--- a/thirdparty/quickjs/quickjs/cutils.h
+++ b/thirdparty/quickjs/quickjs/cutils.h
@@ -119,6 +119,53 @@ static inline int64_t min_int64(int64_t a, int64_t b)
         return b;
 }
 
+
+
+#ifdef _MSC_VER
+#include <intrin.h>
+
+static inline int __builtin_ctz(unsigned x)
+{
+    return (int)_tzcnt_u32(x);
+}
+
+static inline int __builtin_ctzll(unsigned long long x)
+{
+#ifdef _WIN64
+    return (int)_tzcnt_u64(x);
+#else
+    return !!unsigned(x) ? __builtin_ctz((unsigned)x) : 32 + __builtin_ctz((unsigned)(x >> 32));
+#endif
+}
+
+static inline int __builtin_ctzl(unsigned long x)
+{
+    return sizeof(x) == 8 ? __builtin_ctzll(x) : __builtin_ctz((unsigned)x);
+}
+
+static inline int __builtin_clz(unsigned x)
+{
+    return (int)_lzcnt_u32(x);
+}
+
+static inline int __builtin_clzll(unsigned long long x)
+{
+#ifdef _WIN64
+    return (int)_lzcnt_u64(x);
+#else
+    return !!unsigned(x >> 32) ? __builtin_clz((unsigned)(x >> 32)) : 32 + __builtin_clz((unsigned)x);
+#endif
+}
+
+static inline int __builtin_clzl(unsigned long x)
+{
+    return sizeof(x) == 8 ? __builtin_clzll(x) : __builtin_clz((unsigned)x);
+}
+#endif
+
+
+
+
 /* WARNING: undefined if a = 0 */
 static inline int clz32(unsigned int a)
 {
diff --git a/thirdparty/quickjs/quickjs/quickjs-debugger.c b/thirdparty/quickjs/quickjs/quickjs-debugger.c
index 94246f47..0fd2ce96 100644
--- a/thirdparty/quickjs/quickjs/quickjs-debugger.c
+++ b/thirdparty/quickjs/quickjs/quickjs-debugger.c
@@ -36,12 +36,14 @@ static int js_transport_write_fully(JSDebuggerInfo *info, const char *buffer, si
     return 1;
 }
 
+#define JS_TRANSPORT_WRITE_MESSAGE_NEWLINE_MESSAGE_LENGTH 10
+
 static int js_transport_write_message_newline(JSDebuggerInfo *info, const char* value, size_t len) {
     // length prefix is 8 hex followed by newline = 012345678\n
     // not efficient, but protocol is then human readable.
-    char message_length[10];
+    char message_length[JS_TRANSPORT_WRITE_MESSAGE_NEWLINE_MESSAGE_LENGTH];
     message_length[9] = '\0';
-    sprintf(message_length, "%08x\n", (int)len + 1);
+    sprintf_s(message_length, JS_TRANSPORT_WRITE_MESSAGE_NEWLINE_MESSAGE_LENGTH, "%08x\n", (int)len + 1);
     if (!js_transport_write_fully(info, message_length, 9))
         return 0;
     int ret = js_transport_write_fully(info, value, len);
diff --git a/thirdparty/quickjs/quickjs/quickjs.c b/thirdparty/quickjs/quickjs/quickjs.c
index 99b6be9e..3c131a52 100644
--- a/thirdparty/quickjs/quickjs/quickjs.c
+++ b/thirdparty/quickjs/quickjs/quickjs.c
@@ -28,7 +28,12 @@
 #include <inttypes.h>
 #include <string.h>
 #include <assert.h>
+#if defined(_WIN32)
+// import struct timeval
+#include <winsock2.h>
+#else
 #include <sys/time.h>
+#endif
 #include <time.h>
 #include <fenv.h>
 #include <math.h>
@@ -51,7 +56,7 @@
 
 #define OPTIMIZE         1
 #define SHORT_OPCODES    1
-#if defined(EMSCRIPTEN)
+#if defined(EMSCRIPTEN) || defined(_MSC_VER)
 #define DIRECT_DISPATCH  0
 #else
 #define DIRECT_DISPATCH  1
@@ -70,7 +75,7 @@
 
 /* define to include Atomics.* operations which depend on the OS
    threads */
-#if !defined(EMSCRIPTEN)
+#if !(defined(EMSCRIPTEN) || defined(_MSC_VER))
 #define CONFIG_ATOMICS
 #endif
 
@@ -205,7 +210,11 @@ typedef enum JSErrorEnum {
 #define JS_STACK_SIZE_MAX 65536
 #define JS_STRING_LEN_MAX ((1 << 30) - 1)
 
+#if defined(_MSC_VER)
+#define __exception
+#else
 #define __exception __attribute__((warn_unused_result))
+#endif
 
 typedef struct JSShape JSShape;
 typedef struct JSString JSString;
@@ -1013,7 +1022,9 @@ static __exception int JS_ToArrayLengthFree(JSContext *ctx, uint32_t *plen,
                                             JSValue val);
 static JSValue JS_EvalObject(JSContext *ctx, JSValueConst this_obj,
                              JSValueConst val, int flags, int scope_idx);
-JSValue __attribute__((format(printf, 2, 3))) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...);
+
+JSValue __js_printf_like(2, 3) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...);
+
 static __maybe_unused void JS_DumpAtoms(JSRuntime *rt);
 static __maybe_unused void JS_DumpString(JSRuntime *rt,
                                                   const JSString *p);
@@ -6181,7 +6192,7 @@ void JS_DumpMemoryUsage(FILE *fp, const JSMemoryUsage *s, JSRuntime *rt)
             "BigNum "
 #endif
             "2020-09-06" " version, %d-bit, malloc limit: %"PRId64"\n\n",
-            (int)sizeof(void *) * 8, (int64_t)(ssize_t)s->malloc_limit);
+            (int)sizeof(void *) * 8, s->malloc_limit);
 #if 1
     if (rt) {
         static const struct {
@@ -6593,7 +6604,7 @@ static JSValue JS_ThrowError(JSContext *ctx, JSErrorEnum error_num,
     return JS_ThrowError2(ctx, error_num, fmt, ap, add_backtrace);
 }
 
-JSValue __attribute__((format(printf, 2, 3))) JS_ThrowSyntaxError(JSContext *ctx, const char *fmt, ...)
+JSValue __js_printf_like(2, 3) JS_ThrowSyntaxError(JSContext *ctx, const char *fmt, ...)
 {
     JSValue val;
     va_list ap;
@@ -6604,7 +6615,7 @@ JSValue __attribute__((format(printf, 2, 3))) JS_ThrowSyntaxError(JSContext *ctx
     return val;
 }
 
-JSValue __attribute__((format(printf, 2, 3))) JS_ThrowTypeError(JSContext *ctx, const char *fmt, ...)
+JSValue __js_printf_like(2, 3) JS_ThrowTypeError(JSContext *ctx, const char *fmt, ...)
 {
     JSValue val;
     va_list ap;
@@ -6615,7 +6626,7 @@ JSValue __attribute__((format(printf, 2, 3))) JS_ThrowTypeError(JSContext *ctx,
     return val;
 }
 
-static int __attribute__((format(printf, 3, 4))) JS_ThrowTypeErrorOrFalse(JSContext *ctx, int flags, const char *fmt, ...)
+static int __js_printf_like(3, 4) JS_ThrowTypeErrorOrFalse(JSContext *ctx, int flags, const char *fmt, ...)
 {
     va_list ap;
 
@@ -6631,7 +6642,7 @@ static int __attribute__((format(printf, 3, 4))) JS_ThrowTypeErrorOrFalse(JSCont
 }
 
 /* never use it directly */
-static JSValue __attribute__((format(printf, 3, 4))) __JS_ThrowTypeErrorAtom(JSContext *ctx, JSAtom atom, const char *fmt, ...)
+static JSValue __js_printf_like(3, 4) __JS_ThrowTypeErrorAtom(JSContext *ctx, JSAtom atom, const char *fmt, ...)
 {
     char buf[ATOM_GET_STR_BUF_SIZE];
     return JS_ThrowTypeError(ctx, fmt,
@@ -6639,7 +6650,7 @@ static JSValue __attribute__((format(printf, 3, 4))) __JS_ThrowTypeErrorAtom(JSC
 }
 
 /* never use it directly */
-static JSValue __attribute__((format(printf, 3, 4))) __JS_ThrowSyntaxErrorAtom(JSContext *ctx, JSAtom atom, const char *fmt, ...)
+static JSValue __js_printf_like(3, 4) __JS_ThrowSyntaxErrorAtom(JSContext *ctx, JSAtom atom, const char *fmt, ...)
 {
     char buf[ATOM_GET_STR_BUF_SIZE];
     return JS_ThrowSyntaxError(ctx, fmt,
@@ -6662,7 +6673,7 @@ static int JS_ThrowTypeErrorReadOnly(JSContext *ctx, int flags, JSAtom atom)
     }
 }
 
-JSValue __attribute__((format(printf, 2, 3))) JS_ThrowReferenceError(JSContext *ctx, const char *fmt, ...)
+JSValue __js_printf_like(2, 3) JS_ThrowReferenceError(JSContext *ctx, const char *fmt, ...)
 {
     JSValue val;
     va_list ap;
@@ -6673,7 +6684,7 @@ JSValue __attribute__((format(printf, 2, 3))) JS_ThrowReferenceError(JSContext *
     return val;
 }
 
-JSValue __attribute__((format(printf, 2, 3))) JS_ThrowRangeError(JSContext *ctx, const char *fmt, ...)
+JSValue __js_printf_like(2, 3) JS_ThrowRangeError(JSContext *ctx, const char *fmt, ...)
 {
     JSValue val;
     va_list ap;
@@ -6684,7 +6695,7 @@ JSValue __attribute__((format(printf, 2, 3))) JS_ThrowRangeError(JSContext *ctx,
     return val;
 }
 
-JSValue __attribute__((format(printf, 2, 3))) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...)
+JSValue __js_printf_like(2, 3) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...)
 {
     JSValue val;
     va_list ap;
@@ -7209,7 +7220,7 @@ static int JS_DefinePrivateField(JSContext *ctx, JSValueConst obj,
         JS_ThrowTypeErrorNotASymbol(ctx);
         goto fail;
     }
-    prop = js_symbol_to_atom(ctx, (JSValue)name);
+    prop = js_symbol_to_atom(ctx, name);
     p = JS_VALUE_GET_OBJ(obj);
     prs = find_own_property(&pr, p, prop);
     if (prs) {
@@ -7240,7 +7251,7 @@ static JSValue JS_GetPrivateField(JSContext *ctx, JSValueConst obj,
     /* safety check */
     if (unlikely(JS_VALUE_GET_TAG(name) != JS_TAG_SYMBOL))
         return JS_ThrowTypeErrorNotASymbol(ctx);
-    prop = js_symbol_to_atom(ctx, (JSValue)name);
+    prop = js_symbol_to_atom(ctx, name);
     p = JS_VALUE_GET_OBJ(obj);
     prs = find_own_property(&pr, p, prop);
     if (!prs) {
@@ -7267,7 +7278,7 @@ static int JS_SetPrivateField(JSContext *ctx, JSValueConst obj,
         JS_ThrowTypeErrorNotASymbol(ctx);
         goto fail;
     }
-    prop = js_symbol_to_atom(ctx, (JSValue)name);
+    prop = js_symbol_to_atom(ctx, name);
     p = JS_VALUE_GET_OBJ(obj);
     prs = find_own_property(&pr, p, prop);
     if (!prs) {
@@ -7357,7 +7368,7 @@ static int JS_CheckBrand(JSContext *ctx, JSValueConst obj, JSValueConst func)
     if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
         goto not_obj;
     p = JS_VALUE_GET_OBJ(obj);
-    prs = find_own_property(&pr, p, js_symbol_to_atom(ctx, (JSValue)brand));
+    prs = find_own_property(&pr, p, js_symbol_to_atom(ctx, brand));
     if (!prs) {
         JS_ThrowTypeError(ctx, "invalid brand on object");
         return -1;
@@ -10192,7 +10203,7 @@ static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
             } else
 #endif
             {
-                double d = 1.0 / 0.0;
+                double d = HUGE_VAL;
                 if (is_neg)
                     d = -d;
                 val = JS_NewFloat64(ctx, d);
@@ -15947,7 +15958,7 @@ static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
 #else
     sf->js_mode = 0;
 #endif
-    sf->cur_func = (JSValue)func_obj;
+    sf->cur_func = func_obj;
     sf->arg_count = argc;
     arg_buf = argv;
 
@@ -16211,7 +16222,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
     sf->js_mode = b->js_mode;
     arg_buf = argv;
     sf->arg_count = argc;
-    sf->cur_func = (JSValue)func_obj;
+    sf->cur_func = func_obj;
     init_list_head(&sf->var_ref_list);
     var_refs = p->u.func.var_refs;
 
@@ -20176,7 +20187,7 @@ static void free_token(JSParseState *s, JSToken *token)
     }
 }
 
-static void __attribute((unused)) dump_token(JSParseState *s,
+static void __js_unused dump_token(JSParseState *s,
                                              const JSToken *token)
 {
     switch(token->val) {
@@ -20237,7 +20248,7 @@ static void __attribute((unused)) dump_token(JSParseState *s,
     }
 }
 
-int __attribute__((format(printf, 2, 3))) js_parse_error(JSParseState *s, const char *fmt, ...)
+int __js_printf_like(2, 3) js_parse_error(JSParseState *s, const char *fmt, ...)
 {
     JSContext *ctx = s->ctx;
     va_list ap;
@@ -34505,7 +34516,7 @@ typedef struct BCReaderState {
 } BCReaderState;
 
 #ifdef DUMP_READ_OBJECT
-static void __attribute__((format(printf, 2, 3))) bc_read_trace(BCReaderState *s, const char *fmt, ...) {
+static void __js_printf_like(2, 3) bc_read_trace(BCReaderState *s, const char *fmt, ...) {
     va_list ap;
     int i, n, n0;
 
@@ -38885,8 +38896,8 @@ static int64_t JS_FlattenIntoArray(JSContext *ctx, JSValueConst target,
         if (!JS_IsUndefined(mapperFunction)) {
             JSValueConst args[3] = { element, JS_NewInt64(ctx, sourceIndex), source };
             element = JS_Call(ctx, mapperFunction, thisArg, 3, args);
-            JS_FreeValue(ctx, (JSValue)args[0]);
-            JS_FreeValue(ctx, (JSValue)args[1]);
+            JS_FreeValue(ctx, args[0]);
+            JS_FreeValue(ctx, args[1]);
             if (JS_IsException(element))
                 return -1;
         }
@@ -40344,7 +40355,7 @@ static JSValue js_string_match(JSContext *ctx, JSValueConst this_val,
         str = JS_NewString(ctx, "g");
         if (JS_IsException(str))
             goto fail;
-        args[args_len++] = (JSValueConst)str;
+        args[args_len++] = str;
     }
     rx = JS_CallConstructor(ctx, ctx->regexp_ctor, args_len, args);
     JS_FreeValue(ctx, str);
@@ -41400,7 +41411,7 @@ static JSValue js_math_min_max(JSContext *ctx, JSValueConst this_val,
     uint32_t tag;
 
     if (unlikely(argc == 0)) {
-        return __JS_NewFloat64(ctx, is_max ? -1.0 / 0.0 : 1.0 / 0.0);
+        return __JS_NewFloat64(ctx, is_max ? DBL_MAX : HUGE_VAL);
     }
 
     tag = JS_VALUE_GET_TAG(argv[0]);
@@ -41640,6 +41651,30 @@ static JSValue js___date_now(JSContext *ctx, JSValueConst this_val,
 }
 #endif
 
+#if defined(_MSC_VER)
+int gettimeofday(struct timeval * tp, struct timezone * tzp)
+{
+    // Note: some broken versions only have 8 trailing zero's, the correct epoch has 9 trailing zero's
+    // This magic number is the number of 100 nanosecond intervals since January 1, 1601 (UTC)
+    // until 00:00:00 January 1, 1970
+    static const uint64_t EPOCH = ((uint64_t) 116444736000000000ULL);
+
+    SYSTEMTIME  system_time;
+    FILETIME    file_time;
+    uint64_t    time;
+
+    GetSystemTime( &system_time );
+    SystemTimeToFileTime( &system_time, &file_time );
+    time =  ((uint64_t)file_time.dwLowDateTime )      ;
+    time += ((uint64_t)file_time.dwHighDateTime) << 32;
+
+    tp->tv_sec  = (long) ((time - EPOCH) / 10000000L);
+    tp->tv_usec = (long) (system_time.wMilliseconds * 1000);
+    return 0;
+}
+#endif
+
+
 /* OS dependent: return the UTC time in microseconds since 1970. */
 static JSValue js___date_clock(JSContext *ctx, JSValueConst this_val,
                                int argc, JSValueConst *argv)
@@ -45365,7 +45400,7 @@ static JSMapRecord *map_add_record(JSContext *ctx, JSMapState *s,
     } else {
         JS_DupValue(ctx, key);
     }
-    mr->key = (JSValue)key;
+    mr->key = key;
     h = map_hash_key(ctx, key) & (s->hash_size - 1);
     list_add_tail(&mr->hash_link, &s->hash_table[h]);
     list_add_tail(&mr->link, &s->records);
@@ -45587,7 +45622,7 @@ static JSValue js_map_forEach(JSContext *ctx, JSValueConst this_val,
                 args[0] = args[1];
             else
                 args[0] = JS_DupValue(ctx, mr->value);
-            args[2] = (JSValue)this_val;
+            args[2] = this_val;
             ret = JS_Call(ctx, func, this_arg, 3, (JSValueConst *)args);
             JS_FreeValue(ctx, args[0]);
             if (!magic)
@@ -46565,7 +46600,7 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
                 goto fail_reject;
             }
             resolve_element_data[0] = JS_NewBool(ctx, FALSE);
-            resolve_element_data[1] = (JSValueConst)JS_NewInt32(ctx, index);
+            resolve_element_data[1] = JS_NewInt32(ctx, index);
             resolve_element_data[2] = values;
             resolve_element_data[3] = resolving_funcs[is_promise_any];
             resolve_element_data[4] = resolve_element_env;
@@ -46935,7 +46970,7 @@ static JSValue js_async_from_sync_iterator_unwrap_func_create(JSContext *ctx,
 {
     JSValueConst func_data[1];
 
-    func_data[0] = (JSValueConst)JS_NewBool(ctx, done);
+    func_data[0] = JS_NewBool(ctx, done);
     return JS_NewCFunctionData(ctx, js_async_from_sync_iterator_unwrap,
                                1, 0, 1, func_data);
 }
@@ -47240,7 +47275,7 @@ static int isURIReserved(int c) {
     return c < 0x100 && memchr(";/?:@&=+$,#", c, sizeof(";/?:@&=+$,#") - 1) != NULL;
 }
 
-static int __attribute__((format(printf, 2, 3))) js_throw_URIError(JSContext *ctx, const char *fmt, ...)
+static int __js_printf_like(2, 3) js_throw_URIError(JSContext *ctx, const char *fmt, ...)
 {
     va_list ap;
 
@@ -52286,8 +52321,8 @@ static int js_TA_cmp_generic(const void *a, const void *b, void *opaque) {
             psc->exception = 1;
         }
     done:
-        JS_FreeValue(ctx, (JSValue)argv[0]);
-        JS_FreeValue(ctx, (JSValue)argv[1]);
+        JS_FreeValue(ctx, argv[0]);
+        JS_FreeValue(ctx, argv[1]);
     }
     return cmp;
 }
diff --git a/thirdparty/quickjs/quickjs/quickjs.h b/thirdparty/quickjs/quickjs/quickjs.h
index 4b2636b0..c77e3a1c 100644
--- a/thirdparty/quickjs/quickjs/quickjs.h
+++ b/thirdparty/quickjs/quickjs/quickjs.h
@@ -43,11 +43,13 @@ extern "C" {
 #define js_unlikely(x)        __builtin_expect(!!(x), 0)
 #define js_force_inline       inline __attribute__((always_inline))
 #define __js_printf_like(f, a)   __attribute__((format(printf, f, a)))
+#define __js_unused __attribute((unused))
 #else
 #define js_likely(x)     (x)
 #define js_unlikely(x)   (x)
 #define js_force_inline  INLINE_FUNC
 #define __js_printf_like(a, b)
+#define __js_unused
 #endif
 
 #define JS_BOOL int
@@ -221,8 +223,26 @@ typedef struct JSValue {
 #define JS_VALUE_GET_FLOAT64(v) ((v).u.float64)
 #define JS_VALUE_GET_PTR(v) ((v).u.ptr)
 
-#define JS_MKVAL(tag, val) (JSValue){ (JSValueUnion){ .int32 = val }, tag }
-#define JS_MKPTR(tag, p) (JSValue){ (JSValueUnion){ .ptr = p }, tag }
+JSValue INLINE_FUNC _JS_MKVAL_INT32(int64_t tag, int32_t val) {
+	JSValue v;
+
+	v.u.int32 = val;
+	v.tag = tag;
+
+	return v;
+}
+
+JSValue INLINE_FUNC _JS_MKPTR(int64_t tag, void* ptr) {
+	JSValue v;
+
+	v.u.ptr = ptr;
+	v.tag = tag;
+
+	return v;
+}
+
+#define JS_MKVAL(tag, val) _JS_MKVAL_INT32(tag, val)
+#define JS_MKPTR(tag, p) _JS_MKPTR(tag, p)
 
 #define JS_TAG_IS_FLOAT64(tag) ((unsigned)(tag) == JS_TAG_FLOAT64)
 
@@ -668,7 +688,7 @@ static inline JSValue JS_DupValue(JSContext *ctx, JSValueConst v)
         JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
         p->ref_count++;
     }
-    return (JSValue)v;
+    return v;
 }
 
 static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
@@ -677,7 +697,7 @@ static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
         JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
         p->ref_count++;
     }
-    return (JSValue)v;
+    return v;
 }
 
 int JS_ToBool(JSContext *ctx, JSValueConst val); /* return -1 for JS_EXCEPTION */
diff --git a/thirdparty/quickjs/quickjs_binder.cpp b/thirdparty/quickjs/quickjs_binder.cpp
index 757e1cb7..20a7e687 100644
--- a/thirdparty/quickjs/quickjs_binder.cpp
+++ b/thirdparty/quickjs/quickjs_binder.cpp
@@ -1100,7 +1100,7 @@ void QuickJSBinder::add_godot_globals() {
 		const int value = CoreConstants::get_global_constant_value(i);
 
 		JSAtom js_const_name = JS_NewAtom(ctx, const_name);
-		JS_DefinePropertyValue(ctx, godot_object, js_const_name, JS_MKVAL(JS_TAG_INT, value), QuickJSBinder::PROP_DEF_DEFAULT);
+		JS_DefinePropertyValue(ctx, godot_object, js_const_name, JS_NewInt64(ctx, value), QuickJSBinder::PROP_DEF_DEFAULT);
 		JS_FreeAtom(ctx, js_const_name);
 
 		if (HashMap<StringName, int64_t> *consts = global_constants.getptr(enum_name)) {
@@ -1485,7 +1485,9 @@ Error QuickJSBinder::safe_eval_text(const String &p_source, EvalType type, const
 	}
 	JSValue ret = JS_Eval(ctx, code, utf8_str.length(), filename, flags);
 	r_ret.context = ctx;
-	r_ret.javascript_object = JS_VALUE_GET_PTR(ret);
+	if (JS_VALUE_GET_TAG(ret) == JS_TAG_OBJECT) {
+		r_ret.javascript_object = JS_VALUE_GET_PTR(ret);
+	}
 	if (JS_IsException(ret)) {
 		JSValue e = JS_GetException(ctx);
 		JavaScriptError err;
diff --git a/thirdparty/quickjs/quickjs_binder.h b/thirdparty/quickjs/quickjs_binder.h
index 1d003dd1..831e960c 100644
--- a/thirdparty/quickjs/quickjs_binder.h
+++ b/thirdparty/quickjs/quickjs_binder.h
@@ -80,7 +80,7 @@ class QuickJSBinder : public JavaScriptBinder {
 
 	enum {
 		__JS_ATOM_NULL = JS_ATOM_NULL,
-#if !defined(EMSCRIPTEN)
+#if !(defined(EMSCRIPTEN) || defined(_MSC_VER))
 #define CONFIG_ATOMICS
 #endif
 #define DEF(name, str) JS_ATOM_##name,

From 221e3588d9e846ee90ec8f7b1125959c796f5ac2 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 07:33:28 -0700
Subject: [PATCH 64/71] Fix function name and use safer string formatting in
 JavaScript module

Fix github actions CICD errors.
---
 register_types.cpp                            | 2 +-
 thirdparty/quickjs/quickjs/quickjs-debugger.c | 2 +-
 thirdparty/quickjs/quickjs/quickjs.c          | 1 +
 thirdparty/quickjs/quickjs_binder.cpp         | 2 +-
 thirdparty/quickjs/quickjs_debugger.cpp       | 2 +-
 thirdparty/quickjs/quickjs_debugger.h         | 2 +-
 6 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/register_types.cpp b/register_types.cpp
index 1ca45654..b055a364 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -52,7 +52,7 @@ class EditorExportJavaScript : public EditorExportPlugin {
 			return;
 		}
 	}
-	virtual String _get_name() const override { return "JavaScript"; }
+	virtual String get_name() const override { return "JavaScript"; }
 };
 
 #endif
diff --git a/thirdparty/quickjs/quickjs/quickjs-debugger.c b/thirdparty/quickjs/quickjs/quickjs-debugger.c
index 0fd2ce96..6bffc4bc 100644
--- a/thirdparty/quickjs/quickjs/quickjs-debugger.c
+++ b/thirdparty/quickjs/quickjs/quickjs-debugger.c
@@ -43,7 +43,7 @@ static int js_transport_write_message_newline(JSDebuggerInfo *info, const char*
     // not efficient, but protocol is then human readable.
     char message_length[JS_TRANSPORT_WRITE_MESSAGE_NEWLINE_MESSAGE_LENGTH];
     message_length[9] = '\0';
-    sprintf_s(message_length, JS_TRANSPORT_WRITE_MESSAGE_NEWLINE_MESSAGE_LENGTH, "%08x\n", (int)len + 1);
+    snprintf(message_length, JS_TRANSPORT_WRITE_MESSAGE_NEWLINE_MESSAGE_LENGTH, "%08x\n", (int)len + 1);
     if (!js_transport_write_fully(info, message_length, 9))
         return 0;
     int ret = js_transport_write_fully(info, value, len);
diff --git a/thirdparty/quickjs/quickjs/quickjs.c b/thirdparty/quickjs/quickjs/quickjs.c
index 3c131a52..9a4a55ef 100644
--- a/thirdparty/quickjs/quickjs/quickjs.c
+++ b/thirdparty/quickjs/quickjs/quickjs.c
@@ -28,6 +28,7 @@
 #include <inttypes.h>
 #include <string.h>
 #include <assert.h>
+#include <float.h>
 #if defined(_WIN32)
 // import struct timeval
 #include <winsock2.h>
diff --git a/thirdparty/quickjs/quickjs_binder.cpp b/thirdparty/quickjs/quickjs_binder.cpp
index 20a7e687..977bd858 100644
--- a/thirdparty/quickjs/quickjs_binder.cpp
+++ b/thirdparty/quickjs/quickjs_binder.cpp
@@ -1280,7 +1280,7 @@ void QuickJSBinder::initialize() {
 		if (List<String>::Element *E = args.find("--js-debugger-connect")) {
 			if (E->next() && E->next()->get().find(":") != -1) {
 				String address = E->next()->get();
-				Error err = debugger->connect(ctx, address);
+				Error err = debugger->connect_debugger(ctx, address);
 				if (err != OK) {
 					ERR_PRINT(vformat("Failed to connect to JavaScript debugger at %s", address));
 				}
diff --git a/thirdparty/quickjs/quickjs_debugger.cpp b/thirdparty/quickjs/quickjs_debugger.cpp
index 36a54765..366a31c6 100644
--- a/thirdparty/quickjs/quickjs_debugger.cpp
+++ b/thirdparty/quickjs/quickjs_debugger.cpp
@@ -79,7 +79,7 @@ Error QuickJSDebugger::attach_js_debugger(JSContext *ctx, Ref<StreamPeerTCP> p_p
 	return ERR_CANT_CONNECT;
 }
 
-Error QuickJSDebugger::connect(JSContext *ctx, const String &address) {
+Error QuickJSDebugger::connect_debugger(JSContext *ctx, const String &address) {
 	this->ctx = ctx;
 	this->runtime = JS_GetRuntime(ctx);
 
diff --git a/thirdparty/quickjs/quickjs_debugger.h b/thirdparty/quickjs/quickjs_debugger.h
index e509a0b7..e700d269 100644
--- a/thirdparty/quickjs/quickjs_debugger.h
+++ b/thirdparty/quickjs/quickjs_debugger.h
@@ -33,7 +33,7 @@ class QuickJSDebugger : public RefCounted {
 	Error attach_js_debugger(JSContext *p_ctx, Ref<StreamPeerTCP> p_peer);
 
 public:
-	Error connect(JSContext *ctx, const String &address);
+	Error connect_debugger(JSContext *ctx, const String &address);
 	Error listen(JSContext *ctx, const String &address);
 	void poll();
 

From d487bcfe231058d597ecfd97785a55bc62ad7cae Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 07:36:00 -0700
Subject: [PATCH 65/71] Format python files for automated tests.

---
 config.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config.py b/config.py
index 930b9851..e9f39c99 100644
--- a/config.py
+++ b/config.py
@@ -1,6 +1,6 @@
 def can_build(env, platform):
     return True
-    
+
 
 def configure(env):
     pass

From b2cacc03362d477097cab3bca0085d7f4bfae3c8 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 07:44:49 -0700
Subject: [PATCH 66/71] Fix gitub actions tests.

---
 SCsub                              | 13 +++++++------
 {tools => editor}/editor_tools.cpp |  0
 {tools => editor}/editor_tools.h   |  0
 register_types.cpp                 |  2 +-
 4 files changed, 8 insertions(+), 7 deletions(-)
 rename {tools => editor}/editor_tools.cpp (100%)
 rename {tools => editor}/editor_tools.h (100%)

diff --git a/SCsub b/SCsub
index 69aef7f1..bf47ffe5 100644
--- a/SCsub
+++ b/SCsub
@@ -51,8 +51,6 @@ if JS_ENGINE == "quickjs":
     quickjs_env.Append(CPPPATH=["thirdparty/quickjs/quickjs"])
     quickjs_env.Append(CPPPATH=["thirdparty/quickjs"])
     quickjs_env.disable_warnings()
-    if TOOLS:
-        quickjs_env.add_source_files(env.modules_sources, "tools/editor_tools.cpp")
     quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp")
     quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/*.cpp")
 
@@ -83,19 +81,19 @@ if TOOLS:
         '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
     )
     tool_fns = {
-        "tools/godot.d.ts.gen.cpp": (
+        "editor/godot.d.ts.gen.cpp": (
             "BUILTIN_DECLARATION_TEXT",
             dump_text_file_to_cpp("misc/godot.d.ts"),
         ),
-        "tools/tsconfig.json.gen.cpp": (
+        "editor/tsconfig.json.gen.cpp": (
             "TSCONFIG_CONTENT",
             dump_text_file_to_cpp("misc/tsconfig.json"),
         ),
-        "tools/decorators.ts.gen.cpp": (
+        "editor/decorators.ts.gen.cpp": (
             "TS_DECORATORS_CONTENT",
             dump_text_file_to_cpp("misc/decorators.ts"),
         ),
-        "tools/package.json.gen.cpp": (
+        "editor/package.json.gen.cpp": (
             "PACKAGE_JSON_CONTENT",
             dump_text_file_to_cpp("misc/package.json"),
         ),
@@ -108,3 +106,6 @@ if TOOLS:
 
 env_module.Append(CPPPATH=["#modules/javascript"])
 env_module.add_source_files(env.modules_sources, sources)
+
+if env.editor_build:
+    env_module.add_source_files(env.modules_sources, "editor/*.cpp")
diff --git a/tools/editor_tools.cpp b/editor/editor_tools.cpp
similarity index 100%
rename from tools/editor_tools.cpp
rename to editor/editor_tools.cpp
diff --git a/tools/editor_tools.h b/editor/editor_tools.h
similarity index 100%
rename from tools/editor_tools.h
rename to editor/editor_tools.h
diff --git a/register_types.cpp b/register_types.cpp
index b055a364..e1f71d83 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -37,7 +37,7 @@
 #include "core/io/file_access_encrypted.h"
 #include "editor/editor_node.h"
 #include "editor/export/editor_export.h"
-#include "tools/editor_tools.h"
+#include "editor/editor_tools.h"
 void editor_init_callback();
 
 class EditorExportJavaScript : public EditorExportPlugin {

From c2533ae07e5390d8545712af2aa95e44f14c689a Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 07:47:50 -0700
Subject: [PATCH 67/71] Fix tests.

---
 register_types.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/register_types.cpp b/register_types.cpp
index e1f71d83..709d46af 100644
--- a/register_types.cpp
+++ b/register_types.cpp
@@ -36,8 +36,8 @@
 #ifdef TOOLS_ENABLED
 #include "core/io/file_access_encrypted.h"
 #include "editor/editor_node.h"
-#include "editor/export/editor_export.h"
 #include "editor/editor_tools.h"
+#include "editor/export/editor_export.h"
 void editor_init_callback();
 
 class EditorExportJavaScript : public EditorExportPlugin {

From 60db283027330bb34c65871a7b4cee35ec94f86d Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 07:54:00 -0700
Subject: [PATCH 68/71] Try to pass tests.

---
 config.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config.py b/config.py
index e9f39c99..a76fd255 100644
--- a/config.py
+++ b/config.py
@@ -1,5 +1,5 @@
 def can_build(env, platform):
-    return True
+    return not platform == "android"
 
 
 def configure(env):

From 45ca44b9093b3483c06956c68662c87c55bafce5 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 07:55:16 -0700
Subject: [PATCH 69/71] Exclude mono platform

---
 config.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/config.py b/config.py
index a76fd255..8e323971 100644
--- a/config.py
+++ b/config.py
@@ -1,5 +1,5 @@
 def can_build(env, platform):
-    return not platform == "android"
+    return not platform == "android" and not platform == "mono"
 
 
 def configure(env):

From 483c70d0a1e1c570e0c207013aa1887825882839 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Thu, 24 Aug 2023 07:59:24 -0700
Subject: [PATCH 70/71] Apply xml docs fixes for tests.

---
 doc_classes/JavaScript.xml       | 2 +-
 doc_classes/JavaScriptModule.xml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc_classes/JavaScript.xml b/doc_classes/JavaScript.xml
index b70cb7ad..88bc9a12 100644
--- a/doc_classes/JavaScript.xml
+++ b/doc_classes/JavaScript.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<class name="JavaScript" inherits="Script" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
+<class name="JavaScript" inherits="Script" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
 	<brief_description>
 		A JavaScript script resource for creating and managing JavaScript scripts in Godot.
 	</brief_description>
diff --git a/doc_classes/JavaScriptModule.xml b/doc_classes/JavaScriptModule.xml
index e8249976..878c6d1b 100644
--- a/doc_classes/JavaScriptModule.xml
+++ b/doc_classes/JavaScriptModule.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<class name="JavaScriptModule" inherits="Resource" version="4.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
+<class name="JavaScriptModule" inherits="Resource" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
 	<brief_description>
 		A JavaScript module resource for managing JavaScript source code and bytecode.
 	</brief_description>

From 7160c86266c584e2129e7bb71bb07ba396ec67f3 Mon Sep 17 00:00:00 2001
From: "K. S. Ernest (iFire) Lee" <ernest.lee@chibifire.com>
Date: Sun, 1 Oct 2023 07:07:24 -0700
Subject: [PATCH 71/71] Refactor JavaScript integration and improve code
 readability.

We have refactored the JavaScript integration to make it more efficient. We have also improved the readability of the code by adding comments and restructuring the code blocks. This will make it easier for other developers to understand and contribute to the project.

Co-Authored-By: NicolasMerget <Nicolas.Merget@deutschebahn.com>
---
 .github/workflows/linux_builds.yml            |  87 ++-------------
 README.md                                     |   4 +
 SCsub                                         |  47 ++++----
 config.py                                     |   2 +-
 doc_classes/JavaScript.xml                    |   2 +-
 doc_classes/JavaScriptModule.xml              |   2 +-
 editor/editor_tools.h                         |  72 -------------
 javascript_language.cpp                       |   2 +-
 misc/godot.d.ts                               |   2 +-
 quickjs/quickjs_callable.cpp                  |   1 +
 register_types.h                              |   6 +-
 tests/UnitTest.js.disabled                    |  16 +--
 thirdparty/quickjs/quickjs/cutils.h           |  49 +--------
 thirdparty/quickjs/quickjs/quickjs-debugger.c |   8 +-
 thirdparty/quickjs/quickjs/quickjs.c          | 102 ++++++------------
 thirdparty/quickjs/quickjs/quickjs.h          |  30 +-----
 thirdparty/quickjs/quickjs_binder.cpp         |  15 ++-
 thirdparty/quickjs/quickjs_binder.h           |   2 +-
 thirdparty/quickjs/quickjs_builtin_binder.cpp |   1 +
 thirdparty/quickjs/quickjs_callable.cpp       |   3 +-
 thirdparty/quickjs/quickjs_callable.h         |   5 +-
 thirdparty/quickjs/quickjs_debugger.cpp       |   2 +-
 22 files changed, 104 insertions(+), 356 deletions(-)
 delete mode 100644 editor/editor_tools.h

diff --git a/.github/workflows/linux_builds.yml b/.github/workflows/linux_builds.yml
index b1ee98cc..d180139c 100644
--- a/.github/workflows/linux_builds.yml
+++ b/.github/workflows/linux_builds.yml
@@ -33,46 +33,11 @@ jobs:
             proj-conv: true
             artifact: true
 
-          - name: Editor with doubles and GCC sanitizers (target=editor, tests=yes, dev_build=yes, precision=double, use_asan=yes, use_ubsan=yes, linker=gold)
-            cache-name: linux-editor-double-sanitizers
-            target: editor
-            tests: true
-            # Debug symbols disabled as they're huge on this build and we hit the 14 GB limit for runners.
-            sconsflags: dev_build=yes debug_symbols=no precision=double use_asan=yes use_ubsan=yes linker=gold
-            proj-test: true
-            # Can be turned off for PRs that intentionally break compat with godot-cpp,
-            # until both the upstream PR and the matching godot-cpp changes are merged.
-            godot-cpp-test: true
-            bin: "./bin/godot.linuxbsd.editor.dev.double.x86_64.san"
-            build-mono: false
-            # Skip 2GiB artifact speeding up action.
-            artifact: false
-
-          - name: Editor with clang sanitizers (target=editor, tests=yes, dev_build=yes, use_asan=yes, use_ubsan=yes, use_llvm=yes, linker=lld)
-            cache-name: linux-editor-llvm-sanitizers
-            target: editor
-            tests: true
-            sconsflags: dev_build=yes use_asan=yes use_ubsan=yes use_llvm=yes linker=lld
-            bin: "./bin/godot.linuxbsd.editor.dev.x86_64.llvm.san"
-            build-mono: false
-            # Skip 2GiB artifact speeding up action.
-            artifact: false
-
-          - name: Template w/ Mono (target=template_release)
-            cache-name: linux-template-mono
-            target: template_release
-            tests: false
-            sconsflags: module_mono_enabled=yes
-            build-mono: false
-            artifact: true
-
-          - name: Minimal template (target=template_release, everything disabled)
-            cache-name: linux-template-minimal
-            target: template_release
-            tests: false
-            sconsflags: modules_enabled_by_default=no disable_3d=yes disable_advanced_gui=yes deprecated=no minizip=no
-            artifact: true
-
+        - name: Minimal template (target=template_release, everything disabled)
+          cache-name: linux-template-minimal
+          target: template_release
+          tests: false
+          sconsflags: modules_enabled_by_default=no disable_3d=yes disable_advanced_gui=yes deprecated=no
     steps:
       - name: Checkout Godot
         uses: actions/checkout@v2
@@ -185,40 +150,8 @@ jobs:
           xvfb-run ${{ matrix.bin }} 40 --audio-driver Dummy --path test_project 2>&1 | tee sanitizers_log.txt || true
           misc/scripts/check_ci_log.py sanitizers_log.txt
 
-      # Checkout godot-cpp
-      - name: Checkout godot-cpp
-        if: ${{ matrix.godot-cpp-test }}
-        uses: actions/checkout@v3
-        with:
-          repository: godotengine/godot-cpp
-          ref: ${{ env.GODOT_BASE_BRANCH }}
-          submodules: 'recursive'
-          path: 'godot-cpp'
-
-      # Dump GDExtension interface and API
-      - name: Dump GDExtension interface and API for godot-cpp build
-        if: ${{ matrix.godot-cpp-test }}
-        run: |
-          ${{ matrix.bin }} --headless --dump-gdextension-interface --dump-extension-api
-          cp -f gdextension_interface.h godot-cpp/gdextension/
-          cp -f extension_api.json godot-cpp/gdextension/
-
-      # Build godot-cpp test extension
-      - name: Build godot-cpp test extension
-        if: ${{ matrix.godot-cpp-test }}
-        run: |
-          cd godot-cpp/test
-          scons target=template_debug dev_build=yes
-          cd ../..
-
-      - name: Prepare artifact
-        if: ${{ matrix.artifact }}
-        run: |
-          strip bin/godot.*
-          chmod +x bin/godot.*
-
-      - name: Upload artifact
-        uses: ./.github/actions/upload-artifact
-        if: ${{ matrix.artifact }}
-        with:
-          name: ${{ matrix.cache-name }}
+    - name: Upload artifact
+      uses: ./.github/actions/upload-artifact
+      if: ${{ matrix.artifact }}
+      with:
+        name: ${{ matrix.cache-name }}
diff --git a/README.md b/README.md
index a57f7b4d..0261ca5d 100644
--- a/README.md
+++ b/README.md
@@ -282,6 +282,10 @@ You can try demos in the [ECMAScriptDemos](https://github.com/Geequlim/ECMAScrip
 ## Developer notes
 
 - This package is not compatible with MSVC, you will get build errors in quickjs.
+- To update the github actions scripts we have the file `build_github_actions.py`. This script will copy the actions from the godot repo (usually at `../../`) and modify them to fix the requirements of quickjs and this repo.
+  \*\* If you are updating this repo's compatibility, you should run that script (a brief description is at the top of the script) and it will re-create the actions `.yml` files for you.
 - The script also build the `on_tag.yml` script which automates the github release publishing.
   \*\* The `on_tag.yml` functionality tries to sleep until all jobs with the same `sha` are completed. It should be fine to run whenever, but depending on how github actions culls long running jobs you might want to make sure that all/(most of) the builds look good before tagging.
+- Linux ubsan asan build woes:
+- The godot repo has ubsan and asan builds that we can't build from. Currently we skip them (get removed via the `build_github_actions.py` script).
 - They should definitely be fixed & enabled at some point, **so please submit a PR if you have any ideas of how to do that!**
diff --git a/SCsub b/SCsub
index bf47ffe5..1efe9a28 100644
--- a/SCsub
+++ b/SCsub
@@ -7,10 +7,6 @@ env_module = env_modules.Clone()
 JS_ENGINE = "quickjs"
 TOOLS = "editor" == env_module["target"]
 
-if env["platform"] == "windows":
-    if env["use_mingw"]:
-        env.Append(LIBS=["pthread"])
-
 
 def open_file(path, mode):
     if platform.python_version() > "3":
@@ -41,27 +37,20 @@ if JS_ENGINE == "quickjs":
 
     thirdparty.quickjs.builtin_binding_generator.generate_builtin_bindings()
     version = open("thirdparty/quickjs/quickjs/VERSION.txt", "r").read().split("\n")[0]
-    quickjs_env = env_modules.Clone()
-    quickjs_env.Append(CPPDEFINES={"QUICKJS_CONFIG_VERSION": '"' + version + '"'})
-    quickjs_env.Append(CPPDEFINES=["CONFIG_BIGNUM"])
-    if "release" not in (quickjs_env["target"] or ""):
-        quickjs_env.Append(CPPDEFINES={"DUMP_LEAKS": 1})
-        if not env.msvc:
-            env_module.Append(CPPDEFINES={"QUICKJS_WITH_DEBUGGER": 1})
-    quickjs_env.Append(CPPPATH=["thirdparty/quickjs/quickjs"])
-    quickjs_env.Append(CPPPATH=["thirdparty/quickjs"])
-    quickjs_env.disable_warnings()
-    quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp")
-    quickjs_env.add_source_files(env.modules_sources, "thirdparty/quickjs/*.cpp")
-
-    env_thirdparty = quickjs_env.Clone()
-    if env.msvc:
-        env_thirdparty.AppendUnique(CCFLAGS=["/TC"])
-
-        # TODO: find a better way to remove /std:c++17
-        del env_thirdparty["CCFLAGS"][0]
-        env_thirdparty.Prepend(CCFLAGS=["/std:c11"])
-    env_thirdparty.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs/*.c")
+    env_module.Append(CPPDEFINES={"QUICKJS_CONFIG_VERSION": '"' + version + '"'})
+    env_module.Append(CPPDEFINES=["CONFIG_BIGNUM"])
+    if "release" not in (env_module["target"] or ""):
+        env_module.Append(CPPDEFINES={"DUMP_LEAKS": 1})
+        env_module.Append(CPPDEFINES={"QUICKJS_WITH_DEBUGGER": 1})
+    env_module.Append(CPPPATH=["thirdparty/quickjs/quickjs"])
+    env_module.Append(CPPPATH=["thirdparty/quickjs"])
+
+    if TOOLS:
+        env_module.add_source_files(env.modules_sources, "tools/editor_tools.cpp")
+    env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs_builtin_binder.gen.cpp")
+    env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/*.cpp")
+    env_module.add_source_files(env.modules_sources, "thirdparty/quickjs/quickjs/*.c")
+
 
 # Binding script to run at engine initializing
 with open("misc/godot.binding_script.gen.cpp", "w") as f:
@@ -81,19 +70,19 @@ if TOOLS:
         '/* THIS FILE IS GENERATED DO NOT EDIT */\n#include "editor_tools.h"\nString JavaScriptPlugin::{} = \n{};'
     )
     tool_fns = {
-        "editor/godot.d.ts.gen.cpp": (
+        "tools/godot.d.ts.gen.cpp": (
             "BUILTIN_DECLARATION_TEXT",
             dump_text_file_to_cpp("misc/godot.d.ts"),
         ),
-        "editor/tsconfig.json.gen.cpp": (
+        "tools/tsconfig.json.gen.cpp": (
             "TSCONFIG_CONTENT",
             dump_text_file_to_cpp("misc/tsconfig.json"),
         ),
-        "editor/decorators.ts.gen.cpp": (
+        "tools/decorators.ts.gen.cpp": (
             "TS_DECORATORS_CONTENT",
             dump_text_file_to_cpp("misc/decorators.ts"),
         ),
-        "editor/package.json.gen.cpp": (
+        "tools/package.json.gen.cpp": (
             "PACKAGE_JSON_CONTENT",
             dump_text_file_to_cpp("misc/package.json"),
         ),
diff --git a/config.py b/config.py
index 8e323971..951e814f 100644
--- a/config.py
+++ b/config.py
@@ -1,5 +1,5 @@
 def can_build(env, platform):
-    return not platform == "android" and not platform == "mono"
+    return not (platform == "windows" and not env["use_mingw"])
 
 
 def configure(env):
diff --git a/doc_classes/JavaScript.xml b/doc_classes/JavaScript.xml
index 88bc9a12..ca3f4659 100644
--- a/doc_classes/JavaScript.xml
+++ b/doc_classes/JavaScript.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<class name="JavaScript" inherits="Script" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
+<class name="JavaScript" inherits="Script" version="4.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
 	<brief_description>
 		A JavaScript script resource for creating and managing JavaScript scripts in Godot.
 	</brief_description>
diff --git a/doc_classes/JavaScriptModule.xml b/doc_classes/JavaScriptModule.xml
index 878c6d1b..c9f1c7f9 100644
--- a/doc_classes/JavaScriptModule.xml
+++ b/doc_classes/JavaScriptModule.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<class name="JavaScriptModule" inherits="Resource" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../class.xsd">
+<class name="JavaScriptModule" inherits="Resource" version="4.1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../../../doc/class.xsd">
 	<brief_description>
 		A JavaScript module resource for managing JavaScript source code and bytecode.
 	</brief_description>
diff --git a/editor/editor_tools.h b/editor/editor_tools.h
deleted file mode 100644
index 6b38fcc8..00000000
--- a/editor/editor_tools.h
+++ /dev/null
@@ -1,72 +0,0 @@
-/**************************************************************************/
-/*  editor_tools.h                                                        */
-/**************************************************************************/
-/*                         This file is part of:                          */
-/*                             GODOT ENGINE                               */
-/*                        https://godotengine.org                         */
-/**************************************************************************/
-/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
-/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
-/*                                                                        */
-/* Permission is hereby granted, free of charge, to any person obtaining  */
-/* a copy of this software and associated documentation files (the        */
-/* "Software"), to deal in the Software without restriction, including    */
-/* without limitation the rights to use, copy, modify, merge, publish,    */
-/* distribute, sublicense, and/or sell copies of the Software, and to     */
-/* permit persons to whom the Software is furnished to do so, subject to  */
-/* the following conditions:                                              */
-/*                                                                        */
-/* The above copyright notice and this permission notice shall be         */
-/* included in all copies or substantial portions of the Software.        */
-/*                                                                        */
-/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
-/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
-/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
-/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
-/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
-/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
-/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
-/**************************************************************************/
-
-#ifndef EDITOR_TOOLS_H
-#define EDITOR_TOOLS_H
-
-#include "editor/editor_node.h"
-#include "editor/editor_plugin.h"
-#include "editor/gui/editor_file_dialog.h"
-
-class DocTools;
-class EditorFileDialog;
-class JavaScriptPlugin : public EditorPlugin {
-	GDCLASS(JavaScriptPlugin, EditorPlugin);
-
-	enum MenuItem {
-		ITEM_GEN_DECLARE_FILE,
-		ITEM_GEN_TYPESCRIPT_PROJECT,
-		ITEM_GEN_ENUM_BINDING_SCRIPT,
-	};
-
-	EditorFileDialog *declaration_file_dialog;
-	EditorFileDialog *enumberation_file_dialog;
-	const Dictionary *modified_api;
-
-protected:
-	static String BUILTIN_DECLARATION_TEXT;
-	static String TSCONFIG_CONTENT;
-	static String TS_DECORATORS_CONTENT;
-	static String PACKAGE_JSON_CONTENT;
-
-	static void _bind_methods();
-
-	void _notification(int p_what);
-	void _on_menu_item_pressed(int item);
-	void _export_typescript_declare_file(const String &p_path);
-	void _export_enumeration_binding_file(const String &p_path);
-	void _generate_typescript_project();
-
-public:
-	virtual String get_name() const override { return "JavaScriptPlugin"; }
-	JavaScriptPlugin(EditorNode *p_node);
-};
-
-#endif // EDITOR_TOOLS_H
diff --git a/javascript_language.cpp b/javascript_language.cpp
index 382f7740..ae69e781 100644
--- a/javascript_language.cpp
+++ b/javascript_language.cpp
@@ -33,7 +33,7 @@
 #include "core/object/class_db.h"
 
 #include "javascript_binder.h"
-#include "thirdparty/quickjs/quickjs_binder.h"
+#include "quickjs_binder.h"
 
 JavaScriptLanguage *JavaScriptLanguage::singleton = nullptr;
 
diff --git a/misc/godot.d.ts b/misc/godot.d.ts
index 5066a2b1..e4d3f8a2 100644
--- a/misc/godot.d.ts
+++ b/misc/godot.d.ts
@@ -56,7 +56,7 @@ declare module globalThis {
 	 *
 	 * Workers run in another global context that is different from the current context.
 	 *
-	 * You can run whatever code you like inside the worker thread. All of the godot API are available inside workers.
+	 * You can run whatever code you like inside the worker thread. All of the godot API are avaliable inside workers.
 	 *
 	 * Data is sent between workers and the main thread via a system of messages — both sides send their messages using the `postMessage()` method, and respond to messages via the `onmessage` event handler (the message is contained within the Message event's data attribute.) The data is copied rather than shared.
 	 *
diff --git a/quickjs/quickjs_callable.cpp b/quickjs/quickjs_callable.cpp
index 037fd5b2..9e7e59a1 100644
--- a/quickjs/quickjs_callable.cpp
+++ b/quickjs/quickjs_callable.cpp
@@ -32,6 +32,7 @@
 #include "../../quickjs_binder.h"
 #include "../javascript_language.h"
 #include "quickjs/quickjs.h"
+#include "../../quickjs_binder.h"
 
 bool QuickJSCallable::compare_equal(const CallableCustom *p_a, const CallableCustom *p_b) {
 	const QuickJSCallable *a = static_cast<const QuickJSCallable *>(p_a);
diff --git a/register_types.h b/register_types.h
index 885dc929..18785d49 100644
--- a/register_types.h
+++ b/register_types.h
@@ -28,11 +28,11 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
 /**************************************************************************/
 
-#ifndef REGISTER_TYPES_H
-#define REGISTER_TYPES_H
+#ifndef JAVASCRIPT_REGISTER_TYPES_H
+#define JAVASCRIPT_REGISTER_TYPES_H
 
 #include "modules/register_module_types.h"
 void initialize_javascript_module(ModuleInitializationLevel p_level);
 void uninitialize_javascript_module(ModuleInitializationLevel p_level);
 
-#endif // REGISTER_TYPES_H
+#endif // JAVASCRIPT_REGISTER_TYPES_H
diff --git a/tests/UnitTest.js.disabled b/tests/UnitTest.js.disabled
index 57773554..c9699d38 100644
--- a/tests/UnitTest.js.disabled
+++ b/tests/UnitTest.js.disabled
@@ -29,7 +29,7 @@ test('Object.prototype.connect', () => {
 
 	let obj = new godot.Object();
 	obj.connect('script_changed', (...args)=> {
-		console.log(`signal 'script_changed' emitted with:`, ...args);
+		console.log(`signal 'script_changed' emited with:`, ...args);
 		ok = true;
 	});
 	obj.emit_signal('script_changed', 123, 'hello');
@@ -39,19 +39,19 @@ test('Object.prototype.connect', () => {
 
 
 // --------------------------- Unit Test Implementation ------------------------
-function test(description, block, group = 'default') {
+function test(description, blcok, group = 'default') {
 	const entries = TEST_ENTRIES.get(group) || [];
-	entries.push({ description, block });
+	entries.push({ description, blcok });
 	TEST_ENTRIES.set(group, entries);
 }
 function runEntry(entry) {
 	return new Promise((resolve, reject) => {
-		switch (typeof (entry.block)) {
+		switch (typeof (entry.blcok)) {
 			case 'boolean':
-				return resolve(entry.block);
+				return resolve(entry.blcok);
 			case 'function': {
 				try {
-					resolve(entry.block());
+					resolve(entry.blcok());
 				} catch (error) {
 					console.error(error);
 					resolve(false);
@@ -59,8 +59,8 @@ function runEntry(entry) {
 			}
 			break;
 			case 'object':
-				if (entry.block instanceof Promise) {
-					entry.block.then(() => {
+				if (entry.blcok instanceof Promise) {
+					entry.blcok.then(() => {
 						resolve(true);
 					}).catch(err => {
 						resolve(false);
diff --git a/thirdparty/quickjs/quickjs/cutils.h b/thirdparty/quickjs/quickjs/cutils.h
index b0c7a262..09be07a9 100644
--- a/thirdparty/quickjs/quickjs/cutils.h
+++ b/thirdparty/quickjs/quickjs/cutils.h
@@ -31,7 +31,7 @@
 /* set if CPU is big endian */
 #undef WORDS_BIGENDIAN
 
-#if (defined(_MSC_VER) || !defined(__MINGW32__)) && !defined(LINUX_ENABLED) && !defined(MACOS_ENABLED)
+#if defined(_MSC_VER) || !defined(__MINGW32__)
 #define likely(x)       (x)
 #define unlikely(x)     (x)
 #define force_inline __forceinline
@@ -119,53 +119,6 @@ static inline int64_t min_int64(int64_t a, int64_t b)
         return b;
 }
 
-
-
-#ifdef _MSC_VER
-#include <intrin.h>
-
-static inline int __builtin_ctz(unsigned x)
-{
-    return (int)_tzcnt_u32(x);
-}
-
-static inline int __builtin_ctzll(unsigned long long x)
-{
-#ifdef _WIN64
-    return (int)_tzcnt_u64(x);
-#else
-    return !!unsigned(x) ? __builtin_ctz((unsigned)x) : 32 + __builtin_ctz((unsigned)(x >> 32));
-#endif
-}
-
-static inline int __builtin_ctzl(unsigned long x)
-{
-    return sizeof(x) == 8 ? __builtin_ctzll(x) : __builtin_ctz((unsigned)x);
-}
-
-static inline int __builtin_clz(unsigned x)
-{
-    return (int)_lzcnt_u32(x);
-}
-
-static inline int __builtin_clzll(unsigned long long x)
-{
-#ifdef _WIN64
-    return (int)_lzcnt_u64(x);
-#else
-    return !!unsigned(x >> 32) ? __builtin_clz((unsigned)(x >> 32)) : 32 + __builtin_clz((unsigned)x);
-#endif
-}
-
-static inline int __builtin_clzl(unsigned long x)
-{
-    return sizeof(x) == 8 ? __builtin_clzll(x) : __builtin_clz((unsigned)x);
-}
-#endif
-
-
-
-
 /* WARNING: undefined if a = 0 */
 static inline int clz32(unsigned int a)
 {
diff --git a/thirdparty/quickjs/quickjs/quickjs-debugger.c b/thirdparty/quickjs/quickjs/quickjs-debugger.c
index 6bffc4bc..f7557064 100644
--- a/thirdparty/quickjs/quickjs/quickjs-debugger.c
+++ b/thirdparty/quickjs/quickjs/quickjs-debugger.c
@@ -36,14 +36,12 @@ static int js_transport_write_fully(JSDebuggerInfo *info, const char *buffer, si
     return 1;
 }
 
-#define JS_TRANSPORT_WRITE_MESSAGE_NEWLINE_MESSAGE_LENGTH 10
-
 static int js_transport_write_message_newline(JSDebuggerInfo *info, const char* value, size_t len) {
     // length prefix is 8 hex followed by newline = 012345678\n
     // not efficient, but protocol is then human readable.
-    char message_length[JS_TRANSPORT_WRITE_MESSAGE_NEWLINE_MESSAGE_LENGTH];
+    char message_length[10];
     message_length[9] = '\0';
-    snprintf(message_length, JS_TRANSPORT_WRITE_MESSAGE_NEWLINE_MESSAGE_LENGTH, "%08x\n", (int)len + 1);
+    sprintf(message_length, "%08x\n", (int)len + 1);
     if (!js_transport_write_fully(info, message_length, 9))
         return 0;
     int ret = js_transport_write_fully(info, value, len);
@@ -146,7 +144,7 @@ static void js_debugger_get_variable_type(JSContext *ctx,
 
         JSObject *p = JS_VALUE_GET_OBJ(var_val);
         // todo: xor the the two dwords to get a better hash?
-        uintptr_t pl = (uintptr_t)p;
+        uint32_t pl = (uint32_t)p;
         JSValue found = JS_GetPropertyUint32(ctx, state->variable_pointers, pl);
         if (JS_IsUndefined(found)) {
             reference = state->variable_reference_count++;
diff --git a/thirdparty/quickjs/quickjs/quickjs.c b/thirdparty/quickjs/quickjs/quickjs.c
index 9a4a55ef..99b6be9e 100644
--- a/thirdparty/quickjs/quickjs/quickjs.c
+++ b/thirdparty/quickjs/quickjs/quickjs.c
@@ -28,13 +28,7 @@
 #include <inttypes.h>
 #include <string.h>
 #include <assert.h>
-#include <float.h>
-#if defined(_WIN32)
-// import struct timeval
-#include <winsock2.h>
-#else
 #include <sys/time.h>
-#endif
 #include <time.h>
 #include <fenv.h>
 #include <math.h>
@@ -57,7 +51,7 @@
 
 #define OPTIMIZE         1
 #define SHORT_OPCODES    1
-#if defined(EMSCRIPTEN) || defined(_MSC_VER)
+#if defined(EMSCRIPTEN)
 #define DIRECT_DISPATCH  0
 #else
 #define DIRECT_DISPATCH  1
@@ -76,7 +70,7 @@
 
 /* define to include Atomics.* operations which depend on the OS
    threads */
-#if !(defined(EMSCRIPTEN) || defined(_MSC_VER))
+#if !defined(EMSCRIPTEN)
 #define CONFIG_ATOMICS
 #endif
 
@@ -211,11 +205,7 @@ typedef enum JSErrorEnum {
 #define JS_STACK_SIZE_MAX 65536
 #define JS_STRING_LEN_MAX ((1 << 30) - 1)
 
-#if defined(_MSC_VER)
-#define __exception
-#else
 #define __exception __attribute__((warn_unused_result))
-#endif
 
 typedef struct JSShape JSShape;
 typedef struct JSString JSString;
@@ -1023,9 +1013,7 @@ static __exception int JS_ToArrayLengthFree(JSContext *ctx, uint32_t *plen,
                                             JSValue val);
 static JSValue JS_EvalObject(JSContext *ctx, JSValueConst this_obj,
                              JSValueConst val, int flags, int scope_idx);
-
-JSValue __js_printf_like(2, 3) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...);
-
+JSValue __attribute__((format(printf, 2, 3))) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...);
 static __maybe_unused void JS_DumpAtoms(JSRuntime *rt);
 static __maybe_unused void JS_DumpString(JSRuntime *rt,
                                                   const JSString *p);
@@ -6193,7 +6181,7 @@ void JS_DumpMemoryUsage(FILE *fp, const JSMemoryUsage *s, JSRuntime *rt)
             "BigNum "
 #endif
             "2020-09-06" " version, %d-bit, malloc limit: %"PRId64"\n\n",
-            (int)sizeof(void *) * 8, s->malloc_limit);
+            (int)sizeof(void *) * 8, (int64_t)(ssize_t)s->malloc_limit);
 #if 1
     if (rt) {
         static const struct {
@@ -6605,7 +6593,7 @@ static JSValue JS_ThrowError(JSContext *ctx, JSErrorEnum error_num,
     return JS_ThrowError2(ctx, error_num, fmt, ap, add_backtrace);
 }
 
-JSValue __js_printf_like(2, 3) JS_ThrowSyntaxError(JSContext *ctx, const char *fmt, ...)
+JSValue __attribute__((format(printf, 2, 3))) JS_ThrowSyntaxError(JSContext *ctx, const char *fmt, ...)
 {
     JSValue val;
     va_list ap;
@@ -6616,7 +6604,7 @@ JSValue __js_printf_like(2, 3) JS_ThrowSyntaxError(JSContext *ctx, const char *f
     return val;
 }
 
-JSValue __js_printf_like(2, 3) JS_ThrowTypeError(JSContext *ctx, const char *fmt, ...)
+JSValue __attribute__((format(printf, 2, 3))) JS_ThrowTypeError(JSContext *ctx, const char *fmt, ...)
 {
     JSValue val;
     va_list ap;
@@ -6627,7 +6615,7 @@ JSValue __js_printf_like(2, 3) JS_ThrowTypeError(JSContext *ctx, const char *fmt
     return val;
 }
 
-static int __js_printf_like(3, 4) JS_ThrowTypeErrorOrFalse(JSContext *ctx, int flags, const char *fmt, ...)
+static int __attribute__((format(printf, 3, 4))) JS_ThrowTypeErrorOrFalse(JSContext *ctx, int flags, const char *fmt, ...)
 {
     va_list ap;
 
@@ -6643,7 +6631,7 @@ static int __js_printf_like(3, 4) JS_ThrowTypeErrorOrFalse(JSContext *ctx, int f
 }
 
 /* never use it directly */
-static JSValue __js_printf_like(3, 4) __JS_ThrowTypeErrorAtom(JSContext *ctx, JSAtom atom, const char *fmt, ...)
+static JSValue __attribute__((format(printf, 3, 4))) __JS_ThrowTypeErrorAtom(JSContext *ctx, JSAtom atom, const char *fmt, ...)
 {
     char buf[ATOM_GET_STR_BUF_SIZE];
     return JS_ThrowTypeError(ctx, fmt,
@@ -6651,7 +6639,7 @@ static JSValue __js_printf_like(3, 4) __JS_ThrowTypeErrorAtom(JSContext *ctx, JS
 }
 
 /* never use it directly */
-static JSValue __js_printf_like(3, 4) __JS_ThrowSyntaxErrorAtom(JSContext *ctx, JSAtom atom, const char *fmt, ...)
+static JSValue __attribute__((format(printf, 3, 4))) __JS_ThrowSyntaxErrorAtom(JSContext *ctx, JSAtom atom, const char *fmt, ...)
 {
     char buf[ATOM_GET_STR_BUF_SIZE];
     return JS_ThrowSyntaxError(ctx, fmt,
@@ -6674,7 +6662,7 @@ static int JS_ThrowTypeErrorReadOnly(JSContext *ctx, int flags, JSAtom atom)
     }
 }
 
-JSValue __js_printf_like(2, 3) JS_ThrowReferenceError(JSContext *ctx, const char *fmt, ...)
+JSValue __attribute__((format(printf, 2, 3))) JS_ThrowReferenceError(JSContext *ctx, const char *fmt, ...)
 {
     JSValue val;
     va_list ap;
@@ -6685,7 +6673,7 @@ JSValue __js_printf_like(2, 3) JS_ThrowReferenceError(JSContext *ctx, const char
     return val;
 }
 
-JSValue __js_printf_like(2, 3) JS_ThrowRangeError(JSContext *ctx, const char *fmt, ...)
+JSValue __attribute__((format(printf, 2, 3))) JS_ThrowRangeError(JSContext *ctx, const char *fmt, ...)
 {
     JSValue val;
     va_list ap;
@@ -6696,7 +6684,7 @@ JSValue __js_printf_like(2, 3) JS_ThrowRangeError(JSContext *ctx, const char *fm
     return val;
 }
 
-JSValue __js_printf_like(2, 3) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...)
+JSValue __attribute__((format(printf, 2, 3))) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...)
 {
     JSValue val;
     va_list ap;
@@ -7221,7 +7209,7 @@ static int JS_DefinePrivateField(JSContext *ctx, JSValueConst obj,
         JS_ThrowTypeErrorNotASymbol(ctx);
         goto fail;
     }
-    prop = js_symbol_to_atom(ctx, name);
+    prop = js_symbol_to_atom(ctx, (JSValue)name);
     p = JS_VALUE_GET_OBJ(obj);
     prs = find_own_property(&pr, p, prop);
     if (prs) {
@@ -7252,7 +7240,7 @@ static JSValue JS_GetPrivateField(JSContext *ctx, JSValueConst obj,
     /* safety check */
     if (unlikely(JS_VALUE_GET_TAG(name) != JS_TAG_SYMBOL))
         return JS_ThrowTypeErrorNotASymbol(ctx);
-    prop = js_symbol_to_atom(ctx, name);
+    prop = js_symbol_to_atom(ctx, (JSValue)name);
     p = JS_VALUE_GET_OBJ(obj);
     prs = find_own_property(&pr, p, prop);
     if (!prs) {
@@ -7279,7 +7267,7 @@ static int JS_SetPrivateField(JSContext *ctx, JSValueConst obj,
         JS_ThrowTypeErrorNotASymbol(ctx);
         goto fail;
     }
-    prop = js_symbol_to_atom(ctx, name);
+    prop = js_symbol_to_atom(ctx, (JSValue)name);
     p = JS_VALUE_GET_OBJ(obj);
     prs = find_own_property(&pr, p, prop);
     if (!prs) {
@@ -7369,7 +7357,7 @@ static int JS_CheckBrand(JSContext *ctx, JSValueConst obj, JSValueConst func)
     if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
         goto not_obj;
     p = JS_VALUE_GET_OBJ(obj);
-    prs = find_own_property(&pr, p, js_symbol_to_atom(ctx, brand));
+    prs = find_own_property(&pr, p, js_symbol_to_atom(ctx, (JSValue)brand));
     if (!prs) {
         JS_ThrowTypeError(ctx, "invalid brand on object");
         return -1;
@@ -10204,7 +10192,7 @@ static JSValue js_atof(JSContext *ctx, const char *str, const char **pp,
             } else
 #endif
             {
-                double d = HUGE_VAL;
+                double d = 1.0 / 0.0;
                 if (is_neg)
                     d = -d;
                 val = JS_NewFloat64(ctx, d);
@@ -15959,7 +15947,7 @@ static JSValue js_call_c_function(JSContext *ctx, JSValueConst func_obj,
 #else
     sf->js_mode = 0;
 #endif
-    sf->cur_func = func_obj;
+    sf->cur_func = (JSValue)func_obj;
     sf->arg_count = argc;
     arg_buf = argv;
 
@@ -16223,7 +16211,7 @@ static JSValue JS_CallInternal(JSContext *caller_ctx, JSValueConst func_obj,
     sf->js_mode = b->js_mode;
     arg_buf = argv;
     sf->arg_count = argc;
-    sf->cur_func = func_obj;
+    sf->cur_func = (JSValue)func_obj;
     init_list_head(&sf->var_ref_list);
     var_refs = p->u.func.var_refs;
 
@@ -20188,7 +20176,7 @@ static void free_token(JSParseState *s, JSToken *token)
     }
 }
 
-static void __js_unused dump_token(JSParseState *s,
+static void __attribute((unused)) dump_token(JSParseState *s,
                                              const JSToken *token)
 {
     switch(token->val) {
@@ -20249,7 +20237,7 @@ static void __js_unused dump_token(JSParseState *s,
     }
 }
 
-int __js_printf_like(2, 3) js_parse_error(JSParseState *s, const char *fmt, ...)
+int __attribute__((format(printf, 2, 3))) js_parse_error(JSParseState *s, const char *fmt, ...)
 {
     JSContext *ctx = s->ctx;
     va_list ap;
@@ -34517,7 +34505,7 @@ typedef struct BCReaderState {
 } BCReaderState;
 
 #ifdef DUMP_READ_OBJECT
-static void __js_printf_like(2, 3) bc_read_trace(BCReaderState *s, const char *fmt, ...) {
+static void __attribute__((format(printf, 2, 3))) bc_read_trace(BCReaderState *s, const char *fmt, ...) {
     va_list ap;
     int i, n, n0;
 
@@ -38897,8 +38885,8 @@ static int64_t JS_FlattenIntoArray(JSContext *ctx, JSValueConst target,
         if (!JS_IsUndefined(mapperFunction)) {
             JSValueConst args[3] = { element, JS_NewInt64(ctx, sourceIndex), source };
             element = JS_Call(ctx, mapperFunction, thisArg, 3, args);
-            JS_FreeValue(ctx, args[0]);
-            JS_FreeValue(ctx, args[1]);
+            JS_FreeValue(ctx, (JSValue)args[0]);
+            JS_FreeValue(ctx, (JSValue)args[1]);
             if (JS_IsException(element))
                 return -1;
         }
@@ -40356,7 +40344,7 @@ static JSValue js_string_match(JSContext *ctx, JSValueConst this_val,
         str = JS_NewString(ctx, "g");
         if (JS_IsException(str))
             goto fail;
-        args[args_len++] = str;
+        args[args_len++] = (JSValueConst)str;
     }
     rx = JS_CallConstructor(ctx, ctx->regexp_ctor, args_len, args);
     JS_FreeValue(ctx, str);
@@ -41412,7 +41400,7 @@ static JSValue js_math_min_max(JSContext *ctx, JSValueConst this_val,
     uint32_t tag;
 
     if (unlikely(argc == 0)) {
-        return __JS_NewFloat64(ctx, is_max ? DBL_MAX : HUGE_VAL);
+        return __JS_NewFloat64(ctx, is_max ? -1.0 / 0.0 : 1.0 / 0.0);
     }
 
     tag = JS_VALUE_GET_TAG(argv[0]);
@@ -41652,30 +41640,6 @@ static JSValue js___date_now(JSContext *ctx, JSValueConst this_val,
 }
 #endif
 
-#if defined(_MSC_VER)
-int gettimeofday(struct timeval * tp, struct timezone * tzp)
-{
-    // Note: some broken versions only have 8 trailing zero's, the correct epoch has 9 trailing zero's
-    // This magic number is the number of 100 nanosecond intervals since January 1, 1601 (UTC)
-    // until 00:00:00 January 1, 1970
-    static const uint64_t EPOCH = ((uint64_t) 116444736000000000ULL);
-
-    SYSTEMTIME  system_time;
-    FILETIME    file_time;
-    uint64_t    time;
-
-    GetSystemTime( &system_time );
-    SystemTimeToFileTime( &system_time, &file_time );
-    time =  ((uint64_t)file_time.dwLowDateTime )      ;
-    time += ((uint64_t)file_time.dwHighDateTime) << 32;
-
-    tp->tv_sec  = (long) ((time - EPOCH) / 10000000L);
-    tp->tv_usec = (long) (system_time.wMilliseconds * 1000);
-    return 0;
-}
-#endif
-
-
 /* OS dependent: return the UTC time in microseconds since 1970. */
 static JSValue js___date_clock(JSContext *ctx, JSValueConst this_val,
                                int argc, JSValueConst *argv)
@@ -45401,7 +45365,7 @@ static JSMapRecord *map_add_record(JSContext *ctx, JSMapState *s,
     } else {
         JS_DupValue(ctx, key);
     }
-    mr->key = key;
+    mr->key = (JSValue)key;
     h = map_hash_key(ctx, key) & (s->hash_size - 1);
     list_add_tail(&mr->hash_link, &s->hash_table[h]);
     list_add_tail(&mr->link, &s->records);
@@ -45623,7 +45587,7 @@ static JSValue js_map_forEach(JSContext *ctx, JSValueConst this_val,
                 args[0] = args[1];
             else
                 args[0] = JS_DupValue(ctx, mr->value);
-            args[2] = this_val;
+            args[2] = (JSValue)this_val;
             ret = JS_Call(ctx, func, this_arg, 3, (JSValueConst *)args);
             JS_FreeValue(ctx, args[0]);
             if (!magic)
@@ -46601,7 +46565,7 @@ static JSValue js_promise_all(JSContext *ctx, JSValueConst this_val,
                 goto fail_reject;
             }
             resolve_element_data[0] = JS_NewBool(ctx, FALSE);
-            resolve_element_data[1] = JS_NewInt32(ctx, index);
+            resolve_element_data[1] = (JSValueConst)JS_NewInt32(ctx, index);
             resolve_element_data[2] = values;
             resolve_element_data[3] = resolving_funcs[is_promise_any];
             resolve_element_data[4] = resolve_element_env;
@@ -46971,7 +46935,7 @@ static JSValue js_async_from_sync_iterator_unwrap_func_create(JSContext *ctx,
 {
     JSValueConst func_data[1];
 
-    func_data[0] = JS_NewBool(ctx, done);
+    func_data[0] = (JSValueConst)JS_NewBool(ctx, done);
     return JS_NewCFunctionData(ctx, js_async_from_sync_iterator_unwrap,
                                1, 0, 1, func_data);
 }
@@ -47276,7 +47240,7 @@ static int isURIReserved(int c) {
     return c < 0x100 && memchr(";/?:@&=+$,#", c, sizeof(";/?:@&=+$,#") - 1) != NULL;
 }
 
-static int __js_printf_like(2, 3) js_throw_URIError(JSContext *ctx, const char *fmt, ...)
+static int __attribute__((format(printf, 2, 3))) js_throw_URIError(JSContext *ctx, const char *fmt, ...)
 {
     va_list ap;
 
@@ -52322,8 +52286,8 @@ static int js_TA_cmp_generic(const void *a, const void *b, void *opaque) {
             psc->exception = 1;
         }
     done:
-        JS_FreeValue(ctx, argv[0]);
-        JS_FreeValue(ctx, argv[1]);
+        JS_FreeValue(ctx, (JSValue)argv[0]);
+        JS_FreeValue(ctx, (JSValue)argv[1]);
     }
     return cmp;
 }
diff --git a/thirdparty/quickjs/quickjs/quickjs.h b/thirdparty/quickjs/quickjs/quickjs.h
index c77e3a1c..6d130152 100644
--- a/thirdparty/quickjs/quickjs/quickjs.h
+++ b/thirdparty/quickjs/quickjs/quickjs.h
@@ -43,13 +43,11 @@ extern "C" {
 #define js_unlikely(x)        __builtin_expect(!!(x), 0)
 #define js_force_inline       inline __attribute__((always_inline))
 #define __js_printf_like(f, a)   __attribute__((format(printf, f, a)))
-#define __js_unused __attribute((unused))
 #else
 #define js_likely(x)     (x)
 #define js_unlikely(x)   (x)
 #define js_force_inline  INLINE_FUNC
 #define __js_printf_like(a, b)
-#define __js_unused
 #endif
 
 #define JS_BOOL int
@@ -137,7 +135,7 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
 
 #elif defined(JS_NAN_BOXING)
 
-// typedef uint64_t JSValue;
+typedef uint64_t JSValue;
 
 #define JSValueConst JSValue
 
@@ -223,26 +221,8 @@ typedef struct JSValue {
 #define JS_VALUE_GET_FLOAT64(v) ((v).u.float64)
 #define JS_VALUE_GET_PTR(v) ((v).u.ptr)
 
-JSValue INLINE_FUNC _JS_MKVAL_INT32(int64_t tag, int32_t val) {
-	JSValue v;
-
-	v.u.int32 = val;
-	v.tag = tag;
-
-	return v;
-}
-
-JSValue INLINE_FUNC _JS_MKPTR(int64_t tag, void* ptr) {
-	JSValue v;
-
-	v.u.ptr = ptr;
-	v.tag = tag;
-
-	return v;
-}
-
-#define JS_MKVAL(tag, val) _JS_MKVAL_INT32(tag, val)
-#define JS_MKPTR(tag, p) _JS_MKPTR(tag, p)
+#define JS_MKVAL(tag, val) (JSValue){ (JSValueUnion){ .int32 = val }, tag }
+#define JS_MKPTR(tag, p) (JSValue){ (JSValueUnion){ .ptr = p }, tag }
 
 #define JS_TAG_IS_FLOAT64(tag) ((unsigned)(tag) == JS_TAG_FLOAT64)
 
@@ -688,7 +668,7 @@ static inline JSValue JS_DupValue(JSContext *ctx, JSValueConst v)
         JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
         p->ref_count++;
     }
-    return v;
+    return (JSValue)v;
 }
 
 static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
@@ -697,7 +677,7 @@ static inline JSValue JS_DupValueRT(JSRuntime *rt, JSValueConst v)
         JSRefCountHeader *p = (JSRefCountHeader *)JS_VALUE_GET_PTR(v);
         p->ref_count++;
     }
-    return v;
+    return (JSValue)v;
 }
 
 int JS_ToBool(JSContext *ctx, JSValueConst val); /* return -1 for JS_EXCEPTION */
diff --git a/thirdparty/quickjs/quickjs_binder.cpp b/thirdparty/quickjs/quickjs_binder.cpp
index 977bd858..518b7632 100644
--- a/thirdparty/quickjs/quickjs_binder.cpp
+++ b/thirdparty/quickjs/quickjs_binder.cpp
@@ -11,8 +11,9 @@
 #include "editor/editor_settings.h"
 #endif
 
-#include "../../javascript_instance.h"
-#include "../../javascript_language.h"
+#include "javascript.h"
+#include "javascript_instance.h"
+#include "javascript_language.h"
 #include "quickjs_binder.h"
 #include "quickjs_callable.h"
 #include "quickjs_worker.h"
@@ -686,7 +687,7 @@ JSModuleDef *QuickJSBinder::js_module_loader(JSContext *ctx, const char *module_
 			module.hash = hash_var.hash();
 			module.module = m;
 			module.res = res;
-			module.res->reference(); // Avoid auto release as module don't release automatically
+			module.res->reference(); // Avoid auto release as module don't release automaticly
 			module.res_value = val;
 			module.flags = MODULE_FLAG_RESOURCE;
 			module.module = m;
@@ -1100,7 +1101,7 @@ void QuickJSBinder::add_godot_globals() {
 		const int value = CoreConstants::get_global_constant_value(i);
 
 		JSAtom js_const_name = JS_NewAtom(ctx, const_name);
-		JS_DefinePropertyValue(ctx, godot_object, js_const_name, JS_NewInt64(ctx, value), QuickJSBinder::PROP_DEF_DEFAULT);
+		JS_DefinePropertyValue(ctx, godot_object, js_const_name, JS_MKVAL(JS_TAG_INT, value), QuickJSBinder::PROP_DEF_DEFAULT);
 		JS_FreeAtom(ctx, js_const_name);
 
 		if (HashMap<StringName, int64_t> *consts = global_constants.getptr(enum_name)) {
@@ -1280,7 +1281,7 @@ void QuickJSBinder::initialize() {
 		if (List<String>::Element *E = args.find("--js-debugger-connect")) {
 			if (E->next() && E->next()->get().find(":") != -1) {
 				String address = E->next()->get();
-				Error err = debugger->connect_debugger(ctx, address);
+				Error err = debugger->connect(ctx, address);
 				if (err != OK) {
 					ERR_PRINT(vformat("Failed to connect to JavaScript debugger at %s", address));
 				}
@@ -1485,9 +1486,7 @@ Error QuickJSBinder::safe_eval_text(const String &p_source, EvalType type, const
 	}
 	JSValue ret = JS_Eval(ctx, code, utf8_str.length(), filename, flags);
 	r_ret.context = ctx;
-	if (JS_VALUE_GET_TAG(ret) == JS_TAG_OBJECT) {
-		r_ret.javascript_object = JS_VALUE_GET_PTR(ret);
-	}
+	r_ret.javascript_object = JS_VALUE_GET_PTR(ret);
 	if (JS_IsException(ret)) {
 		JSValue e = JS_GetException(ctx);
 		JavaScriptError err;
diff --git a/thirdparty/quickjs/quickjs_binder.h b/thirdparty/quickjs/quickjs_binder.h
index 831e960c..1d003dd1 100644
--- a/thirdparty/quickjs/quickjs_binder.h
+++ b/thirdparty/quickjs/quickjs_binder.h
@@ -80,7 +80,7 @@ class QuickJSBinder : public JavaScriptBinder {
 
 	enum {
 		__JS_ATOM_NULL = JS_ATOM_NULL,
-#if !(defined(EMSCRIPTEN) || defined(_MSC_VER))
+#if !defined(EMSCRIPTEN)
 #define CONFIG_ATOMICS
 #endif
 #define DEF(name, str) JS_ATOM_##name,
diff --git a/thirdparty/quickjs/quickjs_builtin_binder.cpp b/thirdparty/quickjs/quickjs_builtin_binder.cpp
index d06e65e7..34aa19d8 100644
--- a/thirdparty/quickjs/quickjs_builtin_binder.cpp
+++ b/thirdparty/quickjs/quickjs_builtin_binder.cpp
@@ -5,6 +5,7 @@
 
 #include <cstring>
 
+#include "javascript_binder.h"
 #include "quickjs_binder.h"
 #include "quickjs_builtin_binder.h"
 
diff --git a/thirdparty/quickjs/quickjs_callable.cpp b/thirdparty/quickjs/quickjs_callable.cpp
index 99f7b825..07336d54 100644
--- a/thirdparty/quickjs/quickjs_callable.cpp
+++ b/thirdparty/quickjs/quickjs_callable.cpp
@@ -1,8 +1,9 @@
 #include "quickjs_callable.h"
+#include "javascript_language.h"
 #include "quickjs/quickjs.h"
+
 #include "quickjs_binder.h"
 #include "quickjs_builtin_binder.h"
-#include "../../javascript_language.h"
 
 bool QuickJSCallable::compare_equal(const CallableCustom *p_a, const CallableCustom *p_b) {
 	const QuickJSCallable *a = static_cast<const QuickJSCallable *>(p_a);
diff --git a/thirdparty/quickjs/quickjs_callable.h b/thirdparty/quickjs/quickjs_callable.h
index 7b2b2d55..48050cd2 100644
--- a/thirdparty/quickjs/quickjs_callable.h
+++ b/thirdparty/quickjs/quickjs_callable.h
@@ -1,9 +1,6 @@
 #ifndef QUICKJS_CALLABLE_H
 #define QUICKJS_CALLABLE_H
-
-#include "core/variant/callable.h"
-#include "../../javascript_callable.h"
-
+#include "javascript_callable.h"
 #include "quickjs/quickjs.h"
 
 #if !defined(JS_NAN_BOXING)
diff --git a/thirdparty/quickjs/quickjs_debugger.cpp b/thirdparty/quickjs/quickjs_debugger.cpp
index 366a31c6..36a54765 100644
--- a/thirdparty/quickjs/quickjs_debugger.cpp
+++ b/thirdparty/quickjs/quickjs_debugger.cpp
@@ -79,7 +79,7 @@ Error QuickJSDebugger::attach_js_debugger(JSContext *ctx, Ref<StreamPeerTCP> p_p
 	return ERR_CANT_CONNECT;
 }
 
-Error QuickJSDebugger::connect_debugger(JSContext *ctx, const String &address) {
+Error QuickJSDebugger::connect(JSContext *ctx, const String &address) {
 	this->ctx = ctx;
 	this->runtime = JS_GetRuntime(ctx);