entt-js 0.0.0

package/dist/browser/entt.js

@@ -0,0 +1,4004 @@
+var entt = (function(exports) {
+
+
+//#region src/error.ts
+	const NotConstructorError = /* @__PURE__ */ (function() {
+		class NotConstructorError$1 extends TypeError {
+			constructor(message) {
+				super(message);
+			}
+		}
+		Object.defineProperty(NotConstructorError$1.prototype, "name", {
+			value: "NotConstructorError",
+			configurable: true
+		});
+		return NotConstructorError$1;
+	})();
+
+//#endregion
+//#region src/util.ts
+	const assert = typeof ENTT_ASSERT !== "undefined" ? ENTT_ASSERT : /* @__NO_SIDE_EFFECTS__ */ function(condition, message) {
+		if (!condition) throw new AssertionError(message);
+	};
+	function cloneObject(obj, result) {
+		if (typeof obj.clone === "function") return obj.clone();
+		const descriptors = Object.getOwnPropertyDescriptors(obj);
+		result ??= Object.create(Object.getPrototypeOf(obj));
+		for (const [key, descriptor] of Object.entries(descriptors)) Object.defineProperty(result, key, {
+			...descriptor,
+			..."value" in descriptor ? { value: clone(descriptor.value) } : void 0
+		});
+		return result;
+	}
+	function clone(obj) {
+		const type = typeof obj;
+		if (type !== "object" || obj === null) {
+			if (type === "symbol") {
+				if (Symbol.keyFor(obj) != null) throw new Error("Cannot clone global symbol");
+				return Symbol(obj.description);
+			}
+			if (type === "function") return function() {
+				return obj.apply(this, arguments);
+			};
+			return obj;
+		}
+		if (Array.isArray(obj) || obj instanceof ArrayBuffer || ArrayBuffer.isView(obj) || obj instanceof DataView || obj instanceof Date || obj instanceof RegExp || obj instanceof Map || obj instanceof Set || obj instanceof Error || obj instanceof Number || obj instanceof String || obj instanceof Boolean) try {
+			const result = structuredClone(obj);
+			Object.setPrototypeOf(result, Object.getPrototypeOf(obj));
+			return result;
+		} catch (_) {
+			if (Array.isArray(obj)) return obj.map((v) => clone(v));
+			if (obj instanceof ArrayBuffer) return obj.slice(0);
+			if (ArrayBuffer.isView(obj)) return new obj.constructor(obj.buffer, obj.byteOffset, obj.byteLength / obj.constructor.BYTES_PER_ELEMENT);
+			if (obj instanceof DataView) return new DataView(obj.buffer, obj.byteOffset, obj.byteLength);
+			if (obj instanceof Date) return new Date(obj.getTime());
+			if (obj instanceof RegExp) return new RegExp(obj.source, obj.flags);
+			if (obj instanceof Map) {
+				const result = /* @__PURE__ */ new Map();
+				obj.forEach((v, k) => {
+					result.set(clone(k), clone(v));
+				});
+				return result;
+			}
+			if (obj instanceof Set) {
+				const result = /* @__PURE__ */ new Set();
+				obj.forEach((v) => {
+					result.add(clone(v));
+				});
+				return result;
+			}
+			if (obj instanceof Error) return cloneObject(obj, new obj.constructor(obj.message));
+			if (obj instanceof Number || obj instanceof String || obj instanceof Boolean) {
+				const Ctor = obj.constructor;
+				return new Ctor(obj.valueOf());
+			}
+		}
+		if (obj instanceof Promise) return obj.then(clone);
+		return cloneObject(obj);
+	}
+	function popcount(value) {
+		const b = typeof value === "bigint";
+		if (!b) value = value >>> 0;
+		const _1 = b ? BigInt(1) : 1;
+		return value ? Number((value & _1) + (b ? BigInt(popcount(value >> _1)) : popcount(value >>> _1))) : 0;
+	}
+	function defineStaticMethod(Class, name, method) {
+		Object.defineProperty(Class, name, {
+			value: method,
+			configurable: true,
+			writable: true
+		});
+	}
+	function inherits(Derived, Base) {
+		Object.setPrototypeOf(Derived, Base);
+		Object.setPrototypeOf(Derived.prototype, Base.prototype);
+		Object.defineProperty(Derived, "super_", {
+			value: Base,
+			writable: true,
+			configurable: true
+		});
+	}
+	function hasSingleBit(value) {
+		if (!(value >= 0 && (value | 0n) === value)) throw new TypeError("value must be unsigned integer");
+		return value !== 0n && (value & value - 1n) === 0n;
+	}
+	function fastMod(value, mod) {
+		if (!(value >= 0n && (value | 0n) === value)) throw new TypeError("value must be unsigned integer");
+		assert(hasSingleBit(mod), "mod must be a power of two");
+		return Number(value & mod - 1n);
+	}
+	function isExtendsFrom(Type, Classes) {
+		let T = Type;
+		do {
+			if (Classes.includes(T)) return T;
+			T = Object.getPrototypeOf(T);
+		} while (T != null);
+		return null;
+	}
+	const AssertionError = /* @__PURE__ */ (function() {
+		class AssertionError$1 extends Error {
+			constructor(message) {
+				super(message);
+			}
+		}
+		Object.defineProperty(AssertionError$1.prototype, "name", {
+			value: "AssertionError",
+			configurable: true
+		});
+		return AssertionError$1;
+	})();
+	const less = (a, b) => {
+		if (a < b) return -1;
+		if (a > b) return 1;
+		return 0;
+	};
+	function defaultSort(arr, compareFn = less) {
+		return arr.sort(compareFn);
+	}
+	function insertionSort(arr, compareFn = less) {
+		const last = arr.length;
+		if (last > 0) {
+			const first = 0;
+			for (let it = first + 1; it < last; ++it) {
+				const value = arr[it];
+				let pre = it;
+				for (; pre > first && compareFn(value, arr[pre - 1]) < 0; --pre) arr[pre] = arr[pre - 1];
+				arr[pre] = value;
+			}
+		}
+		return arr;
+	}
+	function destructKey(k) {
+		return Array.isArray(k) ? k : typeof k === "function" || k === void 0 ? [k, k] : [null, k];
+	}
+	var Ref = class {
+		value;
+		constructor(value) {
+			this.value = value;
+		}
+		get() {
+			return this.value;
+		}
+		set(value) {
+			this.value = value;
+		}
+	};
+
+//#endregion
+//#region src/type.ts
+	const Uint8 = /* @__PURE__ */ (function() {
+		const Uint8$1 = function Uint8$2(num) {
+			if (typeof num === "bigint") return Math.fround(Number(num & BigInt(255)));
+			return num & 255;
+		};
+		inherits(Uint8$1, Number);
+		Object.defineProperty(Uint8$1, "MIN_VALUE", { value: 0 });
+		Object.defineProperty(Uint8$1, "MAX_VALUE", { value: 255 });
+		defineStaticMethod(Uint8$1, "is", function(instance) {
+			if (typeof instance === "number" || Object.getPrototypeOf(instance) === Number.prototype) return Uint8$1(instance) === Number(instance);
+			return false;
+		});
+		return Uint8$1;
+	})();
+	const Float32 = /* @__PURE__ */ (function() {
+		const Float32$1 = function Float32$2(num) {
+			if (typeof num === "bigint") return Math.fround(Number(num & BigInt(4294967295)) | 0);
+			return Math.fround(num ?? 0);
+		};
+		inherits(Float32$1, Number);
+		return Float32$1;
+	})();
+	const Float64 = /* @__PURE__ */ (function() {
+		const Float64$1 = function Float64$2(num) {
+			return Number(num ?? 0);
+		};
+		inherits(Float64$1, Number);
+		return Float64$1;
+	})();
+	const Int8 = /* @__PURE__ */ (function() {
+		const Int8$1 = function Int8$2(num) {
+			if (typeof num === "bigint") return Number(num & BigInt(255)) << 24 >> 24;
+			return num << 24 >> 24;
+		};
+		inherits(Int8$1, Number);
+		Object.defineProperty(Int8$1, "MIN_VALUE", { value: -128 });
+		Object.defineProperty(Int8$1, "MAX_VALUE", { value: 127 });
+		defineStaticMethod(Int8$1, "is", function(instance) {
+			if (typeof instance === "number" || Object.getPrototypeOf(instance) === Number.prototype) return Int8$1(instance) === Number(instance);
+			return false;
+		});
+		return Int8$1;
+	})();
+	const Uint16 = /* @__PURE__ */ (function() {
+		const Uint16$1 = function Uint16$2(num) {
+			if (typeof num === "bigint") return Number(num & BigInt(65535));
+			return num & 65535;
+		};
+		inherits(Uint16$1, Number);
+		Object.defineProperty(Uint16$1, "MIN_VALUE", { value: 0 });
+		Object.defineProperty(Uint16$1, "MAX_VALUE", { value: 65535 });
+		defineStaticMethod(Uint16$1, "is", function(instance) {
+			if (typeof instance === "number" || Object.getPrototypeOf(instance) === Number.prototype) return Uint16$1(instance) === Number(instance);
+			return false;
+		});
+		return Uint16$1;
+	})();
+	const Int16 = /* @__PURE__ */ (function() {
+		const Int16$1 = function Int16$2(num) {
+			if (typeof num === "bigint") return Number(num & BigInt(65535)) << 16 >> 16;
+			return num << 16 >> 16;
+		};
+		inherits(Int16$1, Number);
+		Object.defineProperty(Int16$1, "MIN_VALUE", { value: -32768 });
+		Object.defineProperty(Int16$1, "MAX_VALUE", { value: 32767 });
+		defineStaticMethod(Int16$1, "is", function(instance) {
+			if (typeof instance === "number" || Object.getPrototypeOf(instance) === Number.prototype) return Int16$1(instance) === Number(instance);
+			return false;
+		});
+		return Int16$1;
+	})();
+	const Uint32 = /* @__PURE__ */ (function() {
+		const Uint32$1 = function Uint32$2(num) {
+			if (typeof num === "bigint") return Number(num & BigInt(4294967295));
+			return (num | 0) >>> 0;
+		};
+		inherits(Uint32$1, Number);
+		Object.defineProperty(Uint32$1, "MIN_VALUE", { value: 0 });
+		Object.defineProperty(Uint32$1, "MAX_VALUE", { value: 4294967295 });
+		defineStaticMethod(Uint32$1, "is", function(instance) {
+			if (typeof instance === "number" || Object.getPrototypeOf(instance) === Number.prototype) return Uint32$1(instance) === Number(instance);
+			return false;
+		});
+		return Uint32$1;
+	})();
+	const Int32 = /* @__PURE__ */ (function() {
+		const Int32$1 = function Int32$2(num) {
+			if (typeof num === "bigint") return Number(num & BigInt(4294967295)) | 0;
+			return num | 0;
+		};
+		inherits(Int32$1, Number);
+		Object.defineProperty(Int32$1, "MIN_VALUE", { value: -2147483648 });
+		Object.defineProperty(Int32$1, "MAX_VALUE", { value: 2147483647 });
+		defineStaticMethod(Int32$1, "is", function(instance) {
+			if (typeof instance === "number" || Object.getPrototypeOf(instance) === Number.prototype) return Int32$1(instance) === Number(instance);
+			return false;
+		});
+		return Int32$1;
+	})();
+	const maxUint64 = /* @__PURE__ */ BigInt("0xFFFFFFFFFFFFFFFF");
+	const Uint64 = /* @__PURE__ */ (function() {
+		const Uint64$1 = function Uint64$2(num) {
+			if (num == null) return BigInt(0);
+			try {
+				return BigInt(num) & maxUint64;
+			} catch (_) {
+				return BigInt(0);
+			}
+		};
+		inherits(Uint64$1, BigInt);
+		Object.defineProperty(Uint64$1, "MIN_VALUE", { value: BigInt(0) });
+		Object.defineProperty(Uint64$1, "MAX_VALUE", { value: maxUint64 });
+		defineStaticMethod(Uint64$1, "is", function(instance) {
+			if (typeof instance === "bigint" || Object.getPrototypeOf(instance) === BigInt.prototype) return Uint64$1(instance) === BigInt(instance);
+			return false;
+		});
+		return Uint64$1;
+	})();
+	const Int64 = /* @__PURE__ */ (function() {
+		const minInt64 = -BigInt("0x8000000000000000");
+		const maxInt64 = BigInt("0x7FFFFFFFFFFFFFFF");
+		const Int64$1 = function Int64$2(num) {
+			if (num == null) return BigInt(0);
+			try {
+				const value = BigInt(num);
+				if (value < minInt64) return value & maxUint64;
+				else if (value > maxInt64) return (value & maxUint64) - (maxUint64 + BigInt(1));
+				return value;
+			} catch (_) {
+				return BigInt(0);
+			}
+		};
+		inherits(Int64$1, BigInt);
+		Object.defineProperty(Int64$1, "MIN_VALUE", { value: minInt64 });
+		Object.defineProperty(Int64$1, "MAX_VALUE", { value: maxInt64 });
+		defineStaticMethod(Int64$1, "is", function(instance) {
+			if (typeof instance === "bigint" || Object.getPrototypeOf(instance) === BigInt.prototype) return Int64$1(instance) === BigInt(instance);
+			return false;
+		});
+		return Int64$1;
+	})();
+	const Entity = /* @__PURE__ */ (function() {
+		const Entity$1 = function Entity$2(value) {
+			return Uint32(value);
+		};
+		inherits(Entity$1, Uint32);
+		return Entity$1;
+	})();
+
+//#endregion
+//#region src/config.ts
+	const EmptyTypeOptimization = {
+		Disabled: 0,
+		Static: 1,
+		0: "Disabled",
+		1: "Static"
+	};
+	const directCall = (Type, ...args) => Type(...args);
+	const config = /* @__PURE__ */ (() => {
+		const customCalls = /* @__PURE__ */ new WeakMap();
+		customCalls.set(Boolean, directCall);
+		customCalls.set(Number, directCall);
+		customCalls.set(String, directCall);
+		customCalls.set(Symbol, directCall);
+		customCalls.set(Entity, directCall);
+		customCalls.set(Uint8, directCall);
+		customCalls.set(Int8, directCall);
+		customCalls.set(Uint16, directCall);
+		customCalls.set(Int16, directCall);
+		customCalls.set(Uint32, directCall);
+		customCalls.set(Int32, directCall);
+		customCalls.set(Uint64, directCall);
+		customCalls.set(Int64, directCall);
+		customCalls.set(Float32, directCall);
+		customCalls.set(Float64, directCall);
+		customCalls.set(BigInt, (Type, ...args) => Type(args.length === 0 ? 0 : args[0]));
+		return {
+			customCalls,
+			emptyClasses: /* @__PURE__ */ new WeakMap(),
+			eto: typeof ENTT_NO_ETO !== "undefined" ? ENTT_NO_ETO ? EmptyTypeOptimization.Disabled : EmptyTypeOptimization.Static : EmptyTypeOptimization.Static,
+			mixin: typeof ENTT_NO_MIXIN !== "undefined" ? !ENTT_NO_MIXIN : true,
+			sparsePage: typeof ENTT_SPARSE_PAGE !== "undefined" ? Number(ENTT_SPARSE_PAGE) : 4096,
+			packedPage: typeof ENTT_PACKED_PAGE !== "undefined" ? Number(ENTT_PACKED_PAGE) : 1024
+		};
+	})();
+	function createSafeNew(Type) {
+		if (config.customCalls.has(Type)) {
+			const func = config.customCalls.get(Type);
+			return (...args) => func(Type, ...args);
+		}
+		return (...args) => {
+			try {
+				return new Type(...args);
+			} catch (err) {
+				if (err instanceof NotConstructorError || err instanceof TypeError && err.message.includes("is not a constructor")) return Type(...args);
+				throw err;
+			}
+		};
+	}
+	function getBlockBody(str, match) {
+		if (!match) return "";
+		let bracketCount = 0;
+		const begin = match.index + match[0].length - 1;
+		let curr = begin;
+		do {
+			const char = str[curr];
+			if (char === "{") bracketCount++;
+			else if (char === "}") bracketCount--;
+			curr++;
+		} while (bracketCount > 0 && curr < str.length);
+		return str.slice(begin, curr);
+	}
+	function isEmptyClass(Type) {
+		if (config.eto === EmptyTypeOptimization.Disabled) return false;
+		if (typeof Type !== "function" || Type.prototype == null) return false;
+		if (config.emptyClasses.has(Type)) return config.emptyClasses.get(Type);
+		if (config.eto === EmptyTypeOptimization.Static) {
+			let str = "";
+			try {
+				str = Function.prototype.toString.call(Type);
+			} catch (_) {
+				return false;
+			}
+			if (str.startsWith("class")) {
+				const match = str.match(/^class\s+\w*(\s+extends\s+[\w$]+)?\s*{/);
+				const classBody = getBlockBody(str, match);
+				if (!classBody) throw new Error("impossible");
+				if (/^\{\s*(\r?\n)*\s*\}$/.test(classBody)) return match[1] ? isEmptyClass(Object.getPrototypeOf(Type)) : true;
+				return false;
+			} else if (str.startsWith("function")) {
+				const constructorBody = getBlockBody(str, str.match(/^function\s+\w*\s*\(([^)]*)\)\s*{/));
+				if (constructorBody) return constructorBody === "{ [native code] }" ? false : !/this|return/.test(constructorBody);
+				else throw new Error("impossible");
+			} else return false;
+		}
+		return false;
+	}
+
+//#endregion
+//#region node_modules/stable-hash/dist/index.mjs
+	const o = /* @__PURE__ */ new WeakMap();
+	let u = 0;
+	function stableHash(t) {
+		const i = typeof t, s = t && t.constructor, c = s === Date;
+		if (Object(t) === t && !c && s != RegExp) {
+			let e = o.get(t);
+			if (e) return e;
+			e = ++u + "~", o.set(t, e);
+			let n;
+			if (s === Array) {
+				for (e = "@", n = 0; n < t.length; n++) e += stableHash(t[n]) + ",";
+				o.set(t, e);
+			} else if (s === Object) {
+				e = "#";
+				const f = Object.keys(t).sort();
+				for (; (n = f.pop()) !== void 0;) t[n] !== void 0 && (e += n + ":" + stableHash(t[n]) + ",");
+				o.set(t, e);
+			}
+			return e;
+		}
+		return c ? t.toJSON() : i === "symbol" ? t.toString() : i === "string" ? JSON.stringify(t) : "" + t;
+	}
+	var dist_default = stableHash;
+
+//#endregion
+//#region src/disposable.ts
+	const Disposable = /* @__PURE__ */ (function() {
+		class Disposable$1 {
+			/** @virtual */
+			dispose() {}
+			[Symbol.dispose]() {
+				this.dispose();
+			}
+		}
+		if (typeof Symbol.dispose !== "symbol") delete Disposable$1.prototype[Symbol.dispose];
+		return Disposable$1;
+	})();
+
+//#endregion
+//#region src/template.ts
+	var Template = class extends Disposable {
+		_registry;
+		_specializations;
+		instantiate;
+		defaultRender;
+		constructor(render, specializations = []) {
+			super();
+			const registry = /* @__PURE__ */ new Map();
+			this._registry = registry;
+			this.defaultRender = render;
+			this._specializations = specializations.map((spec) => ({
+				...spec,
+				userland: false
+			}));
+			this.instantiate = function(...args) {
+				const r = this.selectSpecialization(...args) ?? render;
+				const hash = dist_default([r, args]);
+				if (registry.has(hash)) return registry.get(hash);
+				const ret = r.apply(this, args);
+				registry.set(hash, ret);
+				return ret;
+			};
+		}
+		selectSpecialization(...args) {
+			for (const spec of this._specializations) if (spec.predicate.apply(this, args)) return spec.render;
+			return null;
+		}
+		addSpecialization(spec) {
+			this._specializations.push({
+				...spec,
+				userland: true
+			});
+		}
+		removeSpecialization(spec) {
+			const index = this._specializations.findIndex((s) => s.predicate === spec.predicate && s.render === spec.render && s.userland);
+			if (index !== -1) this._specializations.splice(index, 1);
+		}
+		removeAllUserlandSpecializations() {
+			this._specializations = this._specializations.filter((s) => !s.userland);
+		}
+		dispose() {
+			this._registry.clear();
+			this._specializations.length = 0;
+		}
+	};
+	/* @__NO_SIDE_EFFECTS__ */
+	function defineTemplate(render, specializations = []) {
+		return new Template(render, specializations);
+	}
+
+//#endregion
+//#region src/entity.ts
+	const internalEnttTraits = /* @__PURE__ */ defineTemplate(function(ValueType) {
+		if (typeof ValueType === "function" && ValueType.prototype != null) {
+			const BaseEntityType = isExtendsFrom(ValueType, [
+				Number,
+				BigInt,
+				Uint32,
+				Uint64
+			]);
+			if (BaseEntityType) {
+				const traits$1 = this.selectSpecialization(BaseEntityType).call(this, BaseEntityType);
+				traits$1.ValueType = ValueType;
+				return traits$1;
+			}
+			const EntityType = ValueType.EntityType;
+			if (!EntityType) throw new TypeError("Invalid EntityType");
+			const traits = internalEnttTraits.instantiate(EntityType);
+			traits.ValueType = ValueType;
+			return traits;
+		}
+		throw new TypeError("Invalid ValueType");
+	}, [
+		{
+			predicate: (ValueType) => ValueType === Number,
+			render: function() {
+				return {
+					ValueType: Number,
+					EntityType: Number,
+					VersionType: Number,
+					entityMask: 1048575,
+					versionMask: 4095
+				};
+			}
+		},
+		{
+			predicate: (ValueType) => ValueType === BigInt,
+			render: function() {
+				return {
+					ValueType: BigInt,
+					EntityType: BigInt,
+					VersionType: Number,
+					entityMask: BigInt(4294967295),
+					versionMask: BigInt(4294967295)
+				};
+			}
+		},
+		{
+			predicate: (ValueType) => ValueType === Uint32,
+			render: function() {
+				return {
+					ValueType: Uint32,
+					EntityType: Uint32,
+					VersionType: Uint16,
+					entityMask: Uint32(1048575),
+					versionMask: Uint32(4095)
+				};
+			}
+		},
+		{
+			predicate: (ValueType) => ValueType === Uint64,
+			render: function() {
+				return {
+					ValueType: Uint64,
+					EntityType: Uint64,
+					VersionType: Uint32,
+					entityMask: Uint64(4294967295),
+					versionMask: Uint64(4294967295)
+				};
+			}
+		}
+	]);
+	const basicEnttTraitsTemplate = /* @__PURE__ */ defineTemplate(function(traits) {
+		const { ValueType, EntityType, VersionType, entityMask, versionMask } = traits;
+		const length = popcount(entityMask);
+		assert(entityMask && (entityMask & entityMask + EntityType(1)) === EntityType(0), "Invalid entity mask");
+		assert((versionMask & versionMask + EntityType(1)) === EntityType(0), "Invalid version mask");
+		const newValueType = createSafeNew(ValueType);
+		const toIntegral = EntityType === Number ? (value) => EntityType(value) >>> 0 : (value) => EntityType(value);
+		const toEntity = ((value) => toIntegral(value) & entityMask);
+		const toVersion = VersionType === Number ? (value) => VersionType(!versionMask ? 0 : toIntegral(value) >> EntityType(length) & versionMask) >>> 0 : (value) => VersionType(!versionMask ? 0 : toIntegral(value) >> EntityType(length) & versionMask);
+		const c = isExtendsFrom(ValueType, [Number, BigInt]) ? (v) => ValueType(v) : (v) => newValueType(v);
+		const _construct = (entity, version$1) => {
+			let v = EntityType(entity) & entityMask;
+			if (versionMask) v = v | (EntityType(version$1) & versionMask) << EntityType(length);
+			return v;
+		};
+		const construct = EntityType === Number ? (entity, version$1) => c(_construct(entity, version$1) >>> 0) : (entity, version$1) => c(EntityType(_construct(entity, version$1)));
+		const next = ((value) => {
+			const vers = toVersion(value) + VersionType(1);
+			return construct(toIntegral(value), vers + (vers === versionMask ? VersionType(1) : VersionType(0)));
+		});
+		const _combine = (lhs, rhs) => {
+			let v = EntityType(lhs) & entityMask;
+			if (versionMask) v = v | EntityType(rhs) & versionMask << EntityType(length);
+			return v;
+		};
+		const combine = EntityType === Number ? (lhs, rhs) => c(_combine(lhs, rhs) >>> 0) : (lhs, rhs) => c(EntityType(_combine(lhs, rhs)));
+		const nul = construct(entityMask, versionMask);
+		const tombstone = construct(entityMask, versionMask);
+		const isNull = (value) => toEntity(value) === toEntity(nul);
+		return {
+			ValueType,
+			EntityType,
+			VersionType,
+			entityMask,
+			versionMask,
+			length,
+			null: nul,
+			tombstone,
+			toIntegral,
+			toEntity,
+			toVersion,
+			next,
+			construct,
+			combine,
+			isNull,
+			isTombstone: !versionMask ? (value) => toIntegral(value) === toIntegral(tombstone) : (value) => toVersion(value) === toVersion(tombstone)
+		};
+	});
+	const enttTraitsTemplate = /* @__PURE__ */ defineTemplate(function(ValueType) {
+		const traits = internalEnttTraits.instantiate(ValueType);
+		const BaseType = basicEnttTraitsTemplate.instantiate(traits);
+		return {
+			...BaseType,
+			BaseType,
+			pageSize: config.sparsePage
+		};
+	});
+
+//#endregion
+//#region src/iterator.ts
+	var ReversePointer = class ReversePointer {
+		it;
+		constructor(it) {
+			this.it = it.clone();
+		}
+		clone(target) {
+			if (target) {
+				if (this === target) return target;
+				this.it.clone(target.it);
+				return target;
+			}
+			return new ReversePointer(this.it);
+		}
+		swap(other) {
+			if (this === other) return;
+			this.it.swap(other.it);
+		}
+		base() {
+			return this.it.clone();
+		}
+		selfPlus(n = 1) {
+			this.it.selfMinus(n);
+			return this;
+		}
+		selfMinus(n = 1) {
+			this.it.selfPlus(n);
+			return this;
+		}
+		plus(n) {
+			return new ReversePointer(this.it.minus(n));
+		}
+		minus(n) {
+			return new ReversePointer(this.it.plus(n));
+		}
+		diff(other) {
+			return other.it.diff(this.it);
+		}
+		equals(other) {
+			return this.it.equals(other.it);
+		}
+		lt(other) {
+			return this.it.gt(other.it);
+		}
+		gt(other) {
+			return this.it.lt(other.it);
+		}
+		le(other) {
+			return this.it.ge(other.it);
+		}
+		ge(other) {
+			return this.it.le(other.it);
+		}
+		deref() {
+			return this.it.clone().selfMinus().deref();
+		}
+		write(value) {
+			return this.it.write(value);
+		}
+		access(value) {
+			return this.it.access(-1 - value);
+		}
+		set(off, value) {
+			this.it.set(-1 - off, value);
+		}
+	};
+	function makeReversePointer(it) {
+		return new ReversePointer(it);
+	}
+	function makeRangePointer(first, last) {
+		return [last != null ? first.clone() : first.begin(), last != null ? last.clone() : first.end()];
+	}
+	var RangeIterator = class extends Iterator {
+		first;
+		curr;
+		last;
+		constructor(first, last) {
+			super();
+			this.first = first.clone();
+			this.last = last.clone();
+			this.curr = first.clone();
+		}
+		begin() {
+			return this.first.clone();
+		}
+		end() {
+			return this.last.clone();
+		}
+		next() {
+			if (this.curr.equals(this.last)) return {
+				done: true,
+				value: void 0
+			};
+			const value = this.curr.deref();
+			this.curr.selfPlus();
+			return {
+				done: false,
+				value
+			};
+		}
+		[Symbol.iterator]() {
+			return this;
+		}
+	};
+	var AggregatePointer = class AggregatePointer {
+		pointers;
+		constructor(pointers) {
+			this.pointers = pointers;
+		}
+		base() {
+			return this.pointers[0];
+		}
+		deref() {
+			return this.pointers.map((p) => p.deref());
+		}
+		write(value) {
+			this.pointers.forEach((p, i) => p.write(value[i]));
+			return value;
+		}
+		clone(target) {
+			if (target) {
+				if (this === target) return target;
+				this.pointers.forEach((p, i) => {
+					target.pointers[i] = p.clone();
+				});
+				return target;
+			}
+			return new AggregatePointer(this.pointers.map((p) => p.clone()));
+		}
+		swap(other) {
+			if (this === other) return;
+			const tmp = this.pointers;
+			this.pointers = other.pointers;
+			other.pointers = tmp;
+		}
+		selfPlus() {
+			this.pointers.forEach((p) => p.selfPlus());
+			return this;
+		}
+		equals(other) {
+			return this.pointers.every((p, i) => p.equals(other.pointers[i]));
+		}
+	};
+	function toIterator(first, last) {
+		const [f, l] = makeRangePointer(first, last);
+		return new RangeIterator(f, l);
+	}
+	var ArrayPointer = class ArrayPointer {
+		array;
+		pos;
+		constructor(array, index) {
+			this.array = array;
+			this.pos = index;
+		}
+		clone(target) {
+			if (target) {
+				if (this === target) return target;
+				target.array = this.array;
+				target.pos = this.pos;
+				return target;
+			}
+			return new ArrayPointer(this.array, this.pos);
+		}
+		swap(other) {
+			if (this === other) return;
+			const tmpArray = this.array;
+			const tmpIndex = this.pos;
+			this.array = other.array;
+			this.pos = other.pos;
+			other.array = tmpArray;
+			other.pos = tmpIndex;
+		}
+		selfPlus(n = 1) {
+			this.pos += n;
+			return this;
+		}
+		plus(n) {
+			return new ArrayPointer(this.array, this.pos + n);
+		}
+		selfMinus(n = 1) {
+			this.pos -= n;
+			return this;
+		}
+		minus(n) {
+			return new ArrayPointer(this.array, this.pos - n);
+		}
+		diff(other) {
+			return this.pos - other.pos;
+		}
+		lt(other) {
+			return this.pos < other.pos;
+		}
+		gt(other) {
+			return this.pos > other.pos;
+		}
+		le(other) {
+			return this.pos <= other.pos;
+		}
+		ge(other) {
+			return this.pos >= other.pos;
+		}
+		equals(other) {
+			return this.pos === other.pos;
+		}
+		deref() {
+			return this.array[this.pos];
+		}
+		write(value) {
+			this.array[this.pos] = value;
+			return value;
+		}
+		access(n) {
+			return this.array[this.pos + n];
+		}
+		set(n, value) {
+			this.array[this.pos + n] = value;
+		}
+	};
+	var ArrayRange = class {
+		array;
+		constructor(array) {
+			this.array = array;
+		}
+		data() {
+			return this.array;
+		}
+		begin() {
+			return new ArrayPointer(this.array, 0);
+		}
+		end() {
+			return new ArrayPointer(this.array, this.array.length);
+		}
+		rbegin() {
+			return new ReversePointer(this.end());
+		}
+		rend() {
+			return new ReversePointer(this.begin());
+		}
+		[Symbol.iterator]() {
+			return toIterator(this);
+		}
+	};
+	function toRange(value) {
+		if (Array.isArray(value)) return new ArrayRange(value);
+		throw new Error("Invalid argument");
+	}
+	function distance(first, last) {
+		first = first.clone();
+		last = last.clone();
+		if (typeof first.diff === "function" && typeof last.diff === "function") return last.diff(first);
+		let r = 0;
+		for (; !first.equals(last); first.selfPlus()) ++r;
+		return r;
+	}
+
+//#endregion
+//#region src/sparse-set.ts
+	const DeletionPolicy = {
+		SwapAndPop: 0,
+		InPlace: 1,
+		SwapOnly: 2,
+		Unspecified: 0,
+		0: "SwapAndPop",
+		1: "InPlace",
+		2: "SwapOnly"
+	};
+	var SparseSetPointer = class SparseSetPointer {
+		packed;
+		offset;
+		constructor(packed = null, offset = 0) {
+			this.packed = packed;
+			this.offset = offset;
+		}
+		clone(target) {
+			if (target) {
+				if (this === target) return target;
+				target.packed = this.packed;
+				target.offset = this.offset;
+				return target;
+			}
+			return new SparseSetPointer(this.packed, this.offset);
+		}
+		swap(other) {
+			if (this === other) return;
+			const t = this.packed;
+			this.packed = other.packed;
+			other.packed = t;
+			const o$1 = this.offset;
+			this.offset = other.offset;
+			other.offset = o$1;
+		}
+		data() {
+			return this.packed;
+		}
+		selfPlus(n = 1) {
+			this.offset -= n;
+			return this;
+		}
+		selfMinus(n = 1) {
+			this.offset += n;
+			return this;
+		}
+		plus(n) {
+			return new SparseSetPointer(this.packed, this.offset - n);
+		}
+		minus(n) {
+			return new SparseSetPointer(this.packed, this.offset + n);
+		}
+		diff(other) {
+			return other.index() - this.index();
+		}
+		equals(other) {
+			return this.index() === other.index();
+		}
+		lt(other) {
+			return this.index() > other.index();
+		}
+		gt(other) {
+			return this.index() < other.index();
+		}
+		le(other) {
+			return !this.gt(other);
+		}
+		ge(other) {
+			return !this.lt(other);
+		}
+		deref() {
+			return this.access(0);
+		}
+		write(value) {
+			this.set(0, value);
+			return value;
+		}
+		access(value) {
+			const idx = this.index() - value;
+			if (idx < 0 || idx >= this.packed.length) throw new RangeError(`Iterator access out of range: ${idx}, [0, ${this.packed.length})`);
+			return this.packed[idx];
+		}
+		set(off, value) {
+			const idx = this.index() - off;
+			if (idx < 0 || idx >= this.packed.length) throw new RangeError(`Iterator access out of range: ${idx}, [0, ${this.packed.length})`);
+			this.packed[idx] = value;
+		}
+		index() {
+			return this.offset - 1;
+		}
+		[Symbol.toPrimitive](hint) {
+			const pos = this.packed.length - 1 - this.index();
+			if (hint === "string") return pos.toString();
+			return pos;
+		}
+	};
+	const basicSparseSetTemplate = /* @__PURE__ */ defineTemplate(function(EntityType) {
+		const traits = enttTraitsTemplate.instantiate(EntityType);
+		const typeName = traits.ValueType.name;
+		const maxSize = Uint64(traits.toEntity(traits.null));
+		const pageSize = Uint64(traits.pageSize);
+		const policyToHead = (mode) => mode === DeletionPolicy.SwapOnly ? Uint64(0) : maxSize;
+		const entityToPos = (entity) => Uint64(traits.toEntity(entity));
+		const posToPage = (pos) => pos / pageSize;
+		const _contains = (() => {
+			const cap = traits.entityMask;
+			const mask = traits.toIntegral(traits.null) & ~cap;
+			return isExtendsFrom(traits.EntityType, [Number]) ? (self, entity) => {
+				const elem = self.sparsePtr(entity);
+				if (elem == null) return false;
+				return (mask & traits.toIntegral(entity) ^ traits.toIntegral(elem)) >>> 0 < traits.entityMask;
+			} : (self, entity) => {
+				const elem = self.sparsePtr(entity);
+				if (elem == null) return false;
+				return traits.EntityType(mask & traits.toIntegral(entity) ^ traits.toIntegral(elem)) < traits.entityMask;
+			};
+		})();
+		return class BasicSparseSet extends Disposable {
+			static BasicIterator = SparseSetPointer;
+			static Iterator = BasicSparseSet.BasicIterator;
+			static ReverseIterator = ReversePointer;
+			static TraitsType = traits;
+			static EntityType = traits.ValueType;
+			sparse;
+			packed;
+			mode;
+			head;
+			Type;
+			sparsePtr(entity) {
+				const pos = entityToPos(entity);
+				const page = posToPage(pos);
+				return page < this.sparse.length && this.sparse[page] ? this.sparse[page][fastMod(pos, pageSize)] : null;
+			}
+			sparseRef(entity) {
+				const pos = entityToPos(entity);
+				const page = posToPage(pos);
+				assert(page < this.sparse.length && this.sparse[page], "Invalid element");
+				const pageIndex = fastMod(pos, pageSize);
+				return {
+					get: () => this.sparse[page][pageIndex],
+					set: (value) => {
+						this.sparse[page][pageIndex] = value;
+					}
+				};
+			}
+			assureAtLeast(entity) {
+				const pos = entityToPos(entity);
+				const page = posToPage(pos);
+				while (this.sparse.length <= page) this.sparse.push(Array(traits.pageSize).fill(traits.null));
+				const pageIndex = fastMod(pos, pageSize);
+				return {
+					get: () => this.sparse[page][pageIndex],
+					set: (value) => {
+						this.sparse[page][pageIndex] = value;
+					}
+				};
+			}
+			static isNull(entity) {
+				return traits.isNull(entity);
+			}
+			static isTombstone(entity) {
+				return traits.isTombstone(entity);
+			}
+			constructor(TypeOrMode, modeOrUndefined) {
+				super();
+				this.sparse = [];
+				this.packed = [];
+				const mode = typeof TypeOrMode === "number" ? TypeOrMode : modeOrUndefined ?? DeletionPolicy.SwapAndPop;
+				this.mode = mode;
+				this.head = policyToHead(mode);
+				this.Type = typeof TypeOrMode === "function" ? TypeOrMode : void 0;
+				assert(traits.versionMask || mode !== DeletionPolicy.InPlace, "Policy does not support zero-sized versions");
+			}
+			dispose() {
+				this.clear();
+			}
+			reserve(cap) {
+				if (cap > this.packed.length) this.packed.length = cap;
+			}
+			data() {
+				return this.packed;
+			}
+			policy() {
+				return this.mode;
+			}
+			isNull(entity) {
+				return traits.isNull(entity);
+			}
+			isTombstone(entity) {
+				return traits.isTombstone(entity);
+			}
+			type() {
+				return this.Type;
+			}
+			empty() {
+				return this.packed.length === 0;
+			}
+			get size() {
+				return this.packed.length;
+			}
+			freeList(value) {
+				if (value != null) {
+					assert(this.mode === DeletionPolicy.SwapOnly && !(value > this.packed.length), "Invalid value");
+					this.head = Uint64(value);
+				}
+				return this.head;
+			}
+			contiguous() {
+				return this.mode !== DeletionPolicy.InPlace || this.head === maxSize;
+			}
+			access(pos) {
+				assert(pos < this.packed.length, "Index out of bounds");
+				return this.packed[pos];
+			}
+			swapAt(lhs, rhs) {
+				const from = this.packed[lhs];
+				const to = this.packed[rhs];
+				this.sparseRef(from).set(traits.combine(traits.EntityType(rhs), traits.toIntegral(from)));
+				this.sparseRef(to).set(traits.combine(traits.EntityType(lhs), traits.toIntegral(to)));
+				this.packed[lhs] = to;
+				this.packed[rhs] = from;
+			}
+			/** @virtual */
+			tryEmplace(entity, forceBack = false, _value) {
+				assert(!traits.isNull(entity) && !traits.isTombstone(entity), "Invalid element");
+				const elem = BasicSparseSet.prototype.assureAtLeast.call(this, entity);
+				let pos = this.size;
+				switch (this.mode) {
+					case DeletionPolicy.InPlace: if (this.head !== maxSize && !forceBack) {
+						pos = Number(this.head);
+						assert(elem.get() == null || traits.isNull(elem.get()), "Slot not available");
+						elem.set(traits.combine(traits.EntityType(this.head), traits.toIntegral(entity)));
+						this.head = Uint64(traits.toEntity(this.packed[pos]));
+						this.packed[pos] = entity;
+						break;
+					}
+					case DeletionPolicy.SwapAndPop:
+						assert(elem.get() == null || traits.isNull(elem.get()), "Slot not available");
+						this.packed.push(entity);
+						elem.set(traits.combine(traits.EntityType(this.packed.length - 1), traits.toIntegral(entity)));
+						break;
+					case DeletionPolicy.SwapOnly:
+						if (elem.get() == null || traits.isNull(elem.get())) {
+							this.packed.push(entity);
+							elem.set(traits.combine(traits.EntityType(this.packed.length - 1), traits.toIntegral(entity)));
+						} else {
+							assert(!(entityToPos(elem.get()) < this.head), "Slot not available");
+							this.bump(entity);
+						}
+						pos = Number(this.head);
+						this.head++;
+						BasicSparseSet.prototype.swapAt.call(this, entityToPos(elem.get()), pos);
+						break;
+					default: throw new Error("Unsupported operation");
+				}
+				return new BasicSparseSet.BasicIterator(this.packed, pos + 1);
+			}
+			push(entity, elem) {
+				return this.tryEmplace(entity, false, elem);
+			}
+			pushRange(iterable, last) {
+				let first = void 0;
+				if (last != null) {
+					first = iterable.clone();
+					last = last.clone();
+				} else {
+					first = iterable.begin();
+					last = iterable.end();
+				}
+				let curr = BasicSparseSet.prototype.end.call(this);
+				for (; !first.equals(last); first.selfPlus()) curr = this.tryEmplace(first.deref(), true);
+				return curr;
+			}
+			add(entity) {
+				this.push(entity);
+				return this;
+			}
+			contains(entity) {
+				return _contains(this, entity);
+			}
+			has(entity) {
+				return this.contains(entity);
+			}
+			swapAndPop(entity) {
+				assert(this.mode === DeletionPolicy.SwapAndPop, "Deletion policy mismatch");
+				const self = this.sparseRef(entity);
+				const entt = traits.toEntity(self.get());
+				this.sparseRef(this.packed[this.packed.length - 1]).set(traits.combine(entt, traits.toIntegral(this.packed[this.packed.length - 1])));
+				this.packed[entt] = this.packed[this.packed.length - 1];
+				assert((this.packed[this.packed.length - 1] = traits.null, true), "");
+				self.set(traits.null);
+				this.packed.pop();
+			}
+			inPlacePop(entity) {
+				assert(this.mode === DeletionPolicy.InPlace, "Deletion policy mismatch");
+				const ref = this.sparseRef(entity);
+				const tmp = ref.get();
+				ref.set(traits.null);
+				const pos = entityToPos(tmp);
+				const head = this.head;
+				this.head = Uint64(traits.EntityType(pos));
+				this.packed[pos] = traits.combine(traits.EntityType(head), traits.EntityType(traits.tombstone));
+			}
+			swapOnly(entity) {
+				assert(this.mode === DeletionPolicy.SwapOnly, "Deletion policy mismatch");
+				const pos = this.index(entity);
+				this.bump(traits.next(entity));
+				if (pos < this.head) this.head--;
+				BasicSparseSet.prototype.swapAt.call(this, pos, this.head);
+			}
+			/** @virtual */
+			pop(first, last) {
+				first = first.clone();
+				last = last.clone();
+				if (this.mode === DeletionPolicy.SwapAndPop) for (; !first.equals(last); first.selfPlus()) this.swapAndPop(first.deref());
+				else if (this.mode === DeletionPolicy.InPlace) for (; !first.equals(last); first.selfPlus()) this.inPlacePop(first.deref());
+				else if (this.mode === DeletionPolicy.SwapOnly) for (; !first.equals(last); first.selfPlus()) this.swapOnly(first.deref());
+				else throw new Error("Unsupported operation");
+			}
+			/** @virtual */
+			popAll() {
+				switch (this.mode) {
+					case DeletionPolicy.InPlace: if (this.head !== maxSize) {
+						for (const elem of this.packed) if (!traits.isTombstone(elem)) this.sparseRef(elem).set(traits.null);
+						break;
+					}
+					case DeletionPolicy.SwapOnly:
+					case DeletionPolicy.SwapAndPop:
+						for (const elem of this.packed) this.sparseRef(elem).set(traits.null);
+						break;
+				}
+				this.head = policyToHead(this.mode);
+				this.packed.length = 0;
+			}
+			erase(first, last) {
+				if (last != null) if (first instanceof SparseSetPointer && last instanceof SparseSetPointer) this.pop(first, last);
+				else {
+					const f = first.clone();
+					last = last.clone();
+					for (; !f.equals(last); f.selfPlus()) this.erase(f.deref());
+				}
+				else {
+					const it = this.toIterator(first);
+					this.pop(it, it.plus(1));
+				}
+			}
+			remove(entity, last) {
+				if (last != null) {
+					let count = 0;
+					const first = entity.clone();
+					const l = last.clone();
+					if (entity instanceof SparseSetPointer && last instanceof SparseSetPointer) while (!first.equals(l)) {
+						while (!first.equals(l) && !this.contains(first.deref())) first.selfPlus();
+						const it = first.clone();
+						while (!first.equals(l) && this.contains(first.deref())) first.selfPlus();
+						count += first.diff(it);
+						this.erase(it, first);
+					}
+					else for (; !first.equals(l); first.selfPlus()) count += Number(this.remove(first.deref()));
+					return count;
+				} else {
+					if (!this.has(entity)) return false;
+					this.erase(entity);
+					return true;
+				}
+			}
+			delete(entity) {
+				return this.remove(entity);
+			}
+			clear() {
+				this.popAll();
+				assert((this.compact(), this.size) === 0, "Non-empty set");
+				this.head = policyToHead(this.mode);
+				this.packed.length = 0;
+			}
+			forEach(callbackfn, thisArg) {
+				for (let i = this.packed.length - 1; i >= 0; --i) {
+					const item = this.packed[i];
+					callbackfn.call(thisArg, item, item, this);
+				}
+			}
+			at(index) {
+				return this.packed[(this.packed.length - 1 - index) % this.packed.length];
+			}
+			keys() {
+				return this[Symbol.iterator]();
+			}
+			values() {
+				return this[Symbol.iterator]();
+			}
+			entries() {
+				const begin = BasicSparseSet.prototype.begin.call(this);
+				const end = BasicSparseSet.prototype.end.call(this);
+				return toIterator(new AggregatePointer([begin, begin.clone()]), new AggregatePointer([end, end.clone()]));
+			}
+			current(entt) {
+				const elem = this.sparsePtr(entt);
+				return elem != null ? traits.toVersion(elem) : traits.toVersion(traits.tombstone);
+			}
+			bump(entt) {
+				const elem = this.sparseRef(entt);
+				assert(!traits.isNull(entt) && (elem.get() == null || !traits.isTombstone(elem.get())), "Cannot set the required version");
+				elem.set(traits.combine(traits.toIntegral(elem.get()), traits.toIntegral(entt)));
+				this.packed[entityToPos(elem.get())] = entt;
+				return traits.toVersion(entt);
+			}
+			index(value) {
+				assert(this.contains(value), "Set does not contain entity");
+				return Number(entityToPos(this.sparsePtr(value)));
+			}
+			find(value) {
+				return this.has(value) ? this.toIterator(value) : BasicSparseSet.prototype.end.call(this);
+			}
+			begin() {
+				return new BasicSparseSet.BasicIterator(this.packed, this.packed.length);
+			}
+			end() {
+				return new BasicSparseSet.BasicIterator(this.packed, 0);
+			}
+			rbegin() {
+				return makeReversePointer(BasicSparseSet.prototype.end.call(this));
+			}
+			rend() {
+				return makeReversePointer(BasicSparseSet.prototype.begin.call(this));
+			}
+			toIterator(entt) {
+				return BasicSparseSet.prototype.end.call(this).minus(this.index(entt)).selfMinus();
+			}
+			/** @virtual */
+			bindAny(_value) {}
+			bind(value) {
+				this.bindAny(value);
+			}
+			/** @virtual */
+			swapOrMove(_lhs, _rhs) {
+				assert(this.mode !== DeletionPolicy.SwapOnly || _lhs < this.head === _rhs < this.head, "Cross swapping is not supported");
+			}
+			compact() {
+				if (this.mode === DeletionPolicy.InPlace) {
+					let from = this.packed.length;
+					let pos = this.head;
+					this.head = maxSize;
+					for (; from && traits.isTombstone(this.packed[from - 1]); --from);
+					while (pos !== maxSize) {
+						const to = pos;
+						pos = Uint64(entityToPos(this.packed[pos]));
+						if (to < from) {
+							--from;
+							this.swapOrMove(from, Number(to));
+							this.packed[to] = this.packed[from];
+							const elem = traits.EntityType(to);
+							this.sparseRef(this.packed[to]).set(traits.combine(elem, traits.toIntegral(this.packed[to])));
+							for (; from && traits.isTombstone(this.packed[from - 1]); --from);
+						}
+					}
+					this.packed.length = from;
+				}
+			}
+			sort(compareFn, algo = defaultSort) {
+				const len = this.mode === DeletionPolicy.SwapOnly ? Number(this.head) : this.packed.length;
+				this.sortN(len, compareFn, algo);
+			}
+			sortN(length, compareFn, algo = defaultSort) {
+				assert(this.mode !== DeletionPolicy.InPlace || this.head === maxSize, "Sorting with tombstones is not allowed");
+				assert(!(length > this.packed.length), "Length exceeds the number of elements");
+				const reversedSlice = this.packed.slice(0, length).reverse();
+				algo(reversedSlice, compareFn);
+				for (let i = 0; i < length; ++i) this.packed[length - 1 - i] = reversedSlice[i];
+				for (let pos = 0; pos < length; ++pos) {
+					let curr = pos;
+					let next = this.index(this.packed[curr]);
+					while (curr !== next) {
+						const idx = this.index(this.packed[next]);
+						const entt = this.packed[curr];
+						this.swapOrMove(next, idx);
+						const elem = traits.EntityType(curr);
+						this.sparseRef(entt).set(traits.combine(elem, traits.toIntegral(this.packed[curr])));
+						const old = next;
+						next = idx;
+						curr = old;
+					}
+				}
+			}
+			swapElements(lhs, rhs) {
+				const from = this.index(lhs);
+				const to = this.index(rhs);
+				this.swapOrMove(from, to);
+				BasicSparseSet.prototype.swapAt.call(this, from, to);
+			}
+			sortAs(rangeOrFirst, lastOrNull) {
+				assert(this.mode !== DeletionPolicy.InPlace || this.head === maxSize, "Sorting with tombstones is not allowed");
+				const first = lastOrNull != null ? rangeOrFirst.clone() : rangeOrFirst.begin();
+				const last = lastOrNull != null ? lastOrNull.clone() : rangeOrFirst.end();
+				const len = this.mode === DeletionPolicy.SwapOnly ? Number(this.head) : this.packed.length;
+				const it = BasicSparseSet.prototype.end.call(this).minus(len);
+				const other = BasicSparseSet.prototype.end.call(this);
+				for (; !it.equals(other) && !first.equals(last); first.selfPlus()) {
+					const curr = first.deref();
+					if (this.contains(curr)) {
+						const entt = it.deref();
+						if (traits.toIntegral(entt) !== traits.toIntegral(curr)) this.swapElements(entt, curr);
+						it.selfPlus();
+					}
+				}
+				return it;
+			}
+			get [Symbol.toStringTag]() {
+				return `BasicSparseSet<${typeName}>`;
+			}
+			[Symbol.iterator]() {
+				return toIterator(BasicSparseSet.prototype.begin.call(this), BasicSparseSet.prototype.end.call(this));
+			}
+		};
+	});
+	const SparseSet = /* @__PURE__ */ (() => basicSparseSetTemplate.instantiate(Entity))();
+
+//#endregion
+//#region src/component.ts
+	const componentTraitsTemplate = /* @__PURE__ */ defineTemplate(function(Type, Entity$1) {
+		return {
+			ElementType: Type,
+			EntityType: Entity$1,
+			pageSize: Type == null ? 0 : "pageSize" in Type ? Type.pageSize : isEmptyClass(Type) ? 0 : config.packedPage,
+			inPlaceDelete: Type != null && "inPlaceDelete" in Type ? Type.inPlaceDelete : false
+		};
+	});
+
+//#endregion
+//#region src/signal.ts
+	var Delegate = class extends Disposable {
+		fn;
+		instance;
+		constructor(fn, instance) {
+			super();
+			this.fn = fn;
+			this.instance = instance;
+		}
+		dispose() {
+			this.reset();
+		}
+		reset() {
+			this.fn = null;
+			this.instance = null;
+		}
+		empty() {
+			return this.fn == null;
+		}
+		connect(fn, instance) {
+			this.fn = fn;
+			this.instance = instance;
+		}
+		invoke(...args) {
+			const fn = this.fn;
+			return this.instance ? fn.apply(this.instance, args) : fn(...args);
+		}
+	};
+	var Sink = class Sink extends Disposable {
+		signal;
+		constructor(signal) {
+			super();
+			this.signal = signal;
+		}
+		dispose() {
+			this.signal?.dispose();
+			this.signal = void 0;
+		}
+		empty() {
+			assert(this.signal != null, "Invalid reference to signal");
+			return this.signal.calls.length === 0;
+		}
+		disconnectIf(callback) {
+			assert(this.signal != null, "Invalid reference to signal");
+			for (let pos = this.signal.calls.length - 1; pos >= 0; --pos) {
+				const elem = this.signal.calls[pos];
+				if (callback(elem)) {
+					const tmp = this.signal.calls[pos];
+					this.signal.calls[pos] = this.signal.calls[this.signal.calls.length - 1];
+					this.signal.calls[this.signal.calls.length - 1] = tmp;
+					this.signal.calls.pop();
+				}
+			}
+		}
+		disconnect(fn, instance) {
+			assert(this.signal != null, "Invalid reference to signal");
+			if (fn != null && instance != null) this.disconnectIf((elem) => Object.is(elem.fn, fn) && Object.is(elem.instance, instance));
+			else if (fn != null) this.disconnectIf((elem) => Object.is(elem.fn, fn));
+			else if (instance != null) this.disconnectIf((elem) => Object.is(elem.instance, instance));
+			else this.signal.calls.length = 0;
+		}
+		connect(fn, instance) {
+			this.disconnect(fn, instance);
+			const delegate = new Delegate(fn, instance);
+			this.signal.calls.push(delegate);
+			return new Connection(new Delegate(function(signal) {
+				new Sink(signal).disconnect(fn, this);
+			}, instance), this.signal);
+		}
+	};
+	var Sigh = class extends Disposable {
+		calls;
+		static SinkType = Sink;
+		constructor() {
+			super();
+			this.calls = [];
+		}
+		dispose() {
+			this.calls.length = 0;
+		}
+		get size() {
+			return this.calls.length;
+		}
+		empty() {
+			return this.calls.length === 0;
+		}
+		publish(...args) {
+			for (let i = this.calls.length - 1; i >= 0; --i) this.calls[i].invoke(...args);
+		}
+		collect(fn, ...args) {
+			for (let i = this.calls.length - 1; i >= 0; --i) if (fn(this.calls[i].invoke(...args))) break;
+		}
+	};
+	var Connection = class {
+		signal;
+		disconnect;
+		constructor(fn, ref) {
+			this.disconnect = fn;
+			this.signal = ref;
+		}
+		empty() {
+			return this.disconnect.empty();
+		}
+		release() {
+			if (!this.disconnect.empty()) {
+				this.disconnect.invoke(this.signal);
+				this.disconnect.reset();
+			}
+		}
+	};
+	var ScopedConnection = class extends Disposable {
+		conn;
+		constructor(conn) {
+			super();
+			this.conn = conn;
+		}
+		dispose() {
+			this.conn.release();
+		}
+		empty() {
+			return this.conn.empty();
+		}
+		release() {
+			this.conn.release();
+		}
+	};
+	var BasicDispatcherHandler = class extends Disposable {};
+	const dispatcherHandlerTemplate = /* @__PURE__ */ defineTemplate(function(Type) {
+		const newType = createSafeNew(Type);
+		return class DispatcherHandler extends BasicDispatcherHandler {
+			signal;
+			events;
+			constructor() {
+				super();
+				this.signal = new Sigh();
+				this.events = [];
+			}
+			dispose() {
+				this.signal.dispose();
+				this.events.length = 0;
+			}
+			publish() {
+				while (this.events.length > 0) {
+					const event = this.events.shift();
+					this.signal.publish(event);
+				}
+			}
+			disconnect(instance) {
+				new Sigh.SinkType(this.signal).disconnect(void 0, instance);
+			}
+			clear() {
+				this.events.length = 0;
+			}
+			bucket() {
+				return new Sigh.SinkType(this.signal);
+			}
+			trigger(event) {
+				this.signal.publish(event);
+			}
+			enqueue(...args) {
+				this.events.push(newType(...args));
+			}
+			get size() {
+				return this.events.length;
+			}
+		};
+	});
+	var BasicDispatcher = class extends Disposable {
+		pools;
+		constructor() {
+			super();
+			this.pools = /* @__PURE__ */ new Map();
+		}
+		dispose() {
+			this.pools.forEach((pool) => {
+				pool.dispose();
+			});
+			this.pools.clear();
+		}
+		assure(Type) {
+			if (!this.pools.has(Type)) {
+				const handler = new (dispatcherHandlerTemplate.instantiate(Type))();
+				this.pools.set(Type, handler);
+				return handler;
+			}
+			return this.pools.get(Type);
+		}
+		constAssure(Type) {
+			return this.pools.get(Type);
+		}
+		size(Type) {
+			if (Type != null) {
+				const cpool = this.constAssure(Type);
+				return cpool ? cpool.size : 0;
+			}
+			let size = 0;
+			this.pools.forEach((cpool) => {
+				size += cpool.size;
+			});
+			return size;
+		}
+		sink(Type) {
+			return this.assure(Type).bucket();
+		}
+		trigger(Type, event) {
+			this.assure(Type).trigger(event);
+		}
+		enqueue(Type, ...args) {
+			this.assure(Type).enqueue(...args);
+		}
+		disconnect(instance) {
+			this.pools.forEach((handler) => {
+				handler.disconnect(instance);
+			});
+		}
+		clear(Type) {
+			if (Type != null) this.assure(Type).clear();
+			else this.pools.forEach((handler) => {
+				handler.clear();
+			});
+		}
+		update(Type) {
+			if (Type != null) this.assure(Type).publish();
+			else this.pools.forEach((handler) => {
+				handler.publish();
+			});
+		}
+	};
+	var Emitter = class extends Disposable {
+		handlers;
+		constructor() {
+			super();
+			this.handlers = /* @__PURE__ */ new Map();
+		}
+		dispose() {
+			this.handlers.clear();
+		}
+		on(Type, fn) {
+			this.handlers.set(Type, (value) => {
+				fn(value, this);
+			});
+		}
+		publish(value) {
+			const Constructor = value.constructor;
+			const handler = this.handlers.get(Constructor);
+			if (handler) handler(value);
+		}
+		erase(Type) {
+			this.handlers.delete(Type);
+		}
+		clear() {
+			this.handlers.clear();
+		}
+		contains(Type) {
+			return this.handlers.has(Type);
+		}
+		empty() {
+			return this.handlers.size === 0;
+		}
+	};
+
+//#endregion
+//#region src/mixin.ts
+	const basicSighMixinTemplate = /* @__PURE__ */ defineTemplate(function(Type) {
+		const UnderlyingType = Type;
+		return class BasicSighMixin extends Type {
+			static UnderlyingType = UnderlyingType;
+			owner;
+			construction;
+			destruction;
+			update;
+			constructor(...args) {
+				super(...args);
+				this.owner = null;
+				this.construction = new Sigh();
+				this.destruction = new Sigh();
+				this.update = new Sigh();
+			}
+			dispose() {
+				this.construction.dispose();
+				this.destruction.dispose();
+				this.update.dispose();
+				super.dispose();
+				this.owner = null;
+			}
+			ownerOrAssert() {
+				assert(this.owner != null, "Invalid reference to registry");
+				return this.owner;
+			}
+			pop(first, last) {
+				const reg = this.ownerOrAssert();
+				if (this.destruction.empty()) super.pop(first, last);
+				else {
+					first = first.clone();
+					last = last.clone();
+					for (; !first.equals(last); first.selfPlus()) {
+						const entt = first.deref();
+						this.destruction.publish(reg, entt);
+						const it = super.find(entt);
+						super.pop(it, it.plus(1));
+					}
+				}
+			}
+			popAll() {
+				const reg = this.ownerOrAssert();
+				if (!this.destruction.empty()) if ("ElementType" in UnderlyingType && "EntityType" in UnderlyingType && UnderlyingType.ElementType === UnderlyingType.EntityType) for (let pos = 0, last = super.freeList(); pos < last; ++pos) this.destruction.publish(reg, super.access(pos));
+				else for (const entt of UnderlyingType.BaseType.prototype[Symbol.iterator].call(this)) if (UnderlyingType.storagePolicy === DeletionPolicy.InPlace) {
+					if (!this.isTombstone(entt)) this.destruction.publish(reg, entt);
+				} else this.destruction.publish(reg, entt);
+				super.popAll();
+			}
+			tryEmplace(entt, forceback, value) {
+				const reg = this.ownerOrAssert();
+				const it = super.tryEmplace(entt, forceback, value);
+				if (!this.construction.empty()) this.construction.publish(reg, it.deref());
+			}
+			insert(first, last, ...args) {
+				let from = super.size;
+				super.insert(first, last, ...args);
+				const reg = this.ownerOrAssert();
+				if (!this.construction.empty()) {
+					const to = super.size;
+					for (; from !== to; ++from) this.construction.publish(reg, super.access(from));
+				}
+			}
+			bindAny(value) {
+				this.owner = value;
+				super.bindAny(value);
+			}
+			onConstruct() {
+				return new Sink(this.construction);
+			}
+			onUpdate() {
+				return new Sink(this.update);
+			}
+			onDestroy() {
+				return new Sink(this.destruction);
+			}
+			registry() {
+				return this.ownerOrAssert();
+			}
+			generate(hint) {
+				const e = super.generate(hint);
+				if (!this.construction.empty()) this.construction.publish(this.ownerOrAssert(), e);
+				return e;
+			}
+			generateRange(first, last) {
+				super.generateRange(first, last);
+				const reg = this.ownerOrAssert();
+				if (!this.construction.empty()) {
+					const [f, l] = makeRangePointer(first, last);
+					for (; !f.equals(l); f.selfPlus()) this.construction.publish(reg, f.deref());
+				}
+			}
+			emplace(entt, ...args) {
+				super.emplace(entt, ...args);
+				if (!this.construction.empty()) this.construction.publish(this.ownerOrAssert(), entt);
+				return this.get(entt);
+			}
+			patch(entt, ...args) {
+				super.patch(entt, ...args);
+				if (!this.update.empty()) this.update.publish(this.ownerOrAssert(), entt);
+				return this.get(entt);
+			}
+		};
+	});
+
+//#endregion
+//#region src/storage.ts
+	var StoragePointer = class StoragePointer {
+		payload;
+		offset;
+		pageSize;
+		constructor(pageSize, payload, offset) {
+			this.pageSize = pageSize ?? 0;
+			this.payload = payload ?? null;
+			this.offset = offset ?? 0;
+		}
+		dispose() {
+			this.payload = null;
+			this.offset = 0;
+			this.pageSize = 0;
+		}
+		clone(target) {
+			if (target) {
+				if (target === this) return target;
+				target.payload = this.payload;
+				target.offset = this.offset;
+				target.pageSize = this.pageSize;
+				return target;
+			}
+			return new StoragePointer(this.pageSize, this.payload, this.offset);
+		}
+		swap(other) {
+			if (this === other) return;
+			const t = this.payload;
+			this.payload = other.payload;
+			other.payload = t;
+			const o$1 = this.offset;
+			this.offset = other.offset;
+			other.offset = o$1;
+			const p = this.pageSize;
+			this.pageSize = other.pageSize;
+			other.pageSize = p;
+		}
+		data() {
+			return this.payload;
+		}
+		selfPlus(n = 1) {
+			this.offset -= n;
+			return this;
+		}
+		selfMinus(n = 1) {
+			this.offset += n;
+			return this;
+		}
+		plus(n) {
+			return new StoragePointer(this.pageSize, this.payload, this.offset - n);
+		}
+		minus(n) {
+			return new StoragePointer(this.pageSize, this.payload, this.offset + n);
+		}
+		diff(other) {
+			return other.index() - this.index();
+		}
+		equals(other) {
+			return this.index() === other.index();
+		}
+		lt(other) {
+			return this.index() > other.index();
+		}
+		gt(other) {
+			return this.index() < other.index();
+		}
+		le(other) {
+			return !this.gt(other);
+		}
+		ge(other) {
+			return !this.lt(other);
+		}
+		deref() {
+			return this.access(0);
+		}
+		write(value) {
+			this.set(0, value);
+			return value;
+		}
+		access(value) {
+			const idx = this.index() - value;
+			if (this.pageSize === 0) return this.payload[0][idx];
+			return this.payload[idx / this.pageSize >>> 0][(idx & this.pageSize - 1) >>> 0];
+		}
+		set(off, value) {
+			const idx = this.index() - off;
+			if (this.pageSize === 0) this.payload[0][idx] = value;
+			else this.payload[idx / this.pageSize >>> 0][(idx & this.pageSize - 1) >>> 0] = value;
+		}
+		index() {
+			return this.offset - 1;
+		}
+	};
+	const basicStorageTemplate = /* @__PURE__ */ defineTemplate(function(Type, Entity$1) {
+		const BaseType = basicSparseSetTemplate.instantiate(Entity$1);
+		const TraitsType = componentTraitsTemplate.instantiate(Type, Entity$1);
+		const _new = createSafeNew(TraitsType.ElementType);
+		const storagePolicy = TraitsType.inPlaceDelete ? DeletionPolicy.InPlace : DeletionPolicy.SwapAndPop;
+		if (TraitsType.pageSize === 0) return class BasicStorage$1 extends BaseType {
+			static TraitsType = TraitsType;
+			static storagePolicy = storagePolicy;
+			static EntityType = Entity$1;
+			static ElementType = Type;
+			static BaseType = BaseType;
+			static ValueType = void 0;
+			constructor() {
+				super(TraitsType.ElementType, storagePolicy);
+			}
+			get(entt) {
+				assert(super.contains(entt), "Invalid entity");
+			}
+			getAsRef(entt) {
+				assert(super.contains(entt), "Invalid entity");
+				return {
+					get: () => {},
+					set: () => {}
+				};
+			}
+			getAsTuple(entt) {
+				assert(super.contains(entt), "Invalid entity");
+				return [];
+			}
+			emplace(entt, ..._args) {
+				super.tryEmplace(entt, false);
+			}
+			insert(first, last, _) {
+				first = first.clone();
+				last = last.clone();
+				for (; !first.equals(last); first.selfPlus()) {
+					const entt = first.deref();
+					super.tryEmplace(entt, true);
+				}
+			}
+			patch(entt, ...func) {
+				assert(super.contains(entt), "Invalid entity");
+				for (const f of func) f();
+			}
+			[Symbol.iterator]() {
+				return toIterator(this);
+			}
+			each() {
+				const kBegin = super.begin();
+				const kEnd = super.end();
+				return toIterator(new AggregatePointer([kBegin]), new AggregatePointer([kEnd]));
+			}
+			reach() {
+				const kBegin = super.rbegin();
+				const kEnd = super.rend();
+				return toIterator(new AggregatePointer([kBegin]), new AggregatePointer([kEnd]));
+			}
+		};
+		const BasicStorage = class extends BaseType {
+			payload;
+			static TraitsType = TraitsType;
+			static Iterator = StoragePointer;
+			static ReverseIterator = ReversePointer;
+			static storagePolicy = storagePolicy;
+			static EntityType = Entity$1;
+			static ElementType = Type;
+			static BaseType = BaseType;
+			static ValueType = Type;
+			elementAt(pos) {
+				return this.payload[pos / TraitsType.pageSize >>> 0]?.[(pos & TraitsType.pageSize - 1) >>> 0];
+			}
+			elementSet(pos, value) {
+				const page = this.assureAtLeast(pos);
+				this.payload[page][(pos & TraitsType.pageSize - 1) >>> 0] = value;
+			}
+			assureAtLeast(pos) {
+				const page = pos / TraitsType.pageSize >>> 0;
+				while (this.payload.length <= page) if (this.payload.length === page) this.payload.push(Array(((pos & TraitsType.pageSize - 1) >>> 0) + 1));
+				else this.payload.push(Array(TraitsType.pageSize).fill(void 0));
+				return page;
+			}
+			constructor() {
+				super(TraitsType.ElementType, storagePolicy);
+				this.payload = [];
+			}
+			dispose() {
+				this.payload.length = 0;
+				super.dispose();
+			}
+			reserve(cap) {
+				if (cap !== 0) {
+					super.reserve(cap);
+					this.assureAtLeast(cap - 1);
+				}
+			}
+			get(entt) {
+				return this.elementAt(super.index(entt));
+			}
+			getAsRef(entt) {
+				return {
+					get: () => this.elementAt(super.index(entt)),
+					set: (value) => {
+						this.elementSet(super.index(entt), value);
+					}
+				};
+			}
+			getAsTuple(entt) {
+				return [this.get(entt)];
+			}
+			emplaceElement(entt, forceBack, ...args) {
+				const it = super.tryEmplace(entt, forceBack);
+				let elem = void 0;
+				try {
+					if (args.length === 1 && args[0] instanceof TraitsType.ElementType) elem = clone(args[0]);
+					else elem = _new(...args);
+					this.elementSet(it.index(), elem);
+				} catch (e) {
+					super.pop(it, it.plus(1));
+					throw e;
+				}
+				return it;
+			}
+			tryEmplace(entt, forceBack, value) {
+				if (value != null) return this.emplaceElement(entt, forceBack, value);
+				return this.emplaceElement(entt, forceBack);
+			}
+			emplace(entt, ...args) {
+				const it = this.emplaceElement(entt, false, ...args);
+				return this.elementAt(it.index());
+			}
+			insert(first, last, value = _new()) {
+				first = first.clone();
+				last = last.clone();
+				for (; !first.equals(last); first.selfPlus()) {
+					const entt = first.deref();
+					this.emplaceElement(entt, true, value);
+				}
+				return this.begin();
+			}
+			insertRange(first, last, from) {
+				first = first.clone();
+				last = last.clone();
+				from = from.clone();
+				for (; !first.equals(last); first.selfPlus(), from.selfPlus()) {
+					const entt = first.deref();
+					this.emplaceElement(entt, true, from.deref());
+				}
+				return this.begin();
+			}
+			patch(entt, ...func) {
+				const idx = super.index(entt);
+				let elem = void 0;
+				for (const f of func) {
+					elem = this.elementAt(idx);
+					const update = f(elem);
+					if (update != null) {
+						this.elementSet(idx, update);
+						elem = update;
+					}
+				}
+				return elem;
+			}
+			pop(first, last) {
+				first = first.clone();
+				last = last.clone();
+				for (; !first.equals(last); first.selfPlus()) if (TraitsType.inPlaceDelete) {
+					const entt = first.deref();
+					const idx = super.index(entt);
+					super.inPlacePop(entt);
+					this.elementSet(idx, void 0);
+				} else {
+					const lastIndex = super.size - 1;
+					const entt = first.deref();
+					const idx = super.index(entt);
+					if (idx !== lastIndex) {
+						const tmp = this.elementAt(lastIndex);
+						this.elementSet(idx, tmp);
+						this.elementSet(lastIndex, void 0);
+					} else this.elementSet(lastIndex, void 0);
+					super.swapAndPop(entt);
+				}
+			}
+			popAll() {
+				for (const first = super.begin(); !(first.index() < 0); first.selfPlus()) if (TraitsType.inPlaceDelete) {
+					if (!this.isTombstone(first.deref())) {
+						super.inPlacePop(first.deref());
+						this.elementSet(first.index(), void 0);
+					}
+				} else {
+					super.swapAndPop(first.deref());
+					this.elementSet(first.index(), void 0);
+				}
+			}
+			swapAt(from, to) {
+				const tmp = this.elementAt(from);
+				this.elementSet(from, this.elementAt(to));
+				this.elementSet(to, tmp);
+			}
+			moveTo(from, to) {
+				const tmp = this.elementAt(from);
+				this.elementSet(from, void 0);
+				this.elementSet(to, tmp);
+			}
+			swapOrMove(from, to) {
+				if (this.mode === DeletionPolicy.InPlace) {
+					const entity = super.access(to);
+					if (entity != null && BaseType.TraitsType.isTombstone(entity)) this.moveTo(from, to);
+					else BasicStorage.prototype.swapAt.call(this, from, to);
+				} else BasicStorage.prototype.swapAt.call(this, from, to);
+			}
+			[Symbol.iterator]() {
+				return toIterator(this);
+			}
+			entries() {
+				const kBegin = super.begin();
+				const vBegin = this.begin();
+				const kEnd = super.end();
+				const vEnd = this.end();
+				return toIterator(new AggregatePointer([kBegin, vBegin]), new AggregatePointer([kEnd, vEnd]));
+			}
+			capacity() {
+				return this.payload.length * TraitsType.pageSize;
+			}
+			begin() {
+				return new StoragePointer(TraitsType.pageSize, this.payload, this.size);
+			}
+			end() {
+				return new StoragePointer(TraitsType.pageSize, this.payload, 0);
+			}
+			rbegin() {
+				return makeReversePointer(this.end());
+			}
+			rend() {
+				return makeReversePointer(this.begin());
+			}
+			each() {
+				return this.entries();
+			}
+			reach() {
+				const kBegin = super.rbegin();
+				const vBegin = this.rbegin();
+				const kEnd = super.rend();
+				const vEnd = this.rend();
+				return toIterator(new AggregatePointer([kBegin, vBegin]), new AggregatePointer([kEnd, vEnd]));
+			}
+			forEach(callbackfn, thisArg) {
+				const begin = this.begin();
+				const end = this.end();
+				for (; !begin.equals(end); begin.selfPlus()) {
+					const value = begin.deref();
+					const key = this.data()[begin.index()];
+					callbackfn.call(thisArg, value, key, this);
+				}
+			}
+		};
+		return BasicStorage;
+	}, [{
+		predicate: (Type, Entity$1) => Entity$1 === void 0 || Object.is(Entity$1, Type),
+		render: ((Entity$1) => {
+			const BaseType = basicSparseSetTemplate.instantiate(Entity$1);
+			const TraitsType = enttTraitsTemplate.instantiate(Entity$1);
+			const storagePolicy = DeletionPolicy.SwapOnly;
+			return class BasicStorage extends BaseType {
+				placeholder;
+				static TraitsType = TraitsType;
+				static storagePolicy = storagePolicy;
+				static EntityType = Entity$1;
+				static ElementType = Entity$1;
+				static BaseType = BaseType;
+				static ValueType = void 0;
+				static Iterator = SparseSetPointer;
+				static ReverseIterator = ReversePointer;
+				constructor() {
+					super(TraitsType.ValueType, storagePolicy);
+					this.placeholder = 0n;
+				}
+				dispose() {
+					this.placeholder = 0n;
+					super.dispose();
+				}
+				fromPlaceholder() {
+					const entt = TraitsType.combine(TraitsType.EntityType(this.placeholder), TraitsType.EntityType(0));
+					const isNullEntity = TraitsType.isNull(entt);
+					assert(!isNullEntity, "No more entities available");
+					this.placeholder += !isNullEntity ? 1n : 0n;
+					return entt;
+				}
+				next() {
+					let entt = this.fromPlaceholder();
+					while (super.current(entt) !== TraitsType.toVersion(TraitsType.tombstone) && !TraitsType.isNull(entt)) entt = this.fromPlaceholder();
+					return entt;
+				}
+				popAll() {
+					super.popAll();
+					this.placeholder = 0n;
+				}
+				tryEmplace(hint) {
+					return super.find(this.generate(hint));
+				}
+				get(entt) {
+					assert(super.index(entt) < super.freeList(), "The requested entity is not a live one");
+				}
+				getAsRef(entt) {
+					assert(super.index(entt) < super.freeList(), "The requested entity is not a live one");
+					return {
+						get: () => {},
+						set: () => {}
+					};
+				}
+				getAsTuple(entt) {
+					assert(super.index(entt) < super.freeList(), "The requested entity is not a live one");
+					return [];
+				}
+				startFrom(hint) {
+					this.placeholder = BigInt(TraitsType.toEntity(hint));
+				}
+				generate(hint) {
+					if (hint != null && !TraitsType.isNull(hint) && !TraitsType.isTombstone(hint)) {
+						const curr = TraitsType.construct(TraitsType.toEntity(hint), super.current(hint));
+						if (TraitsType.isTombstone(curr) || super.index(curr) >= super.freeList()) return super.tryEmplace(hint, true).deref();
+					}
+					const len = super.freeList();
+					const entt = len === Uint64(super.size) ? this.next() : super.data()[len];
+					return super.tryEmplace(entt, true).deref();
+				}
+				generateRange(first, last) {
+					const [f, l] = makeRangePointer(first, last);
+					const sz = Uint64(super.size);
+					for (; !f.equals(l) && super.freeList() !== sz; f.selfPlus()) f.write(super.tryEmplace(super.data()[super.freeList()], true).deref());
+					for (; !f.equals(l); f.selfPlus()) f.write(super.tryEmplace(this.next(), true).deref());
+				}
+				insert(first, last) {
+					first = first.clone();
+					last = last.clone();
+					for (; !first.equals(last); first.selfPlus()) {
+						const entt = first.deref();
+						super.tryEmplace(entt, true);
+					}
+				}
+				patch(entt, ...func) {
+					assert(super.index(entt) < super.freeList(), "The requested entity is not a live one");
+					for (const f of func) f();
+				}
+				each() {
+					const it = super.end();
+					const offset = super.freeList();
+					return toIterator(new AggregatePointer([it.minus(Number(offset))]), new AggregatePointer([it]));
+				}
+				reach() {
+					const it = super.rbegin();
+					const offset = super.freeList();
+					return toIterator(new AggregatePointer([new ReversePointer(it)]), new AggregatePointer([new ReversePointer(it.plus(Number(offset)))]));
+				}
+			};
+		})
+	}]);
+	const storageTemplate = /* @__PURE__ */ defineTemplate(function(Type) {
+		return basicStorageTemplate.instantiate(Type, Entity);
+	});
+	const storageTypeTemplate = /* @__PURE__ */ defineTemplate(function(Type, EntityType) {
+		return class StorageType {
+			static Type = config.mixin ? basicSighMixinTemplate.instantiate(basicStorageTemplate.instantiate(Type, EntityType)) : basicStorageTemplate.instantiate(Type, EntityType);
+		};
+	});
+	const storageTypeTTemplate = /* @__PURE__ */ defineTemplate(function(...args) {
+		return storageTypeTemplate.instantiate(...args).Type;
+	});
+
+//#endregion
+//#region src/view.ts
+	const tombstoneCheck = (...args) => args.length === 1 && args[0].storagePolicy === DeletionPolicy.InPlace;
+	const placeholderMap = /* @__PURE__ */ new Map();
+	const viewPlaceholder = (Type) => {
+		if (!placeholderMap.has(Type)) {
+			const instance = new Type();
+			placeholderMap.set(Type, instance);
+			return instance;
+		}
+		return placeholderMap.get(Type);
+	};
+	function allOf(first, last, entt) {
+		first = first.clone();
+		last = last.clone();
+		for (; !first.equals(last) && first.deref().contains(entt); first.selfPlus());
+		return first.equals(last);
+	}
+	function noneOf(first, last, entt) {
+		first = first.clone();
+		last = last.clone();
+		for (; !first.equals(last) && !first.deref().contains(entt); first.selfPlus());
+		return first.equals(last);
+	}
+	function fullyInitialized(first, last, placeholder) {
+		first = first.clone();
+		last = last.clone();
+		for (; !first.equals(last) && first.deref() !== placeholder; first.selfPlus());
+		return first.equals(last);
+	}
+	function findSameBase(A, B) {
+		if (A === B) return A;
+		let CurrentA = A;
+		while (CurrentA != null) {
+			let CurrentB = B;
+			while (CurrentB != null) {
+				if (CurrentA === CurrentB) return CurrentA;
+				CurrentB = Object.getPrototypeOf(CurrentB);
+			}
+			CurrentA = Object.getPrototypeOf(CurrentA);
+		}
+		return null;
+	}
+	function commonType(...instances) {
+		if (instances.length === 0) throw new Error("No storage type provided");
+		let Target = instances[0];
+		for (let pos = 1; pos < instances.length; ++pos) {
+			const Current = instances[pos];
+			Target = findSameBase(Target, Current);
+			if (Target == null) throw new Error("No common storage type found");
+		}
+		return Target;
+	}
+	const viewPointerTemplate = /* @__PURE__ */ defineTemplate(function(Type, checked, get, exclude) {
+		const PointerType = Type.Iterator;
+		class ViewPointer {
+			it;
+			pools;
+			filter;
+			index;
+			valid(entt) {
+				const pools = toRange(this.pools);
+				const filter = toRange(this.filter);
+				return (!checked || !Type.isTombstone(entt)) && (get === 1 || allOf(pools.begin(), pools.begin().plus(this.index), entt) && allOf(pools.begin().plus(this.index + 1), pools.end(), entt)) && (exclude === 0 || noneOf(filter.begin(), filter.end(), entt));
+			}
+			seekNext() {
+				for (const sentinel = new PointerType(); !this.it.equals(sentinel) && !this.valid(this.it.deref()); this.it.selfPlus());
+			}
+			constructor(first, values, excl, idx) {
+				if (first != null && values != null && excl != null && idx != null) {
+					this.it = first.clone();
+					this.pools = values;
+					this.filter = excl;
+					this.index = idx;
+					if (values.length !== get) throw new AssertionError("View iterator get count mismatch");
+					if (excl.length !== exclude) throw new AssertionError("View iterator exclude count mismatch");
+					assert(get !== 1 || exclude !== 0 || this.pools[0].policy() === DeletionPolicy.InPlace, "Non in-place storage view iterator");
+					this.seekNext();
+				} else {
+					this.it = new PointerType();
+					this.pools = Array(get);
+					this.filter = Array(exclude);
+					this.index = 0;
+				}
+			}
+			selfPlus() {
+				this.it.selfPlus();
+				this.seekNext();
+				return this;
+			}
+			write(_value) {
+				throw new Error("Unsupported operation");
+			}
+			deref() {
+				return this.it.deref();
+			}
+			equals(other) {
+				return this.it.equals(other.it);
+			}
+			clone(target) {
+				if (target) {
+					if (this === target) return target;
+					this.it.clone(target.it);
+					target.pools = this.pools;
+					target.filter = this.filter;
+					target.index = this.index;
+					return target;
+				}
+				return new ViewPointer(this.it, this.pools, this.filter, this.index);
+			}
+			swap(other) {
+				if (this === other) return;
+				const it = this.it;
+				this.it = other.it;
+				other.it = it;
+				const pools = this.pools;
+				this.pools = other.pools;
+				other.pools = pools;
+				const filter = this.filter;
+				this.filter = other.filter;
+				other.filter = filter;
+				const index = this.index;
+				this.index = other.index;
+				other.index = index;
+			}
+		}
+		return ViewPointer;
+	});
+	var ExtendedViewPointer = class ExtendedViewPointer {
+		it;
+		constructor(it) {
+			this.it = it.clone();
+		}
+		selfPlus() {
+			this.it.selfPlus();
+			return this;
+		}
+		write(_value) {
+			throw new Error("Unsupported operation");
+		}
+		deref() {
+			return [this.it.deref(), ...this.it.pools.flatMap((pool) => pool.getAsTuple(this.it.deref()))];
+		}
+		equals(other) {
+			return this.it.equals(other.it);
+		}
+		clone(target) {
+			if (target) {
+				if (this === target) return target;
+				this.it.clone(target.it);
+				return target;
+			}
+			return new ExtendedViewPointer(this.it);
+		}
+		swap(other) {
+			if (this === other) return;
+			this.it.swap(other.it);
+		}
+		base() {
+			return this.it.clone();
+		}
+	};
+	const basicCommonViewTemplate = /* @__PURE__ */ defineTemplate(function(Type, checked, get, exclude) {
+		const BasicCommonView = class {
+			pools;
+			filter;
+			index;
+			placeholder;
+			static Iterator = viewPointerTemplate.instantiate(Type, checked, get, exclude);
+			static CommonType = Type;
+			static EntityType = Type.EntityType;
+			offset() {
+				assert(this.index !== get, "Invalid view");
+				return this.pools[this.index].policy() === DeletionPolicy.SwapOnly ? Number(this.pools[this.index].freeList()) : this.pools[this.index].size;
+			}
+			uncheckedRefresh() {
+				this.index = 0;
+				if (get > 1) {
+					for (let pos = 1; pos < get; ++pos) if (this.pools[pos].size < this.pools[this.index].size) this.index = pos;
+				}
+			}
+			constructor(value, excl) {
+				this.placeholder = viewPlaceholder(Type);
+				if (Array.isArray(value) && Array.isArray(excl)) {
+					if (value.length !== get) throw new Error("View pool count mismatch");
+					if (excl.length !== exclude) throw new Error("View exclude count mismatch");
+					this.pools = value;
+					this.filter = excl;
+					this.index = get;
+					this.uncheckedRefresh();
+				} else {
+					this.pools = Array(get);
+					this.filter = Array(exclude);
+					this.index = get;
+					for (let pos = 0, last = this.filter.length; pos < last; ++pos) this.filter[pos] = this.placeholder;
+				}
+			}
+			poolAt(index, elem) {
+				if (index < 0 || index >= get) throw new Error("View pool index out of range");
+				if (elem !== void 0) {
+					assert(elem !== null, "Unexpected element");
+					this.pools[index] = elem;
+					this.refresh();
+				} else return this.pools[index];
+			}
+			filterAt(index, elem) {
+				if (index < 0 || index >= exclude) throw new Error("View filter index out of range");
+				if (elem !== void 0) {
+					assert(elem !== null, "Unexpected element");
+					this.filter[index] = elem;
+				} else return this.filter[index] === this.placeholder ? null : this.filter[index];
+			}
+			noneOf(entt) {
+				const range = toRange(this.filter);
+				return noneOf(range.begin(), range.end(), entt);
+			}
+			use(pos) {
+				this.index = this.index !== get ? pos : get;
+			}
+			refresh() {
+				let pos = Number(this.index !== get) * get;
+				for (; pos < get && this.pools[pos] != null; ++pos);
+				if (pos === get) this.uncheckedRefresh();
+			}
+			handle() {
+				return this.index !== get ? this.pools[this.index] : null;
+			}
+			sizeHint() {
+				return this.index !== get ? this.offset() : 0;
+			}
+			begin() {
+				return this.index !== get ? new BasicCommonView.Iterator(Type.prototype.end.call(this.pools[this.index]).minus(this.offset()), this.pools, this.filter, this.index) : new BasicCommonView.Iterator();
+			}
+			end() {
+				return this.index !== get ? new BasicCommonView.Iterator(Type.prototype.end.call(this.pools[this.index]), this.pools, this.filter, this.index) : new BasicCommonView.Iterator();
+			}
+			front() {
+				const it = this.begin();
+				return it.equals(this.end()) ? Type.TraitsType.null : it.deref();
+			}
+			back() {
+				if (this.index !== get) {
+					const it = this.pools[this.index].rbegin();
+					const last = it.plus(this.offset());
+					for (const idx = this.index; !it.equals(last) && !(allOf(toRange(this.pools).begin(), toRange(this.pools).begin().plus(idx), it.deref()) && allOf(toRange(this.pools).begin().plus(idx).plus(1), toRange(this.pools).end(), it.deref()) && noneOf(toRange(this.filter).begin(), toRange(this.filter).end(), it.deref())); it.selfPlus());
+					return it.equals(last) ? Type.TraitsType.null : it.deref();
+				}
+				return Type.TraitsType.null;
+			}
+			find(entt) {
+				return this.contains(entt) ? new BasicCommonView.Iterator(this.pools[this.index].find(entt), this.pools, this.filter, this.index) : this.end();
+			}
+			ok() {
+				return this.index !== get && fullyInitialized(toRange(this.filter).begin(), toRange(this.filter).end(), this.placeholder);
+			}
+			[Symbol.toPrimitive]() {
+				return this.ok();
+			}
+			contains(entt) {
+				return this.index !== get && (checked ? !Type.isTombstone(entt) : true) && allOf(toRange(this.pools).begin(), toRange(this.pools).begin().plus(this.index), entt) && allOf(toRange(this.pools).begin().plus(this.index + 1), toRange(this.pools).end(), entt) && this.noneOf(entt);
+			}
+			[Symbol.iterator]() {
+				return toIterator(this);
+			}
+		};
+		return BasicCommonView;
+	});
+	const basicViewTemplate = /* @__PURE__ */ defineTemplate(function(_Gets, _Excludes) {
+		throw new Error("Invalid BasicView instantiation");
+	}, [{
+		predicate: (Gets, Excludes) => Gets.length === 1 && (Excludes == null || Excludes.length === 0),
+		render(Gets, _Excludes) {
+			const Get = Gets[0].constructor;
+			const BasicStorageView = basicStorageViewTemplate.instantiate(Get.BaseType, Get.storagePolicy);
+			const BaseType = BasicStorageView;
+			class BasicView extends BasicStorageView {
+				static CommonType = BaseType.CommonType;
+				static EntityType = BaseType.EntityType;
+				static Iterator = BaseType.Iterator;
+				static ReverseIterator = BaseType.ReverseIterator;
+				constructor(value, _) {
+					super(Array.isArray(value) ? value[0] : value);
+				}
+				getStorageByElementType(_ElementType) {
+					return this.getStorageByIndex(0);
+				}
+				getStorageByIndex(index = 0) {
+					if (index !== 0) throw new Error("Index out of bounds");
+					return super.handle();
+				}
+				setStorageByType(elem) {
+					this.setStorage(0, elem);
+				}
+				setStorage(index, elem) {
+					if (index !== 0) throw new Error("Index out of bounds");
+					this.leading = elem;
+				}
+				access(entt) {
+					return this.getStorageByIndex()?.get(entt);
+				}
+				getByElementType(entt, ElementType) {
+					if (ElementType !== Get.ElementType) throw new Error("Invalid element type");
+					return this.get(entt, 0);
+				}
+				get(entt, index) {
+					if (index == null) return this.getStorageByIndex()?.getAsTuple(entt) ?? [void 0];
+					return this.getStorageByIndex(index)?.get(entt);
+				}
+				each(func, componentsOnly) {
+					if (func != null && typeof func === "function") {
+						if (!componentsOnly) for (const pack of this.each()) func.apply(this, pack);
+						else if (Get.storagePolicy === DeletionPolicy.SwapAndPop || Get.storagePolicy === DeletionPolicy.SwapOnly) if (Get.ValueType === void 0) for (let pos = super.size; pos; --pos) func.call(this);
+						else {
+							const len = super.size;
+							if (len !== 0) for (let last = this.getStorageByIndex().end(), first = last.minus(len); !first.equals(last); first.selfPlus()) func.call(this, first.deref());
+						}
+						else {
+							if (Get.storagePolicy !== DeletionPolicy.InPlace) throw new AssertionError("Unexpected storage policy");
+							for (const pack of this.each()) func.call(this, ...pack.slice(1));
+						}
+						return;
+					}
+					if (Get.storagePolicy === DeletionPolicy.SwapAndPop || Get.storagePolicy === DeletionPolicy.SwapOnly) return super.handle() ? this.getStorageByIndex().each() : toIterator(new AggregatePointer([new SparseSetPointer()]), new AggregatePointer([new SparseSetPointer()]));
+					else {
+						if (Get.storagePolicy !== DeletionPolicy.InPlace) throw new AssertionError("Unexpected storage policy");
+						return toIterator(new ExtendedViewPointer(super.begin()), new ExtendedViewPointer(super.end()));
+					}
+				}
+				bitOr(other) {
+					const pools = [this.leading, ...other.pools ?? [other.leading]];
+					const placeholder = viewPlaceholder(commonType(...pools.map((storage) => storage.constructor.BaseType)));
+					const filterOrPlaceholder = (value) => value ?? placeholder;
+					const filter = other.filter ? [...other.filter.map((_, i) => filterOrPlaceholder(other.getStorageByIndex(other.pools.length + i)))] : [];
+					const elem = new (basicViewTemplate.instantiate(pools, filter))();
+					elem.pools = pools;
+					elem.filter = filter;
+					elem.refresh();
+					return elem;
+				}
+			}
+			return BasicView;
+		}
+	}, {
+		predicate: (Gets, _Excludes) => Gets.length !== 0,
+		render(Gets, Excludes) {
+			const BasicCommonView = basicCommonViewTemplate.instantiate(commonType(...Gets.map((storage) => storage.constructor.BaseType)), tombstoneCheck(...Gets), Gets.length, Excludes.length);
+			const BaseType = BasicCommonView;
+			class BasicView extends BasicCommonView {
+				static BaseType = BaseType;
+				static indexOf = (Type) => {
+					return [...Gets.map((t) => t.constructor.ElementType), ...Excludes.map((t) => t.constructor.ElementType)].indexOf(Type);
+				};
+				get(entt, ...indexes) {
+					return indexes.map((index) => this.getStorageByIndex(index)?.getAsTuple(entt) ?? []).flat();
+				}
+				dispatchGet(Curr, Other, curr) {
+					if (Curr === Other) return [curr[Curr + 1]];
+					else return this.getStorageByIndex(Other)?.getAsTuple(curr[0]) ?? [];
+				}
+				_each(Curr, func, componentsOnly, ...indexes) {
+					const storage = this.getStorageByIndex(Curr);
+					for (const curr of storage.each()) {
+						const entt = curr[0];
+						if ((!tombstoneCheck(...Gets) || !storage.isTombstone(entt)) && indexes.every((index) => Curr === index || super.poolAt(index).contains(entt)) && super.noneOf(entt)) {
+							const comps = indexes.flatMap((index) => this.dispatchGet(Curr, index, curr));
+							if (componentsOnly) func.apply(this, comps);
+							else func.call(this, entt, ...comps);
+						}
+					}
+				}
+				pickAndEach(func, componentsOnly, ...indexes) {
+					const view = super.handle();
+					if (view != null) indexes.forEach((index) => {
+						if (view === super.poolAt(index)) this._each(index, func, componentsOnly, ...indexes);
+					});
+				}
+				static CommonType = BaseType.CommonType;
+				static EntityType = BaseType.EntityType;
+				static Iterator = BaseType.Iterator;
+				constructor(value, excl = []) {
+					if (Array.isArray(value) && Array.isArray(excl)) super([...value], [...excl]);
+					else super();
+				}
+				useByType(ElementType) {
+					this.use(BasicView.indexOf(ElementType));
+				}
+				use(index) {
+					this.use(index);
+				}
+				getStorageByElementType(ElementType) {
+					return this.getStorageByIndex(BasicView.indexOf(ElementType));
+				}
+				getStorageByIndex(index) {
+					if (index < Gets.length) return super.poolAt(index);
+					else return super.filterAt(index - Gets.length);
+				}
+				setStorageByType(elem) {
+					const index = BasicView.indexOf(elem.constructor.ElementType);
+					this.setStorage(index, elem);
+				}
+				setStorage(index, elem) {
+					if (index < 0 || index >= Gets.length + Excludes.length) throw new Error("View storage index out of range");
+					if (index < Gets.length) super.poolAt(index, elem);
+					else super.filterAt(index - Gets.length, elem);
+				}
+				access(entt) {
+					return this.get(entt);
+				}
+				getByElementType(entt, ...ElementTypes) {
+					const ret = this.get(entt, ...ElementTypes.map((t) => BasicView.indexOf(t)));
+					return ret.length === 1 ? ret[0] : ret;
+				}
+				getByIndexes(entt, ...indexes) {
+					if (indexes.length === 0) return this.get(entt);
+					else if (indexes.length === 1) return this.getStorageByIndex(indexes[0])?.get(entt);
+					else return indexes.map((index) => this.getStorageByIndex(index)?.getAsTuple(entt)).flat();
+				}
+				each(func, componentsOnly) {
+					if (func != null && typeof func === "function") this.pickAndEach(func, componentsOnly, ...Array.from({ length: Gets.length }, (_, i) => i));
+					else return toIterator(new ExtendedViewPointer(super.begin()), new ExtendedViewPointer(super.end()));
+				}
+				bitOr(other) {
+					const pools = [...this.pools, ...other.pools ?? [other.leading]];
+					const placeholder = viewPlaceholder(commonType(...pools.map((storage) => storage.constructor.BaseType)));
+					const filterOrPlaceholder = (value) => value ?? placeholder;
+					const filter = [...this.filter.map((_, i) => filterOrPlaceholder(this.getStorageByIndex(this.pools.length + i))), ...other.filter ? other.filter.map((_, i) => filterOrPlaceholder(other.getStorageByIndex(other.pools.length + i))) : []];
+					const elem = new (basicViewTemplate.instantiate(pools, filter))();
+					elem.pools = pools;
+					elem.filter = filter;
+					elem.refresh();
+					return elem;
+				}
+			}
+			return BasicView;
+		}
+	}]);
+	function makeView(gets, excl = []) {
+		return new (basicViewTemplate.instantiate(gets, excl))(gets, excl);
+	}
+	const basicStorageViewTemplate = /* @__PURE__ */ defineTemplate(function(Type, policy) {
+		class BasicStorageView {
+			leading;
+			static CommonType = Type;
+			static EntityType = Type.EntityType;
+			static Iterator = policy === DeletionPolicy.InPlace ? viewPointerTemplate.instantiate(Type, true, 1, 0) : Type.Iterator;
+			static ReverseIterator = policy === DeletionPolicy.InPlace ? void 0 : Type.ReverseIterator;
+			constructor(value) {
+				this.leading = value ?? null;
+				assert(this.leading?.policy() === policy, "Unexpected storage policy");
+			}
+			handle() {
+				return this.leading;
+			}
+			get size() {
+				if (policy === DeletionPolicy.InPlace) throw new Error("Size not available for in-place storage views");
+				if (policy === DeletionPolicy.SwapAndPop) return this.leading != null ? Number(this.leading.size) : 0;
+				if (policy !== DeletionPolicy.SwapOnly) throw new AssertionError("Unexpected storage policy");
+				return this.leading != null ? Number(this.leading.freeList()) : 0;
+			}
+			sizeHint() {
+				if (policy !== DeletionPolicy.InPlace) throw new Error("Size hint not available for non in-place storage views");
+				return this.leading != null ? Number(this.leading.size) : 0;
+			}
+			empty() {
+				if (policy === DeletionPolicy.InPlace) throw new Error("Empty not available for in-place storage views");
+				if (policy === DeletionPolicy.SwapAndPop) return !this.leading || this.leading.empty();
+				if (policy !== DeletionPolicy.SwapOnly) throw new AssertionError("Unexpected storage policy");
+				return !this.leading || Number(this.leading.freeList()) === 0;
+			}
+			begin() {
+				if (policy === DeletionPolicy.SwapAndPop) return this.leading ? Type.prototype.begin.call(this.leading) : new BasicStorageView.Iterator();
+				else if (policy === DeletionPolicy.SwapOnly) return this.leading ? Type.prototype.end.call(this.leading).minus(Number(this.leading.freeList())) : new BasicStorageView.Iterator();
+				else {
+					if (policy !== DeletionPolicy.InPlace) throw new AssertionError("Unexpected storage policy");
+					return this.leading ? new BasicStorageView.Iterator(Type.prototype.begin.call(this.leading), [this.leading], [], 0) : new BasicStorageView.Iterator();
+				}
+			}
+			end() {
+				if (policy === DeletionPolicy.SwapAndPop || policy === DeletionPolicy.SwapOnly) return this.leading ? Type.prototype.end.call(this.leading) : new BasicStorageView.Iterator();
+				else {
+					if (policy !== DeletionPolicy.InPlace) throw new AssertionError("Unexpected storage policy");
+					return this.leading ? new BasicStorageView.Iterator(Type.prototype.end.call(this.leading), [this.leading], [], 0) : new BasicStorageView.Iterator();
+				}
+			}
+			rbegin() {
+				if (policy === DeletionPolicy.InPlace) throw new Error("Reverse begin not available for in-place storage views");
+				return this.leading ? Type.prototype.rbegin.call(this.leading) : new BasicStorageView.ReverseIterator(new Type.BasicIterator());
+			}
+			rend() {
+				if (policy === DeletionPolicy.InPlace) throw new Error("Reverse end not available for in-place storage views");
+				if (policy === DeletionPolicy.SwapAndPop) return this.leading ? Type.prototype.rend.call(this.leading) : new BasicStorageView.ReverseIterator(new Type.BasicIterator());
+				else {
+					if (policy !== DeletionPolicy.SwapOnly) throw new AssertionError("Unexpected storage policy");
+					return this.leading ? Type.prototype.rend.call(this.leading).plus(Number(this.leading.freeList())) : new BasicStorageView.ReverseIterator(new Type.BasicIterator());
+				}
+			}
+			front() {
+				if (policy === DeletionPolicy.SwapAndPop) return this.empty() ? Type.TraitsType.null : Type.prototype.begin.call(this.leading).deref();
+				else if (policy === DeletionPolicy.SwapOnly) return this.empty() ? Type.TraitsType.null : Type.prototype.end.call(this.leading).minus(Number(this.leading.freeList())).deref();
+				else {
+					if (policy !== DeletionPolicy.InPlace) throw new AssertionError("Unexpected storage policy");
+					const it = this.begin();
+					return it.equals(this.end()) ? Type.TraitsType.null : it.deref();
+				}
+			}
+			back() {
+				if (policy === DeletionPolicy.SwapAndPop || policy === DeletionPolicy.SwapOnly) return this.empty() ? Type.TraitsType.null : Type.prototype.rbegin.call(this.leading).deref();
+				else {
+					if (policy !== DeletionPolicy.InPlace) throw new AssertionError("Unexpected storage policy");
+					if (this.leading != null) {
+						const it = Type.prototype.rbegin.call(this.leading);
+						const last = Type.prototype.rend.call(this.leading);
+						for (; !it.equals(last) && Type.isTombstone(it.deref()); it.selfPlus());
+						return it.equals(last) ? Type.TraitsType.null : it.deref();
+					}
+					return Type.TraitsType.null;
+				}
+			}
+			find(entt) {
+				if (policy === DeletionPolicy.SwapAndPop) return this.leading != null ? this.leading.find(entt) : new BasicStorageView.Iterator();
+				else if (policy === DeletionPolicy.SwapOnly) {
+					const it = this.leading != null ? this.leading.find(entt) : new BasicStorageView.Iterator();
+					return this.leading != null && it.index() < Number(this.leading.freeList()) ? it : new BasicStorageView.Iterator();
+				} else return this.leading != null ? new BasicStorageView.Iterator(this.leading.find(entt), [this.leading], [], 0) : new BasicStorageView.Iterator();
+			}
+			ok() {
+				return this.leading != null;
+			}
+			contains(entt) {
+				if (policy === DeletionPolicy.SwapAndPop || policy === DeletionPolicy.InPlace) return this.leading?.contains(entt);
+				else {
+					if (policy !== DeletionPolicy.SwapOnly) throw new AssertionError("Unexpected storage policy");
+					return this.leading != null && this.leading.contains(entt) && this.leading.index(entt) < Number(this.leading.freeList());
+				}
+			}
+			[Symbol.iterator]() {
+				return toIterator(this);
+			}
+		}
+		return BasicStorageView;
+	});
+
+//#endregion
+//#region src/group.ts
+	var ExtendedGroupPointer = class ExtendedGroupPointer {
+		it;
+		owned;
+		get;
+		get pools() {
+			return [...this.owned, ...this.get];
+		}
+		indexToElement(cpool) {
+			if (cpool.constructor.ValueType == null) return [];
+			return [cpool.rbegin().access(this.it.index())];
+		}
+		constructor(it, owned, get) {
+			if (it && owned && get) {
+				this.it = it.clone();
+				this.owned = owned;
+				this.get = get;
+			} else {
+				this.it = new it();
+				this.owned = [];
+				this.get = [];
+			}
+		}
+		selfPlus() {
+			this.it.selfPlus();
+			return this;
+		}
+		write(value) {
+			this.it.write(value);
+			return value;
+		}
+		deref() {
+			return [
+				this.it.deref(),
+				...this.owned.flatMap((o$1) => this.indexToElement(o$1)),
+				...this.get.flatMap((g) => g.getAsTuple(this.it.deref()))
+			];
+		}
+		equals(other) {
+			return this.it.equals(other.it);
+		}
+		clone(target) {
+			if (target) {
+				if (this === target) return target;
+				this.it.clone(target.it);
+				this.owned = target.owned.slice();
+				this.get = target.get.slice();
+				return target;
+			}
+			return new ExtendedGroupPointer(this.it, this.owned, this.get);
+		}
+		swap(other) {
+			if (this === other) return;
+			this.it.swap(other.it);
+			const tmpOwned = this.owned;
+			this.owned = other.owned;
+			other.owned = tmpOwned;
+			const tmpGet = this.get;
+			this.get = other.get;
+			other.get = tmpGet;
+		}
+		base() {
+			return this.it.clone();
+		}
+	};
+	var GroupDescriptor = class extends Disposable {
+		/** @virtual */
+		owned(_id) {
+			return false;
+		}
+	};
+	const groupHandlerTemplate = /* @__PURE__ */ defineTemplate(function(Type, Owned, Get, Exclude) {
+		class GroupHandler extends GroupDescriptor {
+			static EntityType = Type.EntityType;
+			pools;
+			filter;
+			len;
+			swapElements(pos, entt) {
+				for (let next = 0; next < Owned; ++next) this.pools[next].swapElements(this.pools[next].access(pos), entt);
+			}
+			pushOnConstruct(entt) {
+				const pos = this.len;
+				if (((...args) => {
+					const [cpool, ...other] = args;
+					return cpool.contains(entt) && !(cpool.index(entt) < pos) && other.every((o$1) => o$1.contains(entt));
+				})(...this.pools) && ((...cpool) => cpool.every((c) => !c.contains(entt)))(...this.filter)) this.swapElements(this.len++, entt);
+			}
+			pushOnDestroy(entt) {
+				const pos = this.len;
+				if (((...args) => {
+					const [cpool, ...other] = args;
+					return cpool.contains(entt) && !(cpool.index(entt) < pos) && other.every((o$1) => o$1.contains(entt));
+				})(...this.pools) && ((...cpool) => cpool.reduce((p, c) => p + Number(c.contains(entt)), 0) === 1)(...this.filter)) this.swapElements(this.len++, entt);
+			}
+			removeIf(entt) {
+				const pools = this.pools;
+				if (pools[0].contains(entt) && pools[0].index(entt) < this.len) this.swapElements(--this.len, entt);
+			}
+			commonSetup() {
+				const pools = this.pools;
+				for (const first = Type.prototype.rbegin.call(pools[0]), last = first.plus(pools[0].size); !first.equals(last); first.selfPlus()) this.pushOnConstruct(first.deref());
+			}
+			CommonType = Type;
+			constructor(ogpool, epool) {
+				super();
+				this.pools = Array(Owned + Get);
+				this.filter = Array(Exclude);
+				for (let i = 0; i < Owned + Get; ++i) this.pools[i] = ogpool[i];
+				for (let i = 0; i < Exclude; ++i) this.filter[i] = epool[i];
+				this.len = 0;
+				ogpool.forEach((cpool) => {
+					cpool.onConstruct().connect(function(_, entt) {
+						GroupHandler.prototype.pushOnConstruct.call(this, entt);
+					}, this);
+					cpool.onDestroy().connect(function(_, entt) {
+						GroupHandler.prototype.removeIf.call(this, entt);
+					}, this);
+				});
+				epool.forEach((cpool) => {
+					cpool.onConstruct().connect(function(_, entt) {
+						GroupHandler.prototype.removeIf.call(this, entt);
+					}, this);
+					cpool.onDestroy().connect(function(_, entt) {
+						GroupHandler.prototype.pushOnDestroy.call(this, entt);
+					}, this);
+				});
+				this.commonSetup();
+			}
+			owned(t) {
+				for (let pos = 0; pos < Owned; ++pos) if (Object.is(this.pools[pos].type(), t) || dist_default(this.pools[pos].type()) === t) return true;
+				return false;
+			}
+			length() {
+				return this.len;
+			}
+			storage(index) {
+				if (index < Owned + Get) return this.pools[index];
+				else return this.filter[index - (Owned + Get)];
+			}
+		}
+		return GroupHandler;
+	}, [{
+		predicate: (_0, Owned, _2, Exclude) => Owned === 0 || Exclude === void 0,
+		render: (Type, Owned, Get, Exclude) => {
+			if (Exclude === void 0) {
+				Exclude = Get;
+				Get = Owned;
+				Owned = 0;
+			}
+			const newType = createSafeNew(Type);
+			class GroupHandler extends GroupDescriptor {
+				static EntityType = Type.EntityType;
+				pools;
+				filter;
+				elem;
+				pushOnConstruct(entt) {
+					if (!this.elem.contains(entt) && this.pools.every((c) => c.contains(entt)) && this.filter.every((f) => !f.contains(entt))) this.elem.push(entt);
+				}
+				pushOnDestroy(entt) {
+					if (this.elem.contains(entt) && this.pools.every((c) => c.contains(entt)) && this.filter.reduce((c, f) => c + Number(f.contains(entt)), 0) === 1) this.elem.remove(entt);
+				}
+				removeIf(entt) {
+					this.elem.remove(entt);
+				}
+				commonSetup() {
+					const jsIt = toIterator(Type.prototype.begin.call(this.pools[0]), Type.prototype.end.call(this.pools[0]));
+					for (const entity of jsIt) this.pushOnConstruct(entity);
+				}
+				static CommonType = Type;
+				constructor(gpool, epool) {
+					super();
+					this.pools = Array(Get);
+					this.filter = Array(Exclude);
+					for (let i = 0; i < Get; ++i) this.pools[i] = gpool[i];
+					for (let i = 0; i < Exclude; ++i) this.filter[i] = epool[i];
+					this.elem = newType();
+					gpool.forEach((cpool) => {
+						cpool.onConstruct().connect(function(_, entt) {
+							GroupHandler.prototype.pushOnConstruct.call(this, entt);
+						}, this);
+						cpool.onDestroy().connect(function(_, entt) {
+							GroupHandler.prototype.removeIf.call(this, entt);
+						}, this);
+					});
+					epool.forEach((cpool) => {
+						cpool.onConstruct().connect(function(_, entt) {
+							GroupHandler.prototype.removeIf.call(this, entt);
+						}, this);
+						cpool.onDestroy().connect(function(_, entt) {
+							GroupHandler.prototype.pushOnDestroy.call(this, entt);
+						}, this);
+					});
+					this.commonSetup();
+				}
+				handle() {
+					return this.elem;
+				}
+				storage(index) {
+					if (index < Get) return this.pools[index];
+					else return this.filter[index - Get];
+				}
+			}
+			return GroupHandler;
+		}
+	}]);
+	const basicGroupTemplate = /* @__PURE__ */ defineTemplate(function(_owned, _get, _exclude) {
+		throw new Error("Invalid BasicGroup instantiation");
+	}, [{
+		predicate: (owned, get, exclude) => owned.length === 0 || owned == null || Array.isArray(owned) && Array.isArray(get) && exclude === void 0,
+		render(owned, get, exclude) {
+			if (Array.isArray(owned) && Array.isArray(get) && exclude === void 0) {
+				exclude = get;
+				get = owned;
+			}
+			const BaseType = commonType(...get.map((g) => g.constructor.BaseType), ...exclude.map((e) => e.constructor.BaseType));
+			const UnderlyingType = BaseType.EntityType;
+			const Handler = groupHandlerTemplate.instantiate(BaseType, 0, get.length, exclude.length);
+			if (get.length === 0) throw new Error("Non-owning group must have at least one get type");
+			class BasicGroup {
+				static BaseType = BaseType;
+				static UnderlyingType = UnderlyingType;
+				static indexOf(T) {
+					return [...get.map((g) => g.constructor.ElementType), ...exclude.map((e) => e.constructor.ElementType)].indexOf(T);
+				}
+				poolsFor(...indexes) {
+					return this.descriptor ? indexes.map((i) => this.descriptor.storage(i)) : [];
+				}
+				static EntityType = UnderlyingType;
+				static CommonType = BaseType;
+				static Iterator = BaseType.Iterator;
+				static ReverseIterator = BaseType.ReverseIterator;
+				static Handler = Handler;
+				descriptor;
+				static groupId() {
+					return dist_default([
+						"non-owning",
+						...get,
+						...exclude
+					]);
+				}
+				constructor(handler) {
+					this.descriptor = handler ?? null;
+				}
+				handle() {
+					return this.descriptor.handle();
+				}
+				storage(ElementType) {
+					if (typeof ElementType === "number") return this.ok() ? this.descriptor.storage(ElementType) : null;
+					return this.storage(BasicGroup.indexOf(ElementType));
+				}
+				ok() {
+					return this.descriptor != null;
+				}
+				get size() {
+					return this.ok() ? this.handle().size : 0;
+				}
+				capacity() {
+					return this.ok() ? this.handle().capacity() : 0;
+				}
+				empty() {
+					return !this.ok() || this.handle().empty();
+				}
+				begin() {
+					return this.ok() ? this.handle().begin() : new BaseType.Iterator();
+				}
+				end() {
+					return this.ok() ? this.handle().end() : new BaseType.Iterator();
+				}
+				rbegin() {
+					return this.ok() ? this.handle().rbegin() : new BaseType.ReverseIterator(new BaseType.Iterator());
+				}
+				rend() {
+					return this.ok() ? this.handle().rend() : new BaseType.ReverseIterator(new BaseType.Iterator());
+				}
+				front() {
+					const it = this.begin();
+					return !it.equals(this.end()) ? it.deref() : BaseType.TraitsType.null;
+				}
+				back() {
+					const rit = this.rbegin();
+					return !rit.equals(this.rend()) ? rit.deref() : BaseType.TraitsType.null;
+				}
+				find(entt) {
+					return this.ok() ? this.handle().find(entt) : new BaseType.Iterator();
+				}
+				access(pos) {
+					return this.begin().access(pos);
+				}
+				contains(entt) {
+					return this.ok() && this.handle().contains(entt);
+				}
+				get(entt, ...types) {
+					return this.getByIndexes(entt, ...types.map((t) => BasicGroup.indexOf(t)));
+				}
+				getByIndexes(entt, ...indexes) {
+					const cpools = this.poolsFor(...Array.from({ length: get.length }, (_, i) => i));
+					if (indexes.length === 0) return cpools.flatMap((c) => c.getAsTuple(entt));
+					else if (indexes.length === 1) return cpools[indexes[0]].get(entt);
+					else return indexes.flatMap((i) => cpools[i].getAsTuple(entt));
+				}
+				each(func, componentsOnly) {
+					if (typeof func === "function") for (const entt of this) {
+						const components = this.get(entt);
+						if (componentsOnly) func.apply(this, components);
+						else func.call(this, entt, ...components);
+					}
+					else {
+						const cpools = this.poolsFor(...Array.from({ length: get.length }, (_, i) => i));
+						return new RangeIterator(new ExtendedGroupPointer(this.begin(), [], cpools), new ExtendedGroupPointer(this.end(), [], cpools));
+					}
+				}
+				[Symbol.iterator]() {
+					return toIterator(this);
+				}
+				sort(compareFn, types, algo = defaultSort) {
+					this.sortByIndexes(compareFn, types.map((t) => BasicGroup.indexOf(t)), algo);
+				}
+				sortByIndexes(compareFn, indexes, algo = defaultSort) {
+					if (!this.ok()) return;
+					if (indexes.length === 0) this.descriptor.handle().sort(compareFn, algo);
+					else {
+						const cpools = this.poolsFor(...indexes);
+						const comp = (lhs, rhs) => {
+							if (indexes.length === 1) return compareFn(cpools[indexes[0]].get(lhs), cpools[indexes[0]].get(rhs));
+							else return compareFn(indexes.map((i) => cpools[i].get(lhs)), indexes.map((i) => cpools[i].get(rhs)));
+						};
+						this.descriptor.handle().sort(comp, algo);
+					}
+				}
+				sortAs(first, last) {
+					if (this.ok()) this.descriptor.handle().sortAs(first, last);
+				}
+			}
+			return BasicGroup;
+		}
+	}, {
+		predicate: (owned, _get, _exclude) => owned.length > 0,
+		render(owned, get, exclude) {
+			if (owned.some((o$1) => o$1.constructor.storagePolicy === DeletionPolicy.InPlace)) throw new AssertionError("Groups do not support in-place delete");
+			const BaseType = commonType(...owned.map((o$1) => o$1.constructor.BaseType), ...get.map((g) => g.constructor.BaseType), ...exclude.map((e) => e.constructor.BaseType));
+			const UnderlyingType = BaseType.EntityType;
+			const Handler = groupHandlerTemplate.instantiate(BaseType, owned.length, get.length, exclude.length);
+			class BasicGroup {
+				static BaseType = BaseType;
+				static UnderlyingType = UnderlyingType;
+				static indexOf(T) {
+					return [
+						...owned.map((o$1) => o$1.constructor.ElementType),
+						...get.map((g) => g.constructor.ElementType),
+						...exclude.map((e) => e.constructor.ElementType)
+					].indexOf(T);
+				}
+				poolsFor(indexes, other) {
+					return this.descriptor ? [...indexes.map((i) => this.descriptor.storage(i)), ...other.map((i) => this.descriptor.storage(i + owned.length))] : [];
+				}
+				static EntityType = UnderlyingType;
+				static CommonType = BaseType;
+				static Iterator = BaseType.Iterator;
+				static ReverseIterator = BaseType.ReverseIterator;
+				static Handler = Handler;
+				descriptor;
+				static groupId() {
+					return dist_default([
+						owned,
+						get,
+						exclude
+					]);
+				}
+				constructor(handler) {
+					this.descriptor = handler ?? null;
+				}
+				handle() {
+					return this.storage(0);
+				}
+				ok() {
+					return this.descriptor != null;
+				}
+				storage(ElementType) {
+					if (typeof ElementType === "number") return this.ok() ? this.descriptor.storage(ElementType) : null;
+					return this.storage(BasicGroup.indexOf(ElementType));
+				}
+				get size() {
+					return this.ok() ? this.descriptor.length() : 0;
+				}
+				empty() {
+					return !this.ok() || !this.descriptor.length();
+				}
+				begin() {
+					return this.ok() ? BaseType.prototype.end.call(this.handle()).minus(this.descriptor.length()) : new BaseType.Iterator();
+				}
+				end() {
+					return this.ok() ? BaseType.prototype.end.call(this.handle()) : new BaseType.Iterator();
+				}
+				rbegin() {
+					return this.ok() ? BaseType.prototype.rbegin.call(this.handle()) : new BaseType.ReverseIterator(new BaseType.Iterator());
+				}
+				rend() {
+					return this.ok() ? BaseType.prototype.rbegin.call(this.handle()).plus(this.descriptor.length()) : new BaseType.ReverseIterator(new BaseType.Iterator());
+				}
+				front() {
+					const it = this.begin();
+					return !it.equals(this.end()) ? it.deref() : BaseType.TraitsType.null;
+				}
+				back() {
+					const rit = this.rbegin();
+					return !rit.equals(this.rend()) ? rit.deref() : BaseType.TraitsType.null;
+				}
+				find(entt) {
+					const it = this.ok() ? this.handle().find(entt) : new BaseType.Iterator();
+					return it.gte(this.begin()) ? it : new BaseType.Iterator();
+				}
+				access(pos) {
+					return this.begin().access(pos);
+				}
+				contains(entt) {
+					return this.ok() && this.handle().contains(entt) && this.handle().index(entt) < this.descriptor.length();
+				}
+				get(entt, ...types) {
+					return this.getByIndexes(entt, ...types.map((t) => BasicGroup.indexOf(t)));
+				}
+				getByIndexes(entt, ...indexes) {
+					const cpools = this.poolsFor(Array.from({ length: owned.length }, (_, i) => i), Array.from({ length: get.length }, (_, i) => i));
+					if (indexes.length === 0) return cpools.flatMap((c) => c.getAsTuple(entt));
+					else if (indexes.length === 1) return cpools[indexes[0]].get(entt);
+					else return indexes.flatMap((i) => cpools[i].getAsTuple(entt));
+				}
+				each(func, componentsOnly) {
+					if (typeof func === "function") for (const args of this.each()) if (componentsOnly) func.apply(this, args.slice(1));
+					else func.apply(this, args);
+					else {
+						const cpools = this.poolsFor(Array.from({ length: owned.length }, (_, i) => i), Array.from({ length: get.length }, (_, i) => i));
+						const begin = this.begin();
+						const end = this.end();
+						return new RangeIterator(new ExtendedGroupPointer(begin, cpools.slice(0, owned.length), cpools.slice(owned.length)), new ExtendedGroupPointer(end, cpools.slice(0, owned.length), cpools.slice(owned.length)));
+					}
+				}
+				[Symbol.iterator]() {
+					return toIterator(this);
+				}
+				sort(compareFn, types, algo = defaultSort) {
+					this.sortByIndexes(compareFn, types.map((t) => BasicGroup.indexOf(t)), algo);
+				}
+				sortByIndexes(compareFn, indexes, algo = defaultSort) {
+					const cpools = this.poolsFor(Array.from({ length: owned.length }, (_, i) => i), Array.from({ length: get.length }, (_, i) => i));
+					if (indexes.length === 0) this.storage(0).sortN(this.descriptor.length(), compareFn, algo);
+					else {
+						const comp = (lhs, rhs) => {
+							if (indexes.length === 1) return compareFn(cpools[indexes[0]].get(lhs), cpools[indexes[0]].get(rhs));
+							else return compareFn(indexes.map((i) => cpools[i].get(lhs)), indexes.map((i) => cpools[i].get(rhs)));
+						};
+						this.storage(0).sortN(this.descriptor.length(), comp, algo);
+					}
+					const cb = (...args) => {
+						const [head, ...other] = args;
+						for (let next = this.descriptor.length(); next; --next) {
+							const pos = next - 1;
+							const entt = head.data()[pos];
+							other.forEach((o$1) => {
+								o$1.swapElements(o$1.data()[pos], entt);
+							});
+						}
+					};
+					cb.apply(this, cpools);
+				}
+			}
+			return BasicGroup;
+		}
+	}]);
+	function makeGroup(owned, get, exclude = []) {
+		return new (basicGroupTemplate.instantiate(owned, get, exclude))();
+	}
+
+//#endregion
+//#region src/registry.ts
+	const basicRegistryTemplate = /* @__PURE__ */ defineTemplate(function templateBasicRegistry(ValueType) {
+		const EntityStorageClass = storageTypeTTemplate.instantiate(ValueType, ValueType);
+		const TraitsType = EntityStorageClass.TraitsType;
+		const EntityType = TraitsType.ValueType;
+		const BaseType = basicSparseSetTemplate.instantiate(ValueType);
+		return class extends Disposable {
+			static TraitsType = TraitsType;
+			static EntityType = EntityType;
+			static CommonType = BaseType;
+			entities;
+			vars;
+			groups;
+			pools;
+			constructor() {
+				super();
+				this.entities = new EntityStorageClass();
+				this.entities.bind(this);
+				this.vars = Object.create(null);
+				this.groups = /* @__PURE__ */ new Map();
+				this.pools = /* @__PURE__ */ new Map();
+			}
+			dispose() {
+				for (const group of this.groups.values()) group.dispose();
+				this.groups.clear();
+				for (const pool of this.pools.values()) pool.dispose();
+				this.pools.clear();
+				this.entities.dispose();
+				Object.keys(this.vars).forEach((_, key) => {
+					delete this.vars[key];
+				});
+			}
+			assure(k) {
+				const [ComponentType, id] = destructKey(k);
+				if (typeof ComponentType !== "function" && ComponentType !== void 0) throw new Error("Invalid component type");
+				if (Object.is(ComponentType, EntityType)) {
+					assert(id === EntityType, "User entity storage not allowed");
+					return this.entities;
+				}
+				if (this.pools.has(id)) {
+					assert(this.pools.get(id).type() === ComponentType, "Unexpected type");
+					return this.pools.get(id);
+				}
+				const cpool = new (storageTypeTTemplate.instantiate(ComponentType, EntityType))();
+				this.pools.set(id, cpool);
+				cpool.bind(this);
+				return cpool;
+			}
+			constAssure(k) {
+				const [ComponentType, id] = destructKey(k);
+				const hasType = typeof ComponentType === "function" || ComponentType === void 0;
+				if (hasType) {
+					if (Object.is(ComponentType, EntityType)) {
+						assert(id === EntityType, "User entity storage not allowed");
+						return this.entities;
+					}
+				}
+				const cpool = this.pools.get(id);
+				if (!cpool) return void 0;
+				assert(!hasType || cpool.type() === ComponentType, "Unexpected type");
+				return cpool;
+			}
+			ctx() {
+				return this.vars;
+			}
+			create(hint) {
+				return this.entities.generate(hint);
+			}
+			createRange(first, last) {
+				this.entities.generateRange(first, last);
+			}
+			insert(ComponentType, first, last, value) {
+				last = last.clone();
+				for (let it = first.clone(); !it.equals(last); it.selfPlus()) assert(this.valid(it.deref()), "Invalid entity");
+				this.assure(ComponentType).insert(first, last, value);
+			}
+			insertRange(ComponentType, first, last, from) {
+				last = last.clone();
+				for (let it = first.clone(); !it.equals(last); it.selfPlus()) assert(this.valid(it.deref()), "Invalid entity");
+				this.assure(ComponentType).insertRange(first, last, from);
+			}
+			storage() {
+				return this.pools.entries();
+			}
+			getStorage(k, forceConst = false) {
+				if (!forceConst && (typeof k === "function" || Array.isArray(k) || k === void 0)) return this.assure(k);
+				return this.constAssure(k);
+			}
+			reset(id) {
+				assert(id !== EntityType, "Cannot reset entity storage");
+				return this.pools.delete(id);
+			}
+			valid(entt) {
+				const idx = this.entities.find(entt).index();
+				return idx >= 0 && idx < this.entities.freeList();
+			}
+			current(entt) {
+				return this.entities.current(entt);
+			}
+			destroy(entt, version$1) {
+				const pools = [...this.pools.values()];
+				for (let pos = pools.length - 1; pos >= 0; --pos) pools[pos].remove(entt);
+				this.entities.erase(entt);
+				const ret = this.entities.current(entt);
+				if (version$1 !== void 0) {
+					const elem = TraitsType.construct(TraitsType.toEntity(entt), version$1);
+					return this.entities.bump(TraitsType.isTombstone(elem) ? TraitsType.next(elem) : elem);
+				}
+				return ret;
+			}
+			destroyRange(iterable, last) {
+				const to = last == null ? this.entities.sortAs(iterable) : this.entities.sortAs(iterable, last);
+				const from = this.entities.end().minus(Number(this.entities.freeList()));
+				for (const pool of this.pools.values()) pool.remove(from, to);
+				this.entities.erase(from, to);
+			}
+			emplace(entt, ComponentType, ...args) {
+				assert(this.valid(entt), "Invalid entity");
+				return this.assure(ComponentType).emplace(entt, ...args);
+			}
+			emplaceOrReplace(entt, ComponentType, ...args) {
+				const cpool = this.assure(ComponentType);
+				assert(this.valid(entt), "Invalid entity");
+				return cpool.has(entt) ? cpool.patch(entt, () => createSafeNew(cpool.type())(...args)) : cpool.emplace(entt, ...args);
+			}
+			patch(entt, ComponentType, ...func) {
+				return this.assure(ComponentType).patch(entt, ...func);
+			}
+			replace(entt, ComponentType, ...args) {
+				const cpool = this.assure(ComponentType);
+				return cpool.patch(entt, () => createSafeNew(cpool.type())(...args));
+			}
+			remove(entt, ...ComponentTypes) {
+				let removed = 0;
+				for (const ComponentType of ComponentTypes) if (this.assure(ComponentType).delete(entt)) ++removed;
+				return removed;
+			}
+			removeRange(first, last, ...ComponentTypes) {
+				let count = 0;
+				first = first.clone();
+				last = last.clone();
+				if (first instanceof SparseSetPointer && last instanceof SparseSetPointer) {
+					const array = ComponentTypes.map((ComponentType) => this.assure(ComponentType));
+					const cpools = toRange(array);
+					const from = cpools.begin();
+					const to = cpools.end();
+					for (; !from.equals(to); from.selfPlus()) {
+						if (ComponentTypes.length > 1) {
+							if (from.deref().data() === first.data()) {
+								const tmp = from.deref();
+								from.write(array[array.length - 1]);
+								array[array.length - 1] = tmp;
+							}
+						}
+						count += from.deref().remove(first, last);
+					}
+				} else for (const cpools = ComponentTypes.map((ComponentType) => this.assure(ComponentType)); !first.equals(last); first.selfPlus()) {
+					const entt = first.deref();
+					for (const cpool of cpools) count += cpool.remove(entt) ? 1 : 0;
+				}
+				return count;
+			}
+			eraseIf(entt, func) {
+				for (const [id, cpool] of this.storage()) if (cpool.contains(entt) && func(id, cpool)) cpool.erase(entt);
+			}
+			erase(entt, ...ComponentTypes) {
+				for (const ComponentType of ComponentTypes) this.assure(ComponentType).erase(entt);
+			}
+			eraseRange(first, last, ...ComponentTypes) {
+				first = first.clone();
+				last = last.clone();
+				if (first instanceof SparseSetPointer && last instanceof SparseSetPointer) {
+					const array = ComponentTypes.map((ComponentType) => this.assure(ComponentType));
+					const cpools = toRange(array);
+					const from = cpools.begin();
+					const to = cpools.end();
+					for (; !from.equals(to); from.selfPlus()) {
+						if (ComponentTypes.length > 1) {
+							if (from.deref().data() === first.data()) {
+								const tmp = from.deref();
+								from.write(array[array.length - 1]);
+								array[array.length - 1] = tmp;
+							}
+						}
+						from.deref().erase(first, last);
+					}
+				} else for (const cpools = ComponentTypes.map((ComponentType) => this.assure(ComponentType)); !first.equals(last); first.selfPlus()) {
+					const entt = first.deref();
+					for (const cpool of cpools) cpool.erase(entt);
+				}
+			}
+			compact(...ComponentTypes) {
+				if (ComponentTypes.length === 0) for (const pool of this.pools.values()) pool.compact();
+				else for (const ComponentType of ComponentTypes) this.assure(ComponentType).compact();
+			}
+			allOf(entt, ...ComponentTypes) {
+				if (ComponentTypes.length === 1) {
+					const cpool = this.constAssure(ComponentTypes[0]);
+					return cpool != null && cpool?.has(entt);
+				}
+				return ComponentTypes.every((ComponentType) => this.allOf(entt, ComponentType));
+			}
+			anyOf(entt, ...ComponentTypes) {
+				return ComponentTypes.some((ComponentType) => this.allOf(entt, ComponentType));
+			}
+			tryGet(entt, ...ComponentType) {
+				if (ComponentType.length === 1) {
+					const cpool = this.constAssure(ComponentType[0]);
+					return cpool ? cpool.has(entt) ? cpool.get(entt) : void 0 : void 0;
+				}
+				return ComponentType.map((Type) => this.tryGet(entt, Type));
+			}
+			get(entt, ...ComponentType) {
+				if (ComponentType.length === 1) return this.assure(ComponentType[0]).get(entt);
+				return ComponentType.map((Type) => this.get(entt, Type));
+			}
+			getOrEmplace(entt, ComponentType, ...args) {
+				const cpool = this.assure(ComponentType);
+				assert(this.valid(entt), "Invalid entity");
+				return cpool.has(entt) ? cpool.get(entt) : cpool.emplace(entt, ...args);
+			}
+			clear(...ComponentTypes) {
+				if (ComponentTypes.length === 0) {
+					const pools = [...this.pools.values()];
+					for (let pos = pools.length - 1; pos >= 0; --pos) pools[pos].clear();
+					const elem = this.entities.each();
+					this.entities.erase(elem.begin().base(), elem.end().base());
+				} else ComponentTypes.forEach((ComponentType) => {
+					this.assure(ComponentType).clear();
+				});
+			}
+			orphan(entt) {
+				return ![...this.pools.values()].some((pool) => pool.has(entt));
+			}
+			onConstruct(ComponentType) {
+				return this.assure(ComponentType).onConstruct();
+			}
+			onUpdate(ComponentType) {
+				return this.assure(ComponentType).onUpdate();
+			}
+			onDestroy(ComponentType) {
+				return this.assure(ComponentType).onDestroy();
+			}
+			sort(ComponentType, compare, algo = defaultSort) {
+				{
+					const [C] = destructKey(ComponentType);
+					if (typeof C !== "function" && C !== void 0) throw new Error("Invalid component type");
+					assert(!this.owned(C), "Cannot sort owned storage");
+				}
+				const cpool = this.assure(ComponentType);
+				cpool.sort((a, b) => compare(cpool.get(a), cpool.get(b)), algo);
+			}
+			sortByEntity(ComponentType, compare, algo = defaultSort) {
+				{
+					const [C] = destructKey(ComponentType);
+					if (typeof C !== "function" && C !== void 0) throw new Error("Invalid component type");
+					assert(!this.owned(C), "Cannot sort owned storage");
+				}
+				this.assure(ComponentType).sort(compare, algo);
+			}
+			sortAs(To, From) {
+				{
+					const [ComponentType] = destructKey(To);
+					if (typeof ComponentType !== "function" && ComponentType !== void 0) throw new Error("Invalid component type");
+					assert(!this.owned(ComponentType), "Cannot sort owned storage");
+				}
+				const cpool = this.assure(From);
+				this.assure(To).sortAs(cpool.begin(), cpool.end());
+			}
+			view(types, excludes = []) {
+				const gets = types.map((Type) => this.assure(Type));
+				const excl = excludes.map((Type) => this.assure(Type));
+				return new (basicViewTemplate.instantiate(gets, excl))(gets, excl);
+			}
+			group(owned, get = [], exclude = []) {
+				const o$1 = owned.map((Type) => this.assure(Type));
+				const g = get.map((Type) => this.assure(Type));
+				const e = exclude.map((Type) => this.assure(Type));
+				const GroupType = basicGroupTemplate.instantiate(o$1, g, e);
+				const HandlerType = GroupType.Handler;
+				if (this.groups.has(GroupType.groupId())) return new GroupType(this.groups.get(GroupType.groupId()));
+				let handler = void 0;
+				if (o$1.length === 0) handler = new HandlerType(g, e);
+				else {
+					handler = new HandlerType([...o$1, ...g], e);
+					this.groups.forEach((group) => {
+						assert(!o$1.every((p) => !group.owned(p)), "Conflicting groups");
+					});
+				}
+				this.groups.set(GroupType.groupId(), handler);
+				return new GroupType(handler);
+			}
+			groupIfExists(owned, get = [], exclude = []) {
+				const o$1 = owned.map((Type) => this.assure(Type));
+				const g = get.map((Type) => this.assure(Type));
+				const e = exclude.map((Type) => this.assure(Type));
+				const GroupType = basicGroupTemplate.instantiate(o$1, g, e);
+				if (this.groups.has(GroupType.groupId())) return new GroupType(this.groups.get(GroupType.groupId()));
+				return new GroupType();
+			}
+			owned(...Types) {
+				for (const group of this.groups.values()) if (Types.some((Type) => group.owned(Type))) return true;
+				return false;
+			}
+		};
+	});
+	const Registry = /* @__PURE__ */ (() => basicRegistryTemplate.instantiate(Entity))();
+
+//#endregion
+//#region src/runtime-view.ts
+	var RuntimeViewIterator = class RuntimeViewIterator {
+		pools;
+		filter;
+		it;
+		tombstoneCheck;
+		valid() {
+			const entt = this.it.deref();
+			return (!this.tombstoneCheck || !this.pools[0].isTombstone(entt)) && this.pools.every((curr) => curr.contains(entt)) && !this.filter.some((curr) => curr?.contains(entt));
+		}
+		constructor(cpools, curr, ignore) {
+			if (cpools != null && curr != null && ignore != null) {
+				this.pools = cpools;
+				this.it = curr.clone();
+				this.filter = ignore;
+				this.tombstoneCheck = cpools.length === 1 && cpools[0].policy() === DeletionPolicy.InPlace;
+				if (!this.it.equals(SparseSet.prototype.end.call(cpools[0])) && !this.valid()) this.selfPlus();
+			} else {
+				this.pools = [];
+				this.it = new SparseSetPointer();
+				this.filter = [];
+				this.tombstoneCheck = false;
+			}
+		}
+		clone(target) {
+			if (target) {
+				if (target === this) return this;
+				target.pools = this.pools.slice();
+				target.it = this.it.clone();
+				target.filter = this.filter.slice();
+				target.tombstoneCheck = this.tombstoneCheck;
+				return target;
+			}
+			const copied = new RuntimeViewIterator();
+			copied.pools = this.pools.slice();
+			copied.it = this.it.clone();
+			copied.filter = this.filter.slice();
+			copied.tombstoneCheck = this.tombstoneCheck;
+			return copied;
+		}
+		swap(other) {
+			if (this === other) return;
+			this.it.swap(other.it);
+			const tmpPools = this.pools;
+			const tmpFilter = this.filter;
+			const tmpTombstoneCheck = this.tombstoneCheck;
+			this.pools = other.pools;
+			this.filter = other.filter;
+			this.tombstoneCheck = other.tombstoneCheck;
+			other.pools = tmpPools;
+			other.filter = tmpFilter;
+			other.tombstoneCheck = tmpTombstoneCheck;
+		}
+		write(value) {
+			return this.it.write(value);
+		}
+		deref() {
+			return this.it.deref();
+		}
+		selfPlus() {
+			this.it.selfPlus();
+			for (const last = SparseSet.prototype.end.call(this.pools[0]); !this.it.equals(last) && !this.valid(); this.it.selfPlus());
+			return this;
+		}
+		selfMinus() {
+			this.it.selfMinus();
+			for (const first = SparseSet.prototype.begin.call(this.pools[0]); !this.it.equals(first) && !this.valid(); this.it.selfMinus());
+			return this;
+		}
+		equals(other) {
+			return this.it.equals(other.it);
+		}
+	};
+	const basicRuntimeViewTemplate = /* @__PURE__ */ defineTemplate(function(Type) {
+		class BasicRuntimeView extends Disposable {
+			pools;
+			filter;
+			offset() {
+				assert(this.pools.length !== 0, "Invalid view");
+				const leading = this.pools[0];
+				return leading.policy() === DeletionPolicy.SwapOnly ? Number(leading.freeList()) : leading.size;
+			}
+			static EntityType = Type.EntityType;
+			static CommonType = Type;
+			static Iterator = RuntimeViewIterator;
+			constructor() {
+				super();
+				this.pools = [];
+				this.filter = [];
+			}
+			dispose() {
+				this.pools.length = 0;
+				this.filter.length = 0;
+			}
+			clear() {
+				this.pools.length = 0;
+				this.filter.length = 0;
+			}
+			iterate(base) {
+				if (this.pools.length === 0 || !(base.size < this.pools[0].size)) this.pools.push(base);
+				else {
+					const front = this.pools[0];
+					this.pools[0] = base;
+					this.pools.push(front);
+				}
+				return this;
+			}
+			exclude(base) {
+				this.filter.push(base);
+				return this;
+			}
+			sizeHint() {
+				return this.pools.length === 0 ? 0 : this.offset();
+			}
+			begin() {
+				return this.pools.length === 0 ? new RuntimeViewIterator() : new RuntimeViewIterator(this.pools, Type.prototype.end.call(this.pools[0]).minus(this.offset()), this.filter);
+			}
+			end() {
+				return this.pools.length === 0 ? new RuntimeViewIterator() : new RuntimeViewIterator(this.pools, Type.prototype.end.call(this.pools[0]), this.filter);
+			}
+			ok() {
+				return !(this.pools.length === 0 && this.filter.length === 0);
+			}
+			contains(entt) {
+				return this.pools.length !== 0 && this.pools.every((curr) => curr.contains(entt)) && !this.filter.some((curr) => curr?.contains(entt)) && this.pools[0].index(entt) < this.offset();
+			}
+			each(func) {
+				for (const entity of this) func(entity);
+			}
+			[Symbol.iterator]() {
+				return toIterator(this.begin(), this.end());
+			}
+		}
+		return BasicRuntimeView;
+	});
+	const RuntimeView = /* @__PURE__ */ (() => basicRuntimeViewTemplate.instantiate(SparseSet))();
+
+//#endregion
+//#region src/snapshot.ts
+	function orphans(registry) {
+		const storage = registry.getStorage(registry.constructor.EntityType);
+		for (const entt of storage) if (registry.orphan(entt)) storage.erase(entt);
+	}
+	const basicSnapshotTemplate = /* @__PURE__ */ defineTemplate(function(Registry$1) {
+		const TraitsType = enttTraitsTemplate.instantiate(Registry$1.EntityType);
+		const EntityType = Registry$1.EntityType;
+		class BasicSnapshot extends Disposable {
+			static TraitsType = TraitsType;
+			static RegistryType = Registry$1;
+			static EntityType = EntityType;
+			reg;
+			constructor(registry) {
+				super();
+				this.reg = registry;
+			}
+			dispose() {
+				this.reg = null;
+			}
+			get(archive, Type) {
+				const [ComponentType] = destructKey(Type);
+				const storage = this.reg.getStorage(Type, true);
+				if (storage) {
+					const base = storage;
+					archive.saveSize(TraitsType.EntityType(storage.size));
+					if (ComponentType === EntityType) {
+						archive.saveSize(TraitsType.EntityType(storage.freeList()));
+						const first = Registry$1.CommonType.prototype.rbegin.call(base);
+						const last = Registry$1.CommonType.prototype.rend.call(base);
+						for (; !first.equals(last); first.selfPlus()) archive.saveEntity(first.deref());
+					} else if (storageTypeTTemplate.instantiate(ComponentType, Registry$1.EntityType).storagePolicy === DeletionPolicy.InPlace) {
+						const it = Registry$1.CommonType.prototype.rbegin.call(base);
+						const last = Registry$1.CommonType.prototype.rend.call(base);
+						for (; !it.equals(last); it.selfPlus()) {
+							const entt = it.deref();
+							if (Registry$1.CommonType.isTombstone(entt)) archive.saveEntity(TraitsType.null);
+							else {
+								archive.saveEntity(entt);
+								const tuple = storage.getAsTuple(entt);
+								for (let i = 0; i < tuple.length; ++i) archive.saveComponent(tuple[i]);
+							}
+						}
+					} else for (const elem of storage.reach()) {
+						archive.saveEntity(elem[0]);
+						if (elem.length > 1) archive.saveComponent(elem[1]);
+					}
+				} else archive.saveSize(TraitsType.EntityType(0));
+				return this;
+			}
+			getRange(archive, first, last, Type) {
+				const [ComponentType] = destructKey(Type);
+				assert(ComponentType !== EntityType, "Entity types not supported");
+				const storage = this.reg.getStorage(Type, true);
+				if (storage && !storage.empty()) {
+					archive.saveSize(TraitsType.EntityType(distance(first, last)));
+					first = first.clone();
+					last = last.clone();
+					for (; !first.equals(last); first.selfPlus()) {
+						const entt = first.deref();
+						if (storage.contains(entt)) {
+							archive.saveEntity(entt);
+							const tuple = storage.getAsTuple(entt);
+							for (let i = 0; i < tuple.length; ++i) archive.saveComponent(tuple[i]);
+						} else archive.saveEntity(TraitsType.null);
+					}
+				} else archive.saveSize(TraitsType.EntityType(0));
+				return this;
+			}
+		}
+		return BasicSnapshot;
+	});
+	const basicSnapshotLoaderTemplate = /* @__PURE__ */ defineTemplate(function(Registry$1) {
+		const TraitsType = enttTraitsTemplate.instantiate(Registry$1.EntityType);
+		const EntityType = Registry$1.EntityType;
+		const newEntityType = createSafeNew(EntityType);
+		class BasicSnapshotLoader extends Disposable {
+			static TraitsType = TraitsType;
+			static RegistryType = Registry$1;
+			static EntityType = EntityType;
+			reg;
+			constructor(registry) {
+				super();
+				this.reg = registry;
+			}
+			dispose() {
+				this.reg = null;
+			}
+			get(archive, Type) {
+				const [ComponentType] = destructKey(Type);
+				const storage = this.reg.getStorage(Type);
+				const length = new Ref(TraitsType.EntityType(0));
+				archive.loadSize(length);
+				if (ComponentType === EntityType) {
+					const count = new Ref(TraitsType.EntityType(0));
+					let placeholder = newEntityType();
+					storage.reserve(length.value);
+					archive.loadSize(count);
+					const entityRef = new Ref(TraitsType.null);
+					for (; length.value > 0; --length.value) {
+						archive.loadEntity(entityRef);
+						storage.generate(entityRef.value);
+						placeholder = entityRef.value > placeholder ? entityRef.value : placeholder;
+					}
+					storage.startFrom(TraitsType.next(placeholder));
+					storage.freeList(count.value);
+				} else {
+					const other = this.reg.getStorage(EntityType);
+					const enttRef = new Ref(TraitsType.null);
+					const isEmptyStorage = componentTraitsTemplate.instantiate(storage.constructor.ElementType, storage.constructor.EntityType).pageSize === 0;
+					const newComponentType = isEmptyStorage ? (() => void 0) : createSafeNew(ComponentType);
+					while (length.value--) {
+						archive.loadEntity(enttRef);
+						if (!TraitsType.isNull(enttRef.value)) {
+							const entity = other.contains(enttRef.value) ? enttRef.value : other.generate(enttRef.value);
+							assert(TraitsType.toIntegral(entity) === TraitsType.toIntegral(enttRef.value), "Entity not available for use");
+							if (isEmptyStorage) storage.emplace(entity);
+							else {
+								const compRef = new Ref(newComponentType());
+								archive.loadComponent(compRef);
+								storage.emplace(entity, compRef.value);
+							}
+						}
+					}
+				}
+				return this;
+			}
+			orphans() {
+				orphans(this.reg);
+				return this;
+			}
+		}
+		return BasicSnapshotLoader;
+	});
+	const basicContinuousLoaderTemplate = /* @__PURE__ */ defineTemplate(function(Registry$1) {
+		const TraitsType = enttTraitsTemplate.instantiate(Registry$1.EntityType);
+		const EntityType = Registry$1.EntityType;
+		class BasicContinuousLoader extends Disposable {
+			static RegistryType = Registry$1;
+			static EntityType = EntityType;
+			static TraitsType = TraitsType;
+			remloc;
+			reg;
+			restore(entt) {
+				const entity = TraitsType.toEntity(entt);
+				const record = this.remloc.get(entity);
+				if (record !== void 0 && TraitsType.toIntegral(record[0]) === TraitsType.toIntegral(entt)) {
+					if (!this.reg.valid(record[1])) record[1] = this.reg.create();
+				} else this.remloc.set(entity, [entt, this.reg.create()]);
+			}
+			constructor(registry) {
+				super();
+				this.remloc = /* @__PURE__ */ new Map();
+				this.reg = registry;
+			}
+			dispose() {
+				this.remloc.clear();
+				this.reg = null;
+			}
+			get(archive, Type) {
+				const [ComponentType] = destructKey(Type);
+				const storage = this.reg.getStorage(Type);
+				const length = new Ref(TraitsType.EntityType(0));
+				const enttRef = new Ref(TraitsType.null);
+				archive.loadSize(length);
+				if (ComponentType === EntityType) {
+					const inUse = new Ref(TraitsType.EntityType(0));
+					storage.reserve(length.value);
+					archive.loadSize(inUse);
+					for (let pos = 0; pos < inUse.value; ++pos) {
+						archive.loadEntity(enttRef);
+						this.restore(enttRef.value);
+					}
+					for (let pos = inUse.value; pos < length.value; ++pos) {
+						archive.loadEntity(enttRef);
+						const entity = TraitsType.toEntity(enttRef.value);
+						const record = this.remloc.get(entity);
+						if (record !== void 0) {
+							if (this.reg.valid(record[1])) this.reg.destroy(record[1]);
+							this.remloc.delete(entity);
+						}
+					}
+				} else {
+					for (const record of this.remloc.values()) storage.remove(record[1]);
+					const isEmptyStorage = componentTraitsTemplate.instantiate(storage.constructor.ElementType, storage.constructor.EntityType).pageSize === 0;
+					const newComponentType = isEmptyStorage ? (() => void 0) : createSafeNew(ComponentType);
+					while (length.value--) {
+						archive.loadEntity(enttRef);
+						if (!TraitsType.isNull(enttRef.value)) {
+							this.restore(enttRef.value);
+							if (isEmptyStorage) storage.emplace(this.map(enttRef.value));
+							else {
+								const compRef = new Ref(newComponentType());
+								archive.loadComponent(compRef);
+								storage.emplace(this.map(enttRef.value), compRef.value);
+							}
+						}
+					}
+				}
+				return this;
+			}
+			orphans() {
+				orphans(this.reg);
+				return this;
+			}
+			contains(entt) {
+				const record = this.remloc.get(TraitsType.toEntity(entt));
+				return record !== void 0 && TraitsType.toIntegral(record[0]) === TraitsType.toIntegral(entt);
+			}
+			map(entt) {
+				const record = this.remloc.get(TraitsType.toEntity(entt));
+				if (record !== void 0 && TraitsType.toIntegral(record[0]) === TraitsType.toIntegral(entt)) return record[1];
+				return TraitsType.null;
+			}
+		}
+		return BasicContinuousLoader;
+	});
+	const Snapshot = /* @__PURE__ */ (() => basicSnapshotTemplate.instantiate(Registry))();
+	const SnapshotLoader = /* @__PURE__ */ (() => basicSnapshotLoaderTemplate.instantiate(Registry))();
+	const ContinuousLoader = /* @__PURE__ */ (() => basicContinuousLoaderTemplate.instantiate(Registry))();
+
+//#endregion
+//#region src/index.ts
+	const version = "0.0.0";
+
+//#endregion
+exports.AggregatePointer = AggregatePointer;
+exports.ArrayPointer = ArrayPointer;
+exports.ArrayRange = ArrayRange;
+exports.BasicDispatcher = BasicDispatcher;
+exports.Connection = Connection;
+exports.ContinuousLoader = ContinuousLoader;
+exports.Delegate = Delegate;
+exports.DeletionPolicy = DeletionPolicy;
+exports.Disposable = Disposable;
+exports.Emitter = Emitter;
+exports.EmptyTypeOptimization = EmptyTypeOptimization;
+exports.Entity = Entity;
+exports.Float32 = Float32;
+exports.Float64 = Float64;
+exports.GroupDescriptor = GroupDescriptor;
+exports.Int16 = Int16;
+exports.Int32 = Int32;
+exports.Int64 = Int64;
+exports.Int8 = Int8;
+exports.NotConstructorError = NotConstructorError;
+exports.RangeIterator = RangeIterator;
+exports.Registry = Registry;
+exports.ReversePointer = ReversePointer;
+exports.RuntimeView = RuntimeView;
+exports.RuntimeViewIterator = RuntimeViewIterator;
+exports.ScopedConnection = ScopedConnection;
+exports.Sigh = Sigh;
+exports.Sink = Sink;
+exports.Snapshot = Snapshot;
+exports.SnapshotLoader = SnapshotLoader;
+exports.SparseSet = SparseSet;
+exports.SparseSetPointer = SparseSetPointer;
+exports.StoragePointer = StoragePointer;
+exports.Template = Template;
+exports.Uint16 = Uint16;
+exports.Uint32 = Uint32;
+exports.Uint64 = Uint64;
+exports.Uint8 = Uint8;
+exports.basicContinuousLoaderTemplate = basicContinuousLoaderTemplate;
+exports.basicEnttTraitsTemplate = basicEnttTraitsTemplate;
+exports.basicGroupTemplate = basicGroupTemplate;
+exports.basicRegistryTemplate = basicRegistryTemplate;
+exports.basicRuntimeViewTemplate = basicRuntimeViewTemplate;
+exports.basicSighMixinTemplate = basicSighMixinTemplate;
+exports.basicSnapshotLoaderTemplate = basicSnapshotLoaderTemplate;
+exports.basicSnapshotTemplate = basicSnapshotTemplate;
+exports.basicSparseSetTemplate = basicSparseSetTemplate;
+exports.basicStorageTemplate = basicStorageTemplate;
+exports.basicViewTemplate = basicViewTemplate;
+exports.commonType = commonType;
+exports.componentTraitsTemplate = componentTraitsTemplate;
+exports.config = config;
+exports.createSafeNew = createSafeNew;
+exports.defineTemplate = defineTemplate;
+exports.directCall = directCall;
+exports.distance = distance;
+exports.enttTraitsTemplate = enttTraitsTemplate;
+exports.insertionSort = insertionSort;
+exports.internalEnttTraits = internalEnttTraits;
+exports.isEmptyClass = isEmptyClass;
+exports.makeGroup = makeGroup;
+exports.makeRangePointer = makeRangePointer;
+exports.makeReversePointer = makeReversePointer;
+exports.makeView = makeView;
+exports.stdSort = defaultSort;
+exports.storageTemplate = storageTemplate;
+exports.storageTypeTTemplate = storageTypeTTemplate;
+exports.storageTypeTemplate = storageTypeTemplate;
+exports.toIterator = toIterator;
+exports.toRange = toRange;
+exports.version = version;
+return exports;
+})({});