@codehz/ecs 0.3.7 → 0.3.8

package/index.js

@@ -1,1481 +0,0 @@
-// src/entity.ts
-var INVALID_COMPONENT_ID = 0;
-var COMPONENT_ID_MAX = 1023;
-var ENTITY_ID_START = 1024;
-var RELATION_SHIFT = 2 ** 42;
-var WILDCARD_TARGET_ID = 0;
-function createComponentId(id) {
-  if (id < 1 || id > COMPONENT_ID_MAX) {
-    throw new Error(`Component ID must be between 1 and ${COMPONENT_ID_MAX}`);
-  }
-  return id;
-}
-function createEntityId(id) {
-  if (id < ENTITY_ID_START) {
-    throw new Error(`Entity ID must be ${ENTITY_ID_START} or greater`);
-  }
-  return id;
-}
-function relation(componentId, targetId) {
-  if (!isComponentId(componentId)) {
-    throw new Error("First argument must be a valid component ID");
-  }
-  let actualTargetId;
-  if (targetId === "*") {
-    actualTargetId = WILDCARD_TARGET_ID;
-  } else {
-    if (!isEntityId(targetId) && !isComponentId(targetId)) {
-      throw new Error("Second argument must be a valid entity ID, component ID, or '*'");
-    }
-    actualTargetId = targetId;
-  }
-  return -(componentId * RELATION_SHIFT + actualTargetId);
-}
-function isComponentId(id) {
-  return id >= 1 && id <= COMPONENT_ID_MAX;
-}
-function isEntityId(id) {
-  return id >= ENTITY_ID_START;
-}
-function isRelationId(id) {
-  return id < 0;
-}
-function isWildcardRelationId(id) {
-  if (!isRelationId(id)) {
-    return false;
-  }
-  const absId = -id;
-  const targetId = absId % RELATION_SHIFT;
-  return targetId === WILDCARD_TARGET_ID;
-}
-function decodeRelationId(relationId) {
-  if (!isRelationId(relationId)) {
-    throw new Error("ID is not a relation ID");
-  }
-  const absId = -relationId;
-  const componentId = Math.floor(absId / RELATION_SHIFT);
-  const targetId = absId % RELATION_SHIFT;
-  if (targetId === WILDCARD_TARGET_ID) {
-    return { componentId, targetId, type: "wildcard" };
-  } else if (isEntityId(targetId)) {
-    return { componentId, targetId, type: "entity" };
-  } else if (isComponentId(targetId)) {
-    return { componentId, targetId, type: "component" };
-  } else {
-    throw new Error("Invalid target ID in relation");
-  }
-}
-function getIdType(id) {
-  if (isComponentId(id))
-    return "component";
-  if (isEntityId(id))
-    return "entity";
-  if (isRelationId(id)) {
-    try {
-      const decoded = decodeRelationId(id);
-      if (!isComponentId(decoded.componentId) || decoded.type !== "wildcard" && !isEntityId(decoded.targetId) && !isComponentId(decoded.targetId)) {
-        return "invalid";
-      }
-      switch (decoded.type) {
-        case "entity":
-          return "entity-relation";
-        case "component":
-          return "component-relation";
-        case "wildcard":
-          return "wildcard-relation";
-      }
-    } catch (error) {
-      return "invalid";
-    }
-  }
-  return "invalid";
-}
-function getDetailedIdType(id) {
-  if (isComponentId(id)) {
-    return { type: "component" };
-  }
-  if (isEntityId(id)) {
-    return { type: "entity" };
-  }
-  if (isRelationId(id)) {
-    try {
-      const decoded = decodeRelationId(id);
-      if (!isComponentId(decoded.componentId) || decoded.type !== "wildcard" && !isEntityId(decoded.targetId) && !isComponentId(decoded.targetId)) {
-        return { type: "invalid" };
-      }
-      let type;
-      switch (decoded.type) {
-        case "entity":
-          type = "entity-relation";
-          break;
-        case "component":
-          type = "component-relation";
-          break;
-        case "wildcard":
-          type = "wildcard-relation";
-          break;
-      }
-      return {
-        type,
-        componentId: decoded.componentId,
-        targetId: decoded.targetId
-      };
-    } catch (error) {
-      return { type: "invalid" };
-    }
-  }
-  return { type: "invalid" };
-}
-function inspectEntityId(id) {
-  if (id === INVALID_COMPONENT_ID) {
-    return "Invalid Component ID (0)";
-  }
-  if (isComponentId(id)) {
-    return `Component ID (${id})`;
-  }
-  if (isEntityId(id)) {
-    return `Entity ID (${id})`;
-  }
-  if (isRelationId(id)) {
-    try {
-      const decoded = decodeRelationId(id);
-      if (!isComponentId(decoded.componentId) || decoded.type !== "wildcard" && !isEntityId(decoded.targetId) && !isComponentId(decoded.targetId)) {
-        return `Invalid Relation ID (${id})`;
-      }
-      const componentStr = `Component ID (${decoded.componentId})`;
-      const targetStr = decoded.type === "entity" ? `Entity ID (${decoded.targetId})` : decoded.type === "component" ? `Component ID (${decoded.targetId})` : "Wildcard (*)";
-      return `Relation ID: ${componentStr} -> ${targetStr}`;
-    } catch (error) {
-      return `Invalid Relation ID (${id})`;
-    }
-  }
-  return `Unknown ID (${id})`;
-}
-
-class EntityIdManager {
-  nextId = ENTITY_ID_START;
-  freelist = new Set;
-  allocate() {
-    if (this.freelist.size > 0) {
-      const id = this.freelist.values().next().value;
-      this.freelist.delete(id);
-      return id;
-    } else {
-      const id = this.nextId;
-      this.nextId++;
-      if (this.nextId >= Number.MAX_SAFE_INTEGER) {
-        throw new Error("Entity ID overflow: reached maximum safe integer");
-      }
-      return id;
-    }
-  }
-  deallocate(id) {
-    if (!isEntityId(id)) {
-      throw new Error("Can only deallocate valid entity IDs");
-    }
-    if (id >= this.nextId) {
-      throw new Error("Cannot deallocate an ID that was never allocated");
-    }
-    this.freelist.add(id);
-  }
-  getFreelistSize() {
-    return this.freelist.size;
-  }
-  getNextId() {
-    return this.nextId;
-  }
-  serializeState() {
-    return { nextId: this.nextId, freelist: Array.from(this.freelist) };
-  }
-  deserializeState(state) {
-    if (typeof state.nextId !== "number") {
-      throw new Error("Invalid state for EntityIdManager.deserializeState");
-    }
-    this.nextId = state.nextId;
-    this.freelist = new Set(state.freelist || []);
-  }
-}
-
-class ComponentIdAllocator {
-  nextId = 1;
-  allocate() {
-    if (this.nextId > COMPONENT_ID_MAX) {
-      throw new Error(`Component ID overflow: maximum ${COMPONENT_ID_MAX} components allowed`);
-    }
-    const id = this.nextId;
-    this.nextId++;
-    return id;
-  }
-  getNextId() {
-    return this.nextId;
-  }
-  hasAvailableIds() {
-    return this.nextId <= COMPONENT_ID_MAX;
-  }
-}
-var globalComponentIdAllocator = new ComponentIdAllocator;
-var ComponentNames = new Map;
-var ComponentIdForNames = new Map;
-function component(name) {
-  const id = globalComponentIdAllocator.allocate();
-  if (name) {
-    if (ComponentIdForNames.has(name)) {
-      throw new Error(`Component name "${name}" is already registered`);
-    }
-    ComponentNames.set(id, name);
-    ComponentIdForNames.set(name, id);
-  }
-  return id;
-}
-function getComponentIdByName(name) {
-  return ComponentIdForNames.get(name);
-}
-function getComponentNameById(id) {
-  return ComponentNames.get(id);
-}
-// src/types.ts
-function isOptionalEntityId(type) {
-  return typeof type === "object" && type !== null && "optional" in type;
-}
-
-// src/utils.ts
-function getOrComputeCache(cache, key, compute) {
-  let value = cache.get(key);
-  if (value === undefined) {
-    value = compute();
-    cache.set(key, value);
-  }
-  return value;
-}
-function getOrCreateWithSideEffect(cache, key, create) {
-  let value = cache.get(key);
-  if (value === undefined) {
-    value = create();
-    cache.set(key, value);
-  }
-  return value;
-}
-
-// src/archetype.ts
-var MISSING_COMPONENT = Symbol("missing component");
-
-class Archetype {
-  componentTypes;
-  entities = [];
-  componentData = new Map;
-  entityToIndex = new Map;
-  componentDataSourcesCache = new Map;
-  constructor(componentTypes) {
-    this.componentTypes = [...componentTypes].sort((a, b) => a - b);
-    for (const componentType of this.componentTypes) {
-      this.componentData.set(componentType, []);
-    }
-  }
-  get size() {
-    return this.entities.length;
-  }
-  matches(componentTypes) {
-    if (this.componentTypes.length !== componentTypes.length) {
-      return false;
-    }
-    const sortedTypes = [...componentTypes].sort((a, b) => a - b);
-    return this.componentTypes.every((type, index) => type === sortedTypes[index]);
-  }
-  addEntity(entityId, componentData) {
-    if (this.entityToIndex.has(entityId)) {
-      throw new Error(`Entity ${entityId} is already in this archetype`);
-    }
-    const index = this.entities.length;
-    this.entities.push(entityId);
-    this.entityToIndex.set(entityId, index);
-    for (const componentType of this.componentTypes) {
-      const data = componentData.get(componentType);
-      this.getComponentData(componentType).push(data === undefined ? MISSING_COMPONENT : data);
-    }
-  }
-  getEntity(entityId) {
-    const index = this.entityToIndex.get(entityId);
-    if (index === undefined) {
-      return;
-    }
-    const entityData = new Map;
-    for (const componentType of this.componentTypes) {
-      const dataArray = this.getComponentData(componentType);
-      const data = dataArray[index];
-      entityData.set(componentType, data === MISSING_COMPONENT ? undefined : data);
-    }
-    return entityData;
-  }
-  dump() {
-    const result = [];
-    for (let i = 0;i < this.entities.length; i++) {
-      const entity = this.entities[i];
-      const components = new Map;
-      for (const componentType of this.componentTypes) {
-        const dataArray = this.getComponentData(componentType);
-        const data = dataArray[i];
-        components.set(componentType, data === MISSING_COMPONENT ? undefined : data);
-      }
-      result.push({ entity, components });
-    }
-    return result;
-  }
-  removeEntity(entityId) {
-    const index = this.entityToIndex.get(entityId);
-    if (index === undefined) {
-      return;
-    }
-    const removedData = new Map;
-    for (const componentType of this.componentTypes) {
-      const dataArray = this.getComponentData(componentType);
-      removedData.set(componentType, dataArray[index]);
-    }
-    this.entityToIndex.delete(entityId);
-    const lastIndex = this.entities.length - 1;
-    if (index !== lastIndex) {
-      const lastEntity = this.entities[lastIndex];
-      this.entities[index] = lastEntity;
-      this.entityToIndex.set(lastEntity, index);
-      for (const componentType of this.componentTypes) {
-        const dataArray = this.getComponentData(componentType);
-        dataArray[index] = dataArray[lastIndex];
-      }
-    }
-    this.entities.pop();
-    for (const componentType of this.componentTypes) {
-      this.getComponentData(componentType).pop();
-    }
-    return removedData;
-  }
-  exists(entityId) {
-    return this.entityToIndex.has(entityId);
-  }
-  get(entityId, componentType) {
-    const index = this.entityToIndex.get(entityId);
-    if (index === undefined) {
-      throw new Error(`Entity ${entityId} is not in this archetype`);
-    }
-    if (isWildcardRelationId(componentType)) {
-      const decoded = decodeRelationId(componentType);
-      const componentId = decoded.componentId;
-      const relations = [];
-      for (const relType of this.componentTypes) {
-        const relDetailed = getDetailedIdType(relType);
-        if ((relDetailed.type === "entity-relation" || relDetailed.type === "component-relation") && relDetailed.componentId === componentId) {
-          const dataArray = this.getComponentData(relType);
-          if (dataArray && dataArray[index] !== undefined) {
-            const data = dataArray[index];
-            relations.push([relDetailed.targetId, data === MISSING_COMPONENT ? undefined : data]);
-          }
-        }
-      }
-      return relations;
-    } else {
-      const data = this.getComponentData(componentType)[index];
-      return data === MISSING_COMPONENT ? undefined : data;
-    }
-  }
-  set(entityId, componentType, data) {
-    if (!this.componentData.has(componentType)) {
-      throw new Error(`Component type ${componentType} is not in this archetype`);
-    }
-    const index = this.entityToIndex.get(entityId);
-    if (index === undefined) {
-      throw new Error(`Entity ${entityId} is not in this archetype`);
-    }
-    const dataArray = this.getComponentData(componentType);
-    dataArray[index] = data;
-  }
-  getEntities() {
-    return this.entities;
-  }
-  getEntityToIndexMap() {
-    return this.entityToIndex;
-  }
-  getComponentData(componentType) {
-    const data = this.componentData.get(componentType);
-    if (!data) {
-      throw new Error(`Component type ${componentType} is not in this archetype`);
-    }
-    return data;
-  }
-  getOptionalComponentData(componentType) {
-    return this.componentData.get(componentType);
-  }
-  getCachedComponentDataSources(componentTypes) {
-    const cacheKey = componentTypes.map((id) => isOptionalEntityId(id) ? `opt(${id.optional})` : `${id}`).join(",");
-    return getOrComputeCache(this.componentDataSourcesCache, cacheKey, () => {
-      return componentTypes.map((compType) => {
-        let optional = false;
-        if (isOptionalEntityId(compType)) {
-          compType = compType.optional;
-          optional = true;
-        }
-        const detailedType = getDetailedIdType(compType);
-        if (detailedType.type === "wildcard-relation") {
-          const componentId = detailedType.componentId;
-          const matchingRelations = this.componentTypes.filter((ct) => {
-            const detailedCt = getDetailedIdType(ct);
-            if (detailedCt.type !== "entity-relation" && detailedCt.type !== "component-relation")
-              return false;
-            return detailedCt.componentId === componentId;
-          });
-          return optional ? matchingRelations.length > 0 ? matchingRelations : undefined : matchingRelations;
-        } else {
-          return optional ? this.getOptionalComponentData(compType) : this.getComponentData(compType);
-        }
-      });
-    });
-  }
-  buildComponentsForIndex(componentTypes, componentDataSources, entityIndex) {
-    return componentDataSources.map((dataSource, i) => {
-      let compType = componentTypes[i];
-      let optional = false;
-      if (isOptionalEntityId(compType)) {
-        compType = compType.optional;
-        optional = true;
-      }
-      if (getIdType(compType) === "wildcard-relation") {
-        if (dataSource === undefined) {
-          if (optional) {
-            return;
-          } else {
-            throw new Error(`No matching relations found for mandatory wildcard relation component type`);
-          }
-        }
-        const matchingRelations = dataSource;
-        const relations = [];
-        for (const relType of matchingRelations) {
-          const dataArray = this.getComponentData(relType);
-          const data = dataArray[entityIndex];
-          const decodedRel = decodeRelationId(relType);
-          relations.push([decodedRel.targetId, data === MISSING_COMPONENT ? undefined : data]);
-        }
-        return optional ? { value: relations } : relations;
-      } else {
-        if (dataSource === undefined) {
-          if (optional) {
-            return;
-          } else {
-            throw new Error(`No matching relations found for mandatory wildcard relation component type`);
-          }
-        }
-        const dataArray = dataSource;
-        const data = dataArray[entityIndex];
-        const result = data === MISSING_COMPONENT ? undefined : data;
-        return optional ? { value: result } : result;
-      }
-    });
-  }
-  getEntitiesWithComponents(componentTypes) {
-    const result = [];
-    this.forEachWithComponents(componentTypes, (entity, ...components) => {
-      result.push({ entity, components });
-    });
-    return result;
-  }
-  *iterateWithComponents(componentTypes) {
-    const componentDataSources = this.getCachedComponentDataSources(componentTypes);
-    for (let entityIndex = 0;entityIndex < this.entities.length; entityIndex++) {
-      const entity = this.entities[entityIndex];
-      const components = this.buildComponentsForIndex(componentTypes, componentDataSources, entityIndex);
-      yield [entity, ...components];
-    }
-  }
-  forEachWithComponents(componentTypes, callback) {
-    const componentDataSources = this.getCachedComponentDataSources(componentTypes);
-    for (let entityIndex = 0;entityIndex < this.entities.length; entityIndex++) {
-      const entity = this.entities[entityIndex];
-      const components = this.buildComponentsForIndex(componentTypes, componentDataSources, entityIndex);
-      callback(entity, ...components);
-    }
-  }
-  forEach(callback) {
-    for (let i = 0;i < this.entities.length; i++) {
-      const components = new Map;
-      for (const componentType of this.componentTypes) {
-        const data = this.getComponentData(componentType)[i];
-        components.set(componentType, data === MISSING_COMPONENT ? undefined : data);
-      }
-      callback(this.entities[i], components);
-    }
-  }
-}
-
-// src/changeset.ts
-class ComponentChangeset {
-  adds = new Map;
-  removes = new Set;
-  set(componentType, component2) {
-    this.adds.set(componentType, component2);
-    this.removes.delete(componentType);
-  }
-  delete(componentType) {
-    this.removes.add(componentType);
-    this.adds.delete(componentType);
-  }
-  hasChanges() {
-    return this.adds.size > 0 || this.removes.size > 0;
-  }
-  clear() {
-    this.adds.clear();
-    this.removes.clear();
-  }
-  merge(other) {
-    for (const [componentType, component2] of other.adds) {
-      this.adds.set(componentType, component2);
-      this.removes.delete(componentType);
-    }
-    for (const componentType of other.removes) {
-      this.removes.add(componentType);
-      this.adds.delete(componentType);
-    }
-  }
-  applyTo(existingComponents) {
-    for (const componentType of this.removes) {
-      existingComponents.delete(componentType);
-    }
-    for (const [componentType, component2] of this.adds) {
-      existingComponents.set(componentType, component2);
-    }
-    return existingComponents;
-  }
-  getFinalComponentTypes(existingComponentTypes) {
-    const finalComponentTypes = new Set(existingComponentTypes);
-    let changed = false;
-    for (const componentType of this.removes) {
-      if (!finalComponentTypes.has(componentType)) {
-        this.removes.delete(componentType);
-        continue;
-      }
-      changed = true;
-      finalComponentTypes.delete(componentType);
-    }
-    for (const componentType of this.adds.keys()) {
-      if (finalComponentTypes.has(componentType)) {
-        continue;
-      }
-      changed = true;
-      finalComponentTypes.add(componentType);
-    }
-    return changed ? Array.from(finalComponentTypes) : undefined;
-  }
-}
-
-// src/command-buffer.ts
-class CommandBuffer {
-  commands = [];
-  executeEntityCommands;
-  constructor(executeEntityCommands) {
-    this.executeEntityCommands = executeEntityCommands;
-  }
-  set(entityId, componentType, component2) {
-    this.commands.push({ type: "set", entityId, componentType, component: component2 });
-  }
-  remove(entityId, componentType) {
-    this.commands.push({ type: "delete", entityId, componentType });
-  }
-  delete(entityId) {
-    this.commands.push({ type: "destroy", entityId });
-  }
-  execute() {
-    const MAX_ITERATIONS = 100;
-    let iterations = 0;
-    while (this.commands.length > 0) {
-      if (iterations >= MAX_ITERATIONS) {
-        throw new Error("Command execution exceeded maximum iterations, possible infinite loop");
-      }
-      iterations++;
-      const currentCommands = [...this.commands];
-      this.commands = [];
-      const entityCommands = new Map;
-      for (const cmd of currentCommands) {
-        if (!entityCommands.has(cmd.entityId)) {
-          entityCommands.set(cmd.entityId, []);
-        }
-        entityCommands.get(cmd.entityId).push(cmd);
-      }
-      for (const [entityId, commands] of entityCommands) {
-        this.executeEntityCommands(entityId, commands);
-      }
-    }
-  }
-  getCommands() {
-    return [...this.commands];
-  }
-  clear() {
-    this.commands = [];
-  }
-}
-
-// src/multi-map.ts
-class MultiMap {
-  map = new Map;
-  _valueCount = 0;
-  get valueCount() {
-    return this._valueCount;
-  }
-  get keyCount() {
-    return this.map.size;
-  }
-  hasKey(key) {
-    return this.map.has(key);
-  }
-  has(key, value) {
-    const set = this.map.get(key);
-    if (!set)
-      return false;
-    if (arguments.length === 1)
-      return true;
-    return set.has(value);
-  }
-  add(key, value) {
-    let set = this.map.get(key);
-    if (!set) {
-      set = new Set;
-      this.map.set(key, set);
-    }
-    if (!set.has(value)) {
-      set.add(value);
-      this._valueCount++;
-    }
-  }
-  remove(key, value) {
-    const set = this.map.get(key);
-    if (!set)
-      return false;
-    if (!set.has(value))
-      return false;
-    set.delete(value);
-    this._valueCount--;
-    if (set.size === 0)
-      this.map.delete(key);
-    return true;
-  }
-  deleteKey(key) {
-    const set = this.map.get(key);
-    if (!set)
-      return false;
-    this._valueCount -= set.size;
-    this.map.delete(key);
-    return true;
-  }
-  get(key) {
-    const set = this.map.get(key);
-    return set ? new Set(set) : new Set;
-  }
-  *keys() {
-    yield* this.map.keys();
-  }
-  *values() {
-    for (const set of this.map.values()) {
-      for (const v of set)
-        yield v;
-    }
-  }
-  [Symbol.iterator]() {
-    return this.entries();
-  }
-  *entries() {
-    for (const [k, set] of this.map.entries()) {
-      for (const v of set)
-        yield [k, v];
-    }
-  }
-  clear() {
-    this.map.clear();
-    this._valueCount = 0;
-  }
-}
-
-// src/query-filter.ts
-function serializeQueryFilter(filter = {}) {
-  const negative = (filter.negativeComponentTypes || []).slice().sort((a, b) => a - b);
-  if (negative.length === 0)
-    return "";
-  return `neg:${negative.join(",")}`;
-}
-function matchesComponentTypes(archetype, componentTypes) {
-  return componentTypes.every((type) => {
-    const detailedType = getDetailedIdType(type);
-    if (detailedType.type === "wildcard-relation") {
-      return archetype.componentTypes.some((archetypeType) => {
-        if (!isRelationId(archetypeType))
-          return false;
-        const decoded = decodeRelationId(archetypeType);
-        return decoded.componentId === detailedType.componentId;
-      });
-    } else {
-      return archetype.componentTypes.includes(type);
-    }
-  });
-}
-function matchesFilter(archetype, filter) {
-  const negativeTypes = filter.negativeComponentTypes || [];
-  return negativeTypes.every((type) => {
-    const detailedType = getDetailedIdType(type);
-    if (detailedType.type === "wildcard-relation") {
-      return !archetype.componentTypes.some((archetypeType) => {
-        if (!isRelationId(archetypeType))
-          return false;
-        const decoded = decodeRelationId(archetypeType);
-        return decoded.componentId === detailedType.componentId;
-      });
-    } else {
-      return !archetype.componentTypes.includes(type);
-    }
-  });
-}
-
-// src/query.ts
-class Query {
-  world;
-  componentTypes;
-  filter;
-  cachedArchetypes = [];
-  isDisposed = false;
-  constructor(world, componentTypes, filter = {}) {
-    this.world = world;
-    this.componentTypes = [...componentTypes].sort((a, b) => a - b);
-    this.filter = filter;
-    this.updateCache();
-    world._registerQuery(this);
-  }
-  getEntities() {
-    if (this.isDisposed) {
-      throw new Error("Query has been disposed");
-    }
-    const result = [];
-    for (const archetype of this.cachedArchetypes) {
-      result.push(...archetype.getEntities());
-    }
-    return result;
-  }
-  getEntitiesWithComponents(componentTypes) {
-    if (this.isDisposed) {
-      throw new Error("Query has been disposed");
-    }
-    const result = [];
-    for (const archetype of this.cachedArchetypes) {
-      const entitiesWithData = archetype.getEntitiesWithComponents(componentTypes);
-      result.push(...entitiesWithData);
-    }
-    return result;
-  }
-  forEach(componentTypes, callback) {
-    if (this.isDisposed) {
-      throw new Error("Query has been disposed");
-    }
-    for (const archetype of this.cachedArchetypes) {
-      archetype.forEachWithComponents(componentTypes, callback);
-    }
-  }
-  *iterate(componentTypes) {
-    if (this.isDisposed) {
-      throw new Error("Query has been disposed");
-    }
-    for (const archetype of this.cachedArchetypes) {
-      yield* archetype.iterateWithComponents(componentTypes);
-    }
-  }
-  getComponentData(componentType) {
-    if (this.isDisposed) {
-      throw new Error("Query has been disposed");
-    }
-    const result = [];
-    for (const archetype of this.cachedArchetypes) {
-      result.push(...archetype.getComponentData(componentType));
-    }
-    return result;
-  }
-  updateCache() {
-    if (this.isDisposed)
-      return;
-    this.cachedArchetypes = this.world.getMatchingArchetypes(this.componentTypes).filter((archetype) => matchesFilter(archetype, this.filter));
-  }
-  checkNewArchetype(archetype) {
-    if (this.isDisposed)
-      return;
-    if (matchesComponentTypes(archetype, this.componentTypes) && matchesFilter(archetype, this.filter) && !this.cachedArchetypes.includes(archetype)) {
-      this.cachedArchetypes.push(archetype);
-    }
-  }
-  removeArchetype(archetype) {
-    if (this.isDisposed)
-      return;
-    const index = this.cachedArchetypes.indexOf(archetype);
-    if (index !== -1) {
-      this.cachedArchetypes.splice(index, 1);
-    }
-  }
-  dispose() {
-    this.world.releaseQuery(this);
-  }
-  _disposeInternal() {
-    if (!this.isDisposed) {
-      this.world._unregisterQuery(this);
-      this.cachedArchetypes = [];
-      this.isDisposed = true;
-    }
-  }
-  [Symbol.dispose]() {
-    this.dispose();
-  }
-  get disposed() {
-    return this.isDisposed;
-  }
-}
-
-// src/system-scheduler.ts
-class SystemScheduler {
-  systems = new Set;
-  systemDependencies = new Map;
-  cachedExecutionOrder = null;
-  addSystem(system, additionalDeps = []) {
-    this.systems.add(system);
-    for (const dep of system.dependencies || []) {
-      this.systems.add(dep);
-    }
-    this.systemDependencies.set(system, new Set([...additionalDeps, ...system.dependencies || []]));
-    this.cachedExecutionOrder = null;
-  }
-  getExecutionOrder() {
-    if (this.cachedExecutionOrder !== null) {
-      return this.cachedExecutionOrder;
-    }
-    const result = [];
-    const visited = new Set;
-    const visiting = new Set;
-    const visit = (system) => {
-      if (visited.has(system))
-        return;
-      if (visiting.has(system)) {
-        throw new Error("Circular dependency detected in system scheduling");
-      }
-      visiting.add(system);
-      for (const dep of this.systemDependencies.get(system) || []) {
-        visit(dep);
-      }
-      visiting.delete(system);
-      visited.add(system);
-      result.push(system);
-    };
-    for (const system of this.systems) {
-      if (!visited.has(system)) {
-        visit(system);
-      }
-    }
-    this.cachedExecutionOrder = result;
-    return result;
-  }
-  update(...params) {
-    const executionOrder = this.getExecutionOrder();
-    const systemPromises = new Map;
-    for (const system of executionOrder) {
-      const deps = Array.from(this.systemDependencies.get(system) || []);
-      const depPromises = deps.map((dep) => systemPromises.get(dep)).filter(Boolean);
-      if (depPromises.length > 0) {
-        const promise = Promise.all(depPromises).then(() => system.update(...params));
-        systemPromises.set(system, promise);
-      } else {
-        const result = system.update(...params);
-        if (result instanceof Promise) {
-          systemPromises.set(system, result);
-        }
-      }
-    }
-    return Promise.all(systemPromises.values());
-  }
-  clear() {
-    this.systems.clear();
-    this.cachedExecutionOrder = null;
-  }
-}
-
-// src/world.ts
-class World {
-  entityIdManager = new EntityIdManager;
-  archetypes = [];
-  archetypeBySignature = new Map;
-  entityToArchetype = new Map;
-  archetypesByComponent = new Map;
-  entityReferences = new Map;
-  queries = [];
-  queryCache = new Map;
-  systemScheduler = new SystemScheduler;
-  commandBuffer = new CommandBuffer((entityId, commands) => this.executeEntityCommands(entityId, commands));
-  hooks = new Map;
-  exclusiveComponents = new Set;
-  cascadeDeleteComponents = new Set;
-  constructor(snapshot) {
-    if (snapshot && typeof snapshot === "object") {
-      if (snapshot.entityManager) {
-        this.entityIdManager.deserializeState(snapshot.entityManager);
-      }
-      if (Array.isArray(snapshot.entities)) {
-        for (const entry of snapshot.entities) {
-          const entityId = entry.id;
-          const componentsArray = entry.components || [];
-          const componentMap = new Map;
-          const componentTypes = [];
-          for (const componentEntry of componentsArray) {
-            const componentTypeRaw = componentEntry.type;
-            let componentType;
-            if (typeof componentTypeRaw === "number") {
-              componentType = componentTypeRaw;
-            } else if (typeof componentTypeRaw === "string") {
-              const compId = getComponentIdByName(componentTypeRaw);
-              if (compId === undefined) {
-                throw new Error(`Unknown component name in snapshot: ${componentTypeRaw}`);
-              }
-              componentType = compId;
-            } else if (typeof componentTypeRaw === "object" && componentTypeRaw !== null && typeof componentTypeRaw.component === "string") {
-              const compId = getComponentIdByName(componentTypeRaw.component);
-              if (compId === undefined) {
-                throw new Error(`Unknown component name in snapshot: ${componentTypeRaw.component}`);
-              }
-              if (typeof componentTypeRaw.target === "string") {
-                const targetCompId = getComponentIdByName(componentTypeRaw.target);
-                if (targetCompId === undefined) {
-                  throw new Error(`Unknown target component name in snapshot: ${componentTypeRaw.target}`);
-                }
-                componentType = relation(compId, targetCompId);
-              } else {
-                componentType = relation(compId, componentTypeRaw.target);
-              }
-            } else {
-              throw new Error(`Invalid component type in snapshot: ${JSON.stringify(componentTypeRaw)}`);
-            }
-            componentMap.set(componentType, componentEntry.value);
-            componentTypes.push(componentType);
-          }
-          const archetype = this.ensureArchetype(componentTypes);
-          archetype.addEntity(entityId, componentMap);
-          this.entityToArchetype.set(entityId, archetype);
-          for (const compType of componentTypes) {
-            const detailedType = getDetailedIdType(compType);
-            if (detailedType.type === "entity-relation") {
-              const targetEntityId = detailedType.targetId;
-              this.trackEntityReference(entityId, compType, targetEntityId);
-            } else if (detailedType.type === "entity") {
-              this.trackEntityReference(entityId, compType, compType);
-            }
-          }
-        }
-      }
-    }
-  }
-  createArchetypeSignature(componentTypes) {
-    return componentTypes.join(",");
-  }
-  new() {
-    const entityId = this.entityIdManager.allocate();
-    let emptyArchetype = this.ensureArchetype([]);
-    emptyArchetype.addEntity(entityId, new Map);
-    this.entityToArchetype.set(entityId, emptyArchetype);
-    return entityId;
-  }
-  destroyEntityImmediate(entityId) {
-    const queue = [entityId];
-    const visited = new Set;
-    while (queue.length > 0) {
-      const cur = queue.shift();
-      if (visited.has(cur))
-        continue;
-      visited.add(cur);
-      const archetype = this.entityToArchetype.get(cur);
-      if (!archetype) {
-        continue;
-      }
-      const componentReferences = Array.from(this.getEntityReferences(cur));
-      for (const [sourceEntityId, componentType] of componentReferences) {
-        const sourceArchetype = this.entityToArchetype.get(sourceEntityId);
-        if (!sourceArchetype)
-          continue;
-        const detailedType = getDetailedIdType(componentType);
-        if (detailedType.type === "entity-relation" && this.cascadeDeleteComponents.has(detailedType.componentId)) {
-          if (!visited.has(sourceEntityId)) {
-            queue.push(sourceEntityId);
-          }
-          continue;
-        }
-        const currentComponents = new Map;
-        let removedComponent = sourceArchetype.get(sourceEntityId, componentType);
-        for (const archetypeComponentType of sourceArchetype.componentTypes) {
-          if (archetypeComponentType !== componentType) {
-            const componentData = sourceArchetype.get(sourceEntityId, archetypeComponentType);
-            currentComponents.set(archetypeComponentType, componentData);
-          }
-        }
-        const newArchetype = this.ensureArchetype(currentComponents.keys());
-        sourceArchetype.removeEntity(sourceEntityId);
-        if (sourceArchetype.getEntities().length === 0) {
-          this.cleanupEmptyArchetype(sourceArchetype);
-        }
-        newArchetype.addEntity(sourceEntityId, currentComponents);
-        this.entityToArchetype.set(sourceEntityId, newArchetype);
-        this.untrackEntityReference(sourceEntityId, componentType, cur);
-        this.triggerLifecycleHooks(sourceEntityId, new Map, new Map([[componentType, removedComponent]]));
-      }
-      this.entityReferences.delete(cur);
-      archetype.removeEntity(cur);
-      if (archetype.getEntities().length === 0) {
-        this.cleanupEmptyArchetype(archetype);
-      }
-      this.entityToArchetype.delete(cur);
-      this.entityIdManager.deallocate(cur);
-    }
-  }
-  exists(entityId) {
-    return this.entityToArchetype.has(entityId);
-  }
-  set(entityId, componentType, component2) {
-    if (!this.exists(entityId)) {
-      throw new Error(`Entity ${entityId} does not exist`);
-    }
-    const detailedType = getDetailedIdType(componentType);
-    if (detailedType.type === "invalid") {
-      throw new Error(`Invalid component type: ${componentType}`);
-    }
-    if (detailedType.type === "wildcard-relation") {
-      throw new Error(`Cannot directly add wildcard relation components: ${componentType}`);
-    }
-    this.commandBuffer.set(entityId, componentType, component2);
-  }
-  remove(entityId, componentType) {
-    if (!this.exists(entityId)) {
-      throw new Error(`Entity ${entityId} does not exist`);
-    }
-    const detailedType = getDetailedIdType(componentType);
-    if (detailedType.type === "invalid") {
-      throw new Error(`Invalid component type: ${componentType}`);
-    }
-    this.commandBuffer.remove(entityId, componentType);
-  }
-  delete(entityId) {
-    this.commandBuffer.delete(entityId);
-  }
-  has(entityId, componentType) {
-    const archetype = this.entityToArchetype.get(entityId);
-    return archetype ? archetype.componentTypes.includes(componentType) : false;
-  }
-  get(entityId, componentType) {
-    const archetype = this.entityToArchetype.get(entityId);
-    if (!archetype) {
-      throw new Error(`Entity ${entityId} does not exist`);
-    }
-    const detailedType = getDetailedIdType(componentType);
-    if (detailedType.type !== "wildcard-relation") {
-      if (!archetype.componentTypes.includes(componentType)) {
-        throw new Error(`Entity ${entityId} does not have component ${componentType}. Use has() to check component existence before calling get().`);
-      }
-    }
-    return archetype.get(entityId, componentType);
-  }
-  registerSystem(system, additionalDeps = []) {
-    this.systemScheduler.addSystem(system, additionalDeps);
-  }
-  hook(componentType, hook) {
-    if (!this.hooks.has(componentType)) {
-      this.hooks.set(componentType, new Set);
-    }
-    this.hooks.get(componentType).add(hook);
-    if (hook.on_init !== undefined) {
-      this.archetypesByComponent.get(componentType)?.forEach((archetype) => {
-        const entities = archetype.getEntityToIndexMap();
-        const componentData = archetype.getComponentData(componentType);
-        for (const [entity, index] of entities) {
-          const data = componentData[index];
-          const value = data === MISSING_COMPONENT ? undefined : data;
-          hook.on_init?.(entity, componentType, value);
-        }
-      });
-    }
-  }
-  unhook(componentType, hook) {
-    const hooks = this.hooks.get(componentType);
-    if (hooks) {
-      hooks.delete(hook);
-      if (hooks.size === 0) {
-        this.hooks.delete(componentType);
-      }
-    }
-  }
-  setExclusive(componentId) {
-    this.exclusiveComponents.add(componentId);
-  }
-  setCascadeDelete(componentId) {
-    this.cascadeDeleteComponents.add(componentId);
-  }
-  update(...params) {
-    const result = this.systemScheduler.update(...params);
-    if (result instanceof Promise) {
-      return result.then(() => this.commandBuffer.execute());
-    } else {
-      this.commandBuffer.execute();
-    }
-  }
-  sync() {
-    this.commandBuffer.execute();
-  }
-  createQuery(componentTypes, filter = {}) {
-    const sortedTypes = [...componentTypes].sort((a, b) => a - b);
-    const filterKey = serializeQueryFilter(filter);
-    const key = `${this.createArchetypeSignature(sortedTypes)}${filterKey ? `|${filterKey}` : ""}`;
-    const cached = this.queryCache.get(key);
-    if (cached) {
-      cached.refCount++;
-      return cached.query;
-    }
-    const query = new Query(this, sortedTypes, filter);
-    this.queryCache.set(key, { query, refCount: 1 });
-    return query;
-  }
-  _registerQuery(query) {
-    this.queries.push(query);
-  }
-  _unregisterQuery(query) {
-    const index = this.queries.indexOf(query);
-    if (index !== -1) {
-      this.queries.splice(index, 1);
-    }
-  }
-  releaseQuery(query) {
-    for (const [k, v] of this.queryCache.entries()) {
-      if (v.query === query) {
-        v.refCount--;
-        if (v.refCount <= 0) {
-          this.queryCache.delete(k);
-          this._unregisterQuery(query);
-          v.query._disposeInternal();
-        }
-        return;
-      }
-    }
-  }
-  getMatchingArchetypes(componentTypes) {
-    if (componentTypes.length === 0) {
-      return [...this.archetypes];
-    }
-    const regularComponents = [];
-    const wildcardRelations = [];
-    for (const componentType of componentTypes) {
-      const detailedType = getDetailedIdType(componentType);
-      if (detailedType.type === "wildcard-relation") {
-        wildcardRelations.push({
-          componentId: detailedType.componentId,
-          relationId: componentType
-        });
-      } else {
-        regularComponents.push(componentType);
-      }
-    }
-    let matchingArchetypes = [];
-    if (regularComponents.length > 0) {
-      const sortedRegularTypes = [...regularComponents].sort((a, b) => a - b);
-      if (sortedRegularTypes.length === 1) {
-        const componentType = sortedRegularTypes[0];
-        matchingArchetypes = this.archetypesByComponent.get(componentType) || [];
-      } else {
-        const archetypeLists = sortedRegularTypes.map((type) => this.archetypesByComponent.get(type) || []);
-        const firstList = archetypeLists[0] || [];
-        const intersection = new Set;
-        for (const archetype of firstList) {
-          let hasAllComponents = true;
-          for (let listIndex = 1;listIndex < archetypeLists.length; listIndex++) {
-            const otherList = archetypeLists[listIndex];
-            if (!otherList.includes(archetype)) {
-              hasAllComponents = false;
-              break;
-            }
-          }
-          if (hasAllComponents) {
-            intersection.add(archetype);
-          }
-        }
-        matchingArchetypes = Array.from(intersection);
-      }
-    } else {
-      matchingArchetypes = [...this.archetypes];
-    }
-    for (const wildcard of wildcardRelations) {
-      matchingArchetypes = matchingArchetypes.filter((archetype) => archetype.componentTypes.some((archetypeType) => {
-        if (!isRelationId(archetypeType))
-          return false;
-        const decoded = decodeRelationId(archetypeType);
-        return decoded.componentId === wildcard.componentId;
-      }));
-    }
-    return matchingArchetypes;
-  }
-  query(componentTypes, includeComponents) {
-    const matchingArchetypes = this.getMatchingArchetypes(componentTypes);
-    if (includeComponents) {
-      const result = [];
-      for (const archetype of matchingArchetypes) {
-        const entitiesWithData = archetype.getEntitiesWithComponents(componentTypes);
-        result.push(...entitiesWithData);
-      }
-      return result;
-    } else {
-      const result = [];
-      for (const archetype of matchingArchetypes) {
-        result.push(...archetype.getEntities());
-      }
-      return result;
-    }
-  }
-  executeEntityCommands(entityId, commands) {
-    const changeset = new ComponentChangeset;
-    const hasDestroy = commands.some((cmd) => cmd.type === "destroy");
-    if (hasDestroy) {
-      this.destroyEntityImmediate(entityId);
-      return changeset;
-    }
-    const currentArchetype = this.entityToArchetype.get(entityId);
-    if (!currentArchetype) {
-      return changeset;
-    }
-    for (const command of commands) {
-      switch (command.type) {
-        case "set":
-          if (command.componentType) {
-            const detailedType = getDetailedIdType(command.componentType);
-            if ((detailedType.type === "entity-relation" || detailedType.type === "component-relation") && this.exclusiveComponents.has(detailedType.componentId)) {
-              for (const componentType of currentArchetype.componentTypes) {
-                const componentDetailedType = getDetailedIdType(componentType);
-                if ((componentDetailedType.type === "entity-relation" || componentDetailedType.type === "component-relation") && componentDetailedType.componentId === detailedType.componentId) {
-                  changeset.delete(componentType);
-                }
-              }
-            }
-            changeset.set(command.componentType, command.component);
-          }
-          break;
-        case "delete":
-          if (command.componentType) {
-            const detailedType = getDetailedIdType(command.componentType);
-            if (detailedType.type === "wildcard-relation") {
-              const baseComponentId = detailedType.componentId;
-              for (const componentType of currentArchetype.componentTypes) {
-                const componentDetailedType = getDetailedIdType(componentType);
-                if (componentDetailedType.type === "entity-relation" || componentDetailedType.type === "component-relation") {
-                  if (componentDetailedType.componentId === baseComponentId) {
-                    changeset.delete(componentType);
-                  }
-                }
-              }
-            } else {
-              changeset.delete(command.componentType);
-            }
-          }
-          break;
-      }
-    }
-    const finalComponentTypes = changeset.getFinalComponentTypes(currentArchetype.componentTypes);
-    const removedCompoents = new Map;
-    if (finalComponentTypes) {
-      const newArchetype = this.ensureArchetype(finalComponentTypes);
-      const currentComponents = currentArchetype.removeEntity(entityId);
-      for (const componentType of changeset.removes) {
-        removedCompoents.set(componentType, currentComponents.get(componentType));
-      }
-      newArchetype.addEntity(entityId, changeset.applyTo(currentComponents));
-      this.entityToArchetype.set(entityId, newArchetype);
-    } else {
-      for (const [componentType, component2] of changeset.adds) {
-        currentArchetype.set(entityId, componentType, component2);
-      }
-    }
-    for (const componentType of changeset.removes) {
-      const detailedType = getDetailedIdType(componentType);
-      if (detailedType.type === "entity-relation") {
-        const targetEntityId = detailedType.targetId;
-        this.untrackEntityReference(entityId, componentType, targetEntityId);
-      } else if (detailedType.type === "entity") {
-        this.untrackEntityReference(entityId, componentType, componentType);
-      }
-    }
-    for (const [componentType, component2] of changeset.adds) {
-      const detailedType = getDetailedIdType(componentType);
-      if (detailedType.type === "entity-relation") {
-        const targetEntityId = detailedType.targetId;
-        this.trackEntityReference(entityId, componentType, targetEntityId);
-      } else if (detailedType.type === "entity") {
-        this.trackEntityReference(entityId, componentType, componentType);
-      }
-    }
-    this.triggerLifecycleHooks(entityId, changeset.adds, removedCompoents);
-    return changeset;
-  }
-  ensureArchetype(componentTypes) {
-    const sortedTypes = Array.from(componentTypes).sort((a, b) => a - b);
-    const hashKey = this.createArchetypeSignature(sortedTypes);
-    return getOrCreateWithSideEffect(this.archetypeBySignature, hashKey, () => {
-      const newArchetype = new Archetype(sortedTypes);
-      this.archetypes.push(newArchetype);
-      for (const componentType of sortedTypes) {
-        const archetypes = this.archetypesByComponent.get(componentType) || [];
-        archetypes.push(newArchetype);
-        this.archetypesByComponent.set(componentType, archetypes);
-      }
-      for (const query of this.queries) {
-        query.checkNewArchetype(newArchetype);
-      }
-      return newArchetype;
-    });
-  }
-  trackEntityReference(sourceEntityId, componentType, targetEntityId) {
-    if (!this.entityReferences.has(targetEntityId)) {
-      this.entityReferences.set(targetEntityId, new MultiMap);
-    }
-    this.entityReferences.get(targetEntityId).add(sourceEntityId, componentType);
-  }
-  untrackEntityReference(sourceEntityId, componentType, targetEntityId) {
-    const references = this.entityReferences.get(targetEntityId);
-    if (references) {
-      references.remove(sourceEntityId, componentType);
-      if (references.keyCount === 0) {
-        this.entityReferences.delete(targetEntityId);
-      }
-    }
-  }
-  getEntityReferences(targetEntityId) {
-    return this.entityReferences.get(targetEntityId) ?? new MultiMap;
-  }
-  cleanupEmptyArchetype(archetype) {
-    if (archetype.getEntities().length > 0) {
-      return;
-    }
-    const index = this.archetypes.indexOf(archetype);
-    if (index !== -1) {
-      this.archetypes.splice(index, 1);
-    }
-    const hashKey = this.createArchetypeSignature(archetype.componentTypes);
-    this.archetypeBySignature.delete(hashKey);
-    for (const componentType of archetype.componentTypes) {
-      const archetypes = this.archetypesByComponent.get(componentType);
-      if (archetypes) {
-        const compIndex = archetypes.indexOf(archetype);
-        if (compIndex !== -1) {
-          archetypes.splice(compIndex, 1);
-          if (archetypes.length === 0) {
-            this.archetypesByComponent.delete(componentType);
-          }
-        }
-      }
-    }
-    for (const query of this.queries) {
-      query.removeArchetype(archetype);
-    }
-  }
-  triggerLifecycleHooks(entityId, addedComponents, removedComponents) {
-    for (const [componentType, component2] of addedComponents) {
-      const directHooks = this.hooks.get(componentType);
-      if (directHooks) {
-        for (const lifecycleHook of directHooks) {
-          lifecycleHook.on_set?.(entityId, componentType, component2);
-        }
-      }
-      const detailedType = getDetailedIdType(componentType);
-      if (detailedType.type === "entity-relation" || detailedType.type === "component-relation" || detailedType.type === "wildcard-relation") {
-        const wildcardRelationId = relation(detailedType.componentId, "*");
-        const wildcardHooks = this.hooks.get(wildcardRelationId);
-        if (wildcardHooks) {
-          for (const lifecycleHook of wildcardHooks) {
-            lifecycleHook.on_set?.(entityId, componentType, component2);
-          }
-        }
-      }
-    }
-    for (const [componentType, component2] of removedComponents) {
-      const directHooks = this.hooks.get(componentType);
-      if (directHooks) {
-        for (const lifecycleHook of directHooks) {
-          lifecycleHook.on_remove?.(entityId, componentType, component2);
-        }
-      }
-      const detailedType = getDetailedIdType(componentType);
-      if (detailedType.type === "entity-relation" || detailedType.type === "component-relation" || detailedType.type === "wildcard-relation") {
-        const wildcardRelationId = relation(detailedType.componentId, "*");
-        const wildcardHooks = this.hooks.get(wildcardRelationId);
-        if (wildcardHooks) {
-          for (const hook of wildcardHooks) {
-            hook.on_remove?.(entityId, componentType, component2);
-          }
-        }
-      }
-    }
-  }
-  serialize() {
-    const entities = [];
-    for (const archetype of this.archetypes) {
-      const dumpedEntities = archetype.dump();
-      for (const { entity, components } of dumpedEntities) {
-        entities.push({
-          id: entity,
-          components: Array.from(components.entries()).map(([rawType, value]) => {
-            const detailedType = getDetailedIdType(rawType);
-            let type = rawType;
-            let componentName;
-            switch (detailedType.type) {
-              case "component":
-                type = getComponentNameById(rawType) || rawType;
-                break;
-              case "entity-relation":
-                componentName = getComponentNameById(detailedType.componentId);
-                if (componentName) {
-                  type = { component: componentName, target: detailedType.targetId };
-                }
-                break;
-              case "component-relation":
-                componentName = getComponentNameById(detailedType.componentId);
-                if (componentName) {
-                  type = {
-                    component: componentName,
-                    target: getComponentNameById(detailedType.targetId) || detailedType.targetId
-                  };
-                }
-                break;
-            }
-            return { type, value: value === MISSING_COMPONENT ? undefined : value };
-          })
-        });
-      }
-    }
-    return {
-      version: 1,
-      entityManager: this.entityIdManager.serializeState(),
-      entities
-    };
-  }
-}
-export {
-  relation,
-  isWildcardRelationId,
-  isRelationId,
-  isOptionalEntityId,
-  isEntityId,
-  isComponentId,
-  inspectEntityId,
-  getIdType,
-  getDetailedIdType,
-  getComponentNameById,
-  getComponentIdByName,
-  decodeRelationId,
-  createEntityId,
-  createComponentId,
-  component,
-  World,
-  WILDCARD_TARGET_ID,
-  SystemScheduler,
-  RELATION_SHIFT,
-  Query,
-  MISSING_COMPONENT,
-  INVALID_COMPONENT_ID,
-  EntityIdManager,
-  ENTITY_ID_START,
-  ComponentIdAllocator,
-  COMPONENT_ID_MAX,
-  Archetype
-};