vue-phaserjs 2.37.2 → 2.38.1

package/dist/index.js

@@ -1,592 +1,937 @@
-import { Fragment as e, computed as t, createCommentVNode as n, createElementBlock as r, createElementVNode as i, defineComponent as a, getCurrentInstance as o, inject as s, nextTick as c, onMounted as l, onUnmounted as u, openBlock as d, provide as f, ref as p, renderSlot as m, toValue as h, unref as g, useTemplateRef as _, watch as ee } from "vue";
-import { ID_SEPARATOR as v, InvalidOperationError as y, NotFoundError as te, NotInitializedError as b, Operation as x, checkIsPlainObject as ne, takeOne as re, toKebabCase as ie } from "@esposter/shared";
-import ae from "phaser4-rex-plugins/plugins/clickoutside.js";
-import { Animations as oe, Cameras as S, Game as se, Loader as C, Scene as ce, Scenes as le, Tilemaps as ue, Tweens as de, Utils as fe } from "phaser";
-import { defineStore as pe, storeToRefs as w } from "pinia";
-import { parseTileset as me, parseXmlString as he } from "parse-tmx";
+import "./vue-shims-Bl66Srx_.d.ts";
+import { Fragment, computed, createCommentVNode, createElementBlock, createElementVNode, defineComponent, getCurrentInstance, inject, nextTick, onMounted, onUnmounted, openBlock, provide, ref, renderSlot, toValue, useTemplateRef, watch } from "vue";
+import { ID_SEPARATOR, InvalidOperationError, NotFoundError, NotInitializedError, Operation, checkIsPlainObject, takeOne, toKebabCase } from "@esposter/shared";
+import ClickOutside from "phaser4-rex-plugins/plugins/clickoutside.js";
+import { Animations, Cameras, Game, Loader, Scene, Scenes, Tilemaps, Tweens, Utils } from "phaser";
+import { defineStore, storeToRefs } from "pinia";
+import { parseTileset, parseXmlString } from "parse-tmx";
 //#region src/util/getDepthInsertIndex.ts
-var ge = (e, t) => typeof t == "number" ? e.findIndex((e) => "depth" in e && typeof e.depth == "number" && e.depth > t) : -1, _e = (e, t, n) => {
-	let r = ge(e.list, "depth" in t ? t.depth : void 0);
-	r === -1 ? e.add(n) : e.addAt(n, r);
-}, ve = {
+const getDepthInsertIndex = (list, depth) => typeof depth === "number" ? list.findIndex((gameObject) => "depth" in gameObject && typeof gameObject.depth === "number" && gameObject.depth > depth) : -1;
+//#endregion
+//#region src/pushGameObject.ts
+const pushGameObject = (parentContainer, configuration, gameObject) => {
+	const i = getDepthInsertIndex(parentContainer.list, "depth" in configuration ? configuration.depth : void 0);
+	if (i === -1) parentContainer.add(gameObject);
+	else parentContainer.addAt(gameObject, i);
+};
+//#endregion
+//#region src/util/emit/GameObjectEventMap.ts
+const GameObjectEventMap = {
 	clickoutside: {},
-	drag: { drag: !0 },
-	dragend: { drag: !0 },
-	dragenter: { drag: !0 },
-	dragleave: { drag: !0 },
-	dragover: { drag: !0 },
-	dragstart: { drag: !0 },
-	drop: { drag: !0 },
+	drag: { drag: true },
+	dragend: { drag: true },
+	dragenter: { drag: true },
+	dragleave: { drag: true },
+	dragover: { drag: true },
+	dragstart: { drag: true },
+	drop: { drag: true },
 	pointerdown: { eventIndex: 3 },
 	pointermove: { eventIndex: 3 },
 	pointerout: { eventIndex: 1 },
 	pointerover: { eventIndex: 3 },
 	pointerup: { eventIndex: 3 },
 	wheel: { eventIndex: 4 }
-}, ye = "on", be = (e) => {
-	if (!e.startsWith("on") || e.length <= 2) throw new y(x.Read, be.name, e);
-	return e.slice(2).toLowerCase();
-}, xe = (e) => e.startsWith("on"), Se = () => {
-	let e = o(), t = new Set(Object.keys(e?.attrs ?? {}).filter((e) => xe(e)).map((e) => be(e))), n = Object.keys(ve).filter((e) => t.has(e)), r = [];
-	return {
-		eventStopHandles: r,
-		initializeGameObjectEvents: (e, t, i) => {
-			if (n.length !== 0) {
-				e.input || e.setInteractive(), n.some((e) => "drag" in ve[e]) && i.input.setDraggable(e);
-				for (let i of n) {
-					let n = ve[i], a = (...e) => {
-						"eventIndex" in n && (re(e).stopPropagation = re(e, n.eventIndex).stopPropagation), t(i, ...e);
-					};
-					if (i === "clickoutside") {
-						let t = new ae(e);
-						t.on(i, a), r.push(() => {
-							t.off(i, a);
-						});
-						continue;
-					}
-					e.on(i, a), r.push(() => {
-						e.off(i, a);
-					});
-				}
+};
+//#endregion
+//#region src/util/emit/constants.ts
+const EVENT_PREFIX = "on";
+//#endregion
+//#region src/util/emit/getEventName.ts
+const getEventName = (event) => {
+	if (!event.startsWith("on") || event.length <= 2) throw new InvalidOperationError(Operation.Read, getEventName.name, event);
+	return event.slice(2).toLowerCase();
+};
+//#endregion
+//#region src/util/emit/isEvent.ts
+const isEvent = (property) => property.startsWith("on");
+//#endregion
+//#region src/composables/useInitializeGameObjectEvents.ts
+const useInitializeGameObjectEvents = () => {
+	const currentInstance = getCurrentInstance();
+	const events = new Set(Object.keys(currentInstance?.attrs ?? {}).filter((key) => isEvent(key)).map((key) => getEventName(key)));
+	const gameObjectEvents = Object.keys(GameObjectEventMap).filter((key) => events.has(key));
+	const eventStopHandles = [];
+	const initializeGameObjectEvents = (gameObject, emit, scene) => {
+		if (gameObjectEvents.length === 0) return;
+		if (!gameObject.input) gameObject.setInteractive();
+		if (gameObjectEvents.some((key) => "drag" in GameObjectEventMap[key])) scene.input.setDraggable(gameObject);
+		for (const gameObjectEvent of gameObjectEvents) {
+			const context = GameObjectEventMap[gameObjectEvent];
+			const eventListener = (...args) => {
+				if ("eventIndex" in context) takeOne(args).stopPropagation = takeOne(args, context.eventIndex).stopPropagation;
+				emit(gameObjectEvent, ...args);
+			};
+			if (gameObjectEvent === "clickoutside") {
+				const clickOutside = new ClickOutside(gameObject);
+				clickOutside.on(gameObjectEvent, eventListener);
+				eventStopHandles.push(() => {
+					clickOutside.off(gameObjectEvent, eventListener);
+				});
+				continue;
 			}
+			gameObject.on(gameObjectEvent, eventListener);
+			eventStopHandles.push(() => {
+				gameObject.off(gameObjectEvent, eventListener);
+			});
 		}
 	};
-}, T = {
+	return {
+		eventStopHandles,
+		initializeGameObjectEvents
+	};
+};
+//#endregion
+//#region src/util/InjectionKeyMap.ts
+const InjectionKeyMap = {
 	ParentContainer: Symbol("ParentContainer"),
 	SceneKey: Symbol("SceneKey")
-}, E = () => {
-	let e = s(T.SceneKey);
-	if (!e) throw new b(T.SceneKey.description ?? "");
-	return e;
-}, D = /* @__PURE__ */ function(e) {
-	return e.Create = "Create", e.Init = "Init", e.NextTick = "NextTick", e.Preload = "Preload", e.Shutdown = "Shutdown", e.Update = "Update", e;
-}({}), O = {
+};
+//#endregion
+//#region src/composables/useInjectSceneKey.ts
+const useInjectSceneKey = () => {
+	const sceneKey = inject(InjectionKeyMap.SceneKey);
+	if (!sceneKey) throw new NotInitializedError(InjectionKeyMap.SceneKey.description ?? "");
+	return sceneKey;
+};
+//#endregion
+//#region src/models/lifecycle/Lifecycle.ts
+let Lifecycle = /* @__PURE__ */ function(Lifecycle) {
+	Lifecycle["Create"] = "Create";
+	Lifecycle["Init"] = "Init";
+	Lifecycle["NextTick"] = "NextTick";
+	Lifecycle["Preload"] = "Preload";
+	Lifecycle["Shutdown"] = "Shutdown";
+	Lifecycle["Update"] = "Update";
+	return Lifecycle;
+}({});
+//#endregion
+//#region src/store/scene.ts
+const ExternalSceneStore = {
 	lifecycleListenersMap: /* @__PURE__ */ new Map(),
 	sceneReadyMap: /* @__PURE__ */ new Map()
-}, k = (e, t, n) => {
-	let r = n ?? E(), i = O.lifecycleListenersMap.get(e);
-	if (!i) {
-		O.lifecycleListenersMap.set(e, /* @__PURE__ */ new Map([[r, [t]]]));
+};
+//#endregion
+//#region src/util/hooks/pushListener.ts
+const pushListener = (lifecycle, listener, key) => {
+	const sceneKey = key ?? useInjectSceneKey();
+	const listenersMap = ExternalSceneStore.lifecycleListenersMap.get(lifecycle);
+	if (!listenersMap) {
+		ExternalSceneStore.lifecycleListenersMap.set(lifecycle, /* @__PURE__ */ new Map([[sceneKey, [listener]]]));
 		return;
 	}
-	let a = i.get(r);
-	a ? a.push(t) : i.set(r, [t]);
-}, A = (...e) => {
-	k(D.NextTick, ...e);
-}, Ce = (e) => `update:${ie(e)}`, we = (e, t, n, r, i) => {
-	let a = E(), o = [], s = [];
-	for (let [c, l] of Object.entries(h(t))) {
-		let u = r[c];
-		if (!u) continue;
-		let d = Ce(c);
-		o.push((e) => {
-			u(e, n)(l), l === void 0 ? c in e && n(d, e[c]) : n(d, l);
-		}), s.push(ee(() => h(t)[c], (t) => {
-			let r = () => {
-				u(h(e), n)(t), n(d, t);
+	const listeners = listenersMap.get(sceneKey);
+	if (listeners) listeners.push(listener);
+	else listenersMap.set(sceneKey, [listener]);
+};
+//#endregion
+//#region src/hooks/onNextTick.ts
+const onNextTick = (...args) => {
+	pushListener("NextTick", ...args);
+};
+//#endregion
+//#region src/util/emit/getUpdateEvent.ts
+const getUpdateEvent = (property) => `update:${toKebabCase(property)}`;
+//#endregion
+//#region src/composables/useInitializeGameObjectSetters.ts
+const useInitializeGameObjectSetters = (gameObject, configuration, emit, setterMap, immediate) => {
+	const sceneKey = useInjectSceneKey();
+	const setters = [];
+	const setterWatchHandles = [];
+	for (const [key, value] of Object.entries(toValue(configuration))) {
+		const setter = setterMap[key];
+		if (!setter) continue;
+		const updateEvent = getUpdateEvent(key);
+		setters.push((targetGameObject) => {
+			setter(targetGameObject, emit)(value);
+			if (value !== void 0) emit(updateEvent, value);
+			else if (key in targetGameObject) emit(updateEvent, targetGameObject[key]);
+		});
+		setterWatchHandles.push(watch(() => toValue(configuration)[key], (newValue) => {
+			const updater = () => {
+				setter(toValue(gameObject), emit)(newValue);
+				emit(updateEvent, newValue);
 			};
-			i ? r() : A(() => {
-				r();
-			}, a);
-		}, { deep: !0 }));
+			if (immediate) updater();
+			else onNextTick(() => {
+				updater();
+			}, sceneKey);
+		}, { deep: true }));
 	}
+	const initializeGameObjectSetters = (targetGameObject) => {
+		for (const setter of setters) setter(targetGameObject);
+	};
 	return {
-		initializeGameObjectSetters: (e) => {
-			for (let t of o) t(e);
-		},
-		setterWatchHandles: s
+		initializeGameObjectSetters,
+		setterWatchHandles
 	};
-}, j = pe("phaser", () => {
-	let e, n = t({
-		get: () => e,
-		set: (t) => {
-			e = t;
+};
+//#endregion
+//#region src/store/index.ts
+const usePhaserStore = defineStore("phaser", () => {
+	let baseGame;
+	const game = computed({
+		get: () => baseGame,
+		set: (newGame) => {
+			baseGame = newGame;
 		}
-	}), r = p(), i = r, a = (e) => e === r.value, o = async (e) => {
-		if (a(e)) return;
-		let t = n.value;
-		if (!t) throw new b(se.name);
-		let i = r.value;
-		r.value = e, await c(), i && t.scene.isActive(i) && t.scene.stop(i), t.scene.start(e);
-	}, s = p([]), l = p([]);
+	});
+	const sceneKey = ref();
+	const rootSceneKey = sceneKey;
+	const isSameScene = (newSceneKey) => newSceneKey === sceneKey.value;
+	const switchToScene = async (newSceneKey) => {
+		if (isSameScene(newSceneKey)) return;
+		const activeGame = game.value;
+		if (!activeGame) throw new NotInitializedError(Game.name);
+		const oldSceneKey = sceneKey.value;
+		sceneKey.value = newSceneKey;
+		await nextTick();
+		if (oldSceneKey && activeGame.scene.isActive(oldSceneKey)) activeGame.scene.stop(oldSceneKey);
+		activeGame.scene.start(newSceneKey);
+	};
+	const parallelSceneKeys = ref([]);
+	const prioritizedParallelSceneKeys = ref([]);
+	const launchParallelScene = (scene, targetSceneKey) => {
+		if (parallelSceneKeys.value.includes(targetSceneKey)) return;
+		scene.scene.bringToTop(targetSceneKey);
+		for (const prioritizedParallelSceneKey of prioritizedParallelSceneKeys.value) if (parallelSceneKeys.value.includes(prioritizedParallelSceneKey)) scene.scene.bringToTop(prioritizedParallelSceneKey);
+		scene.scene.launch(targetSceneKey);
+		parallelSceneKeys.value.push(targetSceneKey);
+	};
+	const removeParallelScene = (scene, targetSceneKey) => {
+		const index = parallelSceneKeys.value.indexOf(targetSceneKey);
+		if (index === -1) return;
+		const parallelSceneKey = parallelSceneKeys.value[index];
+		parallelSceneKeys.value = parallelSceneKeys.value.toSpliced(index, 1);
+		scene.scene.stop(parallelSceneKey);
+	};
 	return {
-		game: n,
-		isSameScene: a,
-		launchParallelScene: (e, t) => {
-			if (!s.value.includes(t)) {
-				e.scene.bringToTop(t);
-				for (let t of l.value) s.value.includes(t) && e.scene.bringToTop(t);
-				e.scene.launch(t), s.value.push(t);
-			}
-		},
-		parallelSceneKeys: s,
-		prioritizedParallelSceneKeys: l,
-		removeParallelScene: (e, t) => {
-			let n = s.value.indexOf(t);
-			if (n === -1) return;
-			let r = s.value.splice(n, 1)[0];
-			e.scene.stop(r);
-		},
-		rootSceneKey: i,
-		switchToScene: o
+		game,
+		isSameScene,
+		launchParallelScene,
+		parallelSceneKeys,
+		prioritizedParallelSceneKeys,
+		removeParallelScene,
+		rootSceneKey,
+		switchToScene
 	};
-}), M = () => {
-	let e = j(), { game: t } = w(e);
-	if (!t.value) throw new b(se.name);
-	return t.value;
-}, N = (e) => M().scene.getScene(e), Te = (...e) => {
-	k(D.Create, ...e);
-}, Ee = (e) => O.sceneReadyMap.get(e) ? A : Te, P = (e, t, n, r, i) => {
-	let a, { initializeGameObjectSetters: o, setterWatchHandles: c } = we(() => a, t, n, r, i), { eventStopHandles: l, initializeGameObjectEvents: d } = Se(), f = s(T.ParentContainer, void 0), p = E(), m = Ee(p), g = (t) => {
-		a = e(t), o(a), d(a, n, t);
-	}, _ = () => {
-		f?.value && _e(f.value, h(t), a);
+});
+//#endregion
+//#region src/composables/useGame.ts
+const useGame = () => {
+	const phaserStore = usePhaserStore();
+	const { game } = storeToRefs(phaserStore);
+	if (!game.value) throw new NotInitializedError(Game.name);
+	return game.value;
+};
+//#endregion
+//#region src/util/getScene.ts
+const getScene = (sceneKey) => {
+	return useGame().scene.getScene(sceneKey);
+};
+//#endregion
+//#region src/hooks/onCreate.ts
+const onCreate = (...args) => {
+	pushListener("Create", ...args);
+};
+//#endregion
+//#region src/util/hooks/getInitializeGameObjectLifecycleHook.ts
+const getInitializeGameObjectLifecycleHook = (sceneKey) => ExternalSceneStore.sceneReadyMap.get(sceneKey) ? onNextTick : onCreate;
+//#endregion
+//#region src/composables/useInitializeGameObject.ts
+const useInitializeGameObject = (create, configuration, emit, setterMap, immediate) => {
+	let gameObject;
+	const { initializeGameObjectSetters, setterWatchHandles } = useInitializeGameObjectSetters(() => gameObject, configuration, emit, setterMap, immediate);
+	const { eventStopHandles, initializeGameObjectEvents } = useInitializeGameObjectEvents();
+	const parentContainer = inject(InjectionKeyMap.ParentContainer, void 0);
+	const sceneKey = useInjectSceneKey();
+	const lifecycleHook = getInitializeGameObjectLifecycleHook(sceneKey);
+	const initializeGameObject = (scene) => {
+		gameObject = create(scene);
+		initializeGameObjectSetters(gameObject);
+		initializeGameObjectEvents(gameObject, emit, scene);
 	};
-	i ? (g(N(p)), m(() => {
-		_();
-	})) : m((e) => {
-		g(e), _();
-	}), u(() => {
-		for (let e of c) e();
-		for (let e of l) e();
-		a.destroy();
+	const pushToParentContainer = () => {
+		if (!parentContainer?.value) return;
+		pushGameObject(parentContainer.value, toValue(configuration), gameObject);
+	};
+	if (immediate) {
+		initializeGameObject(getScene(sceneKey));
+		lifecycleHook(() => {
+			pushToParentContainer();
+		});
+	} else lifecycleHook((scene) => {
+		initializeGameObject(scene);
+		pushToParentContainer();
 	});
-}, De = {
-	displayHeight: (e) => (t) => {
-		t !== void 0 && e.setDisplaySize(e.displayWidth, t);
-	},
-	displayWidth: (e) => (t) => {
-		t !== void 0 && e.setDisplaySize(t, e.displayHeight);
+	onUnmounted(() => {
+		for (const setterWatchHandle of setterWatchHandles) setterWatchHandle();
+		for (const eventStopHandle of eventStopHandles) eventStopHandle();
+		gameObject.destroy();
+	});
+};
+//#endregion
+//#region src/util/setterMap/components/DisplaySizeSetterMap.ts
+const DisplaySizeSetterMap = {
+	displayHeight: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setDisplaySize(gameObject.displayWidth, value);
+	},
+	displayWidth: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setDisplaySize(value, gameObject.displayHeight);
 	}
-}, F = {
-	...De,
-	height: (e) => (t) => {
-		t !== void 0 && e.setSize(e.width, t);
-	},
-	width: (e) => (t) => {
-		t !== void 0 && e.setSize(t, e.height);
+};
+//#endregion
+//#region src/util/setterMap/components/ComputedSizeSetterMap.ts
+const ComputedSizeSetterMap = {
+	...DisplaySizeSetterMap,
+	height: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setSize(gameObject.width, value);
+	},
+	width: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setSize(value, gameObject.height);
 	}
-}, I = { depth: (e) => (t) => {
-	if (t === void 0 || (e.setDepth(t), !e.parentContainer)) return;
-	let n = ge(e.parentContainer.list, e.depth);
-	n === -1 ? e.parentContainer.bringToTop(e) : e.parentContainer.moveTo(e, Math.max(n - 1, 0));
-} }, L = {
-	displayOriginX: (e) => (t) => {
-		e.setDisplayOrigin(t, e.displayOriginY);
+};
+//#endregion
+//#region src/util/setterMap/components/DepthSetterMap.ts
+const DepthSetterMap = { depth: (gameObject) => (value) => {
+	if (value === void 0) return;
+	gameObject.setDepth(value);
+	if (!gameObject.parentContainer) return;
+	const i = getDepthInsertIndex(gameObject.parentContainer.list, gameObject.depth);
+	if (i === -1) gameObject.parentContainer.bringToTop(gameObject);
+	else gameObject.parentContainer.moveTo(gameObject, Math.max(i - 1, 0));
+} };
+//#endregion
+//#region src/util/setterMap/components/OriginSetterMap.ts
+const OriginSetterMap = {
+	displayOriginX: (gameObject) => (value) => {
+		gameObject.setDisplayOrigin(value, gameObject.displayOriginY);
 	},
-	displayOriginY: (e) => (t) => {
-		e.setDisplayOrigin(e.displayOriginX, t);
+	displayOriginY: (gameObject) => (value) => {
+		gameObject.setDisplayOrigin(gameObject.displayOriginX, value);
 	},
-	origin: (e) => (t) => {
-		e.setOrigin(t, t);
+	origin: (gameObject) => (value) => {
+		gameObject.setOrigin(value, value);
 	},
-	originX: (e) => (t) => {
-		e.setOrigin(t, e.originY);
+	originX: (gameObject) => (value) => {
+		gameObject.setOrigin(value, gameObject.originY);
 	},
-	originY: (e) => (t) => {
-		e.setOrigin(e.originX, t);
+	originY: (gameObject) => (value) => {
+		gameObject.setOrigin(gameObject.originX, value);
 	}
-}, R = {
-	scrollFactor: (e) => (t) => {
-		t !== void 0 && e.setScrollFactor(t, t);
-	},
-	scrollFactorX: (e) => (t) => {
-		t !== void 0 && e.setScrollFactor(t, e.scrollFactorY);
-	},
-	scrollFactorY: (e) => (t) => {
-		t !== void 0 && e.setScrollFactor(e.scrollFactorX, t);
+};
+//#endregion
+//#region src/util/setterMap/components/ScrollFactorSetterMap.ts
+const ScrollFactorSetterMap = {
+	scrollFactor: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setScrollFactor(value, value);
+	},
+	scrollFactorX: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setScrollFactor(value, gameObject.scrollFactorY);
+	},
+	scrollFactorY: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setScrollFactor(gameObject.scrollFactorX, value);
 	}
-}, z = {
-	angle: (e) => (t) => {
-		e.setAngle(t);
+};
+//#endregion
+//#region src/util/setterMap/components/TransformSetterMap.ts
+const TransformSetterMap = {
+	angle: (gameObject) => (value) => {
+		gameObject.setAngle(value);
 	},
-	rotation: (e) => (t) => {
-		e.setRotation(t);
+	rotation: (gameObject) => (value) => {
+		gameObject.setRotation(value);
 	},
-	scale: (e) => (t) => {
-		e.setScale(t, t);
+	scale: (gameObject) => (value) => {
+		gameObject.setScale(value, value);
 	},
-	scaleX: (e) => (t) => {
-		e.setScale(t, e.scaleY);
+	scaleX: (gameObject) => (value) => {
+		gameObject.setScale(value, gameObject.scaleY);
 	},
-	scaleY: (e) => (t) => {
-		e.setScale(e.scaleX, t);
+	scaleY: (gameObject) => (value) => {
+		gameObject.setScale(gameObject.scaleX, value);
 	},
-	w: (e) => (t) => {
-		e.setW(t);
+	w: (gameObject) => (value) => {
+		gameObject.setW(value);
 	},
-	x: (e) => (t) => {
-		e.setX(t);
+	x: (gameObject) => (value) => {
+		gameObject.setX(value);
 	},
-	y: (e) => (t) => {
-		e.setY(t);
+	y: (gameObject) => (value) => {
+		gameObject.setY(value);
 	},
-	z: (e) => (t) => {
-		e.setZ(t);
+	z: (gameObject) => (value) => {
+		gameObject.setZ(value);
 	}
-}, B = { visible: (e) => (t) => {
-	t !== void 0 && e.setVisible(t);
-} }, Oe = { active: (e) => (t) => {
-	t !== void 0 && e.setActive(t);
-} }, ke = {
-	tween: (e, t) => (n) => {
-		n && e.scene.add.tween({
-			...n,
-			targets: e
-		}).on(de.Events.TWEEN_COMPLETE, () => {
-			t("update:tween", void 0);
+};
+//#endregion
+//#region src/util/setterMap/components/VisibleSetterMap.ts
+const VisibleSetterMap = { visible: (gameObject) => (value) => {
+	if (value === void 0) return;
+	gameObject.setVisible(value);
+} };
+//#endregion
+//#region src/util/setterMap/global/GameObjectSetterMap.ts
+const GameObjectSetterMap = { active: (gameObject) => (value) => {
+	if (value === void 0) return;
+	gameObject.setActive(value);
+} };
+//#endregion
+//#region src/util/setterMap/global/TweenSetterMap.ts
+const TweenSetterMap = {
+	tween: (gameObject, emit) => (value) => {
+		if (!value) return;
+		gameObject.scene.add.tween({
+			...value,
+			targets: gameObject
+		}).on(Tweens.Events.TWEEN_COMPLETE, () => {
+			emit("update:tween", void 0);
 		});
 	},
-	tweenchain: (e, t) => (n) => {
-		n && e.scene.add.tweenchain(n.map((t) => ({
-			...t,
-			targets: e
-		}))).on(de.Events.TWEEN_COMPLETE, () => {
-			t("update:tweenchain", void 0);
+	tweenchain: (gameObject, emit) => (value) => {
+		if (!value) return;
+		gameObject.scene.add.tweenchain(value.map((c) => ({
+			...c,
+			targets: gameObject
+		}))).on(Tweens.Events.TWEEN_COMPLETE, () => {
+			emit("update:tweenchain", void 0);
 		});
 	}
-}, V = {
-	...ke,
-	...Oe
-}, Ae = {
-	...F,
-	...I,
-	...L,
-	...z,
-	...R,
-	...B,
-	...V
-}, je = /* @__PURE__ */ a({
+};
+//#endregion
+//#region src/util/setterMap/global/GlobalSetterMap.ts
+const GlobalSetterMap = {
+	...TweenSetterMap,
+	...GameObjectSetterMap
+};
+//#endregion
+//#region src/util/setterMap/ZoneSetterMap.ts
+const ZoneSetterMap = {
+	...ComputedSizeSetterMap,
+	...DepthSetterMap,
+	...OriginSetterMap,
+	...TransformSetterMap,
+	...ScrollFactorSetterMap,
+	...VisibleSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Zone.vue
+const _sfc_main$26 = /*@__PURE__*/ defineComponent({
 	__name: "Zone",
 	props: { configuration: {} },
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { height: n, width: r, x: i, y: a } = e.configuration;
-			return t.add.zone(i, a, r, n);
-		}, () => e.configuration, t, Ae), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { height, width, x, y } = __props.configuration;
+			return scene.add.zone(x, y, width, height);
+		}, () => __props.configuration, __emit, ZoneSetterMap);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), H = {
-	alpha: (e) => (t) => {
-		e.setAlpha(t, t, t, t);
+});
+//#endregion
+//#region src/util/setterMap/components/AlphaSetterMap.ts
+const AlphaSetterMap = {
+	alpha: (gameObject) => (value) => {
+		gameObject.setAlpha(value, value, value, value);
 	},
-	alphaBottomLeft: (e) => (t) => {
-		e.setAlpha(e.alphaTopLeft, e.alphaTopRight, t, e.alphaBottomRight);
+	alphaBottomLeft: (gameObject) => (value) => {
+		gameObject.setAlpha(gameObject.alphaTopLeft, gameObject.alphaTopRight, value, gameObject.alphaBottomRight);
 	},
-	alphaBottomRight: (e) => (t) => {
-		e.setAlpha(e.alphaTopLeft, e.alphaTopRight, e.alphaBottomLeft, t);
+	alphaBottomRight: (gameObject) => (value) => {
+		gameObject.setAlpha(gameObject.alphaTopLeft, gameObject.alphaTopRight, gameObject.alphaBottomLeft, value);
 	},
-	alphaTopLeft: (e) => (t) => {
-		e.setAlpha(t, e.alphaTopRight, e.alphaBottomLeft, e.alphaBottomRight);
+	alphaTopLeft: (gameObject) => (value) => {
+		gameObject.setAlpha(value, gameObject.alphaTopRight, gameObject.alphaBottomLeft, gameObject.alphaBottomRight);
 	},
-	alphaTopRight: (e) => (t) => {
-		e.setAlpha(e.alphaTopLeft, t, e.alphaBottomLeft, e.alphaBottomRight);
+	alphaTopRight: (gameObject) => (value) => {
+		gameObject.setAlpha(gameObject.alphaTopLeft, value, gameObject.alphaBottomLeft, gameObject.alphaBottomRight);
 	}
-}, U = { blendMode: (e) => (t) => {
-	t !== void 0 && e.setBlendMode(t);
-} }, W = {
-	flipX: (e) => (t) => {
-		t !== void 0 && e.setFlipX(t);
-	},
-	flipY: (e) => (t) => {
-		t !== void 0 && e.setFlipY(t);
+};
+//#endregion
+//#region src/util/setterMap/components/BlendModeSetterMap.ts
+const BlendModeSetterMap = { blendMode: (gameObject) => (value) => {
+	if (value === void 0) return;
+	gameObject.setBlendMode(value);
+} };
+//#endregion
+//#region src/util/setterMap/components/FlipSetterMap.ts
+const FlipSetterMap = {
+	flipX: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setFlipX(value);
+	},
+	flipY: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setFlipY(value);
 	}
-}, G = { mask: (e) => (t) => {
-	t && e.setMask(t);
-} }, K = {}, Me = {
-	frame: (e) => (t) => {
-		t !== void 0 && e.setFrame(t);
-	},
-	texture: (e) => (t) => {
-		t && e.setTexture(t);
+};
+//#endregion
+//#region src/util/setterMap/components/MaskSetterMap.ts
+const MaskSetterMap = { mask: (gameObject) => (value) => {
+	if (!value) return;
+	gameObject.setMask(value);
+} };
+//#endregion
+//#region src/util/setterMap/components/RenderNodesSetterMap.ts
+const RenderNodesSetterMap = {};
+//#endregion
+//#region src/util/setterMap/components/BaseTextureSetterMap.ts
+const BaseTextureSetterMap = {
+	frame: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setFrame(value);
+	},
+	texture: (gameObject) => (value) => {
+		if (!value) return;
+		gameObject.setTexture(value);
 	}
-}, Ne = { ...Me }, q = {
-	tint: (e) => (t) => {
-		e.setTint(t, t, t, t);
+};
+//#endregion
+//#region src/util/setterMap/components/TextureCropSetterMap.ts
+const TextureCropSetterMap = { ...BaseTextureSetterMap };
+//#endregion
+//#region src/util/setterMap/components/TintSetterMap.ts
+const TintSetterMap = {
+	tint: (gameObject) => (value) => {
+		gameObject.setTint(value, value, value, value);
 	},
-	tintBottomLeft: (e) => (t) => {
-		e.setTint(e.tintTopLeft, e.tintTopRight, t, e.tintBottomRight);
+	tintBottomLeft: (gameObject) => (value) => {
+		gameObject.setTint(gameObject.tintTopLeft, gameObject.tintTopRight, value, gameObject.tintBottomRight);
 	},
-	tintBottomRight: (e) => (t) => {
-		e.setTint(e.tintTopLeft, e.tintTopRight, e.tintBottomLeft, t);
+	tintBottomRight: (gameObject) => (value) => {
+		gameObject.setTint(gameObject.tintTopLeft, gameObject.tintTopRight, gameObject.tintBottomLeft, value);
 	},
-	tintTopLeft: (e) => (t) => {
-		e.setTint(t, e.tintTopRight, e.tintBottomLeft, e.tintBottomRight);
+	tintTopLeft: (gameObject) => (value) => {
+		gameObject.setTint(value, gameObject.tintTopRight, gameObject.tintBottomLeft, gameObject.tintBottomRight);
 	},
-	tintTopRight: (e) => (t) => {
-		e.setTint(e.tintTopLeft, t, e.tintBottomLeft, e.tintBottomRight);
+	tintTopRight: (gameObject) => (value) => {
+		gameObject.setTint(gameObject.tintTopLeft, value, gameObject.tintBottomLeft, gameObject.tintBottomRight);
 	}
-}, Pe = {
-	...H,
-	...U,
-	...I,
-	...W,
-	...G,
-	...L,
-	...K,
-	...R,
-	...Ne,
-	...q,
-	...z,
-	...B,
-	...V,
-	key: (e) => (t) => {
-		t && e.changeSource(t);
-	},
-	muted: (e) => (t) => {
-		e.setMute(t);
-	},
-	volume: (e) => (t) => {
-		e.setVolume(t);
+};
+//#endregion
+//#region src/util/setterMap/VideoSetterMap.ts
+const VideoSetterMap = {
+	...AlphaSetterMap,
+	...BlendModeSetterMap,
+	...DepthSetterMap,
+	...FlipSetterMap,
+	...MaskSetterMap,
+	...OriginSetterMap,
+	...RenderNodesSetterMap,
+	...ScrollFactorSetterMap,
+	...TextureCropSetterMap,
+	...TintSetterMap,
+	...TransformSetterMap,
+	...VisibleSetterMap,
+	...GlobalSetterMap,
+	key: (gameObject) => (value) => {
+		if (!value) return;
+		gameObject.changeSource(value);
+	},
+	muted: (gameObject) => (value) => {
+		gameObject.setMute(value);
+	},
+	volume: (gameObject) => (value) => {
+		gameObject.setVolume(value);
 	}
-}, Fe = /* @__PURE__ */ a({
+};
+//#endregion
+//#region src/components/Video.vue
+const _sfc_main$25 = /*@__PURE__*/ defineComponent({
 	__name: "Video",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { key: n, x: r, y: i } = e.configuration, a = t.add.video(r ?? 0, i ?? 0, n);
-			return e.onComplete?.(t, a), a;
-		}, () => e.configuration, t, Pe, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { key, x, y } = __props.configuration;
+			const video = scene.add.video(x ?? 0, y ?? 0, key);
+			__props.onComplete?.(scene, video);
+			return video;
+		}, () => __props.configuration, __emit, VideoSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), J = { alpha: (e) => (t) => {
-	e.setAlpha(t);
-} }, Y = {
-	...J,
-	...U,
-	...I,
-	...De,
-	...Oe,
-	...G,
-	...L,
-	...K,
-	...R,
-	...z,
-	...B,
-	fillAlpha: (e) => (t) => {
-		e.setFillStyle(e.fillColor, t);
-	},
-	fillColor: (e) => (t) => {
-		e.setFillStyle(t, e.fillAlpha);
-	},
-	strokeStyle: (e) => (t) => {
-		t && e.setStrokeStyle(...t);
+});
+//#endregion
+//#region src/util/setterMap/components/AlphaSingleSetterMap.ts
+const AlphaSingleSetterMap = { alpha: (gameObject) => (value) => {
+	gameObject.setAlpha(value);
+} };
+//#endregion
+//#region src/util/setterMap/shared/ShapeSetterMap.ts
+const ShapeSetterMap = {
+	...AlphaSingleSetterMap,
+	...BlendModeSetterMap,
+	...DepthSetterMap,
+	...DisplaySizeSetterMap,
+	...GameObjectSetterMap,
+	...MaskSetterMap,
+	...OriginSetterMap,
+	...RenderNodesSetterMap,
+	...ScrollFactorSetterMap,
+	...TransformSetterMap,
+	...VisibleSetterMap,
+	fillAlpha: (gameObject) => (value) => {
+		gameObject.setFillStyle(gameObject.fillColor, value);
+	},
+	fillColor: (gameObject) => (value) => {
+		gameObject.setFillStyle(value, gameObject.fillAlpha);
+	},
+	strokeStyle: (gameObject) => (value) => {
+		if (!value) return;
+		gameObject.setStrokeStyle(...value);
 	}
-}, Ie = {
-	to: (e) => (t) => {
-		t && e.setTo(...t);
-	},
-	...Y,
-	...V
-}, Le = /* @__PURE__ */ a({
+};
+//#endregion
+//#region src/util/setterMap/TriangleSetterMap.ts
+const TriangleSetterMap = {
+	to: (gameObject) => (value) => {
+		if (!value) return;
+		gameObject.setTo(...value);
+	},
+	...ShapeSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Triangle.vue
+const _sfc_main$24 = /*@__PURE__*/ defineComponent({
 	__name: "Triangle",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { alpha: n, fillColor: r, to: i, x: a, y: o } = e.configuration, s = t.add.triangle(a, o, i?.[0], i?.[1], i?.[2], i?.[3], i?.[4], i?.[5], r, n);
-			return e.onComplete?.(t, s), s;
-		}, () => e.configuration, t, Ie, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { alpha, fillColor, to, x, y } = __props.configuration;
+			const triangle = scene.add.triangle(x, y, to?.[0], to?.[1], to?.[2], to?.[3], to?.[4], to?.[5], fillColor, alpha);
+			__props.onComplete?.(scene, triangle);
+			return triangle;
+		}, () => __props.configuration, __emit, TriangleSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), X = { ...Me }, Re = {
-	...H,
-	...U,
-	...F,
-	...I,
-	...W,
-	...G,
-	...L,
-	...K,
-	...R,
-	...X,
-	...q,
-	...z,
-	...B,
-	...V
-}, ze = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/components/TextureSetterMap.ts
+const TextureSetterMap = { ...BaseTextureSetterMap };
+//#endregion
+//#region src/util/setterMap/TileSpriteSetterMap.ts
+const TileSpriteSetterMap = {
+	...AlphaSetterMap,
+	...BlendModeSetterMap,
+	...ComputedSizeSetterMap,
+	...DepthSetterMap,
+	...FlipSetterMap,
+	...MaskSetterMap,
+	...OriginSetterMap,
+	...RenderNodesSetterMap,
+	...ScrollFactorSetterMap,
+	...TextureSetterMap,
+	...TintSetterMap,
+	...TransformSetterMap,
+	...VisibleSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/TileSprite.vue
+const _sfc_main$22 = /*@__PURE__*/ defineComponent({
 	__name: "TileSprite",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { frame: n, height: r, texture: i, width: a, x: o, y: s } = e.configuration, c = t.add.tileSprite(o ?? 0, s ?? 0, a ?? 0, r ?? 0, i, n);
-			return e.onComplete?.(t, c), c;
-		}, () => e.configuration, t, Re, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { frame, height, texture, width, x, y } = __props.configuration;
+			const tileSprite = scene.add.tileSprite(x ?? 0, y ?? 0, width ?? 0, height ?? 0, texture, frame);
+			__props.onComplete?.(scene, tileSprite);
+			return tileSprite;
+		}, () => __props.configuration, __emit, TileSpriteSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), Be = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/components/Tilemap.vue
+const _sfc_main$23 = /*@__PURE__*/ defineComponent({
 	__name: "Tilemap",
 	props: {
 		configuration: {},
 		onComplete: { type: Function }
 	},
-	setup(e) {
-		let t = E(), n = p();
-		return Te((t) => {
-			n.value = t.make.tilemap(e.configuration), e.onComplete?.(t, n.value);
-		}), ee(() => e.configuration.key, (r) => {
-			let i = N(t), a = n.value;
-			r ? (n.value = i.make.tilemap(e.configuration), e.onComplete?.(i, n.value)) : n.value = void 0, a && a.destroy();
-		}), u(() => {
-			n.value && n.value.destroy();
-		}), (e, t) => m(e.$slots, "default");
+	setup(__props) {
+		const sceneKey = useInjectSceneKey();
+		const tilemap = ref();
+		onCreate((newScene) => {
+			tilemap.value = newScene.make.tilemap(__props.configuration);
+			__props.onComplete?.(newScene, tilemap.value);
+		});
+		watch(() => __props.configuration.key, (newKey) => {
+			const scene = getScene(sceneKey);
+			const oldTilemap = tilemap.value;
+			if (newKey) {
+				tilemap.value = scene.make.tilemap(__props.configuration);
+				__props.onComplete?.(scene, tilemap.value);
+			} else tilemap.value = void 0;
+			if (oldTilemap) oldTilemap.destroy();
+		});
+		onUnmounted(() => {
+			if (!tilemap.value) return;
+			tilemap.value.destroy();
+		});
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default");
+		};
 	}
-}), Ve = pe("phaser/text", () => ({ defaultTextStyle: p() })), He = {
-	padding: (e) => (t) => {
-		t && e.setPadding(t);
-	},
-	style: (e) => (t) => {
-		t && e.setStyle(t);
-	},
-	text: (e, t) => (n) => {
-		n !== void 0 && (e.setText(n), t("update:width", e.width), t("update:displayWidth", e.displayWidth));
-	},
-	...H,
-	...U,
-	...F,
-	...I,
-	...W,
-	...G,
-	...L,
-	...K,
-	...R,
-	...q,
-	...z,
-	...B,
-	...V
-}, Ue = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/store/text.ts
+const useTextStore = defineStore("phaser/text", () => {
+	return { defaultTextStyle: ref() };
+});
+//#endregion
+//#region src/util/setterMap/TextSetterMap.ts
+const TextSetterMap = {
+	padding: (gameObject) => (value) => {
+		if (!value) return;
+		gameObject.setPadding(value);
+	},
+	style: (gameObject) => (value) => {
+		if (!value) return;
+		gameObject.setStyle(value);
+	},
+	text: (gameObject, emit) => (value) => {
+		if (value === void 0) return;
+		gameObject.setText(value);
+		emit("update:width", gameObject.width);
+		emit("update:displayWidth", gameObject.displayWidth);
+	},
+	...AlphaSetterMap,
+	...BlendModeSetterMap,
+	...ComputedSizeSetterMap,
+	...DepthSetterMap,
+	...FlipSetterMap,
+	...MaskSetterMap,
+	...OriginSetterMap,
+	...RenderNodesSetterMap,
+	...ScrollFactorSetterMap,
+	...TintSetterMap,
+	...TransformSetterMap,
+	...VisibleSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Text.vue
+const _sfc_main$21 = /*@__PURE__*/ defineComponent({
 	__name: "Text",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean }
 	},
-	setup(e, { emit: t }) {
-		let n = t, r = Ve(), { defaultTextStyle: i } = w(r);
-		return P((t) => {
-			let { style: n, text: r, x: a, y: o } = e.configuration;
-			return t.add.text(a ?? 0, o ?? 0, r, {
-				...i.value,
-				...n
+	setup(__props, { emit: __emit }) {
+		const emit = __emit;
+		const textStore = useTextStore();
+		const { defaultTextStyle } = storeToRefs(textStore);
+		useInitializeGameObject((scene) => {
+			const { style, text, x, y } = __props.configuration;
+			return scene.add.text(x ?? 0, y ?? 0, text, {
+				...defaultTextStyle.value,
+				...style
 			});
-		}, () => e.configuration, n, He, e.immediate), (e, t) => null;
+		}, () => __props.configuration, emit, TextSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), We = {
-	innerRadius: (e) => (t) => {
-		t !== void 0 && e.setInnerRadius(t);
-	},
-	outerRadius: (e) => (t) => {
-		t !== void 0 && e.setOuterRadius(t);
-	},
-	points: (e) => (t) => {
-		t !== void 0 && e.setPoints(t);
-	},
-	...Y,
-	...V
-}, Ge = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/StarSetterMap.ts
+const StarSetterMap = {
+	innerRadius: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setInnerRadius(value);
+	},
+	outerRadius: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setOuterRadius(value);
+	},
+	points: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setPoints(value);
+	},
+	...ShapeSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Star.vue
+const _sfc_main$20 = /*@__PURE__*/ defineComponent({
 	__name: "Star",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { alpha: n, fillColor: r, innerRadius: i, outerRadius: a, points: o, x: s, y: c } = e.configuration, l = t.add.star(s, c, o, i, a, r, n);
-			return e.onComplete?.(t, l), l;
-		}, () => e.configuration, t, We, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { alpha, fillColor, innerRadius, outerRadius, points, x, y } = __props.configuration;
+			const star = scene.add.star(x, y, points, innerRadius, outerRadius, fillColor, alpha);
+			__props.onComplete?.(scene, star);
+			return star;
+		}, () => __props.configuration, __emit, StarSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), Z = { ...F }, Ke = {
-	animations: (e, t) => (n) => {
-		if (n && n.length > 0) for (let r of n) {
-			if (!r.key) continue;
-			let n = `${oe.Events.ANIMATION_COMPLETE_KEY}${r.key}`;
-			if (e.once(n, () => {
-				t(n);
-			}), !e.scene.anims.exists(r.key) && !e.scene.anims.create(r)) throw new y(x.Create, "Animation", r.key);
+});
+//#endregion
+//#region src/util/setterMap/components/SizeSetterMap.ts
+const SizeSetterMap = { ...ComputedSizeSetterMap };
+//#endregion
+//#region src/util/setterMap/shared/AnimationSetterMap.ts
+const AnimationSetterMap = {
+	animations: (gameObject, emit) => (configurations) => {
+		if (!(configurations && configurations.length > 0)) return;
+		for (const configuration of configurations) {
+			if (!configuration.key) continue;
+			const event = `${Animations.Events.ANIMATION_COMPLETE_KEY}${configuration.key}`;
+			gameObject.once(event, () => {
+				emit(event);
+			});
+			if (gameObject.scene.anims.exists(configuration.key)) continue;
+			else if (!gameObject.scene.anims.create(configuration)) throw new InvalidOperationError(Operation.Create, "Animation", configuration.key);
 		}
 	},
-	playAnimationKey: (e) => (t) => {
-		if (t === void 0) {
-			e.stop();
+	playAnimationKey: (gameObject) => (value) => {
+		if (value === void 0) {
+			gameObject.stop();
 			return;
 		}
-		e.play(t);
+		gameObject.play(value);
 	}
-}, qe = {
-	...H,
-	...U,
-	...I,
-	...W,
-	...G,
-	...L,
-	...K,
-	...R,
-	...Z,
-	...X,
-	...q,
-	...z,
-	...B,
-	...Ke,
-	...V
-}, Je = /* @__PURE__ */ a({
+};
+//#endregion
+//#region src/util/setterMap/SpriteSetterMap.ts
+const SpriteSetterMap = {
+	...AlphaSetterMap,
+	...BlendModeSetterMap,
+	...DepthSetterMap,
+	...FlipSetterMap,
+	...MaskSetterMap,
+	...OriginSetterMap,
+	...RenderNodesSetterMap,
+	...ScrollFactorSetterMap,
+	...SizeSetterMap,
+	...TextureSetterMap,
+	...TintSetterMap,
+	...TransformSetterMap,
+	...VisibleSetterMap,
+	...AnimationSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Sprite.vue
+const _sfc_main$19 = /*@__PURE__*/ defineComponent({
 	__name: "Sprite",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { frame: n, texture: r, x: i, y: a } = e.configuration, o = t.add.sprite(i ?? 0, a ?? 0, r, n);
-			return e.onComplete?.(t, o), o;
-		}, () => e.configuration, t, qe, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { frame, texture, x, y } = __props.configuration;
+			const sprite = scene.add.sprite(x ?? 0, y ?? 0, texture, frame);
+			__props.onComplete?.(scene, sprite);
+			return sprite;
+		}, () => __props.configuration, __emit, SpriteSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), Ye = pe("phaser/camera", () => {
-	let e = p(!1);
+});
+//#endregion
+//#region src/store/camera.ts
+const useCameraStore = defineStore("phaser/camera", () => {
+	const isFading = ref(false);
+	const fadeIn = (scene, ...args) => {
+		isFading.value = true;
+		scene.cameras.main.fadeIn(...args);
+	};
+	const fadeOut = (scene, ...args) => {
+		isFading.value = true;
+		scene.cameras.main.fadeOut(...args);
+	};
 	return {
-		fadeIn: (t, ...n) => {
-			e.value = !0, t.cameras.main.fadeIn(...n);
-		},
-		fadeOut: (t, ...n) => {
-			e.value = !0, t.cameras.main.fadeOut(...n);
-		},
-		isFading: e
+		fadeIn,
+		fadeOut,
+		isFading
 	};
-}), Xe = pe("phaser/input", () => ({ isInputActive: p(!1) })), Ze = (e, t) => {
-	let n = O.lifecycleListenersMap.get(t);
-	n?.has(e.scene.key) && n.set(e.scene.key, []);
-}, Q = (e, t, n = !0) => {
-	let r = O.lifecycleListenersMap.get(t);
-	if (!r) return;
-	let i = r.get(e.scene.key);
-	if (i) {
-		for (let t of i) t(e);
-		n && Ze(e, t);
-	}
-}, Qe = (e, t = {}) => class extends ce {
+});
+//#endregion
+//#region src/store/input.ts
+const useInputStore = defineStore("phaser/input", () => {
+	return { isInputActive: ref(false) };
+});
+//#endregion
+//#region src/util/hooks/resetLifecycleListeners.ts
+const resetLifecycleListeners = (scene, lifecycle) => {
+	const listenersMap = ExternalSceneStore.lifecycleListenersMap.get(lifecycle);
+	if (!listenersMap?.has(scene.scene.key)) return;
+	listenersMap.set(scene.scene.key, []);
+};
+//#endregion
+//#region src/util/hooks/runLifecycleListeners.ts
+const runLifecycleListeners = (scene, lifecycle, isReset = true) => {
+	const listenersMap = ExternalSceneStore.lifecycleListenersMap.get(lifecycle);
+	if (!listenersMap) return;
+	const listeners = listenersMap.get(scene.scene.key);
+	if (!listeners) return;
+	for (const listener of listeners) listener(scene);
+	if (isReset) resetLifecycleListeners(scene, lifecycle);
+};
+//#endregion
+//#region src/util/createSceneClass.ts
+const createSceneClass = (key, hooks = {}) => class extends Scene {
 	constructor() {
-		super({ key: e });
+		super({ key });
 	}
 	create() {
-		t.onCreate?.(this), Q(this, D.Create);
+		hooks.onCreate?.(this);
+		runLifecycleListeners(this, "Create");
 	}
 	init() {
-		t.onInit?.(this), Q(this, D.Init);
+		hooks.onInit?.(this);
+		runLifecycleListeners(this, "Init");
 	}
 	preload() {
-		t.onPreload?.(this), Q(this, D.Preload);
+		hooks.onPreload?.(this);
+		runLifecycleListeners(this, "Preload");
 	}
-	update(e, n) {
-		t.onUpdate?.(this, e, n), Q(this, D.Update, !1), Q(this, D.NextTick);
+	update(time, delta) {
+		hooks.onUpdate?.(this, time, delta);
+		runLifecycleListeners(this, "Update", false);
+		runLifecycleListeners(this, "NextTick");
 	}
-}, $e = /* @__PURE__ */ a({
+};
+//#endregion
+//#region src/components/Scene.vue
+const _sfc_main$18 = /*@__PURE__*/ defineComponent({
 	__name: "Scene",
 	props: {
 		autoStart: { type: Boolean },
@@ -599,581 +944,936 @@ var ge = (e, t) => typeof t == "number" ? e.findIndex((e) => "depth" in e && typ
 		"shutdown",
 		"update"
 	],
-	setup(e, { emit: r }) {
-		let i = r, a = j(), { isSameScene: o, switchToScene: s } = a, c = Ye(), { isFading: d } = w(c), p = Xe(), { isInputActive: h } = w(p), { parallelSceneKeys: _ } = w(a), ee = t(() => o(e.sceneKey) || _.value.includes(e.sceneKey)), v = () => {
-			h.value = !1;
-		}, y = () => {
-			d.value = !1, h.value = !0;
-		}, te = () => {
-			d.value = !1;
-		}, b = Qe(e.sceneKey, {
-			onCreate: (e) => {
-				i("create", e), e.cameras.main.on(S.Scene2D.Events.FADE_IN_START, v), e.cameras.main.on(S.Scene2D.Events.FADE_IN_COMPLETE, y), e.cameras.main.on(S.Scene2D.Events.FADE_OUT_START, v), e.cameras.main.on(S.Scene2D.Events.FADE_OUT_COMPLETE, te), h.value = !0;
+	setup(__props, { emit: __emit }) {
+		const emit = __emit;
+		const phaserStore = usePhaserStore();
+		const { isSameScene, switchToScene } = phaserStore;
+		const cameraStore = useCameraStore();
+		const { isFading } = storeToRefs(cameraStore);
+		const inputStore = useInputStore();
+		const { isInputActive } = storeToRefs(inputStore);
+		const { parallelSceneKeys } = storeToRefs(phaserStore);
+		const isActive = computed(() => isSameScene(__props.sceneKey) || parallelSceneKeys.value.includes(__props.sceneKey));
+		const fadeStartListener = () => {
+			isInputActive.value = false;
+		};
+		const fadeInCompleteListener = () => {
+			isFading.value = false;
+			isInputActive.value = true;
+		};
+		const fadeOutCompleteListener = () => {
+			isFading.value = false;
+		};
+		const NewScene = createSceneClass(__props.sceneKey, {
+			onCreate: (scene) => {
+				emit("create", scene);
+				scene.cameras.main.on(Cameras.Scene2D.Events.FADE_IN_START, fadeStartListener);
+				scene.cameras.main.on(Cameras.Scene2D.Events.FADE_IN_COMPLETE, fadeInCompleteListener);
+				scene.cameras.main.on(Cameras.Scene2D.Events.FADE_OUT_START, fadeStartListener);
+				scene.cameras.main.on(Cameras.Scene2D.Events.FADE_OUT_COMPLETE, fadeOutCompleteListener);
+				isInputActive.value = true;
 			},
-			onInit: (e) => i("init", e),
-			onPreload: (e) => i("preload", e),
-			onUpdate: (e, t, n) => i("update", e, t, n)
-		}), x = () => {
-			O.sceneReadyMap.set(e.sceneKey, !0);
-		}, ne = () => {
-			let t = N(e.sceneKey);
-			Ze(t, D.Update), Ze(t, D.NextTick), Q(t, D.Shutdown), t.cameras.main.off(S.Scene2D.Events.FADE_IN_START, v), t.cameras.main.off(S.Scene2D.Events.FADE_IN_COMPLETE, y), t.cameras.main.off(S.Scene2D.Events.FADE_OUT_START, v), t.cameras.main.off(S.Scene2D.Events.FADE_OUT_COMPLETE, te), O.sceneReadyMap.set(e.sceneKey, !1), i("shutdown", t);
+			onInit: (scene) => emit("init", scene),
+			onPreload: (scene) => emit("preload", scene),
+			onUpdate: (scene, time, delta) => emit("update", scene, time, delta)
+		});
+		const readyListener = () => {
+			ExternalSceneStore.sceneReadyMap.set(__props.sceneKey, true);
+		};
+		const shutdownListener = () => {
+			const scene = getScene(__props.sceneKey);
+			resetLifecycleListeners(scene, "Update");
+			resetLifecycleListeners(scene, "NextTick");
+			runLifecycleListeners(scene, "Shutdown");
+			scene.cameras.main.off(Cameras.Scene2D.Events.FADE_IN_START, fadeStartListener);
+			scene.cameras.main.off(Cameras.Scene2D.Events.FADE_IN_COMPLETE, fadeInCompleteListener);
+			scene.cameras.main.off(Cameras.Scene2D.Events.FADE_OUT_START, fadeStartListener);
+			scene.cameras.main.off(Cameras.Scene2D.Events.FADE_OUT_COMPLETE, fadeOutCompleteListener);
+			ExternalSceneStore.sceneReadyMap.set(__props.sceneKey, false);
+			emit("shutdown", scene);
 		};
-		return l(async () => {
-			let t = M().scene.add(e.sceneKey, b);
-			if (!t) {
-				console.error(`Failed to add scene: ${e.sceneKey}`);
+		onMounted(async () => {
+			const scene = useGame().scene.add(__props.sceneKey, NewScene);
+			if (!scene) {
+				console.error(`Failed to add scene: ${__props.sceneKey}`);
 				return;
 			}
-			t.events.on(le.Events.READY, x), t.events.on(le.Events.SHUTDOWN, ne), e.autoStart && await s(e.sceneKey);
-		}), u(() => {
-			let t = M(), n = N(e.sceneKey);
-			n.events.off(le.Events.READY, x), n.events.off(le.Events.SHUTDOWN, ne), t.scene.remove(e.sceneKey);
-		}), f(T.SceneKey, e.sceneKey), (e, t) => g(ee) ? m(e.$slots, "default", {}, void 0, void 0, 0) : n("", !0);
+			scene.events.on(Scenes.Events.READY, readyListener);
+			scene.events.on(Scenes.Events.SHUTDOWN, shutdownListener);
+			if (__props.autoStart) await switchToScene(__props.sceneKey);
+		});
+		onUnmounted(() => {
+			const game = useGame();
+			const scene = getScene(__props.sceneKey);
+			scene.events.off(Scenes.Events.READY, readyListener);
+			scene.events.off(Scenes.Events.SHUTDOWN, shutdownListener);
+			game.scene.remove(__props.sceneKey);
+		});
+		provide(InjectionKeyMap.SceneKey, __props.sceneKey);
+		return (_ctx, _cache) => {
+			return isActive.value ? renderSlot(_ctx.$slots, "default", {}, void 0, void 0, 0) : createCommentVNode("v-if", true);
+		};
 	}
-}), et = {
-	...H,
-	...U,
-	...I,
-	...W,
-	...G,
-	...L,
-	...K,
-	...R,
-	...Z,
-	...q,
-	...z,
-	...B,
-	...V
-}, tt = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/RenderTextureSetterMap.ts
+const RenderTextureSetterMap = {
+	...AlphaSetterMap,
+	...BlendModeSetterMap,
+	...DepthSetterMap,
+	...FlipSetterMap,
+	...MaskSetterMap,
+	...OriginSetterMap,
+	...RenderNodesSetterMap,
+	...ScrollFactorSetterMap,
+	...SizeSetterMap,
+	...TintSetterMap,
+	...TransformSetterMap,
+	...VisibleSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/RenderTexture.vue
+const _sfc_main$17 = /*@__PURE__*/ defineComponent({
 	__name: "RenderTexture",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { height: n, width: r, x: i, y: a } = e.configuration, o = t.add.renderTexture(i ?? 0, a ?? 0, r, n);
-			return e.onComplete?.(t, o), o;
-		}, () => e.configuration, t, et, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { height, width, x, y } = __props.configuration;
+			const renderTexture = scene.add.renderTexture(x ?? 0, y ?? 0, width, height);
+			__props.onComplete?.(scene, renderTexture);
+			return renderTexture;
+		}, () => __props.configuration, __emit, RenderTextureSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), nt = {
-	height: F.height,
-	width: F.width,
-	...Y,
-	...V
-}, rt = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/RectangleSetterMap.ts
+const RectangleSetterMap = {
+	height: ComputedSizeSetterMap.height,
+	width: ComputedSizeSetterMap.width,
+	...ShapeSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Rectangle.vue
+const _sfc_main$16 = /*@__PURE__*/ defineComponent({
 	__name: "Rectangle",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { alpha: n, fillColor: r, height: i, width: a, x: o, y: s } = e.configuration, c = t.add.rectangle(o, s, a, i, r, n);
-			return e.onComplete?.(t, c), c;
-		}, () => e.configuration, t, nt, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { alpha, fillColor, height, width, x, y } = __props.configuration;
+			const rectangle = scene.add.rectangle(x, y, width, height, fillColor, alpha);
+			__props.onComplete?.(scene, rectangle);
+			return rectangle;
+		}, () => __props.configuration, __emit, RectangleSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), it = {
-	points: (e) => (t) => {
-		t && e.setTo(t);
-	},
-	...Y,
-	...V
-}, at = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/PolygonSetterMap.ts
+const PolygonSetterMap = {
+	points: (gameObject) => (value) => {
+		if (!value) return;
+		gameObject.setTo(value);
+	},
+	...ShapeSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Polygon.vue
+const _sfc_main$15 = /*@__PURE__*/ defineComponent({
 	__name: "Polygon",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { alpha: n, fillColor: r, points: i, x: a, y: o } = e.configuration, s = t.add.polygon(a, o, i, r, n);
-			return e.onComplete?.(t, s), s;
-		}, () => e.configuration, t, it, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { alpha, fillColor, points, x, y } = __props.configuration;
+			const polygon = scene.add.polygon(x, y, points, fillColor, alpha);
+			__props.onComplete?.(scene, polygon);
+			return polygon;
+		}, () => __props.configuration, __emit, PolygonSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), ot = { path: (e) => (t) => {
-	t && e.setPath(t);
-} }, st = {
-	...H,
-	...U,
-	...I,
-	...W,
-	...G,
-	...L,
-	...ot,
-	...K,
-	...R,
-	...Z,
-	...X,
-	...q,
-	...z,
-	...B,
-	...V
-}, ct = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/components/PathFollowerComponentSetterMap.ts
+const PathFollowerComponentSetterMap = { path: (gameObject) => (value) => {
+	if (!value) return;
+	gameObject.setPath(value);
+} };
+//#endregion
+//#region src/util/setterMap/PathFollowerSetterMap.ts
+const PathFollowerSetterMap = {
+	...AlphaSetterMap,
+	...BlendModeSetterMap,
+	...DepthSetterMap,
+	...FlipSetterMap,
+	...MaskSetterMap,
+	...OriginSetterMap,
+	...PathFollowerComponentSetterMap,
+	...RenderNodesSetterMap,
+	...ScrollFactorSetterMap,
+	...SizeSetterMap,
+	...TextureSetterMap,
+	...TintSetterMap,
+	...TransformSetterMap,
+	...VisibleSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/PathFollower.vue
+const _sfc_main$14 = /*@__PURE__*/ defineComponent({
 	__name: "PathFollower",
 	props: {
 		configuration: {},
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { frame: n, path: r, texture: i, x: a, y: o } = e.configuration, s = t.add.follower(r, a ?? 0, o ?? 0, i, n);
-			return e.onComplete?.(t, s), s;
-		}, () => e.configuration, t, st), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { frame, path, texture, x, y } = __props.configuration;
+			const pathFollower = scene.add.follower(path, x ?? 0, y ?? 0, texture, frame);
+			__props.onComplete?.(scene, pathFollower);
+			return pathFollower;
+		}, () => __props.configuration, __emit, PathFollowerSetterMap);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), lt = {
-	...J,
-	...U,
-	...I,
-	...G,
-	...K,
-	...R,
-	...X,
-	...z,
-	...B,
-	...V,
-	config: (e) => (t) => {
-		t && e.setConfig(t);
+});
+//#endregion
+//#region src/util/setterMap/ParticlesSetterMap.ts
+const ParticlesSetterMap = {
+	...AlphaSingleSetterMap,
+	...BlendModeSetterMap,
+	...DepthSetterMap,
+	...MaskSetterMap,
+	...RenderNodesSetterMap,
+	...ScrollFactorSetterMap,
+	...TextureSetterMap,
+	...TransformSetterMap,
+	...VisibleSetterMap,
+	...GlobalSetterMap,
+	config: (gameObject) => (value) => {
+		if (!value) return;
+		gameObject.setConfig(value);
 	}
-}, ut = /* @__PURE__ */ a({
+};
+//#endregion
+//#region src/components/Particles.vue
+const _sfc_main$13 = /*@__PURE__*/ defineComponent({
 	__name: "Particles",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { config: n, texture: r, x: i, y: a } = e.configuration, o = t.add.particles(i ?? 0, a ?? 0, r, n);
-			return e.onComplete?.(t, o), o;
-		}, () => e.configuration, t, lt, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { config, texture, x, y } = __props.configuration;
+			const particles = scene.add.particles(x ?? 0, y ?? 0, texture, config);
+			__props.onComplete?.(scene, particles);
+			return particles;
+		}, () => __props.configuration, __emit, ParticlesSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), dt = {
-	height: F.height,
-	width: F.width,
-	...J,
-	...U,
-	...I,
-	...G,
-	...L,
-	...K,
-	...R,
-	...X,
-	...z,
-	...B,
-	...V
-}, ft = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/NinesliceSetterMap.ts
+const NinesliceSetterMap = {
+	height: ComputedSizeSetterMap.height,
+	width: ComputedSizeSetterMap.width,
+	...AlphaSingleSetterMap,
+	...BlendModeSetterMap,
+	...DepthSetterMap,
+	...MaskSetterMap,
+	...OriginSetterMap,
+	...RenderNodesSetterMap,
+	...ScrollFactorSetterMap,
+	...TextureSetterMap,
+	...TransformSetterMap,
+	...VisibleSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Nineslice.vue
+const _sfc_main$12 = /*@__PURE__*/ defineComponent({
 	__name: "Nineslice",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { bottomHeight: n, frame: r, height: i, leftWidth: a, rightWidth: o, texture: s, topHeight: c, width: l, x: u, y: d } = e.configuration, f = t.add.nineslice(u ?? 0, d ?? 0, s, r, l, i, a, o, c, n);
-			return e.onComplete?.(t, f), f;
-		}, () => e.configuration, t, dt, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { bottomHeight, frame, height, leftWidth, rightWidth, texture, topHeight, width, x, y } = __props.configuration;
+			const nineSlice = scene.add.nineslice(x ?? 0, y ?? 0, texture, frame, width, height, leftWidth, rightWidth, topHeight, bottomHeight);
+			__props.onComplete?.(scene, nineSlice);
+			return nineSlice;
+		}, () => __props.configuration, __emit, NinesliceSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), pt = {
-	lineWidth: (e) => (t) => {
-		t !== void 0 && e.setLineWidth(t);
-	},
-	to: (e) => (t) => {
-		t && e.setTo(...t);
-	},
-	...Y,
-	...V
-}, mt = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/LineSetterMap.ts
+const LineSetterMap = {
+	lineWidth: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setLineWidth(value);
+	},
+	to: (gameObject) => (value) => {
+		if (!value) return;
+		gameObject.setTo(...value);
+	},
+	...ShapeSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Line.vue
+const _sfc_main$11 = /*@__PURE__*/ defineComponent({
 	__name: "Line",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { to: n, x: r, y: i } = e.configuration, a = t.add.line(r, i, n?.[0], n?.[1], n?.[2], n?.[3]);
-			return e.onComplete?.(t, a), a;
-		}, () => e.configuration, t, pt, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { to, x, y } = __props.configuration;
+			const line = scene.add.line(x, y, to?.[0], to?.[1], to?.[2], to?.[3]);
+			__props.onComplete?.(scene, line);
+			return line;
+		}, () => __props.configuration, __emit, LineSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), ht = {
-	fillLeft: (e) => (t) => {
-		t !== void 0 && e.setFillStyle(e.fillTop, t, e.fillRight);
-	},
-	fillRight: (e) => (t) => {
-		t !== void 0 && e.setFillStyle(e.fillTop, e.fillLeft, t);
-	},
-	fillTop: (e) => (t) => {
-		t !== void 0 && e.setFillStyle(t, e.fillLeft, e.fillRight);
-	},
-	projection: (e) => (t) => {
-		t !== void 0 && e.setProjection(t);
-	},
-	showLeft: (e) => (t) => {
-		t !== void 0 && e.setFaces(e.showTop, t, e.showRight);
-	},
-	showRight: (e) => (t) => {
-		t !== void 0 && e.setFaces(e.showTop, e.showLeft, t);
-	},
-	showTop: (e) => (t) => {
-		t !== void 0 && e.setFaces(t, e.showLeft, e.showRight);
+});
+//#endregion
+//#region src/util/setterMap/shared/IsoSetterMap.ts
+const IsoSetterMap = {
+	fillLeft: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setFillStyle(gameObject.fillTop, value, gameObject.fillRight);
+	},
+	fillRight: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setFillStyle(gameObject.fillTop, gameObject.fillLeft, value);
+	},
+	fillTop: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setFillStyle(value, gameObject.fillLeft, gameObject.fillRight);
+	},
+	projection: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setProjection(value);
+	},
+	showLeft: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setFaces(gameObject.showTop, value, gameObject.showRight);
+	},
+	showRight: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setFaces(gameObject.showTop, gameObject.showLeft, value);
+	},
+	showTop: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setFaces(value, gameObject.showLeft, gameObject.showRight);
 	}
-}, gt = {
-	isReversed: (e) => (t) => {
-		t !== void 0 && e.setReversed(t);
-	},
-	...ht,
-	...Y,
-	...V
-}, _t = /* @__PURE__ */ a({
+};
+//#endregion
+//#region src/util/setterMap/IsoTriangleSetterMap.ts
+const IsoTriangleSetterMap = {
+	isReversed: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setReversed(value);
+	},
+	...IsoSetterMap,
+	...ShapeSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/IsoTriangle.vue
+const _sfc_main$10 = /*@__PURE__*/ defineComponent({
 	__name: "IsoTriangle",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { fillLeft: n, fillRight: r, fillTop: i, height: a, isReversed: o, size: s, x: c, y: l } = e.configuration, u = t.add.isotriangle(c, l, s, a, o, i, n, r);
-			return e.onComplete?.(t, u), u;
-		}, () => e.configuration, t, gt, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { fillLeft, fillRight, fillTop, height, isReversed, size, x, y } = __props.configuration;
+			const isoTriangle = scene.add.isotriangle(x, y, size, height, isReversed, fillTop, fillLeft, fillRight);
+			__props.onComplete?.(scene, isoTriangle);
+			return isoTriangle;
+		}, () => __props.configuration, __emit, IsoTriangleSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), vt = {
-	...ht,
-	...Y,
-	...V
-}, yt = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/IsoBoxSetterMap.ts
+const IsoBoxSetterMap = {
+	...IsoSetterMap,
+	...ShapeSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/IsoBox.vue
+const _sfc_main$9 = /*@__PURE__*/ defineComponent({
 	__name: "IsoBox",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { fillLeft: n, fillRight: r, fillTop: i, height: a, size: o, x: s, y: c } = e.configuration, l = t.add.isobox(s, c, o, a, i, n, r);
-			return e.onComplete?.(t, l), l;
-		}, () => e.configuration, t, vt, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { fillLeft, fillRight, fillTop, height, size, x, y } = __props.configuration;
+			const isoBox = scene.add.isobox(x, y, size, height, fillTop, fillLeft, fillRight);
+			__props.onComplete?.(scene, isoBox);
+			return isoBox;
+		}, () => __props.configuration, __emit, IsoBoxSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), bt = {
-	...H,
-	...U,
-	...I,
-	...W,
-	...G,
-	...L,
-	...K,
-	...R,
-	...Z,
-	...Ne,
-	...q,
-	...z,
-	...B,
-	...V
-}, xt = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/ImageSetterMap.ts
+const ImageSetterMap = {
+	...AlphaSetterMap,
+	...BlendModeSetterMap,
+	...DepthSetterMap,
+	...FlipSetterMap,
+	...MaskSetterMap,
+	...OriginSetterMap,
+	...RenderNodesSetterMap,
+	...ScrollFactorSetterMap,
+	...SizeSetterMap,
+	...TextureCropSetterMap,
+	...TintSetterMap,
+	...TransformSetterMap,
+	...VisibleSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Image.vue
+const _sfc_main$8 = /*@__PURE__*/ defineComponent({
 	__name: "Image",
 	props: {
 		configuration: {},
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { frame: n, texture: r, x: i, y: a } = e.configuration, o = t.add.image(i ?? 0, a ?? 0, r, n);
-			return e.onComplete?.(t, o), o;
-		}, () => e.configuration, t, bt), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { frame, texture, x, y } = __props.configuration;
+			const image = scene.add.image(x ?? 0, y ?? 0, texture, frame);
+			__props.onComplete?.(scene, image);
+			return image;
+		}, () => __props.configuration, __emit, ImageSetterMap);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), St = {
-	...J,
-	...U,
-	...I,
-	...G,
-	...K,
-	...R,
-	...z,
-	...B,
-	...V
-}, Ct = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/GraphicsSetterMap.ts
+const GraphicsSetterMap = {
+	...AlphaSingleSetterMap,
+	...BlendModeSetterMap,
+	...DepthSetterMap,
+	...MaskSetterMap,
+	...RenderNodesSetterMap,
+	...ScrollFactorSetterMap,
+	...TransformSetterMap,
+	...VisibleSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Graphics.vue
+const _sfc_main$7 = /*@__PURE__*/ defineComponent({
 	__name: "Graphics",
 	props: {
 		configuration: { default: () => ({}) },
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { x: n, y: r } = e.configuration, i = t.add.graphics({
-				x: n,
-				y: r
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { x, y } = __props.configuration;
+			const graphics = scene.add.graphics({
+				x,
+				y
 			});
-			return e.onComplete?.(t, i), i;
-		}, () => e.configuration, t, St, e.immediate), (e, t) => null;
+			__props.onComplete?.(scene, graphics);
+			return graphics;
+		}, () => __props.configuration, __emit, GraphicsSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), wt = C.FileTypes.XMLFile, Tt = class extends wt {
+});
+//#endregion
+//#region src/models/plugins/TilesetFile.ts
+const XMLFile = Loader.FileTypes.XMLFile;
+var TilesetFile = class extends XMLFile {
 	tilesetIndex;
-	constructor(e, ...t) {
-		super(...t), this.tilesetIndex = e;
+	constructor(tilesetIndex, ...args) {
+		super(...args);
+		this.tilesetIndex = tilesetIndex;
 	}
-}, $ = fe.Objects.GetFastValue, Et = C.FileTypes.JSONFile, Dt = C.MultiFile, Ot = class extends Dt {
-	constructor(e, t, n, r, i, a, o) {
-		if (ne(t)) {
-			let e = t;
-			t = $(e, "key"), n = $(e, "url"), a = $(e, "xhrSettings"), r = $(e, "path"), i = $(e, "baseURL"), o = $(e, "tilesetXhrSettings");
+};
+//#endregion
+//#region src/models/plugins/TiledJSONExternalFile.ts
+const GetFastValue = Utils.Objects.GetFastValue;
+const JSONFile$1 = Loader.FileTypes.JSONFile;
+const MultiFile = Loader.MultiFile;
+var TiledJSONExternalFile = class extends MultiFile {
+	constructor(loader, key, tilemapURL, path, baseURL, tilemapXhrSettings, tilesetXhrSettings) {
+		if (checkIsPlainObject(key)) {
+			const configuration = key;
+			key = GetFastValue(configuration, "key");
+			tilemapURL = GetFastValue(configuration, "url");
+			tilemapXhrSettings = GetFastValue(configuration, "xhrSettings");
+			path = GetFastValue(configuration, "path");
+			baseURL = GetFastValue(configuration, "baseURL");
+			tilesetXhrSettings = GetFastValue(configuration, "tilesetXhrSettings");
 		}
-		let s = new Et(e, t, n, a);
-		super(e, "tilemapJSON", t, [s]), this.config.path = r, this.config.baseURL = i, this.config.tilesetXhrSettings = o;
+		const tilemapFile = new JSONFile$1(loader, key, tilemapURL, tilemapXhrSettings);
+		super(loader, "tilemapJSON", key, [tilemapFile]);
+		this.config.path = path;
+		this.config.baseURL = baseURL;
+		this.config.tilesetXhrSettings = tilesetXhrSettings;
 	}
 	async addToCache() {
 		if (!this.isReadyToProcess()) return;
-		let [e, ...t] = this.files;
-		if (!(e.type === "json" && Object.hasOwn(e.data, "tilesets"))) return;
-		let n = e.data, r = e.key, i = this.loader, a = this.files;
-		this.complete = !0;
-		for (let e of t) {
-			let t = e.xhrLoader?.responseText;
-			if (!t) throw new y(x.Read, this.addToCache.name, e.key);
-			let r = await he(t), i = me(r.tileset), a = e.tilesetIndex;
-			Object.assign(n.tilesets[a], i, {
-				imageheight: i.image.height,
-				imagewidth: i.image.width,
+		const [tilemapFile, ...tilesetFiles] = this.files;
+		if (!(tilemapFile.type === "json" && Object.hasOwn(tilemapFile.data, "tilesets"))) return;
+		const tilemapData = tilemapFile.data;
+		const tilemapKey = tilemapFile.key;
+		const loader = this.loader;
+		const files = this.files;
+		this.complete = true;
+		for (const tilesetFile of tilesetFiles) {
+			const responseText = tilesetFile.xhrLoader?.responseText;
+			if (!responseText) throw new InvalidOperationError(Operation.Read, this.addToCache.name, tilesetFile.key);
+			const responseData = await parseXmlString(responseText);
+			const tilesetData = parseTileset(responseData.tileset);
+			const index = tilesetFile.tilesetIndex;
+			Object.assign(tilemapData.tilesets[index], tilesetData, {
+				imageheight: tilesetData.image.height,
+				imagewidth: tilesetData.image.width,
 				source: void 0
 			});
 		}
-		i.cacheManager.tilemap.add(r, {
-			data: n,
-			format: ue.Formats.TILED_JSON
+		loader.cacheManager.tilemap.add(tilemapKey, {
+			data: tilemapData,
+			format: Tilemaps.Formats.TILED_JSON
 		});
-		for (let e of a) e.pendingDestroy();
+		for (const file of files) file.pendingDestroy();
 	}
-	onFileComplete(e) {
-		if (this.files.indexOf(e) === -1 || (this.pending--, !(e.type === "json" && Object.hasOwn(e.data, "tilesets")))) return;
-		let t = e.data.tilesets, n = this.config, r = this.loader, i = r.baseURL, a = r.path, o = r.prefix, s = $(n, "baseURL", i), c = $(n, "path", a), l = $(n, "prefix", o), u = $(n, "tilesetXhrSettings");
-		r.setBaseURL(s), r.setPath(c), r.setPrefix(l);
-		for (let [n, i] of t.entries()) {
-			let t = i.source.indexOf("public");
-			if (t === -1) throw new te(this.onFileComplete.name, i.source);
-			let a = i.source.slice(t + 6), o = new Tt(n, r, `${e.key}${v}Tileset${v}${a}`, a, u);
-			this.addToMultiFile(o), r.addFile(o);
+	onFileComplete(file) {
+		if (this.files.indexOf(file) === -1) return;
+		this.pending--;
+		if (!(file.type === "json" && Object.hasOwn(file.data, "tilesets"))) return;
+		const tilesets = file.data.tilesets;
+		const config = this.config;
+		const loader = this.loader;
+		const currentBaseURL = loader.baseURL;
+		const currentPath = loader.path;
+		const currentPrefix = loader.prefix;
+		const baseURL = GetFastValue(config, "baseURL", currentBaseURL);
+		const path = GetFastValue(config, "path", currentPath);
+		const prefix = GetFastValue(config, "prefix", currentPrefix);
+		const tilesetXhrSettings = GetFastValue(config, "tilesetXhrSettings");
+		loader.setBaseURL(baseURL);
+		loader.setPath(path);
+		loader.setPrefix(prefix);
+		for (const [tilesetIndex, tileset] of tilesets.entries()) {
+			const pathIndex = tileset.source.indexOf("public");
+			if (pathIndex === -1) throw new NotFoundError(this.onFileComplete.name, tileset.source);
+			const relativePath = tileset.source.slice(pathIndex + 6);
+			const tilesetFile = new TilesetFile(tilesetIndex, loader, `${file.key}${ID_SEPARATOR}Tileset${ID_SEPARATOR}${relativePath}`, relativePath, tilesetXhrSettings);
+			this.addToMultiFile(tilesetFile);
+			loader.addFile(tilesetFile);
 		}
-		r.setBaseURL(i), r.setPath(a), r.setPrefix(o);
+		loader.setBaseURL(currentBaseURL);
+		loader.setPath(currentPath);
+		loader.setPrefix(currentPrefix);
 	}
-}, kt = "tilemapTiledJSONExternal", At = C.FileTypesManager, jt = () => {
-	At.register(kt, function(...[e, t, n, r, i, a]) {
-		if (Array.isArray(e)) for (let t of e) {
-			let e = new Ot(this, t);
-			this.addFile(e.files);
+};
+//#endregion
+//#region src/util/constants.ts
+const TILEMAP_TILED_JSON_EXTERNAL_KEY = "tilemapTiledJSONExternal";
+//#endregion
+//#region src/plugins/registerTiledJSONExternalLoader.ts
+const FileTypesManager = Loader.FileTypesManager;
+const registerTiledJSONExternalLoader = () => {
+	FileTypesManager.register(TILEMAP_TILED_JSON_EXTERNAL_KEY, function(...[key, tilemapURL, path, baseURL, tilemapXhrSettings, tilesetXhrSettings]) {
+		if (Array.isArray(key)) for (const keyElement of key) {
+			const multifile = new TiledJSONExternalFile(this, keyElement);
+			this.addFile(multifile.files);
 		}
 		else {
-			let o = new Ot(this, e, t, n, r, i, a);
-			this.addFile(o.files);
+			const multifile = new TiledJSONExternalFile(this, key, tilemapURL, path, baseURL, tilemapXhrSettings, tilesetXhrSettings);
+			this.addFile(multifile.files);
 		}
 		return this;
 	});
-}, Mt = /* @__PURE__ */ a({
+};
+//#endregion
+//#region src/components/Game.vue
+const _sfc_main$6 = /*@__PURE__*/ defineComponent({
 	__name: "Game",
 	props: { configuration: {} },
-	setup(t) {
-		let a = j(), { game: o } = w(a), s = _("canvasRoot"), c = p(!1), f = () => {
-			c.value = !0;
+	setup(__props) {
+		const phaserStore = usePhaserStore();
+		const { game: storeGame } = storeToRefs(phaserStore);
+		const canvasRoot = useTemplateRef("canvasRoot");
+		const isReady = ref(false);
+		const readyListener = () => {
+			isReady.value = true;
+		};
+		onMounted(() => {
+			registerTiledJSONExternalLoader();
+			storeGame.value = new Game({
+				...__props.configuration,
+				parent: canvasRoot.value
+			});
+			storeGame.value.events.on("ready", readyListener);
+		});
+		onUnmounted(() => {
+			const game = useGame();
+			game.events.off("ready", readyListener);
+			game.destroy(true);
+			storeGame.value = void 0;
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock(Fragment, null, [createElementVNode("div", {
+				ref_key: "canvasRoot",
+				ref: canvasRoot
+			}, null, 512), isReady.value ? renderSlot(_ctx.$slots, "default", {}, void 0, void 0, 0) : createCommentVNode("v-if", true)], 64);
 		};
-		return l(() => {
-			jt(), o.value = new se({
-				...t.configuration,
-				parent: s.value
-			}), o.value.events.on("ready", f);
-		}), u(() => {
-			let e = M();
-			e.events.off("ready", f), e.destroy(!0), o.value = void 0;
-		}), (t, a) => (d(), r(e, null, [i("div", {
-			ref_key: "canvasRoot",
-			ref: s
-		}, null, 512), g(c) ? m(t.$slots, "default", {}, void 0, void 0, 0) : n("", !0)], 64));
 	}
-}), Nt = {
-	height: F.height,
-	smoothness: (e) => (t) => {
-		t !== void 0 && e.setSmoothness(t);
-	},
-	width: F.width,
-	...Y,
-	...V
-}, Pt = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/EllipseSetterMap.ts
+const EllipseSetterMap = {
+	height: ComputedSizeSetterMap.height,
+	smoothness: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setSmoothness(value);
+	},
+	width: ComputedSizeSetterMap.width,
+	...ShapeSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Ellipse.vue
+const _sfc_main$5 = /*@__PURE__*/ defineComponent({
 	__name: "Ellipse",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { alpha: n, fillColor: r, height: i, width: a, x: o, y: s } = e.configuration, c = t.add.ellipse(o, s, a, i, r, n);
-			return e.onComplete?.(t, c), c;
-		}, () => e.configuration, t, Nt, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { alpha, fillColor, height, width, x, y } = __props.configuration;
+			const ellipse = scene.add.ellipse(x, y, width, height, fillColor, alpha);
+			__props.onComplete?.(scene, ellipse);
+			return ellipse;
+		}, () => __props.configuration, __emit, EllipseSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), Ft = {
-	smoothness: (e) => (t) => {
-		t !== void 0 && e.setSmoothness(t);
-	},
-	...Y,
-	...V
-}, It = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/CurveSetterMap.ts
+const CurveSetterMap = {
+	smoothness: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setSmoothness(value);
+	},
+	...ShapeSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Curve.vue
+const _sfc_main$4 = /*@__PURE__*/ defineComponent({
 	__name: "Curve",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { alpha: n, curve: r, fillColor: i, x: a, y: o } = e.configuration, s = t.add.curve(a, o, r, i, n);
-			return e.onComplete?.(t, s), s;
-		}, () => e.configuration, t, Ft, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { alpha, curve, fillColor, x, y } = __props.configuration;
+			const curveObject = scene.add.curve(x, y, curve, fillColor, alpha);
+			__props.onComplete?.(scene, curveObject);
+			return curveObject;
+		}, () => __props.configuration, __emit, CurveSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), Lt = {
-	...J,
-	...U,
-	...I,
-	...R,
-	...G,
-	...z,
-	...B,
-	...V
-}, Rt = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/ContainerSetterMap.ts
+const ContainerSetterMap = {
+	...AlphaSingleSetterMap,
+	...BlendModeSetterMap,
+	...DepthSetterMap,
+	...ScrollFactorSetterMap,
+	...MaskSetterMap,
+	...TransformSetterMap,
+	...VisibleSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Container.vue
+const _sfc_main$3 = /*@__PURE__*/ defineComponent({
 	__name: "Container",
 	props: {
 		configuration: { default: () => ({}) },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		let n = t, r = p();
-		return P((t) => {
-			let { children: n, x: i, y: a } = e.configuration;
-			return r.value = t.add.container(i, a, n), e.onComplete?.(t, r.value), r.value;
-		}, () => e.configuration, n, Lt), f(T.ParentContainer, r), (e, t) => m(e.$slots, "default");
+	setup(__props, { emit: __emit }) {
+		const emit = __emit;
+		const container = ref();
+		useInitializeGameObject((scene) => {
+			const { children, x, y } = __props.configuration;
+			container.value = scene.add.container(x, y, children);
+			__props.onComplete?.(scene, container.value);
+			return container.value;
+		}, () => __props.configuration, emit, ContainerSetterMap);
+		provide(InjectionKeyMap.ParentContainer, container);
+		return (_ctx, _cache) => {
+			return renderSlot(_ctx.$slots, "default");
+		};
 	}
-}), zt = {
-	closePath: (e) => (t) => {
-		t !== void 0 && e.setClosePath(t);
-	},
-	endAngle: (e) => (t) => {
-		t !== void 0 && e.setEndAngle(t);
-	},
-	radius: (e) => (t) => {
-		t !== void 0 && e.setRadius(t);
-	},
-	startAngle: (e) => (t) => {
-		t !== void 0 && e.setStartAngle(t);
-	},
-	...Y,
-	...V
-}, Bt = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/ArcSetterMap.ts
+const ArcSetterMap = {
+	closePath: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setClosePath(value);
+	},
+	endAngle: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setEndAngle(value);
+	},
+	radius: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setRadius(value);
+	},
+	startAngle: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setStartAngle(value);
+	},
+	...ShapeSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/Circle.vue
+const _sfc_main$2 = /*@__PURE__*/ defineComponent({
 	__name: "Circle",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { alpha: n, fillColor: r, radius: i, x: a, y: o } = e.configuration, s = t.add.circle(a, o, i, r, n);
-			return e.onComplete?.(t, s), s;
-		}, () => e.configuration, t, zt, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { alpha, fillColor, radius, x, y } = __props.configuration;
+			const circle = scene.add.circle(x, y, radius, fillColor, alpha);
+			__props.onComplete?.(scene, circle);
+			return circle;
+		}, () => __props.configuration, __emit, ArcSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), Vt = {
-	align: (e) => (t) => {
-		t !== void 0 && (e.align = t);
-	},
-	dropShadow: (e) => (t) => {
-		t && e.setDropShadow(...t);
-	},
-	font: (e) => (t) => {
-		t && e.setFont(t);
-	},
-	fontSize: (e) => (t) => {
-		t !== void 0 && e.setFontSize(t);
-	},
-	letterSpacing: (e) => (t) => {
-		t !== void 0 && e.setLetterSpacing(t);
-	},
-	lineSpacing: (e) => (t) => {
-		t !== void 0 && e.setLineSpacing(t);
-	},
-	maxWidth: (e) => (t) => {
-		t !== void 0 && e.setMaxWidth(t);
-	},
-	text: (e) => (t) => {
-		t !== void 0 && e.setText(t);
-	},
-	wordWrapCharCode: (e) => (t) => {
-		t !== void 0 && (e.wordWrapCharCode = t);
-	},
-	...H,
-	...U,
-	...I,
-	...G,
-	...L,
-	...K,
-	...R,
-	...q,
-	...z,
-	...B,
-	...V
-}, Ht = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/util/setterMap/BitmapTextSetterMap.ts
+const BitmapTextSetterMap = {
+	align: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.align = value;
+	},
+	dropShadow: (gameObject) => (value) => {
+		if (!value) return;
+		gameObject.setDropShadow(...value);
+	},
+	font: (gameObject) => (value) => {
+		if (!value) return;
+		gameObject.setFont(value);
+	},
+	fontSize: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setFontSize(value);
+	},
+	letterSpacing: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setLetterSpacing(value);
+	},
+	lineSpacing: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setLineSpacing(value);
+	},
+	maxWidth: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setMaxWidth(value);
+	},
+	text: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.setText(value);
+	},
+	wordWrapCharCode: (gameObject) => (value) => {
+		if (value === void 0) return;
+		gameObject.wordWrapCharCode = value;
+	},
+	...AlphaSetterMap,
+	...BlendModeSetterMap,
+	...DepthSetterMap,
+	...MaskSetterMap,
+	...OriginSetterMap,
+	...RenderNodesSetterMap,
+	...ScrollFactorSetterMap,
+	...TintSetterMap,
+	...TransformSetterMap,
+	...VisibleSetterMap,
+	...GlobalSetterMap
+};
+//#endregion
+//#region src/components/BitmapText.vue
+const _sfc_main$1 = /*@__PURE__*/ defineComponent({
 	__name: "BitmapText",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { align: n, font: r, fontSize: i, text: a, x: o, y: s } = e.configuration, c = t.add.bitmapText(o ?? 0, s ?? 0, r, a, i, n);
-			return e.onComplete?.(t, c), c;
-		}, () => e.configuration, t, Vt, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { align, font, fontSize, text, x, y } = __props.configuration;
+			const bitmapText = scene.add.bitmapText(x ?? 0, y ?? 0, font, text, fontSize, align);
+			__props.onComplete?.(scene, bitmapText);
+			return bitmapText;
+		}, () => __props.configuration, __emit, BitmapTextSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), Ut = /* @__PURE__ */ a({
+});
+//#endregion
+//#region src/components/Arc.vue
+const _sfc_main = /*@__PURE__*/ defineComponent({
 	__name: "Arc",
 	props: {
 		configuration: {},
 		immediate: { type: Boolean },
 		onComplete: { type: Function }
 	},
-	setup(e, { emit: t }) {
-		return P((t) => {
-			let { alpha: n, endAngle: r, fillColor: i, radius: a, startAngle: o, x: s, y: c } = e.configuration, l = t.add.arc(s, c, a, o, r, void 0, i, n);
-			return e.onComplete?.(t, l), l;
-		}, () => e.configuration, t, zt, e.immediate), (e, t) => null;
+	setup(__props, { emit: __emit }) {
+		useInitializeGameObject((scene) => {
+			const { alpha, endAngle, fillColor, radius, startAngle, x, y } = __props.configuration;
+			const arc = scene.add.arc(x, y, radius, startAngle, endAngle, void 0, fillColor, alpha);
+			__props.onComplete?.(scene, arc);
+			return arc;
+		}, () => __props.configuration, __emit, ArcSetterMap, __props.immediate);
+		return (_ctx, _cache) => {
+			return null;
+		};
 	}
-}), Wt = (...e) => {
-	k(D.Shutdown, ...e);
-}, Gt = (e, t) => {
-	let n = p([]);
-	return t ? n.value = e(N(E())) : A((t) => {
-		n.value = e(t);
-	}), Wt((e) => {
-		for (let { key: t } of n.value) t && e.anims.remove(t);
-	}), n;
-}, Kt = (e, t) => {
-	e.value = {
-		...t,
-		onComplete: (...n) => {
-			e.value = void 0, t.onComplete?.(...n);
+});
+//#endregion
+//#region src/hooks/onShutdown.ts
+const onShutdown = (...args) => {
+	pushListener("Shutdown", ...args);
+};
+//#endregion
+//#region src/composables/useAnimations.ts
+const useAnimations = (createConfigurations, immediate) => {
+	const animations = ref([]);
+	if (immediate) {
+		const sceneKey = useInjectSceneKey();
+		animations.value = createConfigurations(getScene(sceneKey));
+	} else onNextTick((scene) => {
+		animations.value = createConfigurations(scene);
+	});
+	onShutdown((scene) => {
+		for (const { key } of animations.value) {
+			if (!key) continue;
+			scene.anims.remove(key);
+		}
+	});
+	return animations;
+};
+//#endregion
+//#region src/composables/useTween.ts
+const useTween = (tween, newTween) => {
+	tween.value = {
+		...newTween,
+		onComplete: (...args) => {
+			tween.value = void 0;
+			newTween.onComplete?.(...args);
 		}
 	};
-}, qt = (...e) => {
-	k(D.Init, ...e);
-}, Jt = (...e) => {
-	k(D.Preload, ...e);
-}, Yt = (...e) => {
-	k(D.Update, ...e);
-}, Xt = (e, t) => new Promise((n) => {
-	e.time.delayedCall(t, () => {
-		n();
+};
+//#endregion
+//#region src/hooks/onInit.ts
+const onInit = (...args) => {
+	pushListener("Init", ...args);
+};
+//#endregion
+//#region src/hooks/onPreload.ts
+const onPreload = (...args) => {
+	pushListener("Preload", ...args);
+};
+//#endregion
+//#region src/hooks/onUpdate.ts
+const onUpdate = (...args) => {
+	pushListener("Update", ...args);
+};
+//#endregion
+//#region src/util/sleep.ts
+const sleep = (scene, ms) => new Promise((resolve) => {
+	scene.time.delayedCall(ms, () => {
+		resolve();
 	});
-}), Zt = C.FileTypes.JSONFile, Qt = class extends Zt {};
+});
+//#endregion
+//#region src/models/plugins/TilemapFile.ts
+const JSONFile = Loader.FileTypes.JSONFile;
+var TilemapFile = class extends JSONFile {};
 //#endregion
-export { H as AlphaSetterMap, J as AlphaSingleSetterMap, Ke as AnimationSetterMap, Ut as Arc, zt as ArcSetterMap, Me as BaseTextureSetterMap, Ht as BitmapText, Vt as BitmapTextSetterMap, U as BlendModeSetterMap, Bt as Circle, F as ComputedSizeSetterMap, Rt as Container, Lt as ContainerSetterMap, It as Curve, Ft as CurveSetterMap, I as DepthSetterMap, De as DisplaySizeSetterMap, ye as EVENT_PREFIX, Pt as Ellipse, Nt as EllipseSetterMap, O as ExternalSceneStore, W as FlipSetterMap, Mt as Game, ve as GameObjectEventMap, Oe as GameObjectSetterMap, V as GlobalSetterMap, Ct as Graphics, St as GraphicsSetterMap, xt as Image, bt as ImageSetterMap, T as InjectionKeyMap, yt as IsoBox, vt as IsoBoxSetterMap, ht as IsoSetterMap, _t as IsoTriangle, gt as IsoTriangleSetterMap, D as Lifecycle, mt as Line, pt as LineSetterMap, G as MaskSetterMap, ft as Nineslice, dt as NinesliceSetterMap, L as OriginSetterMap, ut as Particles, lt as ParticlesSetterMap, ct as PathFollower, ot as PathFollowerComponentSetterMap, st as PathFollowerSetterMap, at as Polygon, it as PolygonSetterMap, rt as Rectangle, nt as RectangleSetterMap, K as RenderNodesSetterMap, tt as RenderTexture, et as RenderTextureSetterMap, $e as Scene, R as ScrollFactorSetterMap, Y as ShapeSetterMap, Z as SizeSetterMap, Je as Sprite, qe as SpriteSetterMap, Ge as Star, We as StarSetterMap, kt as TILEMAP_TILED_JSON_EXTERNAL_KEY, Ue as Text, He as TextSetterMap, Ne as TextureCropSetterMap, X as TextureSetterMap, ze as TileSprite, Re as TileSpriteSetterMap, Ot as TiledJSONExternalFile, Be as Tilemap, Qt as TilemapFile, Tt as TilesetFile, q as TintSetterMap, z as TransformSetterMap, Le as Triangle, Ie as TriangleSetterMap, ke as TweenSetterMap, Fe as Video, Pe as VideoSetterMap, B as VisibleSetterMap, je as Zone, Ae as ZoneSetterMap, Qe as createSceneClass, ge as getDepthInsertIndex, be as getEventName, Ee as getInitializeGameObjectLifecycleHook, N as getScene, Ce as getUpdateEvent, xe as isEvent, Te as onCreate, qt as onInit, A as onNextTick, Jt as onPreload, Wt as onShutdown, Yt as onUpdate, _e as pushGameObject, k as pushListener, jt as registerTiledJSONExternalLoader, Ze as resetLifecycleListeners, Q as runLifecycleListeners, Xt as sleep, Gt as useAnimations, Ye as useCameraStore, M as useGame, P as useInitializeGameObject, Se as useInitializeGameObjectEvents, we as useInitializeGameObjectSetters, E as useInjectSceneKey, Xe as useInputStore, j as usePhaserStore, Ve as useTextStore, Kt as useTween };
+export { AlphaSetterMap, AlphaSingleSetterMap, AnimationSetterMap, _sfc_main as Arc, ArcSetterMap, BaseTextureSetterMap, _sfc_main$1 as BitmapText, BitmapTextSetterMap, BlendModeSetterMap, _sfc_main$2 as Circle, ComputedSizeSetterMap, _sfc_main$3 as Container, ContainerSetterMap, _sfc_main$4 as Curve, CurveSetterMap, DepthSetterMap, DisplaySizeSetterMap, EVENT_PREFIX, _sfc_main$5 as Ellipse, EllipseSetterMap, ExternalSceneStore, FlipSetterMap, _sfc_main$6 as Game, GameObjectEventMap, GameObjectSetterMap, GlobalSetterMap, _sfc_main$7 as Graphics, GraphicsSetterMap, _sfc_main$8 as Image, ImageSetterMap, InjectionKeyMap, _sfc_main$9 as IsoBox, IsoBoxSetterMap, IsoSetterMap, _sfc_main$10 as IsoTriangle, IsoTriangleSetterMap, Lifecycle, _sfc_main$11 as Line, LineSetterMap, MaskSetterMap, _sfc_main$12 as Nineslice, NinesliceSetterMap, OriginSetterMap, _sfc_main$13 as Particles, ParticlesSetterMap, _sfc_main$14 as PathFollower, PathFollowerComponentSetterMap, PathFollowerSetterMap, _sfc_main$15 as Polygon, PolygonSetterMap, _sfc_main$16 as Rectangle, RectangleSetterMap, RenderNodesSetterMap, _sfc_main$17 as RenderTexture, RenderTextureSetterMap, _sfc_main$18 as Scene, ScrollFactorSetterMap, ShapeSetterMap, SizeSetterMap, _sfc_main$19 as Sprite, SpriteSetterMap, _sfc_main$20 as Star, StarSetterMap, TILEMAP_TILED_JSON_EXTERNAL_KEY, _sfc_main$21 as Text, TextSetterMap, TextureCropSetterMap, TextureSetterMap, _sfc_main$22 as TileSprite, TileSpriteSetterMap, TiledJSONExternalFile, _sfc_main$23 as Tilemap, TilemapFile, TilesetFile, TintSetterMap, TransformSetterMap, _sfc_main$24 as Triangle, TriangleSetterMap, TweenSetterMap, _sfc_main$25 as Video, VideoSetterMap, VisibleSetterMap, _sfc_main$26 as Zone, ZoneSetterMap, createSceneClass, getDepthInsertIndex, getEventName, getInitializeGameObjectLifecycleHook, getScene, getUpdateEvent, isEvent, onCreate, onInit, onNextTick, onPreload, onShutdown, onUpdate, pushGameObject, pushListener, registerTiledJSONExternalLoader, resetLifecycleListeners, runLifecycleListeners, sleep, useAnimations, useCameraStore, useGame, useInitializeGameObject, useInitializeGameObjectEvents, useInitializeGameObjectSetters, useInjectSceneKey, useInputStore, usePhaserStore, useTextStore, useTween };