risupack 0.1.0

package/dist/unpack-risum-8Iw-UEO2.js

@@ -0,0 +1,1055 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+import zlib from "node:zlib";
+//#region src/bundle.ts
+var REQUIRE_PATTERN = /require\s*\(?["']([^"']+)["']\)?/g;
+function formatBytes(bytes) {
+	if (bytes === 0) return "0 B";
+	const base = 1024;
+	const sizes = [
+		"B",
+		"KB",
+		"MB"
+	];
+	const index = Math.floor(Math.log(bytes) / Math.log(base));
+	return `${Number.parseFloat((bytes / Math.pow(base, index)).toFixed(2))} ${sizes[index]}`;
+}
+function resolveModulePath(moduleName) {
+	return `${moduleName.replace(/\./g, "/")}.lua`;
+}
+function minifyLua(content, hoistedComments) {
+	return content.replace(/(--\[(=*)\[[\s\S]*?\]\2\])|(--.*)|(\[(=*)\[[\s\S]*?\]\5\])|("([^"\\]|\\.)*")|('([^'\\]|\\.)*')/g, (match, longComment, _equals, shortComment) => {
+		if (!longComment && !shortComment) return match;
+		if (shortComment?.startsWith("--!") || longComment && /^--\[(=*)\[!/.test(match)) hoistedComments.push(match);
+		return " ";
+	}).split("\n").map((line) => line.trim()).filter((line) => line.length > 0).join("\n");
+}
+function processModule(moduleName, state) {
+	if (state.includedModules.has(moduleName)) return;
+	const rootDirectory = path.dirname(path.resolve(state.entryPath));
+	const modulePath = path.join(rootDirectory, resolveModulePath(moduleName));
+	if (!fs.existsSync(modulePath)) {
+		console.warn(`Warning: Module '${moduleName}' not found`);
+		return;
+	}
+	const rawContent = fs.readFileSync(modulePath, "utf8");
+	state.includedModules.add(moduleName);
+	state.totalInputBytes += fs.statSync(modulePath).size;
+	for (const match of rawContent.matchAll(new RegExp(REQUIRE_PATTERN.source, "g"))) {
+		const dependency = match[1];
+		if (dependency) processModule(dependency, state);
+	}
+	const minifiedContent = minifyLua(rawContent, state.hoistedComments);
+	state.preloads.push(`package.preload["${moduleName}"]=function(...)${minifiedContent} end`);
+}
+function bundleLua(entryPath, outputArgument) {
+	const resolvedEntryPath = path.resolve(entryPath);
+	if (!fs.existsSync(resolvedEntryPath)) throw new Error(`Entry file not found: ${entryPath}`);
+	let outputPath = path.resolve(outputArgument);
+	if (fs.existsSync(outputPath) && fs.statSync(outputPath).isDirectory()) outputPath = path.join(outputPath, path.basename(resolvedEntryPath));
+	if (path.extname(outputPath) !== ".lua") outputPath += ".lua";
+	const state = {
+		entryPath: resolvedEntryPath,
+		hoistedComments: [],
+		includedModules: /* @__PURE__ */ new Set(),
+		preloads: [],
+		totalInputBytes: fs.statSync(resolvedEntryPath).size
+	};
+	const mainContent = fs.readFileSync(resolvedEntryPath, "utf8");
+	for (const match of mainContent.matchAll(new RegExp(REQUIRE_PATTERN.source, "g"))) {
+		const moduleName = match[1];
+		if (moduleName) processModule(moduleName, state);
+	}
+	const mainMinified = minifyLua(mainContent, state.hoistedComments);
+	const output = `${state.hoistedComments.length > 0 ? `${state.hoistedComments.join("\n")}\n` : ""}${state.preloads.join("\n")}\n${mainMinified}`;
+	fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+	fs.writeFileSync(outputPath, output, "utf8");
+	const outputBytes = fs.statSync(outputPath).size;
+	const reduction = (state.totalInputBytes - outputBytes) / state.totalInputBytes * 100;
+	console.log(`Bundled ${path.relative(process.cwd(), resolvedEntryPath)} to ${path.relative(process.cwd(), outputPath)}`);
+	console.log(`${state.includedModules.size} modules, ${formatBytes(state.totalInputBytes)} to ${formatBytes(outputBytes)}, ${reduction.toFixed(2)}% reduction`);
+	return outputPath;
+}
+//#endregion
+//#region src/build-charx.ts
+var DEFAULT_ICON = Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M/wHwAEAQH/69v17QAAAABJRU5ErkJggg==", "base64");
+var RPACK_MAP_PATH$2 = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "vendor", "rpack", "rpack_map.bin");
+var CRC32_TABLE$1 = (() => {
+	const table = /* @__PURE__ */ new Uint32Array(256);
+	for (let index = 0; index < table.length; index += 1) {
+		let value = index;
+		for (let bit = 0; bit < 8; bit += 1) if ((value & 1) !== 0) value = 3988292384 ^ value >>> 1;
+		else value >>>= 1;
+		table[index] = value >>> 0;
+	}
+	return table;
+})();
+function assert$2(condition, message) {
+	if (!condition) throw new Error(message);
+}
+function calculateCRC32$1(data) {
+	let value = 4294967295;
+	for (const byte of data) value = CRC32_TABLE$1[(value ^ byte) & 255] ^ value >>> 8;
+	return (value ^ 4294967295) >>> 0;
+}
+function createUUID(seed) {
+	const bytes = crypto.createHash("sha256").update(seed).digest().subarray(0, 16);
+	bytes[6] = bytes[6] & 15 | 80;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = bytes.toString("hex");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function detectImageType(data) {
+	if (data.subarray(0, 8).equals(Buffer.from("89504e470d0a1a0a", "hex"))) return "PNG";
+	if (data.subarray(0, 3).equals(Buffer.from("ffd8ff", "hex"))) return "JPEG";
+	if (data.subarray(0, 6).toString("ascii") === "GIF87a" || data.subarray(0, 6).toString("ascii") === "GIF89a") return "GIF";
+	if (data.subarray(0, 4).toString("ascii") === "RIFF" && data.subarray(8, 12).toString("ascii") === "WEBP") return "WEBP";
+	return "Unknown";
+}
+function getAssetCategory(extension) {
+	const audio = /* @__PURE__ */ new Set([
+		"flac",
+		"mp3",
+		"ogg",
+		"wav"
+	]);
+	const code = /* @__PURE__ */ new Set([
+		"js",
+		"lua",
+		"ts"
+	]);
+	const fonts = /* @__PURE__ */ new Set([
+		"otf",
+		"ttf",
+		"woff",
+		"woff2"
+	]);
+	const images = /* @__PURE__ */ new Set([
+		"avif",
+		"gif",
+		"jpeg",
+		"jpg",
+		"png",
+		"webp"
+	]);
+	const models = /* @__PURE__ */ new Set(["mmd", "obj"]);
+	const video = /* @__PURE__ */ new Set([
+		"avi",
+		"mkv",
+		"mov",
+		"mp4",
+		"webm"
+	]);
+	if (audio.has(extension)) return "audio";
+	if (code.has(extension)) return "code";
+	if (fonts.has(extension)) return "fonts";
+	if (images.has(extension)) return "image";
+	if (models.has(extension)) return "model";
+	if (extension === "onnx" || extension === "safetensors" || extension === "cpkt") return "ai";
+	if (video.has(extension)) return "video";
+	return "other";
+}
+function readSource(manifestDirectory, source, label) {
+	if (typeof source === "string") return fs.readFileSync(path.resolve(manifestDirectory, source), "utf8");
+	assert$2(source && typeof source === "object", `${label} must be a file path or source object`);
+	if (typeof source.content === "string") return source.content;
+	assert$2(typeof source.file === "string", `${label}.file must be a string`);
+	return fs.readFileSync(path.resolve(manifestDirectory, source.file), "utf8");
+}
+function sanitizeArchiveName(name) {
+	return Array.from(name, (character) => character.charCodeAt(0) < 32 ? "_" : character).join("").replace(/[<>:"/\\|?*]/g, "_").trim().slice(0, 100) || "asset";
+}
+function sortKeysDeep$1(value) {
+	if (Array.isArray(value)) return value.map(sortKeysDeep$1);
+	if (value && typeof value === "object" && !Buffer.isBuffer(value)) {
+		const sorted = {};
+		for (const key of Object.keys(value).sort()) if (value[key] !== void 0) sorted[key] = sortKeysDeep$1(value[key]);
+		return sorted;
+	}
+	return value;
+}
+function parseFrontmatter(content, fileName) {
+	const normalized = content.replace(/\r\n/g, "\n");
+	assert$2(normalized.startsWith("---\n"), `Missing frontmatter in ${fileName}`);
+	const end = normalized.indexOf("\n---\n", 4);
+	assert$2(end !== -1, `Unclosed frontmatter in ${fileName}`);
+	const metadata = {};
+	for (const line of normalized.slice(4, end).split("\n")) {
+		if (line.trim() === "") continue;
+		const separator = line.indexOf(":");
+		assert$2(separator !== -1, `Invalid frontmatter line in ${fileName}: ${line}`);
+		const key = line.slice(0, separator).trim();
+		const rawValue = line.slice(separator + 1).trim();
+		assert$2(key !== "", `Empty frontmatter key in ${fileName}`);
+		if (rawValue === "true") metadata[key] = true;
+		else if (rawValue === "false") metadata[key] = false;
+		else metadata[key] = rawValue;
+	}
+	return {
+		body: normalized.slice(end + 5),
+		metadata
+	};
+}
+function parseRegexBody(content, fileName) {
+	const match = content.replace(/^\n+/, "").replace(/\n$/, "").match(/^IN:\s*\n([\s\S]*?)\nOUT:\s*(?:\n([\s\S]*))?$/);
+	assert$2(match, `Invalid regex body in ${fileName}`);
+	return {
+		in: match[1],
+		out: match[2] ?? ""
+	};
+}
+function parseRegexDocument(content, fileName) {
+	const { body, metadata } = parseFrontmatter(content, fileName);
+	const parsed = parseRegexBody(body, fileName);
+	return {
+		ableFlag: metadata.ableFlag ?? true,
+		comment: metadata.comment ?? "",
+		flag: metadata.flag,
+		in: parsed.in,
+		out: parsed.out,
+		type: metadata.type ?? "editdisplay"
+	};
+}
+function buildRegexScripts(manifestDirectory, regexGroups = []) {
+	const scripts = [];
+	for (const group of regexGroups) {
+		if (typeof group === "string") {
+			scripts.push(parseRegexDocument(readSource(manifestDirectory, group, `regex ${group}`), group));
+			continue;
+		}
+		if (group.in !== void 0 || group.out !== void 0) {
+			assert$2(typeof group.in === "string" && typeof group.out === "string", "Inline regex entries require in and out");
+			scripts.push({
+				ableFlag: group.ableFlag ?? true,
+				comment: group.comment ?? "",
+				flag: group.flag,
+				in: group.in,
+				out: group.out,
+				type: group.type ?? "editdisplay"
+			});
+			continue;
+		}
+		assert$2(typeof group.file === "string", "Regex entries require a file path, or inline in and out fields");
+		scripts.push(parseRegexDocument(readSource(manifestDirectory, group.file, `regex ${group.file}`), group.file));
+	}
+	return scripts;
+}
+function buildLorebook(manifest, manifestDirectory) {
+	const folderKeys = /* @__PURE__ */ new Map();
+	const folderNames = new Set(manifest.folders ?? []);
+	for (const entry of manifest.lorebook ?? []) if (entry.folder) folderNames.add(entry.folder);
+	for (const name of folderNames) folderKeys.set(name, `\uf000folder:${createUUID(`${manifest.namespace ?? manifest.name}:folder:${name}`)}`);
+	const temporaryDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "risums-charx-lorebook-"));
+	try {
+		const lorebook = (manifest.lorebook ?? []).map((entry, index) => {
+			let content;
+			if (entry.bundle) {
+				assert$2(typeof entry.file === "string", `Bundled lorebook ${entry.comment ?? index + 1} requires a file`);
+				content = bundleLua(path.resolve(manifestDirectory, entry.file), entry.bundleOutput ? path.resolve(manifestDirectory, entry.bundleOutput) : path.join(temporaryDirectory, `lorebook-${index}.lua`));
+			} else content = readSource(manifestDirectory, entry, `lorebook ${entry.comment ?? entry.file ?? ""}`);
+			return {
+				activationPercent: entry.activationPercent,
+				alwaysActive: entry.alwaysActive ?? false,
+				bookVersion: entry.bookVersion ?? 2,
+				comment: entry.comment ?? path.basename(entry.file ?? "Lorebook"),
+				content,
+				extentions: entry.extentions,
+				folder: entry.folder ? folderKeys.get(entry.folder) : void 0,
+				insertorder: entry.insertOrder ?? 100,
+				key: entry.key ?? "",
+				mode: entry.mode ?? "normal",
+				secondkey: entry.secondaryKey ?? "",
+				selective: entry.selective ?? false,
+				useRegex: entry.useRegex ?? false
+			};
+		});
+		for (const name of folderNames) lorebook.push({
+			alwaysActive: false,
+			bookVersion: 2,
+			comment: name,
+			content: "",
+			insertorder: 100,
+			key: folderKeys.get(name),
+			mode: "folder",
+			secondkey: "",
+			selective: false,
+			useRegex: false
+		});
+		return lorebook;
+	} finally {
+		fs.rmSync(temporaryDirectory, {
+			force: true,
+			recursive: true
+		});
+	}
+}
+function readBundledLua(entryPath, outputPath) {
+	bundleLua(entryPath, outputPath);
+	return fs.readFileSync(outputPath, "utf8");
+}
+function buildTriggers(manifest, manifestDirectory) {
+	const temporaryDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "risums-charx-"));
+	try {
+		return (manifest.triggers ?? []).map((trigger, index) => {
+			let effect = trigger.effect;
+			if (trigger.lua) {
+				const entryPath = path.resolve(manifestDirectory, trigger.lua);
+				let code;
+				if (trigger.bundle ?? true) code = readBundledLua(entryPath, trigger.bundleOutput ? path.resolve(manifestDirectory, trigger.bundleOutput) : path.join(temporaryDirectory, `trigger-${index}.lua`));
+				else code = fs.readFileSync(entryPath, "utf8");
+				effect = [{
+					code,
+					type: "triggerlua"
+				}];
+			}
+			assert$2(Array.isArray(effect), `Trigger ${index + 1} requires lua or effect`);
+			return {
+				comment: trigger.comment ?? "",
+				conditions: trigger.conditions ?? [],
+				effect,
+				lowLevelAccess: trigger.lowLevelAccess,
+				type: trigger.type ?? "start"
+			};
+		});
+	} finally {
+		fs.rmSync(temporaryDirectory, {
+			force: true,
+			recursive: true
+		});
+	}
+}
+function createRisuM(module, encodeMap) {
+	const payload = Buffer.from(JSON.stringify(sortKeysDeep$1({
+		module,
+		type: "risuModule"
+	}), null, 2), "utf8");
+	const encoded = Buffer.allocUnsafe(payload.length);
+	for (let index = 0; index < payload.length; index += 1) encoded[index] = encodeMap[payload[index]];
+	const header = Buffer.alloc(6);
+	header.writeUInt8(111, 0);
+	header.writeUInt8(0, 1);
+	header.writeUInt32LE(encoded.length, 2);
+	return Buffer.concat([
+		header,
+		encoded,
+		Buffer.from([0])
+	]);
+}
+function createAssetFiles(manifest, manifestDirectory) {
+	const cardAssets = [];
+	const files = [];
+	const takenNames = /* @__PURE__ */ new Set();
+	function addAsset({ data, extension, name, type }) {
+		const category = getAssetCategory(extension);
+		const baseDirectory = `assets/${type === "icon" ? "icon" : "other"}/${category}`;
+		const baseName = sanitizeArchiveName(name);
+		let archiveName = baseName;
+		let suffix = 0;
+		while (takenNames.has(archiveName)) {
+			suffix += 1;
+			archiveName = `${baseName}_${suffix}`;
+		}
+		const archivePath = `${baseDirectory}/${archiveName}.${extension}`;
+		takenNames.add(archiveName);
+		cardAssets.push({
+			ext: extension,
+			name,
+			type,
+			uri: `embeded://${archivePath}`
+		});
+		files.push({
+			data,
+			name: archivePath
+		});
+		files.push({
+			data: Buffer.from(JSON.stringify({ type: detectImageType(data) }, null, 2)),
+			name: `x_meta/${archiveName}.json`
+		});
+	}
+	if (manifest.icon) {
+		const iconPath = path.resolve(manifestDirectory, manifest.icon);
+		const extension = path.extname(iconPath).slice(1).toLowerCase() || "png";
+		addAsset({
+			data: fs.readFileSync(iconPath),
+			extension,
+			name: "main",
+			type: "icon"
+		});
+	} else addAsset({
+		data: DEFAULT_ICON,
+		extension: "png",
+		name: "main",
+		type: "icon"
+	});
+	for (const asset of manifest.assets ?? []) {
+		assert$2(typeof asset.file === "string", "Asset file must be a string");
+		const assetPath = path.resolve(manifestDirectory, asset.file);
+		const extension = (asset.extension ?? path.extname(assetPath).slice(1)).toLowerCase();
+		assert$2(extension !== "", `Cannot determine extension for ${asset.file}`);
+		assert$2(/^[a-z0-9]+$/.test(extension), `Invalid extension for ${asset.file}: ${extension}`);
+		addAsset({
+			data: fs.readFileSync(assetPath),
+			extension,
+			name: asset.name ?? path.basename(assetPath, path.extname(assetPath)),
+			type: "x-risu-asset"
+		});
+	}
+	return {
+		cardAssets,
+		files
+	};
+}
+function createCard(manifest, lorebook, cardAssets) {
+	return {
+		data: {
+			alternate_greetings: [],
+			assets: cardAssets,
+			character_book: {
+				entries: lorebook.map((entry) => ({
+					case_sensitive: entry.extentions?.risu_case_sensitive ?? false,
+					comment: entry.comment,
+					constant: entry.alwaysActive,
+					content: entry.content,
+					enabled: true,
+					extensions: {
+						...entry.extentions,
+						risu_activationPercent: entry.activationPercent,
+						risu_loreCache: entry.loreCache
+					},
+					folder: entry.folder,
+					insertion_order: entry.insertorder,
+					keys: entry.key.split(",").map((key) => key.trim()),
+					mode: entry.mode,
+					name: entry.comment,
+					secondary_keys: entry.selective ? entry.secondkey.split(",").map((key) => key.trim()) : void 0,
+					selective: entry.selective,
+					use_regex: entry.useRegex
+				})),
+				extensions: { risu_fullWordMatching: false }
+			},
+			character_version: manifest.version ?? "",
+			creation_date: 0,
+			creator: manifest.creator ?? "",
+			creator_notes: manifest.description ?? "",
+			description: "",
+			extensions: {
+				moduleNoneImage: manifest.icon ? void 0 : true,
+				risuai: {
+					additionalText: "",
+					backgroundHTML: manifest.CSS ? readSource(path.dirname(manifest.__path), manifest.CSS, "CSS") : "",
+					bias: [],
+					defaultVariables: "",
+					hideChatIcon: manifest.hideIcon ?? false,
+					inlayViewScreen: false,
+					largePortrait: false,
+					license: manifest.license ?? "",
+					lorePlus: false,
+					lowLevelAccess: manifest.lowLevelAccess ?? false,
+					moduleNamespace: manifest.namespace,
+					newGenData: void 0,
+					prebuiltAssetCommand: "",
+					prebuiltAssetExclude: [],
+					prebuiltAssetStyle: "",
+					sdData: [],
+					toggles: manifest.toggles ? readSource(path.dirname(manifest.__path), manifest.toggles, "toggles") : "",
+					utilityBot: false,
+					viewScreen: "none",
+					virtualscript: "",
+					vits: {}
+				}
+			},
+			first_mes: "",
+			group_only_greetings: [],
+			mes_example: "",
+			modification_date: process.env.SOURCE_DATE_EPOCH ? Number(process.env.SOURCE_DATE_EPOCH) : Math.floor(Date.now() / 1e3),
+			name: manifest.name,
+			nickname: "",
+			personality: "",
+			post_history_instructions: "",
+			scenario: "",
+			source: [],
+			system_prompt: "",
+			tags: manifest.tags ?? []
+		},
+		spec: "chara_card_v3",
+		spec_version: "3.0"
+	};
+}
+function getDOSDateTime(date) {
+	return {
+		date: Math.max(1980, date.getUTCFullYear()) - 1980 << 9 | date.getUTCMonth() + 1 << 5 | date.getUTCDate(),
+		time: date.getUTCHours() << 11 | date.getUTCMinutes() << 5 | Math.floor(date.getUTCSeconds() / 2)
+	};
+}
+function createZIP(files, timestamp) {
+	assert$2(files.length <= 65535, "ZIP contains too many files");
+	const centralRecords = [];
+	const localRecords = [];
+	let offset = 0;
+	const { date, time } = getDOSDateTime(timestamp);
+	for (const file of files) {
+		const data = Buffer.from(file.data);
+		const compressed = zlib.deflateRawSync(data, { level: 6 });
+		const fileName = Buffer.from(file.name.replace(/\\/g, "/"), "utf8");
+		const CRC32 = calculateCRC32$1(data);
+		assert$2(data.length <= 4294967295 && compressed.length <= 4294967295, `${file.name} exceeds ZIP32 limits`);
+		const localHeader = Buffer.alloc(30);
+		localHeader.writeUInt32LE(67324752, 0);
+		localHeader.writeUInt16LE(20, 4);
+		localHeader.writeUInt16LE(2048, 6);
+		localHeader.writeUInt16LE(8, 8);
+		localHeader.writeUInt16LE(time, 10);
+		localHeader.writeUInt16LE(date, 12);
+		localHeader.writeUInt32LE(CRC32, 14);
+		localHeader.writeUInt32LE(compressed.length, 18);
+		localHeader.writeUInt32LE(data.length, 22);
+		localHeader.writeUInt16LE(fileName.length, 26);
+		localHeader.writeUInt16LE(0, 28);
+		localRecords.push(localHeader, fileName, compressed);
+		const centralHeader = Buffer.alloc(46);
+		centralHeader.writeUInt32LE(33639248, 0);
+		centralHeader.writeUInt16LE(20, 4);
+		centralHeader.writeUInt16LE(20, 6);
+		centralHeader.writeUInt16LE(2048, 8);
+		centralHeader.writeUInt16LE(8, 10);
+		centralHeader.writeUInt16LE(time, 12);
+		centralHeader.writeUInt16LE(date, 14);
+		centralHeader.writeUInt32LE(CRC32, 16);
+		centralHeader.writeUInt32LE(compressed.length, 20);
+		centralHeader.writeUInt32LE(data.length, 24);
+		centralHeader.writeUInt16LE(fileName.length, 28);
+		centralHeader.writeUInt16LE(0, 30);
+		centralHeader.writeUInt16LE(0, 32);
+		centralHeader.writeUInt16LE(0, 34);
+		centralHeader.writeUInt16LE(0, 36);
+		centralHeader.writeUInt32LE(0, 38);
+		centralHeader.writeUInt32LE(offset, 42);
+		centralRecords.push(centralHeader, fileName);
+		offset += localHeader.length + fileName.length + compressed.length;
+	}
+	const centralDirectory = Buffer.concat(centralRecords);
+	const end = Buffer.alloc(22);
+	end.writeUInt32LE(101010256, 0);
+	end.writeUInt16LE(0, 4);
+	end.writeUInt16LE(0, 6);
+	end.writeUInt16LE(files.length, 8);
+	end.writeUInt16LE(files.length, 10);
+	end.writeUInt32LE(centralDirectory.length, 12);
+	end.writeUInt32LE(offset, 16);
+	end.writeUInt16LE(0, 20);
+	return Buffer.concat([
+		...localRecords,
+		centralDirectory,
+		end
+	]);
+}
+function buildCharX(manifestPath, outputArgument) {
+	const resolvedManifestPath = path.resolve(manifestPath);
+	const manifestDirectory = path.dirname(resolvedManifestPath);
+	const manifest = JSON.parse(fs.readFileSync(resolvedManifestPath, "utf8"));
+	manifest.__path = resolvedManifestPath;
+	assert$2(typeof manifest.name === "string" && manifest.name !== "", "Manifest name is required");
+	const lorebook = buildLorebook(manifest, manifestDirectory);
+	const regex = buildRegexScripts(manifestDirectory, manifest.regex);
+	const trigger = buildTriggers(manifest, manifestDirectory);
+	const { cardAssets, files: assetFiles } = createAssetFiles(manifest, manifestDirectory);
+	const card = createCard(manifest, lorebook, cardAssets);
+	const module = {
+		description: `Module for ${manifest.name}`,
+		id: createUUID(`${manifest.namespace ?? manifest.name}:module`),
+		lorebook,
+		name: `${manifest.name} Module`,
+		regex,
+		trigger
+	};
+	const map = fs.readFileSync(RPACK_MAP_PATH$2);
+	assert$2(map.length >= 256, `Invalid RPack map: ${RPACK_MAP_PATH$2}`);
+	const files = [
+		...assetFiles,
+		{
+			data: Buffer.from(JSON.stringify(sortKeysDeep$1(card), null, 2)),
+			name: "card.json"
+		},
+		{
+			data: createRisuM(sortKeysDeep$1(module), map.subarray(0, 256)),
+			name: "module.risum"
+		}
+	].sort((left, right) => left.name.localeCompare(right.name));
+	const outputPath = outputArgument ? path.resolve(outputArgument) : path.resolve(manifestDirectory, manifest.output ?? `../dist/${sanitizeArchiveName(manifest.name)}.charx`);
+	fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+	const timestamp = process.env.SOURCE_DATE_EPOCH ? /* @__PURE__ */ new Date(Number(process.env.SOURCE_DATE_EPOCH) * 1e3) : /* @__PURE__ */ new Date();
+	fs.writeFileSync(outputPath, createZIP(files, timestamp));
+	console.log(`Built ${path.relative(process.cwd(), outputPath)} (${files.length} files)`);
+	return outputPath;
+}
+//#endregion
+//#region src/inspect-risusave.ts
+var MAGIC = Buffer.from("RISUSAVE\0");
+var MODULE_BLOCK_TYPE = 5;
+function parseModuleBlock(database) {
+	if (!database.subarray(0, MAGIC.length).equals(MAGIC)) throw new Error("Invalid RISUSAVE header");
+	let offset = MAGIC.length;
+	while (offset < database.length) {
+		if (offset + 3 > database.length) throw new Error(`Truncated block header at byte ${offset}`);
+		const type = database[offset];
+		const compressed = database[offset + 1] === 1;
+		const nameLength = database[offset + 2];
+		offset += 3;
+		if (offset + nameLength + 4 > database.length) throw new Error(`Truncated block name at byte ${offset}`);
+		const name = database.subarray(offset, offset + nameLength).toString("utf8");
+		offset += nameLength;
+		const contentLength = database.readUInt32LE(offset);
+		offset += 4;
+		if (offset + contentLength > database.length) throw new Error(`Truncated ${name} block at byte ${offset}`);
+		let content = database.subarray(offset, offset + contentLength);
+		offset += contentLength;
+		if (type !== MODULE_BLOCK_TYPE) continue;
+		if (compressed) content = zlib.gunzipSync(content);
+		return JSON.parse(content.toString("utf8"));
+	}
+	throw new Error("RISUSAVE module block not found");
+}
+//#endregion
+//#region src/unpack-charx.ts
+var RPACK_MAP_PATH$1 = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "vendor", "rpack", "rpack_map.bin");
+var CRC32_TABLE = (() => {
+	const table = /* @__PURE__ */ new Uint32Array(256);
+	for (let index = 0; index < table.length; index += 1) {
+		let value = index;
+		for (let bit = 0; bit < 8; bit += 1) if ((value & 1) !== 0) value = 3988292384 ^ value >>> 1;
+		else value >>>= 1;
+		table[index] = value >>> 0;
+	}
+	return table;
+})();
+function assert$1(condition, message) {
+	if (!condition) throw new Error(message);
+}
+function calculateCRC32(data) {
+	let value = 4294967295;
+	for (const byte of data) value = CRC32_TABLE[(value ^ byte) & 255] ^ value >>> 8;
+	return (value ^ 4294967295) >>> 0;
+}
+function decodeModule(data, map) {
+	assert$1(data.length >= 7, "module.risum is truncated");
+	assert$1(data.readUInt8(0) === 111, "Invalid module.risum magic number");
+	assert$1(data.readUInt8(1) === 0, `Unsupported module.risum version: ${data.readUInt8(1)}`);
+	const encodedLength = data.readUInt32LE(2);
+	assert$1(encodedLength <= data.length - 6, "module.risum payload is truncated");
+	assert$1(map.length >= 256, `Invalid RPack map: ${RPACK_MAP_PATH$1}`);
+	let decodeMap;
+	if (map.length >= 512) decodeMap = map.subarray(256, 512);
+	else {
+		decodeMap = Buffer.alloc(256);
+		const seen = /* @__PURE__ */ new Set();
+		for (let index = 0; index < 256; index += 1) {
+			const encoded = map[index];
+			assert$1(!seen.has(encoded), "RPack encode map is not a permutation");
+			seen.add(encoded);
+			decodeMap[encoded] = index;
+		}
+	}
+	const encoded = data.subarray(6, 6 + encodedLength);
+	const decoded = Buffer.allocUnsafe(encoded.length);
+	for (let index = 0; index < encoded.length; index += 1) decoded[index] = decodeMap[encoded[index]];
+	const parsed = JSON.parse(decoded.toString("utf8"));
+	assert$1(parsed && parsed.type === "risuModule" && parsed.module, "module.risum does not contain a Risu module");
+	return parsed;
+}
+function findEndOfCentralDirectory(archive) {
+	const minimumOffset = Math.max(0, archive.length - 65535 - 22);
+	for (let offset = archive.length - 22; offset >= minimumOffset; offset -= 1) if (archive.readUInt32LE(offset) === 101010256) {
+		const commentLength = archive.readUInt16LE(offset + 20);
+		if (offset + 22 + commentLength === archive.length) return offset;
+	}
+	throw new Error("ZIP end record not found");
+}
+function normalizeEntryName(name) {
+	assert$1(name !== "", "ZIP entry has an empty name");
+	assert$1(!name.includes("\0"), `ZIP entry contains a null byte: ${JSON.stringify(name)}`);
+	const normalized = name.replace(/\\/g, "/");
+	assert$1(!normalized.startsWith("/"), `ZIP entry uses an absolute path: ${name}`);
+	assert$1(!/^[a-zA-Z]:/.test(normalized), `ZIP entry uses an absolute path: ${name}`);
+	const parts = normalized.split("/");
+	assert$1(!parts.includes(".."), `ZIP entry escapes the output directory: ${name}`);
+	return parts.filter((part) => part !== "" && part !== ".").join("/");
+}
+function sanitizeSourceName(name, fallback) {
+	return Array.from(name, (character) => character.charCodeAt(0) < 32 ? "_" : character).join("").replace(/[<>:"/\\|?*]/g, "_").replace(/[. ]+$/g, "").trim() || fallback;
+}
+function sortKeysDeep(value) {
+	if (Array.isArray(value)) return value.map(sortKeysDeep);
+	if (value && typeof value === "object" && !Buffer.isBuffer(value)) {
+		const sorted = {};
+		for (const key of Object.keys(value).sort()) if (value[key] !== void 0) sorted[key] = sortKeysDeep(value[key]);
+		return sorted;
+	}
+	return value;
+}
+function takeSourcePath(directory, label, extension, takenPaths) {
+	const baseName = sanitizeSourceName(label, "untitled");
+	const suffix = baseName.toLowerCase().endsWith(extension) ? "" : extension;
+	let candidate = `${directory}/${baseName}${suffix}`;
+	let collision = 1;
+	while (takenPaths.has(candidate)) {
+		collision += 1;
+		candidate = `${directory}/${baseName}_${collision}${suffix}`;
+	}
+	takenPaths.add(candidate);
+	return candidate;
+}
+function createRegexDocument(regex) {
+	const frontmatter = [`ableFlag: ${regex.ableFlag ?? true}`, `comment: ${regex.comment ?? ""}`];
+	if (regex.flag !== void 0) frontmatter.push(`flag: ${regex.flag}`);
+	frontmatter.push(`type: ${regex.type ?? "editdisplay"}`);
+	return `---\n${frontmatter.join("\n")}\n---\n\nIN:\n${regex.in ?? ""}\nOUT:\n${regex.out ?? ""}\n`;
+}
+function createExpandedModuleSources(card, decodedModule) {
+	const moduleData = decodedModule.module;
+	const files = /* @__PURE__ */ new Map();
+	const folderNames = /* @__PURE__ */ new Map();
+	const folders = [];
+	const takenPaths = /* @__PURE__ */ new Set();
+	for (const entry of moduleData.lorebook ?? []) {
+		if (entry.mode !== "folder") continue;
+		folderNames.set(entry.key, entry.comment);
+		folders.push(entry.comment);
+	}
+	const lorebook = [];
+	for (const entry of moduleData.lorebook ?? []) {
+		if (entry.mode === "folder") continue;
+		const file = takeSourcePath("lorebooks", entry.comment, ".md", takenPaths);
+		files.set(file, Buffer.from(entry.content ?? "", "utf8"));
+		lorebook.push({
+			activationPercent: entry.activationPercent,
+			alwaysActive: entry.alwaysActive ?? false,
+			bookVersion: entry.bookVersion ?? 2,
+			comment: entry.comment ?? "",
+			extentions: entry.extentions,
+			file,
+			folder: folderNames.get(entry.folder),
+			insertOrder: entry.insertorder ?? 100,
+			key: entry.key ?? "",
+			mode: entry.mode ?? "normal",
+			secondaryKey: entry.secondkey ?? "",
+			selective: entry.selective ?? false,
+			useRegex: entry.useRegex ?? false
+		});
+	}
+	const regex = [];
+	for (const entry of moduleData.regex ?? []) {
+		const file = takeSourcePath("regex", entry.comment, ".md", takenPaths);
+		files.set(file, Buffer.from(createRegexDocument(entry), "utf8"));
+		regex.push(file);
+	}
+	const triggers = [];
+	for (let index = 0; index < (moduleData.trigger ?? []).length; index += 1) {
+		const trigger = moduleData.trigger[index];
+		const luaEffect = trigger.effect?.length === 1 && trigger.effect[0].type === "triggerlua" ? trigger.effect[0] : void 0;
+		if (!luaEffect || typeof luaEffect.code !== "string") {
+			triggers.push(trigger);
+			continue;
+		}
+		const luaPath = takeSourcePath("triggers", trigger.comment || `trigger-${index + 1}`, ".lua", takenPaths);
+		files.set(luaPath, Buffer.from(luaEffect.code, "utf8"));
+		triggers.push({
+			bundle: false,
+			comment: trigger.comment ?? "",
+			conditions: trigger.conditions ?? [],
+			lowLevelAccess: trigger.lowLevelAccess,
+			lua: luaPath,
+			type: trigger.type ?? "start"
+		});
+	}
+	const risuai = card.data?.extensions?.risuai ?? {};
+	const manifest = {
+		card: "card.json",
+		creator: card.data?.creator,
+		description: card.data?.creator_notes ?? moduleData.description ?? "",
+		folders,
+		hideIcon: risuai.hideChatIcon ?? moduleData.hideIcon ?? false,
+		lorebook,
+		lowLevelAccess: risuai.lowLevelAccess ?? moduleData.lowLevelAccess ?? false,
+		name: card.data?.name ?? moduleData.name,
+		namespace: risuai.moduleNamespace ?? moduleData.namespace,
+		regex,
+		tags: card.data?.tags,
+		triggers,
+		version: card.data?.character_version ?? ""
+	};
+	const CSS = risuai.backgroundHTML ?? moduleData.backgroundEmbedding;
+	if (CSS) {
+		manifest.CSS = "style.html";
+		files.set("style.html", Buffer.from(CSS, "utf8"));
+	}
+	const toggles = risuai.toggles ?? moduleData.customModuleToggle;
+	if (toggles) {
+		manifest.toggles = "toggles.txt";
+		files.set("toggles.txt", Buffer.from(toggles, "utf8"));
+	}
+	const mainIcon = card.data?.assets?.find((asset) => asset.type === "icon" && asset.name === "main");
+	if (mainIcon?.uri?.startsWith("embeded://")) manifest.icon = mainIcon.uri.slice(10);
+	const assets = [];
+	for (const asset of card.data?.assets ?? []) {
+		if (asset === mainIcon || !asset.uri?.startsWith("embeded://")) continue;
+		assets.push({
+			extension: asset.ext,
+			file: asset.uri.slice(10),
+			name: asset.name
+		});
+	}
+	if (assets.length > 0) manifest.assets = assets;
+	files.set("charx.json", Buffer.from(`${JSON.stringify(sortKeysDeep(manifest), null, 2)}\n`, "utf8"));
+	return files;
+}
+function parseZIP(archive) {
+	const endOffset = findEndOfCentralDirectory(archive);
+	const diskNumber = archive.readUInt16LE(endOffset + 4);
+	const centralDisk = archive.readUInt16LE(endOffset + 6);
+	const diskEntries = archive.readUInt16LE(endOffset + 8);
+	const totalEntries = archive.readUInt16LE(endOffset + 10);
+	const centralSize = archive.readUInt32LE(endOffset + 12);
+	const centralOffset = archive.readUInt32LE(endOffset + 16);
+	assert$1(diskNumber === 0 && centralDisk === 0, "Multi-disk ZIP archives are not supported");
+	assert$1(diskEntries === totalEntries, "Inconsistent ZIP entry count");
+	assert$1(totalEntries !== 65535 && centralSize !== 4294967295 && centralOffset !== 4294967295, "ZIP64 is not supported");
+	const zipOffset = endOffset - centralSize - centralOffset;
+	assert$1(zipOffset >= 0, "Invalid ZIP central directory offset");
+	const entries = [];
+	const names = /* @__PURE__ */ new Set();
+	let offset = zipOffset + centralOffset;
+	for (let index = 0; index < totalEntries; index += 1) {
+		assert$1(offset + 46 <= archive.length, "ZIP central directory is truncated");
+		assert$1(archive.readUInt32LE(offset) === 33639248, `Invalid ZIP central record at byte ${offset}`);
+		const flags = archive.readUInt16LE(offset + 8);
+		const method = archive.readUInt16LE(offset + 10);
+		const expectedCRC32 = archive.readUInt32LE(offset + 16);
+		const compressedSize = archive.readUInt32LE(offset + 20);
+		const uncompressedSize = archive.readUInt32LE(offset + 24);
+		const nameLength = archive.readUInt16LE(offset + 28);
+		const extraLength = archive.readUInt16LE(offset + 30);
+		const commentLength = archive.readUInt16LE(offset + 32);
+		const diskStart = archive.readUInt16LE(offset + 34);
+		const localOffset = archive.readUInt32LE(offset + 42);
+		const recordLength = 46 + nameLength + extraLength + commentLength;
+		assert$1(offset + recordLength <= archive.length, "ZIP central record is truncated");
+		assert$1((flags & 1) === 0, "Encrypted ZIP entries are not supported");
+		assert$1(method === 0 || method === 8, `Unsupported ZIP compression method: ${method}`);
+		assert$1(diskStart === 0, "Multi-disk ZIP entries are not supported");
+		assert$1(compressedSize !== 4294967295 && uncompressedSize !== 4294967295 && localOffset !== 4294967295, "ZIP64 entries are not supported");
+		const decodedName = archive.subarray(offset + 46, offset + 46 + nameLength).toString("utf8");
+		const directory = decodedName.endsWith("/") || decodedName.endsWith("\\");
+		const name = normalizeEntryName(decodedName);
+		assert$1(name !== "", "ZIP entry resolves to an empty path");
+		assert$1(!names.has(name), `Duplicate ZIP entry: ${name}`);
+		names.add(name);
+		entries.push({
+			compressedSize,
+			directory,
+			expectedCRC32,
+			localOffset: zipOffset + localOffset,
+			method,
+			name,
+			uncompressedSize
+		});
+		offset += recordLength;
+	}
+	assert$1(offset === endOffset, "ZIP central directory size does not match its records");
+	return entries;
+}
+function readEntry(archive, entry) {
+	const offset = entry.localOffset;
+	assert$1(offset + 30 <= archive.length, `ZIP local record is truncated: ${entry.name}`);
+	assert$1(archive.readUInt32LE(offset) === 67324752, `Invalid ZIP local record: ${entry.name}`);
+	const nameLength = archive.readUInt16LE(offset + 26);
+	const extraLength = archive.readUInt16LE(offset + 28);
+	const dataOffset = offset + 30 + nameLength + extraLength;
+	const dataEnd = dataOffset + entry.compressedSize;
+	assert$1(dataEnd <= archive.length, `ZIP entry data is truncated: ${entry.name}`);
+	const compressed = archive.subarray(dataOffset, dataEnd);
+	const data = entry.method === 0 ? Buffer.from(compressed) : zlib.inflateRawSync(compressed);
+	assert$1(data.length === entry.uncompressedSize, `ZIP entry size mismatch: ${entry.name}`);
+	assert$1(calculateCRC32(data) === entry.expectedCRC32, `ZIP entry checksum mismatch: ${entry.name}`);
+	assert$1(!entry.directory || data.length === 0, `ZIP directory entry contains data: ${entry.name}`);
+	return data;
+}
+function assertEmptyOutputDirectory$1(outputDirectory) {
+	if (!fs.existsSync(outputDirectory)) return;
+	assert$1(fs.statSync(outputDirectory).isDirectory(), `Output path is not a directory: ${outputDirectory}`);
+	assert$1(fs.readdirSync(outputDirectory).length === 0, `Output directory is not empty: ${outputDirectory}`);
+}
+function unpackCharX(inputPath, outputPath) {
+	const resolvedInputPath = path.resolve(inputPath);
+	const resolvedOutputPath = path.resolve(outputPath);
+	const archive = fs.readFileSync(resolvedInputPath);
+	const entries = parseZIP(archive);
+	const extracted = /* @__PURE__ */ new Map();
+	for (const entry of entries) extracted.set(entry.name, {
+		data: readEntry(archive, entry),
+		directory: entry.directory
+	});
+	const cardEntry = extracted.get("card.json");
+	assert$1(cardEntry, "CharX archive does not contain card.json");
+	assert$1(!cardEntry.directory, "card.json is a directory");
+	const card = JSON.parse(cardEntry.data.toString("utf8"));
+	let decodedModule;
+	let decodedModuleName;
+	if (extracted.has("module.risum")) {
+		const moduleEntry = extracted.get("module.risum");
+		assert$1(moduleEntry, "CharX archive does not contain module.risum");
+		assert$1(!moduleEntry.directory, "module.risum is a directory");
+		const map = fs.readFileSync(RPACK_MAP_PATH$1);
+		decodedModule = decodeModule(moduleEntry.data, map);
+		decodedModuleName = extracted.has("module.json") ? "module.decoded.json" : "module.json";
+	}
+	const expandedSources = decodedModule ? createExpandedModuleSources(card, decodedModule) : /* @__PURE__ */ new Map();
+	for (const name of expandedSources.keys()) assert$1(!extracted.has(name), `Generated module source conflicts with an archive entry: ${name}`);
+	assertEmptyOutputDirectory$1(resolvedOutputPath);
+	fs.mkdirSync(resolvedOutputPath, { recursive: true });
+	for (const [name, entry] of extracted) {
+		if (name === "module.risum") continue;
+		const destination = path.join(resolvedOutputPath, ...name.split("/"));
+		if (entry.directory) {
+			fs.mkdirSync(destination, { recursive: true });
+			continue;
+		}
+		fs.mkdirSync(path.dirname(destination), { recursive: true });
+		fs.writeFileSync(destination, entry.data);
+	}
+	if (decodedModule) fs.writeFileSync(path.join(resolvedOutputPath, decodedModuleName), `${JSON.stringify(decodedModule, null, 2)}\n`);
+	for (const [name, data] of expandedSources) {
+		const destination = path.join(resolvedOutputPath, ...name.split("/"));
+		fs.mkdirSync(path.dirname(destination), { recursive: true });
+		fs.writeFileSync(destination, data);
+	}
+	const relativeOutput = path.relative(process.cwd(), resolvedOutputPath) || ".";
+	const moduleNote = decodedModule ? ` and decoded ${decodedModuleName}` : "";
+	console.log(`Unpacked ${entries.length - (decodedModule ? 1 : 0)} archive files to ${relativeOutput}${moduleNote}`);
+	return resolvedOutputPath;
+}
+//#endregion
+//#region src/unpack-risum.ts
+var RPACK_MAP_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "vendor", "rpack", "rpack_map.bin");
+function assert(condition, message) {
+	if (!condition) throw new Error(message);
+}
+function assertEmptyOutputDirectory(outputDirectory) {
+	if (!fs.existsSync(outputDirectory)) return;
+	assert(fs.statSync(outputDirectory).isDirectory(), `Output path is not a directory: ${outputDirectory}`);
+	assert(fs.readdirSync(outputDirectory).length === 0, `Output directory is not empty: ${outputDirectory}`);
+}
+function decodeRPack(data, decodeMap) {
+	for (let index = 0; index < data.length; index += 1) data[index] = decodeMap[data[index]];
+	return data;
+}
+function readExactly(fileDescriptor, length, position, label) {
+	const data = Buffer.allocUnsafe(length);
+	let read = 0;
+	while (read < length) {
+		const count = fs.readSync(fileDescriptor, data, read, length - read, position + read);
+		assert(count > 0, `${label} is truncated at byte ${position + read}`);
+		read += count;
+	}
+	return data;
+}
+function sanitizeAssetName(name, fallback) {
+	return Array.from(name, (character) => character.charCodeAt(0) < 32 ? "_" : character).join("").replace(/[<>:"/\\|?*]/g, "_").replace(/[. ]+$/g, "").trim().slice(0, 180) || fallback;
+}
+function detectAssetExtension(data, fallback) {
+	if (data.subarray(0, 8).equals(Buffer.from("89504e470d0a1a0a", "hex"))) return "png";
+	if (data.subarray(0, 3).equals(Buffer.from("ffd8ff", "hex"))) return "jpg";
+	if (data.subarray(0, 6).toString("ascii") === "GIF87a" || data.subarray(0, 6).toString("ascii") === "GIF89a") return "gif";
+	if (data.subarray(0, 4).toString("ascii") === "RIFF" && data.subarray(8, 12).toString("ascii") === "WEBP") return "webp";
+	if (data.subarray(4, 12).toString("ascii").includes("ftypavif")) return "avif";
+	return /^[a-z0-9]+$/i.test(fallback ?? "") ? fallback.toLowerCase() : "bin";
+}
+function takeAssetPath(asset, data, index, takenPaths) {
+	const extension = detectAssetExtension(data, asset[2]);
+	const baseName = sanitizeAssetName(asset[0] ?? "", `asset_${index + 1}`);
+	let candidate = `assets/${baseName}.${extension}`;
+	let collision = 1;
+	while (takenPaths.has(candidate)) {
+		collision += 1;
+		candidate = `assets/${baseName}_${collision}.${extension}`;
+	}
+	takenPaths.add(candidate);
+	return candidate;
+}
+function writeSources(outputDirectory, decodedModule, assetSources) {
+	const sources = createExpandedModuleSources({ data: { name: decodedModule.module.name } }, decodedModule);
+	const manifestSource = sources.get("charx.json");
+	assert(manifestSource, "Expanded module sources do not contain charx.json");
+	const manifest = JSON.parse(manifestSource.toString("utf8"));
+	manifest.assets = assetSources;
+	sources.set("charx.json", Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, "utf8"));
+	sources.set("module.json", Buffer.from(`${JSON.stringify(decodedModule, null, 2)}\n`, "utf8"));
+	for (const [name, data] of sources) {
+		const destination = path.join(outputDirectory, ...name.split("/"));
+		fs.mkdirSync(path.dirname(destination), { recursive: true });
+		fs.writeFileSync(destination, data);
+	}
+}
+function unpackRisuM(inputPath, outputPath) {
+	const resolvedInputPath = path.resolve(inputPath);
+	const resolvedOutputPath = path.resolve(outputPath);
+	assertEmptyOutputDirectory(resolvedOutputPath);
+	const map = fs.readFileSync(RPACK_MAP_PATH);
+	assert(map.length >= 512, `Invalid RPack map: ${RPACK_MAP_PATH}`);
+	const decodeMap = map.subarray(256, 512);
+	const fileDescriptor = fs.openSync(resolvedInputPath, "r");
+	try {
+		const fileSize = fs.fstatSync(fileDescriptor).size;
+		const header = readExactly(fileDescriptor, 6, 0, "RISUM header");
+		assert(header.readUInt8(0) === 111, "Invalid RISUM magic number");
+		assert(header.readUInt8(1) === 0, `Unsupported RISUM version: ${header.readUInt8(1)}`);
+		const payloadLength = header.readUInt32LE(2);
+		const payload = readExactly(fileDescriptor, payloadLength, 6, "RISUM module payload");
+		const decodedModule = JSON.parse(decodeRPack(payload, decodeMap).toString("utf8"));
+		assert(decodedModule?.type === "risuModule" && decodedModule.module, "RISUM does not contain a Risu module");
+		const assetMetadata = decodedModule.module.assets ?? [];
+		const assetSources = [];
+		const takenPaths = /* @__PURE__ */ new Set();
+		let assetIndex = 0;
+		let position = 6 + payloadLength;
+		fs.mkdirSync(path.join(resolvedOutputPath, "assets"), { recursive: true });
+		while (position < fileSize) {
+			const marker = readExactly(fileDescriptor, 1, position, "RISUM asset marker").readUInt8(0);
+			position += 1;
+			if (marker === 0) break;
+			assert(marker === 1, `Invalid RISUM asset marker at byte ${position - 1}: ${marker}`);
+			assert(assetIndex < assetMetadata.length, "RISUM contains more asset blocks than asset metadata entries");
+			const assetLength = readExactly(fileDescriptor, 4, position, "RISUM asset length").readUInt32LE(0);
+			position += 4;
+			const encodedAsset = readExactly(fileDescriptor, assetLength, position, `RISUM asset ${assetIndex + 1}`);
+			position += assetLength;
+			const metadata = assetMetadata[assetIndex];
+			assert(metadata, `RISUM asset ${assetIndex + 1} has no metadata`);
+			const decodedAsset = decodeRPack(encodedAsset, decodeMap);
+			const sourcePath = takeAssetPath(metadata, decodedAsset, assetIndex, takenPaths);
+			const destination = path.join(resolvedOutputPath, ...sourcePath.split("/"));
+			fs.writeFileSync(destination, decodedAsset);
+			assetSources.push({
+				extension: path.extname(sourcePath).slice(1),
+				file: sourcePath,
+				name: metadata[0]
+			});
+			assetIndex += 1;
+			if (assetIndex % 500 === 0) console.log(`Extracted ${assetIndex} / ${assetMetadata.length} assets`);
+		}
+		assert(assetIndex === assetMetadata.length, `RISUM contains ${assetIndex} asset blocks but declares ${assetMetadata.length}`);
+		assert(position === fileSize, `RISUM contains ${fileSize - position} trailing bytes after the end marker`);
+		writeSources(resolvedOutputPath, decodedModule, assetSources);
+		const relativeOutput = path.relative(process.cwd(), resolvedOutputPath) || ".";
+		console.log(`Unpacked ${assetIndex} assets and module sources to ${relativeOutput}`);
+		return resolvedOutputPath;
+	} finally {
+		fs.closeSync(fileDescriptor);
+	}
+}
+//#endregion
+export { unpackCharX as a, bundleLua as c, parseZIP as i, createExpandedModuleSources as n, parseModuleBlock as o, decodeModule as r, buildCharX as s, unpackRisuM as t };
+
+//# sourceMappingURL=unpack-risum-8Iw-UEO2.js.map