@jsprismarine/spawning 0.0.0 → 0.16.0-unstable-20261029140140

package/dist/engineRules.cjs.cjs

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+// src/engineRules.ts
+/** How far into the state a twist step reads its second word. */
+var TWISTER_OFFSET = 397;
+/** The multiplier of the twister's seeding recurrence, Matsumoto and Nishimura's 1812433253. */
+var TWISTER_SEED_MULTIPLIER = 1812433253;
+/** The twist step's tempering matrix. */
+var TWISTER_MATRIX = 2567483615;
+/**
+* The first 32-bit draw of a Mersenne twister seeded with one value.
+*
+* Only the first draw exists because that is all the slime chunk rule takes.
+* The twist of word zero reads words zero, one and {@link TWISTER_OFFSET}, so
+* the seeding recurrence stops one word past the offset rather than filling
+* all 624 words of a full state. Bedrock's own copy stops in the same place.
+*/
+var firstTwisterDraw = (seed) => {
+	const state = /* @__PURE__ */ new Uint32Array(399);
+	state[0] = seed;
+	for (let index = 1; index < state.length; index += 1) {
+		const previous = state[index - 1];
+		state[index] = Math.imul(TWISTER_SEED_MULTIPLIER, previous ^ previous >>> 30) + index >>> 0;
+	}
+	const mixed = state[0] & 2147483648 | state[1] & 2147483647;
+	let draw = state[TWISTER_OFFSET] ^ mixed >>> 1 ^ ((mixed & 1) === 0 ? 0 : TWISTER_MATRIX);
+	draw ^= draw >>> 11;
+	draw ^= draw << 7 & 2636928640;
+	draw ^= draw << 15 & 4022730752;
+	draw ^= draw >>> 18;
+	return draw >>> 0;
+};
+/**
+* The multiplier Bedrock hashes a chunk's X coordinate by. It is the engine's
+* general-purpose hash multiplier rather than anything about slimes.
+*/
+var SLIME_CHUNK_MULTIPLIER = 522133279;
+/** One chunk in ten holds slimes, which is the divisor of the draw. */
+var SLIME_CHUNK_IN = 10;
+/** How many answers {@link isSlimeChunk} keeps before it starts over. */
+var SLIME_CHUNK_MEMO_LIMIT = 4096;
+var slimeChunkMemo = /* @__PURE__ */ new Map();
+/**
+* Whether a chunk is a slime chunk.
+*
+* Bedrock seeds a Mersenne twister with `chunkX * 0x1f1f1f1f ^ chunkZ` and
+* takes its first draw modulo ten. The world seed is not part of it, which is
+* why a Bedrock slime farm sits at the same chunk coordinates in every world
+* and why Java's seeded formula is the wrong answer here.
+*
+* @param chunkX - The chunk's X coordinate, which is a block X shifted right by four.
+* @param chunkZ - The chunk's Z coordinate.
+*/
+var isSlimeChunk = (chunkX, chunkZ) => {
+	const seed = (Math.imul(chunkX, SLIME_CHUNK_MULTIPLIER) ^ chunkZ) >>> 0;
+	const known = slimeChunkMemo.get(seed);
+	if (known !== void 0) return known;
+	const answer = firstTwisterDraw(seed) % SLIME_CHUNK_IN === 0;
+	if (slimeChunkMemo.size >= SLIME_CHUNK_MEMO_LIMIT) slimeChunkMemo.clear();
+	slimeChunkMemo.set(seed, answer);
+	return answer;
+};
+/** How many ticks one Minecraft day lasts. */
+var DAY_TICKS = 24e3;
+/**
+* How bright the moon is at each of its eight phases, starting at the full
+* moon. The swamp branch of the slime rule draws against this number, so a
+* swamp spawns no slimes at all on a new moon.
+*/
+var MOON_BRIGHTNESS = [
+	1,
+	.75,
+	.5,
+	.25,
+	0,
+	.25,
+	.5,
+	.75
+];
+/**
+* The moon phase at one world time.
+*
+* @param time - The world's age in ticks, which is never negative on a running server.
+* @returns A phase from 0, the full moon, to 7.
+*/
+var moonPhase = (time) => Math.abs(Math.trunc(time / DAY_TICKS)) % MOON_BRIGHTNESS.length;
+/** The highest Y at which the slime chunk branch applies. */
+var SLIME_CHUNK_CEILING = 38;
+/** The lowest Y of the swamp branch's band. */
+var SLIME_SWAMP_FLOOR = 50;
+/** The highest Y of the swamp branch's band. */
+var SLIME_SWAMP_CEILING = 68;
+/**
+* The light a swamp slime tolerates, before the extra draw.
+*
+* It is an early exit rather than a second condition: the draw it guards is
+* over `[0, 8)`, so a light above seven already fails it.
+*/
+var SLIME_SWAMP_LIGHT_CEILING = 7;
+/** The width of the draw the swamp branch compares the light against. */
+var SLIME_SWAMP_LIGHT_DRAW = 8;
+/**
+* The biome tag the swamp branch reads. Three vanilla biomes carry it:
+* `swampland`, `swampland_mutated` and `mangrove_swamp`.
+*/
+var SLIME_SURFACE_BIOME_TAG = "spawns_slimes_on_surface";
+/**
+* Where a slime may spawn, which `spawn_rules/slime.json` does not say.
+*
+* Two branches, as Bedrock writes them. At Y 38 and below the position has to
+* be in a slime chunk and nothing else is asked, which is why a slime farm is
+* dug out rather than lit up. Above that the position has to be in a swamp
+* between Y 50 and Y 68, dark enough, and lucky against the moon phase.
+* Everything in between, and every lit surface, spawns no slimes at all.
+*
+* The one divergence from the Bedrock function is the position the biome tag
+* is read at. Bedrock reads it one block higher than the spawn position; this
+* reads it at the spawn position, because a biome boundary is the only place
+* the two can differ and neither answer is more correct there.
+*/
+var slimeSpawnRule = (at, { world, random }) => {
+	if (at.y <= SLIME_CHUNK_CEILING) return isSlimeChunk(at.x >> 4, at.z >> 4);
+	if (at.y < SLIME_SWAMP_FLOOR || at.y > SLIME_SWAMP_CEILING) return false;
+	const light = world.light(at);
+	if (light > SLIME_SWAMP_LIGHT_CEILING) return false;
+	if (light > random.nextInt(SLIME_SWAMP_LIGHT_DRAW)) return false;
+	if (random.nextFloat() >= MOON_BRIGHTNESS[moonPhase(world.age())]) return false;
+	return world.biomeTags(at).includes(SLIME_SURFACE_BIOME_TAG);
+};
+/**
+* Every engine rule vanilla needs, keyed by the entity it gates.
+*
+* {@link import('./spawner').Spawner} applies these by default. A host that
+* wants a different set passes its own map, and a host that wants none passes
+* an empty one.
+*/
+var VANILLA_ENGINE_SPAWN_RULES = /* @__PURE__ */ new Map([["minecraft:slime", slimeSpawnRule]]);
+exports.MOON_BRIGHTNESS = MOON_BRIGHTNESS;
+exports.SLIME_SURFACE_BIOME_TAG = SLIME_SURFACE_BIOME_TAG;
+exports.VANILLA_ENGINE_SPAWN_RULES = VANILLA_ENGINE_SPAWN_RULES;
+exports.isSlimeChunk = isSlimeChunk;
+exports.moonPhase = moonPhase;
+exports.slimeSpawnRule = slimeSpawnRule;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"engineRules.cjs.cjs","names":[],"sources":["../src/engineRules.ts"],"sourcesContent":["import type { RandomSource } from '@jsprismarine/predicates';\n\nimport type { SpawnPosition, SpawnWorld } from './world';\n\n/**\n * The spawn conditions Bedrock keeps in engine code rather than in\n * `spawn_rules/*.json`.\n *\n * The 24-component grammar cannot express a hash of the chunk coordinates or a\n * draw against the moon phase, so Mojang writes those in C++ and leaves the\n * JSON file as the coarse gate in front of them. `spawn_rules/slime.json` is\n * the clearest case: it carries no brightness filter, no height filter and a\n * weight of 100, which on its own lets a slime spawn in any `monster` biome in\n * daylight and fill the monster pool to its cap. The real rule is the function\n * at virtual address `0xbb80040` of BDS 1.26.51.1's `bedrock_server`, which\n * this module reimplements.\n *\n * A rule here runs after the JSON conditions pass and before the weighted\n * draw, so the file still decides the biomes, the difficulty and the weight,\n * and the code decides what the file cannot say.\n */\n\n/** What an engine rule reads besides the position it is deciding. */\nexport interface EngineSpawnContext {\n    readonly world: SpawnWorld;\n    /** The spawner's own source, so one seed still reproduces one set of spawns. */\n    readonly random: RandomSource;\n}\n\n/**\n * One entity's engine-side spawn condition.\n *\n * @returns Whether the entity may spawn at the position, with the entity's\n *   `spawn_rules/*.json` conditions already satisfied.\n */\nexport type EngineSpawnRule = (at: SpawnPosition, context: EngineSpawnContext) => boolean;\n\n/** How far into the state a twist step reads its second word. */\nconst TWISTER_OFFSET = 397;\n\n/** The multiplier of the twister's seeding recurrence, Matsumoto and Nishimura's 1812433253. */\nconst TWISTER_SEED_MULTIPLIER = 0x6c078965;\n\n/** The twist step's tempering matrix. */\nconst TWISTER_MATRIX = 0x9908b0df;\n\n/**\n * The first 32-bit draw of a Mersenne twister seeded with one value.\n *\n * Only the first draw exists because that is all the slime chunk rule takes.\n * The twist of word zero reads words zero, one and {@link TWISTER_OFFSET}, so\n * the seeding recurrence stops one word past the offset rather than filling\n * all 624 words of a full state. Bedrock's own copy stops in the same place.\n */\nconst firstTwisterDraw = (seed: number): number => {\n    const state = new Uint32Array(TWISTER_OFFSET + 2);\n    state[0] = seed;\n    for (let index = 1; index < state.length; index += 1) {\n        const previous = state[index - 1]!;\n        state[index] = (Math.imul(TWISTER_SEED_MULTIPLIER, previous ^ (previous >>> 30)) + index) >>> 0;\n    }\n\n    const mixed = (state[0]! & 0x80000000) | (state[1]! & 0x7fffffff);\n    let draw = state[TWISTER_OFFSET]! ^ (mixed >>> 1) ^ ((mixed & 1) === 0 ? 0 : TWISTER_MATRIX);\n\n    draw ^= draw >>> 11;\n    draw ^= (draw << 7) & 0x9d2c5680;\n    draw ^= (draw << 15) & 0xefc60000;\n    draw ^= draw >>> 18;\n    return draw >>> 0;\n};\n\n/**\n * The multiplier Bedrock hashes a chunk's X coordinate by. It is the engine's\n * general-purpose hash multiplier rather than anything about slimes.\n */\nconst SLIME_CHUNK_MULTIPLIER = 0x1f1f1f1f;\n\n/** One chunk in ten holds slimes, which is the divisor of the draw. */\nconst SLIME_CHUNK_IN = 10;\n\n/** How many answers {@link isSlimeChunk} keeps before it starts over. */\nconst SLIME_CHUNK_MEMO_LIMIT = 4096;\n\nconst slimeChunkMemo = new Map<number, boolean>();\n\n/**\n * Whether a chunk is a slime chunk.\n *\n * Bedrock seeds a Mersenne twister with `chunkX * 0x1f1f1f1f ^ chunkZ` and\n * takes its first draw modulo ten. The world seed is not part of it, which is\n * why a Bedrock slime farm sits at the same chunk coordinates in every world\n * and why Java's seeded formula is the wrong answer here.\n *\n * @param chunkX - The chunk's X coordinate, which is a block X shifted right by four.\n * @param chunkZ - The chunk's Z coordinate.\n */\nexport const isSlimeChunk = (chunkX: number, chunkZ: number): boolean => {\n    const seed = (Math.imul(chunkX, SLIME_CHUNK_MULTIPLIER) ^ chunkZ) >>> 0;\n    const known = slimeChunkMemo.get(seed);\n    if (known !== undefined) return known;\n\n    const answer = firstTwisterDraw(seed) % SLIME_CHUNK_IN === 0;\n    if (slimeChunkMemo.size >= SLIME_CHUNK_MEMO_LIMIT) slimeChunkMemo.clear();\n    slimeChunkMemo.set(seed, answer);\n    return answer;\n};\n\n/** How many ticks one Minecraft day lasts. */\nconst DAY_TICKS = 24000;\n\n/**\n * How bright the moon is at each of its eight phases, starting at the full\n * moon. The swamp branch of the slime rule draws against this number, so a\n * swamp spawns no slimes at all on a new moon.\n */\nexport const MOON_BRIGHTNESS: readonly number[] = [1, 0.75, 0.5, 0.25, 0, 0.25, 0.5, 0.75];\n\n/**\n * The moon phase at one world time.\n *\n * @param time - The world's age in ticks, which is never negative on a running server.\n * @returns A phase from 0, the full moon, to 7.\n */\nexport const moonPhase = (time: number): number => Math.abs(Math.trunc(time / DAY_TICKS)) % MOON_BRIGHTNESS.length;\n\n/** The highest Y at which the slime chunk branch applies. */\nconst SLIME_CHUNK_CEILING = 38;\n\n/** The lowest Y of the swamp branch's band. */\nconst SLIME_SWAMP_FLOOR = 50;\n\n/** The highest Y of the swamp branch's band. */\nconst SLIME_SWAMP_CEILING = 68;\n\n/**\n * The light a swamp slime tolerates, before the extra draw.\n *\n * It is an early exit rather than a second condition: the draw it guards is\n * over `[0, 8)`, so a light above seven already fails it.\n */\nconst SLIME_SWAMP_LIGHT_CEILING = 7;\n\n/** The width of the draw the swamp branch compares the light against. */\nconst SLIME_SWAMP_LIGHT_DRAW = 8;\n\n/**\n * The biome tag the swamp branch reads. Three vanilla biomes carry it:\n * `swampland`, `swampland_mutated` and `mangrove_swamp`.\n */\nexport const SLIME_SURFACE_BIOME_TAG = 'spawns_slimes_on_surface';\n\n/**\n * Where a slime may spawn, which `spawn_rules/slime.json` does not say.\n *\n * Two branches, as Bedrock writes them. At Y 38 and below the position has to\n * be in a slime chunk and nothing else is asked, which is why a slime farm is\n * dug out rather than lit up. Above that the position has to be in a swamp\n * between Y 50 and Y 68, dark enough, and lucky against the moon phase.\n * Everything in between, and every lit surface, spawns no slimes at all.\n *\n * The one divergence from the Bedrock function is the position the biome tag\n * is read at. Bedrock reads it one block higher than the spawn position; this\n * reads it at the spawn position, because a biome boundary is the only place\n * the two can differ and neither answer is more correct there.\n */\nexport const slimeSpawnRule: EngineSpawnRule = (at, { world, random }) => {\n    if (at.y <= SLIME_CHUNK_CEILING) return isSlimeChunk(at.x >> 4, at.z >> 4);\n\n    if (at.y < SLIME_SWAMP_FLOOR || at.y > SLIME_SWAMP_CEILING) return false;\n\n    const light = world.light(at);\n    if (light > SLIME_SWAMP_LIGHT_CEILING) return false;\n    if (light > random.nextInt(SLIME_SWAMP_LIGHT_DRAW)) return false;\n\n    if (random.nextFloat() >= MOON_BRIGHTNESS[moonPhase(world.age())]!) return false;\n\n    return world.biomeTags(at).includes(SLIME_SURFACE_BIOME_TAG);\n};\n\n/**\n * Every engine rule vanilla needs, keyed by the entity it gates.\n *\n * {@link import('./spawner').Spawner} applies these by default. A host that\n * wants a different set passes its own map, and a host that wants none passes\n * an empty one.\n */\nexport const VANILLA_ENGINE_SPAWN_RULES: ReadonlyMap<string, EngineSpawnRule> = new Map([\n    ['minecraft:slime', slimeSpawnRule]\n]);\n"],"mappings":";;;;AAsCA,IAAM,iBAAiB;;AAGvB,IAAM,0BAA0B;;AAGhC,IAAM,iBAAiB;;;;;;;;;AAUvB,IAAM,oBAAoB,SAAyB;CAC/C,MAAM,wBAAQ,IAAI,YAAY,GAAkB;CAChD,MAAM,KAAK;CACX,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,GAAG;EAClD,MAAM,WAAW,MAAM,QAAQ;EAC/B,MAAM,SAAU,KAAK,KAAK,yBAAyB,WAAY,aAAa,EAAG,IAAI,UAAW;CAClG;CAEA,MAAM,QAAS,MAAM,KAAM,aAAe,MAAM,KAAM;CACtD,IAAI,OAAO,MAAM,kBAAoB,UAAU,MAAO,QAAQ,OAAO,IAAI,IAAI;CAE7E,QAAQ,SAAS;CACjB,QAAS,QAAQ,IAAK;CACtB,QAAS,QAAQ,KAAM;CACvB,QAAQ,SAAS;CACjB,OAAO,SAAS;AACpB;;;;;AAMA,IAAM,yBAAyB;;AAG/B,IAAM,iBAAiB;;AAGvB,IAAM,yBAAyB;AAE/B,IAAM,iCAAiB,IAAI,IAAqB;;;;;;;;;;;;AAahD,IAAa,gBAAgB,QAAgB,WAA4B;CACrE,MAAM,QAAQ,KAAK,KAAK,QAAQ,sBAAsB,IAAI,YAAY;CACtE,MAAM,QAAQ,eAAe,IAAI,IAAI;CACrC,IAAI,UAAU,KAAA,GAAW,OAAO;CAEhC,MAAM,SAAS,iBAAiB,IAAI,IAAI,mBAAmB;CAC3D,IAAI,eAAe,QAAQ,wBAAwB,eAAe,MAAM;CACxE,eAAe,IAAI,MAAM,MAAM;CAC/B,OAAO;AACX;;AAGA,IAAM,YAAY;;;;;;AAOlB,IAAa,kBAAqC;CAAC;CAAG;CAAM;CAAK;CAAM;CAAG;CAAM;CAAK;AAAI;;;;;;;AAQzF,IAAa,aAAa,SAAyB,KAAK,IAAI,KAAK,MAAM,OAAO,SAAS,CAAC,IAAI,gBAAgB;;AAG5G,IAAM,sBAAsB;;AAG5B,IAAM,oBAAoB;;AAG1B,IAAM,sBAAsB;;;;;;;AAQ5B,IAAM,4BAA4B;;AAGlC,IAAM,yBAAyB;;;;;AAM/B,IAAa,0BAA0B;;;;;;;;;;;;;;;AAgBvC,IAAa,kBAAmC,IAAI,EAAE,OAAO,aAAa;CACtE,IAAI,GAAG,KAAK,qBAAqB,OAAO,aAAa,GAAG,KAAK,GAAG,GAAG,KAAK,CAAC;CAEzE,IAAI,GAAG,IAAI,qBAAqB,GAAG,IAAI,qBAAqB,OAAO;CAEnE,MAAM,QAAQ,MAAM,MAAM,EAAE;CAC5B,IAAI,QAAQ,2BAA2B,OAAO;CAC9C,IAAI,QAAQ,OAAO,QAAQ,sBAAsB,GAAG,OAAO;CAE3D,IAAI,OAAO,UAAU,KAAK,gBAAgB,UAAU,MAAM,IAAI,CAAC,IAAK,OAAO;CAE3E,OAAO,MAAM,UAAU,EAAE,CAAC,CAAC,SAAS,uBAAuB;AAC/D;;;;;;;;AASA,IAAa,6CAAmE,IAAI,IAAI,CACpF,CAAC,mBAAmB,cAAc,CACtC,CAAC"}

package/dist/engineRules.d.ts

@@ -0,0 +1,86 @@
+import type { RandomSource } from '@jsprismarine/predicates';
+import type { SpawnPosition, SpawnWorld } from './world';
+/**
+ * The spawn conditions Bedrock keeps in engine code rather than in
+ * `spawn_rules/*.json`.
+ *
+ * The 24-component grammar cannot express a hash of the chunk coordinates or a
+ * draw against the moon phase, so Mojang writes those in C++ and leaves the
+ * JSON file as the coarse gate in front of them. `spawn_rules/slime.json` is
+ * the clearest case: it carries no brightness filter, no height filter and a
+ * weight of 100, which on its own lets a slime spawn in any `monster` biome in
+ * daylight and fill the monster pool to its cap. The real rule is the function
+ * at virtual address `0xbb80040` of BDS 1.26.51.1's `bedrock_server`, which
+ * this module reimplements.
+ *
+ * A rule here runs after the JSON conditions pass and before the weighted
+ * draw, so the file still decides the biomes, the difficulty and the weight,
+ * and the code decides what the file cannot say.
+ */
+/** What an engine rule reads besides the position it is deciding. */
+export interface EngineSpawnContext {
+    readonly world: SpawnWorld;
+    /** The spawner's own source, so one seed still reproduces one set of spawns. */
+    readonly random: RandomSource;
+}
+/**
+ * One entity's engine-side spawn condition.
+ *
+ * @returns Whether the entity may spawn at the position, with the entity's
+ *   `spawn_rules/*.json` conditions already satisfied.
+ */
+export type EngineSpawnRule = (at: SpawnPosition, context: EngineSpawnContext) => boolean;
+/**
+ * Whether a chunk is a slime chunk.
+ *
+ * Bedrock seeds a Mersenne twister with `chunkX * 0x1f1f1f1f ^ chunkZ` and
+ * takes its first draw modulo ten. The world seed is not part of it, which is
+ * why a Bedrock slime farm sits at the same chunk coordinates in every world
+ * and why Java's seeded formula is the wrong answer here.
+ *
+ * @param chunkX - The chunk's X coordinate, which is a block X shifted right by four.
+ * @param chunkZ - The chunk's Z coordinate.
+ */
+export declare const isSlimeChunk: (chunkX: number, chunkZ: number) => boolean;
+/**
+ * How bright the moon is at each of its eight phases, starting at the full
+ * moon. The swamp branch of the slime rule draws against this number, so a
+ * swamp spawns no slimes at all on a new moon.
+ */
+export declare const MOON_BRIGHTNESS: readonly number[];
+/**
+ * The moon phase at one world time.
+ *
+ * @param time - The world's age in ticks, which is never negative on a running server.
+ * @returns A phase from 0, the full moon, to 7.
+ */
+export declare const moonPhase: (time: number) => number;
+/**
+ * The biome tag the swamp branch reads. Three vanilla biomes carry it:
+ * `swampland`, `swampland_mutated` and `mangrove_swamp`.
+ */
+export declare const SLIME_SURFACE_BIOME_TAG = "spawns_slimes_on_surface";
+/**
+ * Where a slime may spawn, which `spawn_rules/slime.json` does not say.
+ *
+ * Two branches, as Bedrock writes them. At Y 38 and below the position has to
+ * be in a slime chunk and nothing else is asked, which is why a slime farm is
+ * dug out rather than lit up. Above that the position has to be in a swamp
+ * between Y 50 and Y 68, dark enough, and lucky against the moon phase.
+ * Everything in between, and every lit surface, spawns no slimes at all.
+ *
+ * The one divergence from the Bedrock function is the position the biome tag
+ * is read at. Bedrock reads it one block higher than the spawn position; this
+ * reads it at the spawn position, because a biome boundary is the only place
+ * the two can differ and neither answer is more correct there.
+ */
+export declare const slimeSpawnRule: EngineSpawnRule;
+/**
+ * Every engine rule vanilla needs, keyed by the entity it gates.
+ *
+ * {@link import('./spawner').Spawner} applies these by default. A host that
+ * wants a different set passes its own map, and a host that wants none passes
+ * an empty one.
+ */
+export declare const VANILLA_ENGINE_SPAWN_RULES: ReadonlyMap<string, EngineSpawnRule>;
+//# sourceMappingURL=engineRules.d.ts.map

package/dist/engineRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engineRules.d.ts","sourceRoot":"","sources":["../src/engineRules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAEzD;;;;;;;;;;;;;;;;GAgBG;AAEH,qEAAqE;AACrE,MAAM,WAAW,kBAAkB;IAC/B,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CACjC;AAED;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,EAAE,EAAE,aAAa,EAAE,OAAO,EAAE,kBAAkB,KAAK,OAAO,CAAC;AAmD1F;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,WAAY,MAAM,UAAU,MAAM,KAAG,OAS7D,CAAC;AAKF;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAA6C,CAAC;AAE3F;;;;;GAKG;AACH,eAAO,MAAM,SAAS,SAAU,MAAM,KAAG,MAAyE,CAAC;AAsBnH;;;GAGG;AACH,eAAO,MAAM,uBAAuB,6BAA6B,CAAC;AAElE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,EAAE,eAY5B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAE1E,CAAC"}

package/dist/engineRules.es.js

@@ -0,0 +1,138 @@
+// src/engineRules.ts
+/** How far into the state a twist step reads its second word. */
+var TWISTER_OFFSET = 397;
+/** The multiplier of the twister's seeding recurrence, Matsumoto and Nishimura's 1812433253. */
+var TWISTER_SEED_MULTIPLIER = 1812433253;
+/** The twist step's tempering matrix. */
+var TWISTER_MATRIX = 2567483615;
+/**
+* The first 32-bit draw of a Mersenne twister seeded with one value.
+*
+* Only the first draw exists because that is all the slime chunk rule takes.
+* The twist of word zero reads words zero, one and {@link TWISTER_OFFSET}, so
+* the seeding recurrence stops one word past the offset rather than filling
+* all 624 words of a full state. Bedrock's own copy stops in the same place.
+*/
+var firstTwisterDraw = (seed) => {
+	const state = /* @__PURE__ */ new Uint32Array(399);
+	state[0] = seed;
+	for (let index = 1; index < state.length; index += 1) {
+		const previous = state[index - 1];
+		state[index] = Math.imul(TWISTER_SEED_MULTIPLIER, previous ^ previous >>> 30) + index >>> 0;
+	}
+	const mixed = state[0] & 2147483648 | state[1] & 2147483647;
+	let draw = state[TWISTER_OFFSET] ^ mixed >>> 1 ^ ((mixed & 1) === 0 ? 0 : TWISTER_MATRIX);
+	draw ^= draw >>> 11;
+	draw ^= draw << 7 & 2636928640;
+	draw ^= draw << 15 & 4022730752;
+	draw ^= draw >>> 18;
+	return draw >>> 0;
+};
+/**
+* The multiplier Bedrock hashes a chunk's X coordinate by. It is the engine's
+* general-purpose hash multiplier rather than anything about slimes.
+*/
+var SLIME_CHUNK_MULTIPLIER = 522133279;
+/** One chunk in ten holds slimes, which is the divisor of the draw. */
+var SLIME_CHUNK_IN = 10;
+/** How many answers {@link isSlimeChunk} keeps before it starts over. */
+var SLIME_CHUNK_MEMO_LIMIT = 4096;
+var slimeChunkMemo = /* @__PURE__ */ new Map();
+/**
+* Whether a chunk is a slime chunk.
+*
+* Bedrock seeds a Mersenne twister with `chunkX * 0x1f1f1f1f ^ chunkZ` and
+* takes its first draw modulo ten. The world seed is not part of it, which is
+* why a Bedrock slime farm sits at the same chunk coordinates in every world
+* and why Java's seeded formula is the wrong answer here.
+*
+* @param chunkX - The chunk's X coordinate, which is a block X shifted right by four.
+* @param chunkZ - The chunk's Z coordinate.
+*/
+var isSlimeChunk = (chunkX, chunkZ) => {
+	const seed = (Math.imul(chunkX, SLIME_CHUNK_MULTIPLIER) ^ chunkZ) >>> 0;
+	const known = slimeChunkMemo.get(seed);
+	if (known !== void 0) return known;
+	const answer = firstTwisterDraw(seed) % SLIME_CHUNK_IN === 0;
+	if (slimeChunkMemo.size >= SLIME_CHUNK_MEMO_LIMIT) slimeChunkMemo.clear();
+	slimeChunkMemo.set(seed, answer);
+	return answer;
+};
+/** How many ticks one Minecraft day lasts. */
+var DAY_TICKS = 24e3;
+/**
+* How bright the moon is at each of its eight phases, starting at the full
+* moon. The swamp branch of the slime rule draws against this number, so a
+* swamp spawns no slimes at all on a new moon.
+*/
+var MOON_BRIGHTNESS = [
+	1,
+	.75,
+	.5,
+	.25,
+	0,
+	.25,
+	.5,
+	.75
+];
+/**
+* The moon phase at one world time.
+*
+* @param time - The world's age in ticks, which is never negative on a running server.
+* @returns A phase from 0, the full moon, to 7.
+*/
+var moonPhase = (time) => Math.abs(Math.trunc(time / DAY_TICKS)) % MOON_BRIGHTNESS.length;
+/** The highest Y at which the slime chunk branch applies. */
+var SLIME_CHUNK_CEILING = 38;
+/** The lowest Y of the swamp branch's band. */
+var SLIME_SWAMP_FLOOR = 50;
+/** The highest Y of the swamp branch's band. */
+var SLIME_SWAMP_CEILING = 68;
+/**
+* The light a swamp slime tolerates, before the extra draw.
+*
+* It is an early exit rather than a second condition: the draw it guards is
+* over `[0, 8)`, so a light above seven already fails it.
+*/
+var SLIME_SWAMP_LIGHT_CEILING = 7;
+/** The width of the draw the swamp branch compares the light against. */
+var SLIME_SWAMP_LIGHT_DRAW = 8;
+/**
+* The biome tag the swamp branch reads. Three vanilla biomes carry it:
+* `swampland`, `swampland_mutated` and `mangrove_swamp`.
+*/
+var SLIME_SURFACE_BIOME_TAG = "spawns_slimes_on_surface";
+/**
+* Where a slime may spawn, which `spawn_rules/slime.json` does not say.
+*
+* Two branches, as Bedrock writes them. At Y 38 and below the position has to
+* be in a slime chunk and nothing else is asked, which is why a slime farm is
+* dug out rather than lit up. Above that the position has to be in a swamp
+* between Y 50 and Y 68, dark enough, and lucky against the moon phase.
+* Everything in between, and every lit surface, spawns no slimes at all.
+*
+* The one divergence from the Bedrock function is the position the biome tag
+* is read at. Bedrock reads it one block higher than the spawn position; this
+* reads it at the spawn position, because a biome boundary is the only place
+* the two can differ and neither answer is more correct there.
+*/
+var slimeSpawnRule = (at, { world, random }) => {
+	if (at.y <= SLIME_CHUNK_CEILING) return isSlimeChunk(at.x >> 4, at.z >> 4);
+	if (at.y < SLIME_SWAMP_FLOOR || at.y > SLIME_SWAMP_CEILING) return false;
+	const light = world.light(at);
+	if (light > SLIME_SWAMP_LIGHT_CEILING) return false;
+	if (light > random.nextInt(SLIME_SWAMP_LIGHT_DRAW)) return false;
+	if (random.nextFloat() >= MOON_BRIGHTNESS[moonPhase(world.age())]) return false;
+	return world.biomeTags(at).includes(SLIME_SURFACE_BIOME_TAG);
+};
+/**
+* Every engine rule vanilla needs, keyed by the entity it gates.
+*
+* {@link import('./spawner').Spawner} applies these by default. A host that
+* wants a different set passes its own map, and a host that wants none passes
+* an empty one.
+*/
+var VANILLA_ENGINE_SPAWN_RULES = /* @__PURE__ */ new Map([["minecraft:slime", slimeSpawnRule]]);
+export { MOON_BRIGHTNESS, SLIME_SURFACE_BIOME_TAG, VANILLA_ENGINE_SPAWN_RULES, isSlimeChunk, moonPhase, slimeSpawnRule };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"engineRules.es.js","names":[],"sources":["../src/engineRules.ts"],"sourcesContent":["import type { RandomSource } from '@jsprismarine/predicates';\n\nimport type { SpawnPosition, SpawnWorld } from './world';\n\n/**\n * The spawn conditions Bedrock keeps in engine code rather than in\n * `spawn_rules/*.json`.\n *\n * The 24-component grammar cannot express a hash of the chunk coordinates or a\n * draw against the moon phase, so Mojang writes those in C++ and leaves the\n * JSON file as the coarse gate in front of them. `spawn_rules/slime.json` is\n * the clearest case: it carries no brightness filter, no height filter and a\n * weight of 100, which on its own lets a slime spawn in any `monster` biome in\n * daylight and fill the monster pool to its cap. The real rule is the function\n * at virtual address `0xbb80040` of BDS 1.26.51.1's `bedrock_server`, which\n * this module reimplements.\n *\n * A rule here runs after the JSON conditions pass and before the weighted\n * draw, so the file still decides the biomes, the difficulty and the weight,\n * and the code decides what the file cannot say.\n */\n\n/** What an engine rule reads besides the position it is deciding. */\nexport interface EngineSpawnContext {\n    readonly world: SpawnWorld;\n    /** The spawner's own source, so one seed still reproduces one set of spawns. */\n    readonly random: RandomSource;\n}\n\n/**\n * One entity's engine-side spawn condition.\n *\n * @returns Whether the entity may spawn at the position, with the entity's\n *   `spawn_rules/*.json` conditions already satisfied.\n */\nexport type EngineSpawnRule = (at: SpawnPosition, context: EngineSpawnContext) => boolean;\n\n/** How far into the state a twist step reads its second word. */\nconst TWISTER_OFFSET = 397;\n\n/** The multiplier of the twister's seeding recurrence, Matsumoto and Nishimura's 1812433253. */\nconst TWISTER_SEED_MULTIPLIER = 0x6c078965;\n\n/** The twist step's tempering matrix. */\nconst TWISTER_MATRIX = 0x9908b0df;\n\n/**\n * The first 32-bit draw of a Mersenne twister seeded with one value.\n *\n * Only the first draw exists because that is all the slime chunk rule takes.\n * The twist of word zero reads words zero, one and {@link TWISTER_OFFSET}, so\n * the seeding recurrence stops one word past the offset rather than filling\n * all 624 words of a full state. Bedrock's own copy stops in the same place.\n */\nconst firstTwisterDraw = (seed: number): number => {\n    const state = new Uint32Array(TWISTER_OFFSET + 2);\n    state[0] = seed;\n    for (let index = 1; index < state.length; index += 1) {\n        const previous = state[index - 1]!;\n        state[index] = (Math.imul(TWISTER_SEED_MULTIPLIER, previous ^ (previous >>> 30)) + index) >>> 0;\n    }\n\n    const mixed = (state[0]! & 0x80000000) | (state[1]! & 0x7fffffff);\n    let draw = state[TWISTER_OFFSET]! ^ (mixed >>> 1) ^ ((mixed & 1) === 0 ? 0 : TWISTER_MATRIX);\n\n    draw ^= draw >>> 11;\n    draw ^= (draw << 7) & 0x9d2c5680;\n    draw ^= (draw << 15) & 0xefc60000;\n    draw ^= draw >>> 18;\n    return draw >>> 0;\n};\n\n/**\n * The multiplier Bedrock hashes a chunk's X coordinate by. It is the engine's\n * general-purpose hash multiplier rather than anything about slimes.\n */\nconst SLIME_CHUNK_MULTIPLIER = 0x1f1f1f1f;\n\n/** One chunk in ten holds slimes, which is the divisor of the draw. */\nconst SLIME_CHUNK_IN = 10;\n\n/** How many answers {@link isSlimeChunk} keeps before it starts over. */\nconst SLIME_CHUNK_MEMO_LIMIT = 4096;\n\nconst slimeChunkMemo = new Map<number, boolean>();\n\n/**\n * Whether a chunk is a slime chunk.\n *\n * Bedrock seeds a Mersenne twister with `chunkX * 0x1f1f1f1f ^ chunkZ` and\n * takes its first draw modulo ten. The world seed is not part of it, which is\n * why a Bedrock slime farm sits at the same chunk coordinates in every world\n * and why Java's seeded formula is the wrong answer here.\n *\n * @param chunkX - The chunk's X coordinate, which is a block X shifted right by four.\n * @param chunkZ - The chunk's Z coordinate.\n */\nexport const isSlimeChunk = (chunkX: number, chunkZ: number): boolean => {\n    const seed = (Math.imul(chunkX, SLIME_CHUNK_MULTIPLIER) ^ chunkZ) >>> 0;\n    const known = slimeChunkMemo.get(seed);\n    if (known !== undefined) return known;\n\n    const answer = firstTwisterDraw(seed) % SLIME_CHUNK_IN === 0;\n    if (slimeChunkMemo.size >= SLIME_CHUNK_MEMO_LIMIT) slimeChunkMemo.clear();\n    slimeChunkMemo.set(seed, answer);\n    return answer;\n};\n\n/** How many ticks one Minecraft day lasts. */\nconst DAY_TICKS = 24000;\n\n/**\n * How bright the moon is at each of its eight phases, starting at the full\n * moon. The swamp branch of the slime rule draws against this number, so a\n * swamp spawns no slimes at all on a new moon.\n */\nexport const MOON_BRIGHTNESS: readonly number[] = [1, 0.75, 0.5, 0.25, 0, 0.25, 0.5, 0.75];\n\n/**\n * The moon phase at one world time.\n *\n * @param time - The world's age in ticks, which is never negative on a running server.\n * @returns A phase from 0, the full moon, to 7.\n */\nexport const moonPhase = (time: number): number => Math.abs(Math.trunc(time / DAY_TICKS)) % MOON_BRIGHTNESS.length;\n\n/** The highest Y at which the slime chunk branch applies. */\nconst SLIME_CHUNK_CEILING = 38;\n\n/** The lowest Y of the swamp branch's band. */\nconst SLIME_SWAMP_FLOOR = 50;\n\n/** The highest Y of the swamp branch's band. */\nconst SLIME_SWAMP_CEILING = 68;\n\n/**\n * The light a swamp slime tolerates, before the extra draw.\n *\n * It is an early exit rather than a second condition: the draw it guards is\n * over `[0, 8)`, so a light above seven already fails it.\n */\nconst SLIME_SWAMP_LIGHT_CEILING = 7;\n\n/** The width of the draw the swamp branch compares the light against. */\nconst SLIME_SWAMP_LIGHT_DRAW = 8;\n\n/**\n * The biome tag the swamp branch reads. Three vanilla biomes carry it:\n * `swampland`, `swampland_mutated` and `mangrove_swamp`.\n */\nexport const SLIME_SURFACE_BIOME_TAG = 'spawns_slimes_on_surface';\n\n/**\n * Where a slime may spawn, which `spawn_rules/slime.json` does not say.\n *\n * Two branches, as Bedrock writes them. At Y 38 and below the position has to\n * be in a slime chunk and nothing else is asked, which is why a slime farm is\n * dug out rather than lit up. Above that the position has to be in a swamp\n * between Y 50 and Y 68, dark enough, and lucky against the moon phase.\n * Everything in between, and every lit surface, spawns no slimes at all.\n *\n * The one divergence from the Bedrock function is the position the biome tag\n * is read at. Bedrock reads it one block higher than the spawn position; this\n * reads it at the spawn position, because a biome boundary is the only place\n * the two can differ and neither answer is more correct there.\n */\nexport const slimeSpawnRule: EngineSpawnRule = (at, { world, random }) => {\n    if (at.y <= SLIME_CHUNK_CEILING) return isSlimeChunk(at.x >> 4, at.z >> 4);\n\n    if (at.y < SLIME_SWAMP_FLOOR || at.y > SLIME_SWAMP_CEILING) return false;\n\n    const light = world.light(at);\n    if (light > SLIME_SWAMP_LIGHT_CEILING) return false;\n    if (light > random.nextInt(SLIME_SWAMP_LIGHT_DRAW)) return false;\n\n    if (random.nextFloat() >= MOON_BRIGHTNESS[moonPhase(world.age())]!) return false;\n\n    return world.biomeTags(at).includes(SLIME_SURFACE_BIOME_TAG);\n};\n\n/**\n * Every engine rule vanilla needs, keyed by the entity it gates.\n *\n * {@link import('./spawner').Spawner} applies these by default. A host that\n * wants a different set passes its own map, and a host that wants none passes\n * an empty one.\n */\nexport const VANILLA_ENGINE_SPAWN_RULES: ReadonlyMap<string, EngineSpawnRule> = new Map([\n    ['minecraft:slime', slimeSpawnRule]\n]);\n"],"mappings":";;AAsCA,IAAM,iBAAiB;;AAGvB,IAAM,0BAA0B;;AAGhC,IAAM,iBAAiB;;;;;;;;;AAUvB,IAAM,oBAAoB,SAAyB;CAC/C,MAAM,wBAAQ,IAAI,YAAY,GAAkB;CAChD,MAAM,KAAK;CACX,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,GAAG;EAClD,MAAM,WAAW,MAAM,QAAQ;EAC/B,MAAM,SAAU,KAAK,KAAK,yBAAyB,WAAY,aAAa,EAAG,IAAI,UAAW;CAClG;CAEA,MAAM,QAAS,MAAM,KAAM,aAAe,MAAM,KAAM;CACtD,IAAI,OAAO,MAAM,kBAAoB,UAAU,MAAO,QAAQ,OAAO,IAAI,IAAI;CAE7E,QAAQ,SAAS;CACjB,QAAS,QAAQ,IAAK;CACtB,QAAS,QAAQ,KAAM;CACvB,QAAQ,SAAS;CACjB,OAAO,SAAS;AACpB;;;;;AAMA,IAAM,yBAAyB;;AAG/B,IAAM,iBAAiB;;AAGvB,IAAM,yBAAyB;AAE/B,IAAM,iCAAiB,IAAI,IAAqB;;;;;;;;;;;;AAahD,IAAa,gBAAgB,QAAgB,WAA4B;CACrE,MAAM,QAAQ,KAAK,KAAK,QAAQ,sBAAsB,IAAI,YAAY;CACtE,MAAM,QAAQ,eAAe,IAAI,IAAI;CACrC,IAAI,UAAU,KAAA,GAAW,OAAO;CAEhC,MAAM,SAAS,iBAAiB,IAAI,IAAI,mBAAmB;CAC3D,IAAI,eAAe,QAAQ,wBAAwB,eAAe,MAAM;CACxE,eAAe,IAAI,MAAM,MAAM;CAC/B,OAAO;AACX;;AAGA,IAAM,YAAY;;;;;;AAOlB,IAAa,kBAAqC;CAAC;CAAG;CAAM;CAAK;CAAM;CAAG;CAAM;CAAK;AAAI;;;;;;;AAQzF,IAAa,aAAa,SAAyB,KAAK,IAAI,KAAK,MAAM,OAAO,SAAS,CAAC,IAAI,gBAAgB;;AAG5G,IAAM,sBAAsB;;AAG5B,IAAM,oBAAoB;;AAG1B,IAAM,sBAAsB;;;;;;;AAQ5B,IAAM,4BAA4B;;AAGlC,IAAM,yBAAyB;;;;;AAM/B,IAAa,0BAA0B;;;;;;;;;;;;;;;AAgBvC,IAAa,kBAAmC,IAAI,EAAE,OAAO,aAAa;CACtE,IAAI,GAAG,KAAK,qBAAqB,OAAO,aAAa,GAAG,KAAK,GAAG,GAAG,KAAK,CAAC;CAEzE,IAAI,GAAG,IAAI,qBAAqB,GAAG,IAAI,qBAAqB,OAAO;CAEnE,MAAM,QAAQ,MAAM,MAAM,EAAE;CAC5B,IAAI,QAAQ,2BAA2B,OAAO;CAC9C,IAAI,QAAQ,OAAO,QAAQ,sBAAsB,GAAG,OAAO;CAE3D,IAAI,OAAO,UAAU,KAAK,gBAAgB,UAAU,MAAM,IAAI,CAAC,IAAK,OAAO;CAE3E,OAAO,MAAM,UAAU,EAAE,CAAC,CAAC,SAAS,uBAAuB;AAC/D;;;;;;;;AASA,IAAa,6CAAmE,IAAI,IAAI,CACpF,CAAC,mBAAmB,cAAc,CACtC,CAAC"}

package/dist/index.cjs.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_world = require("./world.cjs.cjs");
+const require_constants = require("./constants.cjs.cjs");
+const require_rules = require("./rules.cjs.cjs");
+const require_conditions = require("./conditions.cjs.cjs");
+const require_engineRules = require("./engineRules.cjs.cjs");
+const require_spawner = require("./spawner.cjs.cjs");
+const require_despawn = require("./despawn.cjs.cjs");
+exports.DIFFICULTIES = require_rules.DIFFICULTIES;
+exports.MOON_BRIGHTNESS = require_engineRules.MOON_BRIGHTNESS;
+exports.POPULATION_POOLS = require_rules.POPULATION_POOLS;
+exports.SLIME_SURFACE_BIOME_TAG = require_engineRules.SLIME_SURFACE_BIOME_TAG;
+exports.SPAWN_CONSTANTS = require_constants.SPAWN_CONSTANTS;
+exports.SPAWN_RULE_COMPONENTS = require_rules.SPAWN_RULE_COMPONENTS;
+exports.SPAWN_SITE_FLAGS = require_world.SPAWN_SITE_FLAGS;
+exports.SPAWN_WEATHER = require_world.SPAWN_WEATHER;
+exports.SpawnDelays = require_conditions.SpawnDelays;
+exports.Spawner = require_spawner.Spawner;
+exports.VANILLA_ENGINE_SPAWN_RULES = require_engineRules.VANILLA_ENGINE_SPAWN_RULES;
+exports.cycleTicksFor = require_constants.cycleTicksFor;
+exports.despawnReason = require_despawn.despawnReason;
+exports.distanceSquared = require_world.distanceSquared;
+exports.evaluateSpawnCondition = require_conditions.evaluateSpawnCondition;
+exports.horizontalDistanceSquared = require_world.horizontalDistanceSquared;
+exports.isSlimeChunk = require_engineRules.isSlimeChunk;
+exports.moonPhase = require_engineRules.moonPhase;
+exports.parseSpawnRule = require_rules.parseSpawnRule;
+exports.passAt = require_world.passAt;
+exports.poolCapFor = require_constants.poolCapFor;
+exports.slimeSpawnRule = require_engineRules.slimeSpawnRule;
+exports.spawnFilterContext = require_conditions.spawnFilterContext;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './conditions';
+export * from './constants';
+export * from './despawn';
+export * from './engineRules';
+export * from './rules';
+export * from './spawner';
+export * from './world';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC"}

package/dist/index.es.js

@@ -0,0 +1,8 @@
+import { SPAWN_SITE_FLAGS, SPAWN_WEATHER, distanceSquared, horizontalDistanceSquared, passAt } from "./world.es.js";
+import { SPAWN_CONSTANTS, cycleTicksFor, poolCapFor } from "./constants.es.js";
+import { DIFFICULTIES, POPULATION_POOLS, SPAWN_RULE_COMPONENTS, parseSpawnRule } from "./rules.es.js";
+import { SpawnDelays, evaluateSpawnCondition, spawnFilterContext } from "./conditions.es.js";
+import { MOON_BRIGHTNESS, SLIME_SURFACE_BIOME_TAG, VANILLA_ENGINE_SPAWN_RULES, isSlimeChunk, moonPhase, slimeSpawnRule } from "./engineRules.es.js";
+import { Spawner } from "./spawner.es.js";
+import { despawnReason } from "./despawn.es.js";
+export { DIFFICULTIES, MOON_BRIGHTNESS, POPULATION_POOLS, SLIME_SURFACE_BIOME_TAG, SPAWN_CONSTANTS, SPAWN_RULE_COMPONENTS, SPAWN_SITE_FLAGS, SPAWN_WEATHER, SpawnDelays, Spawner, VANILLA_ENGINE_SPAWN_RULES, cycleTicksFor, despawnReason, distanceSquared, evaluateSpawnCondition, horizontalDistanceSquared, isSlimeChunk, moonPhase, parseSpawnRule, passAt, poolCapFor, slimeSpawnRule, spawnFilterContext };