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

package/dist/publish-BJ_eelME.js

@@ -0,0 +1,3267 @@
+import { BinaryWriter, GearType, ProjectType, TransitionActionType } from "@openfairygui/core";
+//#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;
+}
+function parseTextureSetMode(value) {
+	const raw = value?.trim() ?? "";
+	if (!raw) return {
+		kind: "auto",
+		raw: ""
+	};
+	if (raw === "alone") return {
+		kind: "standalone",
+		raw,
+		sizeMode: "default"
+	};
+	if (raw === "alone_npot") return {
+		kind: "standalone",
+		raw,
+		sizeMode: "npot"
+	};
+	if (raw === "alone_mof") return {
+		kind: "standalone",
+		raw,
+		sizeMode: "multipleOf4"
+	};
+	if (/^\d+$/.test(raw)) {
+		const pageIndex = Number(raw);
+		if (pageIndex >= 0 && pageIndex <= 10) return {
+			kind: "page",
+			raw,
+			pageIndex
+		};
+	}
+	return {
+		kind: "auto",
+		raw
+	};
+}
+//#endregion
+//#region src/publish/resource-references.ts
+function addReference(target, ownerPackageId, packageId, resourceId) {
+	if (!packageId || !resourceId) return;
+	if (packageId === ownerPackageId) target.localResourceIds.add(resourceId);
+	else target.packageIds.add(packageId);
+}
+function addUiReference(target, ownerPackageId, value) {
+	if (!value?.startsWith("ui://")) return;
+	const reference = value.slice(5);
+	const slashIndex = reference.indexOf("/");
+	if (slashIndex >= 0) {
+		addReference(target, ownerPackageId, reference.slice(0, slashIndex), reference.slice(slashIndex + 1));
+		return;
+	}
+	if (reference.length > 8) addReference(target, ownerPackageId, reference.slice(0, 8), reference.slice(8));
+}
+function addTextReferences(target, ownerPackageId, value) {
+	if (!value) return;
+	for (const match of value.matchAll(/ui:\/\/([0-9a-z]{8})\/?([0-9a-z]+)/giu)) addReference(target, ownerPackageId, match[1] ?? "", match[2] ?? "");
+}
+function addUnknownReferences(target, ownerPackageId, value) {
+	if (Array.isArray(value)) {
+		for (const entry of value) addUnknownReferences(target, ownerPackageId, entry);
+		return;
+	}
+	if (typeof value === "string") {
+		addUiReference(target, ownerPackageId, value);
+		addTextReferences(target, ownerPackageId, value);
+	}
+}
+function addFontReferences(target, ownerPackageId, value) {
+	if (Array.isArray(value)) {
+		for (const entry of value) addUiReference(target, ownerPackageId, entry);
+		return;
+	}
+	addUiReference(target, ownerPackageId, value);
+}
+function collectComponentReferences(target, ownerPackageId, component) {
+	const referenceComponent = component;
+	for (const child of referenceComponent.listChildren()) {
+		const sourceId = child.getSrc?.();
+		if (sourceId) if (sourceId.startsWith("ui://")) addUiReference(target, ownerPackageId, sourceId);
+		else target.localResourceIds.add(sourceId);
+		const sourcePackageId = child.getPackageId?.()?.trim();
+		if (sourcePackageId && sourcePackageId !== ownerPackageId) target.packageIds.add(sourcePackageId);
+		addFontReferences(target, ownerPackageId, child.getFont?.());
+		addTextReferences(target, ownerPackageId, child.getText?.());
+		for (const reference of [
+			child.getUrl?.(),
+			child.getDefaultItem?.(),
+			child.getIcon?.(),
+			child.getSelectedIcon?.(),
+			child.getDropdown?.(),
+			child.getSound?.(),
+			child.getInstanceSound?.(),
+			child.getInstanceIcon?.(),
+			child.getInstanceSelectedIcon?.(),
+			child.getVtScrollBarRes?.(),
+			child.getHzScrollBarRes?.(),
+			child.getHeaderRes?.(),
+			child.getFooterRes?.()
+		]) addUiReference(target, ownerPackageId, reference);
+		for (const item of child.getInstanceComboItems?.() ?? []) addUiReference(target, ownerPackageId, item.icon);
+		for (const item of child.getListItems?.() ?? []) {
+			addUiReference(target, ownerPackageId, item.icon);
+			addUiReference(target, ownerPackageId, item.url);
+		}
+		for (const gear of child.listGears?.() ?? []) {
+			addUnknownReferences(target, ownerPackageId, gear.getValues?.());
+			addUnknownReferences(target, ownerPackageId, gear.getDefaultValue?.());
+		}
+	}
+	addFontReferences(target, ownerPackageId, referenceComponent.getFont?.());
+	for (const reference of [
+		referenceComponent.getDropdown?.(),
+		referenceComponent.getHeaderRes?.(),
+		referenceComponent.getFooterRes?.(),
+		referenceComponent.getVtScrollBarRes?.(),
+		referenceComponent.getHzScrollBarRes?.(),
+		referenceComponent.getSound?.()
+	]) addUiReference(target, ownerPackageId, reference);
+	for (const transition of referenceComponent.listTransitions?.() ?? []) for (const item of transition.listItems?.() ?? []) {
+		addUnknownReferences(target, ownerPackageId, item.getStartValue?.());
+		addUnknownReferences(target, ownerPackageId, item.getEndValue?.());
+	}
+}
+/**
+* Enumerates package-local resource IDs and external package IDs referenced by
+* component content. Callers retain policy decisions such as atlas selection
+* and dependency ordering.
+*/
+function collectPackageResourceReferences(pkg) {
+	const references = {
+		localResourceIds: /* @__PURE__ */ new Set(),
+		packageIds: /* @__PURE__ */ new Set()
+	};
+	for (const resource of pkg.listResources()) if (resource.propertyType === "Component") collectComponentReferences(references, pkg.getId(), resource);
+	return references;
+}
+//#endregion
+//#region src/atlas/font.ts
+/** Parse a BMFont .fnt text file into structured data for binary encoding. */
+function parseFnt(text) {
+	const lines = text.split(/\r?\n/);
+	let hasFace = false;
+	let colored = false;
+	let resizable = false;
+	let hasChannel = false;
+	let fontSize = 0;
+	let globalXadvance = 0;
+	let 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 index = 1; index < parts.length; index += 1) {
+			const entry = parts[index]?.split("=") ?? [];
+			if (entry.length === 2 && entry[0]) attrs[entry[0]] = entry[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 channel = parseInt(attrs.chnl ?? "", 10) || 0;
+				if (channel !== 0 && channel !== 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
+				});
+				break;
+			}
+		}
+	}
+	return {
+		hasFace,
+		colored,
+		resizable: fontSize > 0 ? resizable : false,
+		hasChannel,
+		fontSize,
+		xadvance: globalXadvance,
+		lineHeight,
+		glyphs
+	};
+}
+//#endregion
+//#region src/atlas/jta.ts
+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 signatureIndex = findPngSignature(data, offset);
+		if (signatureIndex === -1) break;
+		if (firstPngOffset === -1) firstPngOffset = signatureIndex;
+		const end = findPngEnd(data, signatureIndex);
+		if (end === -1) break;
+		frames.push(data.subarray(signatureIndex, 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 signatureIndex = 0; signatureIndex < PNG_SIGNATURE.length; signatureIndex += 1) if (data[index + signatureIndex] !== PNG_SIGNATURE[signatureIndex]) {
+			matched = false;
+			break;
+		}
+		if (matched) return index;
+	}
+	return -1;
+}
+function findPngEnd(data, start) {
+	let position = start + PNG_SIGNATURE.length;
+	while (position + 8 <= data.length) {
+		const length = readUint32BE(data, position);
+		position += 8;
+		if (position + length + 4 > data.length) return -1;
+		const isEnd = data[position - 4] === 73 && data[position - 3] === 69 && data[position - 2] === 78 && data[position - 1] === 68;
+		position += length + 4;
+		if (isEnd) return position;
+	}
+	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);
+}
+//#endregion
+//#region src/atlas/inputs.ts
+function getPublishedItemId(resource) {
+	return (resource.getExtras() ?? {})._publishedId ?? resource.getId();
+}
+function resolveFontFileName(fontName) {
+	return /\.fnt$/i.test(fontName) ? fontName : `${fontName}.fnt`;
+}
+function resolveImageFileName$1(resource) {
+	const extras = resource.getExtras();
+	return resource.getFileName() || extras._fileName || resource.getName();
+}
+/**
+* Trim transparent edges from an image using the host raster backend.
+* 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, input, originalWidth, originalHeight) {
+	try {
+		const trimResult = await encoder(input).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(input).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(input).png().toBuffer(),
+			width: originalWidth,
+			height: originalHeight,
+			offsetX: 0,
+			offsetY: 0,
+			originalWidth,
+			originalHeight
+		};
+	}
+}
+/**
+* Resolve an ImageResource to its actual file path on disk.
+*/
+function resolveImagePath$1(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;
+	const declaredWidth = origW;
+	const declaredHeight = origH;
+	let sourceHasAlpha = false;
+	let rasterizedBuffer;
+	if (encoder && options.basePath) {
+		const filePath = resolveImagePath$1(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;
+			if (/\.svg$/i.test(resolveImageFileName$1(resource)) && declaredWidth > 0 && declaredHeight > 0) {
+				rasterizedBuffer = await encoder(filePath).resize({
+					width: declaredWidth,
+					height: declaredHeight,
+					fit: "fill"
+				}).png().toBuffer();
+				sourceHasAlpha = true;
+			}
+		} catch {
+			if (options.strictOutput) throw new Error(`atlas: Could not read image "${filePath}".`);
+			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$1(resource, pkg, options.basePath);
+		try {
+			const trimResult = await _trimImage(encoder, rasterizedBuffer ?? 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,
+		rasterizedBuffer,
+		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) {
+		if (options.strictOutput) throw new Error(`atlas: MovieClip "${resource.getId()}" requires basePath and readFileRaw for complete raster output.`);
+		return;
+	}
+	if (!encoder && options.strictOutput) throw new Error(`atlas: MovieClip "${resource.getId()}" requires an encoder for complete raster output.`);
+	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, options.strictOutput);
+				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, options.strictOutput);
+			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 {
+		const message = `atlas: Could not parse MovieClip "${filePath}".`;
+		if (options.strictOutput) throw new Error(message);
+		logger.warn(`${message} Skipping frames.`);
+	}
+}
+async function createMovieClipFrameInput(buffer, itemId, resource, encoder, strictOutput) {
+	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 {
+		if (strictOutput) throw new Error(`atlas: Could not decode MovieClip frame "${itemId}".`);
+		return null;
+	}
+}
+/** Collect a Bitmap Font's texture image, packed under the font's ID. */
+async function collectFontTexture(doc, fontRes, pkg, options) {
+	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 {}
+	}
+}
+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 isResolvedBuffer(value) {
+	return typeof value === "object" && value !== null && "data" in value && "info" in value;
+}
+//#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(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 = 2 ** w;
+		const height = 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/packing.ts
+async function emitAtlasInputs(input) {
+	const { doc, pkg, allResources, inputs, options, encoder, logger } = input;
+	let totalPageCount = 0;
+	let usedDirectOutput = false;
+	const { autoInputs, fixedPageGroups, standaloneGroups, reservedPageIndexes } = groupStandaloneInputs(doc, inputs, options);
+	const branchGroups = buildBranchAtlasGroups(doc, autoInputs, options);
+	const branchPageOffsets = /* @__PURE__ */ new Map();
+	for (const group of branchGroups) {
+		const directOutput = fixedPageGroups.length === 0 && standaloneGroups.length === 0 ? resolveDirectImageOutput(group.inputs, options) : null;
+		if (directOutput) {
+			await emitDirectImageOutput(doc, pkg, directOutput, encoder, options, logger, group.branchName, group.branchOrdinal);
+			usedDirectOutput = true;
+			totalPageCount += 1;
+			continue;
+		}
+		const pageStart = reserveAutoPageStart(branchPageOffsets, group.branchOrdinal, reservedPageIndexes);
+		const emittedPageCount = await emitPagedAtlasGroup(doc, pkg, allResources, group.inputs, {
+			branchName: group.branchName,
+			branchOrdinal: group.branchOrdinal,
+			pageStart,
+			fileNameAt: (pageIndex) => resolveAtlasOutputFileName(pkg, pageIndex, group.branchName),
+			options,
+			encoder,
+			logger
+		});
+		totalPageCount += emittedPageCount;
+		branchPageOffsets.set(group.branchOrdinal, pageStart + emittedPageCount);
+	}
+	for (const group of fixedPageGroups) {
+		const emittedPageCount = await emitPagedAtlasGroup(doc, pkg, allResources, group.inputs, {
+			branchName: group.branchName,
+			branchOrdinal: group.branchOrdinal,
+			pageStart: group.pageIndex,
+			forceSinglePage: true,
+			fileNameAt: () => resolveAtlasOutputFileName(pkg, group.pageIndex, group.branchName),
+			options,
+			encoder,
+			logger
+		});
+		totalPageCount += emittedPageCount;
+	}
+	const standalonePageOffsets = new Map(branchPageOffsets);
+	for (const group of fixedPageGroups) {
+		const nextPageIndex = group.pageIndex + 1;
+		if (nextPageIndex > (standalonePageOffsets.get(group.branchOrdinal) ?? 0)) standalonePageOffsets.set(group.branchOrdinal, nextPageIndex);
+	}
+	for (const group of standaloneGroups) {
+		const emittedPageCount = await emitStandaloneAtlasGroup(doc, pkg, group, {
+			atlasIndexStart: standalonePageOffsets.get(group.branchOrdinal) ?? 0,
+			options,
+			encoder,
+			logger
+		});
+		totalPageCount += emittedPageCount;
+		standalonePageOffsets.set(group.branchOrdinal, (standalonePageOffsets.get(group.branchOrdinal) ?? 0) + emittedPageCount);
+	}
+	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 reserveAutoPageStart(branchPageOffsets, branchOrdinal, reservedPageIndexes) {
+	let pageIndex = branchPageOffsets.get(branchOrdinal) ?? 0;
+	while (branchOrdinal === 0 && reservedPageIndexes.has(pageIndex)) pageIndex += 1;
+	return pageIndex;
+}
+async function emitPagedAtlasGroup(doc, pkg, allResources, inputs, context) {
+	if (inputs.length === 0) return 0;
+	const pages = packAtlasPages(inputs, context.options, context.forceSinglePage === true);
+	assertPackedInputCoverage(pages, inputs.length, `package "${pkg.getName()}"`);
+	for (let pageOffset = 0; pageOffset < pages.length; pageOffset += 1) {
+		const page = pages[pageOffset];
+		const pageIndex = context.pageStart + pageOffset;
+		const atlasNode = doc.createAtlas(`atlas${resolveAtlasIndex(context.branchOrdinal, pageIndex)}`);
+		atlasNode.setIndex(resolveAtlasIndex(context.branchOrdinal, pageIndex));
+		atlasNode.setFile(context.fileNameAt(pageIndex));
+		atlasNode.setWidth(page.width);
+		atlasNode.setHeight(page.height);
+		pkg.addAtlas(atlasNode);
+		attachSpritesToAtlas(doc, allResources, inputs, page.outputRects, atlasNode);
+		await writeAtlasPageImage(pkg, inputs, page, atlasNode.getFile(), context.encoder, context.options, context.logger);
+	}
+	return pages.length;
+}
+async function emitStandaloneAtlasGroup(doc, pkg, group, context) {
+	if (group.inputs.length === 0) return 0;
+	const pages = packAtlasPages(group.inputs, context.options, true, group.sizeMode === "npot" ? {
+		powerOfTwo: false,
+		multipleOfFour: false,
+		square: false
+	} : group.sizeMode === "multipleOf4" ? {
+		powerOfTwo: false,
+		multipleOfFour: true,
+		square: false
+	} : void 0);
+	assertPackedInputCoverage(pages, group.inputs.length, `standalone texture in package "${pkg.getName()}"`);
+	for (let pageOffset = 0; pageOffset < pages.length; pageOffset += 1) {
+		const page = pages[pageOffset];
+		const baseFileName = resolveStandaloneAtlasOutputFileName(pkg, group.resource, group.branchName);
+		const atlasFileName = pages.length <= 1 ? baseFileName : insertFileNameSuffix(baseFileName, `_${pageOffset}`);
+		const atlasIndex = context.atlasIndexStart + pageOffset;
+		const atlasNode = doc.createAtlas(`atlas${resolveAtlasIndex(group.branchOrdinal, atlasIndex)}`);
+		atlasNode.setIndex(resolveAtlasIndex(group.branchOrdinal, atlasIndex));
+		atlasNode.setFile(atlasFileName);
+		const standaloneSize = resolveStandaloneAtlasSize(page.width, page.height, group.sizeMode, context.options);
+		atlasNode.setWidth(standaloneSize.width);
+		atlasNode.setHeight(standaloneSize.height);
+		pkg.addAtlas(atlasNode);
+		attachSpritesToAtlas(doc, [], group.inputs, page.outputRects, atlasNode);
+		await writeAtlasPageImage(pkg, group.inputs, {
+			...page,
+			width: standaloneSize.width,
+			height: standaloneSize.height
+		}, atlasFileName, context.encoder, context.options, context.logger);
+	}
+	return pages.length;
+}
+function packAtlasPages(inputs, options, forceSinglePage, sizeOverrides) {
+	const hasDuplicatePadding = inputs.some((input) => {
+		return isImageResource$1(input.resource) && input.resource.getDuplicatePadding?.() === true;
+	});
+	return new MaxRectsPackerCompat({
+		pot: sizeOverrides?.powerOfTwo ?? options.powerOfTwo,
+		mof: sizeOverrides?.multipleOfFour ?? !options.powerOfTwo,
+		padding: options.padding,
+		rotation: options.allowRotation,
+		minWidth: 16,
+		minHeight: 16,
+		maxWidth: options.maxSize,
+		maxHeight: options.maxSize,
+		square: sizeOverrides?.square ?? options.square,
+		fast: options.fast,
+		edgePadding: false,
+		duplicatePadding: hasDuplicatePadding,
+		multiPage: forceSinglePage ? false : options.multiPage,
+		preserveInputOrderOnTie: options.preserveInputOrderOnTie
+	}).pack(inputs.map((input, index) => inputToCompatRect(input, index))) ?? [];
+}
+function assertPackedInputCoverage(pages, inputCount, label) {
+	const packedIndexes = /* @__PURE__ */ new Set();
+	for (const page of pages) for (const outputRect of page.outputRects) packedIndexes.add(outputRect.index);
+	const hasEveryInput = Array.from({ length: inputCount }, (_, index) => packedIndexes.has(index)).every(Boolean);
+	if (packedIndexes.size !== inputCount || !hasEveryInput) throw new Error(`atlas: Could not pack every input for ${label}.`);
+}
+function attachSpritesToAtlas(doc, allResources, inputs, outputRects, atlasNode) {
+	for (const packedRect of outputRects) {
+		const input = inputs[packedRect.index];
+		if (!input) continue;
+		const packedSize = resolvePackedRectSize(input, packedRect.width, packedRect.height, packedRect.rotated);
+		const sprite = doc.createSprite();
+		sprite.setItemId(input.id);
+		sprite.setRectX(packedRect.x);
+		sprite.setRectY(packedRect.y);
+		sprite.setRectWidth(packedSize.width);
+		sprite.setRectHeight(packedSize.height);
+		sprite.setRotated(packedRect.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 resource of allResources) {
+		if (!isFontResource$1(resource)) continue;
+		const alias = resource.getExtras()?._fontSpriteAlias;
+		if (!alias) continue;
+		const imageSprite = outputRects.find((result) => inputs[result.index]?.id === alias.textureId);
+		if (!imageSprite) continue;
+		const imageInput = inputs[imageSprite.index];
+		const fontSprite = doc.createSprite();
+		fontSprite.setItemId(alias.fontId);
+		fontSprite.setRectX(imageSprite.x);
+		fontSprite.setRectY(imageSprite.y);
+		fontSprite.setRectWidth(imageSprite.width);
+		fontSprite.setRectHeight(imageSprite.height);
+		fontSprite.setRotated(imageSprite.rotated);
+		if (imageInput) {
+			fontSprite.setOffsetX(imageInput.offsetX);
+			fontSprite.setOffsetY(imageInput.offsetY);
+			fontSprite.setOriginalWidth(imageInput.originalWidth);
+			fontSprite.setOriginalHeight(imageInput.originalHeight);
+		}
+		fontSprite.setAtlas(atlasNode);
+		atlasNode.addSprite(fontSprite);
+	}
+}
+async function writeAtlasPageImage(pkg, inputs, page, atlasFileName, encoder, options, logger) {
+	if (!encoder || !options.outputPath) return;
+	if (options.mkdir) await options.mkdir(options.outputPath);
+	const compositeInputs = [];
+	for (const packedRect of page.outputRects) {
+		const input = inputs[packedRect.index];
+		if (!input) continue;
+		if (packedRect.width <= 0 || packedRect.height <= 0 || input.width <= 0 || input.height <= 0) continue;
+		try {
+			let imageBuffer;
+			if (input.trimBuffer) {
+				imageBuffer = input.trimBuffer;
+				if (imageBuffer.length === 0) continue;
+			} else if (input.rasterizedBuffer) imageBuffer = input.rasterizedBuffer;
+			else {
+				if (!isImageResource$1(input.resource)) {
+					const message = `atlas: Non-image input "${input.id}" is missing inline buffer.`;
+					if (options.strictOutput) throw new Error(message);
+					logger.warn(`${message} Skipping compositing.`);
+					continue;
+				}
+				imageBuffer = await encoder(resolveImagePath$1(input.resource, pkg, options.basePath)).toBuffer();
+			}
+			if (packedRect.rotated) imageBuffer = await encoder(imageBuffer).rotate(270).toBuffer();
+			compositeInputs.push({
+				input: imageBuffer,
+				left: packedRect.x,
+				top: packedRect.y
+			});
+		} catch {
+			const message = `atlas: Could not read image "${input.id}" for compositing.`;
+			if (options.strictOutput) throw new Error(message);
+			logger.warn(message);
+		}
+	}
+	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).toFile(outputFile);
+	logger.info(`atlas: Generated ${atlasFileName} (${page.width}x${page.height}, ${page.outputRects.length} sprites)`);
+}
+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$1(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 {
+		const message = `atlas: Could not write direct-output atlas "${atlasFileName}".`;
+		if (options.strictOutput) throw new Error(message);
+		logger.warn(message);
+	}
+}
+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 resolveStandaloneAtlasOutputFileName(pkg, resource, branchName) {
+	const baseName = `${pkg.getPublishName() || pkg.getName()}_atlas_${getPublishedItemId(resource)}`;
+	const suffix = branchName ? `_${branchName}` : "";
+	if (isImageResource$1(resource)) return `${baseName}${suffix}${extname$1(resolveImageFileName$1(resource)) || ".png"}`;
+	return `${baseName}${suffix}.png`;
+}
+function resolveStandaloneAtlasSize(width, height, sizeMode, options) {
+	if (sizeMode === "npot") return {
+		width,
+		height
+	};
+	if (sizeMode === "multipleOf4") return {
+		width: roundUpToMultiple(width, 4),
+		height: roundUpToMultiple(height, 4)
+	};
+	return resolveDirectOutputAtlasSize(width, height, options);
+}
+function extname$1(fileName) {
+	const normalized = fileName.replace(/\\/g, "/");
+	const lastSlash = normalized.lastIndexOf("/");
+	const lastDot = normalized.lastIndexOf(".");
+	if (lastDot <= lastSlash) return "";
+	return normalized.slice(lastDot);
+}
+function insertFileNameSuffix(fileName, suffix) {
+	const extension = extname$1(fileName);
+	if (!extension) return `${fileName}${suffix}`;
+	return `${fileName.slice(0, -extension.length)}${suffix}${extension}`;
+}
+function nextPow2(value) {
+	if (value <= 1) return 1;
+	return 2 ** Math.ceil(Math.log2(value));
+}
+function roundUpToMultiple(value, base) {
+	if (value <= 0) return 0;
+	return Math.ceil(value / base) * base;
+}
+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;
+}
+function getResourceTextureSetMode(resource) {
+	if (isImageResource$1(resource)) return parseTextureSetMode(resource.getTextureSetMode?.());
+	return parseTextureSetMode(resource.getTextureSetMode?.());
+}
+function groupStandaloneInputs(doc, inputs, options) {
+	const autoInputs = [];
+	const fixedInputsByPage = /* @__PURE__ */ new Map();
+	const standaloneGroups = /* @__PURE__ */ new Map();
+	const reservedPageIndexes = /* @__PURE__ */ new Set();
+	const discoveredBranchNames = [...new Set(inputs.map((input) => getInputBranchName(input)).filter((branchName) => !!branchName))];
+	const orderedBranchNames = doc.getRoot().listBranches().filter((branchName) => discoveredBranchNames.includes(branchName));
+	for (const branchName of discoveredBranchNames) if (!orderedBranchNames.includes(branchName)) orderedBranchNames.push(branchName);
+	const branchOrdinalByName = /* @__PURE__ */ new Map();
+	branchOrdinalByName.set("", 0);
+	if (options.separatedAtlasForBranch) {
+		let ordinal = 1;
+		for (const branchName of orderedBranchNames) branchOrdinalByName.set(branchName, ordinal++);
+	} else for (const branchName of orderedBranchNames) branchOrdinalByName.set(branchName, 0);
+	for (const input of inputs) {
+		const branchName = getInputBranchName(input);
+		const branchOrdinal = branchOrdinalByName.get(branchName) ?? 0;
+		const mode = getResourceTextureSetMode(input.resource);
+		if (mode.kind === "standalone") {
+			const key = `${branchName}\u0000${getPublishedItemId(input.resource)}`;
+			const existing = standaloneGroups.get(key);
+			if (existing) existing.inputs.push(input);
+			else standaloneGroups.set(key, {
+				resource: input.resource,
+				branchName,
+				branchOrdinal,
+				sizeMode: mode.sizeMode,
+				inputs: [input]
+			});
+			continue;
+		}
+		if (mode.kind === "page") {
+			reservedPageIndexes.add(mode.pageIndex);
+			const key = `${branchName}\u0000${mode.pageIndex}`;
+			const existing = fixedInputsByPage.get(key);
+			if (existing) existing.inputs.push(input);
+			else fixedInputsByPage.set(key, {
+				pageIndex: mode.pageIndex,
+				branchName,
+				branchOrdinal,
+				inputs: [input]
+			});
+			continue;
+		}
+		autoInputs.push(input);
+	}
+	return {
+		autoInputs,
+		fixedPageGroups: [...fixedInputsByPage.values()].sort((left, right) => left.branchOrdinal - right.branchOrdinal || left.pageIndex - right.pageIndex),
+		standaloneGroups: [...standaloneGroups.values()].sort((left, right) => left.branchOrdinal - right.branchOrdinal || getPublishedItemId(left.resource).localeCompare(getPublishedItemId(right.resource))),
+		reservedPageIndexes
+	};
+}
+//#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,
+	strictOutput: false
+};
+function getSelectedSkeletonDependencyImageIds(resources) {
+	const imageIds = /* @__PURE__ */ new Set();
+	const resourcesById = new Map(resources.map((resource) => [resource.getId(), resource]));
+	for (const resource of resources) {
+		if (!isSkeletonResource$1(resource)) continue;
+		for (const requiredId of resource.getRequireIds()) {
+			if (!requiredId) continue;
+			const required = resourcesById.get(requiredId);
+			if (required && isImageResource$1(required)) imageIds.add(requiredId);
+		}
+	}
+	return imageIds;
+}
+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?.() !== 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 !== TransitionActionType.Sound && actionType !== 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
+* a raster backend 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;
+		const packageFilter = options.packages ? new Set(options.packages) : null;
+		for (const pkg of root.listPackages()) {
+			if (packageFilter && !packageFilter.has(pkg.getName())) continue;
+			const publishedResourceIds = pkg.getExtras()?.publishedResourceIds;
+			const selectedPublishIds = new Set(publishedResourceIds);
+			const allResources = publishedResourceIds !== void 0 && (options.strictOutput || selectedPublishIds.size > 0) ? pkg.listResources().filter((resource) => selectedPublishIds.has(resource.getId())) : pkg.listResources();
+			const skeletonDependencyImageIds = getSelectedSkeletonDependencyImageIds(allResources);
+			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) => {
+				if (isImageResource$1(resource) && skeletonDependencyImageIds.has(resource.getId())) return false;
+				return isPackableResource(resource);
+			})) continue;
+			const inputs = [];
+			const referencedIds = collectPackageResourceReferences(pkg).localResourceIds;
+			for (const res of orderedAllResources) {
+				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 (skeletonDependencyImageIds.has(resId)) continue;
+				if (selectedPublishIds.size === 0 && !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 (selectedPublishIds.size === 0 && !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 (selectedPublishIds.size === 0 && !res.getExported() && referencedIds.size > 0 && !referencedIds.has(resId)) continue;
+				await collectFontTexture(doc, res, pkg, options);
+			}
+			if (inputs.length === 0) continue;
+			if (options.strictOutput && (!encoder || !options.basePath || !options.outputPath)) throw new Error(`atlas: Package "${pkg.getName()}" requires encoder, basePath, and outputPath for complete raster output.`);
+			await emitAtlasInputs({
+				doc,
+				pkg,
+				allResources,
+				inputs,
+				options,
+				encoder,
+				logger
+			});
+		}
+	});
+}
+//#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/plugins/types.ts
+function formatPluginError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#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;
+	const plugins = options.plugins?.filter((plugin) => typeof plugin.plugin.genCode === "function") ?? [];
+	if (plugins.length > 0) {
+		let handled = false;
+		for (const plugin of plugins) try {
+			await plugin.plugin.genCode(doc, settings, options);
+			handled = true;
+			logger.info(`publish: Generated code using plugin "${plugin.name}"`);
+		} catch (error) {
+			logger.warn(`publish: Code generation plugin "${plugin.name}" failed: ${formatPluginError(error)}`);
+		}
+		if (handled) 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 === ProjectType.Unity) return codeType === "";
+	if (projectType === ProjectType.LayaBox || projectType === ProjectType.CocosCreator) return true;
+	return false;
+}
+function resolveFguiTypescriptVariant(doc) {
+	const projectType = doc.getRoot().getProjectType();
+	if (projectType !== ProjectType.LayaBox && projectType !== 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 codegenComponents = pkg.listComponents().sort((left, right) => left.getId().localeCompare(right.getId()));
+	const generatedById = /* @__PURE__ */ new Map();
+	for (const component of codegenComponents) {
+		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 codegenComponents) {
+		const classInfo = generatedById.get(component.getId());
+		if (!classInfo) continue;
+		classInfo.members = buildCodegenMembers(doc, pkg, component, plan, generatedById);
+	}
+	for (const [componentId, classInfo] of generatedById) if (classInfo.members.every((member) => member.ignored)) generatedById.delete(componentId);
+	for (const component of codegenComponents) {
+		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()) {
+		if (!isRuntimeChild(child)) continue;
+		const index = childIndex++;
+		const resolvedChild = resolveChildType(doc, pkg, child, generatedById);
+		members.push(createMember(ownerType, "child", resolvedChild.type, child.getName(), index, plan, resolvedChild.referencedComponent));
+	}
+	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 isRuntimeChild(child) {
+	return child.propertyType !== "GGroup" || child.getAdvanced?.() === true;
+}
+function createMember(ownerType, kind, type, originalName, index, plan, referencedComponent) {
+	const ignored = plan.settings.ignoreNoname && isDefaultMemberName(ownerType, kind, originalName);
+	return {
+		index,
+		kind,
+		name: applyMemberNamePrefix(originalName, plan.settings.memberNamePrefix),
+		originalName,
+		type,
+		ignored,
+		referencedComponent
+	};
+}
+function resolveChildType(doc, pkg, child, generatedById) {
+	const src = child.getSrc?.();
+	if (src) {
+		let referencedComponent = null;
+		if (src.startsWith("ui://")) {
+			const rest = src.slice(5);
+			const pkgId = rest.slice(0, 8);
+			const resourceId = rest.slice(8);
+			const targetPackage = doc.getRoot().listPackages().find((candidate) => candidate.getId() === pkgId);
+			const targetResource = targetPackage?.getResourceById(resourceId);
+			if (targetPackage && targetResource?.propertyType === "Component") referencedComponent = {
+				component: targetResource,
+				package: targetPackage
+			};
+		} else {
+			const packageId = child.getPackageId?.();
+			const targetPackage = packageId ? doc.getRoot().listPackages().find((candidate) => candidate.getId() === packageId) : pkg;
+			const targetResource = targetPackage?.getResourceById(src);
+			if (targetPackage && targetResource?.propertyType === "Component") referencedComponent = {
+				component: targetResource,
+				package: targetPackage
+			};
+		}
+		if (referencedComponent) return {
+			type: (referencedComponent.package === pkg ? generatedById.get(referencedComponent.component.getId()) : void 0)?.encodedClassName ?? resolveComponentBaseType(referencedComponent.component),
+			referencedComponent
+		};
+	}
+	const instanceExtType = child.getInstanceExtType?.();
+	if (instanceExtType) return { type: `G${instanceExtType}` };
+	return { type: child.propertyType };
+}
+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$1(codePath);
+	const projectBasePath = resolveProjectBasePath(basePath);
+	return projectBasePath ? trimTrailingSlashes$1(fs.join(projectBasePath, codePath)) : trimTrailingSlashes$1(codePath);
+}
+function resolveProjectBasePath(basePath) {
+	if (!basePath) return "";
+	const normalized = trimTrailingSlashes$1(basePath);
+	const assetsMatch = normalized.match(/^(.*)[/\\]assets(?:_[^/\\]+)?$/i);
+	if (assetsMatch?.[1]) return assetsMatch[1];
+	return dirname$1(normalized);
+}
+function dirname$1(filePath) {
+	return trimTrailingSlashes$1(filePath).match(/^(.*)[/\\][^/\\]+$/)?.[1] ?? "";
+}
+function trimTrailingSlashes$1(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") {
+		if (name === "title" || name === "icon") return true;
+	}
+	if (ownerType === "GProgressBar") {
+		if (name === "bar" || name === "bar_v" || name === "title" || name === "ani") return true;
+	}
+	if (ownerType === "GSlider") {
+		if (name === "bar" || name === "bar_v" || name === "grip" || name === "title" || name === "ani") return true;
+	}
+	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/package-context.ts
+const UNITY_PROJECT_TYPE$1 = ProjectType.Unity;
+function isComponentResource(resource) {
+	return resource.propertyType === "Component";
+}
+function isImageResource(resource) {
+	return resource.propertyType === "ImageResource";
+}
+function isMovieClipResource(resource) {
+	return resource.propertyType === "MovieClipResource";
+}
+function isHighResolutionResource(resource) {
+	return isImageResource(resource) || isMovieClipResource(resource);
+}
+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 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, projectType) {
+	const file = resource.getFile();
+	if (projectType !== UNITY_PROJECT_TYPE$1) return file;
+	if (file.toLowerCase().endsWith(".atlas")) return `${file}.txt`;
+	return file;
+}
+function resolvePublishedSkeletonFileName(resource, projectType) {
+	if (projectType === UNITY_PROJECT_TYPE$1 && 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() ?? ""}`;
+}
+const HIGH_RESOLUTION_LEVELS = [
+	{
+		scale: 2,
+		bit: 1,
+		slot: 0
+	},
+	{
+		scale: 3,
+		bit: 2,
+		slot: 1
+	},
+	{
+		scale: 4,
+		bit: 4,
+		slot: 2
+	}
+];
+function buildHighResolutionResourceKey(resource, name = resource.getName()) {
+	return `${resource.propertyType}|${resource.getBranch?.() ?? ""}|${resource.getPath() ?? ""}|${name}`;
+}
+function isHighResolutionVariantName(name) {
+	return /@(?:2|3|4)x(?:\.[^./\\]+)?$/iu.test(name);
+}
+function appendHighResolutionScaleToName(name, scale) {
+	const extensionIndex = name.lastIndexOf(".");
+	if (extensionIndex > 0) return `${name.slice(0, extensionIndex)}@${scale}x${name.slice(extensionIndex)}`;
+	return `${name}@${scale}x`;
+}
+function trimTrailingMissingHighResolutionIds(ids) {
+	while (ids.length > 0 && !ids[ids.length - 1]) ids.pop();
+	return ids;
+}
+function collectHighResolutionItemIds(resources, publishedResourceIds, includeHighResolution) {
+	const result = /* @__PURE__ */ new Map();
+	if (includeHighResolution <= 0) return result;
+	const highResolutionResourceByKey = /* @__PURE__ */ new Map();
+	for (const resource of resources) {
+		if (!isHighResolutionResource(resource)) continue;
+		highResolutionResourceByKey.set(buildHighResolutionResourceKey(resource), resource);
+	}
+	for (const resource of resources) {
+		if (!isHighResolutionResource(resource)) continue;
+		if (!publishedResourceIds.has(resource.getId())) continue;
+		if (isHighResolutionVariantName(resource.getName())) continue;
+		const ids = [];
+		for (const level of HIGH_RESOLUTION_LEVELS) {
+			if ((includeHighResolution & level.bit) === 0) {
+				ids[level.slot] = null;
+				continue;
+			}
+			const highResolutionResource = highResolutionResourceByKey.get(buildHighResolutionResourceKey(resource, appendHighResolutionScaleToName(resource.getName(), level.scale)));
+			if (!highResolutionResource) {
+				ids[level.slot] = null;
+				continue;
+			}
+			const highResolutionId = highResolutionResource.getId();
+			publishedResourceIds.add(highResolutionId);
+			ids[level.slot] = highResolutionId;
+		}
+		trimTrailingMissingHighResolutionIds(ids);
+		if (ids.length > 0) result.set(resource.getId(), ids);
+	}
+	return result;
+}
+function collectPackagePublishContext(pkg, options) {
+	const resources = pkg.listResources();
+	const resourceMap = new Map(resources.map((resource) => [resource.getId(), resource]));
+	const referencedIds = collectPackageResourceReferences(pkg).localResourceIds;
+	const pixelHitTestImageIds = /* @__PURE__ */ new Set();
+	const spriteItemIds = /* @__PURE__ */ new Set();
+	const collectExportedResourceIds = (sourceResources, sourcePublishedResourceIds) => {
+		const exportedResourceIds = new Set(sourcePublishedResourceIds);
+		const resourcesById = new Map(sourceResources.map((resource) => [resource.getId(), resource]));
+		let changed = true;
+		while (changed) {
+			changed = false;
+			for (const resourceId of [...exportedResourceIds]) {
+				const resource = resourcesById.get(resourceId);
+				if (!resource || !isSkeletonResource(resource)) continue;
+				for (const requiredId of resource.getRequireIds()) {
+					if (!requiredId || exportedResourceIds.has(requiredId)) continue;
+					exportedResourceIds.add(requiredId);
+					changed = true;
+				}
+			}
+		}
+		return exportedResourceIds;
+	};
+	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);
+			}
+		}
+	}
+	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);
+	}
+	for (const resourceId of collectExportedResourceIds(resources, publishedResourceIds)) publishedResourceIds.add(resourceId);
+	const highResolutionItemIds = collectHighResolutionItemIds(resources, publishedResourceIds, options.includeHighResolution);
+	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,
+			exportedResourceIds: collectExportedResourceIds(resources, publishedResourceIds),
+			pixelHitTestImageIds,
+			highResolutionItemIds,
+			effectiveResourceIds,
+			includeBranches: false
+		};
+	}
+	return {
+		referencedIds,
+		publishedResourceIds,
+		exportedResourceIds: collectExportedResourceIds(resources, publishedResourceIds),
+		pixelHitTestImageIds,
+		highResolutionItemIds,
+		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, exportedResourceIds, pixelHitTestImageIds, highResolutionItemIds, effectiveResourceIds, includeBranches } = collectPackagePublishContext(pkg, options);
+	for (const resource of pkg.listResources()) {
+		setPublishedIdExtra(resource, effectiveResourceIds.get(resource.getId()) ?? null);
+		if (isHighResolutionResource(resource)) resource.setHighResolutionItemIds(highResolutionItemIds.get(resource.getId()) ?? []);
+	}
+	await applyPixelHitTests(pkg, pixelHitTestImageIds, basePath, encoder);
+	const extras = pkg.getExtras() ?? {};
+	pkg.setExtras({
+		...extras,
+		publishedResourceIds: [...publishedResourceIds].sort((a, b) => a.localeCompare(b)),
+		exportedResourceIds: [...exportedResourceIds].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, options.projectType));
+			continue;
+		}
+		if (isSkeletonResource(resource)) setPublishedFileExtra(resource, resolvePublishedSkeletonFileName(resource, options.projectType));
+	}
+}
+function getAnnotatedPublishedResourceIds(pkg) {
+	const extras = pkg.getExtras() ?? {};
+	return new Set(extras.publishedResourceIds ?? []);
+}
+function getAnnotatedExportedResourceIds(pkg) {
+	const extras = pkg.getExtras() ?? {};
+	return new Set(extras.exportedResourceIds ?? []);
+}
+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;
+}
+//#endregion
+//#region src/publish/external-resources.ts
+async function exportPackageSounds(pkg, outputDir, basePath, fs, readFileRaw) {
+	const publishedResourceIds = getAnnotatedPublishedResourceIds(pkg);
+	if (publishedResourceIds.size === 0) return;
+	if (!basePath || !readFileRaw) {
+		if (pkg.listResources().some((resource) => {
+			return isSoundResource(resource) && publishedResourceIds.has(resource.getId());
+		})) throw new Error(`publish: Sound resources in package "${pkg.getName()}" require basePath and readFileRaw for output.`);
+		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 {
+			throw new Error(`publish: Could not export sound "${resource.getId()}" from package "${pkg.getName()}".`);
+		}
+	}
+}
+async function exportPackageExternalResources(pkg, outputDir, basePath, fs, readFileRaw) {
+	const exportedResourceIds = getAnnotatedExportedResourceIds(pkg);
+	const skeletonDependencyImageIds = getPublishedSkeletonDependencyImageIds(pkg, exportedResourceIds);
+	if (exportedResourceIds.size === 0) return;
+	if (!basePath || !readFileRaw) {
+		if (pkg.listResources().some((resource) => {
+			return (isMiscResource(resource) || isSkeletonResource(resource)) && exportedResourceIds.has(resource.getId()) || skeletonDependencyImageIds.has(resource.getId());
+		})) throw new Error(`publish: External resources in package "${pkg.getName()}" require basePath and readFileRaw for output.`);
+		return;
+	}
+	for (const resource of pkg.listResources()) {
+		const resourceId = resource.getId();
+		const isSkeletonExternal = exportedResourceIds.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 {
+			throw new Error(`publish: Could not export external resource "${resource.getId()}" from package "${pkg.getName()}".`);
+		}
+	}
+}
+//#endregion
+//#region src/publish/options.ts
+const UNITY_PROJECT_TYPE = ProjectType.Unity;
+const COCOS_CREATOR_PROJECT_TYPE = 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
+	};
+}
+//#endregion
+//#region src/publish.ts
+async function runPublishPluginHook(plugins, hook, doc, options) {
+	const logger = doc.getLogger();
+	for (const plugin of plugins) {
+		const fn = plugin.plugin[hook];
+		if (typeof fn !== "function") continue;
+		try {
+			await fn(doc, options);
+		} catch (error) {
+			logger.warn(`publish: Plugin "${plugin.name}" ${hook} failed: ${formatPluginError(error)}`);
+		}
+	}
+}
+function trimTrailingSlashes(value) {
+	return value.replace(/[/\\]+$/, "");
+}
+function isAbsolutePathLike(value) {
+	return /^(?:[a-zA-Z]:[/\\]|[/\\]{1,2})/u.test(value);
+}
+function joinPathSegments(left, right) {
+	const normalizedLeft = trimTrailingSlashes(left);
+	const normalizedRight = right.replace(/^[/\\]+/, "");
+	if (!normalizedLeft) return normalizedRight;
+	if (!normalizedRight) return normalizedLeft;
+	return `${normalizedLeft}${normalizedLeft.includes("\\") ? "\\" : "/"}${normalizedRight}`;
+}
+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
+	};
+}
+/**
+* Publishes a FairyGUI project.
+*
+* Orchestrates:
+* 1. Atlas packing (MaxRects layout + optional raster compositing)
+* 2. Per-package .fui binary serialization
+* 3. File writing to the output directory
+*
+* This is the capability-injected core. Standard hosts should use
+* `publishNode()` or `publishBrowser()` through their dedicated entries.
+*
+* ```ts
+* import { NodeIO } from '@openfairygui/core/node';
+* import { publishNode } from '@openfairygui/functions/node';
+* const doc = await new NodeIO().readProject('./project.fairy');
+*
+* await publishNode({
+*   document: doc,
+*   output: './release/',
+*   compressed: true,
+*   assetsPath: './assets/',
+*   fileExtension: 'bytes',
+* });
+* ```
+*/
+function publish(options) {
+	return createTransform("publish", async (doc) => {
+		const resolveConfiguredOutputPath = (value, projectBasePath) => {
+			const trimmed = value?.trim();
+			if (!trimmed) return void 0;
+			if (isAbsolutePathLike(trimmed) || !projectBasePath) return trimTrailingSlashes(trimmed);
+			return trimTrailingSlashes(options.fs ? options.fs.join(projectBasePath, trimmed) : joinPathSegments(projectBasePath, trimmed));
+		};
+		const resolveProjectPublishConfig = () => {
+			const publishSettings = (doc.getRoot().getSettings?.() ?? {}).publish ?? {};
+			const resolved = resolvePublishOptions(doc, {
+				compressed: options.compressed,
+				fileExtension: options.fileExtension,
+				packages: options.packages,
+				atlas: options.atlas
+			});
+			const includeBranches = (publishSettings.branchProcessing ?? 0) === 0;
+			return {
+				...resolved,
+				projectType: doc.getRoot().getProjectType(),
+				includeBranches,
+				activeBranch: includeBranches ? "" : options.branch ?? "",
+				includeHighResolution: publishSettings.includeHighResolution ?? 0,
+				separatedAtlasForBranch: includeBranches && publishSettings.seperatedAtlasForBranch === true,
+				globalOutputPath: publishSettings.path?.trim() ?? "",
+				globalBranchOutputPath: publishSettings.branchPath?.trim() ?? ""
+			};
+		};
+		const resolvePackagePublishPlan = (pkg, config, projectBasePath) => {
+			let outputDir;
+			if (options.output) outputDir = trimTrailingSlashes(options.output);
+			else {
+				const candidates = [];
+				if (!config.includeBranches && config.activeBranch) candidates.push(pkg.getPublishBranchPath(), config.globalBranchOutputPath);
+				candidates.push(pkg.getPublishPath(), config.globalOutputPath);
+				for (const candidate of candidates) {
+					const resolved = resolveConfiguredOutputPath(candidate, projectBasePath);
+					if (!resolved) continue;
+					outputDir = resolved;
+					break;
+				}
+			}
+			const publishName = pkg.getPublishName() || pkg.getName();
+			return {
+				pkg,
+				outputDir,
+				publishName,
+				fileName: resolvePublishFileName(publishName, config.fileExtension),
+				compressed: config.compressed,
+				fileExtension: config.fileExtension,
+				includeBranches: config.includeBranches,
+				activeBranch: config.activeBranch,
+				includeHighResolution: config.includeHighResolution,
+				separatedAtlasForBranch: config.separatedAtlasForBranch,
+				atlas: config.atlas
+			};
+		};
+		const createNoopPublishFs = () => ({
+			async writeFileRaw() {},
+			async mkdir() {},
+			join(...paths) {
+				return paths.join("/");
+			}
+		});
+		const publishPackage = async (plan, writerFs, packageIndex) => {
+			if (options.fs && !plan.outputDir) throw new Error("publish: no output directory resolved. Provide --output, or configure global publish.path / package publishPath.");
+			if (options.fs) {
+				await options.fs.mkdir(plan.outputDir);
+				await exportPackageSounds(plan.pkg, plan.outputDir, options.basePath, options.fs, options.atlas?.readFileRaw ?? options.fs.readFileRaw);
+				await exportPackageExternalResources(plan.pkg, plan.outputDir, options.basePath, options.fs, options.atlas?.readFileRaw ?? options.fs.readFileRaw);
+			}
+			const atlasRuntimeOptions = resolvePublishAtlasRuntimeOptions(plan.fileExtension);
+			await atlas({
+				...plan.atlas,
+				...options.atlas ?? {},
+				separatedAtlasForBranch: plan.separatedAtlasForBranch,
+				encoder: options.encoder,
+				basePath: options.basePath,
+				outputPath: options.fs ? plan.outputDir : void 0,
+				mkdir: options.fs ? options.fs.mkdir : void 0,
+				readFileRaw: options.atlas?.readFileRaw ?? options.fs?.readFileRaw,
+				strictOutput: options.fs !== void 0,
+				packages: [plan.pkg.getName()],
+				...atlasRuntimeOptions
+			})(doc);
+			if (!options.fs) return;
+			const filePath = options.fs.join(plan.outputDir, plan.fileName);
+			const bwOptions = {
+				compressed: plan.compressed,
+				packageIndex
+			};
+			await new BinaryWriter(writerFs).write(doc, filePath, bwOptions);
+			logger.info(`publish: Written ${plan.fileName}`);
+		};
+		const root = doc.getRoot();
+		const logger = doc.getLogger();
+		const projectBasePath = resolveProjectBasePath(options.basePath) || doc.getProjectDir?.() || "";
+		const plugins = options.plugins ?? [];
+		await runPublishPluginHook(plugins, "onPublishStart", doc, options);
+		const resolved = resolveProjectPublishConfig();
+		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.");
+			await runPublishPluginHook(plugins, "onPublishEnd", doc, options);
+			return;
+		}
+		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(doc, pkg, pkgMap);
+			await annotatePackagePublishArtifacts(pkg, options.basePath, options.encoder, {
+				projectType: resolved.projectType,
+				includeBranches: resolved.includeBranches,
+				activeBranch: resolved.activeBranch,
+				includeHighResolution: resolved.includeHighResolution
+			});
+		}
+		const plans = allPackages.map((pkg) => resolvePackagePublishPlan(pkg, resolved, projectBasePath));
+		if (!options.fs) {
+			const outputPlan = plans.find((plan) => !!plan.outputDir);
+			if (outputPlan) throw new Error(`publish: Output for package "${outputPlan.pkg.getName()}" requires a filesystem. Omit output and publish paths to run a layout-only transform.`);
+			logger.info(`publish: Layout computed for ${allPackages.length} package(s); no output directory was requested.`);
+			const noopWriterFs = toBinaryWriterFileSystem(createNoopPublishFs());
+			for (const plan of plans) await publishPackage(plan, noopWriterFs, allDocPackages.indexOf(plan.pkg));
+			await runPublishPluginHook(plugins, "onPublishEnd", doc, options);
+			return;
+		}
+		const unresolvedPlan = plans.find((plan) => !plan.outputDir);
+		if (unresolvedPlan) throw new Error(`publish: no output directory resolved for package "${unresolvedPlan.pkg.getName()}". Provide --output, or configure global publish.path / package publishPath.`);
+		const writerFs = toBinaryWriterFileSystem(options.fs);
+		for (const plan of plans) await publishPackage(plan, writerFs, allDocPackages.indexOf(plan.pkg));
+		if (options.codeGeneration !== false) await publishCodeGeneration(doc, {
+			basePath: options.basePath,
+			fs: options.fs,
+			packages: allPackages,
+			plugins
+		});
+		const publishedTargets = [...new Set(plans.map((plan) => plan.outputDir).filter((value) => Boolean(value)))];
+		logger.info(publishedTargets.length > 0 ? `publish: Published ${allPackages.length} package(s) to ${publishedTargets.join(", ")}` : `publish: Published ${allPackages.length} package(s)`);
+		await runPublishPluginHook(plugins, "onPublishEnd", doc, options);
+	});
+}
+/**
+* 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(doc, pkg, pkgMap) {
+	const referencedPkgIds = collectPackageResourceReferences(pkg).packageIds;
+	const packageOrder = new Map(doc.getRoot().listPackages().map((entry, index) => [entry.getId(), index]));
+	for (const dep of pkg.listDependencies()) pkg.removeDependency(dep);
+	if (referencedPkgIds.size > 0) {
+		const sortedIds = [...referencedPkgIds].sort((a, b) => {
+			const orderA = packageOrder.get(a) ?? Number.MAX_SAFE_INTEGER;
+			const orderB = packageOrder.get(b) ?? Number.MAX_SAFE_INTEGER;
+			if (orderA !== orderB) return orderA - orderB;
+			return a.localeCompare(b);
+		});
+		for (const refId of sortedIds) {
+			const depPkg = pkgMap.get(refId);
+			if (depPkg) pkg.addDependency(depPkg);
+		}
+	}
+}
+//#endregion
+export { decodeText as a, resolvePackageCodegenPlan as c, atlas as d, createTransform as f, buildCodegenClasses as i, resolveProjectBasePath as l, resolvePublishOptions as n, encodeText as o, AUTO_GENERATED_CODE_MARK as r, publishCodeGeneration as s, publish as t, formatPluginError as u };