@nodecraft/rendermite 0.0.1 → 1.0.0

package/dist/geometry-uIDha8S4.js

@@ -0,0 +1,229 @@
+//#region src/render/geometry.ts
+const FACE_NORMALS = {
+	up: [
+		0,
+		1,
+		0
+	],
+	down: [
+		0,
+		-1,
+		0
+	],
+	north: [
+		0,
+		0,
+		-1
+	],
+	south: [
+		0,
+		0,
+		1
+	],
+	east: [
+		1,
+		0,
+		0
+	],
+	west: [
+		-1,
+		0,
+		0
+	]
+};
+function buildElementFaces(element) {
+	const from = [
+		element.from[0] / 16,
+		element.from[1] / 16,
+		element.from[2] / 16
+	];
+	const to = [
+		element.to[0] / 16,
+		element.to[1] / 16,
+		element.to[2] / 16
+	];
+	const a = [
+		to[0],
+		to[1],
+		to[2]
+	];
+	const g = [
+		from[0],
+		from[1],
+		from[2]
+	];
+	const b = [
+		g[0],
+		a[1],
+		a[2]
+	];
+	const c = [
+		g[0],
+		g[1],
+		a[2]
+	];
+	const d = [
+		a[0],
+		g[1],
+		a[2]
+	];
+	const e = [
+		a[0],
+		a[1],
+		g[2]
+	];
+	const f = [
+		g[0],
+		a[1],
+		g[2]
+	];
+	const h = [
+		a[0],
+		g[1],
+		g[2]
+	];
+	const quads = {
+		down: [
+			c,
+			d,
+			h,
+			g
+		],
+		up: [
+			f,
+			e,
+			a,
+			b
+		],
+		north: [
+			e,
+			f,
+			g,
+			h
+		],
+		south: [
+			b,
+			a,
+			d,
+			c
+		],
+		west: [
+			f,
+			b,
+			c,
+			g
+		],
+		east: [
+			a,
+			e,
+			h,
+			d
+		]
+	};
+	const autoUvs = {
+		down: [[c[0], c[2]], [h[0], h[2]]],
+		up: [[f[0], f[2]], [a[0], a[2]]],
+		north: [[g[0], g[1]], [e[0], e[1]]],
+		south: [[c[0], c[1]], [a[0], a[1]]],
+		west: [[g[2], g[1]], [b[2], b[1]]],
+		east: [[h[2], h[1]], [a[2], a[1]]]
+	};
+	const faces = [];
+	for (const [directionName, faceJson] of Object.entries(element.faces)) {
+		const direction = directionName;
+		if (!faceJson || !(direction in quads)) continue;
+		let uv1;
+		let uv2;
+		if (faceJson.uv) {
+			uv1 = [faceJson.uv[0] / 16, faceJson.uv[1] / 16];
+			uv2 = [faceJson.uv[2] / 16, faceJson.uv[3] / 16];
+		} else {
+			[uv1, uv2] = autoUvs[direction];
+			uv1 = [uv1[0], uv1[1]];
+			uv2 = [uv2[0], uv2[1]];
+		}
+		const override = parseShadeOverride(element);
+		faces.push({
+			direction,
+			vertices: quads[direction],
+			uv1,
+			uv2,
+			textureRef: faceJson.texture,
+			rotation: faceJson.rotation ?? 0,
+			tintIndex: faceJson.tintindex ?? null,
+			shadeDirectionOverride: override
+		});
+	}
+	applyElementRotation(element.rotation_rc ?? element.rotation, [
+		a,
+		b,
+		c,
+		d,
+		e,
+		f,
+		g,
+		h
+	]);
+	return faces;
+}
+function parseShadeOverride(element) {
+	const override = element.shade_direction_override;
+	if (override && override in FACE_NORMALS) return FACE_NORMALS[override];
+	return null;
+}
+/**
+* Element rotation mutates the shared corner vectors in place, after face/UV
+* construction. Supports the vanilla {origin, axis, angle} form and the newer
+* per-axis {origin, x?, y?, z?} form (applied X, then Y, then Z). `rotation_rc`
+* takes precedence when present (renderchest escape hatch). No angle restriction,
+* no rescale — matching upstream.
+*/
+function applyElementRotation(rotation, corners) {
+	if (!rotation) return;
+	const origin = [
+		rotation.origin[0] / 16,
+		rotation.origin[1] / 16,
+		rotation.origin[2] / 16
+	];
+	const toRadians = Math.PI / 180;
+	const multiAxis = rotation;
+	if (rotation.axis !== void 0 && rotation.angle !== void 0) {
+		rotateAll(corners, origin, rotation.axis, rotation.angle * toRadians);
+		return;
+	}
+	for (const axis of [
+		"x",
+		"y",
+		"z"
+	]) {
+		const angle = multiAxis[axis];
+		if (typeof angle === "number" && angle !== 0) rotateAll(corners, origin, axis, angle * toRadians);
+	}
+}
+function rotateAll(corners, origin, axis, angle) {
+	const cos = Math.cos(angle);
+	const sin = Math.sin(angle);
+	for (const corner of corners) {
+		const x = corner[0] - origin[0];
+		const y = corner[1] - origin[1];
+		const z = corner[2] - origin[2];
+		let rx = x;
+		let ry = y;
+		let rz = z;
+		if (axis === "x") {
+			ry = y * cos - z * sin;
+			rz = y * sin + z * cos;
+		} else if (axis === "y") {
+			rx = x * cos + z * sin;
+			rz = -x * sin + z * cos;
+		} else {
+			rx = x * cos - y * sin;
+			ry = x * sin + y * cos;
+		}
+		corner[0] = rx + origin[0];
+		corner[1] = ry + origin[1];
+		corner[2] = rz + origin[2];
+	}
+}
+//#endregion
+export { applyElementRotation as n, buildElementFaces as r, FACE_NORMALS as t };

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { n as ResourceLocator, t as InvalidResourceLocatorError } from "./locator-jDbdUeTd.js";
+import { a as ResourceManager, i as ResourceKindName, n as LayeredResourceManager, r as ResourceKind, t as FolderResourceManager } from "./manager-CoZaeQTu.js";
+import { a as TextureMeta, i as TextureLoader, o as TextureResolutionError, r as Texture, t as AnimatedTexture } from "./loader-TFFNV4Jl.js";
+import { d as parseAtlasSources, n as AtlasSource, r as AtlasSourceError, s as ResolvedSprite, t as AtlasResolver, u as createAtlasResolver } from "./sources-DH9dk3KF.js";
+import { s as builtinDynamicResources } from "./generators-CCB8h0mP.js";
+import { a as resolveTexture, n as ModelResolutionError, o as salvageJson, r as ResolvedModel, t as ModelLoader } from "./loader-lCkMRDH4.js";
+import { c as toFloatTexture, s as toByteTexture, t as FloatTexture } from "./blend-Qvrn6YgK.js";
+import { a as LightingProfileName, i as LightingProfile, r as LightSource, u as lightsForProfile } from "./lighting-3FGRC3Af.js";
+import { a as pointResize, i as boxDownscale, n as RenderOptions, o as renderModel, r as RenderedFrames, s as renderModelFrames, t as ItemRenderError } from "./renderer-DQfv6axF.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-BwX6Xxv0.js";
+import { i as resolveItem, n as ItemResolutionError, r as discoverItems, t as DiscoveredItem } from "./discovery-CmNYzKPr.js";
+import { a as resolveTint, i as parseTintValue, n as InvalidTinterDefinitionError, o as resolveTints, t as DYE_COLORS } from "./tints-Fr6WoPaU.js";
+import { a as encodeAnimatedIcon, i as EncodedIcon, n as EncodeOptions, o as encodeIcon, r as EncodedAnimatedIcon, t as AnimatedEncodeOptions } from "./encode-BDB_VIHN.js";
+import { t as minifyStylesheet } from "./minify-CIV6enbr.js";
+import { a as compareVersions, o as eraForVersion, s as prepareVersionResources } from "./prepare-wfWtaz_X.js";
+import { i as prepareModResources } from "./prepare-DnnGGv9k.js";
+import { i as itemClass, n as StylesheetOptions, r as generateStylesheet, t as ItemStyle } from "./stylesheet-i-t_7sZ7.js";
+import { i as run, n as RunOptions, r as RunResult, t as ItemFailure } from "./run-D2XL05Zl.js";
+import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "./jar-6T3xdgaL.js";
+export { type AnimatedEncodeOptions, AnimatedTexture, type AtlasResolver, type AtlasSource, AtlasSourceError, DYE_COLORS, type DiscoveredItem, type EncodeOptions, type EncodedAnimatedIcon, type EncodedIcon, type FloatTexture, FolderResourceManager, InvalidItemDefinitionError, InvalidResourceLocatorError, InvalidTinterDefinitionError, type ItemFailure, type ItemProperties, ItemRenderError, type ItemRenderInstruction, ItemResolutionError, type ItemStyle, JarResourceManager, LayeredResourceManager, type LightSource, LightingProfile, type LightingProfileName, ModelLoader, ModelResolutionError, type RenderOptions, type RenderedFrames, type ResolvedModel, type ResolvedSprite, ResourceKind, type ResourceKindName, ResourceLocator, type ResourceManager, type RunOptions, type RunResult, type StylesheetOptions, type Texture, TextureLoader, type TextureMeta, TextureResolutionError, type TintDefinition, UNKNOWN_MODEL, UnsafeJarError, boxDownscale, builtinDynamicResources, compareVersions, createAtlasResolver, defaultProperties, discoverItems, encodeAnimatedIcon, encodeIcon, eraForVersion, evaluateItemModel, generateStylesheet, isUnsafeEntryPath, itemClass, lightsForProfile, minifyStylesheet, parseAtlasSources, parseTintValue, pointResize, prepareModResources, prepareVersionResources, renderModel, renderModelFrames, resolveItem, resolveTexture, resolveTint, resolveTints, run, salvageJson, toByteTexture, toFloatTexture };

package/dist/index.js

@@ -0,0 +1,20 @@
+import { n as ResourceLocator, t as InvalidResourceLocatorError } from "./locator-ycZzh_6z.js";
+import { n as LayeredResourceManager, r as ResourceKind, t as FolderResourceManager } from "./manager-dfI7b9N4.js";
+import { n as UnsafeJarError, r as isUnsafeEntryPath, t as JarResourceManager } from "./jar-Bt3i0ls4.js";
+import { o as createAtlasResolver, s as parseAtlasSources, t as AtlasSourceError } from "./sources-Bxk-WOzH.js";
+import { a as builtinDynamicResources } from "./generators-CcVRG30y.js";
+import { a as defaultProperties, i as UNKNOWN_MODEL, n as InvalidItemDefinitionError, o as evaluateItemModel } from "./definition-3MBm8ar_.js";
+import { n as discoverItems, r as resolveItem, t as ItemResolutionError } from "./discovery-BzaOti7l.js";
+import { a as salvageJson, i as resolveTexture, n as ModelResolutionError, t as ModelLoader } from "./loader-C-eqwp3M.js";
+import { o as toByteTexture, s as toFloatTexture } from "./blend-CHP2-j9U.js";
+import { n as encodeIcon, t as encodeAnimatedIcon } from "./encode-BdTHbOp-.js";
+import { t as minifyStylesheet } from "./minify-bjMRmr5J.js";
+import { n as itemClass, t as generateStylesheet } from "./stylesheet-CovT3B2S.js";
+import { c as lightsForProfile, r as LightingProfile } from "./lighting--5myudVu.js";
+import { a as renderModelFrames, i as renderModel, n as boxDownscale, r as pointResize, t as ItemRenderError } from "./renderer-CmOz6WI9.js";
+import { a as resolveTints, i as resolveTint, n as InvalidTinterDefinitionError, r as parseTintValue, t as DYE_COLORS } from "./tints-FQlxTzUL.js";
+import { n as TextureLoader, r as TextureResolutionError, t as AnimatedTexture } from "./loader-CBzn3Koc.js";
+import { t as run } from "./run-CEaRhk4A.js";
+import { a as prepareVersionResources, i as eraForVersion, r as compareVersions } from "./prepare-DROxBZp1.js";
+import { n as prepareModResources } from "./prepare-Bvc5ve2m.js";
+export { AnimatedTexture, AtlasSourceError, DYE_COLORS, FolderResourceManager, InvalidItemDefinitionError, InvalidResourceLocatorError, InvalidTinterDefinitionError, ItemRenderError, ItemResolutionError, JarResourceManager, LayeredResourceManager, LightingProfile, ModelLoader, ModelResolutionError, ResourceKind, ResourceLocator, TextureLoader, TextureResolutionError, UNKNOWN_MODEL, UnsafeJarError, boxDownscale, builtinDynamicResources, compareVersions, createAtlasResolver, defaultProperties, discoverItems, encodeAnimatedIcon, encodeIcon, eraForVersion, evaluateItemModel, generateStylesheet, isUnsafeEntryPath, itemClass, lightsForProfile, minifyStylesheet, parseAtlasSources, parseTintValue, pointResize, prepareModResources, prepareVersionResources, renderModel, renderModelFrames, resolveItem, resolveTexture, resolveTint, resolveTints, run, salvageJson, toByteTexture, toFloatTexture };

package/dist/item-styles-DJ3LWZS2.js

@@ -0,0 +1,174 @@
+import { i as TRIM_MATERIALS, n as POTTERY_SHERDS, r as TRIM_DARKER_MATERIALS, t as ARMOR_ITEM_TYPES } from "./generators-CcVRG30y.js";
+//#region src/output/item-styles.ts
+/**
+* Per-item CSS style classification, ported from upstream's ItemStyleGenerators
+* (Internal, DecoratedPot, Armor, Potion, ChargedProjectile, Map, FireWorkStar,
+* Enchanted, Default — first match wins). Variant rules only reference dynamic
+* images that actually rendered, so a version without (say) resin trims never
+* emits rules pointing at missing files.
+*/
+const ARMOR_MATERIALS = [
+	"leather",
+	"copper",
+	"chainmail",
+	"iron",
+	"golden",
+	"diamond",
+	"netherite"
+];
+/** Items that always show the enchant glint. */
+const ENCHANTED_EFFECT_ITEMS = /* @__PURE__ */ new Set([
+	"minecraft:experience_bottle",
+	"minecraft:enchanted_golden_apple",
+	"minecraft:enchanted_book",
+	"minecraft:written_book"
+]);
+const POTIONS = {
+	"minecraft:potion": {
+		content: "rc_potion_content",
+		bottle: "rc_potion_bottle"
+	},
+	"minecraft:splash_potion": {
+		content: "rc_potion_content",
+		bottle: "rc_potion_bottle_splash"
+	},
+	"minecraft:lingering_potion": {
+		content: "rc_potion_content",
+		bottle: "rc_potion_bottle_lingering"
+	},
+	"minecraft:tipped_arrow": {
+		content: "rc_tipped_arrow_head",
+		bottle: "rc_tipped_arrow_base"
+	}
+};
+function image(id) {
+	return `items/${id.replace(":", "/")}`;
+}
+/**
+* Build the ItemStyle for a rendered item. `renderedIds` gates variant rules to
+* images that exist. Returns null for internal layer-source items (rc_*),
+* which get no rules of their own.
+*/
+function classifyItemStyle(id, renderedIds) {
+	const [namespace, name] = id.split(":", 2);
+	if (namespace === "minecraft" && name.startsWith("rc_")) return null;
+	const base = {
+		id,
+		image: image(id)
+	};
+	if (id === "minecraft:decorated_pot") {
+		base.variants = [];
+		for (const sherd of POTTERY_SHERDS) {
+			if (renderedIds.has(`_decorated_pot:pot_b_${sherd}`)) base.variants.push({
+				suffix: `pot-1-minecraft_${sherd}`,
+				image: image(`_decorated_pot:pot_b_${sherd}`)
+			});
+			if (renderedIds.has(`_decorated_pot:pot_o_${sherd}`)) base.variants.push({
+				suffix: `pot-2-minecraft_${sherd}`,
+				before: { image: image(`_decorated_pot:pot_o_${sherd}`) }
+			});
+		}
+		return base;
+	}
+	const armor = parseArmor(id);
+	if (armor) {
+		base.variants = [];
+		if (armor.material === "leather") {
+			const layerBase = `_leather_armor:leather_${armor.type}_base`;
+			if (renderedIds.has(layerBase)) {
+				base.image = image(layerBase);
+				base.mask = image(id);
+				base.variables = { "--rc-layer-1-tint": "#9e643f" };
+				if (renderedIds.has(`_leather_armor:leather_${armor.type}_overlay`)) {
+					const overlay = image(`_leather_armor:leather_${armor.type}_overlay`);
+					base.before = {
+						image: overlay,
+						mask: overlay
+					};
+				}
+			}
+			for (const material of TRIM_MATERIALS) {
+				const trim = `_leather_armor:leather_${armor.type}_${material}_trim`;
+				if (renderedIds.has(trim)) base.variants.push({
+					suffix: `trim-minecraft_${material}`,
+					before: {
+						image: image(trim),
+						mask: image(trim)
+					}
+				});
+			}
+			return base;
+		}
+		base.mask = image(id);
+		for (const material of TRIM_MATERIALS) {
+			const variant = material === (armor.material === "golden" ? "gold" : armor.material) && TRIM_DARKER_MATERIALS.has(material) ? `${material}_darker` : material;
+			const trim = `_armor_trims:${armor.type}_trim_${variant}`;
+			if (renderedIds.has(trim)) base.variants.push({
+				suffix: `trim-minecraft_${material}`,
+				before: {
+					image: image(trim),
+					mask: image(trim)
+				}
+			});
+		}
+		return base;
+	}
+	const potion = POTIONS[id];
+	if (potion && renderedIds.has(`minecraft:${potion.content}`)) {
+		base.image = image(`minecraft:${potion.content}`);
+		base.mask = image(id);
+		base.variables = { "--rc-layer-1-tint": "#f800f8" };
+		if (renderedIds.has(`minecraft:${potion.bottle}`)) {
+			const bottle = image(`minecraft:${potion.bottle}`);
+			base.before = {
+				image: bottle,
+				mask: bottle
+			};
+		}
+		return base;
+	}
+	if (id === "minecraft:crossbow") {
+		base.variants = [];
+		for (const [projectile, source] of [
+			["arrow", "_crossbow:arrow"],
+			["spectral_arrow", "_crossbow:arrow"],
+			["tipped_arrow", "_crossbow:arrow"],
+			["firework_rocket", "_crossbow:rocket"]
+		]) if (renderedIds.has(source)) base.variants.push({
+			suffix: `projectile-minecraft_${projectile}`,
+			image: image(source)
+		});
+		return base;
+	}
+	if (id === "minecraft:filled_map" && renderedIds.has("minecraft:rc_filled_map_base")) {
+		base.image = image("minecraft:rc_filled_map_base");
+		base.mask = image(id);
+		base.variables = { "--rc-layer-2-tint": "#46402e" };
+		if (renderedIds.has("minecraft:rc_filled_map_overlay")) base.before = { image: image("minecraft:rc_filled_map_overlay") };
+		return base;
+	}
+	if (id === "minecraft:firework_star" && renderedIds.has("minecraft:rc_firework_star_base")) {
+		base.image = image("minecraft:rc_firework_star_base");
+		base.mask = image(id);
+		base.variables = { "--rc-layer-2-tint": "#8a8a8a" };
+		if (renderedIds.has("minecraft:rc_firework_star_overlay")) base.before = { image: image("minecraft:rc_firework_star_overlay") };
+		return base;
+	}
+	if (ENCHANTED_EFFECT_ITEMS.has(id)) base.alwaysEnchanted = true;
+	return base;
+}
+function parseArmor(id) {
+	if (!id.startsWith("minecraft:")) return null;
+	const name = id.slice(10);
+	for (const material of ARMOR_MATERIALS) {
+		if (!name.startsWith(`${material}_`)) continue;
+		const type = name.slice(material.length + 1);
+		if (ARMOR_ITEM_TYPES.includes(type)) return {
+			material,
+			type
+		};
+	}
+	return null;
+}
+//#endregion
+export { classifyItemStyle as t };

package/dist/items/definition.d.ts

@@ -0,0 +1,2 @@
+import { a as STRING_DEFAULTS, c as defaultProperties, i as ItemRenderInstruction, l as evaluateItemModel, n as InvalidItemDefinitionError, o as TintDefinition, r as ItemProperties, s as UNKNOWN_MODEL, t as CONDITION_DEFAULTS } from "../definition-BwX6Xxv0.js";
+export { CONDITION_DEFAULTS, InvalidItemDefinitionError, ItemProperties, ItemRenderInstruction, STRING_DEFAULTS, TintDefinition, UNKNOWN_MODEL, defaultProperties, evaluateItemModel };

package/dist/items/definition.js

@@ -0,0 +1,2 @@
+import { a as defaultProperties, i as UNKNOWN_MODEL, n as InvalidItemDefinitionError, o as evaluateItemModel, r as STRING_DEFAULTS, t as CONDITION_DEFAULTS } from "../definition-3MBm8ar_.js";
+export { CONDITION_DEFAULTS, InvalidItemDefinitionError, STRING_DEFAULTS, UNKNOWN_MODEL, defaultProperties, evaluateItemModel };

package/dist/items/discovery.d.ts

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

package/dist/items/discovery.js

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

package/dist/jar-6T3xdgaL.d.ts

@@ -0,0 +1,21 @@
+import { n as ResourceLocator } from "./locator-jDbdUeTd.js";
+import { a as ResourceManager, i as ResourceKindName } from "./manager-CoZaeQTu.js";
+//#region src/resources/jar.d.ts
+/** Jar entries that could escape the archive get the whole jar rejected. */
+declare function isUnsafeEntryPath(entryPath: string): boolean;
+declare class UnsafeJarError extends Error {}
+declare class JarResourceManager implements ResourceManager {
+  private readonly jarPath;
+  private index;
+  constructor(jarPath: string);
+  private getIndex;
+  private entryPath;
+  getResource(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer | null>;
+  hasResource(kind: ResourceKindName, locator: ResourceLocator): Promise<boolean>;
+  getAllResources(kind: ResourceKindName, locator: ResourceLocator): Promise<Buffer[]>;
+  listResources(kind: ResourceKindName, namespace: string): Promise<ResourceLocator[]>;
+  listNamespaces(): Promise<string[]>;
+  close(): Promise<void>;
+}
+//#endregion
+export { UnsafeJarError as n, isUnsafeEntryPath as r, JarResourceManager as t };

package/dist/jar-Bt3i0ls4.js

@@ -0,0 +1,119 @@
+import { n as ResourceLocator } from "./locator-ycZzh_6z.js";
+import { r as ResourceKind } from "./manager-dfI7b9N4.js";
+import { open } from "yauzl";
+//#region src/resources/jar.ts
+/**
+* Reads resources directly out of a jar/zip — no extraction step, unlike the
+* PHP pipeline which required unpacked trees (and paid dearly for the file
+* count on Docker bind mounts). The central directory is indexed once.
+*/
+/** Jar entries that could escape the archive get the whole jar rejected. */
+function isUnsafeEntryPath(entryPath) {
+	return entryPath.startsWith("/") || /^[A-Z]:/i.test(entryPath) || entryPath.split("/").includes("..");
+}
+var UnsafeJarError = class extends Error {};
+var JarResourceManager = class {
+	jarPath;
+	index = null;
+	constructor(jarPath) {
+		this.jarPath = jarPath;
+	}
+	getIndex() {
+		this.index ??= new Promise((resolve, reject) => {
+			open(this.jarPath, {
+				lazyEntries: true,
+				autoClose: false
+			}, (err, zip) => {
+				if (err) {
+					reject(err);
+					return;
+				}
+				const entries = /* @__PURE__ */ new Map();
+				const entriesLower = /* @__PURE__ */ new Map();
+				const namespaces = /* @__PURE__ */ new Set();
+				zip.on("entry", (entry) => {
+					if (isUnsafeEntryPath(entry.fileName)) {
+						zip.close();
+						reject(new UnsafeJarError(`Unsafe entry in ${this.jarPath}: ${entry.fileName}`));
+						return;
+					}
+					const match = /^assets\/([^/]+)\//.exec(entry.fileName);
+					if (match) {
+						entries.set(entry.fileName, entry);
+						const lower = entry.fileName.toLowerCase();
+						if (!entriesLower.has(lower)) entriesLower.set(lower, entry);
+						namespaces.add(match[1].toLowerCase());
+					}
+					zip.readEntry();
+				});
+				zip.on("end", () => resolve({
+					zip,
+					entries,
+					namespaces,
+					entriesLower
+				}));
+				zip.on("error", reject);
+				zip.readEntry();
+			});
+		});
+		return this.index;
+	}
+	entryPath(kind, locator) {
+		const { directory, extension } = ResourceKind[kind];
+		const prefix = directory === "" ? "" : `${directory}/`;
+		return `assets/${locator.namespace}/${prefix}${locator.path}${extension}`;
+	}
+	async getResource(kind, locator) {
+		const index = await this.getIndex();
+		const entryPath = this.entryPath(kind, locator);
+		const entry = index.entries.get(entryPath) ?? index.entriesLower.get(entryPath.toLowerCase());
+		if (!entry) return null;
+		return 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(Buffer.concat(chunks)));
+				stream.on("error", reject);
+			});
+		});
+	}
+	async hasResource(kind, locator) {
+		const index = await this.getIndex();
+		const entryPath = this.entryPath(kind, locator);
+		return index.entries.has(entryPath) || index.entriesLower.has(entryPath.toLowerCase());
+	}
+	async getAllResources(kind, locator) {
+		const resource = await this.getResource(kind, locator);
+		return resource === null ? [] : [resource];
+	}
+	async listResources(kind, namespace) {
+		const index = await this.getIndex();
+		const { directory, extension } = ResourceKind[kind];
+		const prefix = directory === "" ? `assets/${namespace}/` : `assets/${namespace}/${directory}/`;
+		const locators = [];
+		for (const entryPath of index.entries.keys()) {
+			if (!entryPath.startsWith(prefix) || !entryPath.endsWith(extension) || entryPath.endsWith("/")) continue;
+			const relative = extension === "" ? entryPath.slice(prefix.length) : entryPath.slice(prefix.length, -extension.length);
+			const locator = ResourceLocator.tryParse(`${namespace}:${relative}`);
+			if (locator) locators.push(locator);
+		}
+		return locators;
+	}
+	async listNamespaces() {
+		return [...(await this.getIndex()).namespaces].toSorted((left, right) => left.localeCompare(right));
+	}
+	async close() {
+		if (this.index) {
+			(await this.index).zip.close();
+			this.index = null;
+		}
+	}
+};
+//#endregion
+export { UnsafeJarError as n, isUnsafeEntryPath as r, JarResourceManager as t };