@block_factory/lib 0.0.5 → 0.0.6

package/index.js

@@ -11,32 +11,22 @@ 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,
-  _EntityHandler_: () => _EntityHandler_,
-  _INITIALIZE_BF_FRAMEWORK_: () => _INITIALIZE_BF_FRAMEWORK_,
-  _THREAD_: () => _THREAD_,
-  onEntityEmission: () => onEntityEmission
+  Vec3: () => Vec3
 });
 
-// _module/Framework/_INIT.ts
-var IS_INITIALIZED = false;
-var PACK_ID = void 0;
-function _INITIALIZE_BF_FRAMEWORK_(packId) {
-  if (IS_INITIALIZED) throw Error(`CONFLICT WARNING: ${PACK_ID} already initialized.`);
-  PACK_ID = packId;
-  IS_INITIALIZED = true;
-  console.log("Block Factory Framework Loaded");
-}
-
 // _module/util/Math.ts
 var MathUtils;
 ((MathUtils2) => {
@@ -110,32 +100,80 @@ var MathUtils;
 // _module/util/Signal.ts
 var Signal = class {
   constructor() {
+    /**
+     * 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 callback of Array.from(this.listeners)) {
       try {
         callback(data);
       } catch (err) {
-        console.error("BFLIB: Signal listener error:", 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
@@ -719,7 +757,7 @@ var IPlayerWrapper = class _IPlayerWrapper {
 
 // _module/Framework/Threads.ts
 import { system as system4, TicksPerSecond as TicksPerSecond3 } from "@minecraft/server";
-var Threads = class {
+var SingletonThreadManager = class {
   constructor() {
     __publicField(this, "MAIN", new Signal());
     __publicField(this, "LATE", new Signal());
@@ -774,23 +812,116 @@ var Threads = class {
     };
   }
 };
-var _THREAD_ = new Threads();
+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 world3
-} from "@minecraft/server";
-var onEntityEmission = new Signal();
-var EntityHandler = class {
+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", world3.afterEvents.worldLoad);
-    __publicField(this, "spawnEventSignal", world3.afterEvents.entitySpawn);
-    __publicField(this, "removeAfterEventSignal", world3.afterEvents.entityRemove);
-    __publicField(this, "removeBeforeEventSignal", world3.beforeEvents.entityRemove);
+    __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());
@@ -799,12 +930,11 @@ var EntityHandler = class {
     /* ------------------------------------------------------------------------ */
     /* Event Wiring                                                             */
     /* ------------------------------------------------------------------------ */
-    __publicField(this, "onWorldLoad", (_event) => {
+    __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.removeAfterEventSignal.subscribe(this.onEntityRemovedAfter);
       }
       this._wired = true;
       this.reloadEntityMemory();
@@ -820,10 +950,7 @@ var EntityHandler = class {
         console.error(`BFLIB: entity_emitter JSON parse failed:`, e);
         return;
       }
-      onEntityEmission.emit({
-        iEntity: IEntityWrapper.wrap(event.sourceEntity),
-        parms
-      });
+      this.onEntityEmission.emit({ iEntity: IEntityWrapper.wrap(event.sourceEntity), parms });
     });
     __publicField(this, "onEntitySpawned", (event) => {
       const entity = event.entity;
@@ -835,18 +962,13 @@ var EntityHandler = class {
       if (!this.isValidType(entity.typeId)) return;
       this.deleteEntityInMemory(entity);
     });
-    __publicField(this, "onEntityRemovedAfter", (_event) => {
-    });
-  }
-  configure() {
-    if (this._started) throw new Error("BFLIB: EntityHandler already started;");
   }
   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) return;
+    if (this._started) throw new Error("BFLIB: EntityHandler already started;");
     this._started = true;
     this.PACK_ID = packId;
     this.loadEventSignal.subscribe(this.onWorldLoad);
@@ -858,7 +980,6 @@ var EntityHandler = class {
       this.scriptEventSignal.unsubscribe(this.processScriptEvents);
       this.spawnEventSignal.unsubscribe(this.onEntitySpawned);
       this.removeBeforeEventSignal.unsubscribe(this.onEntityRemovedBefore);
-      this.removeAfterEventSignal.unsubscribe(this.onEntityRemovedAfter);
       this._wired = false;
     }
     this._started = false;
@@ -867,6 +988,7 @@ var EntityHandler = class {
   /* Filters                                                                  */
   /* ------------------------------------------------------------------------ */
   isValidType(typeId) {
+    if (this.PACK_ID && !typeId.startsWith(this.PACK_ID)) return false;
     return this.SEARCH_TYPES.has(typeId);
   }
   /* ------------------------------------------------------------------------ */
@@ -875,7 +997,7 @@ var EntityHandler = class {
   reloadEntityMemory() {
     this.EM_INDEX.clear();
     this.EM_KEYS.length = 0;
-    const raw = world3.getDynamicProperty(this.GLOBAL_MEMORY_ID);
+    const raw = world4.getDynamicProperty(this.GLOBAL_MEMORY_ID);
     if (!raw) return;
     let parsed;
     try {
@@ -886,12 +1008,12 @@ var EntityHandler = class {
     }
     for (const id of parsed) {
       this.EM_KEYS.push(id);
-      const entity = world3.getEntity(id);
+      const entity = world4.getEntity(id);
       if (entity) this.EM_INDEX.set(entity.id, entity);
     }
   }
   persistKeys() {
-    world3.setDynamicProperty(this.GLOBAL_MEMORY_ID, JSON.stringify(this.EM_KEYS));
+    world4.setDynamicProperty(this.GLOBAL_MEMORY_ID, JSON.stringify(this.EM_KEYS));
   }
   saveEntityInMemory(entity) {
     if (this.EM_INDEX.has(entity.id)) return false;
@@ -912,23 +1034,154 @@ var EntityHandler = class {
     return Array.from(this.EM_INDEX.values());
   }
 };
-var _EntityHandler_ = new EntityHandler();
+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,
-  _EntityHandler_,
-  _INITIALIZE_BF_FRAMEWORK_,
-  _THREAD_,
-  onEntityEmission
+  Vec3
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@block_factory/lib",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "main": "index.js",
   "types": "index.d.ts",
   "description": "Typescript Library for Minecraft Bedrock Edition",
@@ -25,7 +25,9 @@
     "@minecraft/server-ui": "^2.0.0"
   },
   "devDependencies": {
-    "esbuild": "^0.25.9"
+    "esbuild": "^0.25.9",
+    "typedoc": "^0.28.16",
+    "typedoc-plugin-markdown": "^4.9.0"
   },
   "scripts": {
     "build": "node esbuild.config.mjs",

package/typedoc.json

@@ -0,0 +1,6 @@
+{
+  "entryPoints": ["./index.ts"],
+  "out": "docs",
+  "plugin": ["typedoc-plugin-markdown"],
+  "readme": "none"
+}

package/_module/Framework/_INIT.ts

@@ -1,39 +0,0 @@
-let IS_INITIALIZED: boolean = false
-let PACK_ID: string | undefined = undefined
-
-/* -------------------------------------------------------------------------- */
-/* Public API                                                                 */
-/* -------------------------------------------------------------------------- */
-
-/**
- * Initializes the Block Factory framework.
- *
- * This **must be called exactly once** before using any backend systems
- * such as threads, entity tasks, or event routing.
- *
- * @param packId - Unique identifier for the active pack instance.
- *
- * @throws Error if the framework has already been initialized.
- *
- * @example
- * ```ts
- * _INITIALIZE_BF_FRAMEWORK_("bf:utility_tools");
- * ```
- */
-export function _INITIALIZE_BF_FRAMEWORK_(packId: string): void {
-    if (IS_INITIALIZED) throw Error(`CONFLICT WARNING: ${PACK_ID} already initialized.`);
-    PACK_ID = packId; IS_INITIALIZED = true;
-    console.log("Block Factory Framework Loaded");
-}
-
-/* -------------------------------------------------------------------------- */
-/* Internal API                                                               */
-/* -------------------------------------------------------------------------- */
-
-export function getPackId(): string | undefined {
-    return PACK_ID;
-}
-
-export function isInitalized(): boolean {
-    return IS_INITIALIZED;
-}

package/_types/_module/Framework/_INIT.d.ts

@@ -1,19 +0,0 @@
-/**
- * Initializes the Block Factory framework.
- *
- * This **must be called exactly once** before using any backend systems
- * such as threads, entity tasks, or event routing.
- *
- * @param packId - Unique identifier for the active pack instance.
- *
- * @throws Error if the framework has already been initialized.
- *
- * @example
- * ```ts
- * _INITIALIZE_BF_FRAMEWORK_("bf:utility_tools");
- * ```
- */
-export declare function _INITIALIZE_BF_FRAMEWORK_(packId: string): void;
-export declare function getPackId(): string | undefined;
-export declare function isInitalized(): boolean;
-//# sourceMappingURL=_INIT.d.ts.map

package/_types/_module/Framework/_INIT.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_INIT.d.ts","sourceRoot":"","sources":["../../../_module/Framework/_INIT.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAI9D;AAMD,wBAAgB,SAAS,IAAI,MAAM,GAAG,SAAS,CAE9C;AAED,wBAAgB,YAAY,IAAI,OAAO,CAEtC"}