@v12-engine/engine 0.1.0 → 0.4.0

package/dist/entityIndex.js

@@ -0,0 +1,149 @@
+//#region src/entityIndex.ts
+var none = /* @__PURE__ */ new Set();
+/** Entities in the order of their ids, with the highest id filed: what comes next goes at the end when it is higher */
+var ById = class extends Set {
+	last = 0;
+};
+/**
+* Entities filed by what they are asked for by: whose they are, which have a component (and, for a component that
+* asks, whose they are too: `Component.index`). Answers questions like "the heroes of player 2"
+* or "every shop" without going through every entity of the world, most of which are trees. Kept up to date by the
+* world as entities come and go, and by the entities as they get or lose a component.
+*
+* Every set keeps entities in the order of their ids, the order they came into the world and the one a walk through
+* `World.entities` gives, however and whenever each was filed: one that changed owner or type, or was given a component
+* late, takes its place among the others, as it has in a world loaded from a save. Code that picks the first of equals
+* gets the same one either way. A set an entity is filed into out of its place is made again: a walk through it under
+* way goes on through the one it had
+*/
+var EntityIndex = class {
+	componentOf;
+	worldOf;
+	/**
+	* `componentOf`: a component of the world's game by its id, an error for one it does not list (`registry.used`);
+	* `worldOf`: the world it is the index of, which its entities reach through it (`Entity.order`)
+	*/
+	constructor(componentOf, worldOf) {
+		this.componentOf = componentOf;
+		this.worldOf = worldOf;
+	}
+	/** The world it is the index of */
+	world() {
+		return this.worldOf();
+	}
+	owned = /* @__PURE__ */ new Map();
+	components = /* @__PURE__ */ new Map();
+	/** By component id, then by owner: for the components that ask (`index: 'owner'`) */
+	byOwner = /* @__PURE__ */ new Map();
+	/** By component id, what has it in the order of the entities' ids (`ordered`): made again once it changes */
+	inOrder = /* @__PURE__ */ new Map();
+	/** Everything the player owns, dead heroes waiting to be brought back included */
+	ownedBy(player) {
+		return this.owned.get(player) ?? none;
+	}
+	/**
+	* Everything that has the component; with a player, what the player owns of it, for a component filed by owner
+	* (`Component.index: 'owner'`; throws for one that is not)
+	*/
+	with(key, owner) {
+		if (owner === void 0) return this.components.get(key.id) ?? none;
+		const owners = this.byOwner.get(key.id);
+		if (!owners) {
+			if (key.index === "owner") return none;
+			throw new Error(`Index: "${key.id}" is not filed by owner: define it with index: 'owner' to ask for a player's`);
+		}
+		return owners.get(owner) ?? none;
+	}
+	/**
+	* Everything that has the component, in the order of the entities' ids: the order a walk through `World.units`
+	* meets them in. What a system that runs over a component goes through (`System.over`), so a game plays the same
+	* as one that looks at every actor. A list of its own, kept until what has the component changes: what is given it
+	* or loses it while the list is gone through is in the next one
+	*/
+	ordered(key) {
+		let list = this.inOrder.get(key.id);
+		if (!list) {
+			const set = this.components.get(key.id);
+			list = set ? [...set] : [];
+			this.inOrder.set(key.id, list);
+		}
+		return list;
+	}
+	add(entity) {
+		file(this.owned, entity.owner, entity);
+		for (const component of entity.heldComponents()) this.fileComponent(entity, component.id);
+		entity.index = this;
+	}
+	remove(entity) {
+		this.owned.get(entity.owner)?.delete(entity);
+		for (const component of entity.heldComponents()) this.dropComponent(entity, component.id);
+		entity.index = null;
+	}
+	/** An entity in the index was given a component, or had it taken away. Told by the entity */
+	/** Whether the component with this id asks to be filed by owner */
+	byOwnerOf(id) {
+		return this.componentOf(id)?.index === "owner";
+	}
+	componentChanged(entity, id, has) {
+		if (has) this.fileComponent(entity, id);
+		else this.dropComponent(entity, id);
+	}
+	fileComponent(entity, id) {
+		file(this.components, id, entity);
+		this.inOrder.delete(id);
+		if (this.byOwnerOf(id)) {
+			let owners = this.byOwner.get(id);
+			if (!owners) this.byOwner.set(id, owners = /* @__PURE__ */ new Map());
+			file(owners, entity.owner, entity);
+		}
+	}
+	dropComponent(entity, id) {
+		if (this.components.get(id)?.delete(entity)) this.inOrder.delete(id);
+		this.byOwner.get(id)?.get(entity.owner)?.delete(entity);
+	}
+	/** Throws when the index does not say what the entities are. See `debugChecks` */
+	check(entities) {
+		let count = 0;
+		for (const entity of entities) {
+			count++;
+			const what = `${entity.def.id}#${entity.id}`;
+			if (!this.ownedBy(entity.owner).has(entity)) throw new Error(`Index: ${what} is not filed under its owner ${entity.owner}`);
+			for (const { id } of entity.heldComponents()) {
+				if (!this.components.get(id)?.has(entity)) throw new Error(`Index: ${what} is not filed under its component ${id}`);
+				if (this.byOwnerOf(id) && !this.byOwner.get(id)?.get(entity.owner)?.has(entity)) throw new Error(`Index: ${what} is not filed under its owner for its component ${id}`);
+			}
+		}
+		let filed = 0;
+		for (const set of this.owned.values()) filed += set.size;
+		if (filed !== count) throw new Error(`Index: ${filed} entities filed by owner, the world has ${count}`);
+		for (const [id, set] of this.components) for (const entity of set) if (!entity.heldComponents().some((held) => held.id === id)) throw new Error(`Index: ${entity.def.id}#${entity.id} is filed under ${id}, which it has not`);
+	}
+	clear() {
+		this.owned.clear();
+		this.components.clear();
+		this.byOwner.clear();
+		this.inOrder.clear();
+	}
+};
+function file(map, key, entity) {
+	let set = map.get(key);
+	if (!set) map.set(key, set = new ById());
+	if (entity.id > set.last) {
+		set.add(entity);
+		set.last = entity.id;
+		return;
+	}
+	if (set.has(entity)) return;
+	const again = new ById();
+	for (const each of set) {
+		if (each.id > entity.id) again.add(entity);
+		again.add(each);
+	}
+	again.add(entity);
+	again.last = set.last;
+	map.set(key, again);
+}
+//#endregion
+export { EntityIndex };
+
+//# sourceMappingURL=entityIndex.js.map

package/dist/entityIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entityIndex.js","names":[],"sources":["../src/entityIndex.ts"],"sourcesContent":["import type { Component } from './components'\nimport type { Entity, PlayerId } from './entity'\nimport type { World } from './world'\n\nconst none: ReadonlySet<Entity> = new Set()\n\n/** Entities in the order of their ids, with the highest id filed: what comes next goes at the end when it is higher */\nclass ById extends Set<Entity> {\n\tlast = 0\n}\n\n/**\n * Entities filed by what they are asked for by: whose they are, which have a component (and, for a component that\n * asks, whose they are too: `Component.index`). Answers questions like \"the heroes of player 2\"\n * or \"every shop\" without going through every entity of the world, most of which are trees. Kept up to date by the\n * world as entities come and go, and by the entities as they get or lose a component.\n *\n * Every set keeps entities in the order of their ids, the order they came into the world and the one a walk through\n * `World.entities` gives, however and whenever each was filed: one that changed owner or type, or was given a component\n * late, takes its place among the others, as it has in a world loaded from a save. Code that picks the first of equals\n * gets the same one either way. A set an entity is filed into out of its place is made again: a walk through it under\n * way goes on through the one it had\n */\nexport class EntityIndex {\n\t/**\n\t * `componentOf`: a component of the world's game by its id, an error for one it does not list (`registry.used`);\n\t * `worldOf`: the world it is the index of, which its entities reach through it (`Entity.order`)\n\t */\n\tconstructor(\n\t\tprivate readonly componentOf: (id: string) => Component<unknown, unknown> | undefined,\n\t\tprivate readonly worldOf: () => World\n\t) {}\n\n\t/** The world it is the index of */\n\tworld(): World {\n\t\treturn this.worldOf()\n\t}\n\n\tprivate readonly owned = new Map<PlayerId, ById>()\n\tprivate readonly components = new Map<string, ById>()\n\t/** By component id, then by owner: for the components that ask (`index: 'owner'`) */\n\tprivate readonly byOwner = new Map<string, Map<PlayerId, ById>>()\n\t/** By component id, what has it in the order of the entities' ids (`ordered`): made again once it changes */\n\tprivate readonly inOrder = new Map<string, readonly Entity[]>()\n\n\t/** Everything the player owns, dead heroes waiting to be brought back included */\n\townedBy(player: PlayerId): ReadonlySet<Entity> {\n\t\treturn this.owned.get(player) ?? none\n\t}\n\n\t/**\n\t * Everything that has the component; with a player, what the player owns of it, for a component filed by owner\n\t * (`Component.index: 'owner'`; throws for one that is not)\n\t */\n\twith(key: Component<unknown, unknown>, owner?: PlayerId): ReadonlySet<Entity> {\n\t\tif (owner === undefined) return this.components.get(key.id) ?? none\n\t\tconst owners = this.byOwner.get(key.id)\n\t\tif (!owners) {\n\t\t\tif (key.index === 'owner') return none\n\t\t\tthrow new Error(`Index: \"${key.id}\" is not filed by owner: define it with index: 'owner' to ask for a player's`)\n\t\t}\n\t\treturn owners.get(owner) ?? none\n\t}\n\n\t/**\n\t * Everything that has the component, in the order of the entities' ids: the order a walk through `World.units`\n\t * meets them in. What a system that runs over a component goes through (`System.over`), so a game plays the same\n\t * as one that looks at every actor. A list of its own, kept until what has the component changes: what is given it\n\t * or loses it while the list is gone through is in the next one\n\t */\n\tordered(key: Component<unknown, unknown>): readonly Entity[] {\n\t\tlet list = this.inOrder.get(key.id)\n\t\tif (!list) {\n\t\t\tconst set = this.components.get(key.id)\n\t\t\tlist = set ? [...set] : []\n\t\t\tthis.inOrder.set(key.id, list)\n\t\t}\n\t\treturn list\n\t}\n\n\tadd(entity: Entity): void {\n\t\tfile(this.owned, entity.owner, entity)\n\t\tfor (const component of entity.heldComponents()) this.fileComponent(entity, component.id)\n\t\tentity.index = this\n\t}\n\n\tremove(entity: Entity): void {\n\t\tthis.owned.get(entity.owner)?.delete(entity)\n\t\tfor (const component of entity.heldComponents()) this.dropComponent(entity, component.id)\n\t\tentity.index = null\n\t}\n\n\t/** An entity in the index was given a component, or had it taken away. Told by the entity */\n\t/** Whether the component with this id asks to be filed by owner */\n\tprivate byOwnerOf(id: string): boolean {\n\t\treturn this.componentOf(id)?.index === 'owner'\n\t}\n\n\tcomponentChanged(entity: Entity, id: string, has: boolean): void {\n\t\tif (has) this.fileComponent(entity, id)\n\t\telse this.dropComponent(entity, id)\n\t}\n\n\tprivate fileComponent(entity: Entity, id: string): void {\n\t\tfile(this.components, id, entity)\n\t\tthis.inOrder.delete(id)\n\t\tif (this.byOwnerOf(id)) {\n\t\t\tlet owners = this.byOwner.get(id)\n\t\t\tif (!owners) this.byOwner.set(id, (owners = new Map()))\n\t\t\tfile(owners, entity.owner, entity)\n\t\t}\n\t}\n\n\tprivate dropComponent(entity: Entity, id: string): void {\n\t\tif (this.components.get(id)?.delete(entity)) this.inOrder.delete(id)\n\t\tthis.byOwner.get(id)?.get(entity.owner)?.delete(entity)\n\t}\n\n\t/** Throws when the index does not say what the entities are. See `debugChecks` */\n\tcheck(entities: Iterable<Entity>): void {\n\t\tlet count = 0\n\t\tfor (const entity of entities) {\n\t\t\tcount++\n\t\t\tconst what = `${entity.def.id}#${entity.id}`\n\t\t\tif (!this.ownedBy(entity.owner).has(entity)) throw new Error(`Index: ${what} is not filed under its owner ${entity.owner}`)\n\t\t\tfor (const { id } of entity.heldComponents()) {\n\t\t\t\tif (!this.components.get(id)?.has(entity)) throw new Error(`Index: ${what} is not filed under its component ${id}`)\n\t\t\t\tif (this.byOwnerOf(id) && !this.byOwner.get(id)?.get(entity.owner)?.has(entity))\n\t\t\t\t\tthrow new Error(`Index: ${what} is not filed under its owner for its component ${id}`)\n\t\t\t}\n\t\t}\n\t\tlet filed = 0\n\t\tfor (const set of this.owned.values()) filed += set.size\n\t\tif (filed !== count) throw new Error(`Index: ${filed} entities filed by owner, the world has ${count}`)\n\t\tfor (const [id, set] of this.components) {\n\t\t\tfor (const entity of set)\n\t\t\t\tif (!entity.heldComponents().some((held) => held.id === id))\n\t\t\t\t\tthrow new Error(`Index: ${entity.def.id}#${entity.id} is filed under ${id}, which it has not`)\n\t\t}\n\t}\n\n\tclear(): void {\n\t\tthis.owned.clear()\n\t\tthis.components.clear()\n\t\tthis.byOwner.clear()\n\t\tthis.inOrder.clear()\n\t}\n}\n\nfunction file<K>(map: Map<K, ById>, key: K, entity: Entity): void {\n\tlet set = map.get(key)\n\tif (!set) map.set(key, (set = new ById()))\n\tif (entity.id > set.last) {\n\t\tset.add(entity)\n\t\tset.last = entity.id\n\t\treturn\n\t}\n\tif (set.has(entity)) return\n\t// out of its place: the set made again with it among the others\n\tconst again = new ById()\n\tfor (const each of set) {\n\t\tif (each.id > entity.id) again.add(entity)\n\t\tagain.add(each)\n\t}\n\tagain.add(entity)\n\tagain.last = set.last\n\tmap.set(key, again)\n}\n"],"mappings":"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"}

package/dist/errors.d.ts

@@ -1,6 +1,6 @@
 /**
  * What becomes of a part of a game that throws: a hook's handler, a listener, a system, a timer, a unit's order, a
- * player's command. The game says (`GameModule.onError`), or whoever runs it (a server, a page); a world that is told
+ * player's command. The game says (`Rules.onError`), or whoever runs it (a server, a page); a world that is told
  * nothing throws, as it always did, so that a test sees every error.
  */
 import type { EntityId, PlayerId } from './entity';
@@ -22,6 +22,7 @@ export type ErrorAnswer = 'throw' | 'end' | 'disable';
  * @beta
  */
 export interface ErrorSite {
+    /** What sort of part threw: a hook's handler, a listener, a system, a timer, a unit's order or a player's command */
     kind: 'hook' | 'listener' | 'system' | 'timer' | 'order' | 'command';
     /** Its id: the handler's, the listener's, the system's name, the timer's, the order's or the command's type */
     id: string;
@@ -48,12 +49,15 @@ export type ErrorPolicy = ErrorAnswer | ((error: unknown, where: ErrorSite, worl
 export interface WorldFailure {
     /** What is said to whoever played: no more than that it stopped, and in what */
     message: string;
+    /** The part that threw */
     where: ErrorSite;
+    /** The thrown error as plain data: its class name, its message and its stack where it had one */
     error: {
         name: string;
         message: string;
         stack?: string;
     };
+    /** The tick the world was stepping when the part threw */
     tick: number;
 }
 /** Thrown to leave the tick a game ends in (`end`): caught by `World.step`, and never seen outside it */
@@ -64,7 +68,7 @@ export declare class GameEnded extends Error {
 /**
  * Why a command was turned away (`commandRejected`): a type the game has not got, fields not as its definition says, a
  * player not in the game, a unit not theirs, one there is not, more than a tick takes, or a director's command sent
- * with no cinematic playing on the sender's screen (`withDirector`)
+ * with no cinematic playing on the sender's screen (`directorPack`)
  *
  * @beta
  */

package/dist/errors.js

@@ -0,0 +1,59 @@
+//#region src/errors.ts
+/** Thrown to leave the tick a game ends in (`end`): caught by `World.step`, and never seen outside it */
+var GameEnded = class extends Error {
+	failure;
+	constructor(failure) {
+		super(failure.message);
+		this.failure = failure;
+	}
+};
+/** What a part switched off is kept as (`world.disabled`, a save): its kind, id, hook and mod, nothing of the moment it threw */
+var siteOf = (where) => ({
+	kind: where.kind,
+	id: where.id,
+	...where.hook !== void 0 && { hook: where.hook },
+	...where.mod !== void 0 && { mod: where.mod }
+});
+/**
+* The name a part goes by among those switched off (`world.disabled`)
+*
+* @internal
+*/
+var siteKey = (where) => where.kind === "hook" ? `hook:${where.hook}:${where.id}` : `${where.kind}:${where.id}`;
+/**
+* A part in words: `the handler "thorns" of the hook "damage"`
+*
+* @beta
+*/
+function siteWords(where) {
+	switch (where.kind) {
+		case "hook": return `the handler "${where.id}" of the hook "${where.hook}"`;
+		case "listener": return `the listener "${where.id}"`;
+		case "system": return `the system "${where.id}"`;
+		case "timer": return `the timer "${where.id}"`;
+		case "order": return `the order "${where.id}" of the unit ${where.entity}`;
+		case "command": return `the command "${where.id}" of player ${where.player}`;
+	}
+}
+/** Which mod added or last changed each part of a game put together with mods, by the words `composeGame` knows it by */
+var changedBy = /* @__PURE__ */ new WeakMap();
+/** Kept by `composeGame` for the game it makes: who changed what, to say whose a part that throws is */
+function notePartOwners(game, owners) {
+	changedBy.set(game, owners);
+}
+/** The parts' owners as noted for a game: none for one without mods */
+var partOwners = (game) => changedBy.get(game) ?? /* @__PURE__ */ new Map();
+var PART_WORDS = {
+	hook: "hook handler",
+	listener: "listener",
+	system: "system",
+	timer: "timer",
+	order: "order",
+	command: "command"
+};
+/** The mod a part is of, when a mod added it or changed it: nothing for a part of the game itself */
+var modOfPart = (game, where) => game ? changedBy.get(game)?.get(`${PART_WORDS[where.kind]} "${where.id}"`) : void 0;
+//#endregion
+export { GameEnded, modOfPart, notePartOwners, partOwners, siteKey, siteOf, siteWords };
+
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\n * What becomes of a part of a game that throws: a hook's handler, a listener, a system, a timer, a unit's order, a\n * player's command. The game says (`Rules.onError`), or whoever runs it (a server, a page); a world that is told\n * nothing throws, as it always did, so that a test sees every error.\n */\nimport type { EntityId, PlayerId } from './entity'\nimport type { World } from './world'\n\n/**\n * - `throw`: the error goes on to whoever stepped the world. Nothing is hidden: for tests and development\n * - `end`: the game ends there, with the reason kept (`world.failure`) and told to the players. The world is not\n *   stepped again. What a server and a launched game do when nothing is said: one game ends, and nothing else does\n * - `disable`: the part that threw is switched off and the game goes on without it: the handler, the listener, the\n *   system or the timer no longer runs; the order is taken off its unit, the command refused. Never done unasked: a\n *   rule that is quietly gone is a game that goes quietly wrong\n *\n * @beta\n */\nexport type ErrorAnswer = 'throw' | 'end' | 'disable'\n\n/**\n * The part of the game that threw\n *\n * @beta\n */\nexport interface ErrorSite {\n\t/** What sort of part threw: a hook's handler, a listener, a system, a timer, a unit's order or a player's command */\n\tkind: 'hook' | 'listener' | 'system' | 'timer' | 'order' | 'command'\n\t/** Its id: the handler's, the listener's, the system's name, the timer's, the order's or the command's type */\n\tid: string\n\t/** The hook a handler is on */\n\thook?: string\n\t/** The unit whose order it was */\n\tentity?: EntityId\n\t/** The player whose command it was */\n\tplayer?: PlayerId\n\t/** The mod that added the part or changed it last, for a game with mods (`composeGame`) */\n\tmod?: string\n}\n\n/**\n * What to do about an error: the same for all of them, or decided for each\n *\n * @beta\n */\nexport type ErrorPolicy = ErrorAnswer | ((error: unknown, where: ErrorSite, world: World) => ErrorAnswer)\n\n/**\n * Why a game ended on an error (`world.failure`): plain data, for a log, a save's notes, a player's screen\n *\n * @beta\n */\nexport interface WorldFailure {\n\t/** What is said to whoever played: no more than that it stopped, and in what */\n\tmessage: string\n\t/** The part that threw */\n\twhere: ErrorSite\n\t/** The thrown error as plain data: its class name, its message and its stack where it had one */\n\terror: { name: string; message: string; stack?: string }\n\t/** The tick the world was stepping when the part threw */\n\ttick: number\n}\n\n/** Thrown to leave the tick a game ends in (`end`): caught by `World.step`, and never seen outside it */\nexport class GameEnded extends Error {\n\tconstructor(readonly failure: WorldFailure) {\n\t\tsuper(failure.message)\n\t}\n}\n\n/**\n * Why a command was turned away (`commandRejected`): a type the game has not got, fields not as its definition says, a\n * player not in the game, a unit not theirs, one there is not, more than a tick takes, or a director's command sent\n * with no cinematic playing on the sender's screen (`directorPack`)\n *\n * @beta\n */\nexport type RejectedKind = 'unknownType' | 'badFields' | 'noSuchPlayer' | 'notTheirs' | 'noSuchUnit' | 'tooMany' | 'notDirecting'\n\n/** What a part switched off is kept as (`world.disabled`, a save): its kind, id, hook and mod, nothing of the moment it threw */\nexport const siteOf = (where: ErrorSite): ErrorSite => ({\n\tkind: where.kind,\n\tid: where.id,\n\t...(where.hook !== undefined && { hook: where.hook }),\n\t...(where.mod !== undefined && { mod: where.mod })\n})\n\n/**\n * The name a part goes by among those switched off (`world.disabled`)\n *\n * @internal\n */\nexport const siteKey = (where: ErrorSite): string => (where.kind === 'hook' ? `hook:${where.hook}:${where.id}` : `${where.kind}:${where.id}`)\n\n/**\n * A part in words: `the handler \"thorns\" of the hook \"damage\"`\n *\n * @beta\n */\nexport function siteWords(where: ErrorSite): string {\n\tswitch (where.kind) {\n\t\tcase 'hook':\n\t\t\treturn `the handler \"${where.id}\" of the hook \"${where.hook}\"`\n\t\tcase 'listener':\n\t\t\treturn `the listener \"${where.id}\"`\n\t\tcase 'system':\n\t\t\treturn `the system \"${where.id}\"`\n\t\tcase 'timer':\n\t\t\treturn `the timer \"${where.id}\"`\n\t\tcase 'order':\n\t\t\treturn `the order \"${where.id}\" of the unit ${where.entity}`\n\t\tcase 'command':\n\t\t\treturn `the command \"${where.id}\" of player ${where.player}`\n\t}\n}\n\n/** Which mod added or last changed each part of a game put together with mods, by the words `composeGame` knows it by */\nconst changedBy = new WeakMap<object, ReadonlyMap<string, string>>()\n\n/** Kept by `composeGame` for the game it makes: who changed what, to say whose a part that throws is */\nexport function notePartOwners(game: object, owners: ReadonlyMap<string, string>): void {\n\tchangedBy.set(game, owners)\n}\n\n/** The parts' owners as noted for a game: none for one without mods */\nexport const partOwners = (game: object): ReadonlyMap<string, string> => changedBy.get(game) ?? new Map()\n\nconst PART_WORDS: Record<ErrorSite['kind'], string> = {\n\thook: 'hook handler',\n\tlistener: 'listener',\n\tsystem: 'system',\n\ttimer: 'timer',\n\torder: 'order',\n\tcommand: 'command'\n}\n\n/** The mod a part is of, when a mod added it or changed it: nothing for a part of the game itself */\nexport const modOfPart = (game: object | null | undefined, where: ErrorSite): string | undefined =>\n\tgame ? changedBy.get(game)?.get(`${PART_WORDS[where.kind]} \"${where.id}\"`) : undefined\n"],"mappings":";;AAgEA,IAAa,YAAb,cAA+B,MAAM;CACf;CAArB,YAAY,SAAgC;EAC3C,MAAM,QAAQ,OAAO;EADD,KAAA,UAAA;CAErB;AACD;;AAYA,IAAa,UAAU,WAAiC;CACvD,MAAM,MAAM;CACZ,IAAI,MAAM;CACV,GAAI,MAAM,SAAS,KAAA,KAAa,EAAE,MAAM,MAAM,KAAK;CACnD,GAAI,MAAM,QAAQ,KAAA,KAAa,EAAE,KAAK,MAAM,IAAI;AACjD;;;;;;AAOA,IAAa,WAAW,UAA8B,MAAM,SAAS,SAAS,QAAQ,MAAM,KAAK,GAAG,MAAM,OAAO,GAAG,MAAM,KAAK,GAAG,MAAM;;;;;;AAOxI,SAAgB,UAAU,OAA0B;CACnD,QAAQ,MAAM,MAAd;EACC,KAAK,QACJ,OAAO,gBAAgB,MAAM,GAAG,iBAAiB,MAAM,KAAK;EAC7D,KAAK,YACJ,OAAO,iBAAiB,MAAM,GAAG;EAClC,KAAK,UACJ,OAAO,eAAe,MAAM,GAAG;EAChC,KAAK,SACJ,OAAO,cAAc,MAAM,GAAG;EAC/B,KAAK,SACJ,OAAO,cAAc,MAAM,GAAG,gBAAgB,MAAM;EACrD,KAAK,WACJ,OAAO,gBAAgB,MAAM,GAAG,cAAc,MAAM;CACtD;AACD;;AAGA,IAAM,4BAAY,IAAI,QAA6C;;AAGnE,SAAgB,eAAe,MAAc,QAA2C;CACvF,UAAU,IAAI,MAAM,MAAM;AAC3B;;AAGA,IAAa,cAAc,SAA8C,UAAU,IAAI,IAAI,qBAAK,IAAI,IAAI;AAExG,IAAM,aAAgD;CACrD,MAAM;CACN,UAAU;CACV,QAAQ;CACR,OAAO;CACP,OAAO;CACP,SAAS;AACV;;AAGA,IAAa,aAAa,MAAiC,UAC1D,OAAO,UAAU,IAAI,IAAI,CAAC,EAAE,IAAI,GAAG,WAAW,MAAM,MAAM,IAAI,MAAM,GAAG,EAAE,IAAI,KAAA"}

package/dist/events.d.ts

@@ -14,6 +14,7 @@ export type EventAudience<T> = 'everyone' | ((payload: T, view: SessionView) =>
  * @beta
  */
 export interface EventKey<T> {
+    /** The event's id, unique among the game's events */
     readonly id: string;
     /** Sent to the screens of these players, in their snapshots. Only to whoever listens in the world when left out */
     readonly replicate?: EventAudience<T>;
@@ -21,23 +22,24 @@ export interface EventKey<T> {
     readonly payload?: T;
 }
 /**
- * An event of a game's own: `const through = defineEvent<{ unit: string }>('td.invaderThrough', { replicate: 'everyone' })`.
+ * An event of a game's own: `const through = defineEvent<{ unit: string }>({ id: 'td.invaderThrough', replicate: 'everyone' })`.
  * Emitted on `world.events` like the engine's (`world.events.emit(through, { unit })`), held to the end of the tick
  * like them, and listened to with `defineListener`. Ids are shared by every game: give them a prefix of the game's.
  *
  * A replicated event goes to the players' screens, where `GameView.on` and the renderers get it: what it says has
  * to be plain data then (numbers, text, lists, plain objects), with entities by id, as it may cross a network
  *
- * @beta
+ * @public
  */
-export declare function defineEvent<T>(id: string, options?: {
+export declare function defineEvent<T>(def: {
+    id: string;
     replicate?: EventAudience<T>;
 }): EventKey<T>;
 /** Whether an event is one of a game's own, rather than one of the engine's */
 export declare const isGameEvent: (id: PropertyKey) => boolean;
 /**
  * How a game reacts to an event: the engine's (`'entityDied'`, `'enteredArea'`) or one of its own. Listeners are
- * given in `GameModule.listeners`, and the world subscribes them when it is made, in their order: a new game, a
+ * given in `Rules.listeners`, and the world subscribes them when it is made, in their order: a new game, a
  * loaded save and every player's machine get the same ones. They run at the end of the tick, once everything in it
  * is settled, and may change the world: what happens then is part of that tick. One with the id of another takes
  * its place, in a mod
@@ -45,14 +47,17 @@ export declare const isGameEvent: (id: PropertyKey) => boolean;
  * @beta
  */
 export interface ListenerDef {
+    /** The listener's id; a listener of another with the same id takes its place */
     id: string;
+    /** The event it reacts to */
     event: EventKey<any>;
+    /** Reacts to one occurrence of the event, with the world and the event's payload */
     run(world: World, payload: any): void;
 }
 /**
  * Typed help for writing a listener: `defineListener({ event: enteredArea, id: 'td.gate', run(world, { area, entity }) { ... } })`
  *
- * @beta
+ * @public
  */
 export declare function defineListener<T>(def: {
     id: string;
@@ -69,6 +74,7 @@ export declare function defineListener<T>(def: {
 export declare class Emitter {
     private handlers;
     private held;
+    /** What waits while held: the type of each, then what it says, so that an event held makes no object to hold it in */
     private queue;
     /** True while what was held back goes out (`release`) */
     releasing: boolean;

package/dist/events.js

@@ -0,0 +1,158 @@
+//#region src/events.ts
+/**
+* Every event defined in the process by id, the last of an id winning (`defineEvent`). No world reads an event's
+* definition here: a server may hold rooms of different games, a game be reloaded, a mod define events of its own, so
+* one id may be defined more than one way. A world finds its game's own in its registry (`Rules.events`), and the
+* engine's in `engines`; this only says whether an id is one of a game's (`isGameEvent`), and what is deprecated (E7)
+*/
+var defined = /* @__PURE__ */ new Map();
+/** The engine's own events by id (`defineEngineEvent`): the first of an id, as the engine defined it. What every world finds them by */
+var engines = /* @__PURE__ */ new Map();
+/**
+* An event of a game's own: `const through = defineEvent<{ unit: string }>({ id: 'td.invaderThrough', replicate: 'everyone' })`.
+* Emitted on `world.events` like the engine's (`world.events.emit(through, { unit })`), held to the end of the tick
+* like them, and listened to with `defineListener`. Ids are shared by every game: give them a prefix of the game's.
+*
+* A replicated event goes to the players' screens, where `GameView.on` and the renderers get it: what it says has
+* to be plain data then (numbers, text, lists, plain objects), with entities by id, as it may cross a network
+*
+* @public
+*/
+function defineEvent(def) {
+	const { id } = def;
+	const key = { ...def };
+	defined.set(id, key);
+	return key;
+}
+/**
+* One of the engine's own events that goes through the world as a game's own does (`core.captured`): `defineEvent`,
+* and kept as the engine's, which every world finds (`Registry.event`) whatever else in the process defines its id
+*
+* @internal
+*/
+function defineEngineEvent(def) {
+	const key = defineEvent(def);
+	if (!engines.has(def.id)) engines.set(def.id, key);
+	return key;
+}
+/**
+* The engine's own event of this id (`defineEngineEvent`), as the engine defined it, if any
+*
+* @internal
+*/
+var engineEventById = (id) => engines.get(id);
+/**
+* One of the engine's events (`engineEvents.ts`): a key as a game's own is, but not one of a game's (`isGameEvent`),
+* and told to the players only by what replicates it (`replicateEvent`)
+*
+* @internal
+*/
+var engineEvent = (id) => ({ id });
+/**
+* The event defined last with this id, in this process, if any: of whichever game or mod defined it last
+*
+* @deprecated A process may have more than one definition of an id (rooms of different games on one server, a
+* game reloaded, a mod): ask the world's registry, `world.registry.event(id)`, which finds its own game's
+*
+* @internal
+*/
+var eventById = (id) => defined.get(id);
+/** Whether an event is one of a game's own, rather than one of the engine's */
+var isGameEvent = (id) => typeof id === "string" && defined.has(id);
+/**
+* The events that go to the screen, of every game of the process, each as defined last
+*
+* @deprecated Of every game of the process, the last definition of an id winning: what goes to a world's players is
+* what its game lists (`Rules.events`) and the engine's, found by `world.registry.event(id)`
+*
+* @internal
+*/
+var replicatedEvents = () => [...defined.values()].filter((key) => key.replicate);
+/**
+* Typed help for writing a listener: `defineListener({ event: enteredArea, id: 'td.gate', run(world, { area, entity }) { ... } })`
+*
+* @public
+*/
+function defineListener(def) {
+	return def;
+}
+/**
+* Minimal typed event emitter: each event by its key (`EventKey`), which types what it says.
+*
+* While held (`hold`), what is emitted waits in a queue and goes out on `release`, in the order it happened.
+* The world holds its events for the length of a tick, so that whoever listens sees how things stand once
+* the tick is over, and cannot change anything halfway through it.
+*/
+var Emitter = class {
+	handlers = /* @__PURE__ */ new Map();
+	held = false;
+	/** What waits while held: the type of each, then what it says, so that an event held makes no object to hold it in */
+	queue = [];
+	/** True while what was held back goes out (`release`) */
+	releasing = false;
+	taps = /* @__PURE__ */ new Set();
+	watchers = /* @__PURE__ */ new Set();
+	/**
+	* Calls back for every event as it goes out, before whoever listens to it: the event log of the debug tools, a
+	* logger. Any number of them. Returns what stops it
+	*/
+	tap(listener) {
+		this.taps.add(listener);
+		return () => this.taps.delete(listener);
+	}
+	/**
+	* Calls back for every event as it goes out, whatever it is, after whoever listens to it by name: for what cannot
+	* know ahead which events there will be, as a player's seat that passes on a game's own. Returns what stops it
+	*/
+	watch(watcher) {
+		this.watchers.add(watcher);
+		return () => this.watchers.delete(watcher);
+	}
+	/** Listens to an event, the engine's (`engineEvents.ts`) or a game's own. Returns what stops it */
+	on(key, handler) {
+		const { id } = key;
+		let set = this.handlers.get(id);
+		if (!set) this.handlers.set(id, set = /* @__PURE__ */ new Set());
+		set.add(handler);
+		return () => set.delete(handler);
+	}
+	emit(key, payload) {
+		const { id } = key;
+		if (this.held) {
+			this.queue.push(id, payload);
+			return;
+		}
+		this.deliver(id, payload);
+	}
+	/** Holds back what is emitted from now on, until `release` */
+	hold() {
+		this.held = true;
+	}
+	/** Sends out everything held back, and stops holding */
+	release() {
+		this.held = false;
+		const queue = this.queue;
+		this.queue = [];
+		this.releasing = true;
+		try {
+			for (let i = 0; i < queue.length; i += 2) this.deliver(queue[i], queue[i + 1]);
+		} finally {
+			this.releasing = false;
+		}
+	}
+	deliver(type, payload) {
+		for (const tap of this.taps) tap(type, payload);
+		const set = this.handlers.get(type);
+		if (set) for (const handler of set) handler(payload);
+		for (const watcher of this.watchers) watcher(type, payload);
+	}
+	clear() {
+		this.handlers.clear();
+		this.watchers.clear();
+		this.queue = [];
+	}
+};
+//#endregion
+export { Emitter, defineEngineEvent, defineEvent, defineListener, engineEvent, engineEventById, eventById, isGameEvent, replicatedEvents };
+
+//# sourceMappingURL=events.js.map

package/dist/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","names":[],"sources":["../src/events.ts"],"sourcesContent":["import type { SessionView } from './replication'\nimport type { World } from './world'\n\ntype Handler<T> = (payload: T) => void\n\n/**\n * Who of the players gets an event of a game's own on their screen (see `defineEvent`): everyone, or those a\n * function picks, from what the event says and what the seat may know (`SessionView`: its player, `knows`, `sees`)\n *\n * @beta\n */\nexport type EventAudience<T> = 'everyone' | ((payload: T, view: SessionView) => boolean)\n\n/**\n * A typed key for an event of a game's own, made with `defineEvent`\n *\n * @beta\n */\nexport interface EventKey<T> {\n\t/** The event's id, unique among the game's events */\n\treadonly id: string\n\t/** Sent to the screens of these players, in their snapshots. Only to whoever listens in the world when left out */\n\treadonly replicate?: EventAudience<T>\n\t/** Only there for the type of the payload */\n\treadonly payload?: T\n}\n\n/**\n * Every event defined in the process by id, the last of an id winning (`defineEvent`). No world reads an event's\n * definition here: a server may hold rooms of different games, a game be reloaded, a mod define events of its own, so\n * one id may be defined more than one way. A world finds its game's own in its registry (`Rules.events`), and the\n * engine's in `engines`; this only says whether an id is one of a game's (`isGameEvent`), and what is deprecated (E7)\n */\nconst defined = new Map<string, EventKey<unknown>>()\n\n/** The engine's own events by id (`defineEngineEvent`): the first of an id, as the engine defined it. What every world finds them by */\nconst engines = new Map<string, EventKey<unknown>>()\n\n/**\n * An event of a game's own: `const through = defineEvent<{ unit: string }>({ id: 'td.invaderThrough', replicate: 'everyone' })`.\n * Emitted on `world.events` like the engine's (`world.events.emit(through, { unit })`), held to the end of the tick\n * like them, and listened to with `defineListener`. Ids are shared by every game: give them a prefix of the game's.\n *\n * A replicated event goes to the players' screens, where `GameView.on` and the renderers get it: what it says has\n * to be plain data then (numbers, text, lists, plain objects), with entities by id, as it may cross a network\n *\n * @public\n */\nexport function defineEvent<T>(def: { id: string; replicate?: EventAudience<T> }): EventKey<T> {\n\tconst { id } = def\n\tconst key: EventKey<T> = { ...def }\n\t// the last of an id, of the process: no world is told by it (see `defined`)\n\tdefined.set(id, key as EventKey<unknown>)\n\treturn key\n}\n\n/**\n * One of the engine's own events that goes through the world as a game's own does (`core.captured`): `defineEvent`,\n * and kept as the engine's, which every world finds (`Registry.event`) whatever else in the process defines its id\n *\n * @internal\n */\nexport function defineEngineEvent<T>(def: { id: string; replicate?: EventAudience<T> }): EventKey<T> {\n\tconst key = defineEvent(def)\n\tif (!engines.has(def.id)) engines.set(def.id, key as EventKey<unknown>)\n\treturn key\n}\n\n/**\n * The engine's own event of this id (`defineEngineEvent`), as the engine defined it, if any\n *\n * @internal\n */\nexport const engineEventById = (id: string): EventKey<unknown> | undefined => engines.get(id)\n\n/**\n * One of the engine's events (`engineEvents.ts`): a key as a game's own is, but not one of a game's (`isGameEvent`),\n * and told to the players only by what replicates it (`replicateEvent`)\n *\n * @internal\n */\nexport const engineEvent = <T>(id: string): EventKey<T> => ({ id })\n\n/**\n * The event defined last with this id, in this process, if any: of whichever game or mod defined it last\n *\n * @deprecated A process may have more than one definition of an id (rooms of different games on one server, a\n * game reloaded, a mod): ask the world's registry, `world.registry.event(id)`, which finds its own game's\n *\n * @internal\n */\nexport const eventById = (id: string): EventKey<unknown> | undefined => defined.get(id)\n\n/** Whether an event is one of a game's own, rather than one of the engine's */\nexport const isGameEvent = (id: PropertyKey): boolean => typeof id === 'string' && defined.has(id)\n\n/**\n * The events that go to the screen, of every game of the process, each as defined last\n *\n * @deprecated Of every game of the process, the last definition of an id winning: what goes to a world's players is\n * what its game lists (`Rules.events`) and the engine's, found by `world.registry.event(id)`\n *\n * @internal\n */\nexport const replicatedEvents = (): EventKey<unknown>[] => [...defined.values()].filter((key) => key.replicate)\n\n/**\n * How a game reacts to an event: the engine's (`'entityDied'`, `'enteredArea'`) or one of its own. Listeners are\n * given in `Rules.listeners`, and the world subscribes them when it is made, in their order: a new game, a\n * loaded save and every player's machine get the same ones. They run at the end of the tick, once everything in it\n * is settled, and may change the world: what happens then is part of that tick. One with the id of another takes\n * its place, in a mod\n *\n * @beta\n */\nexport interface ListenerDef {\n\t/** The listener's id; a listener of another with the same id takes its place */\n\tid: string\n\t/** The event it reacts to */\n\tevent: EventKey<any>\n\t/** Reacts to one occurrence of the event, with the world and the event's payload */\n\trun(world: World, payload: any): void\n}\n\n/**\n * Typed help for writing a listener: `defineListener({ event: enteredArea, id: 'td.gate', run(world, { area, entity }) { ... } })`\n *\n * @public\n */\nexport function defineListener<T>(def: { id: string; event: EventKey<T>; run(world: World, payload: T): void }): ListenerDef {\n\treturn def\n}\n\n/**\n * Minimal typed event emitter: each event by its key (`EventKey`), which types what it says.\n *\n * While held (`hold`), what is emitted waits in a queue and goes out on `release`, in the order it happened.\n * The world holds its events for the length of a tick, so that whoever listens sees how things stand once\n * the tick is over, and cannot change anything halfway through it.\n */\nexport class Emitter {\n\tprivate handlers = new Map<PropertyKey, Set<Handler<any>>>()\n\tprivate held = false\n\t/** What waits while held: the type of each, then what it says, so that an event held makes no object to hold it in */\n\tprivate queue: unknown[] = []\n\t/** True while what was held back goes out (`release`) */\n\treleasing = false\n\tprivate readonly taps = new Set<(type: PropertyKey, payload: unknown) => void>()\n\tprivate readonly watchers = new Set<(type: PropertyKey, payload: unknown) => void>()\n\n\t/**\n\t * Calls back for every event as it goes out, before whoever listens to it: the event log of the debug tools, a\n\t * logger. Any number of them. Returns what stops it\n\t */\n\ttap(listener: (type: PropertyKey, payload: unknown) => void): () => void {\n\t\tthis.taps.add(listener)\n\t\treturn () => this.taps.delete(listener)\n\t}\n\n\t/**\n\t * Calls back for every event as it goes out, whatever it is, after whoever listens to it by name: for what cannot\n\t * know ahead which events there will be, as a player's seat that passes on a game's own. Returns what stops it\n\t */\n\twatch(watcher: (type: PropertyKey, payload: unknown) => void): () => void {\n\t\tthis.watchers.add(watcher)\n\t\treturn () => this.watchers.delete(watcher)\n\t}\n\n\t/** Listens to an event, the engine's (`engineEvents.ts`) or a game's own. Returns what stops it */\n\ton<T>(key: EventKey<T>, handler: Handler<T>): () => void {\n\t\tconst { id } = key\n\t\tlet set = this.handlers.get(id)\n\t\tif (!set) this.handlers.set(id, (set = new Set()))\n\t\tset.add(handler)\n\t\treturn () => set.delete(handler)\n\t}\n\n\temit<T>(key: EventKey<T>, payload: T): void {\n\t\tconst { id } = key\n\t\tif (this.held) {\n\t\t\tthis.queue.push(id, payload)\n\t\t\treturn\n\t\t}\n\t\tthis.deliver(id, payload)\n\t}\n\n\t/** Holds back what is emitted from now on, until `release` */\n\thold(): void {\n\t\tthis.held = true\n\t}\n\n\t/** Sends out everything held back, and stops holding */\n\trelease(): void {\n\t\tthis.held = false\n\t\t// what a listener emits while this goes on is sent at once, after what it is reacting to\n\t\tconst queue = this.queue\n\t\tthis.queue = []\n\t\tthis.releasing = true\n\t\ttry {\n\t\t\tfor (let i = 0; i < queue.length; i += 2) this.deliver(queue[i] as PropertyKey, queue[i + 1])\n\t\t} finally {\n\t\t\tthis.releasing = false\n\t\t}\n\t}\n\n\tprivate deliver(type: PropertyKey, payload: unknown): void {\n\t\tfor (const tap of this.taps) tap(type, payload)\n\t\tconst set = this.handlers.get(type)\n\t\tif (set) for (const handler of set) handler(payload)\n\t\tfor (const watcher of this.watchers) watcher(type, payload)\n\t}\n\n\tclear(): void {\n\t\tthis.handlers.clear()\n\t\tthis.watchers.clear()\n\t\tthis.queue = []\n\t}\n}\n"],"mappings":";;;;;;;AAiCA,IAAM,0BAAU,IAAI,IAA+B;;AAGnD,IAAM,0BAAU,IAAI,IAA+B;;;;;;;;;;;AAYnD,SAAgB,YAAe,KAAgE;CAC9F,MAAM,EAAE,OAAO;CACf,MAAM,MAAmB,EAAE,GAAG,IAAI;CAElC,QAAQ,IAAI,IAAI,GAAwB;CACxC,OAAO;AACR;;;;;;;AAQA,SAAgB,kBAAqB,KAAgE;CACpG,MAAM,MAAM,YAAY,GAAG;CAC3B,IAAI,CAAC,QAAQ,IAAI,IAAI,EAAE,GAAG,QAAQ,IAAI,IAAI,IAAI,GAAwB;CACtE,OAAO;AACR;;;;;;AAOA,IAAa,mBAAmB,OAA8C,QAAQ,IAAI,EAAE;;;;;;;AAQ5F,IAAa,eAAkB,QAA6B,EAAE,GAAG;;;;;;;;;AAUjE,IAAa,aAAa,OAA8C,QAAQ,IAAI,EAAE;;AAGtF,IAAa,eAAe,OAA6B,OAAO,OAAO,YAAY,QAAQ,IAAI,EAAE;;;;;;;;;AAUjG,IAAa,yBAA8C,CAAC,GAAG,QAAQ,OAAO,CAAC,CAAC,CAAC,QAAQ,QAAQ,IAAI,SAAS;;;;;;AAyB9G,SAAgB,eAAkB,KAA2F;CAC5H,OAAO;AACR;;;;;;;;AASA,IAAa,UAAb,MAAqB;CACpB,2BAAmB,IAAI,IAAoC;CAC3D,OAAe;;CAEf,QAA2B,CAAC;;CAE5B,YAAY;CACZ,uBAAwB,IAAI,IAAmD;CAC/E,2BAA4B,IAAI,IAAmD;;;;;CAMnF,IAAI,UAAqE;EACxE,KAAK,KAAK,IAAI,QAAQ;EACtB,aAAa,KAAK,KAAK,OAAO,QAAQ;CACvC;;;;;CAMA,MAAM,SAAoE;EACzE,KAAK,SAAS,IAAI,OAAO;EACzB,aAAa,KAAK,SAAS,OAAO,OAAO;CAC1C;;CAGA,GAAM,KAAkB,SAAiC;EACxD,MAAM,EAAE,OAAO;EACf,IAAI,MAAM,KAAK,SAAS,IAAI,EAAE;EAC9B,IAAI,CAAC,KAAK,KAAK,SAAS,IAAI,IAAK,sBAAM,IAAI,IAAI,CAAE;EACjD,IAAI,IAAI,OAAO;EACf,aAAa,IAAI,OAAO,OAAO;CAChC;CAEA,KAAQ,KAAkB,SAAkB;EAC3C,MAAM,EAAE,OAAO;EACf,IAAI,KAAK,MAAM;GACd,KAAK,MAAM,KAAK,IAAI,OAAO;GAC3B;EACD;EACA,KAAK,QAAQ,IAAI,OAAO;CACzB;;CAGA,OAAa;EACZ,KAAK,OAAO;CACb;;CAGA,UAAgB;EACf,KAAK,OAAO;EAEZ,MAAM,QAAQ,KAAK;EACnB,KAAK,QAAQ,CAAC;EACd,KAAK,YAAY;EACjB,IAAI;GACH,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,GAAG,KAAK,QAAQ,MAAM,IAAmB,MAAM,IAAI,EAAE;EAC7F,UAAU;GACT,KAAK,YAAY;EAClB;CACD;CAEA,QAAgB,MAAmB,SAAwB;EAC1D,KAAK,MAAM,OAAO,KAAK,MAAM,IAAI,MAAM,OAAO;EAC9C,MAAM,MAAM,KAAK,SAAS,IAAI,IAAI;EAClC,IAAI,KAAK,KAAK,MAAM,WAAW,KAAK,QAAQ,OAAO;EACnD,KAAK,MAAM,WAAW,KAAK,UAAU,QAAQ,MAAM,OAAO;CAC3D;CAEA,QAAc;EACb,KAAK,SAAS,MAAM;EACpB,KAAK,SAAS,MAAM;EACpB,KAAK,QAAQ,CAAC;CACf;AACD"}