@godot-scene-web/layout 0.1.0

package/dist/index.js

@@ -0,0 +1,1162 @@
+import { asBoolean, asNumber, asResourceRef, asString, asVector2 } from "@godot-scene-web/core";
+import { deriveNodeVisuals } from "@godot-scene-web/scene-graph";
+//#region src/anchor-grammar.ts
+const verticals = [
+	["contentbottom", "contentBottom"],
+	["contenttop", "contentTop"],
+	["vcenter", "vcenter"],
+	["bottom", "bottom"],
+	["top", "top"]
+];
+const horizontals = {
+	contentright: "contentRight",
+	contentleft: "contentLeft",
+	hcenter: "hcenter",
+	right: "right",
+	left: "left"
+};
+function parseAnchorEdge(token) {
+	const normalized = token.toLowerCase();
+	if (normalized === "center") return {
+		vertical: "vcenter",
+		horizontal: "hcenter"
+	};
+	for (const [key, vertical] of verticals) {
+		if (!normalized.startsWith(key)) continue;
+		const horizontal = horizontals[normalized.slice(key.length)];
+		if (horizontal) return {
+			vertical,
+			horizontal
+		};
+	}
+}
+function anchorEdgePoint(token, own, content) {
+	const edge = parseAnchorEdge(token);
+	if (!edge) return void 0;
+	return {
+		x: edge.horizontal === "contentRight" ? content.x + content.width : edge.horizontal === "contentLeft" ? content.x : edge.horizontal === "hcenter" ? own.x + own.width / 2 : edge.horizontal === "right" ? own.x + own.width : own.x,
+		y: edge.vertical === "contentBottom" ? content.y + content.height : edge.vertical === "contentTop" ? content.y : edge.vertical === "vcenter" ? own.y + own.height / 2 : edge.vertical === "bottom" ? own.y + own.height : own.y
+	};
+}
+//#endregion
+//#region src/anchors.ts
+const edgePoint = anchorEdgePoint;
+/** Union of a node's visible direct children's rendered rects (its content box). */
+function contentExtent(node, layoutByPath) {
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX = -Infinity;
+	let maxY = -Infinity;
+	let found = false;
+	for (const childPath of node.children) {
+		const child = layoutByPath.get(childPath);
+		if (!child || child.visible === false) continue;
+		const rect = child.renderedRect;
+		minX = Math.min(minX, rect.x);
+		minY = Math.min(minY, rect.y);
+		maxX = Math.max(maxX, rect.x + rect.width);
+		maxY = Math.max(maxY, rect.y + rect.height);
+		found = true;
+	}
+	if (!found) {
+		const { x, y } = node.renderedRect;
+		return {
+			x,
+			y,
+			width: 0,
+			height: 0
+		};
+	}
+	return {
+		x: minX,
+		y: minY,
+		width: maxX - minX,
+		height: maxY - minY
+	};
+}
+/** Translate a node and its whole subtree by `(dx, dy)` in global space. */
+function translateSubtree(root, dx, dy, layoutByPath) {
+	const stack = [root.path];
+	while (stack.length > 0) {
+		const node = layoutByPath.get(stack.pop());
+		if (!node) continue;
+		node.rect = {
+			x: node.rect.x + dx,
+			y: node.rect.y + dy,
+			width: node.rect.width,
+			height: node.rect.height
+		};
+		node.renderedRect = {
+			x: node.renderedRect.x + dx,
+			y: node.renderedRect.y + dy,
+			width: node.renderedRect.width,
+			height: node.renderedRect.height
+		};
+		if (node.cumulativeTransform) node.cumulativeTransform = {
+			...node.cumulativeTransform,
+			tx: node.cumulativeTransform.tx + dx,
+			ty: node.cumulativeTransform.ty + dy
+		};
+		for (const childPath of node.children) stack.push(childPath);
+	}
+}
+/**
+* Resolve every declared anchor, translating each anchored node (and its subtree)
+* so its `to` edge lands on its target's `from` edge. Targets that are themselves
+* anchored are resolved first; cycles are broken with a diagnostic.
+*/
+function resolveAnchors(layoutByPath, anchors, diagnostics) {
+	if (!anchors) return;
+	const resolved = /* @__PURE__ */ new Set();
+	const inProgress = /* @__PURE__ */ new Set();
+	const resolveOne = (path) => {
+		if (resolved.has(path)) return;
+		const anchor = anchors[path];
+		const self = layoutByPath.get(path);
+		if (!anchor || !self) {
+			resolved.add(path);
+			return;
+		}
+		if (inProgress.has(path)) {
+			diagnostics.push({
+				severity: "warning",
+				code: "anchor-cycle",
+				message: `Anchor cycle detected resolving ${path}; leaving it unmoved.`,
+				nodePath: path
+			});
+			return;
+		}
+		inProgress.add(path);
+		if (anchors[anchor.anchorTo]) resolveOne(anchor.anchorTo);
+		const target = layoutByPath.get(anchor.anchorTo);
+		if (!target) diagnostics.push({
+			severity: "warning",
+			code: "anchor-target-missing",
+			message: `Anchor target '${anchor.anchorTo}' not found for ${path}.`,
+			nodePath: path
+		});
+		else {
+			const targetPoint = edgePoint(anchor.from, target.renderedRect, contentExtent(target, layoutByPath));
+			const selfPoint = edgePoint(anchor.to, self.renderedRect, contentExtent(self, layoutByPath));
+			if (!targetPoint || !selfPoint) diagnostics.push({
+				severity: "warning",
+				code: "anchor-edge-unparsed",
+				message: `Unrecognized anchor edge (from='${anchor.from}', to='${anchor.to}') for ${path}.`,
+				nodePath: path
+			});
+			else {
+				const dx = targetPoint.x - selfPoint.x + (anchor.offset?.x ?? 0);
+				const dy = targetPoint.y - selfPoint.y + (anchor.offset?.y ?? 0);
+				if (dx !== 0 || dy !== 0) translateSubtree(self, dx, dy, layoutByPath);
+			}
+		}
+		inProgress.delete(path);
+		resolved.add(path);
+	};
+	for (const path of Object.keys(anchors)) resolveOne(path);
+}
+//#endregion
+//#region src/flow-wrap.ts
+/**
+* Wraps flow-container entries into lines, mirroring Godot's
+* `FlowContainer::_resort()` wrapping. The cross axis advances by the line's
+* largest cross extent plus the relevant separation.
+*/
+function flowWrapLines(rect, entries, vertical, hSeparation, vSeparation) {
+	const lines = [];
+	let currentLine = [];
+	let cursorX = rect.x;
+	let cursorY = rect.y;
+	let lineCrossSize = 0;
+	for (const entry of entries) {
+		const size = entry.size;
+		if (vertical) {
+			if (cursorY > rect.y && cursorY + size.height > rect.y + rect.height) {
+				lines.push(currentLine);
+				currentLine = [];
+				cursorX += lineCrossSize + hSeparation;
+				cursorY = rect.y;
+				lineCrossSize = 0;
+			}
+			currentLine.push({
+				...entry,
+				x: cursorX,
+				y: cursorY
+			});
+			cursorY += size.height + vSeparation;
+			lineCrossSize = Math.max(lineCrossSize, size.width);
+		} else {
+			if (cursorX > rect.x && cursorX + size.width > rect.x + rect.width) {
+				lines.push(currentLine);
+				currentLine = [];
+				cursorX = rect.x;
+				cursorY += lineCrossSize + vSeparation;
+				lineCrossSize = 0;
+			}
+			currentLine.push({
+				...entry,
+				x: cursorX,
+				y: cursorY
+			});
+			cursorX += size.width + hSeparation;
+			lineCrossSize = Math.max(lineCrossSize, size.height);
+		}
+	}
+	if (currentLine.length > 0) lines.push(currentLine);
+	return lines;
+}
+/** Total cross-axis extent of wrapped lines: Σ line cross size + separations. */
+function flowCrossExtent(lines, vertical, hSeparation, vSeparation) {
+	const crossSeparation = vertical ? hSeparation : vSeparation;
+	return lines.map((line) => line.reduce((max, entry) => Math.max(max, vertical ? entry.size.width : entry.size.height), 0)).reduce((sum, size) => sum + size, 0) + Math.max(0, lines.length - 1) * crossSeparation;
+}
+//#endregion
+//#region src/container-types.ts
+function isBoxContainerType(type) {
+	return type === "BoxContainer" || type === "HBoxContainer" || type === "VBoxContainer";
+}
+function boxContainerHorizontal(indexed) {
+	if (indexed.node.type === "HBoxContainer") return true;
+	if (indexed.node.type === "VBoxContainer") return false;
+	return !(asBoolean(indexed.props.vertical) ?? false);
+}
+function isFlowContainerType(type) {
+	return type === "FlowContainer" || type === "HFlowContainer" || type === "VFlowContainer";
+}
+function flowContainerVertical(indexed) {
+	if (indexed.node.type === "VFlowContainer") return true;
+	if (indexed.node.type === "HFlowContainer") return false;
+	return asBoolean(indexed.props.vertical) ?? false;
+}
+//#endregion
+//#region src/style-box.ts
+function contentRectForStyleBox(rect, metrics) {
+	return normalizeRect({
+		x: rect.x + metrics.left,
+		y: rect.y + metrics.top,
+		width: rect.width - metrics.left - metrics.right,
+		height: rect.height - metrics.top - metrics.bottom
+	});
+}
+function panelStyleBoxMetrics(indexed, options) {
+	return styleBoxMetrics(resolveStyleBox(indexed.props["theme_override_styles/panel"], indexed, options) ?? resolveStyleBox(options.resolveTheme?.(indexed.node, "panel"), indexed, options));
+}
+function resolveStyleBox(value, indexed, options) {
+	const ref = asResourceRef(value);
+	return ref ? options.resolveResource?.(ref, indexed.node) : value;
+}
+function styleBoxMetrics(resource) {
+	const { type, properties } = resourceDocument(resource);
+	if (!type || type === "StyleBoxEmpty") return {
+		left: 0,
+		top: 0,
+		right: 0,
+		bottom: 0
+	};
+	const props = properties ?? {};
+	if (type === "StyleBoxFlat") {
+		const borders = {
+			left: numeric(props, "border_width_left") ?? numeric(props, "border_width_all") ?? 0,
+			top: numeric(props, "border_width_top") ?? numeric(props, "border_width_all") ?? 0,
+			right: numeric(props, "border_width_right") ?? numeric(props, "border_width_all") ?? 0,
+			bottom: numeric(props, "border_width_bottom") ?? numeric(props, "border_width_all") ?? 0
+		};
+		return {
+			left: styleBoxMargin(props, "left", borders.left),
+			top: styleBoxMargin(props, "top", borders.top),
+			right: styleBoxMargin(props, "right", borders.right),
+			bottom: styleBoxMargin(props, "bottom", borders.bottom)
+		};
+	}
+	return {
+		left: Math.max(0, numeric(props, "content_margin_left") ?? numeric(props, "content_margin_all") ?? 0),
+		top: Math.max(0, numeric(props, "content_margin_top") ?? numeric(props, "content_margin_all") ?? 0),
+		right: Math.max(0, numeric(props, "content_margin_right") ?? numeric(props, "content_margin_all") ?? 0),
+		bottom: Math.max(0, numeric(props, "content_margin_bottom") ?? numeric(props, "content_margin_all") ?? 0)
+	};
+}
+function styleBoxMargin(props, side, fallback) {
+	const value = numeric(props, `content_margin_${side}`) ?? numeric(props, "content_margin_all");
+	return value !== void 0 && value >= 0 ? value : fallback;
+}
+function resourceDocument(resource) {
+	if (!resource || typeof resource !== "object") return {};
+	const record = resource;
+	const directDocument = record.document;
+	const document = directDocument && typeof directDocument === "object" && !Array.isArray(directDocument) ? directDocument : void 0;
+	const properties = document?.properties ?? (record.properties && typeof record.properties === "object" && !Array.isArray(record.properties) ? record.properties : void 0);
+	return {
+		type: asString(document?.header?.attributes.type) ?? (typeof record.type === "string" ? record.type : void 0),
+		properties
+	};
+}
+//#endregion
+//#region src/theme.ts
+/**
+* Godot's built-in default theme constants for container nodes, mirroring
+* `scene/theme/default_theme.cpp` (4.5.1, `set_constant(..., Math::round(4 *
+* scale))` at scale 1). A node that does not carry an explicit
+* `theme_override_constants/*` (and whose project theme provides nothing) still
+* inherits these from the default theme, so the layout engine must fall back to
+* them rather than to 0 — e.g. an HBoxContainer with no separation override lays
+* its children out 4px apart, not flush. MarginContainer margins default to 0 in
+* the default theme, so they intentionally have no entry here.
+*/
+const DEFAULT_THEME_CONSTANTS = {
+	BoxContainer: { separation: 4 },
+	HBoxContainer: { separation: 4 },
+	VBoxContainer: { separation: 4 },
+	GridContainer: {
+		h_separation: 4,
+		v_separation: 4
+	},
+	FlowContainer: {
+		h_separation: 4,
+		v_separation: 4
+	},
+	HFlowContainer: {
+		h_separation: 4,
+		v_separation: 4
+	},
+	VFlowContainer: {
+		h_separation: 4,
+		v_separation: 4
+	}
+};
+function defaultThemeConstant(indexed, name) {
+	const type = indexed.node.type;
+	if (!type) return;
+	return DEFAULT_THEME_CONSTANTS[type]?.[name];
+}
+function themeNumber(indexed, name, options) {
+	return numeric(indexed.props, `theme_override_constants/${name}`) ?? numeric(indexed.props, `theme_constant_${name}`) ?? asNumber(options.resolveTheme?.(indexed.node, name)) ?? defaultThemeConstant(indexed, name);
+}
+//#endregion
+//#region src/minimum-size.ts
+function preferredSize(indexed, byPath, options) {
+	return combinedMinimum(indexed, byPath, options) ?? explicitSizeFromProps(indexed) ?? sizeFromOffsets(indexed) ?? {
+		width: 0,
+		height: 0
+	};
+}
+function explicitSizeFromProps(indexed) {
+	const size = asVector2(indexed.props.size);
+	if (size) return {
+		width: size.x,
+		height: size.y
+	};
+	const width = numeric(indexed.props, "size_width");
+	const height = numeric(indexed.props, "size_height");
+	return width !== void 0 && height !== void 0 ? {
+		width,
+		height
+	} : void 0;
+}
+function sizeFromOffsets(indexed) {
+	const left = numeric(indexed.props, "offset_left") ?? 0;
+	const top = numeric(indexed.props, "offset_top") ?? 0;
+	const right = numeric(indexed.props, "offset_right");
+	const bottom = numeric(indexed.props, "offset_bottom");
+	if (right === void 0 || bottom === void 0) return;
+	return {
+		width: Math.max(0, right - left),
+		height: Math.max(0, bottom - top)
+	};
+}
+function customMinimum(indexed) {
+	const vector = asVector2(indexed.props.custom_minimum_size);
+	if (vector) return {
+		width: vector.x,
+		height: vector.y
+	};
+	const width = numeric(indexed.props, "custom_minimum_width") ?? numeric(indexed.props, "minimum_width");
+	const height = numeric(indexed.props, "custom_minimum_height") ?? numeric(indexed.props, "minimum_height");
+	return width !== void 0 && height !== void 0 ? {
+		width,
+		height
+	} : void 0;
+}
+function declaredCombinedMinimum(indexed) {
+	const vector = asVector2(indexed.props.combined_minimum_size);
+	if (vector) return {
+		width: vector.x,
+		height: vector.y
+	};
+	const width = numeric(indexed.props, "combined_minimum_width");
+	const height = numeric(indexed.props, "combined_minimum_height");
+	return width !== void 0 && height !== void 0 ? {
+		width,
+		height
+	} : void 0;
+}
+function combinedMinimum(indexed, byPath, options, currentRect) {
+	return maxSize(declaredCombinedMinimum(indexed), maxSize(customMinimum(indexed), maxSize(internalMinimum(indexed, options, currentRect), containerMinimumSize(indexed, byPath, options))));
+}
+function maxSize(a, b) {
+	if (!a) return b;
+	if (!b) return a;
+	return {
+		width: Math.max(a.width, b.width),
+		height: Math.max(a.height, b.height)
+	};
+}
+/**
+* Container analogue of Godot `Container::get_minimum_size()`, memoized on the
+* IndexedNode. Non-container controls return `undefined` (a plain Control/Node
+* does not size to its children). Recurses through `byPath` children, which
+* already include flattened instanced PackedScene content.
+*/
+function containerMinimumSize(indexed, byPath, options) {
+	if (indexed.minimumSize !== void 0) return indexed.minimumSize ?? void 0;
+	const size = computeContainerMinimum(indexed, byPath, options);
+	indexed.minimumSize = size ?? null;
+	return size;
+}
+function computeContainerMinimum(indexed, byPath, options) {
+	switch (indexed.node.type ?? "Node") {
+		case "BoxContainer":
+		case "HBoxContainer":
+		case "VBoxContainer": return boxMinimum(indexed, byPath, options);
+		case "GridContainer": return gridMinimum(indexed, byPath, options);
+		case "FlowContainer":
+		case "HFlowContainer":
+		case "VFlowContainer": return flowMinimum(indexed, byPath, options);
+		case "MarginContainer": return marginMinimum(indexed, byPath, options);
+		case "CenterContainer": return maxChildMinimum(indexed, byPath, options);
+		case "AspectRatioContainer": return maxChildMinimum(indexed, byPath, options);
+		case "PanelContainer": return panelMinimum(indexed, byPath, options);
+		case "ScrollContainer": return scrollMinimum(indexed, byPath, options);
+		default: return;
+	}
+}
+function visibleChildren(indexed, byPath) {
+	return indexed.children.map((path) => byPath.get(path)).filter((child) => Boolean(child) && (asBoolean(child.props.visible) ?? true));
+}
+function childSizes(indexed, byPath, options) {
+	return visibleChildren(indexed, byPath).map((child) => combinedMinimum(child, byPath, options) ?? {
+		width: 0,
+		height: 0
+	});
+}
+function boxMinimum(indexed, byPath, options) {
+	const horizontal = boxContainerHorizontal(indexed);
+	const separation = themeNumber(indexed, "separation", options) ?? 0;
+	const sizes = childSizes(indexed, byPath, options);
+	let main = 0;
+	let cross = 0;
+	sizes.forEach((size, index) => {
+		const childMain = horizontal ? size.width : size.height;
+		const childCross = horizontal ? size.height : size.width;
+		main += childMain + (index === 0 ? 0 : separation);
+		cross = Math.max(cross, childCross);
+	});
+	return horizontal ? {
+		width: main,
+		height: cross
+	} : {
+		width: cross,
+		height: main
+	};
+}
+function gridMinimum(indexed, byPath, options) {
+	const columns = Math.max(1, Math.floor(numeric(indexed.props, "columns") ?? 1));
+	const hSeparation = themeNumber(indexed, "h_separation", options) ?? themeNumber(indexed, "separation", options) ?? 0;
+	const vSeparation = themeNumber(indexed, "v_separation", options) ?? themeNumber(indexed, "separation", options) ?? 0;
+	const sizes = childSizes(indexed, byPath, options);
+	const columnWidths = /* @__PURE__ */ new Map();
+	const rowHeights = /* @__PURE__ */ new Map();
+	let maxColumn = 0;
+	let maxRow = 0;
+	sizes.forEach((size, index) => {
+		const column = index % columns;
+		const row = Math.floor(index / columns);
+		columnWidths.set(column, Math.max(columnWidths.get(column) ?? 0, size.width));
+		rowHeights.set(row, Math.max(rowHeights.get(row) ?? 0, size.height));
+		maxColumn = Math.max(maxColumn, column);
+		maxRow = Math.max(maxRow, row);
+	});
+	return {
+		width: [...columnWidths.values()].reduce((sum, value) => sum + value, 0) + hSeparation * maxColumn,
+		height: [...rowHeights.values()].reduce((sum, value) => sum + value, 0) + vSeparation * maxRow
+	};
+}
+function flowMinimum(indexed, byPath, options) {
+	const vertical = flowContainerVertical(indexed);
+	const hSeparation = themeNumber(indexed, "h_separation", options) ?? themeNumber(indexed, "separation", options) ?? 0;
+	const vSeparation = themeNumber(indexed, "v_separation", options) ?? themeNumber(indexed, "separation", options) ?? 0;
+	const sizes = childSizes(indexed, byPath, options);
+	const maxWidth = sizes.reduce((max, size) => Math.max(max, size.width), 0);
+	const maxHeight = sizes.reduce((max, size) => Math.max(max, size.height), 0);
+	const offsetSize = explicitSizeFromProps(indexed) ?? sizeFromOffsets(indexed);
+	const offsetMain = vertical ? offsetSize?.height : offsetSize?.width;
+	const mainExtent = indexed.flowMainExtent ?? (offsetMain !== void 0 && offsetMain > 0 ? offsetMain : void 0);
+	if (mainExtent !== void 0 && mainExtent > 0) {
+		const crossExtent = flowCrossExtent(flowWrapLines(vertical ? {
+			x: 0,
+			y: 0,
+			width: maxWidth,
+			height: mainExtent
+		} : {
+			x: 0,
+			y: 0,
+			width: mainExtent,
+			height: maxHeight
+		}, sizes.map((size) => ({
+			item: size,
+			size
+		})), vertical, hSeparation, vSeparation), vertical, hSeparation, vSeparation);
+		return vertical ? {
+			width: crossExtent,
+			height: maxHeight
+		} : {
+			width: maxWidth,
+			height: crossExtent
+		};
+	}
+	return {
+		width: maxWidth,
+		height: maxHeight
+	};
+}
+function marginMinimum(indexed, byPath, options) {
+	const left = themeNumber(indexed, "margin_left", options) ?? 0;
+	const top = themeNumber(indexed, "margin_top", options) ?? 0;
+	const right = themeNumber(indexed, "margin_right", options) ?? 0;
+	const bottom = themeNumber(indexed, "margin_bottom", options) ?? 0;
+	const max = maxChildMinimum(indexed, byPath, options);
+	return {
+		width: max.width + left + right,
+		height: max.height + top + bottom
+	};
+}
+function panelMinimum(indexed, byPath, options) {
+	const metrics = panelStyleBoxMetrics(indexed, options);
+	const max = maxChildMinimum(indexed, byPath, options);
+	return {
+		width: max.width + metrics.left + metrics.right,
+		height: max.height + metrics.top + metrics.bottom
+	};
+}
+function scrollMinimum(indexed, byPath, options) {
+	const metrics = panelStyleBoxMetrics(indexed, options);
+	const largest = maxChildMinimum(indexed, byPath, options);
+	const horizontalDisabled = (numeric(indexed.props, "horizontal_scroll_mode") ?? 1) === 0;
+	const verticalDisabled = (numeric(indexed.props, "vertical_scroll_mode") ?? 1) === 0;
+	return {
+		width: metrics.left + metrics.right + (horizontalDisabled ? largest.width : 0),
+		height: metrics.top + metrics.bottom + (verticalDisabled ? largest.height : 0)
+	};
+}
+function maxChildMinimum(indexed, byPath, options) {
+	return childSizes(indexed, byPath, options).reduce((max, size) => ({
+		width: Math.max(max.width, size.width),
+		height: Math.max(max.height, size.height)
+	}), {
+		width: 0,
+		height: 0
+	});
+}
+const TEXT_CONTENT_TYPES = new Set(["Label", "RichTextLabel"]);
+function internalMinimum(indexed, options, currentRect) {
+	if (TEXT_CONTENT_TYPES.has(indexed.node.type ?? "")) {
+		const size = options.resolveTextContentSize?.(indexed.node, indexed.path, indexed.props, currentRect?.width);
+		if (!size || size.width < 0 || size.height < 0) return;
+		return size;
+	}
+	if (indexed.node.type !== "TextureRect") return;
+	const textureRef = asResourceRef(indexed.props.texture);
+	if (!textureRef) return;
+	const textureSize = resourceSize(options.resolveResource?.(textureRef, indexed.node));
+	if (!textureSize || textureSize.width <= 0 || textureSize.height <= 0) return;
+	const expandMode = numeric(indexed.props, "expand_mode") ?? 0;
+	if (expandMode === 0) return textureSize;
+	if (expandMode === 2) return {
+		width: currentRect?.height ?? 0,
+		height: 0
+	};
+	if (expandMode === 3) return {
+		width: (currentRect?.height ?? 0) * textureSize.width / textureSize.height,
+		height: 0
+	};
+	if (expandMode === 4) return {
+		width: 0,
+		height: currentRect?.width ?? 0
+	};
+	if (expandMode === 5) return {
+		width: 0,
+		height: (currentRect?.width ?? 0) * textureSize.height / textureSize.width
+	};
+}
+function resourceSize(resource) {
+	if (!resource || typeof resource !== "object") return;
+	const record = resource;
+	const size = record.size;
+	if (size && typeof size === "object" && !Array.isArray(size)) {
+		const sizeRecord = size;
+		const width = typeof sizeRecord.width === "number" ? sizeRecord.width : void 0;
+		const height = typeof sizeRecord.height === "number" ? sizeRecord.height : void 0;
+		return width !== void 0 && height !== void 0 ? {
+			width,
+			height
+		} : void 0;
+	}
+	const width = typeof record.width === "number" ? record.width : void 0;
+	const height = typeof record.height === "number" ? record.height : void 0;
+	return width !== void 0 && height !== void 0 ? {
+		width,
+		height
+	} : void 0;
+}
+function hasExpandFlag(indexed, horizontal) {
+	return ((numeric(indexed.props, horizontal ? "size_flags_horizontal" : "size_flags_vertical") ?? 0) & 2) === 2;
+}
+function hasFillFlag(indexed, horizontal) {
+	return ((numeric(indexed.props, horizontal ? "size_flags_horizontal" : "size_flags_vertical") ?? 0) & 1) === 1;
+}
+function alignmentOffset(indexed, available, content) {
+	const alignment = numeric(indexed.props, "alignment") ?? 0;
+	if (alignment === 1) return Math.max(0, (available - content) / 2);
+	if (alignment === 2) return Math.max(0, available - content);
+	return 0;
+}
+//#endregion
+//#region src/rects.ts
+function rootRect(indexed, viewport, byPath, options) {
+	const minimum = combinedMinimum(indexed, byPath, options);
+	const width = numeric(indexed.props, "size_width") ?? sizeFromOffsets(indexed)?.width ?? minimum?.width ?? viewport.width;
+	const height = numeric(indexed.props, "size_height") ?? sizeFromOffsets(indexed)?.height ?? minimum?.height ?? viewport.height;
+	return {
+		x: viewport.x,
+		y: viewport.y,
+		width,
+		height
+	};
+}
+function controlRect(indexed, parent, byPath, options) {
+	const leftAnchor = numeric(indexed.props, "anchor_left") ?? 0;
+	const topAnchor = numeric(indexed.props, "anchor_top") ?? 0;
+	const rightAnchor = numeric(indexed.props, "anchor_right") ?? leftAnchor;
+	const bottomAnchor = numeric(indexed.props, "anchor_bottom") ?? topAnchor;
+	const position = asVector2(indexed.props.position);
+	const leftOffset = numeric(indexed.props, "offset_left") ?? numeric(indexed.props, "position_x") ?? position?.x ?? 0;
+	const topOffset = numeric(indexed.props, "offset_top") ?? numeric(indexed.props, "position_y") ?? position?.y ?? 0;
+	const explicitSize = explicitSizeFromProps(indexed);
+	const rightOffset = numeric(indexed.props, "offset_right") ?? (explicitSize ? leftOffset + explicitSize.width : 0);
+	const bottomOffset = numeric(indexed.props, "offset_bottom") ?? (explicitSize ? topOffset + explicitSize.height : 0);
+	const left = parent.x + parent.width * leftAnchor + leftOffset;
+	const top = parent.y + parent.height * topAnchor + topOffset;
+	const right = parent.x + parent.width * rightAnchor + rightOffset;
+	const bottom = parent.y + parent.height * bottomAnchor + bottomOffset;
+	return growToMinimum(normalizeRect({
+		x: left,
+		y: top,
+		width: right - left,
+		height: bottom - top
+	}), indexed, byPath, options);
+}
+/**
+* Expands and repositions a rect when its combined minimum size exceeds the
+* offset-derived size, mirroring `Control::_size_changed`. The grow direction
+* (BEGIN shifts the start edge, BOTH centers, END only expands) applies
+* unconditionally, independent of anchors.
+*/
+function growToMinimum(rect, indexed, byPath, options) {
+	const minimum = combinedMinimum(indexed, byPath, options, rect);
+	if (!minimum) return rect;
+	let { x, y, width, height } = rect;
+	if (minimum.width > width) {
+		const delta = minimum.width - width;
+		const grow = numeric(indexed.props, "grow_horizontal") ?? 1;
+		if (grow === 0) x -= delta;
+		else if (grow === 2) x -= delta / 2;
+		width = minimum.width;
+	}
+	if (minimum.height > height) {
+		const delta = minimum.height - height;
+		const grow = numeric(indexed.props, "grow_vertical") ?? 1;
+		if (grow === 0) y -= delta;
+		else if (grow === 2) y -= delta / 2;
+		height = minimum.height;
+	}
+	return {
+		x,
+		y,
+		width,
+		height
+	};
+}
+function numeric(props, name) {
+	return asNumber(props[name]);
+}
+function normalizeRect(rect) {
+	return {
+		x: rect.x,
+		y: rect.y,
+		width: Math.max(0, rect.width),
+		height: Math.max(0, rect.height)
+	};
+}
+/**
+* Apply a node's own `scale` around `pivotOffset` to its layout rect, producing
+* the on-screen global rect. Mirrors the renderer's `transform: scale(...)` with
+* `transform-origin: <pivotOffset>` (see node-style.ts): the pivot is a fixed
+* point, so the top-left corner maps to `rect.pos + pivot·(1 − scale)` and the
+* size scales. Godot's `Control.get_global_rect()` includes scale the same way,
+* which is what the live-game layout-diff compares against. Identity scale
+* returns the rect unchanged.
+*/
+function scaledRect(rect, scale, pivotOffset) {
+	if (scale.x === 1 && scale.y === 1) return rect;
+	return {
+		x: rect.x + pivotOffset.x * (1 - scale.x),
+		y: rect.y + pivotOffset.y * (1 - scale.y),
+		width: rect.width * scale.x,
+		height: rect.height * scale.y
+	};
+}
+const IDENTITY_AFFINE = {
+	a: 1,
+	b: 0,
+	c: 0,
+	d: 1,
+	tx: 0,
+	ty: 0
+};
+/** Compose two affines (2×3 matrix multiply) so the result maps `x -> outer(inner(x))`. */
+function composeAffine(outer, inner) {
+	return {
+		a: outer.a * inner.a + outer.c * inner.b,
+		b: outer.b * inner.a + outer.d * inner.b,
+		c: outer.a * inner.c + outer.c * inner.d,
+		d: outer.b * inner.c + outer.d * inner.d,
+		tx: outer.a * inner.tx + outer.c * inner.ty + outer.tx,
+		ty: outer.b * inner.tx + outer.d * inner.ty + outer.ty
+	};
+}
+/**
+* Apply an affine to a rect, producing an axis-aligned `GodotRect` matching Godot
+* `get_global_rect()`: the top-left ORIGIN is transformed through the full
+* (rotation-bearing) matrix, while width/height take the *unrotated* extent — each
+* axis scaled by its column magnitude (`hypot`), NOT inflated to a rotated bounding
+* box. For a pure scale+translate (`b=c=0`) this reduces bit-for-bit to the old
+* `sx·x+tx` behavior.
+*/
+function applyAffine(transform, rect) {
+	const { a, b, c, d, tx, ty } = transform;
+	if (a === 1 && b === 0 && c === 0 && d === 1 && tx === 0 && ty === 0) return rect;
+	return {
+		x: a * rect.x + c * rect.y + tx,
+		y: b * rect.x + d * rect.y + ty,
+		width: rect.width * Math.hypot(a, b),
+		height: rect.height * Math.hypot(c, d)
+	};
+}
+/**
+* The scale+rotation transform a node applies to its own content and all its
+* descendants, in the global (unscaled-layout) coordinate space, pivoting about the
+* node's global pivot `rect.pos + pivotOffset`. The linear part is Godot's
+* `Transform2D(rotation, scale)` basis — x-axis `(cos·sx, sin·sx)`, y-axis
+* `(-sin·sy, cos·sy)` — i.e. rotate∘scale, which is what the live game composes.
+*
+* NOTE: `rotation` is in radians. Correct when the rotation pivot is the rect origin
+* (`pivotOffset` 0, the only case in the captured data and the case the CSS renderer
+* pivots at the origin for); a non-zero pivot combined with self-rotation would also
+* shift the node's own top-left, which `renderedRect` does not model.
+*/
+function ownTransformAffine(rect, scale, rotation, pivotOffset) {
+	const gx = rect.x + pivotOffset.x;
+	const gy = rect.y + pivotOffset.y;
+	const cos = Math.cos(rotation);
+	const sin = Math.sin(rotation);
+	const a = cos * scale.x;
+	const b = sin * scale.x;
+	const c = -sin * scale.y;
+	const d = cos * scale.y;
+	return {
+		a,
+		b,
+		c,
+		d,
+		tx: gx - (a * gx + c * gy),
+		ty: gy - (b * gx + d * gy)
+	};
+}
+//#endregion
+//#region src/layout-node.ts
+function makeLayoutNode(indexed, rect, parent) {
+	const base = deriveNodeVisuals(indexed, parent?.zIndex);
+	const rotationDegrees = asNumber(indexed.props.rotation_degrees);
+	const rotation = asNumber(indexed.props.rotation) ?? (rotationDegrees === void 0 ? 0 : rotationDegrees * Math.PI / 180);
+	const parentTransform = parent?.cumulativeTransform ?? IDENTITY_AFFINE;
+	const renderedRect = applyAffine(parentTransform, scaledRect(rect, base.scale, base.pivotOffset));
+	const cumulativeTransform = composeAffine(parentTransform, ownTransformAffine(rect, base.scale, rotation, base.pivotOffset));
+	return {
+		...base,
+		rect,
+		renderedRect,
+		cumulativeTransform
+	};
+}
+//#endregion
+//#region src/container-layout.ts
+function aspectAlignmentFactor(value) {
+	const alignment = asNumber(value) ?? 1;
+	if (alignment === 0) return 0;
+	if (alignment === 2) return 1;
+	return .5;
+}
+function layoutBoxContainerChildren(parent, rect, byPath, layoutByPath, diagnostics, options, horizontal, layoutChildren) {
+	const separation = themeNumber(parent, "separation", options) ?? 0;
+	const children = visibleChildren(parent, byPath);
+	const sizes = children.map((child) => preferredSize(child, byPath, options));
+	if (!horizontal) children.forEach((child, index) => {
+		if (!TEXT_CONTENT_TYPES.has(child.node.type ?? "")) return;
+		const reflowed = combinedMinimum(child, byPath, options, {
+			x: 0,
+			y: 0,
+			width: axisPlacement(rect.x, rect.width, sizes[index].width, child, true).size,
+			height: 0
+		});
+		if (reflowed) sizes[index] = {
+			width: sizes[index].width,
+			height: reflowed.height
+		};
+	});
+	const totalMinimum = sizes.reduce((sum, size) => sum + (horizontal ? size.width : size.height), 0) + Math.max(0, children.length - 1) * separation;
+	const available = horizontal ? rect.width : rect.height;
+	const remaining = Math.max(0, available - totalMinimum);
+	const expandCount = children.filter((child) => hasExpandFlag(child, horizontal)).length;
+	let cursor = (horizontal ? rect.x : rect.y) + (expandCount > 0 ? 0 : alignmentOffset(parent, available, totalMinimum));
+	children.forEach((child, index) => {
+		const minimum = sizes[index] ?? {
+			width: 0,
+			height: 0
+		};
+		const extra = expandCount > 0 && hasExpandFlag(child, horizontal) ? remaining / expandCount : 0;
+		const fillExtra = hasFillFlag(child, horizontal) ? extra : 0;
+		const crossAxis = horizontal ? axisPlacement(rect.y, rect.height, minimum.height, child, false) : axisPlacement(rect.x, rect.width, minimum.width, child, true);
+		const childRect = horizontal ? {
+			y: crossAxis.position,
+			x: cursor,
+			width: minimum.width + fillExtra,
+			height: crossAxis.size
+		} : {
+			x: crossAxis.position,
+			y: cursor,
+			width: crossAxis.size,
+			height: minimum.height + fillExtra
+		};
+		cursor += (horizontal ? minimum.width + extra : minimum.height + extra) + separation;
+		const layout = makeLayoutNode(child, childRect, layoutByPath.get(parent.path));
+		layoutByPath.set(child.path, layout);
+		layoutChildren(child, childRect, byPath, layoutByPath, diagnostics, options);
+	});
+}
+function layoutGridContainerChildren(parent, rect, byPath, layoutByPath, diagnostics, options, layoutChildren) {
+	const columns = Math.max(1, Math.floor(numeric(parent.props, "columns") ?? 1));
+	const hSeparation = themeNumber(parent, "h_separation", options) ?? themeNumber(parent, "separation", options) ?? 0;
+	const vSeparation = themeNumber(parent, "v_separation", options) ?? themeNumber(parent, "separation", options) ?? 0;
+	const children = visibleChildren(parent, byPath);
+	const sizes = children.map((child) => preferredSize(child, byPath, options));
+	const columnWidths = Array.from({ length: columns }, (_, column) => Math.max(0, ...sizes.filter((_, index) => index % columns === column).map((size) => size.width)));
+	const rowCount = Math.ceil(children.length / columns);
+	const rowHeights = Array.from({ length: rowCount }, (_, row) => Math.max(0, ...sizes.slice(row * columns, row * columns + columns).map((size) => size.height)));
+	const parentLayout = layoutByPath.get(parent.path);
+	children.forEach((child, index) => {
+		const column = index % columns;
+		const row = Math.floor(index / columns);
+		const cell = {
+			x: rect.x + columnWidths.slice(0, column).reduce((sum, width) => sum + width, 0) + column * hSeparation,
+			y: rect.y + rowHeights.slice(0, row).reduce((sum, height) => sum + height, 0) + row * vSeparation,
+			width: columnWidths[column] ?? 0,
+			height: rowHeights[row] ?? 0
+		};
+		const horizontalPlacement = axisPlacement(cell.x, cell.width, sizes[index]?.width ?? 0, child, true);
+		const verticalPlacement = axisPlacement(cell.y, cell.height, sizes[index]?.height ?? 0, child, false);
+		const childRect = {
+			x: horizontalPlacement.position,
+			y: verticalPlacement.position,
+			width: horizontalPlacement.size,
+			height: verticalPlacement.size
+		};
+		layoutByPath.set(child.path, makeLayoutNode(child, childRect, parentLayout));
+		layoutChildren(child, childRect, byPath, layoutByPath, diagnostics, options);
+	});
+}
+function layoutFlowContainerChildren(parent, rect, byPath, layoutByPath, diagnostics, options, vertical, layoutChildren) {
+	const hSeparation = themeNumber(parent, "h_separation", options) ?? themeNumber(parent, "separation", options) ?? 0;
+	const vSeparation = themeNumber(parent, "v_separation", options) ?? themeNumber(parent, "separation", options) ?? 0;
+	const lines = flowWrapLines(rect, visibleChildren(parent, byPath).map((child) => ({
+		item: child,
+		size: preferredSize(child, byPath, options)
+	})), vertical, hSeparation, vSeparation);
+	for (const line of lines) {
+		const crossSize = line.reduce((max, entry) => Math.max(max, vertical ? entry.size.width : entry.size.height), 0);
+		for (const entry of line) {
+			const childRect = vertical ? {
+				x: entry.x,
+				y: entry.y,
+				width: crossSize,
+				height: entry.size.height
+			} : {
+				x: entry.x,
+				y: entry.y,
+				width: entry.size.width,
+				height: crossSize
+			};
+			layoutByPath.set(entry.item.path, makeLayoutNode(entry.item, childRect, layoutByPath.get(parent.path)));
+			layoutChildren(entry.item, childRect, byPath, layoutByPath, diagnostics, options);
+		}
+	}
+}
+function layoutAspectRatioContainerChildren(parent, rect, byPath, layoutByPath, diagnostics, options, layoutChildren) {
+	const ratio = numeric(parent.props, "ratio") ?? 1;
+	const safeRatio = ratio === 0 ? 1 : ratio;
+	const stretchMode = numeric(parent.props, "stretch_mode") ?? 2;
+	const alignX = aspectAlignmentFactor(parent.props.alignment_horizontal);
+	const alignY = aspectAlignmentFactor(parent.props.alignment_vertical);
+	const parentLayout = layoutByPath.get(parent.path);
+	for (const childPath of parent.children) {
+		const child = byPath.get(childPath);
+		if (!child) continue;
+		const minimum = combinedMinimum(child, byPath, options) ?? {
+			width: 0,
+			height: 0
+		};
+		const base = {
+			width: safeRatio,
+			height: 1
+		};
+		let scaleFactor;
+		if (stretchMode === 0) scaleFactor = rect.width / base.width;
+		else if (stretchMode === 1) scaleFactor = rect.height / base.height;
+		else if (stretchMode === 3) scaleFactor = Math.max(rect.width / base.width, rect.height / base.height);
+		else scaleFactor = Math.min(rect.width / base.width, rect.height / base.height);
+		const width = Math.max(minimum.width, base.width * scaleFactor);
+		const height = Math.max(minimum.height, base.height * scaleFactor);
+		const childRect = {
+			x: rect.x + (rect.width - width) * alignX,
+			y: rect.y + (rect.height - height) * alignY,
+			width,
+			height
+		};
+		layoutByPath.set(child.path, makeLayoutNode(child, childRect, parentLayout));
+		layoutChildren(child, childRect, byPath, layoutByPath, diagnostics, options);
+	}
+}
+function layoutPanelContainerChildren(parent, rect, byPath, layoutByPath, diagnostics, options, layoutChildren) {
+	layoutFitChildren(parent, contentRectForStyleBox(rect, panelStyleBoxMetrics(parent, options)), byPath, layoutByPath, diagnostics, options, layoutChildren);
+}
+function layoutScrollContainerChildren(parent, rect, byPath, layoutByPath, diagnostics, options, layoutChildren) {
+	const content = contentRectForStyleBox(rect, panelStyleBoxMetrics(parent, options));
+	const scrollX = numeric(parent.props, "scroll_horizontal") ?? 0;
+	const scrollY = numeric(parent.props, "scroll_vertical") ?? 0;
+	const parentLayout = layoutByPath.get(parent.path);
+	for (const childPath of parent.children) {
+		const child = byPath.get(childPath);
+		if (!child) continue;
+		const size = preferredSize(child, byPath, options);
+		const childRect = {
+			x: content.x - scrollX,
+			y: content.y - scrollY,
+			width: hasExpandFlag(child, true) ? Math.max(content.width, size.width) : size.width,
+			height: hasExpandFlag(child, false) ? Math.max(content.height, size.height) : size.height
+		};
+		layoutByPath.set(child.path, makeLayoutNode(child, childRect, parentLayout));
+		layoutChildren(child, childRect, byPath, layoutByPath, diagnostics, options);
+	}
+}
+function layoutMarginChildren(parent, rect, byPath, layoutByPath, diagnostics, options, layoutChildren) {
+	const left = themeNumber(parent, "margin_left", options) ?? 0;
+	const top = themeNumber(parent, "margin_top", options) ?? 0;
+	const right = themeNumber(parent, "margin_right", options) ?? 0;
+	const bottom = themeNumber(parent, "margin_bottom", options) ?? 0;
+	layoutFitChildren(parent, normalizeRect({
+		x: rect.x + left,
+		y: rect.y + top,
+		width: rect.width - left - right,
+		height: rect.height - top - bottom
+	}), byPath, layoutByPath, diagnostics, options, layoutChildren);
+}
+function layoutFitChildren(parent, content, byPath, layoutByPath, diagnostics, options, layoutChildren) {
+	const parentLayout = layoutByPath.get(parent.path);
+	for (const childPath of parent.children) {
+		const child = byPath.get(childPath);
+		if (!child) continue;
+		const minimum = preferredSize(child, byPath, options);
+		const horizontal = axisPlacement(content.x, content.width, minimum.width, child, true);
+		const vertical = axisPlacement(content.y, content.height, minimum.height, child, false);
+		const childRect = {
+			x: horizontal.position,
+			y: vertical.position,
+			width: horizontal.size,
+			height: vertical.size
+		};
+		layoutByPath.set(child.path, makeLayoutNode(child, childRect, parentLayout));
+		layoutChildren(child, childRect, byPath, layoutByPath, diagnostics, options);
+	}
+}
+function layoutCenterChildren(parent, rect, byPath, layoutByPath, diagnostics, options, layoutChildren) {
+	for (const childPath of parent.children) {
+		const child = byPath.get(childPath);
+		if (!child) continue;
+		const size = preferredSize(child, byPath, options);
+		const childRect = {
+			x: rect.x + (rect.width - size.width) / 2,
+			y: rect.y + (rect.height - size.height) / 2,
+			width: size.width,
+			height: size.height
+		};
+		layoutByPath.set(childPath, makeLayoutNode(child, childRect, layoutByPath.get(parent.path)));
+		layoutChildren(child, childRect, byPath, layoutByPath, diagnostics, options);
+	}
+}
+function axisPlacement(start, available, minimum, indexed, horizontalAxis) {
+	const flags = numeric(indexed.props, horizontalAxis ? "size_flags_horizontal" : "size_flags_vertical") ?? 0;
+	const shrinkCenter = (flags & 4) === 4;
+	const shrinkEnd = (flags & 8) === 8;
+	const size = shrinkCenter || shrinkEnd ? minimum : Math.max(available, minimum);
+	return {
+		position: shrinkEnd ? start + Math.max(0, available - size) : shrinkCenter ? start + Math.max(0, (available - size) / 2) : start,
+		size
+	};
+}
+//#endregion
+//#region src/membership.ts
+/**
+* The nodes the rect cascade ({@link resolveGodotSceneTree}) would lay out, without
+* running it. The cascade drops exactly one class of node: an invisible child of a
+* Box/Grid/Flow container — and its whole subtree — because a hidden control takes
+* no space in those containers (`visibleChildren` in minimum-size.ts; every other
+* container type and plain parents lay out all children). Consumers that only need
+* per-node structural fields (`drawOrder`, `type`, `source`, `properties`) can use
+* this instead of the cascade and skip all rect math; `membership.test.ts` pins the
+* equivalence against the cascade.
+*/
+function flattenSceneGraphNodes(graph) {
+	const byPath = new Map(graph.nodes.map((node) => [node.path, node]));
+	const out = [];
+	const visit = (node) => {
+		out.push(node);
+		const skipsInvisibleChildren = isBoxContainerType(node.type) || isFlowContainerType(node.type) || node.type === "GridContainer";
+		for (const childPath of node.children) {
+			const child = byPath.get(childPath);
+			if (!child) continue;
+			if (skipsInvisibleChildren && !child.visible) continue;
+			visit(child);
+		}
+	};
+	for (const node of graph.nodes) if (node.parentPath === null) visit(node);
+	return out;
+}
+//#endregion
+//#region src/index.ts
+function isGodotSceneTree(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const tree = value;
+	return isRectLike(tree.viewport) && Array.isArray(tree.nodes) && tree.nodes.every(isTreeNode) && (tree.diagnostics === void 0 || Array.isArray(tree.diagnostics)) && (tree.resourceStatuses === void 0 || Array.isArray(tree.resourceStatuses));
+}
+function isRectLike(value) {
+	return typeof value === "object" && value !== null && typeof value.x === "number" && typeof value.y === "number" && typeof value.width === "number" && typeof value.height === "number";
+}
+function isTreeNode(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const node = value;
+	return typeof node.path === "string" && typeof node.name === "string" && typeof node.type === "string" && (typeof node.parentPath === "string" || node.parentPath === null) && Array.isArray(node.children) && isRectLike(node.rect) && typeof node.visible === "boolean" && typeof node.zIndex === "number" && typeof node.drawOrder === "number" && typeof node.zAsRelative === "boolean" && typeof node.showBehindParent === "boolean" && typeof node.clipContents === "boolean" && typeof node.properties === "object" && node.properties !== null && Array.isArray(node.resourceRefs);
+}
+const DEFAULT_VIEWPORT = {
+	x: 0,
+	y: 0,
+	width: 1280,
+	height: 720
+};
+const MAX_LAYOUT_PASSES = 8;
+function toIndexedNode(node) {
+	return {
+		node: node.source ?? {
+			name: node.name,
+			type: node.type,
+			attributes: {},
+			properties: node.properties
+		},
+		path: node.path,
+		parentPath: node.parentPath,
+		children: [...node.children],
+		props: node.properties,
+		order: node.drawOrder
+	};
+}
+function resolveGodotSceneTree(graph, options = {}) {
+	const viewport = {
+		...DEFAULT_VIEWPORT,
+		...options.viewport
+	};
+	const indexed = graph.nodes.map(toIndexedNode);
+	const byPath = new Map(indexed.map((node) => [node.path, node]));
+	const roots = indexed.filter((node) => node.parentPath === null);
+	const flows = indexed.filter((node) => isFlowContainerType(node.node.type ?? "Node"));
+	let layoutByPath = /* @__PURE__ */ new Map();
+	let diagnostics = [];
+	for (let pass = 0; pass < MAX_LAYOUT_PASSES; pass++) {
+		layoutByPath = /* @__PURE__ */ new Map();
+		diagnostics = [];
+		for (const node of indexed) node.minimumSize = void 0;
+		for (const root of roots) layoutNode(root.path, viewport, byPath, layoutByPath, diagnostics, options);
+		if (flows.length === 0 || !updateFlowExtents(flows, layoutByPath)) break;
+		if (pass === MAX_LAYOUT_PASSES - 1) diagnostics.push({
+			severity: "warning",
+			code: "flow-layout-unconverged",
+			message: "Flow container layout did not converge within the pass limit; rects may be unsettled."
+		});
+	}
+	resolveAnchors(layoutByPath, options.anchorsByPath, diagnostics);
+	return {
+		viewport,
+		nodes: [...layoutByPath.values()].sort((left, right) => left.zIndex - right.zIndex || left.drawOrder - right.drawOrder),
+		diagnostics,
+		resourceStatuses: graph.resourceStatuses
+	};
+}
+/**
+* Records each flow container's resolved main-axis extent for the next pass.
+* Returns true if any extent changed (i.e. another pass is warranted).
+*/
+function updateFlowExtents(flows, layoutByPath) {
+	let changed = false;
+	for (const flow of flows) {
+		const node = layoutByPath.get(flow.path);
+		if (!node) continue;
+		const extent = flowContainerVertical(flow) ? node.rect.height : node.rect.width;
+		if (flow.flowMainExtent === void 0 || Math.abs(flow.flowMainExtent - extent) > 1e-6) {
+			flow.flowMainExtent = extent;
+			changed = true;
+		}
+	}
+	return changed;
+}
+function layoutNode(path, parentRect, byPath, layoutByPath, diagnostics, options) {
+	const indexed = byPath.get(path);
+	if (!indexed) return;
+	if (layoutByPath.has(path)) return layoutByPath.get(path);
+	const rect = indexed.parentPath === null ? rootRect(indexed, parentRect, byPath, options) : controlRect(indexed, parentRect, byPath, options);
+	const computedNode = makeLayoutNode(indexed, rect, indexed.parentPath ? layoutByPath.get(indexed.parentPath) : void 0);
+	layoutByPath.set(path, computedNode);
+	layoutNodeChildren(indexed, rect, byPath, layoutByPath, diagnostics, options);
+	return computedNode;
+}
+function layoutNodeChildren(indexed, rect, byPath, layoutByPath, diagnostics, options) {
+	const type = indexed.node.type ?? "Node";
+	if (isBoxContainerType(type)) layoutBoxContainerChildren(indexed, rect, byPath, layoutByPath, diagnostics, options, boxContainerHorizontal(indexed), layoutNodeChildren);
+	else if (type === "AspectRatioContainer") layoutAspectRatioContainerChildren(indexed, rect, byPath, layoutByPath, diagnostics, options, layoutNodeChildren);
+	else if (type === "GridContainer") layoutGridContainerChildren(indexed, rect, byPath, layoutByPath, diagnostics, options, layoutNodeChildren);
+	else if (isFlowContainerType(type)) layoutFlowContainerChildren(indexed, rect, byPath, layoutByPath, diagnostics, options, flowContainerVertical(indexed), layoutNodeChildren);
+	else if (type === "PanelContainer") layoutPanelContainerChildren(indexed, rect, byPath, layoutByPath, diagnostics, options, layoutNodeChildren);
+	else if (type === "ScrollContainer") layoutScrollContainerChildren(indexed, rect, byPath, layoutByPath, diagnostics, options, layoutNodeChildren);
+	else if (type === "MarginContainer") layoutMarginChildren(indexed, rect, byPath, layoutByPath, diagnostics, options, layoutNodeChildren);
+	else if (type === "CenterContainer") layoutCenterChildren(indexed, rect, byPath, layoutByPath, diagnostics, options, layoutNodeChildren);
+	else for (const childPath of indexed.children) layoutNode(childPath, rect, byPath, layoutByPath, diagnostics, options);
+}
+//#endregion
+export { anchorEdgePoint, flattenSceneGraphNodes, isGodotSceneTree, parseAnchorEdge, resolveGodotSceneTree };
+
+//# sourceMappingURL=index.js.map