@block_factory/lib 0.0.4 → 0.0.6

package/index.js

@@ -1,25 +1,30 @@
 var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // _module/BlockFactory.ts
 var BlockFactory_exports = {};
 __export(BlockFactory_exports, {
   Command: () => Command,
   ContainerWrapper: () => ContainerWrapper,
+  EntityHandler: () => EntityHandler,
   IEntityWrapper: () => IEntityWrapper,
   IForm: () => IForm,
   IPlayerWrapper: () => IPlayerWrapper,
+  ItemHandler: () => ItemHandler,
   MathUtils: () => MathUtils,
+  PlayerHandler: () => PlayerHandler,
   RawText: () => RawText,
   RegisterForm: () => RegisterForm,
   Signal: () => Signal,
   System: () => System,
+  Thread: () => Thread,
   Vec2: () => Vec2,
-  Vec3: () => Vec3,
-  _THREAD_: () => _THREAD_
+  Vec3: () => Vec3
 });
 
 // _module/util/Math.ts
@@ -95,28 +100,80 @@ var MathUtils;
 // _module/util/Signal.ts
 var Signal = class {
   constructor() {
-    this.listeners = /* @__PURE__ */ new Set();
+    /**
+     * Registered signal listeners.
+     */
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
   }
+  /**
+   * Number of currently subscribed listeners.
+   */
   get count() {
     return this.listeners.size;
   }
-  connect(callback) {
+  /**
+   * Subscribes a callback to this signal.
+   *
+   * The callback will be invoked every time the signal is emitted
+   * until it is explicitly unsubscribed or the signal is cleared.
+   *
+   * @param callback Function invoked on signal emission
+   */
+  subscribe(callback) {
     this.listeners.add(callback);
   }
-  disconnect(callback) {
+  /**
+   * Unsubscribes a previously registered callback.
+   *
+   * @param callback Callback to remove
+   * @returns `true` if the callback was removed, `false` otherwise
+   */
+  unsubscribe(callback) {
     return this.listeners.delete(callback);
   }
+  /**
+   * Removes all subscribed listeners from this signal.
+   */
   clear() {
     this.listeners.clear();
   }
-  isConnected(callback) {
+  /**
+   * Checks whether a callback is currently subscribed.
+   *
+   * @param callback Callback to test
+   * @returns `true` if the callback is subscribed
+   */
+  isSubscribed(callback) {
     return this.listeners.has(callback);
   }
+  /**
+   * Emits the signal immediately, invoking all subscribed callbacks.
+   *
+   * Listener errors are caught and logged to prevent a single failure
+   * from interrupting signal propagation.
+   *
+   * @param data Payload to pass to listeners
+   */
   emit(data) {
-    for (const cb of Array.from(this.listeners)) {
-      cb(data);
+    for (const callback of Array.from(this.listeners)) {
+      try {
+        callback(data);
+      } catch (err) {
+        console.error("BFLIB: Subscription listener error:", err);
+      }
     }
   }
+  /**
+   * Emits the signal asynchronously on the microtask queue.
+   *
+   * Useful for deferring execution to avoid re-entrancy issues
+   * or emitting during unsafe execution phases.
+   *
+   * @param data Payload to pass to listeners
+   */
+  emitDeferred(data) {
+    queueMicrotask(() => this.emit(data));
+  }
 };
 
 // _module/util/Vector.ts
@@ -247,15 +304,15 @@ var _Vec2 = class _Vec2 {
   }
 };
 /** Constant zero vector (0, 0) */
-_Vec2.ZERO = new _Vec2(0, 0);
+__publicField(_Vec2, "ZERO", new _Vec2(0, 0));
 /** Up direction (0, 1) */
-_Vec2.UP = new _Vec2(0, 1);
+__publicField(_Vec2, "UP", new _Vec2(0, 1));
 /** Down direction (0, -1) */
-_Vec2.DOWN = new _Vec2(0, -1);
+__publicField(_Vec2, "DOWN", new _Vec2(0, -1));
 /** Left direction (-1, 0) */
-_Vec2.LEFT = new _Vec2(-1, 0);
+__publicField(_Vec2, "LEFT", new _Vec2(-1, 0));
 /** Right direction (1, 0) */
-_Vec2.RIGHT = new _Vec2(1, 0);
+__publicField(_Vec2, "RIGHT", new _Vec2(1, 0));
 var Vec2 = _Vec2;
 var _Vec3 = class _Vec3 {
   /**
@@ -416,27 +473,27 @@ var _Vec3 = class _Vec3 {
   }
 };
 /** Constant zero vector (0, 0, 0) */
-_Vec3.ZERO = new _Vec3(0, 0, 0);
+__publicField(_Vec3, "ZERO", new _Vec3(0, 0, 0));
 /** Up direction (0, 1, 0) */
-_Vec3.UP = new _Vec3(0, 1, 0);
+__publicField(_Vec3, "UP", new _Vec3(0, 1, 0));
 /** Down direction (0, -1, 0) */
-_Vec3.DOWN = new _Vec3(0, -1, 0);
+__publicField(_Vec3, "DOWN", new _Vec3(0, -1, 0));
 /** Left direction (-1, 0, 0) */
-_Vec3.LEFT = new _Vec3(-1, 0, 0);
+__publicField(_Vec3, "LEFT", new _Vec3(-1, 0, 0));
 /** Right direction (1, 0, 0) */
-_Vec3.RIGHT = new _Vec3(1, 0, 0);
+__publicField(_Vec3, "RIGHT", new _Vec3(1, 0, 0));
 /** Forward direction (0, 0, 1) */
-_Vec3.FORWARD = new _Vec3(0, 0, 1);
+__publicField(_Vec3, "FORWARD", new _Vec3(0, 0, 1));
 /** Backward direction (0, 0, -1) */
-_Vec3.BACK = new _Vec3(0, 0, -1);
+__publicField(_Vec3, "BACK", new _Vec3(0, 0, -1));
 /** West direction (-1, 0, 0) */
-_Vec3.WEST = new _Vec3(-1, 0, 0);
+__publicField(_Vec3, "WEST", new _Vec3(-1, 0, 0));
 /** East direction (1, 0, 0) */
-_Vec3.EAST = new _Vec3(1, 0, 0);
+__publicField(_Vec3, "EAST", new _Vec3(1, 0, 0));
 /** North direction (0, 0, 1) */
-_Vec3.NORTH = new _Vec3(0, 0, 1);
+__publicField(_Vec3, "NORTH", new _Vec3(0, 0, 1));
 /** South direction (0, 0, -1) */
-_Vec3.SOUTH = new _Vec3(0, 0, -1);
+__publicField(_Vec3, "SOUTH", new _Vec3(0, 0, -1));
 var Vec3 = _Vec3;
 
 // _module/util/RawText.ts
@@ -482,7 +539,7 @@ var RawText = class {
 /**
  * Common formatting and color codes.
  */
-RawText.FORMAT = {
+__publicField(RawText, "FORMAT", {
   DarkRed: "\xA74",
   Red: "\xA7c",
   Gold: "\xA76",
@@ -505,7 +562,7 @@ RawText.FORMAT = {
   Italic: "\xA7o",
   Reset: "\xA7r",
   NewLine: "\n"
-};
+});
 
 // _module/util/Command.ts
 import {
@@ -514,6 +571,14 @@ import {
 var Command;
 ((Command2) => {
   class ICustomCommand {
+    constructor() {
+      /** Whether cheats must be enabled */
+      __publicField(this, "cheatsRequired");
+      /** Required command parameters */
+      __publicField(this, "mandatoryParameters");
+      /** Optional command parameters */
+      __publicField(this, "optionalParameters");
+    }
   }
   Command2.ICustomCommand = ICustomCommand;
   ;
@@ -581,8 +646,8 @@ var _IForm = class _IForm {
     else _IForm.occupiedPlayers.delete(player.id);
   }
 };
-_IForm.occupiedPlayers = /* @__PURE__ */ new Set();
-_IForm.returnText = "Back";
+__publicField(_IForm, "occupiedPlayers", /* @__PURE__ */ new Set());
+__publicField(_IForm, "returnText", "Back");
 var IForm = _IForm;
 
 // _module/util/Forms/FormAction.ts
@@ -617,6 +682,7 @@ world2.afterEvents.itemUse.subscribe((event) => {
 // _module/util/Wrapper/Container.ts
 var ContainerWrapper = class _ContainerWrapper {
   constructor(source) {
+    __publicField(this, "source");
     this.source = source;
     return System.ProxyConstructor(this, source);
   }
@@ -638,83 +704,107 @@ var ContainerWrapper = class _ContainerWrapper {
 };
 
 // _module/util/Wrapper/IEntity.ts
-import { EntityInventoryComponent } from "@minecraft/server";
+import { EntityInventoryComponent, system as system2, TicksPerSecond } from "@minecraft/server";
 var IEntityWrapper = class _IEntityWrapper {
   constructor(source) {
-    //======================== Interal ========================
-    this.isAlive = false;
+    __publicField(this, "source");
     this.source = source;
     return System.ProxyConstructor(this, source);
   }
   static wrap(source) {
     return new _IEntityWrapper(source);
   }
+  //======================== Interal ========================
   get inventory() {
     const i = this.source.getComponent(
       EntityInventoryComponent.componentId
     );
     return ContainerWrapper.wrap(i.container);
   }
-  test() {
+  async playAnimationAsync(animation, options) {
+    this.source.playAnimation(animation.id, options);
+    await system2.waitTicks(animation.length * TicksPerSecond);
   }
 };
 
 // _module/util/Wrapper/IPlayer.ts
-import { EntityInventoryComponent as EntityInventoryComponent2 } from "@minecraft/server";
+import { EntityInventoryComponent as EntityInventoryComponent2, system as system3, TicksPerSecond as TicksPerSecond2 } from "@minecraft/server";
 var IPlayerWrapper = class _IPlayerWrapper {
   constructor(source) {
-    //======================== Interal ========================
-    this.isAlive = false;
+    __publicField(this, "source");
     this.source = source;
     return System.ProxyConstructor(this, source);
   }
   static wrap(player) {
     return new _IPlayerWrapper(player);
   }
+  //======================== Interal ========================
   get inventory() {
     const i = this.source.getComponent(
       EntityInventoryComponent2.componentId
     );
     return ContainerWrapper.wrap(i.container);
   }
-  test() {
-    this.source.sendMessage(`${this.source.name} was tested`);
+  async playSoundAsync(sound, options) {
+    this.source.playSound(sound.id, options);
+    await system3.waitTicks(sound.length * TicksPerSecond2);
+  }
+  async playAnimationAsync(animation, options) {
+    this.source.playAnimation(animation.id, options);
+    await system3.waitTicks(animation.length * TicksPerSecond2);
   }
 };
 
-// _module/sys/Threads.ts
-import { system as system2, TicksPerSecond } from "@minecraft/server";
-var Threads = class _Threads {
+// _module/Framework/Threads.ts
+import { system as system4, TicksPerSecond as TicksPerSecond3 } from "@minecraft/server";
+var SingletonThreadManager = class {
   constructor() {
-    this.MAIN = new Signal();
-    this.LATE = new Signal();
-    this.MAIN_INTERVAL_RATE = 0;
-    this.LATE_INTERVAL_RATE = TicksPerSecond;
-    this._delta = this.createDeltaTimer();
-    this._MAIN_ID = system2.runInterval(() => {
+    __publicField(this, "MAIN", new Signal());
+    __publicField(this, "LATE", new Signal());
+    __publicField(this, "_mainRate", 0);
+    __publicField(this, "_lateRate", TicksPerSecond3);
+    __publicField(this, "_MAIN_ID");
+    __publicField(this, "_LATE_ID");
+    __publicField(this, "_delta", this.createDeltaTimer());
+    __publicField(this, "_started", false);
+  }
+  configure(cfg) {
+    if (this._started) throw new Error("BFLIB: _THREAD_ already started; configure before start().");
+    if (cfg.mainRate !== void 0) this._mainRate = cfg.mainRate;
+    if (cfg.lateRate !== void 0) this._lateRate = cfg.lateRate;
+  }
+  start() {
+    if (this._started) return;
+    this._started = true;
+    this._MAIN_ID = system4.runInterval(() => {
       if (this.MAIN.count <= 0) return;
       try {
         const delta = this._delta();
         this.MAIN.emit(delta);
-      } catch (error) {
-        throw Error(`ERROR: _THREAD_.MAIN:${this._MAIN_ID} | ${error}`);
+      } catch (e) {
+        console.error(`ERROR: _THREAD_.MAIN:${this._MAIN_ID} |`, e);
       }
-    }, this.MAIN_INTERVAL_RATE);
-    this._LATE_ID = system2.runInterval(() => {
+    }, this._mainRate);
+    this._LATE_ID = system4.runInterval(() => {
       if (this.LATE.count <= 0) return;
       try {
         this.LATE.emit();
-      } catch (error) {
-        throw Error(`ERROR: _THREAD_.LATE:${this._LATE_ID} | ${error}`);
+      } catch (e) {
+        console.error(`ERROR: _THREAD_.LATE:${this._LATE_ID} |`, e);
       }
-    }, this.LATE_INTERVAL_RATE);
-  }
-  static create() {
-    return new _Threads();
+    }, this._lateRate);
+  }
+  stop() {
+    if (this._MAIN_ID !== void 0) system4.clearRun(this._MAIN_ID);
+    if (this._LATE_ID !== void 0) system4.clearRun(this._LATE_ID);
+    this._MAIN_ID = void 0;
+    this._LATE_ID = void 0;
+    this._started = false;
+    this._delta = this.createDeltaTimer();
   }
   createDeltaTimer() {
     let last = Date.now();
-    return function nextDelta() {
+    return () => {
       const now = Date.now();
       const delta = (now - last) / 1e3;
       last = now;
@@ -722,20 +812,376 @@ var Threads = class _Threads {
     };
   }
 };
-var _THREAD_ = Threads.create();
+var Thread = new SingletonThreadManager();
+
+// _module/Framework/PlayerTasks.ts
+import { ButtonState, InputButton, world as world3 } from "@minecraft/server";
+var SingletonPlayerHandler = class {
+  constructor() {
+    __publicField(this, "GLOBAL_MEMORY_ID", "GLB_MEM.PLAYER");
+    __publicField(this, "loadEventSignal", world3.afterEvents.worldLoad);
+    __publicField(this, "playerSpawnSignal", world3.afterEvents.playerSpawn);
+    __publicField(this, "playerLeaveBeforeSignal", world3.beforeEvents.playerLeave);
+    __publicField(this, "buttonInputSignal", world3.afterEvents.playerButtonInput);
+    __publicField(this, "PR_INDEX", /* @__PURE__ */ new Map());
+    __publicField(this, "PR_KEYS", []);
+    __publicField(this, "_started", false);
+    __publicField(this, "_wired", false);
+    __publicField(this, "onWorldLoad", () => {
+      this.reloadPlayerMemory();
+      this.loadEventSignal.unsubscribe(this.onWorldLoad);
+    });
+    __publicField(this, "onPlayerSpawned", (event) => {
+      if (!event) return;
+      if (this.hasPlayer(event.player.id)) return;
+      this.savePlayerInMemory(event.player);
+    });
+    __publicField(this, "onPlayerLeaveBefore", (event) => {
+      if (!this.hasPlayer(event.player.id)) return;
+      this.deletePlayerInMemory(event.player);
+    });
+    __publicField(this, "onButtonPress", (event) => {
+      if (event.button === InputButton.Jump) {
+      } else if (event.button === InputButton.Sneak) {
+      }
+      console.warn(`Player ${event.player.name} pressed button ${InputButton[event.button]}: ${ButtonState[event.newButtonState]}`);
+    });
+  }
+  start() {
+    if (this._started) throw new Error("BFLIB: PlayerHandler already started;");
+    this._started = true;
+    this.onSystemLoad();
+    this.loadEventSignal.subscribe(this.onWorldLoad);
+    this.buttonInputSignal.subscribe(this.onButtonPress);
+  }
+  stop() {
+    if (!this._started) return;
+    if (this._wired) {
+      this.playerSpawnSignal.unsubscribe(this.onPlayerSpawned);
+      this.playerLeaveBeforeSignal.unsubscribe(this.onPlayerLeaveBefore);
+      this.buttonInputSignal.unsubscribe(this.onButtonPress);
+      this._wired = false;
+    }
+    this._started = false;
+  }
+  onSystemLoad() {
+    this.playerSpawnSignal.subscribe(this.onPlayerSpawned);
+    this.playerLeaveBeforeSignal.subscribe(this.onPlayerLeaveBefore);
+    this._wired = true;
+  }
+  hasPlayer(playerId) {
+    return this.PR_INDEX.has(playerId);
+  }
+  /* ------------------------------------------------------------------------ */
+  /* Persistence                                                              */
+  /* ------------------------------------------------------------------------ */
+  reloadPlayerMemory() {
+    this.PR_INDEX.clear();
+    this.PR_KEYS.length = 0;
+    const players = world3.getAllPlayers();
+    for (const player of players) {
+      this.PR_INDEX.set(player.id, player);
+      this.PR_KEYS.push(player.id);
+    }
+  }
+  persistKeys() {
+    world3.setDynamicProperty(this.GLOBAL_MEMORY_ID, JSON.stringify(this.PR_KEYS));
+  }
+  savePlayerInMemory(player) {
+    if (this.PR_INDEX.has(player.id)) return false;
+    this.PR_KEYS.push(player.id);
+    this.PR_INDEX.set(player.id, player);
+    this.persistKeys();
+    return true;
+  }
+  deletePlayerInMemory(player) {
+    const existed = this.PR_INDEX.delete(player.id);
+    if (!existed) return false;
+    const idx = this.PR_KEYS.indexOf(player.id);
+    if (idx !== -1) this.PR_KEYS.splice(idx, 1);
+    this.persistKeys();
+    return true;
+  }
+  getPlayersInMemory() {
+    return Array.from(this.PR_INDEX.values());
+  }
+  getIPlayersInMemory() {
+    return Array.from(this.PR_INDEX.values()).map((player) => IPlayerWrapper.wrap(player));
+  }
+};
+var PlayerHandler = new SingletonPlayerHandler();
+
+// _module/Framework/EntityTasks.ts
+import { system as system5, world as world4 } from "@minecraft/server";
+var SingletonEntityHandler = class {
+  constructor() {
+    __publicField(this, "PACK_ID");
+    __publicField(this, "onEntityEmission", new Signal());
+    __publicField(this, "GLOBAL_MEMORY_ID", "GLB_MEM.ENTITY");
+    __publicField(this, "scriptEventSignal", system5.afterEvents.scriptEventReceive);
+    __publicField(this, "loadEventSignal", world4.afterEvents.worldLoad);
+    __publicField(this, "spawnEventSignal", world4.afterEvents.entitySpawn);
+    __publicField(this, "removeBeforeEventSignal", world4.beforeEvents.entityRemove);
+    __publicField(this, "EM_INDEX", /* @__PURE__ */ new Map());
+    __publicField(this, "EM_KEYS", []);
+    __publicField(this, "SEARCH_TYPES", /* @__PURE__ */ new Set());
+    __publicField(this, "_started", false);
+    __publicField(this, "_wired", false);
+    /* ------------------------------------------------------------------------ */
+    /* Event Wiring                                                             */
+    /* ------------------------------------------------------------------------ */
+    __publicField(this, "onWorldLoad", () => {
+      this.scriptEventSignal.subscribe(this.processScriptEvents);
+      if (this.SEARCH_TYPES.size > 0) {
+        this.spawnEventSignal.subscribe(this.onEntitySpawned);
+        this.removeBeforeEventSignal.subscribe(this.onEntityRemovedBefore);
+      }
+      this._wired = true;
+      this.reloadEntityMemory();
+      this.loadEventSignal.unsubscribe(this.onWorldLoad);
+    });
+    __publicField(this, "processScriptEvents", (event) => {
+      if (!event.sourceEntity) return;
+      if (event.id !== `${this.PACK_ID}:entity_emitter`) return;
+      let parms;
+      try {
+        parms = JSON.parse(event.message);
+      } catch (e) {
+        console.error(`BFLIB: entity_emitter JSON parse failed:`, e);
+        return;
+      }
+      this.onEntityEmission.emit({ iEntity: IEntityWrapper.wrap(event.sourceEntity), parms });
+    });
+    __publicField(this, "onEntitySpawned", (event) => {
+      const entity = event.entity;
+      if (!this.isValidType(entity.typeId)) return;
+      this.saveEntityInMemory(entity);
+    });
+    __publicField(this, "onEntityRemovedBefore", (event) => {
+      const entity = event.removedEntity;
+      if (!this.isValidType(entity.typeId)) return;
+      this.deleteEntityInMemory(entity);
+    });
+  }
+  registerEntity(typeId) {
+    if (Array.isArray(typeId)) typeId.forEach((t) => this.SEARCH_TYPES.add(t));
+    else this.SEARCH_TYPES.add(typeId);
+  }
+  start(packId) {
+    if (this._started) throw new Error("BFLIB: EntityHandler already started;");
+    this._started = true;
+    this.PACK_ID = packId;
+    this.loadEventSignal.subscribe(this.onWorldLoad);
+  }
+  stop() {
+    if (!this._started) return;
+    this.loadEventSignal.unsubscribe(this.onWorldLoad);
+    if (this._wired) {
+      this.scriptEventSignal.unsubscribe(this.processScriptEvents);
+      this.spawnEventSignal.unsubscribe(this.onEntitySpawned);
+      this.removeBeforeEventSignal.unsubscribe(this.onEntityRemovedBefore);
+      this._wired = false;
+    }
+    this._started = false;
+  }
+  /* ------------------------------------------------------------------------ */
+  /* Filters                                                                  */
+  /* ------------------------------------------------------------------------ */
+  isValidType(typeId) {
+    if (this.PACK_ID && !typeId.startsWith(this.PACK_ID)) return false;
+    return this.SEARCH_TYPES.has(typeId);
+  }
+  /* ------------------------------------------------------------------------ */
+  /* Persistence                                                              */
+  /* ------------------------------------------------------------------------ */
+  reloadEntityMemory() {
+    this.EM_INDEX.clear();
+    this.EM_KEYS.length = 0;
+    const raw = world4.getDynamicProperty(this.GLOBAL_MEMORY_ID);
+    if (!raw) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (e) {
+      console.error(`BFLIB: Failed to parse ${this.GLOBAL_MEMORY_ID}:`, e);
+      return;
+    }
+    for (const id of parsed) {
+      this.EM_KEYS.push(id);
+      const entity = world4.getEntity(id);
+      if (entity) this.EM_INDEX.set(entity.id, entity);
+    }
+  }
+  persistKeys() {
+    world4.setDynamicProperty(this.GLOBAL_MEMORY_ID, JSON.stringify(this.EM_KEYS));
+  }
+  saveEntityInMemory(entity) {
+    if (this.EM_INDEX.has(entity.id)) return false;
+    this.EM_KEYS.push(entity.id);
+    this.EM_INDEX.set(entity.id, entity);
+    this.persistKeys();
+    return true;
+  }
+  deleteEntityInMemory(entity) {
+    const existed = this.EM_INDEX.delete(entity.id);
+    if (!existed) return false;
+    const idx = this.EM_KEYS.indexOf(entity.id);
+    if (idx !== -1) this.EM_KEYS.splice(idx, 1);
+    this.persistKeys();
+    return true;
+  }
+  getEntitiesInMemory() {
+    return Array.from(this.EM_INDEX.values());
+  }
+};
+var EntityHandler = new SingletonEntityHandler();
+
+// _module/Framework/ItemTasks.ts
+import { system as system6, world as world5 } from "@minecraft/server";
+var SingletonItemHandler = class {
+  constructor() {
+    __publicField(this, "PACK_ID");
+    __publicField(this, "whileHoldingItemEvent", new Signal());
+    __publicField(this, "onItemHeldEvent", new Signal());
+    __publicField(this, "onItemUnheldEvent", new Signal());
+    __publicField(this, "onItemUsedEvent", new Signal());
+    __publicField(this, "loadEventSignal", world5.afterEvents.worldLoad);
+    __publicField(this, "useBeforeSignal", world5.beforeEvents.itemUse);
+    __publicField(this, "useAfterSignal", world5.afterEvents.itemUse);
+    __publicField(this, "completeUseSignal", world5.afterEvents.itemCompleteUse);
+    __publicField(this, "releaseUseSignal", world5.afterEvents.itemReleaseUse);
+    __publicField(this, "startUseSignal", world5.afterEvents.itemStartUse);
+    __publicField(this, "startUseOnSignal", world5.afterEvents.itemStartUseOn);
+    __publicField(this, "stopUseSignal", world5.afterEvents.itemStopUse);
+    __publicField(this, "stopUseOnSignal", world5.afterEvents.itemStopUseOn);
+    __publicField(this, "inventoryItemChangeSignal", world5.afterEvents.playerInventoryItemChange);
+    __publicField(this, "hotbarChangeSignal", world5.afterEvents.playerHotbarSelectedSlotChange);
+    __publicField(this, "IM_INDEX", /* @__PURE__ */ new Map());
+    __publicField(this, "HOLD_INDEX", /* @__PURE__ */ new Map());
+    __publicField(this, "_started", false);
+    __publicField(this, "_wired", false);
+    __publicField(this, "onWorldLoad", () => {
+      if (this.IM_INDEX.size > 0) {
+        this.useBeforeSignal.subscribe(this.onUseBefore);
+        this.useAfterSignal.subscribe(this.onUseAfter);
+        this.completeUseSignal.subscribe(this.onCompleteUse);
+        this.releaseUseSignal.subscribe(this.onReleaseUse);
+        this.startUseSignal.subscribe(this.onStartUse);
+        this.startUseOnSignal.subscribe(this.onStartUseOn);
+        this.stopUseSignal.subscribe(this.onStopUse);
+        this.stopUseOnSignal.subscribe(this.onStopUseOn);
+        this.hotbarChangeSignal.subscribe(this.onHotbarChange);
+        this.inventoryItemChangeSignal.subscribe(this.onInventoryItemChange);
+        this._wired = true;
+      }
+      this.loadEventSignal.unsubscribe(this.onWorldLoad);
+    });
+    __publicField(this, "onUseBefore", (event) => {
+      const itemStack = event.itemStack;
+      if (!this.isValidType(itemStack.typeId)) return;
+      const i = this.IM_INDEX.get(itemStack.typeId);
+      if (!i || !i.emitOnUse) return;
+      const runId = system6.run(() => {
+        try {
+          this.onItemUsedEvent.emit({ player: event.source, itemStack: event.itemStack });
+        } catch (error) {
+          throw new Error(`${error}`);
+        } finally {
+          system6.clearRun(runId);
+        }
+      });
+    });
+    __publicField(this, "onUseAfter", (_event) => {
+    });
+    __publicField(this, "onCompleteUse", (_event) => {
+    });
+    __publicField(this, "onReleaseUse", (_event) => {
+    });
+    __publicField(this, "onStartUse", (_event) => {
+    });
+    __publicField(this, "onStartUseOn", (_event) => {
+    });
+    __publicField(this, "onStopUse", (_event) => {
+    });
+    __publicField(this, "onStopUseOn", (_event) => {
+    });
+    __publicField(this, "onInventoryItemChange", (_event) => {
+    });
+    __publicField(this, "onHotbarChange", (event) => {
+      const itemStack = event.itemStack;
+      if (this.HOLD_INDEX.has(event.player.id)) this.releaseHold(event.player);
+      if (!itemStack || itemStack && !this.isValidType(itemStack.typeId)) return;
+      this.setNewHold(itemStack, event.player);
+    });
+  }
+  registerItem(itemRegistration) {
+    if (Array.isArray(itemRegistration)) itemRegistration.forEach((i) => this.IM_INDEX.set(i.typeId, i));
+    else this.IM_INDEX.set(itemRegistration.typeId, itemRegistration);
+  }
+  start(packId) {
+    if (this._started) throw new Error("BFLIB: ItemHandler already started;");
+    this._started = true;
+    this.PACK_ID = packId;
+    this.loadEventSignal.subscribe(this.onWorldLoad);
+  }
+  stop() {
+    if (!this._started) return;
+    this.loadEventSignal.unsubscribe(this.onWorldLoad);
+    if (this._wired) {
+      this.useBeforeSignal.unsubscribe(this.onUseBefore);
+      this.useAfterSignal.unsubscribe(this.onUseAfter);
+      this.completeUseSignal.unsubscribe(this.onCompleteUse);
+      this.releaseUseSignal.unsubscribe(this.onReleaseUse);
+      this.startUseSignal.unsubscribe(this.onStartUse);
+      this.startUseOnSignal.unsubscribe(this.onStartUseOn);
+      this.stopUseSignal.unsubscribe(this.onStopUse);
+      this.stopUseOnSignal.unsubscribe(this.onStopUseOn);
+      this.hotbarChangeSignal.unsubscribe(this.onHotbarChange);
+      this.inventoryItemChangeSignal.unsubscribe(this.onInventoryItemChange);
+      this._wired = false;
+    }
+    this._started = false;
+  }
+  setNewHold(itemStack, player) {
+    this.onItemHeldEvent.emit({ player, itemStack });
+    const i = this.IM_INDEX.get(itemStack.typeId);
+    let instanceId = -1;
+    if (i && i.emitWhileHolding) {
+      instanceId = system6.runInterval(() => {
+        this.whileHoldingItemEvent.emit({ player, itemStack });
+      });
+    }
+    this.HOLD_INDEX.set(player.id, { instanceId, itemStack });
+  }
+  releaseHold(player) {
+    const holdData = this.HOLD_INDEX.get(player.id);
+    if (!holdData) return;
+    this.onItemUnheldEvent.emit({ player, itemStack: holdData.itemStack });
+    if (holdData.instanceId !== -1) system6.clearRun(holdData.instanceId);
+    this.HOLD_INDEX.delete(player.id);
+  }
+  isValidType(typeId) {
+    if (this.PACK_ID && !typeId.startsWith(this.PACK_ID)) return false;
+    return this.IM_INDEX.has(typeId);
+  }
+};
+var ItemHandler = new SingletonItemHandler();
 export {
   BlockFactory_exports as BlockFactory,
   Command,
   ContainerWrapper,
+  EntityHandler,
   IEntityWrapper,
   IForm,
   IPlayerWrapper,
+  ItemHandler,
   MathUtils,
+  PlayerHandler,
   RawText,
   RegisterForm,
   Signal,
   System,
+  Thread,
   Vec2,
-  Vec3,
-  _THREAD_
+  Vec3
 };