@pizzapopcorn/unijs 0.0.6 → 0.0.7

package/dist/unity.js

@@ -4,897 +4,910 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Unity = factory());
 })(this, (function () { 'use strict';
 
-    class Transform {
-        
-        constructor(gameObject) {
-            this.gameObject = gameObject;
-        }
-
-        /**
-         * Gets the GameObject's world position.
-         * @returns {object}
-         */
-        get position() {
-            return this.#tryInvokeGameObjectEvent("transform.getPosition", "");
-        }
-
-        /**
-         * Sets the GameObject's world position.
-         * @param {object} value
-         */
-        set position(value) {
-            this.#assertVector3(value);
-            this.#tryInvokeGameObjectEvent("transform.setPosition", value);
-        }
-
-        /**
-         * Gets the GameObject's local position.
-         * @returns {object}
-         */
-        get localPosition() {
-            return this.#tryInvokeGameObjectEvent("transform.getLocalPosition", "");
-        }
-
-        /**
-         * Sets the GameObject's local position.
-         * @param {object} value
-         */
-        set localPosition(value) {
-            this.#assertVector3(value);
-            this.#tryInvokeGameObjectEvent("transform.setLocalPosition", value);
-        }
-
-        /**
-         * Gets the GameObject's local rotation.
-         * @returns {object}
-         */
-        get rotation() {
-            return this.#tryInvokeGameObjectEvent("transform.getRotation", "");
-        }
-
-        /**
-         * Sets the GameObject's local rotation.
-         * @param {object} value
-         */
-        set rotation(value) {
-            this.#assertQuaternion(value);
-            this.#tryInvokeGameObjectEvent("transform.setRotation", value);
-        }
-
-        /**
-         * Gets the GameObject's euler angles in degrees.
-         * @returns {object}
-         */
-        get eulerAngles() {
-            return this.#tryInvokeGameObjectEvent("transform.getEulerAngles", "");
-        }
-
-        /**
-         * Sets the GameObject's euler angles.
-         * @param {object} value
-         */
-        set eulerAngles(value) {
-            console.warn("[Unity] eulerAngles is read-only.");
-        }
-
-        /**
-         * Gets the GameObject's local scale.
-         * @returns {object}
-         */
-        get localScale() {
-            return this.#tryInvokeGameObjectEvent("transform.getLocalScale", "");
-        }
-
-        /**
-         * Sets the GameObject's local scale.
-         * @param {object} value
-         */
-        set localScale(value) {
-            this.#assertVector3(value);
-            this.#tryInvokeGameObjectEvent("transform.setLocalScale", value);
-        }
-
-        /**
-         * Gets the GameObject's lossy scale (Read Only).
-         * @returns {object}
-         */
-        get lossyScale() {
-            return this.#tryInvokeGameObjectEvent("transform.getLossyScale", "");
-        }
-
-        /**
-         * Sets the GameObject's lossy scale.
-         * @param {object} value
-         */
-        set lossyScale(value) {
-            console.warn("[Unity] lossyScale is read-only.");
-        }
-
-        /** 
-         * Translates the GameObject's position by the specified amount on each axis.
-         * @param {number} x
-         * @param {number} y
-         * @param {number} z
-         */
-        Translate(x, y, z) {
-            this.#tryInvokeGameObjectEvent("transform.translate", { x: x, y: y, z: z });
-        }
-
-        /**
-         * Rotates the GameObject around its local axis by the specified amount in degrees.
-         * @param {number} x
-         * @param {number} y
-         * @param {number} z
-         */
-        Rotate(x, y, z) {
-            this.#tryInvokeGameObjectEvent("transform.rotate", { x: x, y: y, z: z });
-        }
-
-        
-        #tryInvokeGameObjectEvent(eventName, payload) {
-            if(!this.gameObject) {
-                console.error("[Unity] The GameObject associated with this Transform is null");
-            }
-            return this.gameObject._invokeGameObjectEvent(eventName, payload);
-        }
-
-        #assertVector3(value) {
-            if (typeof value !== "object" || value === null || typeof value.x !== "number" || typeof value.y !== "number" || typeof value.z !== "number") {
-                throw new Error(`[Unity] Invalid Vector3: ${JSON.stringify(value)}`);
-            }
-        }
-
-        #assertQuaternion(value) {
-            if (typeof value !== "object" || value === null || typeof value.x !== "number" || typeof value.y !== "number" || typeof value.z !== "number" || typeof value.w !== "number") {
-                throw new Error(`[Unity] Invalid Quaternion: ${JSON.stringify(value)}`);
-            }
-        }
+    class Transform {
+        
+        constructor(gameObject) {
+            this.gameObject = gameObject;
+        }
+
+        /**
+         * Gets the GameObject's world position.
+         * @returns {object}
+         */
+        get position() {
+            return this.#tryInvokeGameObjectEvent("transform.getPosition", "");
+        }
+
+        /**
+         * Sets the GameObject's world position.
+         * @param {object} value
+         */
+        set position(value) {
+            this.#assertVector3(value);
+            this.#tryInvokeGameObjectEvent("transform.setPosition", value);
+        }
+
+        /**
+         * Gets the GameObject's local position.
+         * @returns {object}
+         */
+        get localPosition() {
+            return this.#tryInvokeGameObjectEvent("transform.getLocalPosition", "");
+        }
+
+        /**
+         * Sets the GameObject's local position.
+         * @param {object} value
+         */
+        set localPosition(value) {
+            this.#assertVector3(value);
+            this.#tryInvokeGameObjectEvent("transform.setLocalPosition", value);
+        }
+
+        /**
+         * Gets the GameObject's local rotation.
+         * @returns {object}
+         */
+        get rotation() {
+            return this.#tryInvokeGameObjectEvent("transform.getRotation", "");
+        }
+
+        /**
+         * Sets the GameObject's local rotation.
+         * @param {object} value
+         */
+        set rotation(value) {
+            this.#assertQuaternion(value);
+            this.#tryInvokeGameObjectEvent("transform.setRotation", value);
+        }
+
+        /**
+         * Gets the GameObject's euler angles in degrees.
+         * @returns {object}
+         */
+        get eulerAngles() {
+            return this.#tryInvokeGameObjectEvent("transform.getEulerAngles", "");
+        }
+
+        /**
+         * Sets the GameObject's euler angles.
+         * @param {object} value
+         */
+        set eulerAngles(value) {
+            console.warn("[Unity] eulerAngles is read-only.");
+        }
+
+        /**
+         * Gets the GameObject's local scale.
+         * @returns {object}
+         */
+        get localScale() {
+            return this.#tryInvokeGameObjectEvent("transform.getLocalScale", "");
+        }
+
+        /**
+         * Sets the GameObject's local scale.
+         * @param {object} value
+         */
+        set localScale(value) {
+            this.#assertVector3(value);
+            this.#tryInvokeGameObjectEvent("transform.setLocalScale", value);
+        }
+
+        /**
+         * Gets the GameObject's lossy scale (Read Only).
+         * @returns {object}
+         */
+        get lossyScale() {
+            return this.#tryInvokeGameObjectEvent("transform.getLossyScale", "");
+        }
+
+        /**
+         * Sets the GameObject's lossy scale.
+         * @param {object} value
+         */
+        set lossyScale(value) {
+            console.warn("[Unity] lossyScale is read-only.");
+        }
+
+        /** 
+         * Translates the GameObject's position by the specified amount on each axis.
+         * @param {number} x
+         * @param {number} y
+         * @param {number} z
+         */
+        Translate(x, y, z) {
+            this.#tryInvokeGameObjectEvent("transform.translate", { x: x, y: y, z: z });
+        }
+
+        /**
+         * Rotates the GameObject around its local axis by the specified amount in degrees.
+         * @param {number} x
+         * @param {number} y
+         * @param {number} z
+         */
+        Rotate(x, y, z) {
+            this.#tryInvokeGameObjectEvent("transform.rotate", { x: x, y: y, z: z });
+        }
+
+        
+        #tryInvokeGameObjectEvent(eventName, payload) {
+            if(!this.gameObject) {
+                console.error("[Unity] The GameObject associated with this Transform is null");
+            }
+            return this.gameObject._invokeGameObjectEvent(eventName, payload);
+        }
+
+        #assertVector3(value) {
+            if (typeof value !== "object" || value === null || typeof value.x !== "number" || typeof value.y !== "number" || typeof value.z !== "number") {
+                throw new Error(`[Unity] Invalid Vector3: ${JSON.stringify(value)}`);
+            }
+        }
+
+        #assertQuaternion(value) {
+            if (typeof value !== "object" || value === null || typeof value.x !== "number" || typeof value.y !== "number" || typeof value.z !== "number" || typeof value.w !== "number") {
+                throw new Error(`[Unity] Invalid Quaternion: ${JSON.stringify(value)}`);
+            }
+        }
     }
 
-    class Rigidbody {
-        
-        constructor(gameObject) {
-            this.gameObject = gameObject;
-        }
-
-        /**
-         * Gets the mass of the RigidBody.
-         * @returns {number}
-         */
-        get mass() {
-            return this.#tryInvokeGameObjectEvent("physics.getMass", "");
-        }
-
-        /**
-         * Gets whether the RigidBody is affected by gravity.
-         * @returns {boolean}
-         */
-        get useGravity() {
-            return this.#tryInvokeGameObjectEvent("physics.getUseGravity", "");
-        }
-
-        /**
-         * Gets whether the RigidBody is kinematic.
-         * @returns {boolean}
-         */
-        get isKinematic() {
-            return this.#tryInvokeGameObjectEvent("physics.getIsKinematic", "");
-        }
-
-        /**
-         * Gets the linear damping of the RigidBody.
-         * @returns {number}
-         */
-        get linearDamping() {
-            return this.#tryInvokeGameObjectEvent("physics.getLinearDamping", "");
-        }
-
-        /**
-         * Gets the angular damping of the RigidBody.
-         * @returns {number}
-         */
-        get angularDamping() {
-            return this.#tryInvokeGameObjectEvent("physics.getAngularDamping", "");
-        }
-
-        /**
-         * Adds a force to the RigidBody.
-         * @param {number} x
-         * @param {number} y
-         * @param {number} z
-         */
-        AddForce(x, y, z) {
-            this.#tryInvokeGameObjectEvent("physics.addForce", { x: x, y: y, z: z });
-        }
-
-        /**
-         * Adds a torque to the RigidBody.
-         * @param {number} x
-         * @param {number} y
-         * @param {number} z
-         */
-        AddTorque(x, y, z) {
-            this.#tryInvokeGameObjectEvent("physics.addTorque", { x: x, y: y, z: z });
-        }
-
-        /**
-         * Sets the linear velocity of the RigidBody.
-         * @param {number} x
-         * @param {number} y
-         * @param {number} z
-         */
-        SetVelocity(x, y, z) {
-            this.#tryInvokeGameObjectEvent("physics.setVelocity", { x: x, y: y, z: z });
-        }
-
-        /**
-         * Gets the linear velocity of the RigidBody.
-         * @returns {object}
-         */
-        GetVelocity() {
-            return this.#tryInvokeGameObjectEvent("physics.getVelocity", "");
-        }
-
-        /**
-         * Sets the angular velocity of the RigidBody.
-         * @param {number} x
-         * @param {number} y
-         * @param {number} z
-         */
-        SetAngularVelocity(x, y, z) {
-            this.#tryInvokeGameObjectEvent("physics.setAngularVelocity", { x: x, y: y, z: z });
-        }
-
-        /**
-         * Gets the angular velocity of the RigidBody.
-         * @returns {object}
-         */
-        GetAngularVelocity() {
-            return this.#tryInvokeGameObjectEvent("physics.getAngularVelocity", "");
-        }
-
-        /**
-         * Sets whether the RigidBody is affected by gravity.
-         * @param {boolean} useGravity
-         */
-        SetUseGravity(useGravity) {
-            this.#tryInvokeGameObjectEvent("physics.setUseGravity", useGravity);
-        }
-
-        /**
-         * Sets whether the RigidBody is kinematic.
-         * @param {boolean} isKinematic
-         */
-        SetIsKinematic(isKinematic) {
-            this.#tryInvokeGameObjectEvent("physics.setIsKinematic", isKinematic);
-        }
-
-        /**
-         * Sets the mass of the RigidBody.
-         * @param {number} mass
-         */
-        SetMass(mass) {
-            this.#tryInvokeGameObjectEvent("physics.setMass", mass);
-        }
-
-        /**
-         * Sets the linear damping of the RigidBody.
-         * @param {number} linearDamping
-         */
-        SetLinearDamping(linearDamping) {
-            this.#tryInvokeGameObjectEvent("physics.setLinearDamping", linearDamping);
-        }
-
-        #tryInvokeGameObjectEvent(eventName, payload) {
-            if(!this.gameObject) {
-                console.error("[Unity] The GameObject associated with this RigidBody is null");
-                return null;
-            }
-            return this.gameObject._invokeGameObjectEvent(eventName, payload);
-        }
+    class Rigidbody {
+        
+        constructor(gameObject) {
+            this.gameObject = gameObject;
+        }
+
+        /**
+         * Gets the mass of the RigidBody.
+         * @returns {number}
+         */
+        get mass() {
+            return this.#tryInvokeGameObjectEvent("physics.getMass", "");
+        }
+
+        /**
+         * Gets whether the RigidBody is affected by gravity.
+         * @returns {boolean}
+         */
+        get useGravity() {
+            return this.#tryInvokeGameObjectEvent("physics.getUseGravity", "");
+        }
+
+        /**
+         * Gets whether the RigidBody is kinematic.
+         * @returns {boolean}
+         */
+        get isKinematic() {
+            return this.#tryInvokeGameObjectEvent("physics.getIsKinematic", "");
+        }
+
+        /**
+         * Gets the linear damping of the RigidBody.
+         * @returns {number}
+         */
+        get linearDamping() {
+            return this.#tryInvokeGameObjectEvent("physics.getLinearDamping", "");
+        }
+
+        /**
+         * Gets the angular damping of the RigidBody.
+         * @returns {number}
+         */
+        get angularDamping() {
+            return this.#tryInvokeGameObjectEvent("physics.getAngularDamping", "");
+        }
+
+        /**
+         * Adds a force to the RigidBody.
+         * @param {number} x
+         * @param {number} y
+         * @param {number} z
+         */
+        AddForce(x, y, z) {
+            this.#tryInvokeGameObjectEvent("physics.addForce", { x: x, y: y, z: z });
+        }
+
+        /**
+         * Adds a torque to the RigidBody.
+         * @param {number} x
+         * @param {number} y
+         * @param {number} z
+         */
+        AddTorque(x, y, z) {
+            this.#tryInvokeGameObjectEvent("physics.addTorque", { x: x, y: y, z: z });
+        }
+
+        /**
+         * Sets the linear velocity of the RigidBody.
+         * @param {number} x
+         * @param {number} y
+         * @param {number} z
+         */
+        SetVelocity(x, y, z) {
+            this.#tryInvokeGameObjectEvent("physics.setVelocity", { x: x, y: y, z: z });
+        }
+
+        /**
+         * Gets the linear velocity of the RigidBody.
+         * @returns {object}
+         */
+        GetVelocity() {
+            return this.#tryInvokeGameObjectEvent("physics.getVelocity", "");
+        }
+
+        /**
+         * Sets the angular velocity of the RigidBody.
+         * @param {number} x
+         * @param {number} y
+         * @param {number} z
+         */
+        SetAngularVelocity(x, y, z) {
+            this.#tryInvokeGameObjectEvent("physics.setAngularVelocity", { x: x, y: y, z: z });
+        }
+
+        /**
+         * Gets the angular velocity of the RigidBody.
+         * @returns {object}
+         */
+        GetAngularVelocity() {
+            return this.#tryInvokeGameObjectEvent("physics.getAngularVelocity", "");
+        }
+
+        /**
+         * Sets whether the RigidBody is affected by gravity.
+         * @param {boolean} useGravity
+         */
+        SetUseGravity(useGravity) {
+            this.#tryInvokeGameObjectEvent("physics.setUseGravity", useGravity);
+        }
+
+        /**
+         * Sets whether the RigidBody is kinematic.
+         * @param {boolean} isKinematic
+         */
+        SetIsKinematic(isKinematic) {
+            this.#tryInvokeGameObjectEvent("physics.setIsKinematic", isKinematic);
+        }
+
+        /**
+         * Sets the mass of the RigidBody.
+         * @param {number} mass
+         */
+        SetMass(mass) {
+            this.#tryInvokeGameObjectEvent("physics.setMass", mass);
+        }
+
+        /**
+         * Sets the linear damping of the RigidBody.
+         * @param {number} linearDamping
+         */
+        SetLinearDamping(linearDamping) {
+            this.#tryInvokeGameObjectEvent("physics.setLinearDamping", linearDamping);
+        }
+
+        #tryInvokeGameObjectEvent(eventName, payload) {
+            if(!this.gameObject) {
+                console.error("[Unity] The GameObject associated with this RigidBody is null");
+                return null;
+            }
+            return this.gameObject._invokeGameObjectEvent(eventName, payload);
+        }
     }
 
-    class GameObject {
-        #transform = null;
-        #rigidbody = null;
-
-        static keyGameObjects = {};
-        static #lifeCycleCallbacks = {
-            awake: {},
-            start: {},
-            update: {},
-            enable: {},
-            disable: {},
-            destroy: {}
-        }
-
-        /**
-         * Gets a GameObject by its JS Key (previously set in Unity using the JSKeyGameObject component).
-         * @param {string} key
-         * @returns {GameObject | null}
-         * @constructor
-         */
-        static GetKeyGameObject(key){
-            if(!GameObject.keyGameObjects.hasOwnProperty(key)) {
-                console.error(`GameObject with key '${key}' not found`);
-                return null;
-            }
-            return GameObject.keyGameObjects[key];
-        }
-        
-        /**
-         * Instantiates a prefab at the specified position and rotation either in world space or relative to a parent GameObject.
-         * @param {string} prefabPath - The path to the prefab to instantiate from a Resources folder.
-         * @param {Object} position - The position to instantiate the prefab at (Defaults to Vector3.Zero).
-         * @param {Object} rotation - The rotation to instantiate the prefab with (Defaults to Quaternion.Identity).
-         * @param {GameObject | Transform | null} parent - The parent GameObject to instantiate the prefab relative to (Defaults to null).
-         */
-        static Instantiate(prefabPath, position = { x: 0, y: 0, z: 0 }, rotation = { x: 0, y: 0, z: 0, w: 1 }, parent = null) {
-            if(parent === null){
-                Unity.InvokeEvent("InstanceEvent:InstantiateGameObject", { prefabPath: prefabPath, position: position, rotation: rotation });
-            }
-            else {
-                const p = parent instanceof GameObject ? parent : parent instanceof Transform ? parent.gameObject : null;
-                if(p === null) return;
-                p.Instantiate(prefabPath, position, rotation);
-            }
-        }
-
-        /**
-         * Registers a callback for a GameObject's Awake event using its JS Key. If the GameObject doesn't exist yet, it will trigger when it's created.
-         * @param {string} key
-         * @param {function} callback
-         */
-        static onAwake(key, callback){
-            if(!GameObject.#lifeCycleCallbacks.awake.hasOwnProperty(key)) {
-                GameObject.#lifeCycleCallbacks.awake[key] = new Set();
-            }
-            GameObject.#lifeCycleCallbacks.awake[key].add(callback);
-        }
-
-        /**
-         * Registers a callback for a GameObject's Start event using its JS Key. If the GameObject doesn't exist yet, it will trigger when it's created.
-         * @param {string} key
-         * @param {function} callback
-         */
-        static onStart(key, callback) {
-            if(!GameObject.#lifeCycleCallbacks.start.hasOwnProperty(key)) {
-                GameObject.#lifeCycleCallbacks.start[key] = new Set();
-            }
-            GameObject.#lifeCycleCallbacks.start[key].add(callback);
-        }
-        
-        /**
-         * Registers a callback for a GameObject's Update event using its JS Key. If the GameObject doesn't exist yet, it will trigger when it's created.
-         * @param {string} key
-         * @param {function} callback
-         */
-        static onUpdate(key, callback) {
-            if(!GameObject.#lifeCycleCallbacks.update.hasOwnProperty(key)) {
-                GameObject.#lifeCycleCallbacks.update[key] = new Set();
-            }
-            GameObject.#lifeCycleCallbacks.update[key].add(callback);
-        }
-
-        /**
-         * Registers a callback for a GameObject's OnEnable event using its JS Key. If the GameObject doesn't exist yet, it will trigger when it's created.
-         * @param {string} key
-         * @param {function} callback
-         */
-        static onEnable(key, callback) {
-            if(!GameObject.#lifeCycleCallbacks.enable.hasOwnProperty(key)) {
-                GameObject.#lifeCycleCallbacks.enable[key] = new Set();
-            }
-            GameObject.#lifeCycleCallbacks.enable[key].add(callback);
-        }
-
-        /**
-         * Registers a callback for a GameObject's OnDisable event using its JS Key. If the GameObject doesn't exist yet, it will trigger when it's created and then disabled.
-         * @param {string} key
-         * @param {function} callback
-         */
-        static onDisable(key, callback) {
-            if(!GameObject.#lifeCycleCallbacks.disable.hasOwnProperty(key)) {
-                GameObject.#lifeCycleCallbacks.disable[key] = new Set();
-            }
-            GameObject.#lifeCycleCallbacks.disable[key].add(callback);
-        }
-
-        /**
-         * Registers a callback for a GameObject's Destroy event using its JS Key. If the GameObject doesn't exist yet, it will trigger when it's created and then destroyed.
-         * @param {string} key
-         * @param {function} callback
-         */
-        static onDestroy(key, callback) {
-            if(!GameObject.#lifeCycleCallbacks.destroy.hasOwnProperty(key)) {
-                GameObject.#lifeCycleCallbacks.destroy[key] = new Set();
-            }
-            GameObject.#lifeCycleCallbacks.destroy[key].add(callback);
-        }
-
-        /**Only for unity js library use*/
-        static _register(key, data) {
-            GameObject.keyGameObjects[key] = new GameObject(key, data);
-        }
-
-        /**Only for unity js library use*/
-        static _receiveLifeCycleEvent(key, event) {
-            const gameObject = GameObject.keyGameObjects[key];
-            if(!gameObject) return;
-
-            const callbacks = GameObject.#lifeCycleCallbacks[event][key];
-            if(callbacks) {
-                for(const callback of callbacks) {
-                    callback(gameObject);
-                }
-            }
-            if(event === "destroy") {
-                delete GameObject.keyGameObjects[key];
-            }
-        }
-
-        constructor(key, data) {
-            this.key = key;
-            this.name = data.name;
-            this.#transform = new Transform(this);
-            if(data.hasRigidbody) {
-                this.#rigidbody = new Rigidbody(this);
-            }
-            this.hierarchyPath = data.hasOwnProperty("hierarchyPath") ? data.hierarchyPath : "";
-        }
-        
-        /**
-         * Gets the Transform component of the GameObject.
-         * @returns {Transform}
-         */
-        get transform() {
-            return this.#transform;
-        }
-
-        /**
-         * Gets the RigidBody component of the GameObject.
-         * @returns {Rigidbody | null}
-         */
-        get rigidbody() {
-            if(this.HasComponent("Rigidbody")) {
-                this.#rigidbody = new Rigidbody(this);
-                return this.#rigidbody;
-            }
-            return null;
-        }
-
-        /** 
-         * Sets the GameObject's active state.
-         * @param {boolean} active
-         */
-        SetActive(active) {
-            this?._invokeGameObjectEvent("gameObject.setActive", active);
-        }
-
-        /**
-         * Invokes a method on the GameObject via SendMessage. Use GameObject.types for type options.
-         * <br>In order for it to work with custom types, you need to get the fully qualified name of the type.
-         * @param {string} methodName 
-         * @param {string} paramType 
-         * @param {string} paramValue 
-         */
-        InvokeMethod(methodName, paramType = "", paramValue = "") {
-            paramType = Unity.types[paramType] || paramType;
-            this?._invokeGameObjectEvent("gameObject.invokeMethod", { methodName: methodName, parameterType: paramType, parameterValue: paramValue });
-        }
-
-        /**
-         * Gets a child GameObject by index or name.
-         * @param {number | string} query 
-         * @returns {GameObject | null}
-         */
-        GetChild(query) {
-            const eventName = typeof query === "string" ? "gameObject.findChild" : "gameObject.getChild";
-            const childData = this?._invokeGameObjectEvent(eventName, query);
-            if(childData !== null) {
-                const currentPath = this.hierarchyPath === "" ? this.key : this.hierarchyPath;
-                childData.hierarchyPath = currentPath + "/" + childData.name;
-                return new GameObject(this.key, childData);
-            }
-            return null;
-        }
-
-        /**
-         * Looks for a text component and sets its text to the specified value. It works with Legacy, TextMeshPro, and TextMesh components.
-         * @param {string} text
-         */
-        SetText(text) {
-            this?._invokeGameObjectEvent("text.setText", text);
-        }
-
-        /**
-         * Destroys the GameObject.
-         */
-        Destroy() {
-            this?._invokeGameObjectEvent("gameObject.destroy", "");
-        }
-        
-        /**
-         * Instantiates a prefab at the specified position and rotation relative to this GameObject's transform.
-         * @param {string} prefabPath - The path to the prefab to instantiate from a Resources folder.
-         * @param {Object} position - The position to instantiate the prefab at (Defaults to Vector3.Zero).
-         * @param {Object} rotation - The rotation to instantiate the prefab with (Defaults to Quaternion.Identity).
-         */
-        Instantiate(prefabPath, position = { x: 0, y: 0, z: 0 }, rotation = { x: 0, y: 0, z: 0, w: 1 }) {
-            this?._invokeGameObjectEvent("gameObject.instantiate", { prefabPath: prefabPath, position: position, rotation: rotation });
-        }
-        
-        HasComponent(componentName) {
-            return this?._invokeGameObjectEvent("gameObject.hasComponent", componentName);
-        }
-        
-        GetComponent(componentName) {
-            return this?._invokeGameObjectEvent("gameObject.getComponent", componentName);
-        }
-        
-        AddComponent(componentName) {
-            return this?._invokeGameObjectEvent("gameObject.addComponent", componentName);
-        }
-
-        /**Only for internal library use*/
-        _invokeGameObjectEvent(eventName, payload) {
-            let payloadJson = payload;
-            if(typeof payload === "object") payloadJson = JSON.stringify(payload);
-            else if(typeof payload !== "string") payloadJson = payload.toString();
-            const eventPayload = { eventName: eventName, hierarchyPath: this.hierarchyPath, payloadJson: payloadJson, listenDisabled: true };
-            
-            const response = Unity.InvokeEvent(`GOEvent:${this.key}`, JSON.stringify(eventPayload));
-
-            if(Unity.internalLogs) console.log(`Invoked Event: GOEvent:${this.key}`, eventPayload);
-
-            if(response === null || !response.hasOwnProperty("ok")){
-                console.error(`Invalid JSON response from GameObject event callback: ${response}`);
-                return null;
-            }
-
-            if(response.ok) {
-                let responseObj = response.responseJson;
-                try {
-                    responseObj = JSON.parse(response.responseJson);
-                } catch {}
-                return responseObj;
-            }
-            console.error(`Error invoking GameObject event: ${eventName}`, response.error);
-            return null;
-        }
+    class GameObject {
+        #transform = null;
+        #rigidbody = null;
+        #rootInstance = null;
+
+        static keyGameObjects = {};
+        static #lifeCycleCallbacks = {
+            awake: {},
+            start: {},
+            update: {},
+            enable: {},
+            disable: {},
+            destroy: {}
+        }
+
+        /**
+         * Gets a GameObject by its JS Key (previously set in Unity using the JSKeyGameObject component).
+         * @param {string} key
+         * @returns {GameObject | null}
+         * @constructor
+         */
+        static GetKeyGameObject(key){
+            if(!GameObject.keyGameObjects.hasOwnProperty(key)) {
+                const data = Unity.InvokeEvent("InstanceEvent:GetKeyGameObject", key);
+                if(data) {
+                    GameObject.keyGameObjects[key] = new GameObject(key, data);
+                }
+                else {
+                    console.error(`GameObject with key '${key}' not found`);
+                    return null;
+                }
+            }
+            return GameObject.keyGameObjects[key];
+        }
+        
+        /**
+         * Instantiates a prefab at the specified position and rotation either in world space or relative to a parent GameObject.
+         * @param {string} prefabPath - The path to the prefab to instantiate from a Resources folder.
+         * @param {Object} position - The position to instantiate the prefab at (Defaults to Vector3.Zero).
+         * @param {Object} rotation - The rotation to instantiate the prefab with (Defaults to Quaternion.Identity).
+         * @param {GameObject | Transform | null} parent - The parent GameObject to instantiate the prefab relative to (Defaults to null).
+         */
+        static Instantiate(prefabPath, position = { x: 0, y: 0, z: 0 }, rotation = { x: 0, y: 0, z: 0, w: 1 }, parent = null) {
+            if(parent === null){
+                Unity.InvokeEvent("InstanceEvent:InstantiateGameObject", { prefabPath: prefabPath, position: position, rotation: rotation });
+            }
+            else {
+                const p = parent instanceof GameObject ? parent : parent instanceof Transform ? parent.gameObject : null;
+                if(p === null) return;
+                p.Instantiate(prefabPath, position, rotation);
+            }
+        }
+
+        /**
+         * Registers a callback for a GameObject's Awake event using its JS Key. If the GameObject doesn't exist yet, it will trigger when it's created.
+         * @param {string} key
+         * @param {function} callback
+         */
+        static onAwake(key, callback){
+            if(!GameObject.#lifeCycleCallbacks.awake.hasOwnProperty(key)) {
+                GameObject.#lifeCycleCallbacks.awake[key] = new Set();
+            }
+            GameObject.#lifeCycleCallbacks.awake[key].add(callback);
+        }
+
+        /**
+         * Registers a callback for a GameObject's Start event using its JS Key. If the GameObject doesn't exist yet, it will trigger when it's created.
+         * @param {string} key
+         * @param {function} callback
+         */
+        static onStart(key, callback) {
+            if(!GameObject.#lifeCycleCallbacks.start.hasOwnProperty(key)) {
+                GameObject.#lifeCycleCallbacks.start[key] = new Set();
+            }
+            GameObject.#lifeCycleCallbacks.start[key].add(callback);
+        }
+        
+        /**
+         * Registers a callback for a GameObject's Update event using its JS Key. If the GameObject doesn't exist yet, it will trigger when it's created.
+         * @param {string} key
+         * @param {function} callback
+         */
+        static onUpdate(key, callback) {
+            if(!GameObject.#lifeCycleCallbacks.update.hasOwnProperty(key)) {
+                GameObject.#lifeCycleCallbacks.update[key] = new Set();
+            }
+            GameObject.#lifeCycleCallbacks.update[key].add(callback);
+        }
+
+        /**
+         * Registers a callback for a GameObject's OnEnable event using its JS Key. If the GameObject doesn't exist yet, it will trigger when it's created.
+         * @param {string} key
+         * @param {function} callback
+         */
+        static onEnable(key, callback) {
+            if(!GameObject.#lifeCycleCallbacks.enable.hasOwnProperty(key)) {
+                GameObject.#lifeCycleCallbacks.enable[key] = new Set();
+            }
+            GameObject.#lifeCycleCallbacks.enable[key].add(callback);
+        }
+
+        /**
+         * Registers a callback for a GameObject's OnDisable event using its JS Key. If the GameObject doesn't exist yet, it will trigger when it's created and then disabled.
+         * @param {string} key
+         * @param {function} callback
+         */
+        static onDisable(key, callback) {
+            if(!GameObject.#lifeCycleCallbacks.disable.hasOwnProperty(key)) {
+                GameObject.#lifeCycleCallbacks.disable[key] = new Set();
+            }
+            GameObject.#lifeCycleCallbacks.disable[key].add(callback);
+        }
+
+        /**
+         * Registers a callback for a GameObject's Destroy event using its JS Key. If the GameObject doesn't exist yet, it will trigger when it's created and then destroyed.
+         * @param {string} key
+         * @param {function} callback
+         */
+        static onDestroy(key, callback) {
+            if(!GameObject.#lifeCycleCallbacks.destroy.hasOwnProperty(key)) {
+                GameObject.#lifeCycleCallbacks.destroy[key] = new Set();
+            }
+            GameObject.#lifeCycleCallbacks.destroy[key].add(callback);
+        }
+
+        /**Only for unity js library use*/
+        static _register(key, data) {
+            GameObject.keyGameObjects[key] = new GameObject(key, data);
+        }
+
+        /**Only for unity js library use*/
+        static _receiveLifeCycleEvent(key, event) {
+            const gameObject = GameObject.keyGameObjects[key];
+            if(!gameObject) return;
+
+            const callbacks = GameObject.#lifeCycleCallbacks[event][key];
+            if(callbacks) {
+                for(const callback of callbacks) {
+                    callback(gameObject);
+                }
+            }
+            if(event === "destroy") {
+                delete GameObject.keyGameObjects[key];
+            }
+        }
+
+        constructor(key, data, root = null) {
+            this.key = key;
+            this.name = data.name;
+            this.#rootInstance = root || this;
+            this.#transform = new Transform(this);
+            if(data.hasRigidbody) {
+                this.#rigidbody = new Rigidbody(this);
+            }
+            this.hierarchyPath = data.hasOwnProperty("hierarchyPath") ? data.hierarchyPath : "";
+        }
+        
+        /**
+         * Gets the Transform component of the GameObject.
+         * @returns {Transform}
+         */
+        get transform() {
+            return this.#transform;
+        }
+
+        /**
+         * Gets the RigidBody component of the GameObject.
+         * @returns {Rigidbody | null}
+         */
+        get rigidbody() {
+            if(this.HasComponent("Rigidbody")) {
+                this.#rigidbody = new Rigidbody(this);
+                return this.#rigidbody;
+            }
+            return null;
+        }
+
+        /** 
+         * Sets the GameObject's active state.
+         * @param {boolean} active
+         */
+        SetActive(active) {
+            this?._invokeGameObjectEvent("gameObject.setActive", active);
+        }
+
+        /**
+         * Invokes a method on the GameObject via SendMessage. Use GameObject.types for type options.
+         * <br>In order for it to work with custom types, you need to get the fully qualified name of the type.
+         * @param {string} methodName 
+         * @param {string} paramType 
+         * @param {string} paramValue 
+         */
+        InvokeMethod(methodName, paramType = "", paramValue = "") {
+            paramType = Unity.types[paramType] || paramType;
+            this?._invokeGameObjectEvent("gameObject.invokeMethod", { methodName: methodName, parameterType: paramType, parameterValue: paramValue });
+        }
+
+        /**
+         * Gets a child GameObject by index or name.
+         * @param {number | string} query 
+         * @returns {GameObject | null}
+         */
+        GetChild(query) {
+            const eventName = typeof query === "string" ? "gameObject.findChild" : "gameObject.getChild";
+            const childData = this?._invokeGameObjectEvent(eventName, query);
+            if(childData !== null) {
+                const currentPath = this.hierarchyPath === "" ? this.key : this.hierarchyPath;
+                childData.hierarchyPath = currentPath + "/" + childData.name;
+                return new GameObject(this.key, childData, this.#rootInstance);
+            }
+            return null;
+        }
+
+        /**
+         * Looks for a text component and sets its text to the specified value. It works with Legacy, TextMeshPro, and TextMesh components.
+         * @param {string} text
+         */
+        SetText(text) {
+            this?._invokeGameObjectEvent("text.setText", text);
+        }
+
+        /**
+         * Destroys the GameObject.
+         */
+        Destroy() {
+            this?._invokeGameObjectEvent("gameObject.destroy", "");
+        }
+        
+        /**
+         * Instantiates a prefab at the specified position and rotation relative to this GameObject's transform.
+         * @param {string} prefabPath - The path to the prefab to instantiate from a Resources folder.
+         * @param {Object} position - The position to instantiate the prefab at (Defaults to Vector3.Zero).
+         * @param {Object} rotation - The rotation to instantiate the prefab with (Defaults to Quaternion.Identity).
+         */
+        Instantiate(prefabPath, position = { x: 0, y: 0, z: 0 }, rotation = { x: 0, y: 0, z: 0, w: 1 }) {
+            this?._invokeGameObjectEvent("gameObject.instantiate", { prefabPath: prefabPath, position: position, rotation: rotation });
+        }
+        
+        HasComponent(componentName) {
+            return this?._invokeGameObjectEvent("gameObject.hasComponent", componentName);
+        }
+        
+        GetComponent(componentName) {
+            return this?._invokeGameObjectEvent("gameObject.getComponent", componentName);
+        }
+        
+        AddComponent(componentName) {
+            return this?._invokeGameObjectEvent("gameObject.addComponent", componentName);
+        }
+
+        /**Only for internal library use*/
+        _invokeGameObjectEvent(eventName, payload) {
+            if(GameObject.keyGameObjects[this.key] !== this.#rootInstance) {
+                console.error(`Attempted to invoke event '${eventName}' on a stale GameObject reference (Key: ${this.key}, Path: ${this.hierarchyPath}). This object has been destroyed or replaced.`);
+                return null;
+            }
+
+            let payloadJson = payload;
+            if(typeof payload === "object") payloadJson = JSON.stringify(payload);
+            else if(typeof payload !== "string") payloadJson = payload.toString();
+            const eventPayload = { eventName: eventName, hierarchyPath: this.hierarchyPath, payloadJson: payloadJson, listenDisabled: true };
+            
+            const response = Unity.InvokeEvent(`GOEvent:${this.key}`, JSON.stringify(eventPayload));
+
+            if(Unity.internalLogs) console.log(`Invoked Event: GOEvent:${this.key}`, eventPayload);
+
+            if(response === null || !response.hasOwnProperty("ok")){
+                console.error(`Invalid JSON response from GameObject event callback: ${response}`);
+                return null;
+            }
+
+            if(response.ok) {
+                let responseObj = response.responseJson;
+                try {
+                    responseObj = JSON.parse(response.responseJson);
+                } catch {}
+                return responseObj;
+            }
+            console.error(`Error invoking GameObject event: ${eventName}`, response.error);
+            return null;
+        }
     }
 
-    class Time {
-        /**
-         * Current time in seconds.
-         * @returns {number}
-         */
-        static get time() {
-            return Unity.InvokeEvent("InstanceEvent:GetTime");
-        }
-        
-        /**
-         * The time since the last frame in seconds.
-         * @returns {number}
-         */
-        static get deltaTime() {
-            return Unity.InvokeEvent("InstanceEvent:GetDeltaTime");
-        }
-        
-        /**
-         * The interval in seconds of in-game time at which physics and other fixed frame rate updates (like MonoBehaviour's MonoBehaviour.FixedUpdate) are performed.
-         * @returns {number}
-         */
-        static get fixedDeltaTime() {
-            return Unity.InvokeEvent("InstanceEvent:GetFixedDeltaTime");
-        }
-        
-        /**
-         * The timeScale-independent interval in seconds from the last frame to the current one
-         * @returns {number}
-         */
-        static get unscaledDeltaTime() {
-            return Unity.InvokeEvent("InstanceEvent:GetUnscaledDeltaTime");
-        }
-        
-        /**
-         * The real time in seconds since Unity started running.
-         * @returns {number}
-         */
-        static get realtimeSinceStartup() {
-            return Unity.InvokeEvent("InstanceEvent:GetRealtimeSinceStartup");
-        }
-        
-        /**
-         * The scale at which time passes.
-         * @returns {number}
-         */
-        static get timeScale() {
-            return Unity.InvokeEvent("InstanceEvent:GetTimeScale");
-        }
-        
-        static set timeScale(value) {
-            Unity.InvokeEvent("InstanceEvent:SetTimeScale", value);
-        }
+    class Time {
+        /**
+         * Current time in seconds.
+         * @returns {number}
+         */
+        static get time() {
+            return Unity.InvokeEvent("InstanceEvent:GetTime");
+        }
+        
+        /**
+         * The time since the last frame in seconds.
+         * @returns {number}
+         */
+        static get deltaTime() {
+            return Unity.InvokeEvent("InstanceEvent:GetDeltaTime");
+        }
+        
+        /**
+         * The interval in seconds of in-game time at which physics and other fixed frame rate updates (like MonoBehaviour's MonoBehaviour.FixedUpdate) are performed.
+         * @returns {number}
+         */
+        static get fixedDeltaTime() {
+            return Unity.InvokeEvent("InstanceEvent:GetFixedDeltaTime");
+        }
+        
+        /**
+         * The timeScale-independent interval in seconds from the last frame to the current one
+         * @returns {number}
+         */
+        static get unscaledDeltaTime() {
+            return Unity.InvokeEvent("InstanceEvent:GetUnscaledDeltaTime");
+        }
+        
+        /**
+         * The real time in seconds since Unity started running.
+         * @returns {number}
+         */
+        static get realtimeSinceStartup() {
+            return Unity.InvokeEvent("InstanceEvent:GetRealtimeSinceStartup");
+        }
+        
+        /**
+         * The scale at which time passes.
+         * @returns {number}
+         */
+        static get timeScale() {
+            return Unity.InvokeEvent("InstanceEvent:GetTimeScale");
+        }
+        
+        static set timeScale(value) {
+            Unity.InvokeEvent("InstanceEvent:SetTimeScale", value);
+        }
     }
 
-    let Unity$1 = class Unity {
-        /** @type {typeof GameObject} */
-        static GameObject = GameObject;
-        /** @type {typeof Time} */
-        static Time = Time;
-        static internalLogs = false;
-        static types = {
-            int: "System.Int32",
-            float: "System.Single",
-            double: "System.Double",
-            bool: "System.Boolean",
-            string: "System.String",
-            char: "System.Char",
-            byte: "System.Byte",
-            long: "System.Int64",
-            short: "System.Int16",
-            decimal: "System.Decimal",
-            object: "System.Object",
-            customClass: (className, namespace = "", assembly = "Assembly-CSharp") => {
-                const qualifiedName = namespace === "" ? className : `${namespace}.${className}`;
-                return `${qualifiedName}, ${assembly}.dll`;
-            },
-        };
-
-        static #clientEventCallback;
-        static #instanceReady = false;
-        static #onInstanceReadyListeners = new Set();
-        static #onEventListeners = {};
-
-        /**
-         * Loads the Unity canvas from the specified URL and injects it into the specified element.
-         * @param {string} url 
-         * @param {string} elementId 
-         */
-        static LoadInstance(url, elementId) {
-            Unity.#instanceReady = false;
-            const r = new XMLHttpRequest();
-            r.open("GET", url + "/index.html", true);
-            r.onreadystatechange = function () {
-                if (r.readyState !== 4 || r.status !== 200) return;
-                document.querySelector(`#${elementId}`).innerHTML = r.responseText;
-
-                const link = document.createElement('link');
-
-                link.rel = 'stylesheet';
-                link.type = 'text/css';
-                link.href = url + "/TemplateData/style.css";
-                document.head.appendChild(link);
-
-                const indexScript = document.createElement("script");
-                indexScript.src = url + "/index.js";
-                document.body.appendChild(indexScript);
-            };
-            r.send();
-        }
-
-        /**
-         * Gets the current Unity version.
-         * @returns {string}
-         */
-        static GetVersion() {
-            return Unity.InvokeEvent("InstanceEvent:GetUnityVersion");
-        }
-        
-        /**
-         * Gets the current build version.
-         * @returns {string}
-         */
-        static GetBuildVersion() {
-            return Unity.InvokeEvent("InstanceEvent:GetBuildVersion");
-        }
-
-        /**
-         * Invokes a global event that can be listened to by both Unity and JS.
-         * An optional payload can be sent, and the event can also return anything.
-         * @param {string} eventName
-         * @param {any} payload
-         * @returns {any}
-         */
-        static InvokeEvent(eventName, payload = undefined) {
-            const responseJson = Unity.#invokeEventInternal(eventName, payload);
-            try {
-                const response = JSON.parse(responseJson);
-                if(response.hasOwnProperty("promiseId")){
-                    console.warn(`Event '${eventName}' returned a promise. Consider using InvokeEventAsync instead.`);
-                    Unity.onEvent(`PromiseResolvedEvent:${response.promiseId}`, payload => {
-                        delete Unity.#onEventListeners[`PromiseResolvedEvent:${response.promiseId}`];
-                    });
-                }
-                return response;
-            }
-            catch {
-                return responseJson;
-            }
-        }
-
-        /**
-         * Async version of InvokeEvent. Invokes a global async event that can be listened to by both Unity and JS.
-         * An optional payload can be sent, and the event can also return anything.
-         * @param {string} eventName
-         * @param {any} payload
-         * @returns {Promise<any>}
-         */
-        static async InvokeEventAsync(eventName, payload = undefined) {
-            return new Promise(resolve => {
-                const responseJson = Unity.#invokeEventInternal(eventName, payload);
-                try {
-                    const response = JSON.parse(responseJson);
-                    if(response.hasOwnProperty("promiseId")){
-                        Unity.onEvent(`PromiseResolvedEvent:${response.promiseId}`, payload => {
-                            resolve(payload);
-                            delete Unity.#onEventListeners[`PromiseResolvedEvent:${response.promiseId}`];
-                        });
-                    }
-                    else {
-                        resolve(response);
-                    }
-                } catch {
-                    resolve(responseJson);
-                }
-            })
-        }
-
-        /**
-         * Awaits the Unity WaitForEndOfFrame coroutine.
-         * @returns {Promise<void>}
-         */
-        static async WaitForEndOfFrameAsync() {
-            return new Promise((resolve) => {
-                const eventId = crypto.randomUUID().toString();
-                const eventName = `EndOfFrameEvent:${eventId}`;
-
-                Unity.onEvent(eventName, () => {
-                    resolve();
-                    delete Unity.#onEventListeners[eventName];
-                });
-
-                Unity.InvokeEvent("InstanceEvent:WaitForEndOfFrame", eventId);
-            });
-        }
-
-        /**
-         * Loads a scene and awaits its completion.
-         * @param {string} sceneName
-         * @returns {Promise<void>}
-         */
-        static async LoadSceneAsync(sceneName) {
-            return new Promise((resolve) => {
-                const eventName = `SceneLoadedEvent:${sceneName}`;
-                Unity.onEvent(eventName, () => {
-                    resolve();
-                    delete Unity.#onEventListeners[eventName];
-                });
-                
-                Unity.InvokeEvent("InstanceEvent:LoadScene", sceneName);
-            });
-        }
-
-        /**
-         * Returns true if a scene is currently loading.
-         * @returns {boolean}
-         */
-        static IsSceneLoading() {
-            return Unity.InvokeEvent("InstanceEvent:IsSceneLoading");
-        }
-
-        /**
-         * Returns the current scene load progress. If no scene is currently loading, it returns 0.
-         * @returns {number}
-         */
-        static GetSceneLoadProgress() {
-            return Unity.InvokeEvent("InstanceEvent:GetSceneLoadProgress");
-        }
-
-        /**
-         * Loads an asset bundle from the provided URL and awaits its completion.
-         * @param {string} bundleUrl
-         * @returns {Promise<void>}
-         */
-        static async LoadBundleAsync(bundleUrl) {
-            await Unity.InvokeEventAsync("InstanceEvent:LoadBundle", bundleUrl);
-        }
-
-        /**
-         * This function loads the bundle, instantiates a prefab from it, and then unloads the bundle so you don't have to handle it manually.
-         * An optional parent JS Key can be provided to place the instantiated prefab under a specific GameObject.
-         * @param {string} bundleUrl
-         * @param {string} prefabName
-         * @param {string} parentKey
-         * @returns {Promise<void>}
-         */
-        static async InstantiatePrefabFromBundleAsync(bundleUrl, prefabName, parentKey = "") {
-            await Unity.InvokeEventAsync("InstanceEvent:InstantiatePrefabFromBundle", {
-                bundleUrl: bundleUrl,
-                prefabName: prefabName,
-                parentKey: parentKey
-            });
-        }
-
-        // Listeners -----------------------------
-
-        /**
-         * Registers a callback that will be invoked when the Unity instance is ready.
-         * @param {function} callback
-         */
-        static onInstanceReady(callback) {
-            if(!Unity.#instanceReady) {
-                Unity.#onInstanceReadyListeners.add(callback);
-            }
-            else {
-                callback();
-            }
-        }
-
-        /**
-         * Registers a callback that will be invoked when a global event is received. It can listen to events from both Unity and JS.
-         * @param {string} eventName
-         * @param {function} callback
-         */
-        static onEvent(eventName, callback) {
-            if(!Unity.#onEventListeners.hasOwnProperty(eventName)) {
-                Unity.#onEventListeners[eventName] = new Set();
-            }
-            Unity.#onEventListeners[eventName].add(callback);
-        }
-
-        /**
-         * Unregisters a callback previously registered with onEvent.
-         * @param {string} eventName
-         * @param {function} callback
-         */
-        static offEvent(eventName, callback) {
-            if(!Unity.#onEventListeners.hasOwnProperty(eventName)) return;
-            Unity.#onEventListeners[eventName].delete(callback);
-        }
-
-        static #invokeEventInternal(eventName, payload) {
-            if(payload === undefined || payload === null) payload = "";
-            let payloadJson = payload;
-            if(typeof payload === "object") payloadJson = JSON.stringify(payload);
-            else if(typeof payload !== "string") payloadJson = payload.toString();
-            const responseJson = Unity.#clientEventCallback(eventName, payloadJson);
-            Unity.#onEventListeners[eventName]?.forEach(callback => callback(payloadJson));
-            return responseJson;
-        }
-
-        // JSLib usage -----------------------------
-
-        /**Only for unity js library use*/
-        static _instanceReady() {
-            Unity.#instanceReady = true;
-            Unity.#onInstanceReadyListeners.forEach(callback => callback());
-        }
-
-        /**Only for unity js library use*/
-        static _registerClientListener(callback) {
-            Unity.#clientEventCallback = callback;
-        }
-
-        /**Only for unity js library use*/
-        static _receiveEvent(eventName, payloadJson) {
-            let payload = payloadJson;
-            try {
-                payload = JSON.parse(payloadJson);
-            } catch {}
-
-            Unity.InvokeEvent(eventName, payload);
-        }
-
-        /**Only for unity js library use*/
-        static _logFromUnity(verbosity, message) {
-            if(verbosity === "internal" && !Unity.internalLogs) return;
-            if(verbosity === "error") console.error(`[Unity] ${message}`);
-            else if(verbosity === "warning") console.warn(`[Unity] ${message}`);
-            else console.log(`[Unity] ${message}`);
-        }
-
+    let Unity$1 = class Unity {
+        /** @type {typeof GameObject} */
+        static GameObject = GameObject;
+        /** @type {typeof Time} */
+        static Time = Time;
+        static internalLogs = false;
+        static types = {
+            int: "System.Int32",
+            float: "System.Single",
+            double: "System.Double",
+            bool: "System.Boolean",
+            string: "System.String",
+            char: "System.Char",
+            byte: "System.Byte",
+            long: "System.Int64",
+            short: "System.Int16",
+            decimal: "System.Decimal",
+            object: "System.Object",
+            customClass: (className, namespace = "", assembly = "Assembly-CSharp") => {
+                const qualifiedName = namespace === "" ? className : `${namespace}.${className}`;
+                return `${qualifiedName}, ${assembly}.dll`;
+            },
+        };
+
+        static #clientEventCallback;
+        static #instanceReady = false;
+        static #onInstanceReadyListeners = new Set();
+        static #onEventListeners = {};
+
+        /**
+         * Loads the Unity canvas from the specified URL and injects it into the specified element.
+         * @param {string} url 
+         * @param {string} elementId 
+         */
+        static LoadInstance(url, elementId) {
+            Unity.#instanceReady = false;
+            const r = new XMLHttpRequest();
+            r.open("GET", url + "/index.html", true);
+            r.onreadystatechange = function () {
+                if (r.readyState !== 4 || r.status !== 200) return;
+                document.querySelector(`#${elementId}`).innerHTML = r.responseText;
+
+                const link = document.createElement('link');
+
+                link.rel = 'stylesheet';
+                link.type = 'text/css';
+                link.href = url + "/TemplateData/style.css";
+                document.head.appendChild(link);
+
+                const indexScript = document.createElement("script");
+                indexScript.src = url + "/index.js";
+                document.body.appendChild(indexScript);
+            };
+            r.send();
+        }
+
+        /**
+         * Gets the current Unity version.
+         * @returns {string}
+         */
+        static GetVersion() {
+            return Unity.InvokeEvent("InstanceEvent:GetUnityVersion");
+        }
+        
+        /**
+         * Gets the current build version.
+         * @returns {string}
+         */
+        static GetBuildVersion() {
+            return Unity.InvokeEvent("InstanceEvent:GetBuildVersion");
+        }
+
+        /**
+         * Invokes a global event that can be listened to by both Unity and JS.
+         * An optional payload can be sent, and the event can also return anything.
+         * @param {string} eventName
+         * @param {any} payload
+         * @returns {any}
+         */
+        static InvokeEvent(eventName, payload = undefined) {
+            const responseJson = Unity.#invokeEventInternal(eventName, payload);
+            try {
+                const response = JSON.parse(responseJson);
+                if(response.hasOwnProperty("promiseId")){
+                    console.warn(`Event '${eventName}' returned a promise. Consider using InvokeEventAsync instead.`);
+                    Unity.onEvent(`PromiseResolvedEvent:${response.promiseId}`, payload => {
+                        delete Unity.#onEventListeners[`PromiseResolvedEvent:${response.promiseId}`];
+                    });
+                }
+                return response;
+            }
+            catch {
+                return responseJson;
+            }
+        }
+
+        /**
+         * Async version of InvokeEvent. Invokes a global async event that can be listened to by both Unity and JS.
+         * An optional payload can be sent, and the event can also return anything.
+         * @param {string} eventName
+         * @param {any} payload
+         * @returns {Promise<any>}
+         */
+        static async InvokeEventAsync(eventName, payload = undefined) {
+            return new Promise(resolve => {
+                const responseJson = Unity.#invokeEventInternal(eventName, payload);
+                try {
+                    const response = JSON.parse(responseJson);
+                    if(response.hasOwnProperty("promiseId")){
+                        Unity.onEvent(`PromiseResolvedEvent:${response.promiseId}`, payload => {
+                            resolve(payload);
+                            delete Unity.#onEventListeners[`PromiseResolvedEvent:${response.promiseId}`];
+                        });
+                    }
+                    else {
+                        resolve(response);
+                    }
+                } catch {
+                    resolve(responseJson);
+                }
+            })
+        }
+
+        /**
+         * Awaits the Unity WaitForEndOfFrame coroutine.
+         * @returns {Promise<void>}
+         */
+        static async WaitForEndOfFrameAsync() {
+            return new Promise((resolve) => {
+                const eventId = crypto.randomUUID().toString();
+                const eventName = `EndOfFrameEvent:${eventId}`;
+
+                Unity.onEvent(eventName, () => {
+                    resolve();
+                    delete Unity.#onEventListeners[eventName];
+                });
+
+                Unity.InvokeEvent("InstanceEvent:WaitForEndOfFrame", eventId);
+            });
+        }
+
+        /**
+         * Loads a scene and awaits its completion.
+         * @param {string} sceneName
+         * @returns {Promise<void>}
+         */
+        static async LoadSceneAsync(sceneName) {
+            return new Promise((resolve) => {
+                const eventName = `SceneLoadedEvent:${sceneName}`;
+                Unity.onEvent(eventName, () => {
+                    resolve();
+                    delete Unity.#onEventListeners[eventName];
+                });
+                
+                Unity.InvokeEvent("InstanceEvent:LoadScene", sceneName);
+            });
+        }
+
+        /**
+         * Returns true if a scene is currently loading.
+         * @returns {boolean}
+         */
+        static IsSceneLoading() {
+            return Unity.InvokeEvent("InstanceEvent:IsSceneLoading");
+        }
+
+        /**
+         * Returns the current scene load progress. If no scene is currently loading, it returns 0.
+         * @returns {number}
+         */
+        static GetSceneLoadProgress() {
+            return Unity.InvokeEvent("InstanceEvent:GetSceneLoadProgress");
+        }
+
+        /**
+         * Loads an asset bundle from the provided URL and awaits its completion.
+         * @param {string} bundleUrl
+         * @returns {Promise<void>}
+         */
+        static async LoadBundleAsync(bundleUrl) {
+            await Unity.InvokeEventAsync("InstanceEvent:LoadBundle", bundleUrl);
+        }
+
+        /**
+         * This function loads the bundle, instantiates a prefab from it, and then unloads the bundle so you don't have to handle it manually.
+         * An optional parent JS Key can be provided to place the instantiated prefab under a specific GameObject.
+         * @param {string} bundleUrl
+         * @param {string} prefabName
+         * @param {string} parentKey
+         * @returns {Promise<void>}
+         */
+        static async InstantiatePrefabFromBundleAsync(bundleUrl, prefabName, parentKey = "") {
+            await Unity.InvokeEventAsync("InstanceEvent:InstantiatePrefabFromBundle", {
+                bundleUrl: bundleUrl,
+                prefabName: prefabName,
+                parentKey: parentKey
+            });
+        }
+
+        // Listeners -----------------------------
+
+        /**
+         * Registers a callback that will be invoked when the Unity instance is ready.
+         * @param {function} callback
+         */
+        static onInstanceReady(callback) {
+            if(!Unity.#instanceReady) {
+                Unity.#onInstanceReadyListeners.add(callback);
+            }
+            else {
+                callback();
+            }
+        }
+
+        /**
+         * Registers a callback that will be invoked when a global event is received. It can listen to events from both Unity and JS.
+         * @param {string} eventName
+         * @param {function} callback
+         */
+        static onEvent(eventName, callback) {
+            if(!Unity.#onEventListeners.hasOwnProperty(eventName)) {
+                Unity.#onEventListeners[eventName] = new Set();
+            }
+            Unity.#onEventListeners[eventName].add(callback);
+        }
+
+        /**
+         * Unregisters a callback previously registered with onEvent.
+         * @param {string} eventName
+         * @param {function} callback
+         */
+        static offEvent(eventName, callback) {
+            if(!Unity.#onEventListeners.hasOwnProperty(eventName)) return;
+            Unity.#onEventListeners[eventName].delete(callback);
+        }
+
+        static #invokeEventInternal(eventName, payload) {
+            if(payload === undefined || payload === null) payload = "";
+            let payloadJson = payload;
+            if(typeof payload === "object") payloadJson = JSON.stringify(payload);
+            else if(typeof payload !== "string") payloadJson = payload.toString();
+            const responseJson = Unity.#clientEventCallback(eventName, payloadJson);
+            Unity.#onEventListeners[eventName]?.forEach(callback => callback(payloadJson));
+            return responseJson;
+        }
+
+        // JSLib usage -----------------------------
+
+        /**Only for unity js library use*/
+        static _instanceReady() {
+            Unity.#instanceReady = true;
+            Unity.#onInstanceReadyListeners.forEach(callback => callback());
+        }
+
+        /**Only for unity js library use*/
+        static _registerClientListener(callback) {
+            Unity.#clientEventCallback = callback;
+        }
+
+        /**Only for unity js library use*/
+        static _receiveEvent(eventName, payloadJson) {
+            let payload = payloadJson;
+            try {
+                payload = JSON.parse(payloadJson);
+            } catch {}
+
+            Unity.InvokeEvent(eventName, payload);
+        }
+
+        /**Only for unity js library use*/
+        static _logFromUnity(verbosity, message) {
+            if(verbosity === "internal" && !Unity.internalLogs) return;
+            if(verbosity === "error") console.error(`[Unity] ${message}`);
+            else if(verbosity === "warning") console.warn(`[Unity] ${message}`);
+            else console.log(`[Unity] ${message}`);
+        }
+
     };
 
     return Unity$1;