@nodecraft/rendermite 1.8.0 → 1.10.0

package/dist/block-behaviour-DVjqeSkv.js

@@ -0,0 +1,180 @@
+//#region src/blocks/block-behaviour.ts
+const PUSH_REACTIONS = /* @__PURE__ */ new Set([
+	"destroy",
+	"block",
+	"ignore",
+	"push_only"
+]);
+function num(value) {
+	return value?.kind === "number" ? value.value : null;
+}
+function field(handle, name) {
+	return handle.fields.get(`mapped:${name}`) ?? handle.fields.get(name);
+}
+/** A `MapColor` (`MaterialColor` before 1.20) is constructed as `(id, rgb)`; its id is the first. */
+function mapColorId(value) {
+	if (value?.kind !== "object") return null;
+	const args = value.handle.ctorArgs ?? [];
+	const id = num(args[0]);
+	if (args.length === 2 && id !== null && num(args[1]) !== null && id >= 0 && id < 64) return id;
+	if (args[0]?.kind !== "string" || args[1]?.kind !== "number") return null;
+	for (const arg of args) {
+		const nested = arg.kind === "object" && arg.handle !== value.handle ? mapColorId(arg) : null;
+		if (nested !== null) return nested;
+	}
+	return null;
+}
+/** An enum constant's serialized name: the lower-cased constant name it was constructed with. */
+function enumName(value) {
+	const name = value?.kind === "object" ? value.handle.ctorArgs?.[0] : void 0;
+	return name?.kind === "string" ? name.value.toLowerCase() : null;
+}
+/** The chain of `Properties` a block's came from, oldest copy first, so later calls win. */
+function lineage(props) {
+	const chain = [];
+	for (let at = props; at && !chain.includes(at); at = at.copyOf) chain.unshift(at);
+	return chain;
+}
+/** The `Material` a pre-1.20 `Properties` was constructed with, when it was. */
+function materialOf(props) {
+	for (const handle of lineage(props)) for (const arg of handle.ctorArgs ?? []) if (arg.kind === "object" && field(arg.handle, "replaceable") !== void 0) return arg.handle;
+	return null;
+}
+/**
+* The colour a block's `Properties` state: a `mapColor` call, the colour a pre-1.20 `Properties` was
+* constructed with, or its `Material`'s, latest first. A constant or a function of state.
+*/
+function statedMapColor(props) {
+	const material = materialOf(props);
+	let colour = material ? field(material, "color") : void 0;
+	for (const handle of lineage(props)) {
+		colour = (handle.ctorArgs ?? []).find((arg) => arg.kind === "lambda" || mapColorId(arg) !== null) ?? colour;
+		for (const call of handle.calls ?? []) if (call.name === "mapColor") colour = call.args[0];
+	}
+	return colour;
+}
+/** A float as Java wrote it: `0.3F` is 0.30000001192092896 as a double, and 0.3 is what the code says. */
+function float32(value) {
+	for (let digits = 1; digits < 10; digits++) {
+		const candidate = Number(value.toPrecision(digits));
+		if (Math.fround(candidate) === Math.fround(value)) return candidate;
+	}
+	return value;
+}
+function flag(value) {
+	return value.kind === "number" ? value.value === 0 ? 0 : 1 : null;
+}
+function blockBehaviour(registration, extraction, overrides = null) {
+	const props = registration.props;
+	if (!props) return null;
+	const failures = [];
+	const behaviour = {
+		hardness: 0,
+		resistance: 0
+	};
+	const mapColor = statedMapColor(props);
+	const material = materialOf(props);
+	if (material) {
+		if (num(field(material, "replaceable")) === 1) behaviour.replaceable = true;
+		if (num(field(material, "liquid")) === 1) behaviour.liquid = true;
+		if (num(field(material, "flammable")) === 1) behaviour.flammable = true;
+		if (num(field(material, "alwaysDestroyable")) === 0) behaviour.requiresTool = true;
+		const reaction = enumName(field(material, "pushReaction"));
+		if (reaction && PUSH_REACTIONS.has(reaction)) behaviour.pushReaction = reaction;
+	}
+	for (const handle of lineage(props)) for (const call of handle.calls ?? []) {
+		const [first, second] = call.args;
+		switch (call.name) {
+			case "strength":
+				behaviour.hardness = float32(num(first) ?? behaviour.hardness);
+				behaviour.resistance = float32(num(second ?? first) ?? behaviour.resistance);
+				break;
+			case "destroyTime":
+				behaviour.hardness = float32(num(first) ?? behaviour.hardness);
+				break;
+			case "explosionResistance":
+				behaviour.resistance = float32(num(first) ?? behaviour.resistance);
+				break;
+			case "instabreak":
+				behaviour.hardness = 0;
+				behaviour.resistance = 0;
+				break;
+			case "noCollission":
+			case "noCollision":
+				behaviour.collision = false;
+				behaviour.occludes = false;
+				break;
+			case "noOcclusion":
+				behaviour.occludes = false;
+				break;
+			case "replaceable":
+				behaviour.replaceable = true;
+				break;
+			case "air":
+				behaviour.air = true;
+				break;
+			case "liquid":
+				behaviour.liquid = true;
+				break;
+			case "ignitedByLava":
+				behaviour.flammable = true;
+				break;
+			case "requiresCorrectToolForDrops":
+				behaviour.requiresTool = true;
+				break;
+			case "randomTicks":
+				behaviour.randomTicks = true;
+				break;
+			case "pushReaction": {
+				const reaction = enumName(first);
+				if (reaction === "normal") delete behaviour.pushReaction;
+				else if (reaction && PUSH_REACTIONS.has(reaction)) behaviour.pushReaction = reaction;
+				break;
+			}
+			case "friction":
+			case "speedFactor":
+			case "jumpFactor": {
+				const value = num(first);
+				if (value !== null) behaviour[call.name] = float32(value);
+				break;
+			}
+		}
+	}
+	if (mapColor?.kind === "lambda") {
+		const folded = extraction.tabulate(mapColor, mapColorId);
+		if ("failure" in folded) failures.push(`map colour: ${folded.failure}`);
+		else behaviour.mapColor = folded.value;
+	} else if (mapColor !== void 0) {
+		const id = mapColorId(mapColor);
+		if (id === null) failures.push("map colour is a value the interpreter could not identify");
+		else behaviour.mapColor = id;
+	}
+	const answer = (names, read) => {
+		const method = overrides?.of(names) ?? null;
+		if (!method) return null;
+		const folded = extraction.tabulateMethod(registration, method, read);
+		if ("failure" in folded) {
+			failures.push(`${names[0]}: ${folded.failure}`);
+			return null;
+		}
+		return folded.value;
+	};
+	const shape = answer(["useShapeForLightOcclusion"], flag);
+	if (shape === 1) behaviour.lightShape = true;
+	else if (shape !== null && typeof shape === "object") behaviour.lightShape = shape;
+	const lightBlock = answer(["getLightBlock", "getLightDampening"], (value) => value.kind === "number" ? value.value : null);
+	if (lightBlock !== null) behaviour.lightBlock = lightBlock;
+	const fluidMethod = overrides?.of(["getFluidState"]);
+	const fluid = fluidMethod && overrides ? overrides.fluid(fluidMethod) : null;
+	if (fluid) behaviour.fluid = fluid;
+	const renderShape = overrides?.of(["getRenderShape"]);
+	if (renderShape && overrides?.invisible(renderShape)) behaviour.invisible = true;
+	if (overrides?.of(["skipRendering"])) behaviour.hidesSharedFaces = true;
+	if (answer(["isAir"], flag) === 1) behaviour.air = true;
+	return {
+		behaviour,
+		failures
+	};
+}
+//#endregion
+export { statedMapColor as n, blockBehaviour as t };

package/dist/block-overrides-XtxICunI.js

@@ -0,0 +1,77 @@
+import { n as instructions } from "./entity-sizes-DspxgSUA.js";
+//#region src/blocks/block-overrides.ts
+/**
+* Where a block's own class answers a question itself, rather than leaving it to its `Properties`.
+*
+* Some of what a block does is a method override, not a builder call: a stair or a slab tests its
+* shape for light (`useShapeForLightOcclusion`), tinted glass stops all light (`getLightBlock`), kelp is
+* always under water (`getFluidState`), and before 1.16.2 an air block said so by overriding `isAir`.
+* The override is found by walking the block's class chain for a method of that original name, and it
+* only counts where a class below the base declares it: the base's own is the default answer.
+*/
+/** `getstatic`, `invokevirtual` and `invokeinterface`: the instructions whose target says what code reads. */
+const READS = /* @__PURE__ */ new Set([
+	178,
+	182,
+	185
+]);
+/** How far up a block's class chain to look; vanilla's deepest is well under this. */
+const MAX_DEPTH = 16;
+/** The nearest override of one of `names` above `blockType`, or null where only the base declares it. */
+function overrideOf(source, blockType, names) {
+	const declarations = [];
+	let at = source.resolve(blockType);
+	for (let depth = 0; at && depth < MAX_DEPTH; depth++) {
+		const owner = at.thisClass;
+		const method = at.methods.find((candidate) => candidate.code && names.includes(source.nameOf({
+			owner,
+			name: candidate.name,
+			descriptor: candidate.descriptor
+		}, false)));
+		if (method) declarations.push({
+			owner,
+			name: method.name,
+			descriptor: method.descriptor
+		});
+		at = at.superClass ? source.resolve(at.superClass) : null;
+	}
+	return declarations.length > 1 ? declarations[0] : null;
+}
+/**
+* The constants an override reads, by original name, and whether it reads a block property: enough to
+* answer from its code without running it. Kelp's `getFluidState` reads `Fluids.WATER` and nothing
+* else; a barrier's `getRenderShape` reads `RenderShape.INVISIBLE`. One that reads a property
+* (`waterlogged`) answers per state, which the state already says.
+*/
+function constantsReadBy(source, method) {
+	const classFile = source.resolve(method.owner);
+	const code = classFile?.methods.find((candidate) => candidate.name === method.name && candidate.descriptor === method.descriptor)?.code;
+	if (!classFile || !code) return null;
+	const statics = /* @__PURE__ */ new Set();
+	let readsState = false;
+	for (const { op, index } of instructions(code)) {
+		const reference = READS.has(op) ? classFile.reference(index) : null;
+		if (!reference) continue;
+		const name = source.nameOf(reference, op === 178);
+		if (op === 178) statics.add(name);
+		else if (name === "getValue") readsState = true;
+	}
+	return {
+		statics,
+		readsState
+	};
+}
+/** The fluid an override of `getFluidState` holds in every state, or null where it depends on one. */
+function constantFluidOf(source, method) {
+	const read = constantsReadBy(source, method);
+	if (!read || read.readsState) return null;
+	if (read.statics.has("WATER")) return "water";
+	return read.statics.has("LAVA") ? "lava" : null;
+}
+/** Whether an override of `getRenderShape` always answers `INVISIBLE`, as a barrier's and a light block's do. */
+function alwaysInvisible(source, method) {
+	const read = constantsReadBy(source, method);
+	return read !== null && !read.readsState && read.statics.has("INVISIBLE") && !read.statics.has("MODEL");
+}
+//#endregion
+export { overrideOf as i, constantFluidOf as n, constantsReadBy as r, alwaysInvisible as t };

package/dist/blocks/atlas-pack.d.ts

@@ -1,2 +1,2 @@
-import { a as PackedRect, i as PackedPage, n as PackOptions, o as packAtlas, r as PackedAtlas, t as PackEntry } from "../atlas-pack-C56gzqAg.js";
+import { a as PackedRect, i as PackedPage, n as PackOptions, o as packAtlas, r as PackedAtlas, t as PackEntry } from "../atlas-pack-BUadroKy.js";
 export { PackEntry, PackOptions, PackedAtlas, PackedPage, PackedRect, packAtlas };

package/dist/blocks/biomes.d.ts

@@ -1,2 +1,2 @@
-import { a as buildBiomeClimates, i as VANILLA_BIOME_CLIMATES, n as BiomeClimatePack, o as parseBiomeClimate, r as DEFAULT_WATER_COLOR, t as BiomeClimate } from "../biomes-CJDJQqJb.js";
-export { BiomeClimate, BiomeClimatePack, DEFAULT_WATER_COLOR, VANILLA_BIOME_CLIMATES, buildBiomeClimates, parseBiomeClimate };
+import { a as LegacyBiome, c as buildBiomeClimates, i as LEGACY_BIOMES, l as parseBiomeClimate, n as BiomeClimatePack, o as PRE_JAR_BIOMES, r as DEFAULT_WATER_COLOR, s as VANILLA_BIOME_CLIMATES, t as BiomeClimate, u as vanillaBiomesFor } from "../biomes-CnnhDCnk.js";
+export { BiomeClimate, BiomeClimatePack, DEFAULT_WATER_COLOR, LEGACY_BIOMES, LegacyBiome, PRE_JAR_BIOMES, VANILLA_BIOME_CLIMATES, buildBiomeClimates, parseBiomeClimate, vanillaBiomesFor };

package/dist/blocks/biomes.js

@@ -1,2 +1,2 @@
-import { i as parseBiomeClimate, n as VANILLA_BIOME_CLIMATES, r as buildBiomeClimates, t as DEFAULT_WATER_COLOR } from "../biomes-5ZwYxMYe.js";
-export { DEFAULT_WATER_COLOR, VANILLA_BIOME_CLIMATES, buildBiomeClimates, parseBiomeClimate };
+import { a as buildBiomeClimates, i as VANILLA_BIOME_CLIMATES, n as LEGACY_BIOMES, o as parseBiomeClimate, r as PRE_JAR_BIOMES, s as vanillaBiomesFor, t as DEFAULT_WATER_COLOR } from "../biomes-BGOF6gRM.js";
+export { DEFAULT_WATER_COLOR, LEGACY_BIOMES, PRE_JAR_BIOMES, VANILLA_BIOME_CLIMATES, buildBiomeClimates, parseBiomeClimate, vanillaBiomesFor };

package/dist/blocks/block-behaviour.d.ts

@@ -0,0 +1,2 @@
+import { i as statedMapColor, n as PushReactionName, r as blockBehaviour, t as BlockBehaviour } from "../block-behaviour-BBslelpW.js";
+export { BlockBehaviour, PushReactionName, blockBehaviour, statedMapColor };

package/dist/blocks/block-behaviour.js

@@ -0,0 +1,2 @@
+import { n as statedMapColor, t as blockBehaviour } from "../block-behaviour-DVjqeSkv.js";
+export { blockBehaviour, statedMapColor };

package/dist/blocks/block-entities.d.ts

@@ -1,6 +1,6 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { i as TextureLoader } from "../loader-59_eMa8e.js";
-import { t as ModelLoader } from "../loader-DSir1-P0.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
+import { i as TextureLoader } from "../loader-C4gsX_wO.js";
+import { t as ModelLoader } from "../loader-BYyPIs9f.js";
 //#region src/blocks/block-entities.d.ts
 /**
  * What the table is allowed to look at. The vanilla families are a lookup, but

package/dist/blocks/block-overrides.d.ts

@@ -0,0 +1,26 @@
+import { d as MemberReference } from "../block-behaviour-BBslelpW.js";
+import { t as ClassFile } from "../classfile-Dzn0gW9M.js";
+//#region src/blocks/block-overrides.d.ts
+interface OverrideSource {
+  resolve: (internalName: string) => ClassFile | null;
+  /** A member's original name, for a jar that spells the game's own obfuscated. */
+  nameOf: (reference: MemberReference, field: boolean) => string;
+}
+/** The nearest override of one of `names` above `blockType`, or null where only the base declares it. */
+declare function overrideOf(source: OverrideSource, blockType: string, names: readonly string[]): MemberReference | null;
+/**
+ * The constants an override reads, by original name, and whether it reads a block property: enough to
+ * answer from its code without running it. Kelp's `getFluidState` reads `Fluids.WATER` and nothing
+ * else; a barrier's `getRenderShape` reads `RenderShape.INVISIBLE`. One that reads a property
+ * (`waterlogged`) answers per state, which the state already says.
+ */
+declare function constantsReadBy(source: OverrideSource, method: MemberReference): {
+  statics: Set<string>;
+  readsState: boolean;
+} | null;
+/** The fluid an override of `getFluidState` holds in every state, or null where it depends on one. */
+declare function constantFluidOf(source: OverrideSource, method: MemberReference): 'water' | 'lava' | null;
+/** Whether an override of `getRenderShape` always answers `INVISIBLE`, as a barrier's and a light block's do. */
+declare function alwaysInvisible(source: OverrideSource, method: MemberReference): boolean;
+//#endregion
+export { OverrideSource, alwaysInvisible, constantFluidOf, constantsReadBy, overrideOf };

package/dist/blocks/block-overrides.js

@@ -0,0 +1,2 @@
+import { i as overrideOf, n as constantFluidOf, r as constantsReadBy, t as alwaysInvisible } from "../block-overrides-XtxICunI.js";
+export { alwaysInvisible, constantFluidOf, constantsReadBy, overrideOf };

package/dist/blocks/cli.js

@@ -1,2 +1,2 @@
-import { t as runBlocksCli } from "../cli-Dw1Q5CPR.js";
+import { t as runBlocksCli } from "../cli-DwMPoX0I.js";
 export { runBlocksCli };

package/dist/blocks/datapack.d.ts

@@ -0,0 +1,2 @@
+import { i as collectDatapack, n as DatapackResult, r as TagPack, t as AdvancementPack } from "../datapack-CmEg0Vko.js";
+export { AdvancementPack, DatapackResult, TagPack, collectDatapack };

package/dist/blocks/datapack.js

@@ -0,0 +1,2 @@
+import { t as collectDatapack } from "../datapack-D6eH46ay.js";
+export { collectDatapack };

package/dist/blocks/ender-storage.d.ts

@@ -1,5 +1,5 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { m as BlockPackModel } from "../pack-format-BqWf-DNc.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
+import { P as BlockPackModel } from "../block-behaviour-BBslelpW.js";
 //#region src/blocks/ender-storage.d.ts
 /**
  * Ender Storage feeds this OBJ through CodeChickenLib's `swapYZ`, translates it almost exactly onto

package/dist/blocks/entities.d.ts

@@ -1,6 +1,6 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { i as TextureLoader } from "../loader-59_eMa8e.js";
-import { w as EntityPackEntry } from "../pack-format-BqWf-DNc.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
+import { i as TextureLoader } from "../loader-C4gsX_wO.js";
+import { q as EntityPackEntry } from "../block-behaviour-BBslelpW.js";
 //#region src/blocks/entities.d.ts
 interface EntityPackResult {
   entities: Record<string, EntityPackEntry>;

package/dist/blocks/entity-geo.d.ts

@@ -1,4 +1,4 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
 import { r as ExtractedModel } from "../model-PnQ4gV0-.js";
 //#region src/blocks/entity-geo.d.ts
 interface GeoEntityModel {

package/dist/blocks/entity-models.d.ts

@@ -1,8 +1,8 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { D as EquipmentPack, T as EntityPackModel } from "../pack-format-BqWf-DNc.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
 import { t as ClassSource } from "../jar-classes-CSRrPAUy.js";
-import { t as Mappings } from "../mappings-USwcjtcH.js";
-import { t as ModelCode } from "../model-code-Csc3bs3h.js";
+import { J as EntityPackModel, X as EquipmentPack } from "../block-behaviour-BBslelpW.js";
+import { t as Mappings } from "../mappings-DhOPQTgV.js";
+import { t as ModelCode } from "../model-code-BclYt1do.js";
 //#region src/blocks/entity-models.d.ts
 interface EntityGeometryResult {
   /** Model id (the class it came from) → geometry. */
@@ -53,15 +53,6 @@ declare function collectEntityGeometry(options: CollectEntityGeometryOptions): P
  * lowest to highest precedence, matching atlas source resolution when packs extend the vanilla file.
  */
 declare function collectArmourTrims(resources: ResourceManager, spriteIds: Set<string>): Promise<EquipmentPack['trims']>;
-/**
- * Worn armour for the pack: one humanoid mesh, the sheets each material is drawn with, and which
- * item is which.
- *
- * Materials are discovered from the sheets the version actually ships rather than listed, so a
- * version that adds one — copper, in the 26 line — needs no edit here. The item ids are the one part
- * the assets cannot answer, since nothing in them maps `iron_helmet` to `iron`: they follow the
- * game's own naming, and each is confirmed against a real item model before being claimed.
- */
 declare function collectEquipment(names: readonly string[], mappings: Mappings, read: (internal: string) => Promise<Uint8Array | null>, code: ModelCode, resources: ResourceManager | undefined, models: Record<string, EntityPackModel>, spriteIds: Set<string>): Promise<EquipmentPack | null>;
 //#endregion
 export { CollectEntityGeometryOptions, EntityGeometryResult, collectArmourTrims, collectEntityGeometry, collectEquipment };

package/dist/blocks/entity-models.js

@@ -1,2 +1,2 @@
-import { n as collectEntityGeometry, r as collectEquipment, t as collectArmourTrims } from "../entity-models-BGiy3pey.js";
+import { n as collectEntityGeometry, r as collectEquipment, t as collectArmourTrims } from "../entity-models-vFl_EwfA.js";
 export { collectArmourTrims, collectEntityGeometry, collectEquipment };

package/dist/blocks/entity-sizes.d.ts

@@ -0,0 +1,25 @@
+import { t as ClassSource } from "../jar-classes-CSRrPAUy.js";
+//#region src/blocks/entity-sizes.d.ts
+interface Instruction {
+  op: number;
+  /** The pool index a two-byte operand names, for the loads and invokes this reads. */
+  index: number;
+}
+/** Every instruction of a method, in order. */
+declare function instructions(code: Uint8Array): Generator<Instruction>;
+interface EntitySizeResult {
+  /** Entity id → [width, height], in blocks. */
+  sizes: Map<string, [number, number]>;
+  failures: Array<{
+    id: string;
+    reason: string;
+  }>;
+}
+declare function collectEntitySizes(options: {
+  classes: ClassSource;
+  version: string;
+  cacheDir: string;
+  entityIds: readonly string[];
+}): Promise<EntitySizeResult>;
+//#endregion
+export { EntitySizeResult, collectEntitySizes, instructions };

package/dist/blocks/entity-sizes.js

@@ -0,0 +1,2 @@
+import { n as instructions, t as collectEntitySizes } from "../entity-sizes-DspxgSUA.js";
+export { collectEntitySizes, instructions };

package/dist/blocks/export.d.ts

@@ -1,2 +1,2 @@
-import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "../export-J13L9Lqu.js";
+import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "../export-CqeTinYL.js";
 export { BlockPackFailure, BlockPackResult, ExportBlockPackOptions, exportBlockPack };

package/dist/blocks/export.js

@@ -1,2 +1,2 @@
-import { t as exportBlockPack } from "../export-t8X_oRws.js";
+import { t as exportBlockPack } from "../export-ArMmWuCC.js";
 export { exportBlockPack };

package/dist/blocks/game-rules.d.ts

@@ -0,0 +1,2 @@
+import { n as GameRulePack, r as collectGameRules, t as GameRule } from "../game-rules-ThvdDG3B.js";
+export { GameRule, GameRulePack, collectGameRules };

package/dist/blocks/game-rules.js

@@ -0,0 +1,2 @@
+import { t as collectGameRules } from "../game-rules-BDPTopVW.js";
+export { collectGameRules };

package/dist/blocks/geo-blocks.d.ts

@@ -1,5 +1,5 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { m as BlockPackModel } from "../pack-format-BqWf-DNc.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
+import { P as BlockPackModel } from "../block-behaviour-BBslelpW.js";
 //#region src/blocks/geo-blocks.d.ts
 interface GeoBlockOverride {
   model: BlockPackModel;

package/dist/blocks/item-sprites.d.ts

@@ -1,7 +1,7 @@
-import { a as ResourceManager } from "../manager-exOIcdyx.js";
-import { i as TextureLoader } from "../loader-59_eMa8e.js";
-import { t as ModelLoader } from "../loader-DSir1-P0.js";
-import { k as ItemPackEntry } from "../pack-format-BqWf-DNc.js";
+import { a as ResourceManager } from "../manager-Ct0dEOMg.js";
+import { i as TextureLoader } from "../loader-C4gsX_wO.js";
+import { t as ModelLoader } from "../loader-BYyPIs9f.js";
+import { Q as ItemPackEntry } from "../block-behaviour-BBslelpW.js";
 //#region src/blocks/item-sprites.d.ts
 interface ItemSpriteFailure {
   id: string;

package/dist/blocks/light-bytecode.d.ts

@@ -1,174 +1,2 @@
-import { d as BlockPackLight } from "../pack-format-BqWf-DNc.js";
-import { t as ClassFile } from "../classfile-CsLXlh5z.js";
-//#region src/blocks/light-bytecode.d.ts
-/** A member reference as the constant pool spells it. */
-interface MemberReference {
-  owner: string;
-  name: string;
-  descriptor: string;
-}
-/** What the caller supplies: how to find code, and how to rename a reference before looking. */
-interface LightCodeSource {
-  /** The parsed class, or null for anything outside the jars (the JDK, a loader). */
-  resolve: (internalName: string) => ClassFile | null;
-  /**
-   * A reference as the jar spells it. A mod names the game's classes and members by their original
-   * names; against an obfuscated client those have to be renamed before they can be found.
-   */
-  remap: (reference: MemberReference, field: boolean) => MemberReference;
-  remapClass: (internalName: string) => string;
-  /** Classes that are a block `Properties` builder, in every spelling the jars use. */
-  propsClasses: ReadonlySet<string>;
-  /**
-   * Whether a class is the game's rather than a mod's. A mod export runs the game's own `Blocks` too,
-   * for the properties mods copy, and its registrations must not answer for a mod block that happens
-   * to share a name — `immersiveengineering:lantern` is not `minecraft:lantern`.
-   */
-  isVanillaClass: (internalName: string) => boolean;
-  /**
-   * Methods a block class may override to answer its own light: the game's `getLightValue(state)`
-   * before 1.16, when a lit furnace was an override rather than a lambda, and a loader's
-   * `getLightEmission(state, level, pos)`. `root` is the class whose implementation is the plain
-   * property read, so a call resolving there — `super.getLightValue(state)` — is answered from the
-   * block's `Properties`.
-   */
-  lightGetters: ReadonlyArray<LightGetter>;
-}
-interface LightGetter {
-  name: string;
-  /** Empty to match by name alone: a loader method whose parameter types the jar does not spell. */
-  descriptor: string;
-  root: string | null;
-}
-/** How a block's light is stated, before it is evaluated. */
-type LightSpec = {
-  kind: 'constant';
-  level: number;
-} |
-/** A `ToIntFunction<BlockState>`, to be run per state. */
-{
-  kind: 'function';
-  fn: LambdaValue;
-} |
-/** A block class's own light method: a 1.13–1.15 `getLightValue` override, or a loader's `getLightEmission`. */
-{
-  kind: 'method';
-  owner: string;
-  getter: LightGetter;
-  receiver: Handle | null;
-} |
-/** A light function the interpreter could not identify — one built from a value it never saw. */
-{
-  kind: 'opaque';
-  reason: string;
-};
-interface Handle {
-  id: number;
-  /** Internal class name, from `new` or the declared return type of the opaque call that made it. */
-  type: string | null;
-  /** Strings that flowed into this object: the name a registration key or a property was made from. */
-  strings: string[];
-  numbers: number[];
-  /** Class literals that flowed in: the value class of an enum property. */
-  classes: string[];
-  fields: Map<string, Value>;
-  isProps: boolean;
-  light: LightSpec | null;
-  /** For a block: the `Properties` it was constructed with. */
-  props: Handle | null;
-  ctorArgs: Value[] | null;
-  /** `StringBuilder` parts, for the pre-Java 9 way of building a name. */
-  builder?: Array<string | number>;
-  origin?: string;
-  /** Entries of a map the code filled, for a lookup table of properties by direction. */
-  map?: Array<{
-    key: Value;
-    value: Value;
-  }>;
-  /** Elements of a list or set the code filled, for a table of names a mod registers in a loop. */
-  items?: Value[];
-  /** An iterator over a list: what it walks and where it is. */
-  iterator?: {
-    items: Value[];
-    at: number;
-  };
-}
-interface LambdaValue {
-  kind: 'lambda';
-  owner: string;
-  name: string;
-  descriptor: string;
-  captured: Value[];
-}
-/** A `BlockState` during evaluation of a light function: a bag of property values being read. */
-interface StateProbe {
-  values: Map<string, string>;
-  domains: Map<string, PropertyDomain>;
-  reads: Set<string>;
-  failure: string | null;
-}
-interface PropertyDomain {
-  name: string;
-  values: string[];
-  /** The enum constant per serialized value, for a property whose values are an enum. */
-  constants?: Map<string, Handle>;
-}
-type Value = LambdaValue | {
-  kind: 'number';
-  value: number;
-  wide?: boolean;
-} | {
-  kind: 'string';
-  value: string;
-} | {
-  kind: 'object';
-  handle: Handle;
-} | {
-  kind: 'array';
-  items: Value[];
-} | {
-  kind: 'class';
-  name: string;
-} | {
-  kind: 'null';
-} | {
-  kind: 'state';
-  probe: StateProbe;
-} | {
-  kind: 'unknown';
-};
-/** One registration this found: which `Properties` a name was registered with, and the block if seen. */
-interface Registration {
-  props: Handle | null;
-  block: Handle | null;
-  /** The block's class, when a factory method reference named it. */
-  blockType: string | null;
-  /** The call that registered it, for a person chasing a wrong answer. */
-  site: string;
-  /** Made by the game's own code, which a mod's block of the same bare name must not inherit. */
-  vanilla: boolean;
-}
-/** What one run over a set of registry classes found. */
-interface LightExtraction {
-  registrations: Map<string, Registration>;
-  notes: string[];
-  /** The light a block emits, or why it could not be worked out. */
-  lightOf: (blockId: string) => {
-    light: BlockPackLight;
-  } | {
-    failure: string;
-  };
-  /** What was recorded for a block, for a person chasing a failure. */
-  describe: (blockId: string) => string;
-}
-/**
- * Runs the registry code of a set of classes and answers, per block, what it emits.
- *
- * `roots` are the classes whose methods register blocks; every method of each is run, because where
- * the registrations sit differs by era and mod — `<clinit>` for a modern registry, a static
- * `registerBlocks()` in 1.13, an instance `init()` in a mod. The order is `<clinit>` first, since the
- * others read what it set up.
- */
-declare function extractBlockLight(roots: readonly ClassFile[], source: LightCodeSource): LightExtraction;
-//#endregion
-export { LightCodeSource, LightExtraction, LightGetter, LightSpec, MemberReference, PropertyDomain, Registration, StateProbe, extractBlockLight };
+import { _ as extractBlockLight, a as Handle, c as LightExtraction, d as MemberReference, f as PropertyDomain, g as Value, h as StateProbe, l as LightGetter, m as Registration, o as LambdaValue, p as PropsCall, s as LightCodeSource, u as LightSpec } from "../block-behaviour-BBslelpW.js";
+export { Handle, LambdaValue, LightCodeSource, LightExtraction, LightGetter, LightSpec, MemberReference, PropertyDomain, PropsCall, Registration, StateProbe, Value, extractBlockLight };