@nodecraft/rendermite 1.4.1 → 1.6.0

package/dist/geo-model-Bo1gpEwX.js

@@ -0,0 +1,163 @@
+//#region src/entities/geo-model.ts
+/** Where a `ModelPart`'s origin sits above the feet, in pixels: 1.5 blocks. */
+const FEET = 24;
+const DEGREES = Math.PI / 180;
+/** A cycle in `parent` links would otherwise walk forever; no real model nests anywhere near this. */
+const MAX_DEPTH = 32;
+const vec3 = (values) => [
+	values?.[0] ?? 0,
+	values?.[1] ?? 0,
+	values?.[2] ?? 0
+];
+/** A bedrock point in `ModelPart` space. */
+const toJava = (point) => [
+	point[0],
+	FEET - point[1],
+	point[2]
+];
+/** `-0` is what negating an unrotated bone leaves behind, and it has no business in a pack file. */
+const noMinusZero = (value) => value === 0 ? 0 : value;
+const toJavaRotation = (rotation) => {
+	const [pitch, yaw, roll] = vec3(rotation);
+	return [
+		noMinusZero(pitch * DEGREES),
+		noMinusZero(-yaw * DEGREES),
+		noMinusZero(-roll * DEGREES)
+	];
+};
+const FACES = [
+	"north",
+	"south",
+	"east",
+	"west",
+	"up",
+	"down"
+];
+/** Bedrock's per-face rects, which have no equivalent in a Java box unwrap. */
+function faceRects(cube, size) {
+	if (!cube.uv || Array.isArray(cube.uv)) return;
+	const faces = {};
+	for (const face of FACES) {
+		const entry = cube.uv[face];
+		if (entry?.uv) faces[face] = {
+			uv: [entry.uv[0], entry.uv[1]],
+			size: [entry.uv_size?.[0] ?? size[0], entry.uv_size?.[1] ?? size[1]]
+		};
+	}
+	return Object.keys(faces).length > 0 ? faces : void 0;
+}
+/**
+* One bedrock cube, in the space of the part that owns it.
+*
+* `pivot` is the *bone's* pivot in bedrock space: a cube's box is stated in absolute coordinates, and a
+* `ModelPart`'s is stated relative to where the part pivots. The y flip swaps which corner is the
+* minimum, so the origin is measured from the far side of the box.
+*/
+function toCube(cube, pivot) {
+	if (!cube.origin || !cube.size) return null;
+	const stated = vec3(cube.origin);
+	const extent = vec3(cube.size);
+	const origin = stated.map((value, axis) => Math.min(value, value + extent[axis]));
+	const size = extent.map((value) => Math.abs(value));
+	const rects = faceRects(cube, size);
+	const uv = Array.isArray(cube.uv) ? cube.uv : [];
+	return {
+		origin: [
+			origin[0] - pivot[0],
+			pivot[1] - origin[1] - size[1],
+			origin[2] - pivot[2]
+		],
+		size,
+		uv: [uv[0] ?? 0, uv[1] ?? 0],
+		inflate: cube.inflate ?? 0,
+		mirror: cube.mirror ?? false,
+		...rects && { faces: rects }
+	};
+}
+/**
+* Converts one parsed `.geo.json` into a model.
+*
+* Bones are a flat list joined by `parent` name, so the tree is rebuilt here. A bone whose parent is
+* missing becomes a root rather than being dropped, and a cube carrying its own rotation becomes a part
+* of its own: `Cube` has nowhere to put a rotation, and 18% of the corpus's cubes have one.
+*/
+function geoToModel(geo) {
+	const bones = geo.bones;
+	const byName = /* @__PURE__ */ new Map();
+	for (const bone of bones) if (bone.name) byName.set(bone.name, bone);
+	const notes = [];
+	const parts = /* @__PURE__ */ new Map();
+	const pivots = /* @__PURE__ */ new Map();
+	for (const bone of bones) {
+		const pivot = vec3(bone.pivot);
+		pivots.set(bone, pivot);
+		const cubes = [];
+		const rotated = [];
+		for (const cube of bone.cubes ?? []) {
+			if (cube.rotation?.some((value) => value !== 0) && cube.pivot) {
+				const cubePivot = vec3(cube.pivot);
+				const converted = toCube(cube, cubePivot);
+				if (converted) rotated.push({
+					name: `${bone.name ?? "bone"}_cube${rotated.length + 1}`,
+					pivot: subtract(toJava(cubePivot), toJava(pivot)),
+					rotation: toJavaRotation(cube.rotation),
+					cubes: [converted],
+					children: []
+				});
+				continue;
+			}
+			const converted = toCube(cube, pivot);
+			if (converted) cubes.push(converted);
+		}
+		parts.set(bone, {
+			name: bone.name ?? `bone${parts.size + 1}`,
+			pivot: [
+				0,
+				0,
+				0
+			],
+			rotation: toJavaRotation(bone.rotation),
+			cubes,
+			children: rotated
+		});
+	}
+	const roots = [];
+	for (const bone of bones) {
+		const part = parts.get(bone);
+		const parent = bone.parent ? byName.get(bone.parent) : void 0;
+		if (parent && parent !== bone && depthOf(bone, byName) < MAX_DEPTH) {
+			part.pivot = subtract(toJava(pivots.get(bone)), toJava(pivots.get(parent)));
+			parts.get(parent).children.push(part);
+			continue;
+		}
+		if (bone.parent && !parent) notes.push(`${bone.name ?? "a bone"} names a parent the file does not define, so it hangs from the model root`);
+		part.pivot = toJava(pivots.get(bone));
+		roots.push(part);
+	}
+	return {
+		textureSize: [geo.textureWidth, geo.textureHeight],
+		parts: roots,
+		notes
+	};
+}
+function subtract(left, right) {
+	return [
+		left[0] - right[0],
+		left[1] - right[1],
+		left[2] - right[2]
+	];
+}
+/** How far a bone sits from its root, which is also the cycle check. */
+function depthOf(bone, byName) {
+	const seen = /* @__PURE__ */ new Set();
+	let current = bone;
+	let depth = 0;
+	while (current && !seen.has(current) && depth < MAX_DEPTH) {
+		seen.add(current);
+		current = current.parent ? byName.get(current.parent) : void 0;
+		depth++;
+	}
+	return depth;
+}
+//#endregion
+export { geoToModel as t };

package/dist/index.d.ts

@@ -6,15 +6,15 @@ import { a as PackedRect, i as PackedPage, n as PackOptions, o as packAtlas, r a
 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";
 import { a as resolveTexture, n as ModelResolutionError, o as salvageJson, r as ResolvedModel, t as ModelLoader } from "./loader-DSir1-P0.js";
 import { a as BlockStateMultipartCase, d as matchesCondition, f as parseBlockState, i as BlockStateError, l as collectModels, n as BlockProperties, o as BlockStateVariantCase, p as weightedVariantIndex, r as BlockStateDefinition, s as MultipartCondition, t as BlockModelVariant, u as evaluateBlockState } from "./blockstate-eval-BzznRcVY.js";
-import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "./export-Bllg8Fw7.js";
 import { i as buildObjMesh, n as ObjMesh, r as ObjMeshError, t as MeshGroup } from "./obj-mesh-ydhVfLKs.js";
 import { a as buildBlockTints, i as UNREGISTERED_TINTS, n as BlockTintPack, t as BlockTint } from "./tints-DoBv5S9v.js";
+import { i as exportBlockPack, n as BlockPackResult, r as ExportBlockPackOptions, t as BlockPackFailure } from "./export-D8fLC1wS.js";
 import { s as builtinDynamicResources } from "./generators-BnIzAftW.js";
 import { d as toFloatTexture, n as FloatTexture, u as toByteTexture } from "./blend-eT64Z6qm.js";
 import { a as LightingProfileName, i as LightingProfile, r as LightSource, u as lightsForProfile } from "./lighting-3FGRC3Af.js";
 import { a as RenderedFrames, c as renderModel, i as RenderOptions, l as renderModelFrames, o as boxDownscale, r as ItemRenderError, s as pointResize } from "./renderer-C_DFi8DF.js";
 import { c as defaultProperties, i as ItemRenderInstruction, l as evaluateItemModel, n as InvalidItemDefinitionError, o as TintDefinition, r as ItemProperties, s as UNKNOWN_MODEL } from "./definition-ricL7Jqf.js";
-import { a as resolveItem, i as discoverItems, n as ItemDiscoveryOptions, r as ItemResolutionError, t as DiscoveredItem } from "./discovery-C5ZR4aoG.js";
+import { i as discoverItems, n as ItemDiscoveryOptions, o as resolveItem, r as ItemResolutionError, t as DiscoveredItem } from "./discovery-Cmir3QfC.js";
 import { a as resolveTint, i as parseTintValue, n as InvalidTinterDefinitionError, o as resolveTints, t as DYE_COLORS } from "./tints-6z6ysGUs.js";
 import { i as EncodedIcon, n as EncodeOptions, o as encodeAnimatedIcon, r as EncodedAnimatedIcon, s as encodeIcon, t as AnimatedEncodeOptions } from "./encode-Cf8hI5OY.js";
 import { t as minifyStylesheet } from "./minify-CIV6enbr.js";

package/dist/index.js

@@ -1,26 +1,26 @@
-import { t as packAtlas } from "./atlas-pack-CoOih7By.js";
 import { i as parseBiomeClimate, n as VANILLA_BIOME_CLIMATES, r as buildBiomeClimates, t as DEFAULT_WATER_COLOR } from "./biomes-5ZwYxMYe.js";
 import { n as ResourceLocator, t as InvalidResourceLocatorError } from "./locator-COMEtEn9.js";
 import { a as parseBlockState, i as matchesCondition, n as collectModels, o as weightedVariantIndex, r as evaluateBlockState, t as BlockStateError } from "./blockstate-eval-BRQ3NWY2.js";
 import { c as toByteTexture, l as toFloatTexture } from "./blend-KXMclcHk.js";
 import { c as lightsForProfile, r as LightingProfile } from "./lighting--5myudVu.js";
+import { a as defaultProperties, i as UNKNOWN_MODEL, n as InvalidItemDefinitionError, o as evaluateItemModel } from "./definition-ColsvWrH.js";
+import { i as resolveItem, n as discoverItems, t as ItemResolutionError } from "./discovery-CD0QqxSF.js";
 import { a as salvageJson, i as resolveTexture, n as ModelResolutionError, t as ModelLoader } from "./loader-C-NuJaEi.js";
-import { a as ItemRenderError, c as renderModel, l as renderModelFrames, o as boxDownscale, s as pointResize } from "./obj-bvs3gwex.js";
-import { n as buildObjMesh, t as ObjMeshError } from "./obj-mesh-rnYbSbpv.js";
+import { a as resolveTints, i as resolveTint, n as InvalidTinterDefinitionError, r as parseTintValue, t as DYE_COLORS } from "./tints-B3WQcPtx.js";
+import { a as ItemRenderError, c as renderModel, l as renderModelFrames, o as boxDownscale, s as pointResize } from "./obj-CJHEHpki.js";
+import { n as buildObjMesh, t as ObjMeshError } from "./obj-mesh-JwPkZEWL.js";
+import { t as packAtlas } from "./atlas-pack-CoOih7By.js";
 import { n as buildBlockTints, t as UNREGISTERED_TINTS } from "./tints-Cl0r-Ol3.js";
 import { o as createAtlasResolver, s as parseAtlasSources, t as AtlasSourceError } from "./sources-BlUriDCs.js";
 import { n as LayeredResourceManager, r as ResourceKind, t as FolderResourceManager } from "./manager-BNibYkmI.js";
 import { n as TextureLoader, r as TextureResolutionError, t as AnimatedTexture } from "./loader-C18GpurU.js";
-import { t as exportBlockPack } from "./export-kMoMes_a.js";
-import { a as defaultProperties, i as UNKNOWN_MODEL, n as InvalidItemDefinitionError, o as evaluateItemModel } from "./definition-ColsvWrH.js";
+import { t as exportBlockPack } from "./export-DT_drDoI.js";
 import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "./jar-W2cV2ZVO.js";
-import { n as prepareModResources } from "./prepare-C9gjqQTt.js";
-import { a as prepareVersionResources, i as eraForVersion, r as compareVersions } from "./prepare-8LswFoS-.js";
-import { n as discoverItems, r as resolveItem, t as ItemResolutionError } from "./discovery-CsZu08re.js";
+import { n as prepareModResources } from "./prepare-Myd_ec4v.js";
+import { a as prepareVersionResources, i as eraForVersion, r as compareVersions } from "./prepare-D49Gu4Lv.js";
 import { n as encodeIcon, t as encodeAnimatedIcon } from "./encode-LR9wxigC.js";
 import { a as builtinDynamicResources } from "./generators-BCZVlWig.js";
 import { t as minifyStylesheet } from "./minify-bjMRmr5J.js";
 import { n as itemClass, t as generateStylesheet } from "./stylesheet-CovT3B2S.js";
-import { a as resolveTints, i as resolveTint, n as InvalidTinterDefinitionError, r as parseTintValue, t as DYE_COLORS } from "./tints-B3WQcPtx.js";
-import { t as run } from "./run-B_JAUbXe.js";
+import { t as run } from "./run-BQJkqc5f.js";
 export { AnimatedTexture, AtlasSourceError, BlockStateError, DEFAULT_WATER_COLOR, DYE_COLORS, FolderResourceManager, InvalidItemDefinitionError, InvalidResourceLocatorError, InvalidTinterDefinitionError, ItemRenderError, ItemResolutionError, JarResourceManager, LayeredResourceManager, LightingProfile, ModelLoader, ModelResolutionError, ObjMeshError, ResourceKind, ResourceLocator, TextureLoader, TextureResolutionError, UNKNOWN_MODEL, UNREGISTERED_TINTS, UnsafeJarError, VANILLA_BIOME_CLIMATES, boxDownscale, buildBiomeClimates, buildBlockTints, buildObjMesh, builtinDynamicResources, collectModels, compareVersions, createAtlasResolver, defaultProperties, discoverItems, encodeAnimatedIcon, encodeIcon, eraForVersion, evaluateBlockState, evaluateItemModel, exportBlockPack, generateStylesheet, isUnsafeEntryPath, itemClass, lightsForProfile, matchesCondition, minifyStylesheet, packAtlas, parseAtlasSources, parseBiomeClimate, parseBlockState, parseTintValue, pointResize, prepareModResources, prepareVersionResources, renderModel, renderModelFrames, resolveItem, resolveTexture, resolveTint, resolveTints, run, salvageJson, toByteTexture, toFloatTexture, weightedVariantIndex };

package/dist/inherit-KkDsM2N_.js

@@ -0,0 +1,77 @@
+import { t as parseClassFile } from "./classfile-CAhS5qNf.js";
+import { i as mergeModels } from "./merge-3HkeQ_6A.js";
+import { t as extractModel } from "./model-bytecode-C1nw2G8O.js";
+//#region src/entities/inherit.ts
+/**
+* A model class read together with its ancestors.
+*
+* Model code leans on its superclass everywhere. Before 1.17 a model's parts were fields assigned in
+* the constructor and a subclass overrode the two or three it cared about, leaving the rest to
+* `super()`; `CowModel` declares a head with horns and a body, and its four legs belong to
+* `QuadrupedModel`. It did not end with the old API either: 26.2's `PigModel` still starts from
+* `QuadrupedModel.createBodyMesh(6, …)` and only replaces the head.
+*
+* So the interpreter is handed the chain and follows calls into it, arguments and all. What it cannot
+* follow — a builder that loops, a frame past the budget — the name merge below still salvages, one
+* class at a time.
+*/
+/** `java/lang/Object` ends the walk; the cap is for a jar whose hierarchy has a cycle in it. */
+const MAX_ANCESTORS = 8;
+/** Reads a class and everything it inherits from that the jar still holds. */
+async function ancestryOf(internalName, read) {
+	const ancestors = /* @__PURE__ */ new Map();
+	const chain = [];
+	let next = internalName.replaceAll(".", "/");
+	for (let depth = 0; next && depth < MAX_ANCESTORS && !ancestors.has(next); depth++) {
+		const bytes = await read(next);
+		if (!bytes) break;
+		let classFile;
+		try {
+			classFile = parseClassFile(bytes);
+		} catch {
+			break;
+		}
+		ancestors.set(next, classFile);
+		chain.push({
+			internalName: next,
+			bytes
+		});
+		next = classFile.superClass;
+	}
+	return {
+		ancestors,
+		chain
+	};
+}
+/**
+* Geometry for one class, with the code it builds on available and its ancestors' parts filled in.
+*
+* `code` widens what a call may be followed into beyond the ancestors, which some models need: the
+* witch's body is the villager's, and a donkey's chest comes from the saddle model. Without it those
+* models still come out, minus the piece the other class holds.
+*
+* Every ancestor is merged rather than only the first with boxes, because a deep hierarchy splits
+* several ways: 1.16.5's sheep overrides a head in `SheepFurModel` and takes its legs from
+* `QuadrupedModel` two hops up.
+*/
+async function extractInheritedModel(internalName, read, code) {
+	const { ancestors, chain } = await ancestryOf(internalName, read);
+	const [own, ...inherited] = chain;
+	if (!own) return null;
+	const resolve = (name) => ancestors.get(name) ?? code?.resolve(name) ?? null;
+	const following = (name) => !code || code.resolve(name) !== null;
+	let model = extractModel(own.bytes, {
+		resolve,
+		isModelCode: following(own.internalName)
+	});
+	for (const ancestor of inherited) {
+		const inheritedModel = extractModel(ancestor.bytes, {
+			resolve,
+			isModelCode: following(ancestor.internalName)
+		});
+		model = mergeModels(model, inheritedModel);
+	}
+	return model;
+}
+//#endregion
+export { extractInheritedModel as n, ancestryOf as t };

package/dist/item-sprites-G-yikdfV.js

@@ -0,0 +1,126 @@
+import { i as resolveItem, r as langRegistry } from "./discovery-CD0QqxSF.js";
+import { i as resolveTexture } from "./loader-C-NuJaEi.js";
+import { a as resolveTints } from "./tints-B3WQcPtx.js";
+//#region src/blocks/item-sprites.ts
+/**
+* Flat item sprites, for the items a world holds that are not blocks.
+*
+* A dropped stack is the commonest entity in a played-in world, and the game
+* draws it from the *item* model rather than the block one. Most of the time that
+* item model is a block's, and a consumer with the block pack already has what it
+* needs. The rest — a lead, a handful of charcoal, an arrow, a mod's seed — are
+* `item/generated`: a stack of flat sprites the client extrudes into a thin slab,
+* with no geometry stated anywhere because `ItemModelGenerator` builds it in code.
+*
+* So this exports the only thing there is to export: the ordered layer sprites,
+* and which of them the item tints. The consumer does the extruding.
+*
+* Deliberately *not* filtered to non-block ids. Whether an item is flat is decided
+* by asking what its own model resolves to, which is also what the game asks —
+* and it gets `minecraft:wheat` right, where the item is a flat sheaf and the
+* block of the same id is a crop cross.
+*/
+/** The builtin parent whose geometry the client generates from flat layers. */
+const GENERATED = "builtin/generated";
+/** `layer0`, `layer1`, … in the order the client stacks them. */
+const LAYER_NAME = /^layer(\d+)$/;
+/** `{ r, g, b }` in 0–1 as `#rrggbb`, matching how the tint pack writes a colour. */
+function hex(color) {
+	return `#${[
+		color.r,
+		color.g,
+		color.b
+	].map((channel) => Math.round(Math.max(0, Math.min(1, channel)) * 255).toString(16).padStart(2, "0")).join("")}`;
+}
+/**
+* The layers of one generated model, in draw order.
+*
+* Sorted by the number in the name rather than by key order: a mod that writes
+* `layer1` before `layer0` still stacks the way the client stacks it, and a chain
+* that merged its parent's textures has no reliable order at all.
+*/
+function layersOf(textures) {
+	const layers = [];
+	for (const name of Object.keys(textures)) {
+		const match = LAYER_NAME.exec(name);
+		if (match) layers.push({
+			index: Number(match[1]),
+			reference: `#${name}`
+		});
+	}
+	return layers.toSorted((left, right) => left.index - right.index);
+}
+async function collectItemSprites(options) {
+	const { resources, models, textures, blocks, itemIds } = options;
+	const items = {};
+	const spriteIds = /* @__PURE__ */ new Set();
+	const failures = [];
+	let done = 0;
+	const translated = /* @__PURE__ */ new Map();
+	for (const namespace of options.namespaces) translated.set(namespace, await langRegistry(resources, namespace));
+	const report = (id, reason) => {
+		const divider = id.indexOf(":");
+		const gate = translated.get(id.slice(0, divider));
+		if (gate === void 0 || gate === null || gate.has(id.slice(divider + 1).replaceAll("/", "."))) failures.push({
+			id,
+			reason
+		});
+	};
+	for (const id of [...itemIds].toSorted((left, right) => left.localeCompare(right))) {
+		options.onProgress?.(++done, itemIds.length);
+		let instructions;
+		try {
+			instructions = await resolveItem(resources, id);
+		} catch (err) {
+			if (!blocks.has(id)) report(id, err.message);
+			continue;
+		}
+		const layers = [];
+		let flat = true;
+		for (const instruction of instructions) {
+			let model;
+			try {
+				model = await models.load(instruction.model);
+			} catch (err) {
+				flat = false;
+				if (!blocks.has(id)) report(id, `model ${instruction.model} did not load: ${err.message}`);
+				break;
+			}
+			if (model.builtinParent !== GENERATED) {
+				flat = false;
+				break;
+			}
+			const tints = await resolveTints(instruction.tints, { textures });
+			for (const layer of layersOf(model.textures)) {
+				const sprite = resolveTexture(model, layer.reference);
+				if (!sprite) {
+					report(id, `${layer.reference} resolves to no texture; layer dropped`);
+					continue;
+				}
+				const tint = tints[layer.index];
+				layers.push({
+					sprite: sprite.toString(),
+					...instruction.tints[layer.index] !== void 0 && { tintindex: layer.index },
+					...tint && { tint: hex(tint) }
+				});
+				spriteIds.add(sprite.toString());
+			}
+		}
+		if (!flat) {
+			if (!blocks.has(id)) report(id, "item model is not a flat sprite stack and the pack describes no block of this id");
+			continue;
+		}
+		if (layers.length === 0) {
+			report(id, "generated item model states no layers");
+			continue;
+		}
+		items[id] = { layers };
+	}
+	return {
+		items,
+		spriteIds,
+		failures
+	};
+}
+//#endregion
+export { collectItemSprites as t };

package/dist/items/discovery.d.ts

@@ -1,2 +1,2 @@
-import { a as resolveItem, i as discoverItems, n as ItemDiscoveryOptions, r as ItemResolutionError, t as DiscoveredItem } from "../discovery-C5ZR4aoG.js";
-export { DiscoveredItem, ItemDiscoveryOptions, ItemResolutionError, discoverItems, resolveItem };
+import { a as langRegistry, i as discoverItems, n as ItemDiscoveryOptions, o as resolveItem, r as ItemResolutionError, t as DiscoveredItem } from "../discovery-Cmir3QfC.js";
+export { DiscoveredItem, ItemDiscoveryOptions, ItemResolutionError, discoverItems, langRegistry, resolveItem };

package/dist/items/discovery.js

@@ -1,2 +1,2 @@
-import { n as discoverItems, r as resolveItem, t as ItemResolutionError } from "../discovery-CsZu08re.js";
-export { ItemResolutionError, discoverItems, resolveItem };
+import { i as resolveItem, n as discoverItems, r as langRegistry, t as ItemResolutionError } from "../discovery-CD0QqxSF.js";
+export { ItemResolutionError, discoverItems, langRegistry, resolveItem };

package/dist/jar-classes-Bj15hjdr.js

@@ -0,0 +1,75 @@
+import { t as openZip } from "./zip-reader-BSbJKUT1.js";
+import { n as UnsafeJarError, r as isUnsafeEntryPath } from "./jar-W2cV2ZVO.js";
+//#region src/entities/jar-classes.ts
+/**
+* Reading `.class` entries out of a jar.
+*
+* `JarResourceManager` deliberately indexes only `assets/` and `data/` — it is a *resource* manager,
+* and a class file is not a resource. But entity geometry lives in the code (see
+* `docs/entity-geometry.md`), so the extractor needs the other half of the archive, and it needs it
+* by internal class name rather than by resource locator.
+*
+* Same shape as the resource manager for the same reason: index the central directory once, then read
+* entries on demand. A client jar holds around eight thousand classes and the extractor touches a
+* hundred of them.
+*/
+/** Reads class files out of one jar, by internal name. */
+var JarClassReader = class {
+	jarPath;
+	index = null;
+	constructor(jarPath) {
+		this.jarPath = jarPath;
+	}
+	getIndex() {
+		this.index ??= (async () => {
+			const zip = await openZip(this.jarPath);
+			return await new Promise((resolve, reject) => {
+				const entries = /* @__PURE__ */ new Map();
+				zip.on("entry", (entry) => {
+					if (isUnsafeEntryPath(entry.fileName)) {
+						zip.close();
+						reject(new UnsafeJarError(`Unsafe entry in ${this.jarPath}: ${entry.fileName}`));
+						return;
+					}
+					if (entry.fileName.endsWith(".class")) entries.set(entry.fileName.slice(0, -6), entry);
+					zip.readEntry();
+				});
+				zip.on("end", () => resolve({
+					zip,
+					entries
+				}));
+				zip.on("error", reject);
+				zip.readEntry();
+			});
+		})();
+		return this.index;
+	}
+	/** Every class in the jar, for a sweep that does not know what it is looking for. */
+	async list() {
+		return (await this.getIndex()).entries.keys().toArray();
+	}
+	async read(internalName) {
+		const index = await this.getIndex();
+		const entry = index.entries.get(internalName.replaceAll(".", "/"));
+		if (!entry) return null;
+		return await new Promise((resolve, reject) => {
+			index.zip.openReadStream(entry, (err, stream) => {
+				if (err) {
+					reject(err);
+					return;
+				}
+				const chunks = [];
+				stream.on("data", (chunk) => {
+					chunks.push(chunk);
+				});
+				stream.on("end", () => resolve(new Uint8Array(Buffer.concat(chunks))));
+				stream.on("error", reject);
+			});
+		});
+	}
+	async close() {
+		if (this.index) (await this.index).zip.close();
+	}
+};
+//#endregion
+export { JarClassReader as t };