@openfairygui/functions 0.1.0

package/dist/index.cjs

@@ -0,0 +1,3110 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _openfairygui_core = require("@openfairygui/core");
+//#region src/inspect.ts
+function mapResource(resource) {
+	return {
+		name: resource.getName(),
+		id: resource.getId(),
+		path: resource.getPath?.() ?? "/",
+		exported: resource.getExported?.() ?? false
+	};
+}
+function mapComponentDetail(component, totals) {
+	const children = component.listChildren();
+	const controllers = component.listControllers();
+	const transitions = component.listTransitions();
+	totals.displayObjects += children.length;
+	totals.controllers += controllers.length;
+	totals.transitions += transitions.length;
+	for (const child of children) totals.gears += child.listGears().length;
+	return {
+		name: component.getName(),
+		id: component.getId(),
+		childCount: children.length,
+		controllerCount: controllers.length,
+		transitionCount: transitions.length
+	};
+}
+/**
+* Generates a detailed report of the project contents.
+*
+* Unlike other transforms, `inspect()` does NOT modify the document —
+* it returns a structured report.
+*
+* ```ts
+* const report = inspect(doc);
+* console.log(`${report.totals.packages} packages, ${report.totals.components} components`);
+* ```
+*/
+function inspect(doc) {
+	const root = doc.getRoot();
+	const totals = {
+		packages: 0,
+		images: 0,
+		sounds: 0,
+		fonts: 0,
+		movieClips: 0,
+		components: 0,
+		displayObjects: 0,
+		gears: 0,
+		controllers: 0,
+		transitions: 0
+	};
+	const packages = root.listPackages().map((pkg) => {
+		totals.packages++;
+		const resources = pkg.listResources();
+		const images = resources.filter((r) => r.propertyType === "ImageResource");
+		const sounds = resources.filter((r) => r.propertyType === "SoundResource");
+		const fonts = resources.filter((r) => r.propertyType === "FontResource");
+		const movieClips = resources.filter((r) => r.propertyType === "MovieClipResource");
+		const components = pkg.listComponents();
+		totals.images += images.length;
+		totals.sounds += sounds.length;
+		totals.fonts += fonts.length;
+		totals.movieClips += movieClips.length;
+		totals.components += components.length;
+		const componentDetails = components.map((component) => mapComponentDetail(component, totals));
+		return {
+			name: pkg.getName(),
+			id: pkg.getId(),
+			publishName: pkg.getPublishName() || pkg.getName(),
+			resources: {
+				images: {
+					count: images.length,
+					details: images.map(mapResource)
+				},
+				sounds: {
+					count: sounds.length,
+					details: sounds.map(mapResource)
+				},
+				fonts: {
+					count: fonts.length,
+					details: fonts.map(mapResource)
+				},
+				movieClips: {
+					count: movieClips.length,
+					details: movieClips.map(mapResource)
+				},
+				components: {
+					count: components.length,
+					details: components.map(mapResource)
+				}
+			},
+			componentDetails
+		};
+	});
+	return {
+		projectId: root.getProjectId(),
+		projectType: root.getProjectType(),
+		version: root.getVersion(),
+		packages,
+		totals
+	};
+}
+//#endregion
+//#region src/utils.ts
+/**
+* Wraps a transform function, assigning it a name for the transform stack.
+*/
+function createTransform(name, fn) {
+	Object.defineProperty(fn, "name", { value: name });
+	return fn;
+}
+//#endregion
+//#region src/validate.ts
+/**
+* Severity of a validation issue.
+*/
+let ValidationSeverity = /* @__PURE__ */ function(ValidationSeverity) {
+	ValidationSeverity["ERROR"] = "error";
+	ValidationSeverity["WARNING"] = "warning";
+	ValidationSeverity["INFO"] = "info";
+	return ValidationSeverity;
+}({});
+const VALIDATE_DEFAULTS = { throwOnError: false };
+/**
+* Validates a FairyGUI project for common issues:
+* - Missing resource IDs
+* - Broken `ui://` references (src pointing to non-existent resources)
+* - Empty components (no children)
+* - Controllers with no pages
+* - Duplicate resource IDs within a package
+*
+* The validation result is stored in `doc.getRoot().getExtras()._validation`.
+*
+* ```ts
+* await doc.transform(validate({ throwOnError: true }));
+* ```
+*/
+function validate(_options = {}) {
+	const options = {
+		...VALIDATE_DEFAULTS,
+		..._options
+	};
+	return createTransform("validate", (doc) => {
+		const issues = [];
+		const root = doc.getRoot();
+		if (!root.getProjectId()) issues.push({
+			severity: ValidationSeverity.WARNING,
+			message: "Project has no ID."
+		});
+		const globalResources = /* @__PURE__ */ new Map();
+		for (const pkg of root.listPackages()) {
+			if (!pkg.getId()) issues.push({
+				severity: ValidationSeverity.ERROR,
+				message: `Package "${pkg.getName()}" has no ID.`,
+				packageName: pkg.getName()
+			});
+			const idSet = /* @__PURE__ */ new Set();
+			for (const res of pkg.listResources()) {
+				const resId = res.getId();
+				if (!resId) {
+					issues.push({
+						severity: ValidationSeverity.WARNING,
+						message: `Resource "${res.getName()}" has no ID.`,
+						packageName: pkg.getName(),
+						resourceName: res.getName()
+					});
+					continue;
+				}
+				if (idSet.has(resId)) issues.push({
+					severity: ValidationSeverity.ERROR,
+					message: `Duplicate resource ID "${resId}" in package "${pkg.getName()}".`,
+					packageName: pkg.getName(),
+					resourceName: res.getName()
+				});
+				idSet.add(resId);
+				globalResources.set(`${pkg.getId()}${resId}`, `${pkg.getName()}/${res.getName()}`);
+			}
+			for (const comp of pkg.listComponents()) {
+				const children = comp.listChildren();
+				if (children.length === 0) issues.push({
+					severity: ValidationSeverity.INFO,
+					message: `Component "${comp.getName()}" has no children.`,
+					packageName: pkg.getName(),
+					componentName: comp.getName()
+				});
+				for (const ctrl of comp.listControllers()) if (ctrl.listPages().length === 0) issues.push({
+					severity: ValidationSeverity.WARNING,
+					message: `Controller "${ctrl.getName()}" in "${comp.getName()}" has no pages.`,
+					packageName: pkg.getName(),
+					componentName: comp.getName()
+				});
+				for (const child of children) {
+					const src = child.getSrc?.();
+					if (!src) continue;
+					if (src.startsWith("ui://")) {
+						const idPart = src.slice(5);
+						if (idPart.length > 8) {
+							const key = `${idPart.slice(0, 8)}${idPart.slice(8)}`;
+							if (!globalResources.has(key)) issues.push({
+								severity: ValidationSeverity.ERROR,
+								message: `Broken reference "${src}" in "${child.getName()}" (component "${comp.getName()}").`,
+								packageName: pkg.getName(),
+								componentName: comp.getName(),
+								resourceName: child.getName()
+							});
+						}
+					}
+				}
+			}
+		}
+		const errors = issues.filter((i) => i.severity === ValidationSeverity.ERROR);
+		const warnings = issues.filter((i) => i.severity === ValidationSeverity.WARNING);
+		const infos = issues.filter((i) => i.severity === ValidationSeverity.INFO);
+		const result = {
+			ok: errors.length === 0,
+			errors,
+			warnings,
+			infos
+		};
+		root.setExtras({
+			...root.getExtras(),
+			_validation: result
+		});
+		const logger = doc.getLogger();
+		if (errors.length) logger.warn(`validate: ${errors.length} error(s) found.`);
+		if (warnings.length) logger.warn(`validate: ${warnings.length} warning(s) found.`);
+		logger.info(`validate: ${issues.length} issue(s) total.`);
+		if (options.throwOnError && errors.length > 0) throw new Error(`Validation failed with ${errors.length} error(s):\n${errors.map((e) => `  - ${e.message}`).join("\n")}`);
+	});
+}
+//#endregion
+//#region src/prune.ts
+const PRUNE_DEFAULTS = {
+	emptyComponents: false,
+	unusedResources: true
+};
+/**
+* Removes unreferenced resources from the project.
+*
+* By default, removes image/sound/font/movieclip resources that are not
+* referenced by any component's display objects via `src` or `ui://` URLs.
+*
+* ```ts
+* await doc.transform(prune());
+* await doc.transform(prune({ emptyComponents: true }));
+* ```
+*/
+function prune(_options = {}) {
+	const options = {
+		...PRUNE_DEFAULTS,
+		..._options
+	};
+	return createTransform("prune", (doc) => {
+		const root = doc.getRoot();
+		const logger = doc.getLogger();
+		let pruned = 0;
+		if (options.unusedResources) {
+			const referencedIds = /* @__PURE__ */ new Set();
+			for (const pkg of root.listPackages()) for (const comp of pkg.listComponents()) for (const child of comp.listChildren()) {
+				const src = child.getSrc?.();
+				if (!src) continue;
+				if (src.startsWith("ui://")) {
+					const idPart = src.slice(5);
+					if (idPart.length > 8) referencedIds.add(idPart.slice(8));
+					else referencedIds.add(idPart);
+				} else referencedIds.add(src);
+			}
+			for (const pkg of root.listPackages()) {
+				const resources = pkg.listResources();
+				for (const res of resources) {
+					if (res.propertyType === "Component") continue;
+					const resId = res.getId?.() ?? "";
+					if (resId && !referencedIds.has(resId) && !res.getExported?.()) {
+						res.dispose();
+						pruned++;
+					}
+				}
+			}
+		}
+		if (options.emptyComponents) {
+			for (const pkg of root.listPackages()) for (const comp of pkg.listComponents()) if (comp.listChildren().length === 0 && !comp.getExported?.()) {
+				comp.dispose();
+				pruned++;
+			}
+		}
+		logger.info(`prune: Removed ${pruned} unused resource(s).`);
+	});
+}
+//#endregion
+//#region src/rename.ts
+/**
+* Renames a resource and optionally updates all references to it.
+*
+* This searches all display objects' `src` attributes across all packages
+* for `ui://` URLs that point to the renamed resource, and updates them
+* to reflect the new name (the resource ID doesn't change, so references
+* are already valid — but the name stored in package.xml is updated).
+*
+* ```ts
+* await doc.transform(rename({
+*   packageName: 'Basics',
+*   resourceName: 'Button',
+*   newName: 'PrimaryButton',
+* }));
+* ```
+*/
+function rename(options) {
+	const updateReferences = options.updateReferences ?? true;
+	return createTransform("rename", (doc) => {
+		const root = doc.getRoot();
+		const logger = doc.getLogger();
+		const pkg = root.listPackages().find((p) => p.getName() === options.packageName);
+		if (!pkg) {
+			logger.warn(`rename: Package "${options.packageName}" not found.`);
+			return;
+		}
+		const resource = pkg.listResources().find((r) => r.getName() === options.resourceName) || pkg.listComponents().find((c) => c.getName() === options.resourceName);
+		if (!resource) {
+			logger.warn(`rename: Resource "${options.resourceName}" not found in package "${options.packageName}".`);
+			return;
+		}
+		const oldName = resource.getName();
+		resource.setName(options.newName);
+		logger.info(`rename: Renamed "${oldName}" → "${options.newName}" in package "${options.packageName}".`);
+		if (updateReferences) logger.info(`rename: References use resource IDs — no src updates needed.`);
+	});
+}
+//#endregion
+//#region src/max-rects-compat.ts
+const NO_ROTATION = 2;
+const MAX_SCORE = 2147483647;
+const MAX_RECTS_METHOD = {
+	BestShortSideFit: 0,
+	BestLongSideFit: 1,
+	BestAreaFit: 2,
+	BottomLeftRule: 3,
+	ContactPointRule: 4
+};
+const COMPAT_NODE_RECT_FLAGS = {
+	DUPLICATE_PADDING: 1,
+	NO_ROTATION
+};
+var MaxRectsCompat = class MaxRectsCompat {
+	static helperRect = createNodeRect();
+	binWidth = 0;
+	binHeight = 0;
+	allowRotations = false;
+	usedRectangles = [];
+	freeRectangles = [];
+	init(width, height, allowRotations = false) {
+		this.binWidth = width;
+		this.binHeight = height;
+		this.allowRotations = allowRotations;
+		this.usedRectangles.length = 0;
+		this.freeRectangles.length = 0;
+		this.freeRectangles.push({
+			...createNodeRect(),
+			x: 0,
+			y: 0,
+			width,
+			height
+		});
+	}
+	insert(rect, method) {
+		const newNode = this.scoreRect(rect, method);
+		if (newNode.height === 0) return null;
+		const placed = cloneNodeRect(newNode);
+		this.placeRect(placed);
+		return placed;
+	}
+	pack(rects, method) {
+		const remaining = rects.map(cloneNodeRect);
+		while (remaining.length > 0) {
+			let bestIndex = -1;
+			const bestNode = createNodeRect();
+			bestNode.score1 = MAX_SCORE;
+			bestNode.score2 = MAX_SCORE;
+			for (let index = 0; index < remaining.length; index += 1) {
+				const candidate = this.scoreRect(remaining[index], method);
+				if (candidate.score1 < bestNode.score1 || candidate.score1 === bestNode.score1 && candidate.score2 < bestNode.score2) {
+					copyNodeRect(bestNode, candidate);
+					bestIndex = index;
+				}
+			}
+			if (bestIndex === -1) break;
+			this.placeRect(bestNode);
+			remaining.splice(bestIndex, 1);
+		}
+		const result = this.getResult();
+		result.remainingRects = remaining;
+		return result;
+	}
+	getResult() {
+		let width = 0;
+		let height = 0;
+		for (const rect of this.usedRectangles) {
+			width = Math.max(width, rect.x + rect.width);
+			height = Math.max(height, rect.y + rect.height);
+		}
+		return {
+			outputRects: this.usedRectangles.map(cloneNodeRect),
+			remainingRects: [],
+			occupancy: this.getOccupancy(),
+			width,
+			height
+		};
+	}
+	getOccupancy() {
+		let usedSurface = 0;
+		for (const rect of this.usedRectangles) usedSurface += rect.width * rect.height;
+		return usedSurface / (this.binWidth * this.binHeight);
+	}
+	placeRect(rect) {
+		for (let index = 0; index < this.freeRectangles.length; index += 1) if (this.splitFreeNode(this.freeRectangles[index], rect)) {
+			this.freeRectangles.splice(index, 1);
+			index -= 1;
+		}
+		this.pruneFreeList();
+		this.usedRectangles.push(rect);
+	}
+	scoreRect(rect, method) {
+		const helper = MaxRectsCompat.helperRect;
+		helper.height = 0;
+		let newNode;
+		switch (method) {
+			case MAX_RECTS_METHOD.BestShortSideFit:
+				newNode = this.findPositionForNewNodeBestShortSideFit(rect.width, rect.height, allowRotation(rect));
+				break;
+			case MAX_RECTS_METHOD.BestLongSideFit:
+				newNode = this.findPositionForNewNodeBestLongSideFit(rect.width, rect.height, allowRotation(rect));
+				break;
+			case MAX_RECTS_METHOD.BestAreaFit:
+				newNode = this.findPositionForNewNodeBestAreaFit(rect.width, rect.height, allowRotation(rect));
+				break;
+			case MAX_RECTS_METHOD.BottomLeftRule:
+				newNode = this.findPositionForNewNodeBottomLeft(rect.width, rect.height, allowRotation(rect));
+				break;
+			case MAX_RECTS_METHOD.ContactPointRule:
+				newNode = this.findPositionForNewNodeContactPoint(rect.width, rect.height, allowRotation(rect));
+				newNode.score1 = -newNode.score1;
+				break;
+			default:
+				newNode = helper;
+				break;
+		}
+		if (newNode.height === 0) {
+			newNode.score1 = MAX_SCORE;
+			newNode.score2 = MAX_SCORE;
+		}
+		newNode.index = rect.index;
+		newNode.subIndex = rect.subIndex;
+		newNode.flags = rect.flags;
+		newNode.sourceKind = rect.sourceKind;
+		return cloneNodeRect(newNode);
+	}
+	findPositionForNewNodeBottomLeft(width, height, allowRectRotation) {
+		const bestNode = MaxRectsCompat.helperRect;
+		bestNode.score1 = MAX_SCORE;
+		bestNode.score2 = 0;
+		for (const freeRect of this.freeRectangles) {
+			if (freeRect.width >= width && freeRect.height >= height) {
+				const topSideY = freeRect.y + height;
+				if (topSideY < bestNode.score1 || topSideY === bestNode.score1 && freeRect.x < bestNode.score2) setNodeRect(bestNode, freeRect.x, freeRect.y, width, height, false, topSideY, freeRect.x);
+			}
+			if (this.allowRotations && allowRectRotation && freeRect.width >= height && freeRect.height >= width) {
+				const topSideY = freeRect.y + width;
+				if (topSideY < bestNode.score1 || topSideY === bestNode.score1 && freeRect.x < bestNode.score2) setNodeRect(bestNode, freeRect.x, freeRect.y, height, width, true, topSideY, freeRect.x);
+			}
+		}
+		return bestNode;
+	}
+	findPositionForNewNodeBestShortSideFit(width, height, allowRectRotation) {
+		const bestNode = MaxRectsCompat.helperRect;
+		bestNode.score1 = MAX_SCORE;
+		bestNode.score2 = 0;
+		for (const freeRect of this.freeRectangles) {
+			if (freeRect.width >= width && freeRect.height >= height) {
+				const leftoverHoriz = Math.abs(freeRect.width - width);
+				const leftoverVert = Math.abs(freeRect.height - height);
+				const shortSideFit = Math.min(leftoverHoriz, leftoverVert);
+				const longSideFit = Math.max(leftoverHoriz, leftoverVert);
+				if (shortSideFit < bestNode.score1 || shortSideFit === bestNode.score1 && longSideFit < bestNode.score2) setNodeRect(bestNode, freeRect.x, freeRect.y, width, height, false, shortSideFit, longSideFit);
+			}
+			if (this.allowRotations && allowRectRotation && freeRect.width >= height && freeRect.height >= width) {
+				const leftoverHoriz = Math.abs(freeRect.width - height);
+				const leftoverVert = Math.abs(freeRect.height - width);
+				const shortSideFit = Math.min(leftoverHoriz, leftoverVert);
+				const longSideFit = Math.max(leftoverHoriz, leftoverVert);
+				if (shortSideFit < bestNode.score1 || shortSideFit === bestNode.score1 && longSideFit < bestNode.score2) setNodeRect(bestNode, freeRect.x, freeRect.y, height, width, true, shortSideFit, longSideFit);
+			}
+		}
+		return bestNode;
+	}
+	findPositionForNewNodeBestLongSideFit(width, height, allowRectRotation) {
+		const bestNode = MaxRectsCompat.helperRect;
+		bestNode.score1 = 0;
+		bestNode.score2 = MAX_SCORE;
+		for (const freeRect of this.freeRectangles) {
+			if (freeRect.width >= width && freeRect.height >= height) {
+				const leftoverHoriz = Math.abs(freeRect.width - width);
+				const leftoverVert = Math.abs(freeRect.height - height);
+				const shortSideFit = Math.min(leftoverHoriz, leftoverVert);
+				const longSideFit = Math.max(leftoverHoriz, leftoverVert);
+				if (longSideFit < bestNode.score2 || longSideFit === bestNode.score2 && shortSideFit < bestNode.score1) setNodeRect(bestNode, freeRect.x, freeRect.y, width, height, false, shortSideFit, longSideFit);
+			}
+			if (this.allowRotations && allowRectRotation && freeRect.width >= height && freeRect.height >= width) {
+				const leftoverHoriz = Math.abs(freeRect.width - height);
+				const leftoverVert = Math.abs(freeRect.height - width);
+				const shortSideFit = Math.min(leftoverHoriz, leftoverVert);
+				const longSideFit = Math.max(leftoverHoriz, leftoverVert);
+				if (longSideFit < bestNode.score2 || longSideFit === bestNode.score2 && shortSideFit < bestNode.score1) setNodeRect(bestNode, freeRect.x, freeRect.y, height, width, true, shortSideFit, longSideFit);
+			}
+		}
+		return bestNode;
+	}
+	findPositionForNewNodeBestAreaFit(width, height, allowRectRotation) {
+		const bestNode = MaxRectsCompat.helperRect;
+		bestNode.score1 = MAX_SCORE;
+		bestNode.score2 = 0;
+		for (const freeRect of this.freeRectangles) {
+			const areaFit = freeRect.width * freeRect.height - width * height;
+			if (freeRect.width >= width && freeRect.height >= height) {
+				const leftoverHoriz = Math.abs(freeRect.width - width);
+				const leftoverVert = Math.abs(freeRect.height - height);
+				const shortSideFit = Math.min(leftoverHoriz, leftoverVert);
+				if (areaFit < bestNode.score1 || areaFit === bestNode.score1 && shortSideFit < bestNode.score2) setNodeRect(bestNode, freeRect.x, freeRect.y, width, height, false, areaFit, shortSideFit);
+			}
+			if (this.allowRotations && allowRectRotation && freeRect.width >= height && freeRect.height >= width) {
+				const leftoverHoriz = Math.abs(freeRect.width - height);
+				const leftoverVert = Math.abs(freeRect.height - width);
+				const shortSideFit = Math.min(leftoverHoriz, leftoverVert);
+				if (areaFit < bestNode.score1 || areaFit === bestNode.score1 && shortSideFit < bestNode.score2) setNodeRect(bestNode, freeRect.x, freeRect.y, height, width, true, areaFit, shortSideFit);
+			}
+		}
+		return bestNode;
+	}
+	findPositionForNewNodeContactPoint(width, height, allowRectRotation) {
+		const bestNode = MaxRectsCompat.helperRect;
+		bestNode.score1 = -1;
+		bestNode.score2 = 0;
+		for (const freeRect of this.freeRectangles) {
+			if (freeRect.width >= width && freeRect.height >= height) {
+				const score = this.contactPointScoreNode(freeRect.x, freeRect.y, width, height);
+				if (score > bestNode.score1) setNodeRect(bestNode, freeRect.x, freeRect.y, width, height, false, score, bestNode.score2);
+			}
+			if (this.allowRotations && allowRectRotation && freeRect.width >= height && freeRect.height >= width) {
+				const score = this.contactPointScoreNode(freeRect.x, freeRect.y, height, width);
+				if (score > bestNode.score1) setNodeRect(bestNode, freeRect.x, freeRect.y, height, width, true, score, bestNode.score2);
+			}
+		}
+		return bestNode;
+	}
+	contactPointScoreNode(x, y, width, height) {
+		let score = 0;
+		if (x === 0 || x + width === this.binWidth) score += height;
+		if (y === 0 || y + height === this.binHeight) score += width;
+		for (const rect of this.usedRectangles) {
+			if (rect.x === x + width || rect.x + rect.width === x) score += commonIntervalLength(rect.y, rect.y + rect.height, y, y + height);
+			if (rect.y === y + height || rect.y + rect.height === y) score += commonIntervalLength(rect.x, rect.x + rect.width, x, x + width);
+		}
+		return score;
+	}
+	splitFreeNode(freeNode, usedNode) {
+		if (usedNode.x >= freeNode.x + freeNode.width || usedNode.x + usedNode.width <= freeNode.x || usedNode.y >= freeNode.y + freeNode.height || usedNode.y + usedNode.height <= freeNode.y) return false;
+		if (usedNode.x < freeNode.x + freeNode.width && usedNode.x + usedNode.width > freeNode.x) {
+			if (usedNode.y > freeNode.y && usedNode.y < freeNode.y + freeNode.height) {
+				const newNode = cloneNodeRect(freeNode);
+				newNode.height = usedNode.y - newNode.y;
+				this.freeRectangles.push(newNode);
+			}
+			if (usedNode.y + usedNode.height < freeNode.y + freeNode.height) {
+				const newNode = cloneNodeRect(freeNode);
+				newNode.y = usedNode.y + usedNode.height;
+				newNode.height = freeNode.y + freeNode.height - (usedNode.y + usedNode.height);
+				this.freeRectangles.push(newNode);
+			}
+		}
+		if (usedNode.y < freeNode.y + freeNode.height && usedNode.y + usedNode.height > freeNode.y) {
+			if (usedNode.x > freeNode.x && usedNode.x < freeNode.x + freeNode.width) {
+				const newNode = cloneNodeRect(freeNode);
+				newNode.width = usedNode.x - newNode.x;
+				this.freeRectangles.push(newNode);
+			}
+			if (usedNode.x + usedNode.width < freeNode.x + freeNode.width) {
+				const newNode = cloneNodeRect(freeNode);
+				newNode.x = usedNode.x + usedNode.width;
+				newNode.width = freeNode.x + freeNode.width - (usedNode.x + usedNode.width);
+				this.freeRectangles.push(newNode);
+			}
+		}
+		return true;
+	}
+	pruneFreeList() {
+		let length = this.freeRectangles.length;
+		let left = 0;
+		while (left < length) {
+			let right = left + 1;
+			while (right < length) {
+				if (isContainedIn(this.freeRectangles[left], this.freeRectangles[right])) {
+					this.freeRectangles.splice(left, 1);
+					length -= 1;
+					break;
+				}
+				if (isContainedIn(this.freeRectangles[right], this.freeRectangles[left])) {
+					this.freeRectangles.splice(right, 1);
+					length -= 1;
+				}
+				right += 1;
+			}
+			left += 1;
+		}
+	}
+};
+function createNodeRect() {
+	return {
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0,
+		rotated: false,
+		index: 0,
+		subIndex: -1,
+		flags: 0,
+		score1: 0,
+		score2: 0,
+		sourceKind: void 0
+	};
+}
+function cloneNodeRect(rect) {
+	return { ...rect };
+}
+function copyNodeRect(target, source) {
+	target.x = source.x;
+	target.y = source.y;
+	target.width = source.width;
+	target.height = source.height;
+	target.rotated = source.rotated;
+	target.index = source.index;
+	target.subIndex = source.subIndex;
+	target.flags = source.flags;
+	target.score1 = source.score1;
+	target.score2 = source.score2;
+	target.sourceKind = source.sourceKind;
+}
+function setNodeRect(target, x, y, width, height, rotated, score1, score2) {
+	target.x = x;
+	target.y = y;
+	target.width = width;
+	target.height = height;
+	target.rotated = rotated;
+	target.score1 = score1;
+	target.score2 = score2;
+}
+function allowRotation(rect) {
+	return (rect.flags & NO_ROTATION) === 0;
+}
+function commonIntervalLength(startA, endA, startB, endB) {
+	if (endA < startB || endB < startA) return 0;
+	return Math.min(endA, endB) - Math.max(startA, startB);
+}
+function isContainedIn(left, right) {
+	return left.x >= right.x && left.y >= right.y && left.x + left.width <= right.x + right.width && left.y + left.height <= right.y + right.height;
+}
+//#endregion
+//#region src/max-rects-packer-compat.ts
+const DEFAULT_SETTINGS = {
+	pot: true,
+	mof: true,
+	padding: 2,
+	rotation: false,
+	minWidth: 16,
+	minHeight: 16,
+	maxWidth: 2048,
+	maxHeight: 2048,
+	square: false,
+	fast: true,
+	edgePadding: false,
+	duplicatePadding: false,
+	multiPage: false,
+	preserveInputOrderOnTie: false
+};
+let sizeScheme = null;
+var BinarySearchCompat = class {
+	min;
+	max;
+	fuzziness;
+	low;
+	high;
+	current;
+	constructor(min, max, fuzziness, pot, mof) {
+		this.pot = pot;
+		this.mof = mof;
+		this.fuzziness = pot ? 0 : fuzziness;
+		if (pot) {
+			this.min = Math.log(MaxRectsPackerCompat.getNextPowerOfTwo(min)) / Math.log(2);
+			this.max = Math.log(MaxRectsPackerCompat.getNextPowerOfTwo(max)) / Math.log(2);
+		} else if (mof) {
+			this.min = min / 4;
+			this.max = max / 4;
+		} else {
+			this.min = min;
+			this.max = max;
+		}
+		this.low = this.min;
+		this.high = this.max;
+		this.current = this.min;
+	}
+	reset() {
+		this.low = this.min;
+		this.high = this.max;
+		this.current = this.low + this.high >>> 1;
+		return this.getCurrent();
+	}
+	next(failed) {
+		if (this.low >= this.high) return -1;
+		if (failed) this.low = this.current + 1;
+		else this.high = this.current - 1;
+		this.current = this.low + this.high >>> 1;
+		if (Math.abs(this.low - this.high) < this.fuzziness) return -1;
+		return this.getCurrent();
+	}
+	getCurrent() {
+		if (this.pot) return Math.trunc(Math.pow(2, this.current));
+		if (this.mof) return this.current * 4;
+		return this.current;
+	}
+};
+var MaxRectsPackerCompat = class MaxRectsPackerCompat {
+	maxRects = new MaxRectsCompat();
+	settings;
+	constructor(settings = {}) {
+		this.settings = {
+			...DEFAULT_SETTINGS,
+			...settings
+		};
+	}
+	static getNextPowerOfTwo(value) {
+		if (Number.isInteger(value) && value > 0 && (value & value - 1) === 0) return value;
+		let result = 1;
+		const target = value - 1e-9;
+		while (result < target) result <<= 1;
+		return result;
+	}
+	pack(inputRects) {
+		const rects = inputRects.map(cloneCompatRect);
+		if (this.settings.fast) vectorSortCompat(rects, this.settings.preserveInputOrderOnTie ? this.settings.rotation ? compareNodeRectStable : compareNodeRect2Stable : this.settings.rotation ? compareNodeRect : compareNodeRect2);
+		const padding = this.settings.padding;
+		let hasDuplicatePadding = false;
+		for (const rect of rects) {
+			if (duplicatePadding(rect)) hasDuplicatePadding = true;
+			if (this.settings.maxWidth - rect.width > padding || duplicatePadding(rect)) rect.width += padding;
+			if (this.settings.maxHeight - rect.height > padding || duplicatePadding(rect)) rect.height += padding;
+		}
+		const pages = [];
+		let remaining = rects;
+		while (remaining.length > 0) {
+			const page = this.packPage(remaining);
+			if (!page) return null;
+			if (this.settings.pot) {
+				page.width = MaxRectsPackerCompat.getNextPowerOfTwo(page.width);
+				page.height = MaxRectsPackerCompat.getNextPowerOfTwo(page.height);
+			} else if (this.settings.mof) {
+				page.width = Math.ceil(page.width / 4) * 4;
+				page.height = Math.ceil(page.height / 4) * 4;
+			}
+			if (this.settings.square) {
+				const side = Math.max(page.width, page.height);
+				page.width = side;
+				page.height = side;
+			}
+			pages.push(page);
+			remaining = page.remainingRects.map(cloneCompatRect);
+		}
+		pages.sort(comparePage);
+		for (const page of pages) {
+			for (const rect of page.outputRects) {
+				shrinkRectForPadding(rect, padding, this.settings.maxWidth, this.settings.maxHeight);
+				if (hasDuplicatePadding) {
+					if (rect.width !== page.width) rect.x += Math.floor(padding / 2);
+					if (rect.height !== page.height) rect.y += Math.floor(padding / 2);
+				}
+			}
+			for (const rect of page.remainingRects) shrinkRectForPadding(rect, padding, this.settings.maxWidth, this.settings.maxHeight);
+		}
+		return pages;
+	}
+	packPage(rects) {
+		if (!sizeScheme) sizeScheme = initSizeScheme();
+		const edgePadding = this.settings.edgePadding ? this.settings.padding : 0;
+		let totalArea = 0;
+		for (const rect of rects) totalArea += rect.width * rect.height;
+		const candidates = sizeScheme.filter((entry) => entry.area >= totalArea && entry.width <= this.settings.maxWidth && entry.height <= this.settings.maxHeight);
+		if (candidates.length === 0) candidates.push({
+			width: this.settings.maxWidth,
+			height: this.settings.maxHeight,
+			area: 0,
+			aspectRatio: 0,
+			len: 0
+		});
+		let page = null;
+		let selectedWidth = 0;
+		let selectedHeight = 0;
+		for (let index = 0; index < candidates.length; index += 1) {
+			selectedWidth = candidates[index].width;
+			selectedHeight = candidates[index].height;
+			page = this.packAtSize(index !== candidates.length - 1, selectedWidth - edgePadding, selectedHeight - edgePadding, rects);
+			if (page) break;
+		}
+		if (page && !this.settings.pot && page.remainingRects.length === 0) {
+			let bestRefined = null;
+			if (this.settings.square) {
+				const search = new BinarySearchCompat(Math.min(selectedWidth / 2, selectedHeight / 2), Math.max(selectedWidth, selectedHeight), this.settings.fast ? 25 : 15, this.settings.pot, this.settings.mof);
+				let current = search.reset();
+				while (current !== -1) {
+					const refined = this.packAtSize(true, current - edgePadding, current - edgePadding, rects);
+					bestRefined = getBestPage(bestRefined, refined);
+					current = search.next(refined == null);
+				}
+			} else {
+				const widthSearch = new BinarySearchCompat(selectedWidth / 2, selectedWidth, this.settings.fast ? 25 : 15, this.settings.pot, this.settings.mof);
+				const heightSearch = new BinarySearchCompat(selectedHeight / 2, selectedHeight, this.settings.fast ? 25 : 15, this.settings.pot, this.settings.mof);
+				let currentHeight = heightSearch.reset();
+				let currentWidth = widthSearch.reset();
+				while (true) {
+					let bestForHeight = null;
+					while (currentWidth !== -1) {
+						const refined = this.packAtSize(true, currentWidth - edgePadding, currentHeight - edgePadding, rects);
+						bestForHeight = getBestPage(bestForHeight, refined);
+						currentWidth = widthSearch.next(refined == null);
+					}
+					bestRefined = getBestPage(bestRefined, bestForHeight);
+					currentHeight = heightSearch.next(bestForHeight == null);
+					if (currentHeight === -1) break;
+					currentWidth = widthSearch.reset();
+				}
+			}
+			if (bestRefined) page = bestRefined;
+		}
+		return page;
+	}
+	packAtSize(requireFullFit, width, height, rects) {
+		const methods = [
+			MAX_RECTS_METHOD.BestShortSideFit,
+			MAX_RECTS_METHOD.BestLongSideFit,
+			MAX_RECTS_METHOD.BestAreaFit
+		];
+		let best = null;
+		for (const method of methods) {
+			this.maxRects.init(width, height, this.settings.rotation);
+			let page;
+			if (!this.settings.fast) page = this.maxRects.pack(rects, method);
+			else {
+				const remaining = [];
+				let index = 0;
+				while (index < rects.length) {
+					if (this.maxRects.insert(rects[index], method) == null) {
+						while (index < rects.length) {
+							remaining.push(cloneCompatRect(rects[index]));
+							index += 1;
+						}
+						break;
+					}
+					index += 1;
+				}
+				page = this.maxRects.getResult();
+				page.remainingRects = remaining;
+			}
+			if (!(requireFullFit && page.remainingRects.length > 0) && page.outputRects.length !== 0) best = getBestPage(best, page);
+		}
+		return best;
+	}
+};
+function vectorSortCompat(items, compare) {
+	if (items.length <= 1) return;
+	avmQuickSortCompat(items, 0, items.length - 1, compare);
+}
+function avmQuickSortCompat(items, initialLo, initialHi, compare) {
+	if (initialLo >= initialHi) return;
+	const stack = [];
+	let lo = initialLo;
+	let hi = initialHi;
+	while (true) {
+		const size = hi - lo + 1;
+		if (size < 4) {
+			if (size === 3) {
+				if (compare(items[lo], items[lo + 1]) > 0) {
+					swapCompat(items, lo, lo + 1);
+					if (compare(items[lo + 1], items[lo + 2]) > 0) {
+						swapCompat(items, lo + 1, lo + 2);
+						if (compare(items[lo], items[lo + 1]) > 0) swapCompat(items, lo, lo + 1);
+					}
+				} else if (compare(items[lo + 1], items[lo + 2]) > 0) {
+					swapCompat(items, lo + 1, lo + 2);
+					if (compare(items[lo], items[lo + 1]) > 0) swapCompat(items, lo, lo + 1);
+				}
+			} else if (size === 2 && compare(items[lo], items[lo + 1]) > 0) swapCompat(items, lo, lo + 1);
+		} else {
+			swapCompat(items, lo + (size >> 1), lo);
+			let left = lo;
+			let right = hi + 1;
+			while (true) {
+				do
+					left += 1;
+				while (left <= hi && compare(items[left], items[lo]) <= 0);
+				do
+					right -= 1;
+				while (right > lo && compare(items[right], items[lo]) >= 0);
+				if (right < left) break;
+				swapCompat(items, left, right);
+			}
+			swapCompat(items, lo, right);
+			if (right - 1 - lo >= hi - left) {
+				if (lo + 1 < right) stack.push({
+					lo,
+					hi: right - 1
+				});
+				if (left < hi) {
+					lo = left;
+					continue;
+				}
+			} else {
+				if (left < hi) stack.push({
+					lo: left,
+					hi
+				});
+				if (lo + 1 < right) {
+					hi = right - 1;
+					continue;
+				}
+			}
+		}
+		if (stack.length === 0) return;
+		const frame = stack.pop();
+		lo = frame.lo;
+		hi = frame.hi;
+	}
+}
+function swapCompat(items, left, right) {
+	const value = items[left];
+	items[left] = items[right];
+	items[right] = value;
+}
+function initSizeScheme() {
+	const result = [];
+	for (let w = 5; w <= 13; w += 1) for (let h = 5; h <= 13; h += 1) {
+		const width = Math.pow(2, w);
+		const height = Math.pow(2, h);
+		const area = width * height;
+		const aspectRatio = width > height ? width / height : height / width;
+		result.push({
+			width,
+			height,
+			area,
+			aspectRatio,
+			len: Math.max(width, height)
+		});
+	}
+	result.sort(compareSizeScheme);
+	return result;
+}
+function compareSizeScheme(left, right) {
+	if (left.len < right.len) return -1;
+	if (left.len > right.len) return 1;
+	if (left.area < right.area) return -1;
+	if (left.area > right.area) return 1;
+	if (left.aspectRatio < right.aspectRatio) return -1;
+	if (left.aspectRatio > right.aspectRatio) return 1;
+	if (left.width > left.height) return -1;
+	if (right.width > right.height) return 1;
+	return 0;
+}
+function getBestPage(left, right) {
+	if (!left) return right;
+	if (!right) return left;
+	return left.occupancy > right.occupancy ? left : right;
+}
+function comparePage(left, right) {
+	return right.outputRects.length - left.outputRects.length;
+}
+function compareNodeRect(left, right) {
+	const leftEdge = left.width > left.height ? left.width : left.height;
+	return (right.width > right.height ? right.width : right.height) - leftEdge;
+}
+function compareNodeRectStable(left, right) {
+	const delta = compareNodeRect(left, right);
+	if (delta !== 0) return delta;
+	if (left.sourceKind === "movieclip-frame" && right.sourceKind === "movieclip-frame") {
+		const areaDelta = right.width * right.height - left.width * left.height;
+		if (areaDelta !== 0) return areaDelta;
+		const widthDelta = right.width - left.width;
+		if (widthDelta !== 0) return widthDelta;
+	}
+	return left.index - right.index;
+}
+function compareNodeRect2(left, right) {
+	return right.width - left.width;
+}
+function compareNodeRect2Stable(left, right) {
+	const delta = compareNodeRect2(left, right);
+	if (delta !== 0) return delta;
+	if (left.sourceKind === "movieclip-frame" && right.sourceKind === "movieclip-frame") {
+		const areaDelta = right.width * right.height - left.width * left.height;
+		if (areaDelta !== 0) return areaDelta;
+		const heightDelta = right.height - left.height;
+		if (heightDelta !== 0) return heightDelta;
+	}
+	return left.index - right.index;
+}
+function duplicatePadding(rect) {
+	return (rect.flags & COMPAT_NODE_RECT_FLAGS.DUPLICATE_PADDING) !== 0;
+}
+function shrinkRectForPadding(rect, padding, maxWidth, maxHeight) {
+	if (!rect.rotated) {
+		if (maxWidth - rect.width > padding || duplicatePadding(rect)) rect.width -= padding;
+		if (maxHeight - rect.height > padding || duplicatePadding(rect)) rect.height -= padding;
+	} else {
+		if (maxHeight - rect.width > padding || duplicatePadding(rect)) rect.width -= padding;
+		if (maxWidth - rect.height > padding || duplicatePadding(rect)) rect.height -= padding;
+	}
+}
+function cloneCompatRect(rect) {
+	return { ...rect };
+}
+//#endregion
+//#region src/atlas.ts
+const ATLAS_DEFAULTS = {
+	maxSize: 2048,
+	fast: true,
+	allowRotation: true,
+	padding: 1,
+	powerOfTwo: false,
+	square: false,
+	multiPage: true,
+	trimImage: false,
+	preserveInputOrderOnTie: false,
+	directSingleImageOutput: false,
+	extractAlpha: false,
+	separatedAtlasForBranch: false
+};
+function getPublishedItemId(resource) {
+	return (resource.getExtras() ?? {})._publishedId ?? resource.getId();
+}
+function resolveFontFileName(fontName) {
+	return /\.fnt$/i.test(fontName) ? fontName : `${fontName}.fnt`;
+}
+async function resolveEditorCompatibleResourceOrder(pkg, allResources, options) {
+	const pkgId = pkg.getId();
+	const resourceMap = new Map(allResources.map((resource) => [resource.getId(), resource]));
+	const ordered = [];
+	const added = /* @__PURE__ */ new Set();
+	const componentStack = [];
+	async function addResource(resource) {
+		if (!resource) return;
+		const resourceId = resource.getId();
+		if (!resourceId || added.has(resourceId)) return;
+		added.add(resourceId);
+		ordered.push(resource);
+		if (isFontResource$1(resource)) {
+			await addResource(resourceMap.get(resource.getTextureId?.() ?? ""));
+			if (options.readFileRaw && options.basePath) {
+				const fontName = resolveFontFileName(resource.getName());
+				const fontPath = resource.getPath() ?? "/";
+				const fntFile = `${options.basePath}/${pkg.getName()}${fontPath}${fontName}`;
+				try {
+					const fntData = await options.readFileRaw(fntFile);
+					const fntText = new TextDecoder().decode(fntData);
+					for (const line of fntText.split(/\r?\n/)) {
+						const imgMatch = line.match(/\bimg=(\w+)/);
+						if (imgMatch) await addResource(resourceMap.get(imgMatch[1] ?? ""));
+					}
+				} catch {}
+			}
+		}
+		if (isComponentResource$1(resource)) componentStack.push(resource);
+	}
+	async function addResourceByLocalUiUrl(value) {
+		if (!value || typeof value !== "string" || !value.startsWith("ui://")) return;
+		const normalized = value.slice(5).split(",")[0] ?? "";
+		if (!normalized) return;
+		let resourceId = "";
+		const slashIndex = normalized.indexOf("/");
+		if (slashIndex >= 0) {
+			if (normalized.slice(0, slashIndex) !== pkgId) return;
+			resourceId = normalized.slice(slashIndex + 1);
+		} else if (normalized.length > 8) {
+			if (normalized.slice(0, 8) !== pkgId) return;
+			resourceId = normalized.slice(8);
+		}
+		if (!resourceId) return;
+		await addResource(resourceMap.get(resourceId));
+	}
+	async function addGearIconResources(gear) {
+		if (gear.getGearType?.() !== _openfairygui_core.GearType.Icon) return;
+		const values = gear.getValues?.();
+		if (typeof values === "string" && values) for (const value of values.split("|")) await addResourceByLocalUiUrl(value.trim());
+		const defaultValue = gear.getDefaultValue?.();
+		if (typeof defaultValue === "string") await addResourceByLocalUiUrl(defaultValue);
+	}
+	for (const resource of allResources) if (resource.getExported()) await addResource(resource);
+	while (componentStack.length > 0) {
+		const component = componentStack.pop();
+		if (!component) continue;
+		for (const child of component.listChildren()) {
+			const refChild = child;
+			await addResource(resourceMap.get(refChild.getSrc?.() ?? ""));
+			for (const ref of [
+				refChild.getUrl?.(),
+				refChild.getDefaultItem?.(),
+				refChild.getIcon?.(),
+				refChild.getSelectedIcon?.(),
+				refChild.getFont?.(),
+				refChild.getDropdown?.(),
+				refChild.getVtScrollBarRes?.(),
+				refChild.getHzScrollBarRes?.(),
+				refChild.getHeaderRes?.(),
+				refChild.getFooterRes?.(),
+				refChild.getSound?.(),
+				refChild.getInstanceIcon?.(),
+				refChild.getInstanceSelectedIcon?.()
+			]) await addResourceByLocalUiUrl(ref);
+			for (const item of refChild.getInstanceComboItems?.() ?? []) await addResourceByLocalUiUrl(item.icon ?? void 0);
+			for (const item of refChild.getListItems?.() ?? []) {
+				await addResourceByLocalUiUrl(item.icon ?? void 0);
+				await addResourceByLocalUiUrl(item.url ?? void 0);
+			}
+			for (const gear of refChild.listGears?.() ?? []) await addGearIconResources(gear);
+		}
+		for (const ref of [
+			component.getDropdown?.(),
+			component.getVtScrollBarRes?.(),
+			component.getHzScrollBarRes?.(),
+			component.getHeaderRes?.(),
+			component.getFooterRes?.(),
+			component.getSound?.()
+		]) await addResourceByLocalUiUrl(ref);
+		for (const transition of component.listTransitions?.() ?? []) for (const item of transition.listItems?.() ?? []) {
+			const actionType = item.getActionType?.();
+			if (actionType !== _openfairygui_core.TransitionActionType.Sound && actionType !== _openfairygui_core.TransitionActionType.Icon) continue;
+			for (const value of [item.getStartValue?.(), item.getEndValue?.()]) if (Array.isArray(value)) {
+				for (const entry of value) if (typeof entry === "string") await addResourceByLocalUiUrl(entry);
+			} else if (typeof value === "string") await addResourceByLocalUiUrl(value);
+		}
+	}
+	for (const resource of allResources) await addResource(resource);
+	return ordered;
+}
+/**
+* Packs image resources into texture atlases.
+*
+* This transform performs MaxRects bin-packing on all ImageResource items
+* within each package, creating Atlas and Sprite property nodes. When an
+* `encoder` (sharp) is provided, it also composites the actual PNG files.
+*
+* When `trimImage` is enabled and encoder is available, transparent pixels
+* at image edges are trimmed before packing. The trimmed offset and original
+* dimensions are stored in the Sprite nodes for runtime reconstruction.
+*
+* ```ts
+* import sharp from 'sharp';
+* await doc.transform(atlas({
+*   encoder: sharp,
+*   maxSize: 2048,
+*   trimImage: true,
+*   basePath: './assets/',
+*   outputPath: './dist/',
+* }));
+* ```
+*/
+function atlas(_options = {}) {
+	const options = {
+		...ATLAS_DEFAULTS,
+		..._options
+	};
+	return createTransform("atlas", async (doc) => {
+		const root = doc.getRoot();
+		const logger = doc.getLogger();
+		const encoder = options.encoder;
+		const doTrim = options.trimImage && !!encoder && !!options.basePath;
+		for (const pkg of root.listPackages()) {
+			const selectedPublishIds = new Set((pkg.getExtras() ?? {}).publishedResourceIds ?? []);
+			const allResources = selectedPublishIds.size > 0 ? pkg.listResources().filter((resource) => selectedPublishIds.has(resource.getId())) : pkg.listResources();
+			const orderedResources = await resolveEditorCompatibleResourceOrder(pkg, allResources, options);
+			const orderedAllResources = sortResourcesByOrder(allResources, new Map(orderedResources.map((resource, index) => [resource.getId(), index])), new Map(allResources.map((resource, index) => [resource.getId(), index])));
+			if (!allResources.some((resource) => isPackableResource(resource))) continue;
+			const inputs = [];
+			const referencedIds = /* @__PURE__ */ new Set();
+			const resourceMap = /* @__PURE__ */ new Map();
+			for (const res of allResources) {
+				const id = res.getId();
+				if (id) resourceMap.set(id, res);
+			}
+			function collectRefs(component, visited) {
+				for (const child of component.listChildren()) {
+					const refChild = child;
+					const src = refChild.getSrc?.();
+					if (src && !visited.has(src)) {
+						referencedIds.add(src);
+						visited.add(src);
+						const srcRes = resourceMap.get(src);
+						if (srcRes && isComponentResource$1(srcRes)) collectRefs(srcRes, visited);
+					}
+					for (const ref of [
+						refChild.getIcon?.(),
+						refChild.getSelectedIcon?.(),
+						refChild.getFont?.(),
+						refChild.getDropdown?.(),
+						refChild.getInstanceIcon?.(),
+						refChild.getInstanceSelectedIcon?.(),
+						refChild.getVtScrollBarRes?.(),
+						refChild.getHzScrollBarRes?.(),
+						refChild.getHeaderRes?.(),
+						refChild.getFooterRes?.(),
+						refChild.getUrl?.()
+					]) addUiResourceRef(referencedIds, ref);
+					addUiResourceRefsFromText(referencedIds, refChild.getText?.());
+					for (const item of refChild.getInstanceComboItems?.() ?? []) addUiResourceRef(referencedIds, item.icon ?? void 0);
+					for (const item of refChild.getListItems?.() ?? []) addUiResourceRef(referencedIds, item.icon ?? void 0);
+					for (const gear of refChild.listGears?.() ?? []) {
+						addUiResourceRefsFromUnknown(referencedIds, gear.getValues?.());
+						addUiResourceRefsFromUnknown(referencedIds, gear.getDefaultValue?.());
+					}
+				}
+				for (const transition of component.listTransitions?.() ?? []) for (const item of transition.listItems?.() ?? []) {
+					addUiResourceRefsFromUnknown(referencedIds, item.getStartValue?.());
+					addUiResourceRefsFromUnknown(referencedIds, item.getEndValue?.());
+				}
+			}
+			for (const res of orderedAllResources) {
+				if (isComponentResource$1(res)) collectRefs(res, /* @__PURE__ */ new Set());
+				if (isSkeletonResource$1(res) && referencedIds.has(res.getId())) {
+					for (const requiredId of res.getRequireIds()) if (requiredId) referencedIds.add(requiredId);
+				}
+				if (isFontResource$1(res)) {
+					const textureId = res.getTextureId?.() ?? "";
+					if (textureId) referencedIds.add(textureId);
+					if (options.readFileRaw && options.basePath) {
+						const fontName = resolveFontFileName(res.getName());
+						const fontPath = res.getPath() ?? "/";
+						const fntFile = `${options.basePath}/${pkg.getName()}${fontPath}${fontName}`;
+						try {
+							const fntData = await options.readFileRaw(fntFile);
+							const fntText = new TextDecoder().decode(fntData);
+							for (const line of fntText.split(/\r?\n/)) {
+								const match = line.match(/img=(\w+)/);
+								if (match) referencedIds.add(match[1]);
+							}
+						} catch {}
+					}
+				}
+			}
+			for (const res of orderedAllResources) if (isImageResource$1(res)) {
+				const resId = res.getId();
+				if (!res.getExported() && referencedIds.size > 0 && !referencedIds.has(resId)) continue;
+				await _collectImage(res, pkg, inputs, encoder, options, doTrim, logger);
+			} else if (isMovieClipResource$1(res)) {
+				const resId = res.getId();
+				if (!res.getExported() && referencedIds.size > 0 && !referencedIds.has(resId)) continue;
+				await _collectMovieClipFrames(doc, res, pkg, inputs, encoder, options, logger);
+			} else if (isFontResource$1(res)) {
+				const resId = res.getId();
+				if (!res.getExported() && referencedIds.size > 0 && !referencedIds.has(resId)) continue;
+				await _collectFontTexture(doc, res, pkg, options);
+			}
+			if (inputs.length === 0) continue;
+			const branchGroups = buildBranchAtlasGroups(doc, inputs, options);
+			let totalPageCount = 0;
+			let usedDirectOutput = false;
+			for (const group of branchGroups) {
+				const directOutput = resolveDirectImageOutput(group.inputs, options);
+				if (directOutput) {
+					await emitDirectImageOutput(doc, pkg, directOutput, encoder, options, logger, group.branchName, group.branchOrdinal);
+					usedDirectOutput = true;
+					totalPageCount += 1;
+					continue;
+				}
+				const hasDuplicatePadding = group.inputs.some((i) => {
+					return isImageResource$1(i.resource) && i.resource.getDuplicatePadding?.() === true;
+				});
+				const pages = new MaxRectsPackerCompat({
+					pot: options.powerOfTwo,
+					mof: !options.powerOfTwo,
+					padding: options.padding,
+					rotation: options.allowRotation,
+					minWidth: 16,
+					minHeight: 16,
+					maxWidth: options.maxSize,
+					maxHeight: options.maxSize,
+					square: options.square,
+					fast: options.fast,
+					edgePadding: false,
+					duplicatePadding: hasDuplicatePadding,
+					multiPage: options.multiPage,
+					preserveInputOrderOnTie: options.preserveInputOrderOnTie
+				}).pack(group.inputs.map((input, index) => inputToCompatRect(input, index)));
+				if (!pages || pages.length === 0) continue;
+				totalPageCount += pages.length;
+				for (let p = 0; p < pages.length; p++) {
+					const page = pages[p];
+					const atlasNode = doc.createAtlas(`atlas${resolveAtlasIndex(group.branchOrdinal, p)}`);
+					atlasNode.setIndex(resolveAtlasIndex(group.branchOrdinal, p));
+					atlasNode.setFile(resolveAtlasOutputFileName(pkg, p, group.branchName));
+					atlasNode.setWidth(page.width);
+					atlasNode.setHeight(page.height);
+					pkg.addAtlas(atlasNode);
+					for (const pr of page.outputRects) {
+						const input = group.inputs[pr.index];
+						if (!input) continue;
+						const packedSize = resolvePackedRectSize(input, pr.width, pr.height, pr.rotated);
+						const rotated = pr.rotated;
+						const sprite = doc.createSprite();
+						sprite.setItemId(input.id);
+						sprite.setRectX(pr.x);
+						sprite.setRectY(pr.y);
+						sprite.setRectWidth(packedSize.width);
+						sprite.setRectHeight(packedSize.height);
+						sprite.setRotated(rotated);
+						sprite.setOffsetX(input.offsetX);
+						sprite.setOffsetY(input.offsetY);
+						sprite.setOriginalWidth(input.originalWidth);
+						sprite.setOriginalHeight(input.originalHeight);
+						sprite.setAtlas(atlasNode);
+						atlasNode.addSprite(sprite);
+					}
+					for (const res of allResources) {
+						if (!isFontResource$1(res)) continue;
+						const alias = res.getExtras()?._fontSpriteAlias;
+						if (!alias) continue;
+						const imgSprite = page.outputRects.find((result) => group.inputs[result.index]?.id === alias.textureId);
+						if (!imgSprite) continue;
+						const imgInput = group.inputs[imgSprite.index];
+						const fontSprite = doc.createSprite();
+						fontSprite.setItemId(alias.fontId);
+						fontSprite.setRectX(imgSprite.x);
+						fontSprite.setRectY(imgSprite.y);
+						fontSprite.setRectWidth(imgSprite.width);
+						fontSprite.setRectHeight(imgSprite.height);
+						fontSprite.setRotated(imgSprite.rotated);
+						if (imgInput) {
+							fontSprite.setOffsetX(imgInput.offsetX);
+							fontSprite.setOffsetY(imgInput.offsetY);
+							fontSprite.setOriginalWidth(imgInput.originalWidth);
+							fontSprite.setOriginalHeight(imgInput.originalHeight);
+						}
+						fontSprite.setAtlas(atlasNode);
+						atlasNode.addSprite(fontSprite);
+					}
+				}
+				if (encoder && options.outputPath) {
+					if (options.mkdir) await options.mkdir(options.outputPath);
+					for (let p = 0; p < pages.length; p++) {
+						const page = pages[p];
+						const compositeInputs = [];
+						for (const pr of page.outputRects) {
+							const input = group.inputs[pr.index];
+							if (!input) continue;
+							if (pr.width <= 0 || pr.height <= 0 || input.width <= 0 || input.height <= 0) continue;
+							try {
+								let imgBuffer;
+								if (input.trimBuffer) {
+									imgBuffer = input.trimBuffer;
+									if (imgBuffer.length === 0) continue;
+								} else {
+									if (!isImageResource$1(input.resource)) {
+										logger.warn(`atlas: Non-image input "${input.id}" is missing inline buffer, skipping compositing.`);
+										continue;
+									}
+									imgBuffer = await encoder(_resolveImagePath(input.resource, pkg, options.basePath)).toBuffer();
+								}
+								if (pr.rotated) imgBuffer = await encoder(imgBuffer).rotate(270).toBuffer();
+								compositeInputs.push({
+									input: imgBuffer,
+									left: pr.x,
+									top: pr.y
+								});
+							} catch {
+								logger.warn(`atlas: Could not read image "${input.id}" for compositing.`);
+							}
+						}
+						const atlasFileName = resolveAtlasOutputFileName(pkg, p, group.branchName);
+						const outputFile = `${options.outputPath}/${atlasFileName}`;
+						await encoder({ create: {
+							width: page.width,
+							height: page.height,
+							channels: 4,
+							background: {
+								r: 0,
+								g: 0,
+								b: 0,
+								alpha: 0
+							}
+						} }).composite(compositeInputs).png().toFile(outputFile);
+						logger.info(`atlas: Generated ${atlasFileName} (${page.width}x${page.height}, ${page.outputRects.length} sprites)`);
+					}
+				}
+			}
+			if (usedDirectOutput) logger.info(`atlas: Direct output for single image package "${pkg.getName()}".`);
+			logger.info(`atlas: Packed ${inputs.length} images into ${totalPageCount} atlas(es) for package "${pkg.getName()}".`);
+		}
+	});
+}
+function buildBranchAtlasGroups(doc, inputs, options) {
+	if (!options.separatedAtlasForBranch) return [{
+		branchName: "",
+		branchOrdinal: 0,
+		inputs
+	}];
+	const discoveredBranchNames = [...new Set(inputs.map((input) => getInputBranchName(input)).filter((branchName) => !!branchName))];
+	if (discoveredBranchNames.length === 0) return [{
+		branchName: "",
+		branchOrdinal: 0,
+		inputs
+	}];
+	const orderedBranchNames = doc.getRoot().listBranches().filter((branchName) => discoveredBranchNames.includes(branchName));
+	for (const branchName of discoveredBranchNames) if (!orderedBranchNames.includes(branchName)) orderedBranchNames.push(branchName);
+	const groups = /* @__PURE__ */ new Map();
+	groups.set("", []);
+	for (const branchName of orderedBranchNames) groups.set(branchName, []);
+	for (const input of inputs) {
+		const branchName = getInputBranchName(input);
+		const key = groups.has(branchName) ? branchName : "";
+		groups.get(key).push(input);
+	}
+	const orderedKeys = [""];
+	for (const branchName of orderedBranchNames) if ((groups.get(branchName)?.length ?? 0) > 0) orderedKeys.push(branchName);
+	return orderedKeys.filter((branchName) => (groups.get(branchName)?.length ?? 0) > 0).map((branchName, index) => ({
+		branchName,
+		branchOrdinal: index,
+		inputs: groups.get(branchName) ?? []
+	}));
+}
+function inputToCompatRect(input, index) {
+	const duplicatePadding = isImageResource$1(input.resource) && input.resource.getDuplicatePadding?.() === true;
+	return {
+		x: 0,
+		y: 0,
+		width: input.width,
+		height: input.height,
+		rotated: false,
+		index,
+		subIndex: -1,
+		flags: duplicatePadding ? COMPAT_NODE_RECT_FLAGS.DUPLICATE_PADDING : 0,
+		score1: 0,
+		score2: 0,
+		sourceKind: input.sourceKind
+	};
+}
+function resolvePackedRectSize(input, width, height, rectRotated) {
+	if (!rectRotated) return {
+		width,
+		height
+	};
+	return {
+		width: input.height,
+		height: input.width
+	};
+}
+function resolveDirectImageOutput(inputs, options) {
+	if (!options.directSingleImageOutput || options.extractAlpha) return null;
+	if (inputs.length !== 1) return null;
+	const [input] = inputs;
+	if (!input || input.sourceKind !== "image" || !isImageResource$1(input.resource)) return null;
+	if (input.resource.getDuplicatePadding?.() === true) return null;
+	if (input.width !== input.originalWidth || input.height !== input.originalHeight) return null;
+	if (!resolveImageFileName$1(input.resource).toLowerCase().endsWith(".png")) return null;
+	return input;
+}
+function resolveDirectOutputAtlasSize(width, height, options) {
+	let resolvedWidth = width;
+	let resolvedHeight = height;
+	if (options.square) {
+		const side = Math.max(resolvedWidth, resolvedHeight);
+		resolvedWidth = side;
+		resolvedHeight = side;
+	}
+	if (options.powerOfTwo) {
+		resolvedWidth = nextPow2(resolvedWidth);
+		resolvedHeight = nextPow2(resolvedHeight);
+	}
+	return {
+		width: resolvedWidth,
+		height: resolvedHeight
+	};
+}
+async function emitDirectImageOutput(doc, pkg, input, encoder, options, logger, branchName = "", branchOrdinal = 0) {
+	const atlasFileName = resolveAtlasOutputFileName(pkg, 0, branchName);
+	const atlasSize = resolveDirectOutputAtlasSize(input.originalWidth, input.originalHeight, options);
+	const atlasNode = doc.createAtlas(`atlas${resolveAtlasIndex(branchOrdinal, 0)}`);
+	atlasNode.setIndex(resolveAtlasIndex(branchOrdinal, 0));
+	atlasNode.setFile(atlasFileName);
+	atlasNode.setWidth(atlasSize.width);
+	atlasNode.setHeight(atlasSize.height);
+	pkg.addAtlas(atlasNode);
+	const sprite = doc.createSprite();
+	sprite.setItemId(input.id);
+	sprite.setRectX(0);
+	sprite.setRectY(0);
+	sprite.setRectWidth(input.originalWidth);
+	sprite.setRectHeight(input.originalHeight);
+	sprite.setRotated(false);
+	sprite.setOffsetX(0);
+	sprite.setOffsetY(0);
+	sprite.setOriginalWidth(input.originalWidth);
+	sprite.setOriginalHeight(input.originalHeight);
+	sprite.setAtlas(atlasNode);
+	atlasNode.addSprite(sprite);
+	if (!encoder || !options.outputPath || !isImageResource$1(input.resource) || !options.basePath) return;
+	if (options.mkdir) await options.mkdir(options.outputPath);
+	const outputFile = `${options.outputPath}/${atlasFileName}`;
+	const filePath = _resolveImagePath(input.resource, pkg, options.basePath);
+	try {
+		if (atlasSize.width === input.originalWidth && atlasSize.height === input.originalHeight) await encoder(filePath).png().toFile(outputFile);
+		else {
+			const imageBuffer = await encoder(filePath).png().toBuffer();
+			await encoder({ create: {
+				width: atlasSize.width,
+				height: atlasSize.height,
+				channels: 4,
+				background: {
+					r: 0,
+					g: 0,
+					b: 0,
+					alpha: 0
+				}
+			} }).composite([{
+				input: imageBuffer,
+				left: 0,
+				top: 0
+			}]).png().toFile(outputFile);
+		}
+	} catch {
+		logger.warn(`atlas: Could not write direct-output atlas "${atlasFileName}".`);
+	}
+}
+function getInputBranchName(input) {
+	return input.resource.getBranch?.() ?? "";
+}
+function resolveAtlasIndex(branchOrdinal, pageIndex) {
+	if (branchOrdinal <= 0) return pageIndex;
+	return branchOrdinal * 100 + pageIndex;
+}
+function resolveAtlasOutputFileName(pkg, pageIndex, branchName) {
+	const suffix = branchName ? `_${branchName}` : "";
+	return `${pkg.getPublishName() || pkg.getName()}_atlas${pageIndex}${suffix}.png`;
+}
+function resolveImageFileName$1(resource) {
+	const extras = resource.getExtras();
+	return resource.getFileName() || extras._fileName || resource.getName();
+}
+function nextPow2(value) {
+	if (value <= 1) return 1;
+	return 2 ** Math.ceil(Math.log2(value));
+}
+function sortResourcesByOrder(resources, orderMap, inputOrderMap) {
+	const ordered = [...resources];
+	ordered.sort((left, right) => {
+		const leftId = left.getId();
+		const rightId = right.getId();
+		const leftOrder = leftId && orderMap.has(leftId) ? orderMap.get(leftId) ?? Number.MAX_SAFE_INTEGER : Number.MAX_SAFE_INTEGER;
+		const rightOrder = rightId && orderMap.has(rightId) ? orderMap.get(rightId) ?? Number.MAX_SAFE_INTEGER : Number.MAX_SAFE_INTEGER;
+		if (leftOrder !== rightOrder) return leftOrder - rightOrder;
+		const leftInputOrder = leftId && inputOrderMap.has(leftId) ? inputOrderMap.get(leftId) ?? Number.MAX_SAFE_INTEGER : Number.MAX_SAFE_INTEGER;
+		const rightInputOrder = rightId && inputOrderMap.has(rightId) ? inputOrderMap.get(rightId) ?? Number.MAX_SAFE_INTEGER : Number.MAX_SAFE_INTEGER;
+		if (leftInputOrder !== rightInputOrder) return leftInputOrder - rightInputOrder;
+		return (leftId ?? "").localeCompare(rightId ?? "");
+	});
+	return ordered;
+}
+/**
+* Trim transparent edges from an image using sharp.
+* Returns the trimmed buffer, dimensions, and offsets.
+* Falls back to the original image if trim fails (e.g. no alpha channel, no transparent edges).
+*/
+async function _trimImage(encoder, filePath, originalWidth, originalHeight) {
+	try {
+		const trimResult = await encoder(filePath).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+		if (!isResolvedBuffer(trimResult)) throw new Error("atlas: encoder raw alpha trim did not return resolved metadata.");
+		const { data, info } = trimResult;
+		const width = info.width;
+		const height = info.height;
+		const channels = info.channels || 4;
+		let minX = width;
+		let minY = height;
+		let maxX = -1;
+		let maxY = -1;
+		for (let y = 0; y < height; y += 1) for (let x = 0; x < width; x += 1) {
+			if ((data[(y * width + x) * channels + 3] ?? 0) === 0) continue;
+			if (x < minX) minX = x;
+			if (y < minY) minY = y;
+			if (x > maxX) maxX = x;
+			if (y > maxY) maxY = y;
+		}
+		if (maxX < minX || maxY < minY) return {
+			buffer: new Uint8Array(0),
+			width: 0,
+			height: 0,
+			offsetX: 0,
+			offsetY: 0,
+			originalWidth,
+			originalHeight
+		};
+		const trimmedWidth = maxX - minX + 1;
+		const trimmedHeight = maxY - minY + 1;
+		return {
+			buffer: await encoder(filePath).extract({
+				left: minX,
+				top: minY,
+				width: trimmedWidth,
+				height: trimmedHeight
+			}).toBuffer(),
+			width: trimmedWidth,
+			height: trimmedHeight,
+			offsetX: minX,
+			offsetY: minY,
+			originalWidth,
+			originalHeight
+		};
+	} catch {
+		return {
+			buffer: await encoder(filePath).png().toBuffer(),
+			width: originalWidth,
+			height: originalHeight,
+			offsetX: 0,
+			offsetY: 0,
+			originalWidth,
+			originalHeight
+		};
+	}
+}
+/**
+* Resolve an ImageResource to its actual file path on disk.
+*/
+function _resolveImagePath(resource, pkg, basePath) {
+	const imgPath = resource.getPath() ?? "/";
+	const fileName = resolveImageFileName$1(resource);
+	const branchName = resource.getBranch?.() ?? "";
+	const normalizedBasePath = basePath.replace(/[/\\]+$/, "");
+	return `${!branchName ? normalizedBasePath : /[\\/]assets$/i.test(normalizedBasePath) ? normalizedBasePath.replace(/([\\/])assets$/i, `$1assets_${branchName}`) : `${normalizedBasePath}_${branchName}`}/${pkg.getName()}${imgPath}${fileName}`;
+}
+/** Collect a single ImageResource into the inputs array. */
+async function _collectImage(resource, pkg, inputs, encoder, options, doTrim, logger) {
+	let origW = resource.getWidth() ?? 0;
+	let origH = resource.getHeight() ?? 0;
+	let sourceHasAlpha = false;
+	if (encoder && options.basePath) {
+		const filePath = _resolveImagePath(resource, pkg, options.basePath);
+		try {
+			const metadata = await encoder(filePath).metadata();
+			if (origW === 0 || origH === 0) {
+				origW = metadata.width ?? 0;
+				origH = metadata.height ?? 0;
+				resource.setWidth(origW);
+				resource.setHeight(origH);
+			}
+			sourceHasAlpha = metadata.hasAlpha === true || metadata.channels === 4;
+		} catch {
+			if (origW === 0 || origH === 0) {
+				logger.warn(`atlas: Could not read image "${filePath}", skipping.`);
+				return;
+			}
+		}
+	}
+	if (origW <= 0 || origH <= 0) return;
+	let packW = origW, packH = origH, offX = 0, offY = 0;
+	let trimBuf;
+	if (doTrim && sourceHasAlpha && options.basePath && encoder) {
+		const filePath = _resolveImagePath(resource, pkg, options.basePath);
+		try {
+			const trimResult = await _trimImage(encoder, filePath, origW, origH);
+			packW = trimResult.width;
+			packH = trimResult.height;
+			offX = trimResult.offsetX;
+			offY = trimResult.offsetY;
+			trimBuf = trimResult.buffer;
+		} catch {
+			logger.warn(`atlas: Could not trim "${filePath}", using original.`);
+		}
+	}
+	inputs.push({
+		id: getPublishedItemId(resource),
+		width: packW,
+		height: packH,
+		originalWidth: origW,
+		originalHeight: origH,
+		offsetX: offX,
+		offsetY: offY,
+		resource,
+		trimBuffer: trimBuf,
+		sourceKind: "image"
+	});
+}
+/** Collect MovieClip frame textures from a .jta file into the inputs array. */
+async function _collectMovieClipFrames(doc, resource, pkg, inputs, encoder, options, logger) {
+	if (!options.basePath || !options.readFileRaw) return;
+	const mcId = resource.getId();
+	const mcName = resource.getName() + ".jta";
+	const mcPath = resource.getPath() ?? "/";
+	const filePath = `${options.basePath}/${pkg.getName()}${mcPath}${mcName}`;
+	try {
+		const jta = _extractJtaFrames(await options.readFileRaw(filePath));
+		if (jta.frames.length === 0) return;
+		const frameMetas = jta.meta?.frames ?? [];
+		for (const frame of resource.listFrames()) resource.removeFrame(frame);
+		resource.setInterval(jta.meta?.interval ?? 100).setSwing(jta.meta?.swing ?? false).setRepeatDelay(jta.meta?.repeatDelay ?? 0);
+		if (frameMetas.length > 0) {
+			const firstFrameIndexByTextureIndex = /* @__PURE__ */ new Map();
+			for (let frameIndex = 0; frameIndex < frameMetas.length; frameIndex += 1) {
+				const meta = frameMetas[frameIndex];
+				const textureIndex = Number.isFinite(meta.textureIndex) ? meta.textureIndex : frameIndex;
+				if (!firstFrameIndexByTextureIndex.has(textureIndex)) firstFrameIndexByTextureIndex.set(textureIndex, frameIndex);
+			}
+			const spriteIdByTextureIndex = /* @__PURE__ */ new Map();
+			for (let textureIndex = 0; textureIndex < jta.frames.length; textureIndex += 1) {
+				const exportFrameIndex = firstFrameIndexByTextureIndex.get(textureIndex);
+				if (exportFrameIndex === void 0) continue;
+				const itemId = `${mcId}_${exportFrameIndex}`;
+				const input = await _createMovieClipFrameInput(jta.frames[textureIndex], itemId, resource, encoder);
+				if (!input) continue;
+				inputs.push(input);
+				spriteIdByTextureIndex.set(textureIndex, itemId);
+			}
+			for (let frameIndex = 0; frameIndex < frameMetas.length; frameIndex += 1) {
+				const meta = frameMetas[frameIndex];
+				const textureIndex = Number.isFinite(meta.textureIndex) ? meta.textureIndex : frameIndex;
+				const frame = doc.createMovieFrame(`${mcId}_${frameIndex}`);
+				frame.setRectX(meta.offsetX).setRectY(meta.offsetY).setRectWidth(meta.width).setRectHeight(meta.height).setAddDelay(meta.addDelay).setSpriteId(spriteIdByTextureIndex.get(textureIndex) ?? "");
+				resource.addFrame(frame);
+			}
+		} else for (let frameIndex = 0; frameIndex < jta.frames.length; frameIndex += 1) {
+			const itemId = `${mcId}_${frameIndex}`;
+			const input = await _createMovieClipFrameInput(jta.frames[frameIndex], itemId, resource, encoder);
+			if (!input) continue;
+			inputs.push(input);
+			const frame = doc.createMovieFrame(itemId);
+			frame.setRectX(0).setRectY(0).setRectWidth(input.originalWidth).setRectHeight(input.originalHeight).setAddDelay(0).setSpriteId(itemId);
+			resource.addFrame(frame);
+		}
+		if ((jta.meta?.width ?? 0) > 0 && (jta.meta?.height ?? 0) > 0) {
+			resource.setWidth(jta.meta?.width ?? 0);
+			resource.setHeight(jta.meta?.height ?? 0);
+		}
+	} catch {
+		logger.warn(`atlas: Could not parse MovieClip "${filePath}", skipping frames.`);
+	}
+}
+async function _createMovieClipFrameInput(buffer, itemId, resource, encoder) {
+	if (!encoder || buffer.length === 0) return null;
+	try {
+		const meta = await encoder(buffer).metadata();
+		const width = meta.width ?? 0;
+		const height = meta.height ?? 0;
+		if (width <= 0 || height <= 0) return null;
+		return {
+			id: itemId,
+			width,
+			height,
+			originalWidth: width,
+			originalHeight: height,
+			offsetX: 0,
+			offsetY: 0,
+			resource,
+			trimBuffer: buffer,
+			sourceKind: "movieclip-frame"
+		};
+	} catch {
+		return null;
+	}
+}
+const PNG_SIGNATURE = new Uint8Array([
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+]);
+function _extractJtaFrames(data) {
+	const frames = [];
+	let offset = 0;
+	let firstPngOffset = -1;
+	while (offset < data.length) {
+		const sigIndex = _findPngSignature(data, offset);
+		if (sigIndex === -1) break;
+		if (firstPngOffset === -1) firstPngOffset = sigIndex;
+		const end = _findPngEnd(data, sigIndex);
+		if (end === -1) break;
+		frames.push(data.subarray(sigIndex, end));
+		offset = end;
+	}
+	if (firstPngOffset === -1 || frames.length === 0) return { frames: [] };
+	return {
+		frames,
+		meta: _parseJtaHeader(data, firstPngOffset, frames.length)
+	};
+}
+function _findPngSignature(data, fromIndex) {
+	for (let index = fromIndex; index <= data.length - PNG_SIGNATURE.length; index += 1) {
+		let matched = true;
+		for (let sigIndex = 0; sigIndex < PNG_SIGNATURE.length; sigIndex += 1) if (data[index + sigIndex] !== PNG_SIGNATURE[sigIndex]) {
+			matched = false;
+			break;
+		}
+		if (matched) return index;
+	}
+	return -1;
+}
+function _findPngEnd(data, start) {
+	let pos = start + PNG_SIGNATURE.length;
+	while (pos + 8 <= data.length) {
+		const length = _readUint32BE(data, pos);
+		pos += 8;
+		if (pos + length + 4 > data.length) return -1;
+		const isIEND = data[pos - 4] === 73 && data[pos - 3] === 69 && data[pos - 2] === 78 && data[pos - 1] === 68;
+		pos += length + 4;
+		if (isIEND) return pos;
+	}
+	return -1;
+}
+function _parseJtaHeader(data, firstPngOffset, frameCount) {
+	if (data.length < 10) return void 0;
+	const state = { offset: 0 };
+	const end = Math.min(firstPngOffset, data.length);
+	if (!_readUtfBE(data, state, end)) return void 0;
+	const version = _readInt32BEAt(data, state, end);
+	if (version == null) return void 0;
+	const fpsRaw = _readInt8At(data, state, end);
+	if (fpsRaw == null) return void 0;
+	const fps = fpsRaw > 0 ? fpsRaw : 24;
+	if (state.offset + 3 > end) return void 0;
+	state.offset += 3;
+	if (version < 102) return void 0;
+	_readUint16BEAt(data, state, end);
+	_readUint16BEAt(data, state, end);
+	const width = _readUint16BEAt(data, state, end);
+	const height = _readUint16BEAt(data, state, end);
+	if (width == null || height == null) return void 0;
+	const speedRaw = _readUint8At(data, state, end);
+	const repeatDelayRaw = _readUint8At(data, state, end);
+	const swingRaw = _readInt8At(data, state, end);
+	const frameTableCount = _readInt16BEAt(data, state, end);
+	if (speedRaw == null || repeatDelayRaw == null || swingRaw == null || frameTableCount == null) return void 0;
+	const frames = [];
+	for (let index = 0; index < frameTableCount; index += 1) {
+		const delayRaw = _readInt16BEAt(data, state, end);
+		const offsetX = _readInt16BEAt(data, state, end);
+		const offsetY = _readInt16BEAt(data, state, end);
+		const frameWidth = _readInt16BEAt(data, state, end);
+		const frameHeight = _readInt16BEAt(data, state, end);
+		const textureIndex = _readInt16BEAt(data, state, end);
+		if (delayRaw == null || offsetX == null || offsetY == null || frameWidth == null || frameHeight == null || textureIndex == null) break;
+		frames.push({
+			addDelay: Math.trunc(1e3 / fps * delayRaw),
+			offsetX,
+			offsetY,
+			width: frameWidth,
+			height: frameHeight,
+			textureIndex
+		});
+	}
+	return {
+		interval: Math.trunc(1e3 / fps * (speedRaw || 1)),
+		repeatDelay: Math.trunc(1e3 / fps * repeatDelayRaw),
+		swing: swingRaw === 1,
+		width,
+		height,
+		frames: frames.length === 0 && frameCount > 0 ? [] : frames
+	};
+}
+function _readUtfBE(data, state, end) {
+	const length = _readUint16BEAt(data, state, end);
+	if (length == null || state.offset + length > end) return null;
+	const value = new TextDecoder().decode(data.subarray(state.offset, state.offset + length));
+	state.offset += length;
+	return value;
+}
+function _readUint8At(data, state, end) {
+	if (state.offset + 1 > end) return null;
+	const value = data[state.offset];
+	state.offset += 1;
+	return value ?? 0;
+}
+function _readInt8At(data, state, end) {
+	if (state.offset + 1 > end) return null;
+	const value = new DataView(data.buffer, data.byteOffset, data.byteLength).getInt8(state.offset);
+	state.offset += 1;
+	return value;
+}
+function _readUint16BEAt(data, state, end) {
+	if (state.offset + 2 > end) return null;
+	const value = _readUint16BE(data, state.offset);
+	state.offset += 2;
+	return value;
+}
+function _readInt16BEAt(data, state, end) {
+	if (state.offset + 2 > end) return null;
+	const value = new DataView(data.buffer, data.byteOffset, data.byteLength).getInt16(state.offset, false);
+	state.offset += 2;
+	return value;
+}
+function _readInt32BEAt(data, state, end) {
+	if (state.offset + 4 > end) return null;
+	const value = new DataView(data.buffer, data.byteOffset, data.byteLength).getInt32(state.offset, false);
+	state.offset += 4;
+	return value;
+}
+function _readUint16BE(data, offset) {
+	if (offset + 1 >= data.length) return 0;
+	return data[offset] << 8 | data[offset + 1];
+}
+function _readUint32BE(data, offset) {
+	if (offset + 3 >= data.length) return 0;
+	return data[offset] * 16777216 + ((data[offset + 1] ?? 0) << 16) + ((data[offset + 2] ?? 0) << 8) + (data[offset + 3] ?? 0);
+}
+/** Collect a Bitmap Font's texture image, packed under the font's ID. */
+async function _collectFontTexture(doc, fontRes, pkg, options) {
+	fontRes.getExtras();
+	const textureId = fontRes.getTextureId?.() ?? "";
+	if (textureId) {
+		const fontId = fontRes.getId();
+		fontRes.setExtras({
+			...fontRes.getExtras(),
+			_fontSpriteAlias: {
+				fontId,
+				textureId
+			}
+		});
+	}
+	if (options.readFileRaw && options.basePath) {
+		const fontName = resolveFontFileName(fontRes.getName());
+		const fontPath = fontRes.getPath() ?? "/";
+		const pkgName = pkg.getName();
+		const fntFile = `${options.basePath}/${pkgName}${fontPath}${fontName}`;
+		try {
+			const fntData = await options.readFileRaw(fntFile);
+			const fntParsed = _parseFnt(new TextDecoder().decode(fntData));
+			for (const glyph of fontRes.listGlyphs()) fontRes.removeGlyph(glyph);
+			fontRes.setTtf(fntParsed.hasFace).setTint(fntParsed.colored).setAutoScale(fntParsed.resizable).setHasChannel(fntParsed.hasChannel).setFontSize(fntParsed.fontSize).setXAdvance(fntParsed.xadvance).setLineHeight(fntParsed.lineHeight);
+			for (const item of fntParsed.glyphs) {
+				const glyph = doc.createFontGlyph(`${fontRes.getId()}_${item.charId}`);
+				glyph.setCharId(item.charId).setChar(item.charId > 0 ? String.fromCodePoint(item.charId) : "").setImg(item.img ?? "").setX(item.x).setY(item.y).setXOffset(item.xoffset).setYOffset(item.yoffset).setWidth(item.width).setHeight(item.height).setAdvance(item.xadvance).setLineHeight(fntParsed.lineHeight).setChannel(item.channel);
+				fontRes.addGlyph(glyph);
+			}
+		} catch {}
+	}
+}
+/** Parse a BMFont .fnt text file into structured data for binary encoding. */
+function _parseFnt(text) {
+	const lines = text.split(/\r?\n/);
+	let hasFace = false, colored = false, resizable = false, hasChannel = false;
+	let fontSize = 0, globalXadvance = 0, lineHeight = 0;
+	const glyphs = [];
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const parts = trimmed.split(/\s+/);
+		const attrs = {};
+		for (let i = 1; i < parts.length; i++) {
+			const eq = parts[i].split("=");
+			if (eq.length === 2) attrs[eq[0]] = eq[1];
+		}
+		switch (parts[0]) {
+			case "info":
+				hasFace = attrs.face != null;
+				colored = hasFace;
+				if (attrs.colored !== void 0) colored = attrs.colored === "true";
+				fontSize = parseInt(attrs.size, 10) || 0;
+				resizable = attrs.resizable === "true";
+				break;
+			case "common":
+				lineHeight = parseInt(attrs.lineHeight, 10) || 0;
+				globalXadvance = parseInt(attrs.xadvance, 10) || 0;
+				if (fontSize === 0) fontSize = lineHeight;
+				else if (lineHeight === 0) lineHeight = fontSize;
+				break;
+			case "char": {
+				const charId = parseInt(attrs.id, 10) || 0;
+				if (charId === 0) continue;
+				const img = attrs.img || null;
+				if (!hasFace && !img) continue;
+				const chnl = parseInt(attrs.chnl, 10) || 0;
+				if (chnl !== 0 && chnl !== 15) hasChannel = true;
+				glyphs.push({
+					charId,
+					img,
+					x: parseInt(attrs.x, 10) || 0,
+					y: parseInt(attrs.y, 10) || 0,
+					xoffset: parseInt(attrs.xoffset, 10) || 0,
+					yoffset: parseInt(attrs.yoffset, 10) || 0,
+					width: parseInt(attrs.width, 10) || 0,
+					height: parseInt(attrs.height, 10) || 0,
+					xadvance: parseInt(attrs.xadvance, 10) || 0,
+					channel: chnl
+				});
+				break;
+			}
+		}
+	}
+	return {
+		hasFace,
+		colored,
+		resizable: fontSize > 0 ? resizable : false,
+		hasChannel,
+		fontSize,
+		xadvance: globalXadvance,
+		lineHeight,
+		glyphs
+	};
+}
+function isComponentResource$1(resource) {
+	return resource.propertyType === "Component";
+}
+function isImageResource$1(resource) {
+	return resource.propertyType === "ImageResource";
+}
+function isMovieClipResource$1(resource) {
+	return resource.propertyType === "MovieClipResource";
+}
+function isSkeletonResource$1(resource) {
+	return resource.propertyType === "SpineResource" || resource.propertyType === "DragonBonesResource";
+}
+function isFontResource$1(resource) {
+	return resource.propertyType === "FontResource";
+}
+function isPackableResource(resource) {
+	return isImageResource$1(resource) || isMovieClipResource$1(resource) || isFontResource$1(resource);
+}
+function addUiResourceRef(target, value) {
+	if (!value?.startsWith("ui://")) return;
+	const refId = value.slice(5).slice(8);
+	if (refId) target.add(refId);
+}
+function addUiResourceRefsFromText(target, value) {
+	if (!value || typeof value !== "string") return;
+	const matches = value.matchAll(/ui:\/\/[0-9a-z]{8}([0-9a-z]+)/gi);
+	for (const match of matches) {
+		const refId = match[1] ?? "";
+		if (refId) target.add(refId);
+	}
+}
+function addUiResourceRefsFromUnknown(target, value) {
+	if (Array.isArray(value)) {
+		for (const entry of value) addUiResourceRefsFromUnknown(target, entry);
+		return;
+	}
+	if (typeof value === "string") {
+		addUiResourceRef(target, value);
+		addUiResourceRefsFromText(target, value);
+	}
+}
+function isResolvedBuffer(value) {
+	return typeof value === "object" && value !== null && "data" in value && "info" in value;
+}
+//#endregion
+//#region src/codegen-templates.ts
+const UNITY_COMPONENT_TEMPLATE = `{{generatedMark}}
+
+using FairyGUI;
+using FairyGUI.Utils;
+
+namespace {{namespaceName}}
+{
+\tpublic partial class {{className}} : {{componentType}}
+\t{
+\t\tpublic const string URL = "{{url}}";
+{{variableLines}}
+\t\tpublic static {{className}} CreateInstance()
+\t\t{
+\t\t\treturn ({{className}})UIPackage.CreateObject("{{packageName}}", "{{componentName}}");
+\t\t}
+
+\t\tpublic override void ConstructFromXML(XML xml)
+\t\t{
+\t\t\tbase.ConstructFromXML(xml);
+{{assignmentLines}}
+\t\t}
+\t}
+}
+`;
+const UNITY_BINDER_TEMPLATE = `{{generatedMark}}
+
+using FairyGUI;
+
+namespace {{namespaceName}}
+{
+\tpublic static class {{binderClassName}}
+\t{
+\t\tpublic static void BindAll()
+\t\t{
+{{bindLines}}
+\t\t}
+\t}
+}
+`;
+const FGUI_TYPESCRIPT_COMPONENT_TEMPLATE = `{{generatedMark}}
+
+{{importLines}}export default class {{className}} extends {{componentType}}
+{
+\tpublic static URL:string = "{{url}}";
+{{variableLines}}
+\tpublic static createInstance():{{className}}
+\t{
+\t\treturn <{{className}}><any>({{runtimeNamespace}}.UIPackage.createObject("{{packageName}}","{{componentName}}"));
+\t}
+
+\tprotected onConstruct():void
+\t{
+{{assignmentLines}}\t}
+}
+`;
+const FGUI_TYPESCRIPT_BINDER_TEMPLATE = `{{generatedMark}}
+
+{{importLines}}export default class {{binderClassName}}
+{
+\tpublic static bindAll():void
+\t{
+{{bindLines}}\t}
+}
+`;
+//#endregion
+//#region src/codegen.ts
+const AUTO_GENERATED_CODE_MARK = "/** This is an automatically generated class by FairyGUI. Please do not modify it. **/";
+const DEFAULT_CLASS_NAME_PREFIX = "UI_";
+const DEFAULT_MEMBER_NAME_PREFIX = "m_";
+const FGUI_TYPESCRIPT_RUNTIME_TYPES = new Set([
+	"Controller",
+	"GButton",
+	"GComboBox",
+	"GComponent",
+	"GGraph",
+	"GGroup",
+	"GImage",
+	"GLabel",
+	"GList",
+	"GLoader",
+	"GLoader3D",
+	"GMovieClip",
+	"GProgressBar",
+	"GRichTextField",
+	"GScrollBar",
+	"GSlider",
+	"GSwfObject",
+	"GTextField",
+	"GTextInput",
+	"GTree",
+	"Transition"
+]);
+const SHARED_FGUI_TYPESCRIPT_VARIANT = {
+	binderMethod: "setExtension",
+	runtimeNamespace: "fgui"
+};
+async function publishCodeGeneration(doc, options) {
+	const logger = doc.getLogger();
+	const settings = resolveCodeGenerationSettings(doc);
+	if (!settings.allowGenCode) return;
+	for (const pkg of options.packages) {
+		if (!pkg.getGenCode()) continue;
+		const plan = resolvePackageCodegenPlan(pkg, settings, options);
+		if (!plan) {
+			logger.warn(`publish: Code generation skipped for package "${pkg.getName()}" because no codePath was resolved.`);
+			continue;
+		}
+		if (!supportsCodeGenerationLane(doc, settings.codeType)) {
+			logger.warn(`publish: Code generation skipped for package "${pkg.getName()}" because project/codeType is not supported yet.`);
+			continue;
+		}
+		const fguiTypescriptVariant = resolveFguiTypescriptVariant(doc);
+		if (fguiTypescriptVariant) await generateFguiTypescriptCode(doc, pkg, plan, options.fs, fguiTypescriptVariant);
+		else await generateUnityCode(doc, pkg, plan, options.fs);
+		logger.info(`publish: Generated code for package "${pkg.getName()}" into ${plan.outputDir}`);
+	}
+}
+function resolveCodeGenerationSettings(doc) {
+	const codeGeneration = ((doc.getRoot().getSettings?.() ?? {}).publish ?? {}).codeGeneration;
+	if (!codeGeneration) return {
+		allowGenCode: true,
+		classNamePrefix: "UI_",
+		memberNamePrefix: "m_",
+		packageName: "",
+		ignoreNoname: false,
+		getMemberByName: false,
+		codePath: "",
+		codeType: ""
+	};
+	return {
+		allowGenCode: codeGeneration.allowGenCode ?? true,
+		classNamePrefix: codeGeneration.classNamePrefix ?? DEFAULT_CLASS_NAME_PREFIX,
+		memberNamePrefix: codeGeneration.memberNamePrefix ?? DEFAULT_MEMBER_NAME_PREFIX,
+		packageName: codeGeneration.packageName ?? "",
+		ignoreNoname: codeGeneration.ignoreNoname ?? false,
+		getMemberByName: Boolean(codeGeneration.getMemberByName),
+		codePath: codeGeneration.codePath ?? "",
+		codeType: codeGeneration.codeType?.trim() ?? ""
+	};
+}
+function resolvePackageCodegenPlan(pkg, settings, options) {
+	const rawCodePath = (pkg.getCodePath() || settings.codePath || "").trim();
+	if (!rawCodePath) return null;
+	const packageFolderName = normalizeTypeName(pkg.getName()) || "Package";
+	return {
+		outputDir: resolveCodePath(rawCodePath, options.basePath, options.fs),
+		packageFolderName,
+		packageNamespace: settings.packageName ? `${settings.packageName}.${packageFolderName}` : packageFolderName,
+		binderClassName: `${packageFolderName}Binder`,
+		settings
+	};
+}
+function supportsCodeGenerationLane(doc, codeType) {
+	const projectType = doc.getRoot().getProjectType();
+	if (projectType === _openfairygui_core.ProjectType.Unity) return codeType === "";
+	if (projectType === _openfairygui_core.ProjectType.LayaBox || projectType === _openfairygui_core.ProjectType.CocosCreator) return true;
+	return false;
+}
+function resolveFguiTypescriptVariant(doc) {
+	const projectType = doc.getRoot().getProjectType();
+	if (projectType !== _openfairygui_core.ProjectType.LayaBox && projectType !== _openfairygui_core.ProjectType.CocosCreator) return null;
+	return SHARED_FGUI_TYPESCRIPT_VARIANT;
+}
+async function generateUnityCode(doc, pkg, plan, fs) {
+	const packageDir = fs.join(plan.outputDir, plan.packageFolderName);
+	await fs.mkdir(plan.outputDir);
+	await fs.mkdir(packageDir);
+	await cleanupGeneratedFiles(packageDir, fs);
+	const classes = buildCodegenClasses(doc, pkg, plan);
+	for (const classInfo of classes) await writeTextFile(fs, fs.join(packageDir, `${classInfo.encodedClassName}.cs`), renderUnityComponentClass(classInfo, plan));
+	await writeTextFile(fs, fs.join(packageDir, `${plan.binderClassName}.cs`), renderUnityBinder(classes, plan));
+}
+async function generateFguiTypescriptCode(doc, pkg, plan, fs, variant) {
+	const packageDir = fs.join(plan.outputDir, plan.packageFolderName);
+	await fs.mkdir(plan.outputDir);
+	await fs.mkdir(packageDir);
+	await cleanupGeneratedFiles(packageDir, fs, ".ts");
+	const classes = buildCodegenClasses(doc, pkg, plan);
+	for (const classInfo of classes) await writeTextFile(fs, fs.join(packageDir, `${classInfo.encodedClassName}.ts`), renderFguiTypescriptComponentClass(classInfo, plan, variant));
+	await writeTextFile(fs, fs.join(packageDir, `${plan.binderClassName}.ts`), renderFguiTypescriptBinder(classes, plan, variant));
+}
+async function cleanupGeneratedFiles(directory, fs, extension = ".cs") {
+	if (!fs.readdir || !fs.readFileRaw || !fs.deleteFile) return;
+	let entries;
+	try {
+		entries = await fs.readdir(directory);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		if (!entry.toLowerCase().endsWith(extension)) continue;
+		const filePath = fs.join(directory, entry);
+		try {
+			if (decodeText(await fs.readFileRaw(filePath)).startsWith("/** This is an automatically generated class by FairyGUI. Please do not modify it. **/")) await fs.deleteFile(filePath);
+		} catch {}
+	}
+}
+function buildCodegenClasses(doc, pkg, plan) {
+	const exportedComponents = pkg.listComponents().filter((component) => component.getExported()).sort((left, right) => left.getId().localeCompare(right.getId()));
+	const generatedById = /* @__PURE__ */ new Map();
+	for (const component of exportedComponents) {
+		const encodedClassName = `${plan.settings.classNamePrefix}${normalizeTypeName(component.getName()) || "Component"}`;
+		generatedById.set(component.getId(), {
+			classId: component.getId(),
+			className: component.getName(),
+			encodedClassName,
+			componentType: resolveComponentBaseType(component),
+			componentName: component.getName(),
+			packageName: pkg.getName(),
+			url: `ui://${pkg.getId()}${component.getId()}`,
+			members: []
+		});
+	}
+	for (const component of exportedComponents) {
+		const classInfo = generatedById.get(component.getId());
+		if (!classInfo) continue;
+		classInfo.members = buildCodegenMembers(doc, pkg, component, plan, generatedById);
+	}
+	return [...generatedById.values()];
+}
+function buildCodegenMembers(doc, pkg, component, plan, generatedById) {
+	const members = [];
+	const ownerType = resolveComponentBaseType(component);
+	let controllerIndex = 0;
+	let childIndex = 0;
+	let transitionIndex = 0;
+	for (const controller of component.listControllers()) members.push(createMember(ownerType, "controller", "Controller", controller.getName(), controllerIndex++, plan));
+	for (const child of component.listChildren()) members.push(createMember(ownerType, "child", resolveChildType(doc, pkg, child, generatedById), child.getName(), childIndex++, plan));
+	for (const transition of component.listTransitions()) members.push(createMember(ownerType, "transition", "Transition", transition.getName(), transitionIndex++, plan));
+	const usedNames = /* @__PURE__ */ new Map();
+	for (const member of members) {
+		if (member.ignored) continue;
+		const key = applyMemberNamePrefix(member.originalName, plan.settings.memberNamePrefix);
+		const current = usedNames.get(key) ?? 0;
+		if (current > 0) member.name = `${key}_${current + 1}`;
+		usedNames.set(key, current + 1);
+	}
+	return members;
+}
+function createMember(ownerType, kind, type, originalName, index, plan) {
+	const ignored = plan.settings.ignoreNoname && isDefaultMemberName(ownerType, kind, originalName);
+	return {
+		index,
+		kind,
+		name: applyMemberNamePrefix(originalName, plan.settings.memberNamePrefix),
+		originalName,
+		type,
+		ignored
+	};
+}
+function resolveChildType(doc, pkg, child, generatedById) {
+	const src = child.getSrc?.();
+	if (src) {
+		const localResource = resolveChildSourceComponent(doc, pkg, src);
+		if (localResource) return generatedById.get(localResource.getId())?.encodedClassName ?? resolveComponentBaseType(localResource);
+	}
+	const instanceExtType = child.getInstanceExtType?.();
+	if (instanceExtType) return `G${instanceExtType}`;
+	return child.propertyType;
+}
+function resolveChildSourceComponent(doc, pkg, src) {
+	if (!src) return null;
+	if (src.startsWith("ui://")) {
+		const rest = src.slice(5);
+		const pkgId = rest.slice(0, 8);
+		const resourceId = rest.slice(8);
+		const targetResource = doc.getRoot().listPackages().find((candidate) => candidate.getId() === pkgId)?.getResourceById(resourceId);
+		return targetResource?.propertyType === "Component" ? targetResource : null;
+	}
+	const localResource = pkg.getResourceById(src);
+	return localResource?.propertyType === "Component" ? localResource : null;
+}
+function resolveComponentBaseType(component) {
+	const extensionType = component.getExtensionType();
+	return extensionType ? `G${extensionType}` : "GComponent";
+}
+function renderUnityComponentClass(classInfo, plan) {
+	const variableLines = classInfo.members.filter((member) => !member.ignored).map((member) => `\t\tpublic ${member.type} ${member.name};`).join("\n");
+	const contentLines = classInfo.members.map((member) => renderMemberAssignment(member, plan.settings.getMemberByName)).filter((line) => Boolean(line)).join("\n");
+	return renderTemplate(UNITY_COMPONENT_TEMPLATE, {
+		assignmentLines: contentLines ? `${contentLines}\n` : "",
+		className: classInfo.encodedClassName,
+		componentName: escapeCSharpString(classInfo.className),
+		componentType: classInfo.componentType,
+		generatedMark: AUTO_GENERATED_CODE_MARK,
+		namespaceName: plan.packageNamespace,
+		packageName: escapeCSharpString(classInfo.packageName),
+		url: escapeCSharpString(classInfo.url),
+		variableLines: variableLines ? `${variableLines}\n` : ""
+	});
+}
+function renderUnityBinder(classes, plan) {
+	const bindLines = classes.map((classInfo) => `\t\t\tUIObjectFactory.SetPackageItemExtension(${classInfo.encodedClassName}.URL, typeof(${classInfo.encodedClassName}));`).join("\n");
+	return renderTemplate(UNITY_BINDER_TEMPLATE, {
+		binderClassName: plan.binderClassName,
+		bindLines: bindLines ? `${bindLines}\n` : "",
+		generatedMark: AUTO_GENERATED_CODE_MARK,
+		namespaceName: plan.packageNamespace
+	});
+}
+function renderFguiTypescriptComponentClass(classInfo, plan, variant) {
+	const variableLines = classInfo.members.filter((member) => !member.ignored).map((member) => `\tpublic ${member.name}:${translateFguiTypescriptType(member.type, variant)};`).join("\n");
+	const assignmentLines = classInfo.members.map((member) => renderFguiTypescriptMemberAssignment(member, plan.settings.getMemberByName, variant)).filter((line) => Boolean(line)).join("\n");
+	const importLines = collectFguiTypescriptImports(classInfo, variant);
+	return renderTemplate(FGUI_TYPESCRIPT_COMPONENT_TEMPLATE, {
+		assignmentLines: assignmentLines ? `${assignmentLines}\n` : "",
+		className: classInfo.encodedClassName,
+		componentName: escapeTypeScriptString(classInfo.className),
+		componentType: translateFguiTypescriptType(classInfo.componentType, variant),
+		generatedMark: AUTO_GENERATED_CODE_MARK,
+		importLines,
+		packageName: escapeTypeScriptString(classInfo.packageName),
+		runtimeNamespace: variant.runtimeNamespace,
+		url: escapeTypeScriptString(classInfo.url),
+		variableLines: variableLines ? `${variableLines}\n` : ""
+	});
+}
+function renderFguiTypescriptBinder(classes, plan, variant) {
+	const bindLines = classes.map((classInfo) => `\t\t${variant.runtimeNamespace}.UIObjectFactory.${variant.binderMethod}(${classInfo.encodedClassName}.URL, ${classInfo.encodedClassName});`).join("\n");
+	const importLines = classes.map((classInfo) => `import ${classInfo.encodedClassName} from "./${classInfo.encodedClassName}";`).join("\n");
+	return renderTemplate(FGUI_TYPESCRIPT_BINDER_TEMPLATE, {
+		binderClassName: plan.binderClassName,
+		bindLines: bindLines ? `${bindLines}\n` : "",
+		generatedMark: AUTO_GENERATED_CODE_MARK,
+		importLines: importLines ? `${importLines}\n\n` : ""
+	});
+}
+function renderMemberAssignment(member, getMemberByName) {
+	if (member.ignored) return null;
+	if (member.type === "Controller") return getMemberByName ? `\t\t\t${member.name} = this.GetController("${escapeCSharpString(member.originalName)}");` : `\t\t\t${member.name} = this.GetControllerAt(${member.index});`;
+	if (member.type === "Transition") return getMemberByName ? `\t\t\t${member.name} = this.GetTransition("${escapeCSharpString(member.originalName)}");` : `\t\t\t${member.name} = this.GetTransitionAt(${member.index});`;
+	return getMemberByName ? `\t\t\t${member.name} = (${member.type})this.GetChild("${escapeCSharpString(member.originalName)}");` : `\t\t\t${member.name} = (${member.type})this.GetChildAt(${member.index});`;
+}
+function renderFguiTypescriptMemberAssignment(member, getMemberByName, variant) {
+	if (member.ignored) return null;
+	if (member.type === "Controller") return getMemberByName ? `\t\tthis.${member.name} = this.getController("${escapeTypeScriptString(member.originalName)}");` : `\t\tthis.${member.name} = this.getControllerAt(${member.index});`;
+	if (member.type === "Transition") return getMemberByName ? `\t\tthis.${member.name} = this.getTransition("${escapeTypeScriptString(member.originalName)}");` : `\t\tthis.${member.name} = this.getTransitionAt(${member.index});`;
+	const translatedType = translateFguiTypescriptType(member.type, variant);
+	return getMemberByName ? `\t\tthis.${member.name} = <${translatedType}><any>(this.getChild("${escapeTypeScriptString(member.originalName)}"));` : `\t\tthis.${member.name} = <${translatedType}><any>(this.getChildAt(${member.index}));`;
+}
+function resolveCodePath(codePath, basePath, fs) {
+	if (isAbsolutePath(codePath)) return trimTrailingSlashes(codePath);
+	const projectBasePath = resolveProjectBasePath(basePath);
+	return projectBasePath ? trimTrailingSlashes(fs.join(projectBasePath, codePath)) : trimTrailingSlashes(codePath);
+}
+function resolveProjectBasePath(basePath) {
+	if (!basePath) return "";
+	const normalized = trimTrailingSlashes(basePath);
+	const assetsMatch = normalized.match(/^(.*)[/\\]assets(?:_[^/\\]+)?$/i);
+	if (assetsMatch?.[1]) return assetsMatch[1];
+	return dirname$1(normalized);
+}
+function dirname$1(filePath) {
+	return trimTrailingSlashes(filePath).match(/^(.*)[/\\][^/\\]+$/)?.[1] ?? "";
+}
+function trimTrailingSlashes(value) {
+	return value.replace(/[/\\]+$/, "");
+}
+function isAbsolutePath(value) {
+	return /^[a-z]:[/\\]/i.test(value) || value.startsWith("/") || value.startsWith("\\\\");
+}
+function isDefaultMemberName(ownerType, kind, name) {
+	if (kind === "controller") return (ownerType === "GButton" || ownerType === "GComboBox") && name === "button";
+	if (kind === "transition") return false;
+	if (ownerType === "GButton" || ownerType === "GLabel" || ownerType === "GComboBox") return name === "title" || name === "icon";
+	if (ownerType === "GProgressBar") return name === "bar" || name === "bar_v" || name === "title" || name === "ani";
+	if (ownerType === "GSlider") return name === "bar" || name === "bar_v" || name === "grip" || name === "title" || name === "ani";
+	return /^n\d+(?:_.*)?$/i.test(name);
+}
+function applyMemberNamePrefix(name, prefix) {
+	const normalized = normalizeMemberName(name) || "member";
+	return prefix ? `${prefix}${normalized}` : normalized;
+}
+function normalizeMemberName(value) {
+	const cleaned = value.replace(/[^0-9A-Za-z_]+/g, "_").replace(/^_+|_+$/g, "");
+	if (!cleaned) return "";
+	return /^[0-9]/.test(cleaned) ? `_${cleaned}` : cleaned;
+}
+function normalizeTypeName(value) {
+	const cleaned = value.replace(/[^0-9A-Za-z_]+/g, "_").replace(/^_+|_+$/g, "");
+	if (!cleaned) return "";
+	const normalized = cleaned.split(/_+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+	return /^[0-9]/.test(normalized) ? `_${normalized}` : normalized;
+}
+function collectFguiTypescriptImports(classInfo, variant) {
+	const imports = /* @__PURE__ */ new Set();
+	for (const member of classInfo.members) {
+		if (member.ignored) continue;
+		const translated = translateFguiTypescriptType(member.type, variant);
+		if (!translated.includes(".")) imports.add(`import ${translated} from "./${translated}";`);
+	}
+	return imports.size > 0 ? `${[...imports].sort().join("\n")}\n\n` : "";
+}
+function translateFguiTypescriptType(typeName, variant) {
+	if (FGUI_TYPESCRIPT_RUNTIME_TYPES.has(typeName)) return `${variant.runtimeNamespace}.${typeName}`;
+	return typeName;
+}
+function renderTemplate(template, data) {
+	let output = template;
+	for (const [key, value] of Object.entries(data)) output = output.replaceAll(`{{${key}}}`, value);
+	return output;
+}
+function escapeCSharpString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function escapeTypeScriptString(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+async function writeTextFile(fs, filePath, content) {
+	await fs.writeFileRaw(filePath, encodeText(content));
+}
+function encodeText(value) {
+	return new TextEncoder().encode(value);
+}
+function decodeText(value) {
+	return new TextDecoder().decode(value);
+}
+//#endregion
+//#region src/publish.ts
+const UNITY_PROJECT_TYPE = _openfairygui_core.ProjectType.Unity;
+const COCOS_CREATOR_PROJECT_TYPE = _openfairygui_core.ProjectType.CocosCreator;
+function resolveDefaultPublishFileExtension(projectType, publishSettings) {
+	if (projectType === UNITY_PROJECT_TYPE) return "bytes";
+	if (projectType === COCOS_CREATOR_PROJECT_TYPE) return publishSettings.fileExtension || "bin";
+	return publishSettings.fileExtension || "fui";
+}
+function resolvePublishAtlasRuntimeOptions(fileExtension) {
+	return {
+		preserveInputOrderOnTie: fileExtension === "fui",
+		directSingleImageOutput: fileExtension === "bytes"
+	};
+}
+function resolvePublishFileName(publishName, fileExtension) {
+	if (fileExtension === "bytes") return `${publishName}_fui.bytes`;
+	return `${publishName}.${fileExtension}`;
+}
+/**
+* Resolve publish defaults from the document's project settings.
+*
+* This keeps the editor-aligned publish rules reusable across environments,
+* while callers still provide environment-specific concerns such as fs/encoder/basePath.
+*/
+function resolvePublishOptions(doc, overrides = {}) {
+	const root = doc.getRoot();
+	const publishSettings = (root.getSettings?.() ?? {}).publish ?? {};
+	const atlasSetting = publishSettings.atlasSetting ?? {};
+	const projectType = root.getProjectType();
+	const fileExtension = overrides.fileExtension ?? resolveDefaultPublishFileExtension(projectType, publishSettings);
+	let compressed = overrides.compressed ?? publishSettings.compressDesc ?? false;
+	if (projectType === UNITY_PROJECT_TYPE) compressed = overrides.compressed ?? false;
+	const atlasOptions = {
+		maxSize: overrides.atlas?.maxSize ?? atlasSetting.maxSize ?? 2048,
+		fast: overrides.atlas?.fast ?? atlasSetting.fast ?? true,
+		allowRotation: overrides.atlas?.allowRotation ?? atlasSetting.allowRotation ?? false,
+		padding: overrides.atlas?.padding ?? atlasSetting.padding ?? 2,
+		powerOfTwo: overrides.atlas?.powerOfTwo ?? atlasSetting.sizeOption === "pot",
+		square: overrides.atlas?.square ?? atlasSetting.forceSquare ?? false,
+		multiPage: overrides.atlas?.multiPage ?? atlasSetting.paging ?? true,
+		trimImage: overrides.atlas?.trimImage ?? atlasSetting.trimImage ?? false,
+		extractAlpha: overrides.atlas?.extractAlpha ?? atlasSetting.extractAlpha ?? false
+	};
+	return {
+		compressed,
+		fileExtension,
+		packages: overrides.packages,
+		atlas: atlasOptions
+	};
+}
+function dirname(filePath) {
+	return filePath.replace(/[/\\]+$/, "").match(/^(.*)[/\\][^/\\]+$/)?.[1] ?? "";
+}
+function createUnsupportedFsOperation(name) {
+	return async () => {
+		throw new Error(`publish: FileSystem.${name}() is not available in the publish writer adapter.`);
+	};
+}
+function toBinaryWriterFileSystem(fs) {
+	return {
+		readFile: createUnsupportedFsOperation("readFile"),
+		readFileRaw: createUnsupportedFsOperation("readFileRaw"),
+		writeFile: createUnsupportedFsOperation("writeFile"),
+		writeFileRaw: fs.writeFileRaw,
+		mkdir: fs.mkdir,
+		readdir: createUnsupportedFsOperation("readdir"),
+		exists: createUnsupportedFsOperation("exists"),
+		join: fs.join,
+		dirname
+	};
+}
+function isComponentResource(resource) {
+	return resource.propertyType === "Component";
+}
+function isImageResource(resource) {
+	return resource.propertyType === "ImageResource";
+}
+function isMovieClipResource(resource) {
+	return resource.propertyType === "MovieClipResource";
+}
+function isMiscResource(resource) {
+	return resource.propertyType === "MiscResource";
+}
+function isFontResource(resource) {
+	return resource.propertyType === "FontResource";
+}
+function isSoundResource(resource) {
+	return resource.propertyType === "SoundResource";
+}
+function isSpineResource(resource) {
+	return resource.propertyType === "SpineResource";
+}
+function isDragonBonesResource(resource) {
+	return resource.propertyType === "DragonBonesResource";
+}
+function isSkeletonResource(resource) {
+	return isSpineResource(resource) || isDragonBonesResource(resource);
+}
+function addLocalUiResourceRef(target, pkgId, value) {
+	if (!value || typeof value !== "string" || !value.startsWith(`ui://${pkgId}`) || value.length <= 13) return;
+	target.add(value.slice(13));
+}
+function addLocalUiResourceRefsFromText(target, pkgId, value) {
+	if (!value || typeof value !== "string") return;
+	const prefix = `ui://${pkgId}`;
+	let index = value.indexOf(prefix);
+	while (index !== -1) {
+		const start = index + prefix.length;
+		let end = start;
+		while (end < value.length && /[0-9a-z]/i.test(value[end] ?? "")) end++;
+		if (end > start) target.add(value.slice(start, end));
+		index = value.indexOf(prefix, end);
+	}
+}
+function addLocalUiResourceRefsFromUnknown(target, pkgId, value) {
+	if (Array.isArray(value)) {
+		for (const entry of value) addLocalUiResourceRefsFromUnknown(target, pkgId, entry);
+		return;
+	}
+	if (typeof value === "string") {
+		addLocalUiResourceRef(target, pkgId, value);
+		addLocalUiResourceRefsFromText(target, pkgId, value);
+	}
+}
+function addLocalFontRef(target, pkgId, value) {
+	if (Array.isArray(value)) {
+		for (const entry of value) addLocalUiResourceRef(target, pkgId, entry);
+		return;
+	}
+	addLocalUiResourceRef(target, pkgId, value ?? void 0);
+}
+function resolvePackageAssetsBasePath(basePath, resource) {
+	const branchName = resource?.getBranch?.() ?? "";
+	if (!branchName) return basePath;
+	const normalized = basePath.replace(/[/\\]+$/, "");
+	if (/[\\/]assets$/i.test(normalized)) return normalized.replace(/([\\/])assets$/i, `$1assets_${branchName}`);
+	return `${normalized}_${branchName}`;
+}
+function resolveImagePath(resource, pkg, basePath) {
+	const fileName = resolveImageFileName(resource);
+	const resourcePath = resource.getPath() ?? "/";
+	return `${resolvePackageAssetsBasePath(basePath, resource)}/${pkg.getName()}${resourcePath}${fileName}`;
+}
+function resolveImageFileName(resource) {
+	const extras = resource.getExtras() ?? {};
+	return resource.getFileName() || extras._fileName || resource.getName();
+}
+function resolveSoundPath(resource, pkg, basePath) {
+	const resourcePath = resource.getPath() ?? "/";
+	return `${resolvePackageAssetsBasePath(basePath, resource)}/${pkg.getName()}${resourcePath}${resource.getFile()}`;
+}
+function resolveGenericResourcePath(resource, pkg, basePath) {
+	const resourcePath = resource.getPath() ?? "/";
+	return `${resolvePackageAssetsBasePath(basePath, resource)}/${pkg.getName()}${resourcePath}${resource.getFile()}`;
+}
+function extname(fileName) {
+	const normalized = fileName.replace(/\\/g, "/");
+	const lastSlash = normalized.lastIndexOf("/");
+	const lastDot = normalized.lastIndexOf(".");
+	if (lastDot <= lastSlash) return "";
+	return normalized.slice(lastDot);
+}
+function resolvePublishedMiscFileName(resource) {
+	const file = resource.getFile();
+	if (file.toLowerCase().endsWith(".atlas")) return `${file}.txt`;
+	return file;
+}
+function resolvePublishedSkeletonFileName(resource) {
+	if (isSpineResource(resource) && resource.getFile().toLowerCase().endsWith(".skel")) return `${resource.getFile()}.bytes`;
+	return resource.getFile();
+}
+function setPublishedFileExtra(resource, fileName) {
+	const extras = resource.getExtras() ?? {};
+	resource.setExtras({
+		...extras,
+		_publishedFile: fileName
+	});
+}
+function setPublishedIdExtra(resource, effectiveId) {
+	const extras = resource.getExtras() ?? {};
+	if (!effectiveId || effectiveId === resource.getId()) {
+		if (!("_publishedId" in extras)) return;
+		const { _publishedId: _ignored, ...rest } = extras;
+		resource.setExtras(rest);
+		return;
+	}
+	resource.setExtras({
+		...extras,
+		_publishedId: effectiveId
+	});
+}
+function getPublishedId(resource) {
+	return (resource.getExtras() ?? {})._publishedId ?? resource.getId();
+}
+function getBranchName(resource) {
+	return resource?.getBranch?.() ?? "";
+}
+function buildBranchResourceKey(resource) {
+	return `${resource.propertyType}|${resource.getPath() ?? ""}|${resource.getName() ?? ""}`;
+}
+function collectPackagePublishContext(pkg, options) {
+	const pkgId = pkg.getId();
+	const resources = pkg.listResources();
+	const resourceMap = new Map(resources.map((resource) => [resource.getId(), resource]));
+	const referencedIds = /* @__PURE__ */ new Set();
+	const pixelHitTestImageIds = /* @__PURE__ */ new Set();
+	const spriteItemIds = /* @__PURE__ */ new Set();
+	for (const atlas of pkg.listAtlases()) for (const sprite of atlas.listSprites()) spriteItemIds.add(sprite.getItemId());
+	for (const resource of resources) {
+		if (!isComponentResource(resource)) continue;
+		const component = resource;
+		const children = component.listChildren();
+		const childMap = new Map(children.map((child) => [child.getId?.() ?? "", child]));
+		const hitTest = component.getHitTest?.()?.trim();
+		if (hitTest && !hitTest.includes(",")) {
+			const sourceId = childMap.get(hitTest)?.getSrc?.();
+			if (sourceId) {
+				const sourceResource = resourceMap.get(sourceId);
+				if (sourceResource && isImageResource(sourceResource)) pixelHitTestImageIds.add(sourceId);
+			}
+		}
+		for (const child of children) {
+			const src = child.getSrc?.();
+			if (src) referencedIds.add(src);
+			addLocalFontRef(referencedIds, pkgId, child.getFont?.());
+			addLocalUiResourceRefsFromText(referencedIds, pkgId, child.getText?.());
+			for (const ref of [
+				child.getUrl?.(),
+				child.getDefaultItem?.(),
+				child.getIcon?.(),
+				child.getSelectedIcon?.(),
+				child.getDropdown?.(),
+				child.getSound?.(),
+				child.getInstanceIcon?.(),
+				child.getInstanceSelectedIcon?.(),
+				child.getVtScrollBarRes?.(),
+				child.getHzScrollBarRes?.(),
+				child.getHeaderRes?.(),
+				child.getFooterRes?.()
+			]) addLocalUiResourceRef(referencedIds, pkgId, ref);
+			for (const item of child.getInstanceComboItems?.() ?? []) addLocalUiResourceRef(referencedIds, pkgId, item.icon ?? void 0);
+			for (const item of child.getListItems?.() ?? []) {
+				addLocalUiResourceRef(referencedIds, pkgId, item.icon ?? void 0);
+				addLocalUiResourceRef(referencedIds, pkgId, item.url ?? void 0);
+			}
+			for (const gear of child.listGears?.() ?? []) {
+				addLocalUiResourceRefsFromUnknown(referencedIds, pkgId, gear.getValues?.());
+				addLocalUiResourceRefsFromUnknown(referencedIds, pkgId, gear.getDefaultValue?.());
+			}
+		}
+		addLocalFontRef(referencedIds, pkgId, component.getFont?.());
+		for (const ref of [
+			component.getDropdown?.(),
+			component.getHeaderRes?.(),
+			component.getFooterRes?.(),
+			component.getVtScrollBarRes?.(),
+			component.getHzScrollBarRes?.(),
+			component.getSound?.()
+		]) addLocalUiResourceRef(referencedIds, pkgId, ref);
+		for (const transition of component.listTransitions?.() ?? []) for (const item of transition.listItems?.() ?? []) {
+			addLocalUiResourceRefsFromUnknown(referencedIds, pkgId, item.getStartValue?.());
+			addLocalUiResourceRefsFromUnknown(referencedIds, pkgId, item.getEndValue?.());
+		}
+	}
+	const publishedResourceIds = new Set(spriteItemIds);
+	for (const resource of resources) {
+		const resourceId = resource.getId();
+		if (!resourceId) continue;
+		if (isComponentResource(resource)) {
+			if (resource.getExported() || referencedIds.has(resourceId)) publishedResourceIds.add(resourceId);
+			continue;
+		}
+		if (isImageResource(resource)) {
+			if (resource.getExported() || referencedIds.has(resourceId) || spriteItemIds.has(resourceId) || pixelHitTestImageIds.has(resourceId)) publishedResourceIds.add(resourceId);
+			continue;
+		}
+		if (isMovieClipResource(resource) || isSoundResource(resource)) {
+			if (resource.getExported() || referencedIds.has(resourceId)) publishedResourceIds.add(resourceId);
+			continue;
+		}
+		if (isMiscResource(resource) || isSkeletonResource(resource)) {
+			if (resource.getExported() || referencedIds.has(resourceId)) publishedResourceIds.add(resourceId);
+			continue;
+		}
+		if (isFontResource(resource)) {
+			if (resource.getExported() || referencedIds.has(resourceId)) publishedResourceIds.add(resourceId);
+			continue;
+		}
+		if (resource.getExported() || referencedIds.has(resourceId)) publishedResourceIds.add(resourceId);
+	}
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const resource of resources) {
+			if (!isSkeletonResource(resource)) continue;
+			if (!publishedResourceIds.has(resource.getId())) continue;
+			for (const requiredId of resource.getRequireIds()) {
+				if (!requiredId || publishedResourceIds.has(requiredId)) continue;
+				publishedResourceIds.add(requiredId);
+				changed = true;
+			}
+		}
+	}
+	if (!options.includeBranches) {
+		const mainByKey = /* @__PURE__ */ new Map();
+		const activeBranchByKey = /* @__PURE__ */ new Map();
+		for (const resource of resources) {
+			const branchName = getBranchName(resource);
+			const key = buildBranchResourceKey(resource);
+			if (!branchName) mainByKey.set(key, resource);
+			else if (branchName === options.activeBranch) activeBranchByKey.set(key, resource);
+		}
+		const mergedPublishedResourceIds = /* @__PURE__ */ new Set();
+		const effectiveResourceIds = /* @__PURE__ */ new Map();
+		for (const resource of resources) {
+			const resourceId = resource.getId();
+			if (!publishedResourceIds.has(resourceId)) continue;
+			const branchName = getBranchName(resource);
+			const key = buildBranchResourceKey(resource);
+			if (branchName) {
+				if (branchName !== options.activeBranch) continue;
+				const mainResource = mainByKey.get(key);
+				mergedPublishedResourceIds.add(resourceId);
+				effectiveResourceIds.set(resourceId, mainResource?.getId() ?? resourceId);
+				continue;
+			}
+			const override = activeBranchByKey.get(key);
+			if (override) {
+				mergedPublishedResourceIds.add(override.getId());
+				effectiveResourceIds.set(override.getId(), resourceId);
+				continue;
+			}
+			mergedPublishedResourceIds.add(resourceId);
+			effectiveResourceIds.set(resourceId, resourceId);
+		}
+		publishedResourceIds.clear();
+		for (const resourceId of mergedPublishedResourceIds) publishedResourceIds.add(resourceId);
+		const mergedPixelHitTestImageIds = /* @__PURE__ */ new Set();
+		for (const resource of resources) {
+			if (!isImageResource(resource)) continue;
+			const resourceId = resource.getId();
+			if (!publishedResourceIds.has(resourceId)) continue;
+			const effectiveId = effectiveResourceIds.get(resourceId) ?? resourceId;
+			if (pixelHitTestImageIds.has(effectiveId)) mergedPixelHitTestImageIds.add(resourceId);
+		}
+		pixelHitTestImageIds.clear();
+		for (const resourceId of mergedPixelHitTestImageIds) pixelHitTestImageIds.add(resourceId);
+		return {
+			referencedIds,
+			publishedResourceIds,
+			pixelHitTestImageIds,
+			effectiveResourceIds,
+			includeBranches: false
+		};
+	}
+	return {
+		referencedIds,
+		publishedResourceIds,
+		pixelHitTestImageIds,
+		effectiveResourceIds: new Map([...publishedResourceIds].map((resourceId) => [resourceId, resourceId])),
+		includeBranches: true
+	};
+}
+async function applyPixelHitTests(pkg, imageIds, basePath, encoder) {
+	const images = pkg.listImageResources();
+	for (const image of images) image.setPixelHitTestData(null);
+	if (!basePath || !encoder || imageIds.size === 0) return;
+	for (const image of images) {
+		const imageId = image.getId();
+		if (!imageIds.has(imageId)) continue;
+		try {
+			const sourcePath = resolveImagePath(image, pkg, basePath);
+			const metadata = await encoder(sourcePath).metadata();
+			if (!metadata.width || !metadata.height) continue;
+			const resizedWidth = Math.max(1, Math.floor(metadata.width / 2));
+			const resizedHeight = Math.max(1, Math.floor(metadata.height / 2));
+			const { data, info } = await encoder(sourcePath).ensureAlpha().resize({
+				width: resizedWidth,
+				height: resizedHeight,
+				fit: "fill"
+			}).raw().toBuffer({ resolveWithObject: true });
+			const pixelCount = info.width * info.height;
+			const maskBytes = new Uint8Array(Math.ceil(pixelCount / 8));
+			let byteValue = 0;
+			let bitIndex = 0;
+			let maskIndex = 0;
+			for (let pixel = 0; pixel < pixelCount; pixel++) {
+				if (data[pixel * info.channels + 3] > 10) byteValue |= 1 << bitIndex;
+				bitIndex++;
+				if (bitIndex === 8) {
+					maskBytes[maskIndex++] = byteValue;
+					bitIndex = 0;
+					byteValue = 0;
+				}
+			}
+			if (bitIndex !== 0) maskBytes[maskIndex] = byteValue;
+			image.setPixelHitTestData({
+				pixelWidth: info.width,
+				scaleDenominator: 2,
+				pixels: maskBytes
+			});
+		} catch {
+			image.setPixelHitTestData(null);
+		}
+	}
+}
+async function annotatePackagePublishArtifacts(pkg, basePath, encoder, options) {
+	const { publishedResourceIds, pixelHitTestImageIds, effectiveResourceIds, includeBranches } = collectPackagePublishContext(pkg, options);
+	for (const resource of pkg.listResources()) setPublishedIdExtra(resource, effectiveResourceIds.get(resource.getId()) ?? null);
+	await applyPixelHitTests(pkg, pixelHitTestImageIds, basePath, encoder);
+	const extras = pkg.getExtras() ?? {};
+	pkg.setExtras({
+		...extras,
+		publishedResourceIds: [...publishedResourceIds].sort((a, b) => a.localeCompare(b)),
+		publishedIncludeBranches: includeBranches,
+		publishedEffectiveResourceIds: Object.fromEntries(effectiveResourceIds)
+	});
+	for (const resource of pkg.listResources()) {
+		if (isMiscResource(resource)) {
+			setPublishedFileExtra(resource, resolvePublishedMiscFileName(resource));
+			continue;
+		}
+		if (isSkeletonResource(resource)) setPublishedFileExtra(resource, resolvePublishedSkeletonFileName(resource));
+	}
+}
+function getAnnotatedPublishedResourceIds(pkg) {
+	const extras = pkg.getExtras() ?? {};
+	return new Set(extras.publishedResourceIds ?? []);
+}
+function getPublishedSkeletonDependencyImageIds(pkg, publishedResourceIds) {
+	const imageIds = /* @__PURE__ */ new Set();
+	const resourcesById = new Map(pkg.listResources().map((resource) => [resource.getId(), resource]));
+	for (const resource of pkg.listResources()) {
+		if (!isSkeletonResource(resource)) continue;
+		if (!publishedResourceIds.has(resource.getId())) continue;
+		for (const requiredId of resource.getRequireIds()) {
+			if (!requiredId) continue;
+			const required = resourcesById.get(requiredId);
+			if (required && isImageResource(required)) imageIds.add(requiredId);
+		}
+	}
+	return imageIds;
+}
+async function exportPackageSounds(pkg, outputDir, basePath, fs, readFileRaw, logger) {
+	const publishedResourceIds = getAnnotatedPublishedResourceIds(pkg);
+	if (publishedResourceIds.size === 0) return;
+	if (!basePath || !readFileRaw) {
+		if (pkg.listResources().some((resource) => {
+			return isSoundResource(resource) && publishedResourceIds.has(resource.getId());
+		})) logger.warn(`publish: Sound resources in package "${pkg.getName()}" were not exported because basePath/readFileRaw is unavailable.`);
+		return;
+	}
+	for (const resource of pkg.listResources()) {
+		if (!isSoundResource(resource)) continue;
+		if (!publishedResourceIds.has(resource.getId())) continue;
+		const sourcePath = resolveSoundPath(resource, pkg, basePath);
+		const targetName = `${pkg.getPublishName() || pkg.getName()}_${getPublishedId(resource)}${extname(resource.getFile() || "")}`;
+		const targetPath = fs.join(outputDir, targetName);
+		try {
+			const data = await readFileRaw(sourcePath);
+			await fs.writeFileRaw(targetPath, data);
+		} catch {
+			logger.warn(`publish: Could not export sound "${resource.getId()}" from package "${pkg.getName()}".`);
+		}
+	}
+}
+async function exportPackageExternalResources(pkg, outputDir, basePath, fs, readFileRaw, logger) {
+	const publishedResourceIds = getAnnotatedPublishedResourceIds(pkg);
+	const skeletonDependencyImageIds = getPublishedSkeletonDependencyImageIds(pkg, publishedResourceIds);
+	if (publishedResourceIds.size === 0) return;
+	if (!basePath || !readFileRaw) {
+		if (pkg.listResources().some((resource) => {
+			return (isMiscResource(resource) || isSkeletonResource(resource)) && publishedResourceIds.has(resource.getId()) || skeletonDependencyImageIds.has(resource.getId());
+		})) logger.warn(`publish: External resources in package "${pkg.getName()}" were not exported because basePath/readFileRaw is unavailable.`);
+		return;
+	}
+	for (const resource of pkg.listResources()) {
+		const resourceId = resource.getId();
+		const isSkeletonExternal = publishedResourceIds.has(resourceId) && (isMiscResource(resource) || isSkeletonResource(resource));
+		const isSkeletonImageDependency = skeletonDependencyImageIds.has(resourceId) && isImageResource(resource);
+		if (!isSkeletonExternal && !isSkeletonImageDependency) continue;
+		let sourcePath;
+		let targetName;
+		if (isSkeletonImageDependency) {
+			sourcePath = resolveImagePath(resource, pkg, basePath);
+			targetName = resolveImageFileName(resource);
+		} else if (isMiscResource(resource) || isSkeletonResource(resource)) {
+			sourcePath = resolveGenericResourcePath(resource, pkg, basePath);
+			targetName = (resource.getExtras() ?? {})._publishedFile ?? resource.getFile();
+		} else continue;
+		const targetPath = fs.join(outputDir, targetName);
+		try {
+			const data = await readFileRaw(sourcePath);
+			await fs.writeFileRaw(targetPath, data);
+		} catch {
+			logger.warn(`publish: Could not export external resource "${resource.getId()}" from package "${pkg.getName()}".`);
+		}
+	}
+}
+/**
+* Publishes a FairyGUI project.
+*
+* Orchestrates:
+* 1. Atlas packing (MaxRects layout + optional sharp compositing)
+* 2. Per-package .fui binary serialization
+* 3. File writing to the output directory
+*
+* ```ts
+* import sharp from 'sharp';
+* const io = new NodeIO();
+* const doc = await io.readProject('./project.fairy');
+*
+* await doc.transform(publish({
+*   output: './release/',
+*   compressed: true,
+*   encoder: sharp,
+*   basePath: './assets/',
+*   fileExtension: 'bytes',
+*   fs: io.createFileSystem(),
+* }));
+* ```
+*/
+function publish(options) {
+	return createTransform("publish", async (doc) => {
+		const root = doc.getRoot();
+		const logger = doc.getLogger();
+		const publishSettings = (root.getSettings?.() ?? {}).publish ?? {};
+		const resolved = resolvePublishOptions(doc, {
+			compressed: options.compressed,
+			fileExtension: options.fileExtension,
+			packages: options.packages,
+			atlas: options.atlas
+		});
+		const ext = resolved.fileExtension;
+		let allPackages = root.listPackages();
+		if (resolved.packages && resolved.packages.length > 0) {
+			const names = new Set(resolved.packages);
+			allPackages = allPackages.filter((p) => names.has(p.getName()));
+		}
+		if (allPackages.length === 0) {
+			logger.warn("publish: No packages to publish.");
+			return;
+		}
+		const includeBranches = (publishSettings.branchProcessing ?? 0) === 0;
+		const activeBranch = includeBranches ? "" : options.branch ?? "";
+		const atlasRuntimeOptions = resolvePublishAtlasRuntimeOptions(ext);
+		const allDocPackages = root.listPackages();
+		const pkgMap = /* @__PURE__ */ new Map();
+		for (const p of allDocPackages) pkgMap.set(p.getId(), p);
+		for (const pkg of allPackages) {
+			_computeDependencies(pkg, pkgMap);
+			await annotatePackagePublishArtifacts(pkg, options.basePath, options.encoder, {
+				includeBranches,
+				activeBranch
+			});
+		}
+		await atlas({
+			...resolved.atlas,
+			...options.atlas ?? {},
+			separatedAtlasForBranch: includeBranches && publishSettings.seperatedAtlasForBranch === true,
+			encoder: options.encoder,
+			basePath: options.basePath,
+			outputPath: options.fs ? options.output : void 0,
+			mkdir: options.fs ? options.fs.mkdir : void 0,
+			readFileRaw: options.atlas?.readFileRaw ?? options.fs?.readFileRaw,
+			...atlasRuntimeOptions
+		})(doc);
+		if (!options.fs) {
+			logger.info(`publish: No fs provided — layout computed for ${allPackages.length} package(s), skipping file output.`);
+			return;
+		}
+		await options.fs.mkdir(options.output);
+		const writerFs = toBinaryWriterFileSystem(options.fs);
+		for (const pkg of allPackages) {
+			const pkgIndex = allDocPackages.indexOf(pkg);
+			const fileName = resolvePublishFileName(pkg.getPublishName() || pkg.getName(), ext);
+			const filePath = options.fs.join(options.output, fileName);
+			const bwOptions = {
+				compressed: resolved.compressed,
+				packageIndex: pkgIndex
+			};
+			await new _openfairygui_core.BinaryWriter(writerFs).write(doc, filePath, bwOptions);
+			await exportPackageSounds(pkg, options.output, options.basePath, options.fs, options.atlas?.readFileRaw ?? options.fs.readFileRaw, logger);
+			await exportPackageExternalResources(pkg, options.output, options.basePath, options.fs, options.atlas?.readFileRaw ?? options.fs.readFileRaw, logger);
+			logger.info(`publish: Written ${fileName}`);
+		}
+		await publishCodeGeneration(doc, {
+			basePath: options.basePath,
+			fs: options.fs,
+			packages: allPackages
+		});
+		logger.info(`publish: Published ${allPackages.length} package(s) to ${options.output}`);
+	});
+}
+/**
+* Scan component children for font="ui://..." references to build dependency list.
+* The editor only adds dependencies for packages referenced via bitmap font URLs.
+* @internal
+*/
+function _computeDependencies(pkg, pkgMap) {
+	const referencedPkgIds = /* @__PURE__ */ new Set();
+	function scanFontUrl(font) {
+		if (!font) return;
+		const fontStr = Array.isArray(font) ? font[0] : String(font);
+		if (typeof fontStr !== "string" || !fontStr.startsWith("ui://")) return;
+		const rest = fontStr.slice(5);
+		if (rest.length >= 8) {
+			const depPkgId = rest.slice(0, 8);
+			if (depPkgId !== pkg.getId()) referencedPkgIds.add(depPkgId);
+		}
+	}
+	for (const res of pkg.listResources()) {
+		if (res.propertyType !== "Component") continue;
+		for (const child of res.listChildren?.() ?? []) scanFontUrl(child.getFont?.());
+	}
+	for (const dep of pkg.listDependencies()) pkg.removeDependency(dep);
+	if (referencedPkgIds.size > 0) {
+		const sortedIds = [...referencedPkgIds].sort((a, b) => a.localeCompare(b));
+		for (const refId of sortedIds) {
+			const depPkg = pkgMap.get(refId);
+			if (depPkg) pkg.addDependency(depPkg);
+		}
+	}
+}
+//#endregion
+exports.AUTO_GENERATED_CODE_MARK = AUTO_GENERATED_CODE_MARK;
+exports.ValidationSeverity = ValidationSeverity;
+exports.atlas = atlas;
+exports.createTransform = createTransform;
+exports.inspect = inspect;
+exports.prune = prune;
+exports.publish = publish;
+exports.publishCodeGeneration = publishCodeGeneration;
+exports.rename = rename;
+exports.resolvePublishOptions = resolvePublishOptions;
+exports.validate = validate;