@openfairygui/functions 0.2.0-alpha.2 → 0.2.0-alpha.21

package/dist/restore-BW2xacB3.cjs

@@ -0,0 +1,936 @@
+let _openfairygui_core = require("@openfairygui/core");
+//#region src/restore-internals/output-transaction.ts
+function trimTrailingSlashes(value) {
+	return value.replace(/[/\\]+$/, "");
+}
+function normalizeComparablePath(value) {
+	const normalized = trimTrailingSlashes(value).replace(/\\/g, "/");
+	const driveMatch = normalized.match(/^([a-z]:)(?:\/(.*))?$/i);
+	const drivePrefix = driveMatch?.[1].toLowerCase() ?? "";
+	const remainder = driveMatch ? driveMatch[2] ?? "" : normalized;
+	const hasRoot = driveMatch ? true : remainder.startsWith("/");
+	const rawSegments = remainder.split("/").filter((segment) => segment.length > 0);
+	const segments = [];
+	for (const segment of rawSegments) {
+		if (segment === ".") continue;
+		if (segment === "..") {
+			if (segments.length > 0 && segments[segments.length - 1] !== "..") segments.pop();
+			else if (!hasRoot) segments.push("..");
+			continue;
+		}
+		segments.push(segment);
+	}
+	const joined = segments.join("/");
+	return (drivePrefix ? `${drivePrefix}/${joined}`.replace(/\/$/, "") : hasRoot ? `/${joined}`.replace(/\/$/, "") : joined || ".").toLowerCase();
+}
+function isPathWithin(root, candidate) {
+	const normalizedRoot = normalizeComparablePath(root);
+	return normalizeComparablePath(candidate).startsWith(`${normalizedRoot}/`);
+}
+function basename(filePath) {
+	return trimTrailingSlashes(filePath).match(/([^/\\]+)$/)?.[1] ?? "";
+}
+function normalizeRestoreOutputDir(output) {
+	const normalized = trimTrailingSlashes(output);
+	const name = basename(normalized);
+	if (!normalized || /\.fairy$/i.test(normalized) || !name || name === "." || name === ".." || /^[a-z]:$/iu.test(name)) throw new Error("restore: Output must be a non-root project directory, not a .fairy file.");
+	return normalized;
+}
+function resolveOutputProjectPath(outputDir, fs) {
+	return fs.join(outputDir, `${basename(outputDir)}.fairy`);
+}
+async function resolvePathForContainment(filePath, fs) {
+	const missingSegments = [];
+	let existingPath = filePath;
+	while (!await fs.exists(existingPath)) {
+		const parentPath = fs.dirname(existingPath);
+		if (!parentPath || parentPath === existingPath) return Promise.resolve(fs.resolvePath(filePath));
+		missingSegments.unshift(basename(existingPath));
+		existingPath = parentPath;
+	}
+	const resolvedExistingPath = await Promise.resolve(fs.resolvePath(existingPath));
+	return missingSegments.reduce((resolvedPath, segment) => fs.join(resolvedPath, segment), resolvedExistingPath);
+}
+async function assertRestoreOutputDir(inputDir, outputDir, fs, force) {
+	const [resolvedInputDir, resolvedOutputDir] = await Promise.all([resolvePathForContainment(inputDir, fs), resolvePathForContainment(outputDir, fs)]);
+	const normalizedInputDir = normalizeComparablePath(resolvedInputDir);
+	const normalizedOutputDir = normalizeComparablePath(resolvedOutputDir);
+	if (normalizedInputDir === normalizedOutputDir || isPathWithin(normalizedInputDir, normalizedOutputDir) || isPathWithin(normalizedOutputDir, normalizedInputDir)) throw new Error("Restore output directory must be independent from the published input directory.");
+	if (!await fs.exists(outputDir)) return;
+	let entries;
+	try {
+		entries = await fs.readdir(outputDir);
+	} catch {
+		throw new Error(`Restore output path is not a directory: ${outputDir}`);
+	}
+	if (entries.length === 0) return;
+	if (!force) throw new Error(`Restore output directory is not empty: ${outputDir}. Use --force to overwrite it.`);
+}
+async function createRestoreStagingDir(outputDir, fs) {
+	const parentDir = fs.dirname(outputDir) || ".";
+	await fs.mkdir(parentDir);
+	for (let attempt = 0; attempt < 8; attempt += 1) {
+		const stagingDir = fs.join(parentDir, `.${basename(outputDir)}.restore-${(0, _openfairygui_core.generateId)()}`);
+		if (await fs.exists(stagingDir)) continue;
+		await fs.mkdir(stagingDir);
+		return stagingDir;
+	}
+	throw new Error(`restore: Could not allocate a staging directory beside ${outputDir}.`);
+}
+async function commitRestoreOutput(stagingDir, outputDir, fs) {
+	if (!await fs.exists(outputDir)) {
+		await fs.rename(stagingDir, outputDir);
+		return null;
+	}
+	const parentDir = fs.dirname(outputDir) || ".";
+	let backupDir = "";
+	for (let attempt = 0; attempt < 8; attempt += 1) {
+		const candidate = fs.join(parentDir, `.${basename(outputDir)}.restore-backup-${(0, _openfairygui_core.generateId)()}`);
+		if (!await fs.exists(candidate)) {
+			backupDir = candidate;
+			break;
+		}
+	}
+	if (!backupDir) throw new Error(`restore: Could not allocate a backup directory beside ${outputDir}.`);
+	await fs.rename(outputDir, backupDir);
+	try {
+		await fs.rename(stagingDir, outputDir);
+	} catch (error) {
+		await fs.rename(backupDir, outputDir);
+		throw error;
+	}
+	try {
+		await fs.rm(backupDir, {
+			recursive: true,
+			force: true
+		});
+		return null;
+	} catch {
+		return `restore: Previous output retained at ${backupDir}; remove it after checking the restored project.`;
+	}
+}
+//#endregion
+//#region src/restore-internals/font.ts
+function resourceFileName$1(resource) {
+	return resource.getFileName?.() || resource.getFile?.() || resource.getName?.() || "";
+}
+function stripExtension$1(fileName) {
+	return fileName.split(/[\\/]/).pop()?.replace(/\.[^.]+$/u, "") ?? "";
+}
+function fontGlyphCharId(glyph) {
+	const charId = glyph.getCharId();
+	if (charId > 0) return charId;
+	const char = glyph.getChar();
+	return char ? char.codePointAt(0) ?? 0 : 0;
+}
+function serializeTtfFontHeader(pkg, resource, glyphs) {
+	const face = stripExtension$1(resourceFileName$1(resource)) || resource.getName?.() || "Font";
+	const lineHeight = resource.getLineHeight?.() ?? 0;
+	const fontSize = resource.getFontSize?.() ?? lineHeight;
+	const textureId = resource.getTextureId?.() ?? "";
+	const textureResource = textureId ? pkg.getResourceById(textureId) : null;
+	const textureName = textureResource ? resourceFileName$1(textureResource) : `${face}_atlas.png`;
+	const scaleW = textureResource?.getWidth?.() ?? 256;
+	const scaleH = textureResource?.getHeight?.() ?? 256;
+	const base = Math.max(Math.min(fontSize, lineHeight) - 6, 0);
+	return [
+		`info face="${face}" size=${fontSize} bold=0 italic=0 charset="" unicode=1 stretchH=100 smooth=1 aa=1 padding=0,0,0,0 spacing=1,1 outline=0`,
+		`common lineHeight=${lineHeight} base=${base} scaleW=${scaleW} scaleH=${scaleH} pages=1 packed=0 alphaChnl=${resource.getTint?.() ? 1 : 0} redChnl=0 greenChnl=0 blueChnl=0`,
+		`page id=0 file="${textureName}"`,
+		`chars count=${glyphs.length}`
+	];
+}
+function serializeFont(pkg, resource, glyphs) {
+	const isTtf = resource.getTtf?.() === true;
+	const lines = isTtf ? serializeTtfFontHeader(pkg, resource, glyphs) : ["info creator=UIBuilder", `common lineHeight=${resource.getLineHeight?.() ?? 0}`];
+	for (const glyph of glyphs) {
+		const charId = fontGlyphCharId(glyph);
+		if (isTtf) lines.push(`char id=${charId} x=${glyph.getX()} y=${glyph.getY()} width=${glyph.getWidth()} height=${glyph.getHeight()} xoffset=${glyph.getXOffset()} yoffset=${glyph.getYOffset()} xadvance=${glyph.getAdvance()} page=0 chnl=${glyph.getChannel()}`);
+		else lines.push(`char id=${charId} img=${glyph.getImg()} xoffset=${glyph.getXOffset()} yoffset=${glyph.getYOffset()} xadvance=${glyph.getAdvance()}`);
+	}
+	return `${lines.join("\n")}\n`;
+}
+//#endregion
+//#region src/restore-internals/movie-clip.ts
+const JTA_FILE_MARK = "yytou";
+const JTA_VERSION = 102;
+const JTA_DEFAULT_FPS = 24;
+function scaledFrameDelay(milliseconds) {
+	return milliseconds <= 0 ? 0 : Math.max(1, Math.round(milliseconds / (1e3 / JTA_DEFAULT_FPS)));
+}
+function jtaSpeed(interval) {
+	return interval <= 0 ? 1 : Math.max(1, Math.round(interval / (1e3 / JTA_DEFAULT_FPS)));
+}
+function writeInt16(value) {
+	const data = new Uint8Array(2);
+	new DataView(data.buffer).setInt16(0, value);
+	return data;
+}
+function writeUint16(value) {
+	const data = new Uint8Array(2);
+	new DataView(data.buffer).setUint16(0, value);
+	return data;
+}
+function writeInt32(value) {
+	const data = new Uint8Array(4);
+	new DataView(data.buffer).setInt32(0, value);
+	return data;
+}
+function writeByte(value) {
+	return new Uint8Array([value & 255]);
+}
+function concatBytes(chunks) {
+	const length = chunks.reduce((total, chunk) => total + chunk.byteLength, 0);
+	const data = new Uint8Array(length);
+	let offset = 0;
+	for (const chunk of chunks) {
+		data.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return data;
+}
+function encodeJtaUtf(value) {
+	const bytes = new TextEncoder().encode(value);
+	return concatBytes([writeUint16(bytes.byteLength), bytes]);
+}
+function serializeMovieClip(resource, frames, textures) {
+	const chunks = [
+		encodeJtaUtf(JTA_FILE_MARK),
+		writeInt32(JTA_VERSION),
+		writeByte(0),
+		writeByte(0),
+		writeByte(0),
+		writeByte(0),
+		writeUint16(0),
+		writeUint16(0),
+		writeUint16(resource.getWidth?.() ?? 0),
+		writeUint16(resource.getHeight?.() ?? 0),
+		writeByte(jtaSpeed(resource.getInterval?.() ?? 0)),
+		writeByte(scaledFrameDelay(resource.getRepeatDelay?.() ?? 0)),
+		writeByte(resource.getSwing?.() ? 1 : 0),
+		writeInt16(frames.length)
+	];
+	for (const [index, frame] of frames.entries()) chunks.push(writeInt16(scaledFrameDelay(frame.getAddDelay())), writeInt16(frame.getRectX()), writeInt16(frame.getRectY()), writeInt16(frame.getRectWidth()), writeInt16(frame.getRectHeight()), writeInt16(textures[index]?.byteLength === 0 ? -1 : index));
+	chunks.push(writeInt16(textures.length));
+	for (const texture of textures) chunks.push(writeInt32(texture.byteLength), texture);
+	return concatBytes(chunks);
+}
+//#endregion
+//#region src/restore.ts
+const TRANSPARENT_PNG_1X1 = Uint8Array.from([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10,
+	0,
+	0,
+	0,
+	13,
+	73,
+	72,
+	68,
+	82,
+	0,
+	0,
+	0,
+	1,
+	0,
+	0,
+	0,
+	1,
+	8,
+	6,
+	0,
+	0,
+	0,
+	31,
+	21,
+	196,
+	137,
+	0,
+	0,
+	0,
+	13,
+	73,
+	68,
+	65,
+	84,
+	120,
+	156,
+	99,
+	96,
+	0,
+	0,
+	0,
+	2,
+	0,
+	1,
+	229,
+	39,
+	212,
+	138,
+	0,
+	0,
+	0,
+	0,
+	73,
+	69,
+	78,
+	68,
+	174,
+	66,
+	96,
+	130
+]);
+function assertSafeRestoreSegment(value, label) {
+	if (!value || value === "." || value === ".." || value.includes("\0") || /[\\/:]/u.test(value)) throw new Error(`restore: Invalid ${label} "${value}".`);
+}
+function normalizeVirtualPath(path) {
+	const raw = (path ?? "").trim();
+	if (!raw || raw === "/") return "";
+	if (raw.includes("\0") || raw.startsWith("\\") || raw.startsWith("//") || /^[a-z]:/iu.test(raw)) throw new Error(`restore: Invalid resource path "${raw}".`);
+	const segments = raw.replace(/\\/g, "/").split("/").filter(Boolean);
+	if (segments.some((segment) => segment === "." || segment === ".." || segment.includes(":"))) throw new Error(`restore: Invalid resource path "${raw}".`);
+	return segments.join("/");
+}
+function resourceFileName(resource) {
+	return resource.getFileName?.() || resource.getFile?.() || resource.getName?.() || "";
+}
+function resourcePublishedFileName(resource) {
+	const publishedFile = (resource.getExtras?.() ?? {})._publishedFile;
+	return typeof publishedFile === "string" ? publishedFile : resourceFileName(resource);
+}
+function normalizePublishedLooseResourceFileName(resource, fileName) {
+	if (resource.propertyType === "MiscResource" && /\.atlas\.txt$/i.test(fileName)) return fileName.replace(/\.atlas\.txt$/i, ".atlas");
+	if (resource.propertyType === "SpineResource" && /\.skel\.bytes$/i.test(fileName)) return fileName.replace(/\.skel\.bytes$/i, ".skel");
+	return fileName;
+}
+function replaceLooseResourceBaseName(resource, fileName) {
+	const normalized = normalizePublishedLooseResourceFileName(resource, fileName);
+	const displayName = resource.getName?.() ?? "";
+	if (!displayName) return normalized;
+	const baseName = fileBaseName(normalized);
+	const ext = /((?:\.[^.\\/]+)+)$/u.exec(baseName)?.[1] ?? "";
+	const currentBaseName = ext ? baseName.slice(0, -ext.length) : baseName;
+	const resourceId = resource.getId?.() ?? "";
+	if (!resourceId || currentBaseName.toLowerCase() !== resourceId.toLowerCase()) return normalized;
+	return `${normalized.slice(0, normalized.length - baseName.length)}${displayName}${ext}`;
+}
+function fileBaseName(fileName) {
+	return fileName.split(/[\\/]/).pop() ?? fileName;
+}
+function stripExtension(fileName) {
+	return fileBaseName(fileName).replace(/\.[^.]+$/u, "");
+}
+function resourceInstanceFileName(resource) {
+	const fileName = (resource.propertyType === "Component" ? `${resource.getName?.() ?? resource.getId?.() ?? "component"}.xml` : resourceFileName(resource)).replace(/\\/g, "/").replace(/^\/+/, "");
+	if (!fileName) return "";
+	if (fileName.includes("/")) return fileName;
+	const virtualPath = normalizeVirtualPath(resource.getPath?.());
+	return virtualPath ? `${virtualPath}/${fileName}` : fileName;
+}
+function isSyntheticFontGlyphResource(resource) {
+	return resource.getExtras?.()?._syntheticFontGlyph === true;
+}
+function glyphDisplayChar(glyph) {
+	const char = glyph.getChar();
+	if (char) return char;
+	const charId = glyph.getCharId();
+	if (charId <= 0) return "";
+	try {
+		return String.fromCodePoint(charId);
+	} catch {
+		return "";
+	}
+}
+function sanitizeGlyphFileSegment(char) {
+	if (!char) return "glyph";
+	return char.replace(/\s/gu, "space").replace(/[\\/:*?"<>|]/gu, "_").replace(/\./gu, "_").split("").filter((item) => {
+		return (item.codePointAt(0) ?? 0) >= 32;
+	}).join("") || "glyph";
+}
+function defaultSyntheticFontGlyphFileName(resourceId) {
+	return `${resourceId}.png`;
+}
+function syntheticFontGlyphVirtualPath(pkg, font) {
+	const pkgName = pkg.getName?.() ?? "";
+	const fontBase = stripExtension(resourceFileName(font)).toLowerCase();
+	if (pkgName === "EmitNumbers") return "/";
+	if (pkgName === "Transition" && fontBase === "number3") return "/";
+	return "/images/";
+}
+function syntheticFontGlyphFileName(pkg, font, glyph, index, glyphCount) {
+	const pkgName = pkg.getName?.() ?? "";
+	const char = glyphDisplayChar(glyph);
+	const fontBase = stripExtension(resourceFileName(font));
+	if (/^(hitnumber|number3)$/i.test(fontBase) && /^[0-9]$/u.test(char)) return `h${char}.png`;
+	if (/^cdtime$/i.test(fontBase) && /^[0-9]$/u.test(char)) return `${char}(4)_png.png`;
+	if (pkgName === "EmitNumbers" && /^number1$/i.test(fontBase)) {
+		if (/^[0-9]$/u.test(char)) return `${char}(2)5_png.png`;
+		if (char === "-") return "m2_png.png";
+	}
+	if (pkgName === "EmitNumbers" && /^number2$/i.test(fontBase)) {
+		if (/^[0-9]$/u.test(char)) return `${char}(4)_png.png`;
+		if (char === "-") return "m1_png.png";
+	}
+	if (pkgName === "Transition" && /^number1$/i.test(fontBase)) {
+		const display = char === "0" && index === glyphCount - 1 ? "0-" : sanitizeGlyphFileSegment(char);
+		return `${String(index).padStart(4, "0")}_${display}_png.png`;
+	}
+	if (pkgName === "Transition" && /^number2$/i.test(fontBase)) return `${String(index).padStart(4, "0")}_${sanitizeGlyphFileSegment(char)}.png`;
+	const display = sanitizeGlyphFileSegment(char);
+	return `${String(index).padStart(4, "0")}_${display}.png`;
+}
+function syntheticFontTextureFileName(font) {
+	return `${stripExtension(resourceFileName(font)) || font.getId?.() || "font"}_atlas.png`;
+}
+function sameVirtualPath(a, b) {
+	return normalizeVirtualPath(a.getPath?.()) === normalizeVirtualPath(b.getPath?.());
+}
+function imageFileName(resource) {
+	const current = resource.getFileName?.() ?? "";
+	if (current) return current;
+	const name = resource.getName?.() ?? resource.getId?.() ?? "image";
+	const fileName = /\.[a-z0-9]+$/i.test(name) ? name : `${name}.png`;
+	resource.setFileName?.(fileName);
+	return fileName;
+}
+function findImageResource(pkg, itemId) {
+	return pkg.listResources().find((resource) => {
+		return resource.propertyType === "ImageResource" && resource.getId?.() === itemId;
+	}) ?? null;
+}
+function isPublishedBinaryFile(fileName) {
+	return /_fui\.bytes$/i.test(fileName) || /\.fui$/i.test(fileName) || /\.bin$/i.test(fileName);
+}
+function inferPackageName(fileName) {
+	if (/_fui\.bytes$/i.test(fileName)) return fileName.replace(/_fui\.bytes$/i, "");
+	if (/\.fui$/i.test(fileName)) return fileName.replace(/\.fui$/i, "");
+	return fileName.replace(/\.bin$/i, "");
+}
+async function restore(options) {
+	const sourceDir = trimTrailingSlashes(options.inputDir);
+	const outputDir = normalizeRestoreOutputDir(options.output);
+	const outputProjectPath = resolveOutputProjectPath(outputDir, options.fs);
+	await assertRestoreOutputDir(sourceDir, outputDir, options.fs, options.force === true);
+	const packageFilter = options.packages?.length ? new Set(options.packages) : null;
+	const binaryNames = (await options.fs.readdir(sourceDir)).filter((name) => isPublishedBinaryFile(name)).filter((name) => !packageFilter || packageFilter.has(inferPackageName(name)));
+	for (const binaryName of binaryNames) assertSafeRestoreSegment(binaryName, "published binary file name");
+	const candidateBinaryPaths = binaryNames.map((name) => options.fs.join(sourceDir, name)).sort((left, right) => left.localeCompare(right));
+	const binaryPaths = (await Promise.all(candidateBinaryPaths.map(async (filePath) => await options.fs.isFile(filePath) ? filePath : null))).filter((filePath) => !!filePath).sort((left, right) => left.localeCompare(right));
+	if (binaryPaths.length === 0) throw new Error(`No FairyGUI published binary files found in ${sourceDir}.`);
+	const restorer = new RestoreWorkflow(options.fs);
+	const document = await restorer.prepare({
+		binaryPaths,
+		sourceDir,
+		outputProjectPath,
+		projectType: options.projectType,
+		cropImage: options.cropImage,
+		extractImage: options.extractImage
+	});
+	const stagingDir = await createRestoreStagingDir(outputDir, options.fs);
+	const stagingProjectPath = options.fs.join(stagingDir, basename(outputProjectPath));
+	const warnings = [];
+	try {
+		await restorer.write(document, {
+			binaryPaths,
+			sourceDir,
+			outputProjectPath: stagingProjectPath,
+			projectType: options.projectType,
+			cropImage: options.cropImage,
+			extractImage: options.extractImage
+		}, warnings);
+		const cleanupWarning = await commitRestoreOutput(stagingDir, outputDir, options.fs);
+		if (cleanupWarning) warnings.push(cleanupWarning);
+	} catch (error) {
+		await options.fs.rm(stagingDir, {
+			recursive: true,
+			force: true
+		}).catch(() => void 0);
+		throw error;
+	}
+	return {
+		document,
+		projectPath: outputProjectPath,
+		warnings
+	};
+}
+var RestoreWorkflow = class {
+	_fs;
+	constructor(fs) {
+		this._fs = fs;
+	}
+	async prepare(options) {
+		const doc = await new _openfairygui_core.BinaryReader(this._fs).readMany(options.binaryPaths);
+		this._assertDocumentPaths(doc);
+		this._initializeProjectDefaults(doc, options.projectType);
+		this._initializeImageFileNames(doc);
+		this._initializeLooseResourceFileNames(doc);
+		this._assertDocumentPaths(doc);
+		await this._synthesizeLooseSkeletonResources(doc, options.sourceDir);
+		this._initializeRestoredResourceRelations(doc);
+		this._initializePublishedFontTextureIds(doc);
+		this._initializeFontTextureImageResources(doc);
+		this._initializeFontGlyphImageResources(doc);
+		this._initializePublishedTextFontResources(doc);
+		this._initializeDisplayObjectFileNames(doc);
+		this._initializePublishedFontDefaults(doc);
+		this._assertDocumentPaths(doc);
+		return doc;
+	}
+	async write(doc, options, warnings) {
+		await new _openfairygui_core.ProjectWriter(this._fs).write(doc, options.outputProjectPath);
+		await this._restoreAssets(doc, options, warnings);
+	}
+	_assertDocumentPaths(doc) {
+		for (const pkg of doc.getRoot().listPackages()) {
+			assertSafeRestoreSegment(pkg.getName(), "package name");
+			assertSafeRestoreSegment(pkg.getPublishName() || pkg.getName(), "package publish name");
+			for (const resource of pkg.listResources()) {
+				normalizeVirtualPath(resource.getPath?.());
+				const branch = resource.getBranch?.() ?? "";
+				if (branch) assertSafeRestoreSegment(branch, "branch name");
+				const fileName = resourceFileName(resource);
+				if (fileName) assertSafeRestoreSegment(fileName, "resource file name");
+				const publishedFileName = resourcePublishedFileName(resource);
+				if (publishedFileName) assertSafeRestoreSegment(publishedFileName, "published resource file name");
+			}
+		}
+	}
+	_initializeProjectDefaults(doc, projectType) {
+		doc.getRoot().setProjectId((0, _openfairygui_core.generateId)()).setProjectType(projectType ?? _openfairygui_core.ProjectType.Unity).setVersion("3.0").setSettings({
+			publish: {
+				binaryFormat: true,
+				fileExtension: "bytes",
+				compressDesc: false
+			},
+			common: {},
+			adaptation: {}
+		});
+	}
+	_initializeImageFileNames(doc) {
+		for (const pkg of doc.getRoot().listPackages()) for (const resource of pkg.listResources()) {
+			if (resource.propertyType !== "ImageResource") continue;
+			imageFileName(resource);
+			resource.setExtras?.({
+				...resource.getExtras?.() ?? {},
+				_suppressPackageSize: true
+			});
+		}
+	}
+	_initializeLooseResourceFileNames(doc) {
+		for (const pkg of doc.getRoot().listPackages()) for (const resource of pkg.listResources()) {
+			if (![
+				"MiscResource",
+				"SpineResource",
+				"DragonBonesResource",
+				"SoundResource"
+			].includes(resource.propertyType)) continue;
+			const current = resource.getFile?.() ?? "";
+			if (!current) continue;
+			const normalized = replaceLooseResourceBaseName(resource, current);
+			if (normalized !== current) resource.setFile?.(normalized);
+		}
+	}
+	async _synthesizeLooseSkeletonResources(doc, sourceDir) {
+		for (const pkg of doc.getRoot().listPackages()) for (const resource of [...pkg.listResources()]) {
+			let current = resource;
+			if (resource.propertyType === "DragonBonesResource" && /\.skel\.bytes$/i.test(resourceFileName(resource))) {
+				const normalizedFile = resourceFileName(resource).replace(/\.skel\.bytes$/i, ".skel");
+				const atlasBase = stripExtension(normalizedFile).replace(/-(?:pro|ess)$/i, "-pma");
+				if (await this._resolveLooseSourceFile(pkg, sourceDir, `${atlasBase}.atlas`)) current = this._replaceSkeletonResourceType(doc, pkg, resource, "SpineResource", normalizedFile);
+			}
+			if (current.propertyType === "SpineResource") await this._ensureSpineSidecarResources(doc, pkg, current, sourceDir);
+			else if (current.propertyType === "DragonBonesResource") await this._ensureDragonBonesSidecarResources(doc, pkg, current, sourceDir);
+		}
+	}
+	_initializeRestoredResourceRelations(doc) {
+		for (const pkg of doc.getRoot().listPackages()) {
+			const resources = pkg.listResources();
+			for (const resource of resources) if (resource.propertyType === "SpineResource") this._initializeSpineResourceRelation(resource, resources);
+			else if (resource.propertyType === "DragonBonesResource") this._initializeDragonBonesResourceRelation(resource, resources);
+		}
+	}
+	_replaceSkeletonResourceType(doc, pkg, resource, targetType, fileName) {
+		const replacement = targetType === "SpineResource" ? doc.createSpineResource(resource.getName?.() ?? "") : doc.createDragonBonesResource(resource.getName?.() ?? "");
+		replacement.setId?.(resource.getId?.() ?? "").setPath?.(resource.getPath?.() ?? "/").setFile?.(fileName).setExported?.(resource.getExported?.() ?? false).setWidth?.(resource.getWidth?.() ?? 0).setHeight?.(resource.getHeight?.() ?? 0).setRequireIds?.(resource.getRequireIds?.() ?? []).setAtlasNames?.(resource.getAtlasNames?.() ?? []).setAnchor?.(resource.getAnchorX?.() ?? 0, resource.getAnchorY?.() ?? 0).setBranch?.(resource.getBranch?.() ?? "").setBranchItemIds?.(resource.getBranchItemIds?.() ?? []);
+		replacement.setExtras?.({ ...resource.getExtras?.() ?? {} });
+		pkg.removeResource(resource);
+		pkg.addResource(replacement);
+		return replacement;
+	}
+	async _ensureSpineSidecarResources(doc, pkg, resource, sourceDir) {
+		const skeletonBase = stripExtension(resourceFileName(resource).replace(/\.skel\.bytes$/i, ".skel"));
+		if (!skeletonBase) return;
+		const atlasBase = skeletonBase.replace(/-(?:pro|ess)$/i, "-pma");
+		const atlas = await this._ensureLooseMiscResource(doc, pkg, resource, sourceDir, `${atlasBase}.atlas`);
+		const texture = await this._ensureLooseImageResource(doc, pkg, resource, sourceDir, `${atlasBase}.png`);
+		const requireIds = [atlas?.getId?.(), texture?.getId?.()].filter((id) => !!id);
+		if (requireIds.length > 0) resource.setRequireIds?.(requireIds);
+		if (atlas) resource.setAtlasNames?.([atlasBase]);
+	}
+	async _ensureDragonBonesSidecarResources(doc, pkg, resource, sourceDir) {
+		const skeletonBase = stripExtension(resourceFileName(resource)).replace(/_ske$/i, "");
+		if (!skeletonBase) return;
+		const textureJson = await this._ensureLooseMiscResource(doc, pkg, resource, sourceDir, `${skeletonBase}_tex.json`);
+		const textureImage = await this._ensureLooseImageResource(doc, pkg, resource, sourceDir, `${skeletonBase}.png`);
+		const requireIds = [textureJson?.getId?.(), textureImage?.getId?.()].filter((id) => !!id);
+		if (requireIds.length > 0) resource.setRequireIds?.(requireIds);
+	}
+	async _ensureLooseMiscResource(doc, pkg, owner, sourceDir, fileName) {
+		const resources = pkg.listResources();
+		const existing = this._findResourceByFile(resources, owner, "MiscResource", fileName);
+		if (existing) return existing;
+		const sourcePath = await this._resolveLooseSourceFile(pkg, sourceDir, fileName);
+		if (!sourcePath) return null;
+		const resource = doc.createMiscResource(stripExtension(fileName));
+		resource.setId((0, _openfairygui_core.generateId)()).setPath(owner.getPath?.() ?? "/").setBranch(owner.getBranch?.() ?? "").setBranchItemIds(owner.getBranchItemIds?.() ?? []).setExported(false).setFile(fileName);
+		resource.setExtras?.({
+			...resource.getExtras?.() ?? {},
+			_publishedFile: fileBaseName(sourcePath)
+		});
+		pkg.addResource(resource);
+		return resource;
+	}
+	async _ensureLooseImageResource(doc, pkg, owner, sourceDir, fileName) {
+		const resources = pkg.listResources();
+		const existing = this._findResourceByFile(resources, owner, "ImageResource", fileName);
+		const sourcePath = await this._resolveLooseSourceFile(pkg, sourceDir, fileName);
+		if (!sourcePath) return existing ?? null;
+		if (existing) {
+			existing.setExtras?.({
+				...existing.getExtras?.() ?? {},
+				_publishedFile: fileBaseName(sourcePath),
+				_restoreAsLooseImage: true
+			});
+			return existing;
+		}
+		const resource = doc.createImageResource(stripExtension(fileName));
+		resource.setId((0, _openfairygui_core.generateId)()).setPath(owner.getPath?.() ?? "/").setBranch(owner.getBranch?.() ?? "").setBranchItemIds(owner.getBranchItemIds?.() ?? []).setExported(false).setFileName(fileName);
+		resource.setExtras?.({
+			...resource.getExtras?.() ?? {},
+			_publishedFile: fileBaseName(sourcePath),
+			_suppressPackageSize: true,
+			_restoreAsLooseImage: true
+		});
+		pkg.addResource(resource);
+		return resource;
+	}
+	_initializeDisplayObjectFileNames(doc) {
+		for (const pkg of doc.getRoot().listPackages()) for (const component of pkg.listComponents()) for (const child of component.listChildren()) {
+			if (!child.setFileName || child.getFileName?.()) continue;
+			const resource = this._resolveDisplayObjectResource(doc, pkg, child);
+			const fileName = resource ? resourceInstanceFileName(resource) : "";
+			if (fileName) child.setFileName(fileName);
+		}
+	}
+	_initializeFontGlyphImageResources(doc) {
+		for (const pkg of doc.getRoot().listPackages()) for (const resource of [...pkg.listResources()]) {
+			if (resource.propertyType !== "FontResource") continue;
+			const glyphEntries = /* @__PURE__ */ new Map();
+			for (const [index, glyph] of resource.listGlyphs().entries()) {
+				const glyphId = glyph.getImg?.() ?? "";
+				if (!glyphId || glyphEntries.has(glyphId)) continue;
+				glyphEntries.set(glyphId, {
+					glyph,
+					index
+				});
+			}
+			for (const [glyphId, entry] of glyphEntries) {
+				if (pkg.getResourceById(glyphId)) continue;
+				const image = doc.createImageResource(glyphId);
+				image.setId(glyphId).setPath(syntheticFontGlyphVirtualPath(pkg, resource)).setBranch(resource.getBranch?.() ?? "").setFileName(syntheticFontGlyphFileName(pkg, resource, entry.glyph, entry.index, glyphEntries.size)).setExtras({
+					...image.getExtras?.() ?? {},
+					_syntheticFontGlyph: true,
+					_packageOrderAfterId: resource.getId?.() ?? "",
+					_packageOrderWeight: 1,
+					_suppressPackageSize: true
+				});
+				pkg.addResource(image);
+			}
+		}
+	}
+	_initializeFontTextureImageResources(doc) {
+		for (const pkg of doc.getRoot().listPackages()) for (const resource of [...pkg.listResources()]) {
+			if (resource.propertyType !== "FontResource") continue;
+			const textureId = resource.getTextureId?.() ?? "";
+			if (!textureId || pkg.getResourceById(textureId)) continue;
+			const image = doc.createImageResource(textureId);
+			image.setId(textureId).setPath(resource.getPath?.() ?? "/").setBranch(resource.getBranch?.() ?? "").setFileName(syntheticFontTextureFileName(resource)).setExtras({
+				...image.getExtras?.() ?? {},
+				_syntheticFontTexture: true,
+				_packageOrderAfterId: resource.getId?.() ?? "",
+				_packageOrderWeight: 0,
+				_suppressPackageSize: true
+			});
+			pkg.addResource(image);
+		}
+	}
+	_resolveDisplayObjectResource(doc, pkg, child) {
+		const src = child.getSrc?.() ?? "";
+		if (!src) return null;
+		return (child.getPackageId?.() ? doc.getRoot().getPackageById(child.getPackageId?.() ?? "") : pkg)?.getResourceById(src) ?? null;
+	}
+	_initializeSpineResourceRelation(resource, resources) {
+		const skeletonBase = stripExtension(resourceFileName(resource));
+		if (!skeletonBase) return;
+		const atlasBase = skeletonBase.replace(/-(?:pro|ess)$/i, "-pma");
+		const requireIds = [];
+		const atlas = this._findResourceByFile(resources, resource, "MiscResource", `${atlasBase}.atlas`);
+		const texture = this._findResourceByFile(resources, resource, "ImageResource", `${atlasBase}.png`);
+		if (atlas?.getId?.()) requireIds.push(atlas.getId());
+		if (texture?.getId?.()) requireIds.push(texture.getId());
+		if (requireIds.length > 0) resource.setRequireIds?.(requireIds);
+		if (atlas) resource.setAtlasNames?.([atlasBase]);
+	}
+	_initializeDragonBonesResourceRelation(resource, resources) {
+		const skeletonBase = stripExtension(resourceFileName(resource)).replace(/_ske$/i, "");
+		if (!skeletonBase) return;
+		const requireIds = [];
+		const textureJson = this._findResourceByFile(resources, resource, "MiscResource", `${skeletonBase}_tex.json`);
+		const textureImage = this._findResourceByFile(resources, resource, "ImageResource", `${skeletonBase}.png`);
+		if (textureJson?.getId?.()) requireIds.push(textureJson.getId());
+		if (textureImage?.getId?.()) requireIds.push(textureImage.getId());
+		if (requireIds.length > 0) resource.setRequireIds?.(requireIds);
+	}
+	_findResourceByFile(resources, owner, propertyType, fileName) {
+		const expected = fileName.toLowerCase();
+		return resources.find((resource) => {
+			return resource.propertyType === propertyType && sameVirtualPath(owner, resource) && fileBaseName(resourceFileName(resource)).toLowerCase() === expected;
+		}) ?? null;
+	}
+	_initializePublishedFontDefaults(doc) {
+		for (const pkg of doc.getRoot().listPackages()) for (const resource of pkg.listResources()) {
+			if (resource.propertyType !== "FontResource") continue;
+			const fileName = resourceFileName(resource);
+			if (!/\bsdf\b/i.test(fileName)) continue;
+			if (!resource.getRenderMode?.()) resource.setRenderMode?.("sdfaa");
+			if (!resource.getSamplePointSize?.()) resource.setSamplePointSize?.(60);
+		}
+	}
+	_initializePublishedTextFontResources(doc) {
+		for (const pkg of doc.getRoot().listPackages()) {
+			const fontResources = pkg.listResources().filter((resource) => resource.propertyType === "FontResource");
+			const fontByFileName = new Map(fontResources.map((resource) => [resourceFileName(resource).toLowerCase(), resource]));
+			const fontByDisplayName = new Map(fontResources.map((resource) => [stripExtension(resourceFileName(resource)).toLowerCase(), resource]));
+			for (const component of pkg.listComponents()) for (const child of component.listChildren()) {
+				const font = child.getFont?.() ?? "";
+				if (!font || font.startsWith("ui://")) continue;
+				if (!/\bsdf\b/i.test(font)) continue;
+				const normalized = font.trim().toLowerCase();
+				let resource = fontByDisplayName.get(normalized) ?? fontByFileName.get(`${normalized}.ttf`);
+				if (!resource) {
+					resource = doc.createFontResource(font.trim());
+					resource.setId((0, _openfairygui_core.generateId)()).setPath("/font/").setFileName(`${font.trim()}.ttf`).setExported(false).setRenderMode("sdfaa").setSamplePointSize(60).setTtf(true);
+					pkg.addResource(resource);
+					fontByDisplayName.set(normalized, resource);
+					fontByFileName.set(`${normalized}.ttf`, resource);
+				}
+				child.setFont?.(`ui://${pkg.getId()}${resource.getId?.() ?? ""}`);
+			}
+		}
+	}
+	_initializePublishedFontTextureIds(doc) {
+		for (const pkg of doc.getRoot().listPackages()) {
+			const resources = pkg.listResources();
+			for (const resource of resources) {
+				if (resource.propertyType !== "FontResource") continue;
+				if (resource.getTextureId?.()) continue;
+				if (resource.getTtf?.() !== true) continue;
+				const expectedFileName = syntheticFontTextureFileName(resource).toLowerCase();
+				const texture = resources.find((candidate) => {
+					return candidate.propertyType === "ImageResource" && sameVirtualPath(resource, candidate) && fileBaseName(resourceFileName(candidate)).toLowerCase() === expectedFileName;
+				});
+				if (texture?.getId?.()) resource.setTextureId?.(texture.getId());
+			}
+		}
+	}
+	async _restoreAssets(doc, options, warnings) {
+		for (const pkg of doc.getRoot().listPackages()) {
+			await this._restoreAtlasImages(pkg, options);
+			await this._writeGeneratedResources(pkg, options, warnings);
+			await this._copyLooseResources(pkg, options, warnings);
+		}
+	}
+	async _restoreAtlasImages(pkg, options) {
+		if (!options.cropImage) return;
+		for (const atlas of pkg.listAtlases()) {
+			const sourceAtlas = await this._resolveSourceFile(options.sourceDir, this._sourceFileCandidates(pkg, atlas.getFile()));
+			if (!sourceAtlas) throw new Error(`Atlas image not found for package "${pkg.getName()}": ${this._sourceFileCandidates(pkg, atlas.getFile()).join(", ")}`);
+			for (const sprite of atlas.listSprites()) {
+				const image = findImageResource(pkg, sprite.getItemId());
+				if (!image) continue;
+				if (sprite.getRectWidth() <= 0 || sprite.getRectHeight() <= 0) continue;
+				const outputPath = this._resourceOutputPath(options.outputProjectPath, pkg, image, imageFileName(image));
+				const imageWidth = image.getWidth?.() ?? 0;
+				const imageHeight = image.getHeight?.() ?? 0;
+				const spriteWidth = sprite.getRotated() ? sprite.getRectHeight() : sprite.getRectWidth();
+				const spriteHeight = sprite.getRotated() ? sprite.getRectWidth() : sprite.getRectHeight();
+				await this._mkdirForFile(outputPath);
+				await options.cropImage({
+					sourcePath: sourceAtlas,
+					outputPath,
+					left: sprite.getRectX(),
+					top: sprite.getRectY(),
+					width: sprite.getRectWidth(),
+					height: sprite.getRectHeight(),
+					rotated: sprite.getRotated(),
+					offsetX: sprite.getOffsetX(),
+					offsetY: sprite.getOffsetY(),
+					expectedWidth: Math.max(imageWidth, sprite.getOriginalWidth(), spriteWidth),
+					expectedHeight: Math.max(imageHeight, sprite.getOriginalHeight(), spriteHeight)
+				});
+			}
+		}
+	}
+	async _copyLooseResources(pkg, options, warnings) {
+		for (const resource of pkg.listResources()) {
+			const restoreAsLooseImage = resource.getExtras?.()?._restoreAsLooseImage === true;
+			if (![
+				"SoundResource",
+				"MiscResource",
+				"SpineResource",
+				"DragonBonesResource"
+			].includes(resource.propertyType) && !restoreAsLooseImage) continue;
+			const fileName = resourceFileName(resource);
+			if (!fileName) continue;
+			const sourcePath = await this._resolveSourceFile(options.sourceDir, this._sourceFileCandidates(pkg, resourcePublishedFileName(resource), fileName));
+			if (!sourcePath) {
+				warnings.push(`Loose resource not found for package "${pkg.getName()}": ${fileName}`);
+				continue;
+			}
+			const outputPath = this._resourceOutputPath(options.outputProjectPath, pkg, resource, fileName);
+			await this._mkdirForFile(outputPath);
+			await this._fs.writeFileRaw(outputPath, await this._fs.readFileRaw(sourcePath));
+		}
+	}
+	async _writeGeneratedResources(pkg, options, warnings) {
+		for (const resource of pkg.listResources()) if (resource.propertyType === "FontResource") await this._writeFontFile(pkg, resource, options.outputProjectPath);
+		else if (resource.propertyType === "MovieClipResource") await this._writeMovieClipFile(pkg, resource, options, warnings);
+		await this._writeSyntheticFontGlyphImages(pkg, options.outputProjectPath);
+	}
+	async _writeFontFile(pkg, resource, outputProjectPath) {
+		const fileName = resourceFileName(resource);
+		if (!/\.fnt$/i.test(fileName)) return;
+		const glyphs = resource.listGlyphs?.() ?? [];
+		if (glyphs.length === 0) return;
+		const outputPath = this._resourceOutputPath(outputProjectPath, pkg, resource, fileName);
+		await this._mkdirForFile(outputPath);
+		await this._fs.writeFile(outputPath, serializeFont(pkg, resource, glyphs));
+	}
+	async _writeMovieClipFile(pkg, resource, options, warnings) {
+		const fileName = resourceFileName(resource);
+		if (!/\.jta$/i.test(fileName)) return;
+		const frames = resource.listFrames?.() ?? [];
+		if (frames.length === 0) return;
+		if (!options.extractImage) {
+			warnings.push(`MovieClip file not generated for package "${pkg.getName()}": ${fileName}`);
+			return;
+		}
+		const sprites = await this._buildSpriteLookup(pkg, options);
+		const textures = [];
+		for (const [index, frame] of frames.entries()) {
+			const spriteEntry = sprites.get(frame.getSpriteId());
+			if (!spriteEntry) {
+				warnings.push(`MovieClip frame sprite not found for package "${pkg.getName()}": ${fileName} frame ${index}`);
+				return;
+			}
+			const sprite = spriteEntry.sprite;
+			if (sprite.getRectWidth() <= 0 || sprite.getRectHeight() <= 0) {
+				textures.push(new Uint8Array(0));
+				continue;
+			}
+			textures.push(await options.extractImage({
+				sourcePath: spriteEntry.sourceAtlas,
+				left: sprite.getRectX(),
+				top: sprite.getRectY(),
+				width: sprite.getRectWidth(),
+				height: sprite.getRectHeight(),
+				rotated: sprite.getRotated(),
+				offsetX: 0,
+				offsetY: 0,
+				expectedWidth: sprite.getRotated() ? sprite.getRectHeight() : sprite.getRectWidth(),
+				expectedHeight: sprite.getRotated() ? sprite.getRectWidth() : sprite.getRectHeight()
+			}));
+		}
+		const outputPath = this._resourceOutputPath(options.outputProjectPath, pkg, resource, fileName);
+		await this._mkdirForFile(outputPath);
+		await this._fs.writeFileRaw(outputPath, serializeMovieClip(resource, frames, textures));
+	}
+	async _writeSyntheticFontGlyphImages(pkg, outputProjectPath) {
+		for (const resource of pkg.listResources()) {
+			if (resource.propertyType !== "ImageResource" || !isSyntheticFontGlyphResource(resource)) continue;
+			const fileName = resourceFileName(resource) || defaultSyntheticFontGlyphFileName(resource.getId?.() ?? "glyph");
+			const outputPath = this._resourceOutputPath(outputProjectPath, pkg, resource, fileName);
+			await this._mkdirForFile(outputPath);
+			await this._fs.writeFileRaw(outputPath, TRANSPARENT_PNG_1X1);
+		}
+	}
+	async _buildSpriteLookup(pkg, options) {
+		const sprites = /* @__PURE__ */ new Map();
+		for (const atlas of pkg.listAtlases()) {
+			const sourceAtlas = await this._resolveSourceFile(options.sourceDir, this._sourceFileCandidates(pkg, atlas.getFile()));
+			if (!sourceAtlas) throw new Error(`Atlas image not found for package "${pkg.getName()}": ${this._sourceFileCandidates(pkg, atlas.getFile()).join(", ")}`);
+			for (const sprite of atlas.listSprites()) sprites.set(sprite.getItemId(), {
+				sourceAtlas,
+				sprite
+			});
+		}
+		return sprites;
+	}
+	_sourceFileCandidates(pkg, fileName, outputFileName = fileName) {
+		const publishName = pkg.getPublishName() || pkg.getName();
+		assertSafeRestoreSegment(publishName, "package publish name");
+		assertSafeRestoreSegment(fileName, "published source file name");
+		assertSafeRestoreSegment(outputFileName, "published source file name");
+		const candidates = Array.from(new Set([
+			`${publishName}_${fileName}`,
+			fileName,
+			`${publishName}_${outputFileName}`,
+			outputFileName
+		]));
+		for (const candidate of candidates) assertSafeRestoreSegment(candidate, "published source file name");
+		return candidates;
+	}
+	async _resolveLooseSourceFile(pkg, sourceDir, outputFileName) {
+		const candidates = outputFileName.endsWith(".atlas") ? this._sourceFileCandidates(pkg, `${outputFileName}.txt`, outputFileName) : outputFileName.endsWith(".skel") ? this._sourceFileCandidates(pkg, `${outputFileName}.bytes`, outputFileName) : this._sourceFileCandidates(pkg, outputFileName);
+		return this._resolveSourceFile(sourceDir, candidates);
+	}
+	async _resolveSourceFile(sourceDir, candidates) {
+		const resolvedSourceDir = await Promise.resolve(this._fs.resolvePath(sourceDir));
+		for (const candidate of candidates) {
+			assertSafeRestoreSegment(candidate, "published source file name");
+			const sourcePath = this._fs.join(sourceDir, candidate);
+			if (!await this._fs.isFile(sourcePath)) continue;
+			const resolvedSourcePath = await Promise.resolve(this._fs.resolvePath(sourcePath));
+			if (!isPathWithin(resolvedSourceDir, resolvedSourcePath)) throw new Error(`restore: Published source file resolves outside the input directory: ${candidate}.`);
+			return resolvedSourcePath;
+		}
+		return null;
+	}
+	_resourceOutputPath(outputProjectPath, pkg, resource, fileName) {
+		const basePath = this._fs.dirname(outputProjectPath);
+		const branch = resource.getBranch?.() ?? "";
+		assertSafeRestoreSegment(pkg.getName(), "package name");
+		if (branch) assertSafeRestoreSegment(branch, "branch name");
+		assertSafeRestoreSegment(fileName, "resource file name");
+		const assetsDir = branch ? `assets_${branch}` : "assets";
+		const virtualPath = normalizeVirtualPath(resource.getPath?.());
+		const pkgDir = this._fs.join(basePath, assetsDir, pkg.getName());
+		return virtualPath ? this._fs.join(pkgDir, virtualPath, fileName) : this._fs.join(pkgDir, fileName);
+	}
+	async _mkdirForFile(filePath) {
+		await this._fs.mkdir(this._fs.dirname(filePath));
+	}
+};
+//#endregion
+Object.defineProperty(exports, "restore", {
+	enumerable: true,
+	get: function() {
+		return restore;
+	}
+});