@jsprismarine/spawning 0.0.0 → 0.16.0-unstable-20261029140140

package/dist/spawner.es.js

@@ -0,0 +1,278 @@
+import { SPAWN_CONSTANTS, poolCapFor } from "./constants.es.js";
+import { SpawnDelays, evaluateSpawnCondition } from "./conditions.es.js";
+import { VANILLA_ENGINE_SPAWN_RULES } from "./engineRules.es.js";
+// src/spawner.ts
+/** Splits `minecraft:pillager<minecraft:spawn_as_patrol_follower>` into its two halves. */
+var splitSpawnType = (value) => {
+	const match = /^(?<identifier>[^<]+)<(?<event>[^>]+)>$/.exec(value);
+	if (match?.groups === void 0) return { identifier: value };
+	return {
+		identifier: match.groups.identifier,
+		event: match.groups.event
+	};
+};
+/** Draws an integer in the inclusive range, which is how every size and offset is picked. */
+var between = (random, min, max) => max <= min ? min : min + random.nextInt(max - min + 1);
+/**
+* Builds the permutation each herd member spawns as.
+*
+* `min_guaranteed` members take their permutation before the weighted draw
+* runs, which is what makes the pillager patrol's captain and the zombie
+* herd's one villager certain.
+*/
+var permutationsFor = (permutations, size, random) => {
+	const members = [];
+	for (const permutation of permutations) for (let index = 0; index < permutation.minGuaranteed && members.length < size; index += 1) members.push(permutation);
+	const total = permutations.reduce((sum, permutation) => sum + Math.max(0, permutation.weight), 0);
+	while (members.length < size) {
+		if (total <= 0) {
+			members.push(void 0);
+			continue;
+		}
+		let roll = random.nextFloat() * total;
+		let chosen;
+		for (const permutation of permutations) {
+			roll -= Math.max(0, permutation.weight);
+			if (roll < 0) {
+				chosen = permutation;
+				break;
+			}
+		}
+		members.push(chosen ?? permutations[permutations.length - 1]);
+	}
+	return members;
+};
+/**
+* The event one herd member runs.
+*
+* `initial_event` wins for the first `initial_event_count` members, `event`
+* takes every member past `event_skip_count`, and a permutation's `<event>`
+* suffix or the condition's `minecraft:spawn_event` fills in for the rest.
+*/
+var eventForMember = (index, herd, permutationEvent, condition) => {
+	if (herd?.initialEvent !== void 0 && index < herd.initialEventCount) return herd.initialEvent;
+	if (herd?.event !== void 0 && index >= herd.eventSkipCount) return herd.event;
+	return permutationEvent ?? condition.spawnEvent;
+};
+/** Runs the spawn loop for one world. */
+var Spawner = class {
+	rulesByPool = /* @__PURE__ */ new Map();
+	world;
+	random;
+	constants;
+	delays;
+	engineRules;
+	onUnanswered;
+	constructor(options) {
+		this.world = options.world;
+		this.random = options.random;
+		this.constants = options.constants ?? SPAWN_CONSTANTS;
+		this.delays = options.delays ?? new SpawnDelays();
+		this.engineRules = options.engineRules ?? VANILLA_ENGINE_SPAWN_RULES;
+		this.onUnanswered = options.onUnanswered;
+		for (const rule of options.rules) {
+			const pool = rule.populationControl;
+			if (pool === void 0) continue;
+			const existing = this.rulesByPool.get(pool);
+			if (existing === void 0) this.rulesByPool.set(pool, [rule]);
+			else existing.push(rule);
+		}
+	}
+	/** The pools the loaded rules name, which is what {@link tick} cycles. */
+	get pools() {
+		return [...this.rulesByPool.keys()];
+	}
+	/**
+	* Runs every pool whose cadence falls on this tick.
+	*
+	* @returns Every entity to create, in the order the cycles produced them.
+	*/
+	tick(tick) {
+		const requests = [];
+		for (const pool of this.rulesByPool.keys()) {
+			const cadence = this.constants.pools[pool]?.cycleTicks;
+			if (cadence === void 0 || cadence <= 0 || tick % cadence !== 0) continue;
+			requests.push(...this.cycle(pool, tick));
+		}
+		return requests;
+	}
+	/**
+	* Runs one cycle of one pool, whatever the cadence says.
+	*
+	* @returns Every entity to create, never more than the pool's remaining cap.
+	*/
+	cycle(pool, tick) {
+		const rules = this.rulesByPool.get(pool);
+		if (rules === void 0 || rules.length === 0) return [];
+		const players = this.world.players();
+		if (players.length === 0) return [];
+		const cap = poolCapFor(pool, players.length, this.constants);
+		let remaining = cap === void 0 ? Number.POSITIVE_INFINITY : cap - this.world.poolCount(pool);
+		if (remaining <= 0) return [];
+		const requests = [];
+		const { spawnRadiusChunks, chunksPerCycle, positionsPerChunk } = this.constants;
+		for (const player of players) {
+			const playerChunkX = Math.floor(player.position.x / 16);
+			const playerChunkZ = Math.floor(player.position.z / 16);
+			for (let sample = 0; sample < chunksPerCycle && remaining > 0; sample += 1) {
+				const chunkX = playerChunkX + between(this.random, -spawnRadiusChunks, spawnRadiusChunks);
+				const chunkZ = playerChunkZ + between(this.random, -spawnRadiusChunks, spawnRadiusChunks);
+				for (let attempt = 0; attempt < positionsPerChunk && remaining > 0; attempt += 1) for (const pass of ["surface", "underground"]) {
+					if (remaining <= 0) break;
+					const position = this.positionIn(chunkX, chunkZ, pass);
+					if (position === void 0) continue;
+					const spawned = this.attemptAt(pool, rules, position, pass, tick, remaining);
+					remaining -= spawned.length;
+					requests.push(...spawned);
+				}
+			}
+		}
+		return requests;
+	}
+	/**
+	* Draws one position inside a chunk for one pass.
+	*
+	* @returns The position, or undefined when the column is unloaded or the draw landed
+	*   somewhere no entity fits.
+	*/
+	positionIn(chunkX, chunkZ, pass) {
+		const x = chunkX * 16 + this.random.nextInt(16);
+		const z = chunkZ * 16 + this.random.nextInt(16);
+		if (pass === "surface") return this.surfacePosition(x, z);
+		const top = this.world.surfaceY(x, z);
+		if (top === void 0) return void 0;
+		const floor = this.world.minY();
+		if (top - 1 < floor) return void 0;
+		const at = {
+			x,
+			y: between(this.random, floor, top - 1),
+			z
+		};
+		return this.fits(at) ? at : void 0;
+	}
+	/** The top spawn position in a column, using the water surface when one covers the terrain. */
+	surfacePosition(x, z) {
+		const top = this.world.surfaceY(x, z);
+		if (top === void 0) return void 0;
+		const surface = {
+			x,
+			y: top,
+			z
+		};
+		if (this.world.site("underwater", surface)) return surface;
+		const waterSurface = {
+			...surface,
+			y: top - 1
+		};
+		return this.world.site("underwater", waterSurface) ? waterSurface : surface;
+	}
+	/** Whether an entity fits at a position: its own block and the one over its head are free. */
+	fits(at) {
+		return !this.world.solid(at) && !this.world.solid({
+			...at,
+			y: at.y + 1
+		});
+	}
+	/**
+	* Runs one attempt: collect the rules that pass here, draw one, and build
+	* its herd.
+	*
+	* A rule with an engine condition is asked that first, because a condition
+	* Bedrock keeps in code is a condition the file was never able to state.
+	* `minecraft:slime` is the rule this matters to: its file names no
+	* brightness and no height, so without the engine condition it is the only
+	* monster that passes in daylight and it fills the pool on its own.
+	*/
+	attemptAt(pool, rules, position, pass, tick, remaining) {
+		const candidates = [];
+		let totalWeight = 0;
+		for (const rule of rules) {
+			if (this.world.structureSpawnOverrideAt?.(rule.identifier, position) === false) continue;
+			const engineRule = this.engineRules.get(rule.identifier);
+			if (engineRule !== void 0 && !engineRule(position, {
+				world: this.world,
+				random: this.random
+			})) continue;
+			for (const condition of rule.conditions) {
+				if (!evaluateSpawnCondition(condition, position, this.contextFor(rule, tick), pass).passed) continue;
+				candidates.push({
+					rule,
+					condition
+				});
+				totalWeight += Math.max(0, condition.weight.default);
+			}
+		}
+		if (candidates.length === 0 || totalWeight <= 0) return [];
+		let roll = this.random.nextFloat() * totalWeight;
+		let chosen = candidates[candidates.length - 1];
+		for (const candidate of candidates) {
+			roll -= Math.max(0, candidate.condition.weight.default);
+			if (roll < 0) {
+				chosen = candidate;
+				break;
+			}
+		}
+		const { rarity } = chosen.condition.weight;
+		if (rarity > 0 && this.random.nextFloat() * rarity >= 1) return [];
+		if (chosen.condition.delay !== void 0) this.delays.scheduleFrom(chosen.condition.delay, tick, this.random);
+		return this.herdAt(pool, chosen, position, pass, remaining);
+	}
+	/** Builds one herd around an anchor position. */
+	herdAt(pool, candidate, anchor, pass, remaining) {
+		const { condition, rule } = candidate;
+		const herd = condition.herd.length === 0 ? void 0 : condition.herd[this.random.nextInt(condition.herd.length)];
+		const drawn = herd === void 0 ? 1 : between(this.random, herd.minSize, herd.maxSize);
+		const size = Math.max(0, Math.min(drawn, remaining));
+		if (size === 0) return [];
+		const permutations = condition.permutations === void 0 ? void 0 : permutationsFor(condition.permutations, size, this.random);
+		const requests = [];
+		for (let index = 0; index < size; index += 1) {
+			const permutation = permutations?.[index];
+			const swapped = permutation?.entityType === void 0 ? void 0 : splitSpawnType(permutation.entityType);
+			const position = index === 0 ? anchor : this.herdMemberPosition(anchor, pass);
+			const identifier = swapped?.identifier ?? rule.identifier;
+			if (this.world.structureSpawnOverrideAt?.(identifier, position) === false) continue;
+			const event = eventForMember(index, herd, swapped?.event, condition);
+			const request = {
+				identifier,
+				position,
+				pool,
+				rule: rule.identifier,
+				pass
+			};
+			if (event !== void 0) request.spawnEvent = event;
+			requests.push(request);
+		}
+		return requests;
+	}
+	/** Places one herd member around the anchor, following the terrain on the surface pass. */
+	herdMemberPosition(anchor, pass) {
+		const radius = this.constants.herdRadius;
+		const x = anchor.x + between(this.random, -radius, radius);
+		const z = anchor.z + between(this.random, -radius, radius);
+		if (pass !== "surface") return {
+			x,
+			y: anchor.y,
+			z
+		};
+		const position = this.surfacePosition(x, z);
+		if (position === void 0) return anchor;
+		if (this.world.site("underwater", anchor) && !this.world.site("underwater", position)) return anchor;
+		return position;
+	}
+	contextFor(rule, tick) {
+		const context = {
+			world: this.world,
+			identifier: rule.identifier,
+			random: this.random,
+			tick,
+			constants: this.constants,
+			delays: this.delays
+		};
+		if (this.onUnanswered !== void 0) context.onUnanswered = this.onUnanswered;
+		return context;
+	}
+};
+export { Spawner };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"spawner.es.js","names":[],"sources":["../src/spawner.ts"],"sourcesContent":["import type { EvaluateFilterOptions } from '@jsprismarine/entities';\nimport type { RandomSource } from '@jsprismarine/predicates';\n\nimport type { SpawnConditionContext } from './conditions';\nimport { SpawnDelays, evaluateSpawnCondition } from './conditions';\nimport type { SpawnConstants } from './constants';\nimport { SPAWN_CONSTANTS, poolCapFor } from './constants';\nimport type { EngineSpawnRule } from './engineRules';\nimport { VANILLA_ENGINE_SPAWN_RULES } from './engineRules';\nimport type { HerdRule, SpawnCondition, SpawnPermutation, SpawnRule } from './rules';\nimport type { SpawnPass, SpawnPosition, SpawnWorld } from './world';\n\n/**\n * The spawn loop.\n *\n * Mojang's spawn cycle diagram names six steps, \"check spawn conditions, find\n * valid spawn locations, check population caps, evaluate spawn weight, spawn\n * entity, and run spawn event\", and publishes no number behind any of them.\n * This loop implements those six steps over the constants in\n * `src/tables/spawnConstants.json`, and every draw goes through an injected\n * {@link RandomSource}, so one seed reproduces one set of spawns.\n *\n * One cycle of one pool samples `chunksPerCycle` chunks around each player,\n * tries `positionsPerChunk` positions in each chunk for the surface pass and\n * the same number for the underground pass, and at each position draws one of\n * the conditions that passed, weighted by `minecraft:weight`.\n */\n\n/** One entity the spawner asks the server to create. */\nexport interface SpawnRequest {\n    /** The entity type, with any `<event>` suffix already split off. */\n    readonly identifier: string;\n    /** The event to run instead of `minecraft:entity_spawned`, when the rule names one. */\n    readonly spawnEvent?: string;\n    readonly position: SpawnPosition;\n    /** The pool whose cap this spawn counts against. */\n    readonly pool: string;\n    /** The rule that produced the spawn, which is the identifier of its file. */\n    readonly rule: string;\n    readonly pass: SpawnPass;\n}\n\n/** How to build a {@link Spawner}. */\nexport interface SpawnerOptions {\n    readonly rules: Iterable<SpawnRule>;\n    readonly world: SpawnWorld;\n    readonly random: RandomSource;\n    readonly constants?: SpawnConstants;\n    /** The `minecraft:delay_filter` cooldowns, so a caller can persist them across a restart. */\n    readonly delays?: SpawnDelays;\n    /**\n     * The conditions Bedrock keeps in engine code, keyed by the entity each\n     * one gates. Defaults to {@link VANILLA_ENGINE_SPAWN_RULES}; pass an empty\n     * map to run the JSON conditions alone.\n     */\n    readonly engineRules?: ReadonlyMap<string, EngineSpawnRule>;\n    /** Receives every biome filter test the evaluator could not answer. */\n    readonly onUnanswered?: EvaluateFilterOptions['onUnanswered'];\n}\n\n/** One rule and the one of its conditions that passed at a position. */\ninterface Candidate {\n    readonly rule: SpawnRule;\n    readonly condition: SpawnCondition;\n}\n\n/** Splits `minecraft:pillager<minecraft:spawn_as_patrol_follower>` into its two halves. */\nconst splitSpawnType = (value: string): { readonly identifier: string; readonly event?: string } => {\n    const match = /^(?<identifier>[^<]+)<(?<event>[^>]+)>$/.exec(value);\n    if (match?.groups === undefined) return { identifier: value };\n    return { identifier: match.groups.identifier!, event: match.groups.event! };\n};\n\n/** Draws an integer in the inclusive range, which is how every size and offset is picked. */\nconst between = (random: RandomSource, min: number, max: number): number =>\n    max <= min ? min : min + random.nextInt(max - min + 1);\n\n/**\n * Builds the permutation each herd member spawns as.\n *\n * `min_guaranteed` members take their permutation before the weighted draw\n * runs, which is what makes the pillager patrol's captain and the zombie\n * herd's one villager certain.\n */\nconst permutationsFor = (\n    permutations: readonly SpawnPermutation[],\n    size: number,\n    random: RandomSource\n): readonly (SpawnPermutation | undefined)[] => {\n    const members: (SpawnPermutation | undefined)[] = [];\n    for (const permutation of permutations) {\n        for (let index = 0; index < permutation.minGuaranteed && members.length < size; index += 1)\n            members.push(permutation);\n    }\n\n    const total = permutations.reduce((sum, permutation) => sum + Math.max(0, permutation.weight), 0);\n    while (members.length < size) {\n        if (total <= 0) {\n            members.push(undefined);\n            continue;\n        }\n        let roll = random.nextFloat() * total;\n        let chosen: SpawnPermutation | undefined;\n        for (const permutation of permutations) {\n            roll -= Math.max(0, permutation.weight);\n            if (roll < 0) {\n                chosen = permutation;\n                break;\n            }\n        }\n        members.push(chosen ?? permutations[permutations.length - 1]);\n    }\n\n    return members;\n};\n\n/**\n * The event one herd member runs.\n *\n * `initial_event` wins for the first `initial_event_count` members, `event`\n * takes every member past `event_skip_count`, and a permutation's `<event>`\n * suffix or the condition's `minecraft:spawn_event` fills in for the rest.\n */\nconst eventForMember = (\n    index: number,\n    herd: HerdRule | undefined,\n    permutationEvent: string | undefined,\n    condition: SpawnCondition\n): string | undefined => {\n    if (herd?.initialEvent !== undefined && index < herd.initialEventCount) return herd.initialEvent;\n    if (herd?.event !== undefined && index >= herd.eventSkipCount) return herd.event;\n    return permutationEvent ?? condition.spawnEvent;\n};\n\n/** Runs the spawn loop for one world. */\nexport class Spawner {\n    private readonly rulesByPool = new Map<string, SpawnRule[]>();\n    private readonly world: SpawnWorld;\n    private readonly random: RandomSource;\n    private readonly constants: SpawnConstants;\n    private readonly delays: SpawnDelays;\n    private readonly engineRules: ReadonlyMap<string, EngineSpawnRule>;\n    private readonly onUnanswered: EvaluateFilterOptions['onUnanswered'] | undefined;\n\n    public constructor(options: SpawnerOptions) {\n        this.world = options.world;\n        this.random = options.random;\n        this.constants = options.constants ?? SPAWN_CONSTANTS;\n        this.delays = options.delays ?? new SpawnDelays();\n        this.engineRules = options.engineRules ?? VANILLA_ENGINE_SPAWN_RULES;\n        this.onUnanswered = options.onUnanswered;\n\n        for (const rule of options.rules) {\n            const pool = rule.populationControl;\n            if (pool === undefined) continue;\n            const existing = this.rulesByPool.get(pool);\n            if (existing === undefined) this.rulesByPool.set(pool, [rule]);\n            else existing.push(rule);\n        }\n    }\n\n    /** The pools the loaded rules name, which is what {@link tick} cycles. */\n    public get pools(): readonly string[] {\n        return [...this.rulesByPool.keys()];\n    }\n\n    /**\n     * Runs every pool whose cadence falls on this tick.\n     *\n     * @returns Every entity to create, in the order the cycles produced them.\n     */\n    public tick(tick: number): readonly SpawnRequest[] {\n        const requests: SpawnRequest[] = [];\n        for (const pool of this.rulesByPool.keys()) {\n            const cadence = this.constants.pools[pool]?.cycleTicks;\n            if (cadence === undefined || cadence <= 0 || tick % cadence !== 0) continue;\n            requests.push(...this.cycle(pool, tick));\n        }\n        return requests;\n    }\n\n    /**\n     * Runs one cycle of one pool, whatever the cadence says.\n     *\n     * @returns Every entity to create, never more than the pool's remaining cap.\n     */\n    public cycle(pool: string, tick: number): readonly SpawnRequest[] {\n        const rules = this.rulesByPool.get(pool);\n        if (rules === undefined || rules.length === 0) return [];\n\n        const players = this.world.players();\n        if (players.length === 0) return [];\n\n        const cap = poolCapFor(pool, players.length, this.constants);\n        let remaining = cap === undefined ? Number.POSITIVE_INFINITY : cap - this.world.poolCount(pool);\n        if (remaining <= 0) return [];\n\n        const requests: SpawnRequest[] = [];\n        const { spawnRadiusChunks, chunksPerCycle, positionsPerChunk } = this.constants;\n\n        for (const player of players) {\n            const playerChunkX = Math.floor(player.position.x / 16);\n            const playerChunkZ = Math.floor(player.position.z / 16);\n\n            for (let sample = 0; sample < chunksPerCycle && remaining > 0; sample += 1) {\n                const chunkX = playerChunkX + between(this.random, -spawnRadiusChunks, spawnRadiusChunks);\n                const chunkZ = playerChunkZ + between(this.random, -spawnRadiusChunks, spawnRadiusChunks);\n\n                for (let attempt = 0; attempt < positionsPerChunk && remaining > 0; attempt += 1) {\n                    for (const pass of ['surface', 'underground'] as const) {\n                        if (remaining <= 0) break;\n                        const position = this.positionIn(chunkX, chunkZ, pass);\n                        if (position === undefined) continue;\n                        const spawned = this.attemptAt(pool, rules, position, pass, tick, remaining);\n                        remaining -= spawned.length;\n                        requests.push(...spawned);\n                    }\n                }\n            }\n        }\n\n        return requests;\n    }\n\n    /**\n     * Draws one position inside a chunk for one pass.\n     *\n     * @returns The position, or undefined when the column is unloaded or the draw landed\n     *   somewhere no entity fits.\n     */\n    private positionIn(chunkX: number, chunkZ: number, pass: SpawnPass): SpawnPosition | undefined {\n        const x = chunkX * 16 + this.random.nextInt(16);\n        const z = chunkZ * 16 + this.random.nextInt(16);\n        if (pass === 'surface') return this.surfacePosition(x, z);\n\n        const top = this.world.surfaceY(x, z);\n        if (top === undefined) return undefined;\n\n        const floor = this.world.minY();\n        if (top - 1 < floor) return undefined;\n\n        // The draw is uniform over the column, so in a world with few caves most of it is\n        // inside rock. One attempt, one draw, the way Java's `NaturalSpawner` rejects a\n        // position rather than searching for a better one: a spawn inside a block is a mob\n        // that can path nowhere, never despawns and fills the pool so nothing else can spawn.\n        const at = { x, y: between(this.random, floor, top - 1), z };\n        return this.fits(at) ? at : undefined;\n    }\n\n    /** The top spawn position in a column, using the water surface when one covers the terrain. */\n    private surfacePosition(x: number, z: number): SpawnPosition | undefined {\n        const top = this.world.surfaceY(x, z);\n        if (top === undefined) return undefined;\n\n        const surface = { x, y: top, z };\n        if (this.world.site('underwater', surface)) return surface;\n\n        // A height map that counts water puts its surface one block above the fluid. Fish rules\n        // ask for both the surface pass and an underwater position, so sample the top water\n        // block instead of the air above it.\n        const waterSurface = { ...surface, y: top - 1 };\n        return this.world.site('underwater', waterSurface) ? waterSurface : surface;\n    }\n\n    /** Whether an entity fits at a position: its own block and the one over its head are free. */\n    private fits(at: SpawnPosition): boolean {\n        return !this.world.solid(at) && !this.world.solid({ ...at, y: at.y + 1 });\n    }\n\n    /**\n     * Runs one attempt: collect the rules that pass here, draw one, and build\n     * its herd.\n     *\n     * A rule with an engine condition is asked that first, because a condition\n     * Bedrock keeps in code is a condition the file was never able to state.\n     * `minecraft:slime` is the rule this matters to: its file names no\n     * brightness and no height, so without the engine condition it is the only\n     * monster that passes in daylight and it fills the pool on its own.\n     */\n    private attemptAt(\n        pool: string,\n        rules: readonly SpawnRule[],\n        position: SpawnPosition,\n        pass: SpawnPass,\n        tick: number,\n        remaining: number\n    ): readonly SpawnRequest[] {\n        const candidates: Candidate[] = [];\n        let totalWeight = 0;\n\n        for (const rule of rules) {\n            if (this.world.structureSpawnOverrideAt?.(rule.identifier, position) === false) continue;\n\n            const engineRule = this.engineRules.get(rule.identifier);\n            if (engineRule !== undefined && !engineRule(position, { world: this.world, random: this.random })) continue;\n\n            for (const condition of rule.conditions) {\n                if (!evaluateSpawnCondition(condition, position, this.contextFor(rule, tick), pass).passed) continue;\n                candidates.push({ rule, condition });\n                totalWeight += Math.max(0, condition.weight.default);\n            }\n        }\n\n        if (candidates.length === 0 || totalWeight <= 0) return [];\n\n        let roll = this.random.nextFloat() * totalWeight;\n        let chosen = candidates[candidates.length - 1]!;\n        for (const candidate of candidates) {\n            roll -= Math.max(0, candidate.condition.weight.default);\n            if (roll < 0) {\n                chosen = candidate;\n                break;\n            }\n        }\n\n        // `rarity` is documented by name only. This project reads it as a\n        // one-in-N roll on top of the weight, which is the only reading that\n        // makes a rarity of 2 or 3 rarer rather than more common.\n        const { rarity } = chosen.condition.weight;\n        if (rarity > 0 && this.random.nextFloat() * rarity >= 1) return [];\n\n        if (chosen.condition.delay !== undefined) this.delays.scheduleFrom(chosen.condition.delay, tick, this.random);\n\n        return this.herdAt(pool, chosen, position, pass, remaining);\n    }\n\n    /** Builds one herd around an anchor position. */\n    private herdAt(\n        pool: string,\n        candidate: Candidate,\n        anchor: SpawnPosition,\n        pass: SpawnPass,\n        remaining: number\n    ): readonly SpawnRequest[] {\n        const { condition, rule } = candidate;\n        const herd =\n            condition.herd.length === 0 ? undefined : condition.herd[this.random.nextInt(condition.herd.length)];\n        const drawn = herd === undefined ? 1 : between(this.random, herd.minSize, herd.maxSize);\n        const size = Math.max(0, Math.min(drawn, remaining));\n        if (size === 0) return [];\n\n        const permutations =\n            condition.permutations === undefined\n                ? undefined\n                : permutationsFor(condition.permutations, size, this.random);\n\n        const requests: SpawnRequest[] = [];\n        for (let index = 0; index < size; index += 1) {\n            const permutation = permutations?.[index];\n            const swapped = permutation?.entityType === undefined ? undefined : splitSpawnType(permutation.entityType);\n            const position = index === 0 ? anchor : this.herdMemberPosition(anchor, pass);\n            const identifier = swapped?.identifier ?? rule.identifier;\n            if (this.world.structureSpawnOverrideAt?.(identifier, position) === false) continue;\n            const event = eventForMember(index, herd, swapped?.event, condition);\n\n            const request: { -readonly [Key in keyof SpawnRequest]: SpawnRequest[Key] } = {\n                identifier,\n                position,\n                pool,\n                rule: rule.identifier,\n                pass\n            };\n            if (event !== undefined) request.spawnEvent = event;\n            requests.push(request);\n        }\n\n        return requests;\n    }\n\n    /** Places one herd member around the anchor, following the terrain on the surface pass. */\n    private herdMemberPosition(anchor: SpawnPosition, pass: SpawnPass): SpawnPosition {\n        const radius = this.constants.herdRadius;\n        const x = anchor.x + between(this.random, -radius, radius);\n        const z = anchor.z + between(this.random, -radius, radius);\n        if (pass !== 'surface') return { x, y: anchor.y, z };\n\n        const position = this.surfacePosition(x, z);\n        if (position === undefined) return anchor;\n        if (this.world.site('underwater', anchor) && !this.world.site('underwater', position)) return anchor;\n        return position;\n    }\n\n    private contextFor(rule: SpawnRule, tick: number): SpawnConditionContext {\n        const context: { -readonly [Key in keyof SpawnConditionContext]: SpawnConditionContext[Key] } = {\n            world: this.world,\n            identifier: rule.identifier,\n            random: this.random,\n            tick,\n            constants: this.constants,\n            delays: this.delays\n        };\n        if (this.onUnanswered !== undefined) context.onUnanswered = this.onUnanswered;\n        return context;\n    }\n}\n"],"mappings":"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"}

package/dist/tables/spawnConstants.cjs.cjs

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+// src/tables/spawnConstants.json
+var provenance = "Mojang publishes no spawn attempt rate, no cap value, no spawn radius and no light algorithm for Bedrock Edition. The only published numbers are the tilde-hedged 'Typical Cap' column of EntitySpawningDeepDive.md. Every number below is therefore this project's choice; the `source` string on each one says where it came from, and a host may replace the whole table.";
+var pools = {
+	"animal": {
+		"cap": 10,
+		"scope": "per_player",
+		"cycleTicks": 400,
+		"source": "EntitySpawningDeepDive.md gives '~10 per player'. The 400-tick cadence is Java's animal pass, because Bedrock publishes none."
+	},
+	"water_animal": {
+		"cap": 5,
+		"scope": "per_player",
+		"cycleTicks": 400,
+		"source": "EntitySpawningDeepDive.md gives '~5 per water body'. This project counts per player instead, because a water body is not a quantity the server tracks."
+	},
+	"water_ambient": {
+		"cap": 20,
+		"scope": "per_player",
+		"cycleTicks": 400,
+		"source": "EntitySpawningDeepDive.md gives '~20 per water body'. No vanilla spawn rule names this pool."
+	},
+	"ambient": {
+		"cap": 15,
+		"scope": "per_player",
+		"cycleTicks": 400,
+		"source": "EntitySpawningDeepDive.md gives '~15 in caves'. Only the bat uses this pool."
+	},
+	"monster": {
+		"cap": 70,
+		"scope": "per_region",
+		"cycleTicks": 20,
+		"source": "EntitySpawningDeepDive.md gives '~70 in loaded chunks', so the cap covers the whole spawn region rather than scaling with players. The 20-tick cadence is this project's choice; Java runs the monster pass every tick, which costs more than this server wants to pay."
+	},
+	"cat": {
+		"cap": 5,
+		"scope": "per_region",
+		"cycleTicks": 1200,
+		"source": "DataDrivenSpawning.md says only that cat limits are 'based upon the amount within a village' and gives no number. Five per region and one cycle per minute are this project's choice."
+	},
+	"pillager": {
+		"cap": null,
+		"scope": "per_region",
+		"cycleTicks": 20,
+		"source": "EntitySpawningDeepDive.md says 'Limited by patrols', so this pool has no cap of its own and `minecraft:delay_filter` plus `minecraft:mob_event_filter` gate it."
+	},
+	"villager": {
+		"cap": null,
+		"scope": "per_region",
+		"cycleTicks": 400,
+		"source": "DataDrivenSpawning.md says the pool exists in the game files and no entity uses it."
+	}
+};
+var spawnRadiusChunks = 4;
+var spawnRadiusSource = "Bedrock's documented default simulation distance is 4 chunks, and the ticking area documentation says 'all forms of mob spawning attempts are done in a radius centered on a player'. Mojang publishes no spawn radius, so this project uses the simulation distance.";
+var chunksPerCycle = 8;
+var positionsPerChunk = 3;
+var attemptSource = "Mojang publishes no attempt rate. Eight chunks per player per cycle with three positions in each is this project's budget, picked so one player standing in an empty plains biome reaches the animal cap of 10 within a few animal cycles.";
+var herdRadius = 5;
+var herdRadiusSource = "Mojang publishes no herd placement rule. Five blocks is the horizontal spread Java gives a pack spawn.";
+var densityRadius = 16;
+var densityRadiusSource = "Mojang says `minecraft:density_limit` caps 'the amount of mobs to spawn in certain locations' and names no radius. One chunk's width is this project's reading of 'location'.";
+var rainDarkening = 5;
+var thunderDarkening = 10;
+var darkeningSource = "Mojang publishes neither the light value `minecraft:brightness_filter` compares nor what `adjust_for_weather` does to it. Java's `Level.getSkyDarken` subtracts 5 under rain and 10 under thunder, so this project subtracts the same amounts from the light the world reports.";
+var despawnRadiusChunks = 8;
+var despawnFloorY = -128;
+var despawnSource = "128 blocks is the documented default of `minecraft:despawn.despawn_from_distance.max_distance`, which is 8 chunks, and is the only published spawning distance. The Y floor is published: all mobs despawn at Y=-128 and below in both editions.";
+var spawnConstants_default = {
+	provenance,
+	pools,
+	spawnRadiusChunks: 4,
+	spawnRadiusSource,
+	chunksPerCycle: 8,
+	positionsPerChunk: 3,
+	attemptSource,
+	herdRadius: 5,
+	herdRadiusSource,
+	densityRadius: 16,
+	densityRadiusSource,
+	rainDarkening: 5,
+	thunderDarkening: 10,
+	darkeningSource,
+	despawnRadiusChunks: 8,
+	despawnFloorY,
+	despawnSource
+};
+exports.attemptSource = attemptSource;
+exports.chunksPerCycle = chunksPerCycle;
+exports.darkeningSource = darkeningSource;
+exports.default = spawnConstants_default;
+exports.densityRadius = densityRadius;
+exports.densityRadiusSource = densityRadiusSource;
+exports.despawnFloorY = despawnFloorY;
+exports.despawnRadiusChunks = despawnRadiusChunks;
+exports.despawnSource = despawnSource;
+exports.herdRadius = herdRadius;
+exports.herdRadiusSource = herdRadiusSource;
+exports.pools = pools;
+exports.positionsPerChunk = positionsPerChunk;
+exports.provenance = provenance;
+exports.rainDarkening = rainDarkening;
+exports.spawnRadiusChunks = spawnRadiusChunks;
+exports.spawnRadiusSource = spawnRadiusSource;
+exports.thunderDarkening = thunderDarkening;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/tables/spawnConstants.d.ts

@@ -0,0 +1,2 @@
+declare const _default: { "provenance": string; "pools": { "animal": { "cap": number; "scope": string; "cycleTicks": number; "source": string }; "water_animal": { "cap": number; "scope": string; "cycleTicks": number; "source": string }; "water_ambient": { "cap": number; "scope": string; "cycleTicks": number; "source": string }; "ambient": { "cap": number; "scope": string; "cycleTicks": number; "source": string }; "monster": { "cap": number; "scope": string; "cycleTicks": number; "source": string }; "cat": { "cap": number; "scope": string; "cycleTicks": number; "source": string }; "pillager": { "cap": null; "scope": string; "cycleTicks": number; "source": string }; "villager": { "cap": null; "scope": string; "cycleTicks": number; "source": string } }; "spawnRadiusChunks": number; "spawnRadiusSource": string; "chunksPerCycle": number; "positionsPerChunk": number; "attemptSource": string; "herdRadius": number; "herdRadiusSource": string; "densityRadius": number; "densityRadiusSource": string; "rainDarkening": number; "thunderDarkening": number; "darkeningSource": string; "despawnRadiusChunks": number; "despawnFloorY": number; "despawnSource": string };
+export default _default;

package/dist/tables/spawnConstants.es.js

@@ -0,0 +1,89 @@
+// src/tables/spawnConstants.json
+var provenance = "Mojang publishes no spawn attempt rate, no cap value, no spawn radius and no light algorithm for Bedrock Edition. The only published numbers are the tilde-hedged 'Typical Cap' column of EntitySpawningDeepDive.md. Every number below is therefore this project's choice; the `source` string on each one says where it came from, and a host may replace the whole table.";
+var pools = {
+	"animal": {
+		"cap": 10,
+		"scope": "per_player",
+		"cycleTicks": 400,
+		"source": "EntitySpawningDeepDive.md gives '~10 per player'. The 400-tick cadence is Java's animal pass, because Bedrock publishes none."
+	},
+	"water_animal": {
+		"cap": 5,
+		"scope": "per_player",
+		"cycleTicks": 400,
+		"source": "EntitySpawningDeepDive.md gives '~5 per water body'. This project counts per player instead, because a water body is not a quantity the server tracks."
+	},
+	"water_ambient": {
+		"cap": 20,
+		"scope": "per_player",
+		"cycleTicks": 400,
+		"source": "EntitySpawningDeepDive.md gives '~20 per water body'. No vanilla spawn rule names this pool."
+	},
+	"ambient": {
+		"cap": 15,
+		"scope": "per_player",
+		"cycleTicks": 400,
+		"source": "EntitySpawningDeepDive.md gives '~15 in caves'. Only the bat uses this pool."
+	},
+	"monster": {
+		"cap": 70,
+		"scope": "per_region",
+		"cycleTicks": 20,
+		"source": "EntitySpawningDeepDive.md gives '~70 in loaded chunks', so the cap covers the whole spawn region rather than scaling with players. The 20-tick cadence is this project's choice; Java runs the monster pass every tick, which costs more than this server wants to pay."
+	},
+	"cat": {
+		"cap": 5,
+		"scope": "per_region",
+		"cycleTicks": 1200,
+		"source": "DataDrivenSpawning.md says only that cat limits are 'based upon the amount within a village' and gives no number. Five per region and one cycle per minute are this project's choice."
+	},
+	"pillager": {
+		"cap": null,
+		"scope": "per_region",
+		"cycleTicks": 20,
+		"source": "EntitySpawningDeepDive.md says 'Limited by patrols', so this pool has no cap of its own and `minecraft:delay_filter` plus `minecraft:mob_event_filter` gate it."
+	},
+	"villager": {
+		"cap": null,
+		"scope": "per_region",
+		"cycleTicks": 400,
+		"source": "DataDrivenSpawning.md says the pool exists in the game files and no entity uses it."
+	}
+};
+var spawnRadiusChunks = 4;
+var spawnRadiusSource = "Bedrock's documented default simulation distance is 4 chunks, and the ticking area documentation says 'all forms of mob spawning attempts are done in a radius centered on a player'. Mojang publishes no spawn radius, so this project uses the simulation distance.";
+var chunksPerCycle = 8;
+var positionsPerChunk = 3;
+var attemptSource = "Mojang publishes no attempt rate. Eight chunks per player per cycle with three positions in each is this project's budget, picked so one player standing in an empty plains biome reaches the animal cap of 10 within a few animal cycles.";
+var herdRadius = 5;
+var herdRadiusSource = "Mojang publishes no herd placement rule. Five blocks is the horizontal spread Java gives a pack spawn.";
+var densityRadius = 16;
+var densityRadiusSource = "Mojang says `minecraft:density_limit` caps 'the amount of mobs to spawn in certain locations' and names no radius. One chunk's width is this project's reading of 'location'.";
+var rainDarkening = 5;
+var thunderDarkening = 10;
+var darkeningSource = "Mojang publishes neither the light value `minecraft:brightness_filter` compares nor what `adjust_for_weather` does to it. Java's `Level.getSkyDarken` subtracts 5 under rain and 10 under thunder, so this project subtracts the same amounts from the light the world reports.";
+var despawnRadiusChunks = 8;
+var despawnFloorY = -128;
+var despawnSource = "128 blocks is the documented default of `minecraft:despawn.despawn_from_distance.max_distance`, which is 8 chunks, and is the only published spawning distance. The Y floor is published: all mobs despawn at Y=-128 and below in both editions.";
+var spawnConstants_default = {
+	provenance,
+	pools,
+	spawnRadiusChunks: 4,
+	spawnRadiusSource,
+	chunksPerCycle: 8,
+	positionsPerChunk: 3,
+	attemptSource,
+	herdRadius: 5,
+	herdRadiusSource,
+	densityRadius: 16,
+	densityRadiusSource,
+	rainDarkening: 5,
+	thunderDarkening: 10,
+	darkeningSource,
+	despawnRadiusChunks: 8,
+	despawnFloorY,
+	despawnSource
+};
+export { attemptSource, chunksPerCycle, darkeningSource, spawnConstants_default as default, densityRadius, densityRadiusSource, despawnFloorY, despawnRadiusChunks, despawnSource, herdRadius, herdRadiusSource, pools, positionsPerChunk, provenance, rainDarkening, spawnRadiusChunks, spawnRadiusSource, thunderDarkening };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/tables/spawnConstants.json.d.ts

@@ -0,0 +1,2 @@
+declare const _default: { "provenance": string; "pools": { "animal": { "cap": number; "scope": string; "cycleTicks": number; "source": string }; "water_animal": { "cap": number; "scope": string; "cycleTicks": number; "source": string }; "water_ambient": { "cap": number; "scope": string; "cycleTicks": number; "source": string }; "ambient": { "cap": number; "scope": string; "cycleTicks": number; "source": string }; "monster": { "cap": number; "scope": string; "cycleTicks": number; "source": string }; "cat": { "cap": number; "scope": string; "cycleTicks": number; "source": string }; "pillager": { "cap": null; "scope": string; "cycleTicks": number; "source": string }; "villager": { "cap": null; "scope": string; "cycleTicks": number; "source": string } }; "spawnRadiusChunks": number; "spawnRadiusSource": string; "chunksPerCycle": number; "positionsPerChunk": number; "attemptSource": string; "herdRadius": number; "herdRadiusSource": string; "densityRadius": number; "densityRadiusSource": string; "rainDarkening": number; "thunderDarkening": number; "darkeningSource": string; "despawnRadiusChunks": number; "despawnFloorY": number; "despawnSource": string };
+export default _default;

package/dist/world.cjs.cjs

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+// src/world.ts
+/**
+* The boolean facts about one position, each named by the rule component or
+* filter test that reads it.
+*
+* `surface` and `underground` select the pass; `underwater` and `lava` are the
+* medium the position sits in; `bubble_column` answers
+* `minecraft:disallow_spawns_in_bubble`; `snow_covered` answers the one
+* `is_snow_covered` test a vanilla biome filter writes.
+*/
+var SPAWN_SITE_FLAGS = [
+	"surface",
+	"underground",
+	"underwater",
+	"lava",
+	"bubble_column",
+	"snow_covered"
+];
+/** The weather names `adjust_for_weather` reads. */
+var SPAWN_WEATHER = [
+	"clear",
+	"rain",
+	"thunder"
+];
+/** The squared distance between two positions, which is what the range checks compare. */
+var distanceSquared = (from, to) => {
+	const dx = from.x - to.x;
+	const dy = from.y - to.y;
+	const dz = from.z - to.z;
+	return dx * dx + dy * dy + dz * dz;
+};
+/**
+* The squared distance between two positions on the X and Z axes alone, which
+* is what a chunk radius such as the simulation distance measures.
+*/
+var horizontalDistanceSquared = (from, to) => {
+	const dx = from.x - to.x;
+	const dz = from.z - to.z;
+	return dx * dx + dz * dz;
+};
+/** Which pass a position belongs to, which the world decides and the conditions read. */
+var passAt = (world, at) => world.site("underground", at) ? "underground" : "surface";
+exports.SPAWN_SITE_FLAGS = SPAWN_SITE_FLAGS;
+exports.SPAWN_WEATHER = SPAWN_WEATHER;
+exports.distanceSquared = distanceSquared;
+exports.horizontalDistanceSquared = horizontalDistanceSquared;
+exports.passAt = passAt;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"world.cjs.cjs","names":[],"sources":["../src/world.ts"],"sourcesContent":["import type { Difficulty } from './rules';\n\n/**\n * What the spawner reads about the world.\n *\n * Every fact a spawn rule asks for arrives through this one interface, so a\n * test drives the whole algorithm with a typed double and a server implements\n * it once against its own chunks, light engine and entity index.\n */\n\n/** A block position. Spawn positions are integers; distances are measured between centers. */\nexport interface SpawnPosition {\n    readonly x: number;\n    readonly y: number;\n    readonly z: number;\n}\n\n/**\n * The boolean facts about one position, each named by the rule component or\n * filter test that reads it.\n *\n * `surface` and `underground` select the pass; `underwater` and `lava` are the\n * medium the position sits in; `bubble_column` answers\n * `minecraft:disallow_spawns_in_bubble`; `snow_covered` answers the one\n * `is_snow_covered` test a vanilla biome filter writes.\n */\nexport const SPAWN_SITE_FLAGS = [\n    'surface',\n    'underground',\n    'underwater',\n    'lava',\n    'bubble_column',\n    'snow_covered'\n] as const;\n\n/** One of {@link SPAWN_SITE_FLAGS}. */\nexport type SpawnSiteFlag = (typeof SPAWN_SITE_FLAGS)[number];\n\n/** Which of the two passes a position belongs to. */\nexport type SpawnPass = 'surface' | 'underground';\n\n/** The weather names `adjust_for_weather` reads. */\nexport const SPAWN_WEATHER = ['clear', 'rain', 'thunder'] as const;\n\n/** One of {@link SPAWN_WEATHER}. */\nexport type SpawnWeather = (typeof SPAWN_WEATHER)[number];\n\n/** One player the spawner spawns around. */\nexport interface SpawnPlayer {\n    readonly position: SpawnPosition;\n}\n\n/** Everything one spawn cycle reads about the world. */\nexport interface SpawnWorld {\n    /** A boolean fact about one position, named by the component that reads it. */\n    site(flag: SpawnSiteFlag, at: SpawnPosition): boolean;\n    /**\n     * The block identifier at one position, or undefined when the chunk is not\n     * loaded, which stops the attempt.\n     */\n    block(at: SpawnPosition): string | undefined;\n    /**\n     * Whether the block at one position stops an entity standing in it.\n     *\n     * The underground pass draws a y uniformly between the world floor and the\n     * surface, so most of what it draws is inside rock. Java rejects such a\n     * draw in `NaturalSpawner.isSpawnPositionOk`; without this the spawner\n     * puts a zombie inside a stone block, where it can path nowhere and never\n     * despawns.\n     */\n    solid(at: SpawnPosition): boolean;\n    /**\n     * The light level at one position, 0 to 15, before this package applies the\n     * weather darkening that `adjust_for_weather` asks for.\n     */\n    light(at: SpawnPosition): number;\n    /** The biome tags at one position, which is what `has_biome_tag` compares. */\n    biomeTags(at: SpawnPosition): readonly string[];\n    /** The biome name at one position, for `is_biome`. */\n    biome?(at: SpawnPosition): string;\n    /**\n     * The lowest y an entity may stand on in one column, which is the position\n     * the surface pass tries. Undefined when the column is not loaded, which\n     * skips the attempt.\n     */\n    surfaceY(x: number, z: number): number | undefined;\n    /** The lowest y the world generates, which bounds the underground pass. */\n    minY(): number;\n    /** The players the spawner spawns around, which is every player in the spawn region. */\n    players(): readonly SpawnPlayer[];\n    /** How many entities of one population pool stand in the spawn region now. */\n    poolCount(pool: string): number;\n    /** How many entities of one type stand within `radius` blocks of a position. */\n    typeCount(identifier: string, at: SpawnPosition, radius: number): number;\n    difficulty(): Difficulty;\n    weather(): SpawnWeather;\n    /** The world's age in ticks, which is what `minecraft:world_age_filter` compares. */\n    age(): number;\n    /** Whether a named mob event, such as `minecraft:pillager_patrols_event`, is running. */\n    mobEventActive(event: string): boolean;\n    /**\n     * How far a position is from the nearest village border, negative inside it\n     * and undefined when no village is near. `minecraft:player_in_village_filter`\n     * reads it.\n     */\n    villageBorderDistance?(at: SpawnPosition): number | undefined;\n    /**\n     * Whether Java restricts this entity type to a structure spawn override at this position.\n     *\n     * `false` means the Java data declares at least one structure override for the entity, but\n     * this position is outside every active override. `true` means a matching override covers\n     * this position. `undefined` means Java's biome data also permits this entity to spawn\n     * outside structures, or that the world has no Java override data for it, so the spawn rule\n     * decides as usual.\n     */\n    structureSpawnOverrideAt?(identifier: string, at: SpawnPosition): boolean | undefined;\n}\n\n/** The squared distance between two positions, which is what the range checks compare. */\nexport const distanceSquared = (from: SpawnPosition, to: SpawnPosition): number => {\n    const dx = from.x - to.x;\n    const dy = from.y - to.y;\n    const dz = from.z - to.z;\n    return dx * dx + dy * dy + dz * dz;\n};\n\n/**\n * The squared distance between two positions on the X and Z axes alone, which\n * is what a chunk radius such as the simulation distance measures.\n */\nexport const horizontalDistanceSquared = (from: SpawnPosition, to: SpawnPosition): number => {\n    const dx = from.x - to.x;\n    const dz = from.z - to.z;\n    return dx * dx + dz * dz;\n};\n\n/** Which pass a position belongs to, which the world decides and the conditions read. */\nexport const passAt = (world: SpawnWorld, at: SpawnPosition): SpawnPass =>\n    world.site('underground', at) ? 'underground' : 'surface';\n"],"mappings":";;;;;;;;;;;;AA0BA,IAAa,mBAAmB;CAC5B;CACA;CACA;CACA;CACA;CACA;AACJ;;AASA,IAAa,gBAAgB;CAAC;CAAS;CAAQ;AAAS;;AA6ExD,IAAa,mBAAmB,MAAqB,OAA8B;CAC/E,MAAM,KAAK,KAAK,IAAI,GAAG;CACvB,MAAM,KAAK,KAAK,IAAI,GAAG;CACvB,MAAM,KAAK,KAAK,IAAI,GAAG;CACvB,OAAO,KAAK,KAAK,KAAK,KAAK,KAAK;AACpC;;;;;AAMA,IAAa,6BAA6B,MAAqB,OAA8B;CACzF,MAAM,KAAK,KAAK,IAAI,GAAG;CACvB,MAAM,KAAK,KAAK,IAAI,GAAG;CACvB,OAAO,KAAK,KAAK,KAAK;AAC1B;;AAGA,IAAa,UAAU,OAAmB,OACtC,MAAM,KAAK,eAAe,EAAE,IAAI,gBAAgB"}