@draug/engine 1.0.21 → 1.0.23

package/dist/index.cjs

@@ -1,1034 +1,78 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Asset: () => Asset,
-  AssetState: () => AssetState,
-  AssetStorage: () => AssetStorage,
-  AssetsManager: () => AssetsManager,
-  Clock: () => Clock,
-  Commands: () => Commands,
-  Component: () => Component,
-  ComponentAlreadyRegisteredError: () => ComponentAlreadyRegisteredError,
-  ComponentStorage: () => ComponentStorage,
-  ComponentsManager: () => ComponentsManager,
-  DAGNode: () => DAGNode,
-  Engine: () => Engine,
-  EntitiesManager: () => EntitiesManager,
-  EntityMaskNotFoundError: () => EntityMaskNotFoundError,
-  EntityRef: () => EntityRef,
-  ErrDAGCycleDetected: () => ErrDAGCycleDetected,
-  ErrMissingPluginMetadata: () => ErrMissingPluginMetadata,
-  ErrMissingSystemMetadata: () => ErrMissingSystemMetadata,
-  ErrNotAPlugin: () => ErrNotAPlugin,
-  ErrNotASystem: () => ErrNotASystem,
-  ErrPluginNotInit: () => ErrPluginNotInit,
-  ErrUnknownPlugin: () => ErrUnknownPlugin,
-  EventBuffer: () => EventBuffer,
-  EventBus: () => EventBus,
-  LogLevel: () => LogLevel,
-  Loop: () => Loop,
-  ObjectPool: () => ObjectPool,
-  Plugin: () => Plugin,
-  PluginBase: () => PluginBase,
-  PluginError: () => PluginError,
-  PluginsManager: () => PluginsManager,
-  Resource: () => Resource,
-  ResourcesManager: () => ResourcesManager,
-  Runtime: () => Runtime,
-  System: () => System,
-  SystemBase: () => SystemBase,
-  SystemError: () => SystemError,
-  SystemPhase: () => SystemPhase,
-  SystemsManager: () => SystemsManager,
-  UnregisteredComponentStorageError: () => UnregisteredComponentStorageError,
-  VisitedState: () => VisitedState,
-  World: () => World3,
-  createEventKey: () => createEventKey,
-  entry: () => entry,
-  getPluginMetadata: () => getPluginMetadata,
-  getResourceMetadata: () => getResourceMetadata,
-  getSystemMetadata: () => getSystemMetadata,
-  isPlugin: () => isPlugin,
-  isSystem: () => isSystem,
-  topologicalSort: () => topologicalSort
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/core/graph/dag.ts
-var VisitedState = /* @__PURE__ */ ((VisitedState2) => {
-  VisitedState2[VisitedState2["Unvisited"] = 0] = "Unvisited";
-  VisitedState2[VisitedState2["Visiting"] = 1] = "Visiting";
-  VisitedState2[VisitedState2["Visited"] = 2] = "Visited";
-  return VisitedState2;
-})(VisitedState || {});
-var DAGNode = class {
-  data;
-  vertices = [];
-  constructor(data, vertices) {
-    this.data = data;
-    if (vertices)
-      this.vertices = vertices;
-  }
-};
-var ErrDAGCycleDetected = class extends Error {
-  constructor() {
-    super(`Cycle detected!`);
-  }
-};
-function topologicalSort(nodes) {
-  const visited = /* @__PURE__ */ new Map();
-  const result = [];
-  const dfs = (node) => {
-    const state = visited.get(node) ?? 0 /* Unvisited */;
-    if (state === 2 /* Visited */) return;
-    if (state === 1 /* Visiting */) {
-      throw new ErrDAGCycleDetected();
-    }
-    visited.set(node, 1 /* Visiting */);
-    for (const child of node.vertices) {
-      dfs(child);
-    }
-    visited.set(node, 2 /* Visited */);
-    result.push(node);
-  };
-  for (const node of nodes) {
-    dfs(node);
-  }
-  return result.reverse();
-}
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class; var _class2; var _class3; var _class4; var _class5; var _class6;
+
+var _chunkCNBFO5GJcjs = require('./chunk-CNBFO5GJ.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-// src/ecs/system.ts
-var SystemError = class extends Error {
-  constructor(target) {
-    super(`[System Error] (System "${target.name}".`);
-  }
-};
-var ErrNotASystem = class extends Error {
-  constructor(target) {
-    super(`Provided class "${target.name}" is not a System! Extend your class from SystemBase.`);
-  }
-};
-var ErrMissingSystemMetadata = class extends SystemError {
-  constructor(target) {
-    super(target);
-    this.message = `${this.message}: Missing system metadata! Define system class with @System decorator.`;
-  }
-};
-var SystemPhase = /* @__PURE__ */ ((SystemPhase2) => {
-  SystemPhase2[SystemPhase2["PRE"] = 0] = "PRE";
-  SystemPhase2[SystemPhase2["MAIN"] = 1] = "MAIN";
-  SystemPhase2[SystemPhase2["POST"] = 2] = "POST";
-  return SystemPhase2;
-})(SystemPhase || {});
-var SystemMetadataSymbol = /* @__PURE__ */ Symbol("system");
-function System(props) {
-  return (target) => {
-    const systemTarget = target;
-    if ("__proto__" in systemTarget && systemTarget.__proto__ !== SystemBase) {
-      throw new ErrNotASystem(target);
-    }
-    const query = { ...props.query };
-    const requiredComponents = new Set(props.requiredComponents);
-    const computeAfter = new Set(props.computeAfter);
-    const phase = props.phase ?? 1 /* MAIN */;
-    const name = props.name ?? target.name;
-    const metadata = { query, requiredComponents, computeAfter, phase, name };
-    systemTarget[SystemMetadataSymbol] = metadata;
-  };
-}
-function getSystemMetadata(system) {
-  if (hasMetadata(system)) {
-    return system[SystemMetadataSymbol];
-  }
-  throw new ErrMissingSystemMetadata(system);
-}
-function hasMetadata(ctor) {
-  return SystemMetadataSymbol in ctor;
-}
-function isSystem(ctor) {
-  return hasMetadata(ctor);
-}
-var SystemBase = class {
-};
-var SystemsManager = class {
-  constructor(world, logger) {
-    this.world = world;
-    this.logger = logger;
-  }
-  world;
-  logger;
-  systems_ = /* @__PURE__ */ new Map();
-  executionOrder_ = [];
-  requiredComponents_ = /* @__PURE__ */ new Set();
-  dirty_ = true;
-  getRequiredComponents() {
-    return Array.from(this.requiredComponents_);
-  }
-  register(sys) {
-    const ctor = sys.constructor;
-    if (this.systems_.has(ctor)) throw new Error("Duplicate system");
-    const { query, requiredComponents } = getSystemMetadata(ctor);
-    this.systems_.set(ctor, sys);
-    const q = query;
-    for (const c of q.include ?? [])
-      this.requiredComponents_.add(c);
-    for (const c of q.exclude ?? [])
-      this.requiredComponents_.add(c);
-    for (const c of q.anyOf ?? [])
-      this.requiredComponents_.add(c);
-    for (const c of requiredComponents)
-      this.requiredComponents_.add(c);
-    const meta = getSystemMetadata(ctor);
-    this.logger.debug(() => `[Systems]: system "${meta.name}" was registered`);
-  }
-  build() {
-    this.buildSystemsArray();
-    for (const sys of this.systems_.values()) {
-      sys.onInit?.({ world: this.world, logger: this.logger });
-    }
-    this.logger.debug(() => `Built ${this.systems_.size} systems`);
-    this.dirty_ = false;
-  }
-  rebuild() {
-    this.build();
-  }
-  get(ctor) {
-    const s = this.systems_.get(ctor);
-    if (!s)
-      throw new Error("System not registered");
-    return s;
-  }
-  update(time) {
-    if (this.dirty_)
-      this.rebuild();
-    this.world.events.swapAll();
-    for (const s of this.executionOrder_) {
-      const { query } = getSystemMetadata(s.constructor);
-      const entities = this.world.query(query);
-      s.compute({
-        world: this.world,
-        entities,
-        time,
-        logger: this.logger
-      });
-    }
-  }
-  buildSystemsArray() {
-    const pre = [];
-    const main = [];
-    const post = [];
-    const map = /* @__PURE__ */ new Map();
-    for (const [ctor, system] of this.systems_.entries()) {
-      const meta = getSystemMetadata(ctor);
-      switch (meta.phase) {
-        case 0 /* PRE */:
-          pre.push(system);
-          break;
-        case 1 /* MAIN */:
-          post.push(system);
-          break;
-        default:
-          main.push(system);
-          map.set(ctor, new DAGNode(system));
-          break;
-      }
-    }
-    for (const ctor of map.keys()) {
-      const currentNode = map.get(ctor);
-      const { computeAfter } = getSystemMetadata(ctor);
-      for (const depCtor of computeAfter ?? []) {
-        const depNode = map.get(depCtor);
-        if (!depNode) {
-          throw new Error(`Dependency ${depCtor.name} not registered`);
-        }
-        depNode.vertices.push(currentNode);
-      }
-    }
-    this.executionOrder_ = [
-      ...pre,
-      ...topologicalSort(map.values()).map((x) => x.data),
-      ...post
-    ];
-  }
-};
 
-// src/ecs/entity.ts
-var UnregisteredComponentStorageError = class extends Error {
-  constructor(component) {
-    super(`Cannot get storage for component ${component.name}. Seems like it's not registered in world.`);
-  }
-};
-var EntityMaskNotFoundError = class extends Error {
-  constructor(id2) {
-    super(`Cannot find bitmask for entity [${id2}]. Seems like it's not registered in the EntityManager.`);
-  }
-};
-var EntitiesManager = class {
-  constructor(logger) {
-    this.logger = logger;
-  }
-  logger;
-  id_ = 0;
-  nextId() {
-    return ++this.id_;
-  }
-  create() {
-    const id2 = this.nextId();
-    this.logger.debug(() => `[Entities]: Created new entity with ID ${id2}`);
-    return id2;
-  }
-};
-var EntityRef = class {
-  constructor(world, id2) {
-    this.world = world;
-    this.id = id2;
-  }
-  world;
-  id;
-  with(...components) {
-    return components.map((c) => {
-      const s = this.world.components.getStorage(c);
-      return s.tryGet(this.id);
-    });
-  }
-};
 
-// src/ecs/constant.ts
-var ECS_DEFAULTS = {
-  MAX_ENTITY_COUNT: Math.pow(2, 12)
-};
 
-// src/ecs/events-buffer.ts
-var EventBuffer = class {
-  readBuf = [];
-  writeBuf = [];
-  write(event) {
-    this.writeBuf.push(event);
-  }
-  /**
-   * Advances the buffer to the next frame.
-   *
-   * Performs a double-buffer flip:
-   * - Promotes all events written during the previous frame (`writeBuf`)
-   *   to be readable in the current frame (`readBuf`).
-   * - Reuses the previous `readBuf` as the new `writeBuf` and clears it
-   *   to collect events for the next frame.
-   *
-   * After calling this method:
-   * - `get()` will return a stable snapshot of events produced in the previous frame.
-   * - `add()` will write into an empty buffer for the current frame.
-   *
-   * Guarantees:
-   * - No events written during the current frame are visible until the next `swap()`.
-   * - Readers observe a consistent, immutable snapshot within a frame.
-   *
-   * Expected to be called exactly once per frame, before system execution.
-  */
-  swap() {
-    const tmp = this.readBuf;
-    this.readBuf = this.writeBuf;
-    this.writeBuf = tmp;
-    this.writeBuf.length = 0;
-  }
-  read() {
-    return this.readBuf;
-  }
-  size() {
-    return this.readBuf.length;
-  }
-};
-function createEventKey(description) {
-  return Symbol(description);
-}
-var EventBus = class {
-  storage = /* @__PURE__ */ new Map();
-  swapAll() {
-    this.storage.forEach((s) => s.swap());
-  }
-  getBuffer(key) {
-    let buf = this.storage.get(key);
-    if (!buf) {
-      buf = new EventBuffer();
-      this.storage.set(key, buf);
-    }
-    return buf;
-  }
-};
 
-// src/core/memory/pool.ts
-var ObjectPool = class {
-  pool_;
-  factory_;
-  cursor_;
-  constructor(factory, initialSize = 0) {
-    this.pool_ = new Array(initialSize);
-    this.factory_ = factory;
-    this.cursor_ = initialSize - 1;
-  }
-  acquire() {
-    if (this.cursor_ >= 0) {
-      return this.pool_[this.cursor_--];
-    }
-    return this.factory_();
-  }
-  release(obj) {
-    this.pool_[++this.cursor_] = obj;
-  }
-  grow() {
-    const oldSize = this.pool_.length;
-    const newSize = oldSize * 2;
-    for (let i = oldSize; i < newSize; i++) this.pool_[i] = this.factory_();
-    this.cursor_ = newSize - 1;
-    this.pool_.length = newSize;
-  }
-};
 
-// src/ecs/components/component-storage.ts
-var import_bitmap_index = require("bitmap-index");
-var ComponentStorage = class {
-  bits_;
-  data_ = [];
-  entityIds_ = [];
-  indexMap_ = /* @__PURE__ */ new Map();
-  pool_;
-  id_ = 0;
-  size_ = 0;
-  cls;
-  constructor(cap = ECS_DEFAULTS.MAX_ENTITY_COUNT, factory, cls) {
-    this.bits_ = new import_bitmap_index.Bitmap(cap);
-    this.pool_ = new ObjectPool(factory, 0);
-    this.cls = cls;
-  }
-  bitmap() {
-    return this.bits_;
-  }
-  get id() {
-    return this.id_;
-  }
-  _internalSetId(id2) {
-    return this.id_ = id2;
-  }
-  add(id2, initFn) {
-    if (this.indexMap_.has(id2)) {
-      throw new Error(`[ComponentStorage "${this.cls.name}"]: Entity ${id2} already has this component`);
-    }
-    const obj = this.pool_.acquire();
-    initFn?.(obj);
-    const index = this.data_.length;
-    this.data_.push(obj);
-    this.entityIds_.push(id2);
-    this.indexMap_.set(id2, index);
-    this.bits_.set(id2);
-    this.size_++;
-    return obj;
-  }
-  remove(id2) {
-    const index = this.indexMap_.get(id2);
-    if (index === void 0) return;
-    this.bits_.remove(id2);
-    const lastIndex = this.data_.length - 1;
-    const lastEntityId = this.entityIds_[lastIndex];
-    const removedObj = this.data_[index];
-    if (index !== lastIndex) {
-      this.data_[index] = this.data_[lastIndex];
-      this.entityIds_[index] = lastEntityId;
-      this.indexMap_.set(lastEntityId, index);
-    }
-    this.data_.pop();
-    this.entityIds_.pop();
-    this.indexMap_.delete(id2);
-    this.pool_.release(removedObj);
-    this.size_--;
-  }
-  get(id2) {
-    const index = this.indexMap_.get(id2);
-    return index !== void 0 ? this.data_[index] : null;
-  }
-  tryGet(id2) {
-    const index = this.indexMap_.get(id2);
-    if (index === void 0)
-      throw new Error(`[ComponentStorage "${this.cls.name}"]: Requesting non-existing item with ID ${id2}.`);
-    return this.data_[index];
-  }
-  writeComponentsToBuf(ids, out) {
-    let len = 0;
-    for (const id2 of ids) {
-      const index = this.indexMap_.get(id2);
-      if (index !== void 0) out[len++] = this.data_[index];
-    }
-    return len;
-  }
-  has(id2) {
-    return this.bits_.contains(id2);
-  }
-  size() {
-    return this.size_;
-  }
-  forEach(cb) {
-    for (const id2 of this.entityIds_) {
-      cb(id2);
-    }
-  }
-};
 
-// src/ecs/components/utils.ts
-var registry = /* @__PURE__ */ new Map();
-var id = 0;
-var ComponentMetadataSymbol = /* @__PURE__ */ Symbol("component");
-function Component(options) {
-  return (target) => {
-    const metadata = {
-      name: options.name,
-      id: ++id
-    };
-    registry.set(target, metadata.id);
-    target[ComponentMetadataSymbol] = metadata;
-  };
-}
-function getComponentId(ctor) {
-  const id2 = registry.get(ctor);
-  if (id2 === void 0) {
-    throw new Error(`Component not registered: ${ctor.name}`);
-  }
-  return id2;
-}
-var ErrNotComponent = class extends Error {
-  constructor(ctor) {
-    super(`Class ${ctor.name} is not a Component. Use @Component decorator to define components.`);
-  }
-};
-function getComponentMetadata(component) {
-  if (isComponent(component)) {
-    return component[ComponentMetadataSymbol];
-  }
-  throw new ErrNotComponent(component);
-}
-function isComponent(ctor) {
-  return ComponentMetadataSymbol in ctor;
-}
 
-// src/ecs/components/manager.ts
-var ComponentAlreadyRegisteredError = class extends Error {
-  constructor(component) {
-    super(`Component ${component.name} already registered!`);
-  }
-};
-var ComponentsManager = class {
-  constructor(logger, maxEntityCount = ECS_DEFAULTS.MAX_ENTITY_COUNT) {
-    this.logger = logger;
-    this.maxEntityCount = maxEntityCount;
-  }
-  logger;
-  maxEntityCount;
-  storages_ = /* @__PURE__ */ new Map();
-  currId_ = 0;
-  nextId() {
-    return ++this.currId_;
-  }
-  register(component, opts) {
-    if (this.storages_.has(component))
-      return this.storages_.get(component);
-    const store = this.createComponentStore(component, opts);
-    this.storages_.set(component, store);
-    const meta = getComponentMetadata(component);
-    this.logger.debug(() => `[Components]: Registered component "${meta.name}"`);
-    return store;
-  }
-  createComponentStore(component, opts) {
-    const factory = opts?.factory ?? ((...args) => new component(...args));
-    const store = new ComponentStorage(this.maxEntityCount, factory, component);
-    store._internalSetId(this.nextId());
-    return store;
-  }
-  getStorage(component) {
-    const store = this.storages_.get(component);
-    if (store === void 0)
-      throw new UnregisteredComponentStorageError(component);
-    return store;
-  }
-  getComponentId(ctor) {
-    return getComponentId(ctor);
-  }
-};
 
-// src/ecs/resources/resources.ts
-var ResourceMetadataSymbol = /* @__PURE__ */ Symbol("resource");
-function Resource(params) {
-  return (target) => {
-    const metadata = {
-      name: params.name
-    };
-    target[ResourceMetadataSymbol] = metadata;
-  };
-}
-var ErrNotResource = class extends Error {
-  constructor(ctor) {
-    super(`Class ${ctor.name} is not a Resource. Use @Resource decorator to define resources.`);
-  }
-};
-function getResourceMetadata(resource) {
-  if (isResource(resource)) {
-    return resource[ResourceMetadataSymbol];
-  }
-  throw new ErrNotResource(resource);
-}
-function isResource(ctor) {
-  return ResourceMetadataSymbol in ctor;
-}
-var ResourcesManager = class {
-  constructor(logger) {
-    this.logger = logger;
-  }
-  logger;
-  items_ = /* @__PURE__ */ new Map();
-  insert(type, value) {
-    this.items_.set(type, value);
-    const metadata = getResourceMetadata(type);
-    this.logger.debug(() => `[Resources]: Inserted new Resource "${metadata.name}"`);
-    return value;
-  }
-  get(type) {
-    const value = this.items_.get(type);
-    const meta = getResourceMetadata(type);
-    if (!value)
-      throw new Error(`Resource of class ${meta.name} does not exist!`);
-    return value;
-  }
-  getOrInsert(type, factory) {
-    let value = this.items_.get(type) ?? null;
-    if (value === null) {
-      value = factory();
-      this.insert(type, value);
-    }
-    return value;
-  }
-  remove(type) {
-    const meta = getResourceMetadata(type);
-    this.logger.debug(() => `[Resources]: Removed resource "${meta.name}"`);
-    this.items_.delete(type);
-  }
-};
 
-// src/ecs/command.ts
-function entry(component, init = () => {
-}) {
-  return [component, init];
-}
-var Commands = class {
-  constructor(world, logger) {
-    this.world = world;
-    this.logger = logger;
-  }
-  world;
-  logger;
-  commandsQueue_ = [];
-  add(cmd) {
-    this.commandsQueue_.push(cmd);
-  }
-  flush(world) {
-    for (const cmd of this.commandsQueue_)
-      cmd(world);
-    this.commandsQueue_.length = 0;
-  }
-  createEntity(...entries) {
-    const id2 = this.world.entities.create();
-    const cmd = (world) => {
-      for (const [cls, initFn] of entries) {
-        world.addComponent(id2, cls, initFn);
-      }
-    };
-    this.add(cmd);
-    this.logger.debug(() => {
-      const components = entries.map((x) => getComponentMetadata(x[0]).name).join(", ");
-      return `[Commands.createEntity]: Created new entity with ID ${id2}. Linked components: [${components}]`;
-    });
-    return id2;
-  }
-};
 
-// src/ecs/query.ts
-var import_bitmap_index2 = require("bitmap-index");
-var QueryManager = class {
-  constructor(world) {
-    this.world = world;
-  }
-  world;
-  cache = /* @__PURE__ */ new Map();
-  get(params) {
-    const key = this.getKey(params);
-    let entry2 = this.cache.get(key);
-    if (!entry2) {
-      entry2 = {
-        params,
-        bitmap: this.compute(params),
-        dirty: false,
-        deps: this.collectDeps(params)
-      };
-      this.cache.set(key, entry2);
-    }
-    if (entry2.dirty) {
-      entry2.bitmap = this.compute(entry2.params);
-      entry2.dirty = false;
-    }
-    let targetBitmap = entry2.bitmap;
-    if (params.excludeEntitiesIds?.length) {
-      targetBitmap = entry2.bitmap.clone();
-      const excludeBm = new import_bitmap_index2.Bitmap();
-      for (const id2 of params.excludeEntitiesIds) {
-        excludeBm.set(id2);
-      }
-      targetBitmap.andNot(excludeBm);
-    }
-    if (params.filter) {
-      const result = [];
-      targetBitmap.range((id2) => {
-        if (params.filter(id2)) result.push(id2);
-      });
-      return result;
-    }
-    return this.extractIds(targetBitmap);
-  }
-  invalidate(component) {
-    for (const entry2 of this.cache.values()) {
-      if (entry2.deps.has(component)) {
-        entry2.dirty = true;
-      }
-    }
-  }
-  getKey(q) {
-    return [
-      this.ids(q.include),
-      this.ids(q.exclude),
-      this.ids(q.anyOf)
-    ].join("|");
-  }
-  ids(arr) {
-    if (!arr || arr.length === 0) return "";
-    return arr.map((c) => this.world.components.getComponentId(c)).sort((a, b) => a - b).join(",");
-  }
-  collectDeps(q) {
-    const set = /* @__PURE__ */ new Set();
-    q.include?.forEach((c) => set.add(c));
-    q.exclude?.forEach((c) => set.add(c));
-    q.anyOf?.forEach((c) => set.add(c));
-    return set;
-  }
-  compute(params) {
-    let result = this.combineBitmaps(params.include, "and");
-    const any = this.combineBitmaps(params.anyOf, "or");
-    if (any) {
-      result = result ? result.and(any) : any;
-    }
-    if (!result) {
-      return new import_bitmap_index2.Bitmap();
-    }
-    this.applyExclusions(result, params.exclude);
-    return result;
-  }
-  combineBitmaps(components, op) {
-    if (!components?.length) return null;
-    let result = null;
-    let hasAtLeastOneValid = false;
-    for (const c of components) {
-      const bm = this.world.components.getStorage(c)?.bitmap();
-      if (!bm) {
-        if (op === "and") {
-          return new import_bitmap_index2.Bitmap();
-        }
-        continue;
-      }
-      hasAtLeastOneValid = true;
-      if (!result) {
-        result = bm.clone();
-      } else {
-        op === "and" ? result.and(bm) : result.or(bm);
-      }
-    }
-    if (op === "or" && !hasAtLeastOneValid) {
-      return new import_bitmap_index2.Bitmap();
-    }
-    return result;
-  }
-  applyExclusions(target, excludeComponents) {
-    if (excludeComponents?.length) {
-      for (const c of excludeComponents) {
-        const bm = this.world.components.getStorage(c)?.bitmap();
-        if (bm) target.andNot(bm);
-      }
-    }
-  }
-  extractIds(bitmap) {
-    const result = [];
-    bitmap.range((id2) => {
-      result.push(id2);
-    });
-    return result;
-  }
-};
 
-// src/ecs/plugin/plugin.ts
-var PluginMetadataSymbol = /* @__PURE__ */ Symbol("plugin");
-function Plugin(metadata) {
-  return (target) => {
-    if ("__proto__" in target && target.__proto__ !== PluginBase)
-      throw new ErrNotAPlugin(target);
-    target[PluginMetadataSymbol] = metadata;
-  };
-}
-function getPluginMetadata(plugin) {
-  if (hasMetadata2(plugin)) {
-    return plugin[PluginMetadataSymbol];
-  }
-  throw new ErrMissingPluginMetadata(plugin);
-}
-function hasMetadata2(ctor) {
-  return PluginMetadataSymbol in ctor;
-}
-function isPlugin(ctor) {
-  return hasMetadata2(ctor);
-}
-var PluginBase = class {
-  onPluginLoad;
-  onPluginUnload;
-  onAfterWorldInit;
-};
-var PluginError = class extends Error {
-  constructor(pluginId) {
-    super(`Plugin error! Plugin [${pluginId}]`);
-  }
-};
-var ErrNotAPlugin = class extends Error {
-  constructor(target) {
-    super(`Provided class ${target.name} is not a Plugin! Every plugin must extends of PluginBase class.`);
-  }
-};
-var ErrMissingPluginMetadata = class extends Error {
-  constructor(plugin) {
-    super(`Provided class ${plugin.name}: Missing plugin metadata! Define plugin class with @Plugin decorator.`);
-  }
-};
-var ErrUnknownPlugin = class extends PluginError {
-  constructor(pluginId) {
-    super(pluginId);
-    this.message = `${super.message}: Plugin not found in manager.`;
-  }
-};
-var ErrPluginNotInit = class extends PluginError {
-  constructor(pluginId) {
-    super(pluginId);
-    this.message = `${super.message}: Plugin not initiated yet. You must use PluginsManager.build() before getting instance.`;
-  }
-};
-var ErrMissingPluginDependency = class extends PluginError {
-  constructor(pluginId, missingDepId) {
-    super(pluginId);
-    this.message = `${super.message}: Missing required dependency [${missingDepId}]. Install it first.`;
-  }
-};
-var ErrDAGCycleDetectedPlugin = class extends Error {
-  constructor() {
-    super(`Cycle detected in plugin dependencies!`);
-  }
-};
-var PluginsManager = class {
-  constructor(logger) {
-    this.logger = logger;
-  }
-  logger;
-  plugins_ = /* @__PURE__ */ new Map();
-  isInitiated_ = false;
-  install(plugin, ...constructorProps) {
-    if (!isPlugin(plugin))
-      throw new ErrMissingPluginMetadata(plugin);
-    const metadata = getPluginMetadata(plugin);
-    if (this.plugins_.has(plugin))
-      return;
-    const entry2 = {
-      ctor: plugin,
-      ctorParams: constructorProps,
-      metadata
-    };
-    this.plugins_.set(plugin, entry2);
-    this.logger.debug(() => `[Plugins]: Installed plugin ${metadata.name} (${metadata.version})`);
-  }
-  build() {
-    if (this.plugins_.size === 0) {
-      return;
-    }
-    const nodes = /* @__PURE__ */ new Map();
-    for (const id2 of this.plugins_.keys()) {
-      nodes.set(id2, new DAGNode(id2));
-    }
-    for (const [plugin, entry2] of this.plugins_) {
-      const node = nodes.get(plugin);
-      const depPlugins = entry2.metadata.dependencies?.plugins ?? [];
-      for (const dep of depPlugins) {
-        const depNode = nodes.get(dep.plugin);
-        if (!depNode) {
-          throw new ErrMissingPluginDependency(plugin, dep.plugin);
-        }
-        depNode.vertices.push(node);
-      }
-    }
-    let sortedNodes;
-    try {
-      sortedNodes = topologicalSort(nodes.values());
-    } catch (e) {
-      if (e instanceof ErrDAGCycleDetected) {
-        throw new ErrDAGCycleDetectedPlugin();
-      }
-      throw e;
-    }
-    for (const node of sortedNodes) {
-      const entry2 = this.plugins_.get(node.data);
-      const { ctor, ctorParams } = entry2;
-      const instance = new ctor(...ctorParams);
-      entry2.instance = instance;
-      instance.onPluginLoad?.();
-    }
-    this.isInitiated_ = true;
-    this.logger.debug(() => `[Plugins]: Plugins built successfully!`);
-  }
-  /**
-   * @internal
-   */
-  __internal__onAfterWorldInit(world) {
-    for (const p of this.plugins_.values()) {
-      p.instance?.onAfterWorldInit?.(world);
-    }
-  }
-  getPluginMetadata(plugin) {
-    const entry2 = this.plugins_.get(plugin);
-    if (!entry2) throw new ErrUnknownPlugin(plugin);
-    return entry2.metadata;
-  }
-  getPluginInstance(plugin) {
-    const entry2 = this.plugins_.get(plugin);
-    if (!entry2) throw new ErrUnknownPlugin(plugin);
-    if (!entry2.instance) throw new ErrPluginNotInit(plugin);
-    if (!this.isInitiated_) {
-      throw new ErrPluginNotInit(plugin);
-    }
-    return entry2.instance;
-  }
-};
 
-// src/ecs/world.ts
-var World3 = class {
-  entities;
-  components;
-  systems;
-  events;
-  resources;
-  commands;
-  queries;
-  plugins;
-  logger;
-  entityRefs_ = /* @__PURE__ */ new Map();
-  updatesCount_ = 0;
-  get updatesCount() {
-    return this.updatesCount_;
-  }
-  constructor(params) {
-    this.entities = new EntitiesManager(params.logger);
-    this.components = new ComponentsManager(params.logger, params.maxEntityCount ?? ECS_DEFAULTS.MAX_ENTITY_COUNT);
-    this.systems = new SystemsManager(this, params.logger);
-    this.events = new EventBus();
-    this.resources = new ResourcesManager(params.logger);
-    this.commands = new Commands(this, params.logger);
-    this.queries = new QueryManager(this);
-    this.plugins = new PluginsManager(params.logger);
-    this.logger = params.logger;
-  }
-  getEntityRef(id2) {
-    let ref = this.entityRefs_.get(id2);
-    if (!ref) {
-      ref = new EntityRef(this, id2);
-      this.entityRefs_.set(id2, ref);
-    }
-    return ref;
-  }
-  query(params) {
-    return this.queries.get(params);
-  }
-  removeComponent(entity, component) {
-    const id2 = typeof entity === "number" ? entity : entity.id;
-    const storage = this.components.getStorage(component);
-    storage.remove(id2);
-    this.queries.invalidate(component);
-  }
-  addComponent(entity, component, initFn) {
-    const storage = this.components.getStorage(component);
-    let id2;
-    if (typeof entity === "number") {
-      id2 = entity;
-    } else {
-      id2 = entity.id;
-    }
-    const c = storage.add(id2, (o) => {
-      if (initFn) {
-        initFn(o);
-      }
-      return o;
-    });
-    this.queries.invalidate(component);
-    return c;
-  }
-  update(clock) {
-    this.systems.update(clock.getTime());
-    this.commands.flush(this);
-    this.updatesCount_++;
-  }
-  build() {
-    this.plugins.build();
-    this.logger.debug(() => "World was built successfully");
-  }
-};
+
+
+
+var _chunkGUD2YACAcjs = require('./chunk-GUD2YACA.cjs');
 
 // src/runtime/runtime.ts
 var Runtime = class {
   constructor(loop) {
     this.loop = loop;
   }
-  loop;
+  
   run(world) {
     this.loop.start(world);
   }
 };
 
 // src/runtime/clock.ts
-var Clock = class {
-  constructor(timeSource_) {
+var Clock = (_class = class {
+  constructor(timeSource_) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
     this.timeSource_ = timeSource_;
     this.lastTimeMs_ = timeSource_.now();
   }
-  timeSource_;
-  lastTimeMs_;
-  ellapsedTime_ = 0;
-  delta_ = 0;
-  time_ = {
+  
+  
+  __init() {this.ellapsedTime_ = 0}
+  __init2() {this.delta_ = 0}
+  __init3() {this.time_ = {
     delta: 0,
     elapsed: 0
-  };
+  }}
   get deltaMs() {
     return this.delta_;
   }
@@ -1045,19 +89,19 @@ var Clock = class {
   getTime() {
     return this.time_;
   }
-};
+}, _class);
 
 // src/runtime/loop.ts
-var Loop = class {
-  constructor(clock, stepFn, platformLoop) {
+var Loop = (_class2 = class {
+  constructor(clock, stepFn, platformLoop) {;_class2.prototype.__init4.call(this);
     this.clock = clock;
     this.stepFn = stepFn;
     this.platformLoop = platformLoop;
   }
-  clock;
-  stepFn;
-  platformLoop;
-  running = false;
+  
+  
+  
+  __init4() {this.running = false}
   start(world) {
     this.running = true;
     const loop = () => {
@@ -1071,7 +115,7 @@ var Loop = class {
   stop() {
     this.running = false;
   }
-};
+}, _class2);
 
 // src/assets/assets.ts
 var AssetState = /* @__PURE__ */ ((AssetState2) => {
@@ -1080,21 +124,21 @@ var AssetState = /* @__PURE__ */ ((AssetState2) => {
   AssetState2[AssetState2["READY"] = 3] = "READY";
   return AssetState2;
 })(AssetState || {});
-var Asset = class {
-  constructor(id2, url, loader, disposer) {
-    this.id = id2;
+var Asset = (_class3 = class {
+  constructor(id, url, loader, disposer) {;_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);
+    this.id = id;
     this.url = url;
     this.loader = loader;
     this.disposer = disposer;
   }
-  id;
-  url;
-  loader;
-  disposer;
-  data_ = null;
-  state_ = 1 /* NOT_READY */;
-  loading_ = null;
-  disposed_ = false;
+  
+  
+  
+  
+  __init5() {this.data_ = null}
+  __init6() {this.state_ = 1} /* NOT_READY */
+  __init7() {this.loading_ = null}
+  __init8() {this.disposed_ = false}
   async load() {
     if (this.state_ === 3 /* READY */)
       return this.data_;
@@ -1131,47 +175,47 @@ var Asset = class {
       throw new Error("Data is not loaded yet!");
     return this.data_;
   }
-};
-var AssetStorage = class {
-  constructor(nextIdFn_, defaultLoader_, defaultDisposer_) {
+}, _class3);
+var AssetStorage = (_class4 = class {
+  constructor(nextIdFn_, defaultLoader_, defaultDisposer_) {;_class4.prototype.__init9.call(this);
     this.nextIdFn_ = nextIdFn_;
     this.defaultLoader_ = defaultLoader_;
     this.defaultDisposer_ = defaultDisposer_;
   }
-  nextIdFn_;
-  defaultLoader_;
-  defaultDisposer_;
-  items_ = /* @__PURE__ */ new Map();
-  newAsset(id2, url, loader, disposer) {
-    return new Asset(id2, url, loader, disposer);
+  
+  
+  
+  __init9() {this.items_ = /* @__PURE__ */ new Map()}
+  newAsset(id, url, loader, disposer) {
+    return new Asset(id, url, loader, disposer);
   }
   add(url) {
-    const id2 = this.nextIdFn_();
-    const rs = this.newAsset(id2, url, this.defaultLoader_, this.defaultDisposer_);
-    this.items_.set(id2, rs);
+    const id = this.nextIdFn_();
+    const rs = this.newAsset(id, url, this.defaultLoader_, this.defaultDisposer_);
+    this.items_.set(id, rs);
     return rs;
   }
   addCustom(url, customLoader, customDisposer) {
-    const id2 = this.nextIdFn_();
-    const rs = this.newAsset(id2, url, customLoader, customDisposer);
-    this.items_.set(id2, rs);
+    const id = this.nextIdFn_();
+    const rs = this.newAsset(id, url, customLoader, customDisposer);
+    this.items_.set(id, rs);
     return rs;
   }
-  get(id2) {
-    const item = this.items_.get(id2);
-    return item ?? null;
+  get(id) {
+    const item = this.items_.get(id);
+    return _nullishCoalesce(item, () => ( null));
   }
-  tryGet(id2) {
-    const item = this.items_.get(id2);
+  tryGet(id) {
+    const item = this.items_.get(id);
     if (!item)
-      throw new Error(`Asset with id ${id2} in storage ${this.constructor.name} not exist`);
+      throw new Error(`Asset with id ${id} in storage ${this.constructor.name} not exist`);
     return item;
   }
-  async remove(id2) {
-    const item = this.items_.get(id2);
+  async remove(id) {
+    const item = this.items_.get(id);
     if (!item) return;
     await item.dispose();
-    this.items_.delete(id2);
+    this.items_.delete(id);
   }
   async loadAll() {
     await Promise.all(
@@ -1184,15 +228,15 @@ var AssetStorage = class {
     );
     this.items_.clear();
   }
-};
+}, _class4);
 var NOOP_DISPOSER = async () => {
 };
-var AssetsManager = class {
-  storages_ = /* @__PURE__ */ new Map();
-  currId = 0;
-  nextIdFn = () => {
+var AssetsManager = (_class5 = class {constructor() { _class5.prototype.__init10.call(this);_class5.prototype.__init11.call(this);_class5.prototype.__init12.call(this); }
+  __init10() {this.storages_ = /* @__PURE__ */ new Map()}
+  __init11() {this.currId = 0}
+  __init12() {this.nextIdFn = () => {
     return ++this.currId;
-  };
+  }}
   register(res, defaultLoader, defaultDisposer = NOOP_DISPOSER) {
     const storage = new AssetStorage(
       this.nextIdFn,
@@ -1203,7 +247,7 @@ var AssetsManager = class {
     return storage;
   }
   getStorage(res) {
-    return this.storages_.get(res) ?? null;
+    return _nullishCoalesce(this.storages_.get(res), () => ( null));
   }
   tryGetStorage(res) {
     const s = this.storages_.get(res);
@@ -1217,7 +261,7 @@ var AssetsManager = class {
   disposeAll() {
     Array.from(this.storages_.values(), (s) => s.clearAll());
   }
-};
+}, _class5);
 
 // src/logger/logger.ts
 var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
@@ -1238,19 +282,30 @@ var NoopLogger = class {
   }
 };
 
+// src/std/utils.ts
+function injectStd(world) {
+  world.components.register(_chunkGUD2YACAcjs.Transform);
+  world.components.register(_chunkGUD2YACAcjs.Velocity);
+  world.systems.register(new (0, _chunkCNBFO5GJcjs.MovementSystem)());
+}
+
 // src/engine.ts
-var Engine = class {
-  runtime;
-  assets = new AssetsManager();
-  world;
-  logger;
-  constructor(params) {
+var Engine = (_class6 = class {
+  
+  __init13() {this.assets = new AssetsManager()}
+  
+  
+  constructor(params) {;_class6.prototype.__init13.call(this);
     this.runtime = new Runtime(params.loop);
-    this.logger = params.logger ?? new NoopLogger();
-    this.world = new World3({
+    this.logger = _nullishCoalesce(params.logger, () => ( new NoopLogger()));
+    this.world = new (0, _chunkGUD2YACAcjs.World)({
       logger: this.logger,
-      maxEntityCount: params.maxEntityCount ?? ECS_DEFAULTS.MAX_ENTITY_COUNT
+      maxEntityCount: _nullishCoalesce(params.maxEntityCount, () => ( _chunkGUD2YACAcjs.ECS_DEFAULTS.MAX_ENTITY_COUNT))
     });
+    injectStd(this.world);
+  }
+  getTick() {
+    return this.world.updatesCount;
   }
   init() {
     this.world.build();
@@ -1258,58 +313,57 @@ var Engine = class {
   start() {
     this.runtime.run(this.world);
   }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Asset,
-  AssetState,
-  AssetStorage,
-  AssetsManager,
-  Clock,
-  Commands,
-  Component,
-  ComponentAlreadyRegisteredError,
-  ComponentStorage,
-  ComponentsManager,
-  DAGNode,
-  Engine,
-  EntitiesManager,
-  EntityMaskNotFoundError,
-  EntityRef,
-  ErrDAGCycleDetected,
-  ErrMissingPluginMetadata,
-  ErrMissingSystemMetadata,
-  ErrNotAPlugin,
-  ErrNotASystem,
-  ErrPluginNotInit,
-  ErrUnknownPlugin,
-  EventBuffer,
-  EventBus,
-  LogLevel,
-  Loop,
-  ObjectPool,
-  Plugin,
-  PluginBase,
-  PluginError,
-  PluginsManager,
-  Resource,
-  ResourcesManager,
-  Runtime,
-  System,
-  SystemBase,
-  SystemError,
-  SystemPhase,
-  SystemsManager,
-  UnregisteredComponentStorageError,
-  VisitedState,
-  World,
-  createEventKey,
-  entry,
-  getPluginMetadata,
-  getResourceMetadata,
-  getSystemMetadata,
-  isPlugin,
-  isSystem,
-  topologicalSort
-});
+}, _class6);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.Asset = Asset; exports.AssetState = AssetState; exports.AssetStorage = AssetStorage; exports.AssetsManager = AssetsManager; exports.Clock = Clock; exports.Commands = _chunkGUD2YACAcjs.Commands; exports.Component = _chunkGUD2YACAcjs.Component; exports.ComponentAlreadyRegisteredError = _chunkGUD2YACAcjs.ComponentAlreadyRegisteredError; exports.ComponentStorage = _chunkGUD2YACAcjs.ComponentStorage; exports.ComponentsManager = _chunkGUD2YACAcjs.ComponentsManager; exports.DAGNode = _chunkGUD2YACAcjs.DAGNode; exports.Engine = Engine; exports.EntitiesManager = _chunkGUD2YACAcjs.EntitiesManager; exports.EntityMaskNotFoundError = _chunkGUD2YACAcjs.EntityMaskNotFoundError; exports.EntityRef = _chunkGUD2YACAcjs.EntityRef; exports.ErrDAGCycleDetected = _chunkGUD2YACAcjs.ErrDAGCycleDetected; exports.ErrMissingPluginMetadata = _chunkGUD2YACAcjs.ErrMissingPluginMetadata; exports.ErrMissingSystemMetadata = _chunkGUD2YACAcjs.ErrMissingSystemMetadata; exports.ErrNotAPlugin = _chunkGUD2YACAcjs.ErrNotAPlugin; exports.ErrNotASystem = _chunkGUD2YACAcjs.ErrNotASystem; exports.ErrPluginNotInit = _chunkGUD2YACAcjs.ErrPluginNotInit; exports.ErrUnknownPlugin = _chunkGUD2YACAcjs.ErrUnknownPlugin; exports.EventBuffer = _chunkGUD2YACAcjs.EventBuffer; exports.EventBus = _chunkGUD2YACAcjs.EventBus; exports.LogLevel = LogLevel; exports.Loop = Loop; exports.ObjectPool = _chunkGUD2YACAcjs.ObjectPool; exports.Plugin = _chunkGUD2YACAcjs.Plugin; exports.PluginBase = _chunkGUD2YACAcjs.PluginBase; exports.PluginError = _chunkGUD2YACAcjs.PluginError; exports.PluginsManager = _chunkGUD2YACAcjs.PluginsManager; exports.Resource = _chunkGUD2YACAcjs.Resource; exports.ResourcesManager = _chunkGUD2YACAcjs.ResourcesManager; exports.Runtime = Runtime; exports.System = _chunkGUD2YACAcjs.System; exports.SystemBase = _chunkGUD2YACAcjs.SystemBase; exports.SystemError = _chunkGUD2YACAcjs.SystemError; exports.SystemPhase = _chunkGUD2YACAcjs.SystemPhase; exports.SystemsManager = _chunkGUD2YACAcjs.SystemsManager; exports.UnregisteredComponentStorageError = _chunkGUD2YACAcjs.UnregisteredComponentStorageError; exports.VisitedState = _chunkGUD2YACAcjs.VisitedState; exports.World = _chunkGUD2YACAcjs.World; exports.createEventKey = _chunkGUD2YACAcjs.createEventKey; exports.entry = _chunkGUD2YACAcjs.entry; exports.getPluginMetadata = _chunkGUD2YACAcjs.getPluginMetadata; exports.getResourceMetadata = _chunkGUD2YACAcjs.getResourceMetadata; exports.getSystemMetadata = _chunkGUD2YACAcjs.getSystemMetadata; exports.isPlugin = _chunkGUD2YACAcjs.isPlugin; exports.isSystem = _chunkGUD2YACAcjs.isSystem; exports.topologicalSort = _chunkGUD2YACAcjs.topologicalSort;
 //# sourceMappingURL=index.cjs.map