flexily 0.5.2 → 0.6.0

package/dist/index-classic.mjs

@@ -0,0 +1,1909 @@
+import { $ as WRAP_WRAP, A as GUTTER_ROW, B as OVERFLOW_HIDDEN, C as EDGE_VERTICAL, D as FLEX_DIRECTION_ROW_REVERSE, E as FLEX_DIRECTION_ROW, F as JUSTIFY_SPACE_BETWEEN, G as POSITION_TYPE_STATIC, H as OVERFLOW_VISIBLE, I as JUSTIFY_SPACE_EVENLY, J as UNIT_PERCENT, K as UNIT_AUTO, L as MEASURE_MODE_AT_MOST, M as JUSTIFY_FLEX_END, N as JUSTIFY_FLEX_START, O as GUTTER_ALL, P as JUSTIFY_SPACE_AROUND, Q as WRAP_NO_WRAP, R as MEASURE_MODE_EXACTLY, S as EDGE_TOP, T as FLEX_DIRECTION_COLUMN_REVERSE, U as POSITION_TYPE_ABSOLUTE, V as OVERFLOW_SCROLL, W as POSITION_TYPE_RELATIVE, Y as UNIT_POINT, Z as UNIT_UNDEFINED, _ as EDGE_END, a as ALIGN_FLEX_START, b as EDGE_RIGHT, c as ALIGN_SPACE_EVENLY, d as DIRECTION_LTR, et as WRAP_WRAP_REVERSE, f as DIRECTION_RTL, g as EDGE_BOTTOM, h as EDGE_ALL, i as ALIGN_FLEX_END, j as JUSTIFY_CENTER, k as GUTTER_COLUMN, l as ALIGN_STRETCH, m as DISPLAY_NONE, n as ALIGN_BASELINE, o as ALIGN_SPACE_AROUND, p as DISPLAY_FLEX, r as ALIGN_CENTER, s as ALIGN_SPACE_BETWEEN, t as ALIGN_AUTO, u as DIRECTION_INHERIT, v as EDGE_HORIZONTAL, w as FLEX_DIRECTION_COLUMN, x as EDGE_START, y as EDGE_LEFT, z as MEASURE_MODE_UNDEFINED } from "./constants-BNURa6H7.mjs";
+import { a as getEdgeBorderValue, c as setEdgeBorder, i as applyMinMax, l as setEdgeValue, n as createValue, o as getEdgeValue, r as log, s as resolveValue, t as createDefaultStyle } from "./types--IozHd4V.mjs";
+//#region src/classic/layout.ts
+/**
+* Flexily Layout Algorithm
+*
+* Core flexbox layout computation extracted from node.ts.
+* Based on Planning-nl/flexbox.js reference implementation.
+*/
+/**
+* Check if flex direction is row-oriented (horizontal main axis).
+*/
+function isRowDirection(flexDirection) {
+	return flexDirection === 2 || flexDirection === 3;
+}
+/**
+* Check if flex direction is reversed.
+*/
+function isReverseDirection(flexDirection) {
+	return flexDirection === 3 || flexDirection === 1;
+}
+/**
+* Get the logical edge value (START/END) for a given physical index.
+* Returns undefined if no logical value applies to this physical edge.
+*
+* The mapping depends on flex direction and text direction:
+* - Row LTR: START→left, END→right (swapped if reverse)
+* - Row RTL: START→right, END→left (swapped if reverse)
+* - Column: START→top, END→bottom (swapped if reverse)
+*/
+function getLogicalEdgeValue(arr, physicalIndex, _flexDirection, direction = 1) {
+	const isRTL = direction === 2;
+	if (physicalIndex === 0) return isRTL ? arr[5] : arr[4];
+	else if (physicalIndex === 2) return isRTL ? arr[4] : arr[5];
+}
+/**
+* Resolve logical (START/END) margins/padding to physical values.
+* EDGE_START/EDGE_END always resolve along the inline (horizontal) axis:
+* - LTR: START→left, END→right
+* - RTL: START→right, END→left
+*
+* Physical edges (LEFT/RIGHT/TOP/BOTTOM) are used directly.
+* When both physical and logical are set, logical takes precedence.
+*/
+function resolveEdgeValue(arr, physicalIndex, flexDirection, availableSize, direction = 1) {
+	const logicalValue = getLogicalEdgeValue(arr, physicalIndex, flexDirection, direction);
+	if (logicalValue && logicalValue.unit !== 0) return resolveValue(logicalValue, availableSize);
+	return resolveValue(arr[physicalIndex], availableSize);
+}
+/**
+* Check if a logical edge margin is set to auto.
+*/
+function isEdgeAuto(arr, physicalIndex, flexDirection, direction = 1) {
+	const logicalValue = getLogicalEdgeValue(arr, physicalIndex, flexDirection, direction);
+	if (logicalValue && logicalValue.unit !== 0) return logicalValue.unit === 3;
+	return arr[physicalIndex].unit === 3;
+}
+/**
+* Resolve logical (START/END) border widths to physical values.
+* Border values are plain numbers (always points), so resolution is simpler
+* than for margin/padding. Uses NaN as the "not set" sentinel for logical slots.
+* When both physical and logical are set, logical takes precedence.
+*/
+function resolveEdgeBorderValue(arr, physicalIndex, _flexDirection, direction = 1) {
+	const isRTL = direction === 2;
+	let logicalSlot;
+	if (physicalIndex === 0) logicalSlot = isRTL ? 5 : 4;
+	else if (physicalIndex === 2) logicalSlot = isRTL ? 4 : 5;
+	if (logicalSlot !== void 0 && !Number.isNaN(arr[logicalSlot])) return arr[logicalSlot];
+	return arr[physicalIndex];
+}
+function markSubtreeLayoutSeen(node) {
+	for (const child of node.children) {
+		child["_hasNewLayout"] = true;
+		markSubtreeLayoutSeen(child);
+	}
+}
+function countNodes(node) {
+	let count = 1;
+	for (const child of node.children) count += countNodes(child);
+	return count;
+}
+/**
+* Epsilon value for floating point comparisons in flex distribution.
+* Used to determine when remaining space is negligible and iteration should stop.
+*/
+const EPSILON_FLOAT = .001;
+/**
+* Break children into flex lines based on available main-axis space.
+*
+* @param children - All children to potentially wrap
+* @param mainAxisSize - Available main-axis space (NaN for unconstrained)
+* @param mainGap - Gap between items on main axis
+* @param wrap - Wrap mode (WRAP_NO_WRAP, WRAP_WRAP, WRAP_WRAP_REVERSE)
+* @returns Array of flex lines
+*/
+function breakIntoLines(children, mainAxisSize, mainGap, wrap) {
+	if (wrap === 0 || Number.isNaN(mainAxisSize) || children.length === 0) return [{
+		children,
+		crossSize: 0,
+		crossStart: 0
+	}];
+	const lines = [];
+	let currentLine = [];
+	let lineMainSize = 0;
+	for (const child of children) {
+		const childMainSize = Math.max(child.minMain, Math.min(child.maxMain, child.baseSize)) + child.mainMargin;
+		const gapIfNotFirst = currentLine.length > 0 ? mainGap : 0;
+		if (currentLine.length > 0 && lineMainSize + gapIfNotFirst + childMainSize > mainAxisSize) {
+			lines.push({
+				children: currentLine,
+				crossSize: 0,
+				crossStart: 0
+			});
+			currentLine = [child];
+			lineMainSize = childMainSize;
+		} else {
+			currentLine.push(child);
+			lineMainSize += gapIfNotFirst + childMainSize;
+		}
+	}
+	if (currentLine.length > 0) lines.push({
+		children: currentLine,
+		crossSize: 0,
+		crossStart: 0
+	});
+	if (wrap === 2) lines.reverse();
+	return lines;
+}
+/**
+* Distribute free space among flex children using grow or shrink factors.
+* Handles both positive (grow) and negative (shrink) free space.
+*
+* For shrinking, per CSS Flexbox spec, the shrink factor is weighted by the item's
+* base size: scaledShrinkFactor = flexShrink * baseSize
+*
+* @param children - Array of child layout info to distribute space among
+* @param freeSpace - Amount of space to distribute (positive for grow, negative for shrink)
+*/
+function distributeFlexSpace(children, initialFreeSpace) {
+	const isGrowing = initialFreeSpace > 0;
+	if (initialFreeSpace === 0) return;
+	if (children.length === 1) {
+		const child = children[0];
+		if (isGrowing ? child.flexGrow > 0 : child.flexShrink > 0) {
+			const target = child.baseSize + initialFreeSpace;
+			child.mainSize = Math.max(child.minMain, Math.min(child.maxMain, target));
+		}
+		return;
+	}
+	let totalBase = 0;
+	for (const childLayout of children) totalBase += childLayout.baseSize;
+	const containerInner = initialFreeSpace + totalBase;
+	for (const childLayout of children) childLayout.frozen = false;
+	let freeSpace = initialFreeSpace;
+	let iterations = 0;
+	const maxIterations = children.length + 1;
+	while (iterations++ < maxIterations) {
+		let totalFlex = 0;
+		for (const childLayout of children) {
+			if (childLayout.frozen) continue;
+			if (isGrowing) totalFlex += childLayout.flexGrow;
+			else totalFlex += childLayout.flexShrink * childLayout.baseSize;
+		}
+		if (totalFlex === 0) break;
+		let effectiveFreeSpace = freeSpace;
+		if (isGrowing && totalFlex < 1) effectiveFreeSpace = freeSpace * totalFlex;
+		let totalViolation = 0;
+		for (const childLayout of children) {
+			if (childLayout.frozen) continue;
+			const flexFactor = isGrowing ? childLayout.flexGrow : childLayout.flexShrink * childLayout.baseSize;
+			const ratio = totalFlex > 0 ? flexFactor / totalFlex : 0;
+			const target = childLayout.baseSize + effectiveFreeSpace * ratio;
+			const clamped = Math.max(childLayout.minMain, Math.min(childLayout.maxMain, target));
+			const violation = clamped - target;
+			totalViolation += violation;
+			childLayout.mainSize = clamped;
+		}
+		let anyFrozen = false;
+		if (Math.abs(totalViolation) < EPSILON_FLOAT) {
+			for (const childLayout of children) childLayout.frozen = true;
+			break;
+		} else if (totalViolation > 0) for (const childLayout of children) {
+			if (childLayout.frozen) continue;
+			const target = childLayout.baseSize + (isGrowing ? childLayout.flexGrow : childLayout.flexShrink * childLayout.baseSize) / totalFlex * effectiveFreeSpace;
+			if (childLayout.mainSize > target + EPSILON_FLOAT) {
+				childLayout.frozen = true;
+				anyFrozen = true;
+			}
+		}
+		else for (const childLayout of children) {
+			if (childLayout.frozen) continue;
+			const flexFactor = isGrowing ? childLayout.flexGrow : childLayout.flexShrink * childLayout.baseSize;
+			const target = childLayout.baseSize + flexFactor / totalFlex * effectiveFreeSpace;
+			if (childLayout.mainSize < target - EPSILON_FLOAT) {
+				childLayout.frozen = true;
+				anyFrozen = true;
+			}
+		}
+		if (!anyFrozen) break;
+		let frozenSpace = 0;
+		let unfrozenBase = 0;
+		for (const childLayout of children) if (childLayout.frozen) frozenSpace += childLayout.mainSize;
+		else unfrozenBase += childLayout.baseSize;
+		freeSpace = containerInner - frozenSpace - unfrozenBase;
+	}
+}
+/**
+* Compute layout for a node tree.
+*
+* @param root - Root node of the tree
+* @param availableWidth - Available width for layout
+* @param availableHeight - Available height for layout
+* @param direction - Text direction (LTR or RTL), affects horizontal edge resolution
+*/
+function computeLayout(root, availableWidth, availableHeight, direction = 1) {
+	layoutNode(root, availableWidth, availableHeight, 0, 0, 0, 0, direction);
+}
+/**
+* Layout a node and its children.
+*
+* @param absX - Absolute X position from document root (for Yoga-compatible edge rounding)
+* @param absY - Absolute Y position from document root (for Yoga-compatible edge rounding)
+* @param direction - Text direction (LTR or RTL), affects horizontal edge resolution
+*/
+function layoutNode(node, availableWidth, availableHeight, offsetX, offsetY, absX, absY, direction = 1) {
+	log.debug?.("layoutNode called: availW=%d, availH=%d, offsetX=%d, offsetY=%d, absX=%d, absY=%d, children=%d", availableWidth, availableHeight, offsetX, offsetY, absX, absY, node.children.length);
+	const style = node.style;
+	const layout = node.layout;
+	if (style.display === 1) {
+		layout.left = 0;
+		layout.top = 0;
+		layout.width = 0;
+		layout.height = 0;
+		return;
+	}
+	const marginLeft = resolveEdgeValue(style.margin, 0, style.flexDirection, availableWidth, direction);
+	const marginTop = resolveEdgeValue(style.margin, 1, style.flexDirection, availableWidth, direction);
+	const marginRight = resolveEdgeValue(style.margin, 2, style.flexDirection, availableWidth, direction);
+	const marginBottom = resolveEdgeValue(style.margin, 3, style.flexDirection, availableWidth, direction);
+	const paddingLeft = resolveEdgeValue(style.padding, 0, style.flexDirection, availableWidth, direction);
+	const paddingTop = resolveEdgeValue(style.padding, 1, style.flexDirection, availableWidth, direction);
+	const paddingRight = resolveEdgeValue(style.padding, 2, style.flexDirection, availableWidth, direction);
+	const paddingBottom = resolveEdgeValue(style.padding, 3, style.flexDirection, availableWidth, direction);
+	const borderLeft = resolveEdgeBorderValue(style.border, 0, style.flexDirection, direction);
+	const borderTop = resolveEdgeBorderValue(style.border, 1, style.flexDirection, direction);
+	const borderRight = resolveEdgeBorderValue(style.border, 2, style.flexDirection, direction);
+	const borderBottom = resolveEdgeBorderValue(style.border, 3, style.flexDirection, direction);
+	let nodeWidth;
+	if (style.width.unit === 1) nodeWidth = style.width.value;
+	else if (style.width.unit === 2) nodeWidth = resolveValue(style.width, availableWidth);
+	else if (Number.isNaN(availableWidth)) nodeWidth = NaN;
+	else nodeWidth = availableWidth - marginLeft - marginRight;
+	nodeWidth = applyMinMax(nodeWidth, style.minWidth, style.maxWidth, availableWidth);
+	let nodeHeight;
+	if (style.height.unit === 1) nodeHeight = style.height.value;
+	else if (style.height.unit === 2) nodeHeight = resolveValue(style.height, availableHeight);
+	else if (Number.isNaN(availableHeight)) nodeHeight = NaN;
+	else nodeHeight = availableHeight - marginTop - marginBottom;
+	const aspectRatio = style.aspectRatio;
+	if (!Number.isNaN(aspectRatio) && aspectRatio > 0) {
+		const widthIsAuto = Number.isNaN(nodeWidth) || style.width.unit === 3;
+		const heightIsAuto = Number.isNaN(nodeHeight) || style.height.unit === 3;
+		if (widthIsAuto && !heightIsAuto && !Number.isNaN(nodeHeight)) nodeWidth = nodeHeight * aspectRatio;
+		else if (heightIsAuto && !widthIsAuto && !Number.isNaN(nodeWidth)) nodeHeight = nodeWidth / aspectRatio;
+	}
+	nodeHeight = applyMinMax(nodeHeight, style.minHeight, style.maxHeight, availableHeight);
+	const innerLeft = borderLeft + paddingLeft;
+	const innerTop = borderTop + paddingTop;
+	const innerRight = borderRight + paddingRight;
+	const innerBottom = borderBottom + paddingBottom;
+	const minInnerWidth = innerLeft + innerRight;
+	const minInnerHeight = innerTop + innerBottom;
+	if (!Number.isNaN(nodeWidth) && nodeWidth < minInnerWidth) nodeWidth = minInnerWidth;
+	if (!Number.isNaN(nodeHeight) && nodeHeight < minInnerHeight) nodeHeight = minInnerHeight;
+	const contentWidth = Number.isNaN(nodeWidth) ? NaN : Math.max(0, nodeWidth - innerLeft - innerRight);
+	const contentHeight = Number.isNaN(nodeHeight) ? NaN : Math.max(0, nodeHeight - innerTop - innerBottom);
+	let parentPosOffsetX = 0;
+	let parentPosOffsetY = 0;
+	if (style.positionType === 1) {
+		const leftPos = style.position[0];
+		const topPos = style.position[1];
+		const rightPos = style.position[2];
+		const bottomPos = style.position[3];
+		if (leftPos.unit !== 0) parentPosOffsetX = resolveValue(leftPos, availableWidth);
+		else if (rightPos.unit !== 0) parentPosOffsetX = -resolveValue(rightPos, availableWidth);
+		if (topPos.unit !== 0) parentPosOffsetY = resolveValue(topPos, availableHeight);
+		else if (bottomPos.unit !== 0) parentPosOffsetY = -resolveValue(bottomPos, availableHeight);
+	}
+	if (node.hasMeasureFunc() && node.children.length === 0) {
+		const measureFunc = node.measureFunc;
+		const widthIsAuto = style.width.unit === 3 || style.width.unit === 0 || Number.isNaN(nodeWidth);
+		const heightIsAuto = style.height.unit === 3 || style.height.unit === 0 || Number.isNaN(nodeHeight);
+		const widthMode = widthIsAuto ? 2 : 1;
+		const heightMode = heightIsAuto ? 0 : 1;
+		const measured = measureFunc(Number.isNaN(contentWidth) ? Infinity : contentWidth, widthMode, Number.isNaN(contentHeight) ? Infinity : contentHeight, heightMode);
+		if (widthIsAuto) nodeWidth = measured.width + innerLeft + innerRight;
+		if (heightIsAuto) nodeHeight = measured.height + innerTop + innerBottom;
+		layout.width = Math.round(nodeWidth);
+		layout.height = Math.round(nodeHeight);
+		layout.left = Math.round(offsetX + marginLeft);
+		layout.top = Math.round(offsetY + marginTop);
+		return;
+	}
+	if (node.children.length === 0) {
+		if (Number.isNaN(nodeWidth)) nodeWidth = innerLeft + innerRight;
+		if (Number.isNaN(nodeHeight)) nodeHeight = innerTop + innerBottom;
+		layout.width = Math.round(nodeWidth);
+		layout.height = Math.round(nodeHeight);
+		layout.left = Math.round(offsetX + marginLeft);
+		layout.top = Math.round(offsetY + marginTop);
+		return;
+	}
+	const relativeChildren = node.children.filter((c) => c.style.positionType !== 2 && c.style.display !== 1);
+	const absoluteChildren = node.children.filter((c) => c.style.positionType === 2 && c.style.display !== 1);
+	log.debug?.("layoutNode: node.children=%d, relativeChildren=%d, absolute=%d", node.children.length, relativeChildren.length, absoluteChildren.length);
+	if (relativeChildren.length > 0) {
+		const isRow = isRowDirection(style.flexDirection);
+		const isReverse = isReverseDirection(style.flexDirection);
+		const mainAxisSize = isRow ? contentWidth : contentHeight;
+		const crossAxisSize = isRow ? contentHeight : contentWidth;
+		const mainGap = isRow ? style.gap[0] : style.gap[1];
+		const children = [];
+		let totalBaseMain = 0;
+		for (const child of relativeChildren) {
+			const childStyle = child.style;
+			const mainStartIndex = isRow ? isReverse ? 2 : 0 : isReverse ? 3 : 1;
+			const mainEndIndex = isRow ? isReverse ? 0 : 2 : isReverse ? 1 : 3;
+			const mainStartMarginAuto = isEdgeAuto(childStyle.margin, mainStartIndex, style.flexDirection);
+			const mainEndMarginAuto = isEdgeAuto(childStyle.margin, mainEndIndex, style.flexDirection);
+			const parentWidth = isRow ? mainAxisSize : crossAxisSize;
+			const mainStartMarginValue = mainStartMarginAuto ? 0 : resolveEdgeValue(childStyle.margin, mainStartIndex, style.flexDirection, parentWidth, direction);
+			const mainEndMarginValue = mainEndMarginAuto ? 0 : resolveEdgeValue(childStyle.margin, mainEndIndex, style.flexDirection, parentWidth, direction);
+			const mainMargin = mainStartMarginValue + mainEndMarginValue;
+			let baseSize = 0;
+			if (childStyle.flexBasis.unit === 1) baseSize = childStyle.flexBasis.value;
+			else if (childStyle.flexBasis.unit === 2) baseSize = mainAxisSize * (childStyle.flexBasis.value / 100);
+			else {
+				const sizeVal = isRow ? childStyle.width : childStyle.height;
+				if (sizeVal.unit === 1) baseSize = sizeVal.value;
+				else if (sizeVal.unit === 2) baseSize = mainAxisSize * (sizeVal.value / 100);
+				else if (child.hasMeasureFunc() && childStyle.flexGrow === 0) {
+					const availCross = crossAxisSize - (isRow ? resolveEdgeValue(childStyle.margin, 1, style.flexDirection, contentWidth, direction) + resolveEdgeValue(childStyle.margin, 3, style.flexDirection, contentWidth, direction) : resolveEdgeValue(childStyle.margin, 0, style.flexDirection, contentWidth, direction) + resolveEdgeValue(childStyle.margin, 2, style.flexDirection, contentWidth, direction));
+					const measured = child.measureFunc(mainAxisSize, 2, availCross, 0);
+					baseSize = isRow ? measured.width : measured.height;
+				} else if (child.children.length > 0) {
+					layoutNode(child, isRow ? NaN : crossAxisSize, isRow ? crossAxisSize : NaN, 0, 0, 0, 0, direction);
+					baseSize = isRow ? child.layout.width : child.layout.height;
+				} else {
+					const parentWidth = isRow ? mainAxisSize : crossAxisSize;
+					baseSize = (isRow ? resolveEdgeValue(childStyle.padding, 0, childStyle.flexDirection, parentWidth, direction) + resolveEdgeValue(childStyle.padding, 2, childStyle.flexDirection, parentWidth, direction) : resolveEdgeValue(childStyle.padding, 1, childStyle.flexDirection, parentWidth, direction) + resolveEdgeValue(childStyle.padding, 3, childStyle.flexDirection, parentWidth, direction)) + (isRow ? resolveEdgeBorderValue(childStyle.border, 0, childStyle.flexDirection, direction) + resolveEdgeBorderValue(childStyle.border, 2, childStyle.flexDirection, direction) : resolveEdgeBorderValue(childStyle.border, 1, childStyle.flexDirection, direction) + resolveEdgeBorderValue(childStyle.border, 3, childStyle.flexDirection, direction));
+				}
+			}
+			const minVal = isRow ? childStyle.minWidth : childStyle.minHeight;
+			const maxVal = isRow ? childStyle.maxWidth : childStyle.maxHeight;
+			const minMain = minVal.unit !== 0 ? resolveValue(minVal, mainAxisSize) : 0;
+			const maxMain = maxVal.unit !== 0 ? resolveValue(maxVal, mainAxisSize) : Infinity;
+			children.push({
+				node: child,
+				mainSize: baseSize,
+				baseSize,
+				mainMargin,
+				flexGrow: childStyle.flexGrow,
+				flexShrink: childStyle.flexShrink,
+				minMain,
+				maxMain,
+				mainStartMarginAuto,
+				mainEndMarginAuto,
+				mainStartMarginValue,
+				mainEndMarginValue,
+				frozen: false
+			});
+			totalBaseMain += baseSize + mainMargin;
+		}
+		const lines = breakIntoLines(children, mainAxisSize, mainGap, style.flexWrap);
+		const crossGap = isRow ? style.gap[1] : style.gap[0];
+		for (const line of lines) {
+			const lineChildren = line.children;
+			if (lineChildren.length === 0) continue;
+			const lineTotalBaseMain = lineChildren.reduce((sum, c) => sum + c.baseSize + c.mainMargin, 0);
+			const lineTotalGaps = lineChildren.length > 1 ? mainGap * (lineChildren.length - 1) : 0;
+			let effectiveMainSize = mainAxisSize;
+			if (Number.isNaN(mainAxisSize)) {
+				const maxMainVal = isRow ? style.maxWidth : style.maxHeight;
+				if (maxMainVal.unit !== 0) {
+					const maxMain = resolveValue(maxMainVal, isRow ? availableWidth : availableHeight);
+					if (!Number.isNaN(maxMain) && lineTotalBaseMain + lineTotalGaps > maxMain) effectiveMainSize = maxMain - (isRow ? innerLeft + innerRight : innerTop + innerBottom);
+				}
+			}
+			if (!Number.isNaN(effectiveMainSize)) distributeFlexSpace(lineChildren, effectiveMainSize - lineTotalBaseMain - lineTotalGaps);
+			for (const childLayout of lineChildren) childLayout.mainSize = Math.max(childLayout.minMain, Math.min(childLayout.maxMain, childLayout.mainSize));
+		}
+		const totalGaps = children.length > 1 ? mainGap * (children.length - 1) : 0;
+		const usedMain = children.reduce((sum, c) => sum + c.mainSize + c.mainMargin, 0) + totalGaps;
+		const remainingSpace = Number.isNaN(mainAxisSize) ? 0 : mainAxisSize - usedMain;
+		const totalAutoMargins = children.reduce((sum, c) => sum + (c.mainStartMarginAuto ? 1 : 0) + (c.mainEndMarginAuto ? 1 : 0), 0);
+		let hasAutoMargins = totalAutoMargins > 0;
+		if (hasAutoMargins) {
+			const autoMarginValue = remainingSpace / totalAutoMargins;
+			for (const childLayout of children) {
+				if (childLayout.mainStartMarginAuto) childLayout.mainStartMarginValue = autoMarginValue;
+				if (childLayout.mainEndMarginAuto) childLayout.mainEndMarginValue = autoMarginValue;
+			}
+		}
+		let startOffset = 0;
+		let itemSpacing = mainGap;
+		if (!hasAutoMargins) switch (style.justifyContent) {
+			case 2:
+				startOffset = remainingSpace;
+				break;
+			case 1:
+				startOffset = remainingSpace / 2;
+				break;
+			case 3:
+				if (children.length > 1 && remainingSpace > 0) itemSpacing = mainGap + remainingSpace / (children.length - 1);
+				break;
+			case 4:
+				if (children.length > 0) {
+					const extraSpace = remainingSpace / children.length;
+					startOffset = extraSpace / 2;
+					itemSpacing = mainGap + extraSpace;
+				}
+				break;
+			case 5:
+				if (children.length > 0) {
+					const extraSpace = remainingSpace / (children.length + 1);
+					startOffset = extraSpace;
+					itemSpacing = mainGap + extraSpace;
+				}
+				break;
+		}
+		let maxBaseline = 0;
+		const childBaselines = [];
+		if ((style.alignItems === 5 || relativeChildren.some((c) => c.style.alignSelf === 5)) && isRow) for (let i = 0; i < children.length; i++) {
+			const childLayout = children[i];
+			const child = childLayout.node;
+			const childStyle = child.style;
+			const topMargin = resolveEdgeValue(childStyle.margin, 1, style.flexDirection, contentWidth, direction);
+			let childWidth;
+			let childHeight;
+			const widthDim = childStyle.width;
+			const heightDim = childStyle.height;
+			if (widthDim.unit === 1) childWidth = widthDim.value;
+			else if (widthDim.unit === 2 && !Number.isNaN(mainAxisSize)) childWidth = mainAxisSize * (widthDim.value / 100);
+			else childWidth = childLayout.mainSize;
+			if (heightDim.unit === 1) childHeight = heightDim.value;
+			else if (heightDim.unit === 2 && !Number.isNaN(crossAxisSize)) childHeight = crossAxisSize * (heightDim.value / 100);
+			else {
+				layoutNode(child, childLayout.mainSize, NaN, 0, 0, 0, 0, direction);
+				childWidth = child.layout.width;
+				childHeight = child.layout.height;
+			}
+			let baseline;
+			if (child.baselineFunc !== null) baseline = topMargin + child.baselineFunc(childWidth, childHeight);
+			else baseline = topMargin + childHeight;
+			childBaselines.push(baseline);
+			maxBaseline = Math.max(maxBaseline, baseline);
+		}
+		const childLineIndex = /* @__PURE__ */ new Map();
+		const lineCrossOffsets = [];
+		let cumulativeCrossOffset = 0;
+		for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+			const line = lines[lineIdx];
+			lineCrossOffsets.push(cumulativeCrossOffset);
+			let maxLineCross = 0;
+			for (const childLayout of line.children) {
+				childLineIndex.set(childLayout, lineIdx);
+				const childStyle = childLayout.node.style;
+				const crossDim = isRow ? childStyle.height : childStyle.width;
+				const crossMarginStart = isRow ? resolveEdgeValue(childStyle.margin, 1, style.flexDirection, contentWidth, direction) : resolveEdgeValue(childStyle.margin, 0, style.flexDirection, contentWidth, direction);
+				const crossMarginEnd = isRow ? resolveEdgeValue(childStyle.margin, 3, style.flexDirection, contentWidth, direction) : resolveEdgeValue(childStyle.margin, 2, style.flexDirection, contentWidth, direction);
+				let childCross = 0;
+				if (crossDim.unit === 1) childCross = crossDim.value;
+				else if (crossDim.unit === 2 && !Number.isNaN(crossAxisSize)) childCross = crossAxisSize * (crossDim.value / 100);
+				else if (childLayout.node.children.length > 0) childCross = isRow ? childLayout.node.layout.height : childLayout.node.layout.width;
+				else childCross = 0;
+				maxLineCross = Math.max(maxLineCross, childCross + crossMarginStart + crossMarginEnd);
+			}
+			line.crossSize = maxLineCross > 0 ? maxLineCross : crossAxisSize / lines.length;
+			cumulativeCrossOffset += line.crossSize + crossGap;
+		}
+		const isWrapReverse = style.flexWrap === 2;
+		const numLines = lines.length;
+		if (!Number.isNaN(crossAxisSize) && numLines > 0) {
+			const freeSpace = crossAxisSize - (cumulativeCrossOffset - crossGap);
+			const alignContent = style.alignContent;
+			if (freeSpace > 0 || alignContent === 4) switch (alignContent) {
+				case 3:
+					for (let i = 0; i < numLines; i++) lineCrossOffsets[i] += freeSpace;
+					break;
+				case 2:
+					const centerOffset = freeSpace / 2;
+					for (let i = 0; i < numLines; i++) lineCrossOffsets[i] += centerOffset;
+					break;
+				case 6:
+					if (numLines > 1) {
+						const gap = freeSpace / (numLines - 1);
+						for (let i = 1; i < numLines; i++) lineCrossOffsets[i] += gap * i;
+					}
+					break;
+				case 7:
+					const halfGap = freeSpace / (numLines * 2);
+					for (let i = 0; i < numLines; i++) lineCrossOffsets[i] += halfGap + halfGap * 2 * i;
+					break;
+				case 8:
+					if (numLines > 0) {
+						const spaceEvenlyGap = freeSpace / (numLines + 1);
+						for (let i = 0; i < numLines; i++) lineCrossOffsets[i] += spaceEvenlyGap * (i + 1);
+					}
+					break;
+				case 4:
+					if (freeSpace > 0 && numLines > 0) {
+						const extraPerLine = freeSpace / numLines;
+						for (let i = 0; i < numLines; i++) {
+							lines[i].crossSize += extraPerLine;
+							if (i > 0) lineCrossOffsets[i] = lineCrossOffsets[i - 1] + lines[i - 1].crossSize + crossGap;
+						}
+					}
+					break;
+			}
+			if (isWrapReverse) {
+				let totalLineCrossSize = 0;
+				for (let i = 0; i < numLines; i++) totalLineCrossSize += lines[i].crossSize;
+				totalLineCrossSize += crossGap * (numLines - 1);
+				const crossStartOffset = crossAxisSize - totalLineCrossSize;
+				for (let i = 0; i < numLines; i++) lineCrossOffsets[i] += crossStartOffset;
+			}
+		}
+		const effectiveReverse = isRow ? direction === 2 !== isReverse : isReverse;
+		let mainPos = effectiveReverse ? mainAxisSize - startOffset : startOffset;
+		let currentLineIdx = -1;
+		log.debug?.("positioning children: isRow=%s, startOffset=%d, relativeChildren=%d, isReverse=%s, lines=%d", isRow, startOffset, relativeChildren.length, isReverse, lines.length);
+		for (let i = 0; i < children.length; i++) {
+			const childLayout = children[i];
+			const child = childLayout.node;
+			const childStyle = child.style;
+			const childLineIdx = childLineIndex.get(childLayout) ?? 0;
+			if (childLineIdx !== currentLineIdx) {
+				currentLineIdx = childLineIdx;
+				mainPos = effectiveReverse ? mainAxisSize - startOffset : startOffset;
+			}
+			const lineCrossOffset = lineCrossOffsets[childLineIdx] ?? 0;
+			let childMarginLeft;
+			let childMarginTop;
+			let childMarginRight;
+			let childMarginBottom;
+			if (isRow) {
+				childMarginLeft = childLayout.mainStartMarginAuto && !isReverse ? childLayout.mainStartMarginValue : childLayout.mainEndMarginAuto && isReverse ? childLayout.mainEndMarginValue : resolveEdgeValue(childStyle.margin, 0, style.flexDirection, contentWidth, direction);
+				childMarginRight = childLayout.mainEndMarginAuto && !isReverse ? childLayout.mainEndMarginValue : childLayout.mainStartMarginAuto && isReverse ? childLayout.mainStartMarginValue : resolveEdgeValue(childStyle.margin, 2, style.flexDirection, contentWidth, direction);
+				childMarginTop = resolveEdgeValue(childStyle.margin, 1, style.flexDirection, contentWidth, direction);
+				childMarginBottom = resolveEdgeValue(childStyle.margin, 3, style.flexDirection, contentWidth, direction);
+			} else {
+				childMarginTop = childLayout.mainStartMarginAuto && !isReverse ? childLayout.mainStartMarginValue : childLayout.mainEndMarginAuto && isReverse ? childLayout.mainEndMarginValue : resolveEdgeValue(childStyle.margin, 1, style.flexDirection, contentWidth, direction);
+				childMarginBottom = childLayout.mainEndMarginAuto && !isReverse ? childLayout.mainEndMarginValue : childLayout.mainStartMarginAuto && isReverse ? childLayout.mainStartMarginValue : resolveEdgeValue(childStyle.margin, 3, style.flexDirection, contentWidth, direction);
+				childMarginLeft = resolveEdgeValue(childStyle.margin, 0, style.flexDirection, contentWidth, direction);
+				childMarginRight = resolveEdgeValue(childStyle.margin, 2, style.flexDirection, contentWidth, direction);
+			}
+			const childMainSize = childLayout.mainSize;
+			let alignment = style.alignItems;
+			if (childStyle.alignSelf !== 0) alignment = childStyle.alignSelf;
+			let childCrossSize;
+			const crossDim = isRow ? childStyle.height : childStyle.width;
+			const crossMargin = isRow ? childMarginTop + childMarginBottom : childMarginLeft + childMarginRight;
+			const parentCrossDim = isRow ? style.height : style.width;
+			const parentHasDefiniteCross = parentCrossDim.unit === 1 || parentCrossDim.unit === 2 || !Number.isNaN(crossAxisSize);
+			if (crossDim.unit === 1) childCrossSize = crossDim.value;
+			else if (crossDim.unit === 2) childCrossSize = resolveValue(crossDim, crossAxisSize);
+			else if (parentHasDefiniteCross && alignment === 4) childCrossSize = crossAxisSize - crossMargin;
+			else childCrossSize = NaN;
+			const crossMinVal = isRow ? childStyle.minHeight : childStyle.minWidth;
+			const crossMaxVal = isRow ? childStyle.maxHeight : childStyle.maxWidth;
+			const crossMin = crossMinVal.unit !== 0 ? resolveValue(crossMinVal, crossAxisSize) : 0;
+			const crossMax = crossMaxVal.unit !== 0 ? resolveValue(crossMaxVal, crossAxisSize) : Infinity;
+			if (Number.isNaN(childCrossSize)) {
+				if (crossMin > 0) childCrossSize = crossMin;
+			} else childCrossSize = Math.max(crossMin, Math.min(crossMax, childCrossSize));
+			const mainDim = isRow ? childStyle.width : childStyle.height;
+			const mainIsAuto = mainDim.unit === 3 || mainDim.unit === 0;
+			const hasFlexGrow = childLayout.flexGrow > 0;
+			const parentMainDim = isRow ? style.width : style.height;
+			parentMainDim.unit === 1 || parentMainDim.unit;
+			let effectiveMainSize;
+			if (hasFlexGrow) effectiveMainSize = childMainSize;
+			else if (mainIsAuto) effectiveMainSize = childMainSize;
+			else effectiveMainSize = childMainSize;
+			let childWidth = isRow ? effectiveMainSize : childCrossSize;
+			let childHeight = isRow ? childCrossSize : effectiveMainSize;
+			if (child.hasMeasureFunc() && child.children.length === 0 && !hasFlexGrow) {
+				const widthAuto = childStyle.width.unit === 3 || childStyle.width.unit === 0;
+				const heightAuto = childStyle.height.unit === 3 || childStyle.height.unit === 0;
+				if (widthAuto || heightAuto) {
+					const widthMode = widthAuto ? 2 : 1;
+					const heightMode = heightAuto ? 0 : 1;
+					const rawAvailW = widthAuto ? isRow ? mainAxisSize - mainPos : crossAxisSize - crossMargin : childStyle.width.value;
+					const rawAvailH = heightAuto ? isRow ? crossAxisSize - crossMargin : mainAxisSize - mainPos : childStyle.height.value;
+					const availW = Number.isNaN(rawAvailW) ? Infinity : rawAvailW;
+					const availH = Number.isNaN(rawAvailH) ? Infinity : rawAvailH;
+					const measured = child.measureFunc(availW, widthMode, availH, heightMode);
+					if (widthAuto) childWidth = measured.width;
+					if (heightAuto) childHeight = measured.height;
+				}
+			}
+			let childX;
+			let childY;
+			if (effectiveReverse) if (isRow) {
+				childX = mainPos - childMainSize - childMarginRight;
+				childY = lineCrossOffset + childMarginTop;
+			} else {
+				childX = lineCrossOffset + childMarginLeft;
+				childY = mainPos - childMainSize - childMarginTop;
+			}
+			else {
+				childX = isRow ? mainPos + childMarginLeft : lineCrossOffset + childMarginLeft;
+				childY = isRow ? lineCrossOffset + childMarginTop : mainPos + childMarginTop;
+			}
+			const fractionalLeft = innerLeft + childX;
+			const fractionalTop = innerTop + childY;
+			let posOffsetX = 0;
+			let posOffsetY = 0;
+			if (childStyle.positionType === 1) {
+				const relLeftPos = childStyle.position[0];
+				const relTopPos = childStyle.position[1];
+				const relRightPos = childStyle.position[2];
+				const relBottomPos = childStyle.position[3];
+				if (relLeftPos.unit !== 0) posOffsetX = resolveValue(relLeftPos, contentWidth);
+				else if (relRightPos.unit !== 0) posOffsetX = -resolveValue(relRightPos, contentWidth);
+				if (relTopPos.unit !== 0) posOffsetY = resolveValue(relTopPos, contentHeight);
+				else if (relBottomPos.unit !== 0) posOffsetY = -resolveValue(relBottomPos, contentHeight);
+			}
+			const absChildLeft = absX + marginLeft + parentPosOffsetX + fractionalLeft + posOffsetX;
+			const absChildTop = absY + marginTop + parentPosOffsetY + fractionalTop + posOffsetY;
+			let roundedAbsMainStart;
+			let roundedAbsMainEnd;
+			let edgeBasedMainSize;
+			const useEdgeBasedRounding = childMainSize > 0;
+			const childPaddingL = resolveEdgeValue(childStyle.padding, 0, childStyle.flexDirection, contentWidth, direction);
+			const childPaddingT = resolveEdgeValue(childStyle.padding, 1, childStyle.flexDirection, contentWidth, direction);
+			const childPaddingR = resolveEdgeValue(childStyle.padding, 2, childStyle.flexDirection, contentWidth, direction);
+			const childPaddingB = resolveEdgeValue(childStyle.padding, 3, childStyle.flexDirection, contentWidth, direction);
+			const childBorderL = resolveEdgeBorderValue(childStyle.border, 0, childStyle.flexDirection, direction);
+			const childBorderT = resolveEdgeBorderValue(childStyle.border, 1, childStyle.flexDirection, direction);
+			const childBorderR = resolveEdgeBorderValue(childStyle.border, 2, childStyle.flexDirection, direction);
+			const childBorderB = resolveEdgeBorderValue(childStyle.border, 3, childStyle.flexDirection, direction);
+			const childMinW = childPaddingL + childPaddingR + childBorderL + childBorderR;
+			const childMinH = childPaddingT + childPaddingB + childBorderT + childBorderB;
+			const childMinMain = isRow ? childMinW : childMinH;
+			const constrainedMainSize = Math.max(childMainSize, childMinMain);
+			if (useEdgeBasedRounding) if (isRow) {
+				roundedAbsMainStart = Math.round(absChildLeft);
+				roundedAbsMainEnd = Math.round(absChildLeft + constrainedMainSize);
+				edgeBasedMainSize = roundedAbsMainEnd - roundedAbsMainStart;
+			} else {
+				roundedAbsMainStart = Math.round(absChildTop);
+				roundedAbsMainEnd = Math.round(absChildTop + constrainedMainSize);
+				edgeBasedMainSize = roundedAbsMainEnd - roundedAbsMainStart;
+			}
+			else {
+				roundedAbsMainStart = isRow ? Math.round(absChildLeft) : Math.round(absChildTop);
+				edgeBasedMainSize = childMinMain;
+			}
+			const childLeft = Math.round(fractionalLeft + posOffsetX);
+			const childTop = Math.round(fractionalTop + posOffsetY);
+			const crossDimForLayoutCall = isRow ? childStyle.height : childStyle.width;
+			const crossIsAutoForLayoutCall = crossDimForLayoutCall.unit === 3 || crossDimForLayoutCall.unit === 0;
+			const mainIsPercent = (isRow ? childStyle.width : childStyle.height).unit === 2;
+			const crossIsPercent = crossDimForLayoutCall.unit === 2;
+			let passWidthToChild;
+			if (isRow && mainIsAuto && !hasFlexGrow) passWidthToChild = NaN;
+			else if (!isRow && crossIsAutoForLayoutCall && !parentHasDefiniteCross) passWidthToChild = NaN;
+			else if (isRow && mainIsPercent) passWidthToChild = contentWidth;
+			else if (!isRow && crossIsPercent) passWidthToChild = contentWidth;
+			else passWidthToChild = childWidth;
+			let passHeightToChild;
+			if (!isRow && mainIsAuto && !hasFlexGrow) passHeightToChild = NaN;
+			else if (isRow && crossIsAutoForLayoutCall && !parentHasDefiniteCross) passHeightToChild = NaN;
+			else if (!isRow && mainIsPercent) passHeightToChild = contentHeight;
+			else if (isRow && crossIsPercent) passHeightToChild = contentHeight;
+			else passHeightToChild = childHeight;
+			const childAbsX = absChildLeft - childMarginLeft;
+			const childAbsY = absChildTop - childMarginTop;
+			layoutNode(child, passWidthToChild, passHeightToChild, childLeft, childTop, childAbsX, childAbsY, direction);
+			if (childWidth < childMinW) childWidth = childMinW;
+			if (childHeight < childMinH) childHeight = childMinH;
+			const hasMeasure = child.hasMeasureFunc() && child.children.length === 0;
+			if (!mainIsAuto || hasFlexGrow || hasMeasure || !Number.isNaN(effectiveMainSize)) if (isRow) child.layout.width = edgeBasedMainSize;
+			else child.layout.height = edgeBasedMainSize;
+			const crossDimForCheck = isRow ? childStyle.height : childStyle.width;
+			const crossIsAuto = crossDimForCheck.unit === 3 || crossDimForCheck.unit === 0;
+			const parentCrossIsAuto = !parentHasDefiniteCross;
+			const hasCrossMinMax = crossMinVal.unit !== 0 || crossMaxVal.unit !== 0;
+			if (!crossIsAuto || !parentCrossIsAuto && alignment === 4 || hasCrossMinMax && !Number.isNaN(childCrossSize)) if (isRow) child.layout.height = Math.round(childHeight);
+			else child.layout.width = Math.round(childWidth);
+			child.layout.left = childLeft;
+			child.layout.top = childTop;
+			childWidth = child.layout.width;
+			childHeight = child.layout.height;
+			const finalCrossSize = isRow ? child.layout.height : child.layout.width;
+			let crossOffset = 0;
+			const crossStartMargin = isRow ? childStyle.margin[1] : childStyle.margin[0];
+			const crossEndMargin = isRow ? childStyle.margin[3] : childStyle.margin[2];
+			const hasAutoStartMargin = crossStartMargin.unit === 3;
+			const hasAutoEndMargin = crossEndMargin.unit === 3;
+			const availableCrossSpace = crossAxisSize - finalCrossSize - crossMargin;
+			if (hasAutoStartMargin && hasAutoEndMargin) crossOffset = availableCrossSpace / 2;
+			else if (hasAutoStartMargin) crossOffset = availableCrossSpace;
+			else if (hasAutoEndMargin) crossOffset = 0;
+			else switch (alignment) {
+				case 3:
+					crossOffset = availableCrossSpace;
+					break;
+				case 2:
+					crossOffset = availableCrossSpace / 2;
+					break;
+				case 5:
+					if (isRow && childBaselines.length > 0) crossOffset = maxBaseline - childBaselines[i];
+					break;
+			}
+			if (crossOffset !== 0) if (isRow) child.layout.top += Math.round(crossOffset);
+			else child.layout.left += Math.round(crossOffset);
+			const fractionalMainSize = constrainedMainSize;
+			const totalMainMargin = childLayout.mainStartMarginValue + childLayout.mainEndMarginValue;
+			log.debug?.("  child %d: mainPos=%d → top=%d (fractionalMainSize=%d, totalMainMargin=%d)", i, mainPos, child.layout.top, fractionalMainSize, totalMainMargin);
+			if (effectiveReverse) {
+				mainPos -= fractionalMainSize + totalMainMargin;
+				if (i < children.length - 1) mainPos -= itemSpacing;
+			} else {
+				mainPos += fractionalMainSize + totalMainMargin;
+				if (i < children.length - 1) mainPos += itemSpacing;
+			}
+		}
+		let actualUsedMain = 0;
+		for (const childLayout of children) {
+			const childMainSize = isRow ? childLayout.node.layout.width : childLayout.node.layout.height;
+			const totalMainMargin = childLayout.mainStartMarginValue + childLayout.mainEndMarginValue;
+			actualUsedMain += childMainSize + totalMainMargin;
+		}
+		actualUsedMain += totalGaps;
+		if (isRow && style.width.unit !== 1 && style.width.unit !== 2) nodeWidth = actualUsedMain + innerLeft + innerRight;
+		if (!isRow && style.height.unit !== 1 && style.height.unit !== 2) nodeHeight = actualUsedMain + innerTop + innerBottom;
+		let maxCrossSize = 0;
+		for (const childLayout of children) {
+			const childCross = isRow ? childLayout.node.layout.height : childLayout.node.layout.width;
+			const childMargin = isRow ? resolveEdgeValue(childLayout.node.style.margin, 1, style.flexDirection, contentWidth, direction) + resolveEdgeValue(childLayout.node.style.margin, 3, style.flexDirection, contentWidth, direction) : resolveEdgeValue(childLayout.node.style.margin, 0, style.flexDirection, contentWidth, direction) + resolveEdgeValue(childLayout.node.style.margin, 2, style.flexDirection, contentWidth, direction);
+			maxCrossSize = Math.max(maxCrossSize, childCross + childMargin);
+		}
+		if (isRow && style.height.unit !== 1 && style.height.unit !== 2 && Number.isNaN(availableHeight)) nodeHeight = maxCrossSize + innerTop + innerBottom;
+		if (!isRow && style.width.unit !== 1 && style.width.unit !== 2 && Number.isNaN(availableWidth)) nodeWidth = maxCrossSize + innerLeft + innerRight;
+	}
+	nodeWidth = applyMinMax(nodeWidth, style.minWidth, style.maxWidth, availableWidth);
+	nodeHeight = applyMinMax(nodeHeight, style.minHeight, style.maxHeight, availableHeight);
+	if (!Number.isNaN(nodeWidth) && nodeWidth < minInnerWidth) nodeWidth = minInnerWidth;
+	if (!Number.isNaN(nodeHeight) && nodeHeight < minInnerHeight) nodeHeight = minInnerHeight;
+	const absNodeLeft = absX + marginLeft + parentPosOffsetX;
+	const absNodeTop = absY + marginTop + parentPosOffsetY;
+	const absNodeRight = absNodeLeft + nodeWidth;
+	const absNodeBottom = absNodeTop + nodeHeight;
+	const roundedAbsLeft = Math.round(absNodeLeft);
+	const roundedAbsTop = Math.round(absNodeTop);
+	const roundedAbsRight = Math.round(absNodeRight);
+	const roundedAbsBottom = Math.round(absNodeBottom);
+	layout.width = roundedAbsRight - roundedAbsLeft;
+	layout.height = roundedAbsBottom - roundedAbsTop;
+	const roundedAbsParentLeft = Math.round(absX);
+	const roundedAbsParentTop = Math.round(absY);
+	layout.left = roundedAbsLeft - roundedAbsParentLeft;
+	layout.top = roundedAbsTop - roundedAbsParentTop;
+	const absInnerLeft = borderLeft;
+	const absInnerTop = borderTop;
+	const absInnerRight = borderRight;
+	const absInnerBottom = borderBottom;
+	const absPaddingBoxW = nodeWidth - absInnerLeft - absInnerRight;
+	const absPaddingBoxH = nodeHeight - absInnerTop - absInnerBottom;
+	const absContentBoxW = absPaddingBoxW - paddingLeft - paddingRight;
+	const absContentBoxH = absPaddingBoxH - paddingTop - paddingBottom;
+	const isRow = isRowDirection(style.flexDirection);
+	for (const child of absoluteChildren) {
+		const childStyle = child.style;
+		const childMarginLeft = resolveEdgeValue(childStyle.margin, 0, style.flexDirection, nodeWidth, direction);
+		const childMarginTop = resolveEdgeValue(childStyle.margin, 1, style.flexDirection, nodeWidth, direction);
+		const childMarginRight = resolveEdgeValue(childStyle.margin, 2, style.flexDirection, nodeWidth, direction);
+		const childMarginBottom = resolveEdgeValue(childStyle.margin, 3, style.flexDirection, nodeWidth, direction);
+		const leftPos = childStyle.position[0];
+		const topPos = childStyle.position[1];
+		const rightPos = childStyle.position[2];
+		const bottomPos = childStyle.position[3];
+		const hasLeft = leftPos.unit !== 0;
+		const hasRight = rightPos.unit !== 0;
+		const hasTop = topPos.unit !== 0;
+		const hasBottom = bottomPos.unit !== 0;
+		const leftOffset = resolveValue(leftPos, absContentBoxW);
+		const topOffset = resolveValue(topPos, absContentBoxH);
+		const rightOffset = resolveValue(rightPos, absContentBoxW);
+		const bottomOffset = resolveValue(bottomPos, absContentBoxH);
+		const contentW = absPaddingBoxW;
+		const contentH = absPaddingBoxH;
+		let childAvailWidth;
+		const widthIsAuto = childStyle.width.unit === 3 || childStyle.width.unit === 0;
+		const widthIsPercent = childStyle.width.unit === 2;
+		if (widthIsAuto && hasLeft && hasRight) childAvailWidth = contentW - leftOffset - rightOffset - childMarginLeft - childMarginRight;
+		else if (widthIsAuto) childAvailWidth = NaN;
+		else if (widthIsPercent) childAvailWidth = absContentBoxW;
+		else childAvailWidth = contentW;
+		let childAvailHeight;
+		const heightIsAuto = childStyle.height.unit === 3 || childStyle.height.unit === 0;
+		const heightIsPercent = childStyle.height.unit === 2;
+		if (heightIsAuto && hasTop && hasBottom) childAvailHeight = contentH - topOffset - bottomOffset - childMarginTop - childMarginBottom;
+		else if (heightIsAuto) childAvailHeight = NaN;
+		else if (heightIsPercent) childAvailHeight = absContentBoxH;
+		else childAvailHeight = contentH;
+		let childX = childMarginLeft + leftOffset;
+		let childY = childMarginTop + topOffset;
+		const childAbsX = absX + marginLeft + absInnerLeft + leftOffset;
+		const childAbsY = absY + marginTop + absInnerTop + topOffset;
+		const clampIfNumber = (v) => Number.isNaN(v) ? NaN : Math.max(0, v);
+		layoutNode(child, clampIfNumber(childAvailWidth), clampIfNumber(childAvailHeight), layout.left + absInnerLeft + childX, layout.top + absInnerTop + childY, childAbsX, childAbsY, direction);
+		const childWidth = child.layout.width;
+		const childHeight = child.layout.height;
+		if (!hasLeft && !hasRight) if (isRow) {
+			const freeSpaceX = contentW - childWidth - childMarginLeft - childMarginRight;
+			switch (style.justifyContent) {
+				case 1:
+					childX = childMarginLeft + freeSpaceX / 2;
+					break;
+				case 2:
+					childX = childMarginLeft + freeSpaceX;
+					break;
+				default:
+					childX = childMarginLeft;
+					break;
+			}
+		} else {
+			let alignment = style.alignItems;
+			if (childStyle.alignSelf !== 0) alignment = childStyle.alignSelf;
+			const freeSpaceX = contentW - childWidth - childMarginLeft - childMarginRight;
+			switch (alignment) {
+				case 2:
+					childX = childMarginLeft + freeSpaceX / 2;
+					break;
+				case 3:
+					childX = childMarginLeft + freeSpaceX;
+					break;
+				case 4: break;
+				default:
+					childX = childMarginLeft;
+					break;
+			}
+		}
+		else if (!hasLeft && hasRight) childX = contentW - rightOffset - childMarginRight - childWidth;
+		else if (hasLeft && hasRight && widthIsAuto) child.layout.width = Math.round(childAvailWidth);
+		if (!hasTop && !hasBottom) if (isRow) {
+			let alignment = style.alignItems;
+			if (childStyle.alignSelf !== 0) alignment = childStyle.alignSelf;
+			const freeSpaceY = contentH - childHeight - childMarginTop - childMarginBottom;
+			switch (alignment) {
+				case 2:
+					childY = childMarginTop + freeSpaceY / 2;
+					break;
+				case 3:
+					childY = childMarginTop + freeSpaceY;
+					break;
+				case 4: break;
+				default:
+					childY = childMarginTop;
+					break;
+			}
+		} else {
+			const freeSpaceY = contentH - childHeight - childMarginTop - childMarginBottom;
+			switch (style.justifyContent) {
+				case 1:
+					childY = childMarginTop + freeSpaceY / 2;
+					break;
+				case 2:
+					childY = childMarginTop + freeSpaceY;
+					break;
+				default:
+					childY = childMarginTop;
+					break;
+			}
+		}
+		else if (!hasTop && hasBottom) childY = contentH - bottomOffset - childMarginBottom - childHeight;
+		else if (hasTop && hasBottom && heightIsAuto) child.layout.height = Math.round(childAvailHeight);
+		child.layout.left = Math.round(absInnerLeft + childX);
+		child.layout.top = Math.round(absInnerTop + childY);
+	}
+}
+let layoutNodeCalls = 0;
+let layoutSizingCalls = 0;
+let layoutPositioningCalls = 0;
+let layoutCacheHits = 0;
+function resetLayoutStats() {
+	layoutNodeCalls = 0;
+	layoutSizingCalls = 0;
+	layoutPositioningCalls = 0;
+	layoutCacheHits = 0;
+}
+//#endregion
+//#region src/classic/node.ts
+/**
+* Flexily Node
+*
+* Yoga-compatible Node class for flexbox layout.
+*/
+/**
+* A layout node in the flexbox tree.
+*/
+var Node = class Node {
+	_parent = null;
+	_children = [];
+	_style = createDefaultStyle();
+	_measureFunc = null;
+	_baselineFunc = null;
+	_layout = {
+		left: 0,
+		top: 0,
+		width: 0,
+		height: 0
+	};
+	_isDirty = true;
+	_hasNewLayout = false;
+	/**
+	* Create a new layout node.
+	*
+	* @returns A new Node instance
+	* @example
+	* ```typescript
+	* const root = Node.create();
+	* root.setWidth(100);
+	* root.setHeight(200);
+	* ```
+	*/
+	static create() {
+		return new Node();
+	}
+	/**
+	* Get the number of child nodes.
+	*
+	* @returns The number of children
+	*/
+	getChildCount() {
+		return this._children.length;
+	}
+	/**
+	* Get a child node by index.
+	*
+	* @param index - Zero-based child index
+	* @returns The child node at the given index, or undefined if index is out of bounds
+	*/
+	getChild(index) {
+		return this._children[index];
+	}
+	/**
+	* Get the parent node.
+	*
+	* @returns The parent node, or null if this is a root node
+	*/
+	getParent() {
+		return this._parent;
+	}
+	/**
+	* Insert a child node at the specified index.
+	* If the child already has a parent, it will be removed from that parent first.
+	* Marks the node as dirty to trigger layout recalculation.
+	*
+	* @param child - The child node to insert
+	* @param index - The index at which to insert the child
+	* @example
+	* ```typescript
+	* const parent = Node.create();
+	* const child1 = Node.create();
+	* const child2 = Node.create();
+	* parent.insertChild(child1, 0);
+	* parent.insertChild(child2, 1);
+	* ```
+	*/
+	insertChild(child, index) {
+		if (child === this) throw new Error("Cannot insert a node as a child of itself");
+		let ancestor = this._parent;
+		while (ancestor !== null) {
+			if (ancestor === child) throw new Error("Cannot insert an ancestor as a child (would create a cycle)");
+			ancestor = ancestor._parent;
+		}
+		if (child._parent !== null) child._parent.removeChild(child);
+		child._parent = this;
+		this._children.splice(index, 0, child);
+		this.markDirty();
+	}
+	/**
+	* Remove a child node from this node.
+	* The child's parent reference will be cleared.
+	* Marks the node as dirty to trigger layout recalculation.
+	*
+	* @param child - The child node to remove
+	*/
+	removeChild(child) {
+		const index = this._children.indexOf(child);
+		if (index !== -1) {
+			this._children.splice(index, 1);
+			child._parent = null;
+			this.markDirty();
+		}
+	}
+	/**
+	* Free this node and clean up all references.
+	* Removes the node from its parent, clears all children, and removes the measure function.
+	* This does not recursively free child nodes.
+	*/
+	free() {
+		if (this._parent !== null) this._parent.removeChild(this);
+		for (const child of this._children) child._parent = null;
+		this._children = [];
+		this._measureFunc = null;
+		this._baselineFunc = null;
+	}
+	/**
+	* Free this node and all descendants recursively.
+	* Each node is detached from its parent and cleaned up.
+	*/
+	freeRecursive() {
+		const children = [...this._children];
+		for (const child of children) child.freeRecursive();
+		this.free();
+	}
+	/**
+	* Dispose the node (calls free)
+	*/
+	[Symbol.dispose]() {
+		this.free();
+	}
+	/**
+	* Set a measure function for intrinsic sizing.
+	* The measure function is called during layout to determine the node's natural size.
+	* Typically used for text nodes or other content that has an intrinsic size.
+	* Marks the node as dirty to trigger layout recalculation.
+	*
+	* @param measureFunc - Function that returns width and height given available space and constraints
+	* @example
+	* ```typescript
+	* const textNode = Node.create();
+	* textNode.setMeasureFunc((width, widthMode, height, heightMode) => {
+	*   // Measure text and return dimensions
+	*   return { width: 50, height: 20 };
+	* });
+	* ```
+	*/
+	setMeasureFunc(measureFunc) {
+		this._measureFunc = measureFunc;
+		this.markDirty();
+	}
+	/**
+	* Remove the measure function from this node.
+	* Marks the node as dirty to trigger layout recalculation.
+	*/
+	unsetMeasureFunc() {
+		this._measureFunc = null;
+		this.markDirty();
+	}
+	/**
+	* Check if this node has a measure function.
+	*
+	* @returns True if a measure function is set
+	*/
+	hasMeasureFunc() {
+		return this._measureFunc !== null;
+	}
+	/**
+	* Set a baseline function to determine where this node's text baseline is.
+	* Used for ALIGN_BASELINE to align text across siblings with different heights.
+	*
+	* @param baselineFunc - Function that returns baseline offset from top given width and height
+	* @example
+	* ```typescript
+	* textNode.setBaselineFunc((width, height) => {
+	*   // For a text node, baseline might be at 80% of height
+	*   return height * 0.8;
+	* });
+	* ```
+	*/
+	setBaselineFunc(baselineFunc) {
+		this._baselineFunc = baselineFunc;
+		this.markDirty();
+	}
+	/**
+	* Remove the baseline function from this node.
+	* Marks the node as dirty to trigger layout recalculation.
+	*/
+	unsetBaselineFunc() {
+		this._baselineFunc = null;
+		this.markDirty();
+	}
+	/**
+	* Check if this node has a baseline function.
+	*
+	* @returns True if a baseline function is set
+	*/
+	hasBaselineFunc() {
+		return this._baselineFunc !== null;
+	}
+	/**
+	* Check if this node needs layout recalculation.
+	*
+	* @returns True if the node is dirty and needs layout
+	*/
+	isDirty() {
+		return this._isDirty;
+	}
+	/**
+	* Mark this node and all ancestors as dirty.
+	* A dirty node needs layout recalculation.
+	* This is automatically called by all style setters and tree operations.
+	*/
+	markDirty() {
+		this._isDirty = true;
+		if (this._parent !== null) this._parent.markDirty();
+	}
+	/**
+	* Check if this node has new layout results since the last check.
+	*
+	* @returns True if layout was recalculated since the last call to markLayoutSeen
+	*/
+	hasNewLayout() {
+		return this._hasNewLayout;
+	}
+	/**
+	* Mark that the current layout has been seen/processed.
+	* Clears the hasNewLayout flag.
+	*/
+	markLayoutSeen() {
+		this._hasNewLayout = false;
+	}
+	/**
+	* Calculate layout for this node and all descendants.
+	* This runs the flexbox layout algorithm to compute positions and sizes.
+	* Only recalculates if the node is marked as dirty.
+	*
+	* @param width - Available width for layout
+	* @param height - Available height for layout
+	* @param _direction - Text direction (LTR or RTL), defaults to LTR
+	* @example
+	* ```typescript
+	* const root = Node.create();
+	* root.setFlexDirection(FLEX_DIRECTION_ROW);
+	* root.setWidth(100);
+	* root.setHeight(50);
+	*
+	* const child = Node.create();
+	* child.setFlexGrow(1);
+	* root.insertChild(child, 0);
+	*
+	* root.calculateLayout(100, 50, DIRECTION_LTR);
+	*
+	* // Now you can read computed layout
+	* console.log(child.getComputedWidth());
+	* ```
+	*/
+	calculateLayout(width, height, _direction = 1) {
+		if (!this._isDirty) {
+			log.debug?.("layout skip (not dirty)");
+			return;
+		}
+		const start = Date.now();
+		const nodeCount = countNodes(this);
+		computeLayout(this, width ?? NaN, height ?? NaN, _direction);
+		this._isDirty = false;
+		this._hasNewLayout = true;
+		markSubtreeLayoutSeen(this);
+		log.debug?.("layout: %dx%d, %d nodes in %dms", width, height, nodeCount, Date.now() - start);
+	}
+	/**
+	* Get the computed left position after layout.
+	*
+	* @returns The left position in points
+	*/
+	getComputedLeft() {
+		return this._layout.left;
+	}
+	/**
+	* Get the computed top position after layout.
+	*
+	* @returns The top position in points
+	*/
+	getComputedTop() {
+		return this._layout.top;
+	}
+	/**
+	* Get the computed width after layout.
+	*
+	* @returns The width in points
+	*/
+	getComputedWidth() {
+		return this._layout.width;
+	}
+	/**
+	* Get the computed height after layout.
+	*
+	* @returns The height in points
+	*/
+	getComputedHeight() {
+		return this._layout.height;
+	}
+	/**
+	* Get the computed right edge position after layout (left + width).
+	*/
+	getComputedRight() {
+		return this._layout.left + this._layout.width;
+	}
+	/**
+	* Get the computed bottom edge position after layout (top + height).
+	*/
+	getComputedBottom() {
+		return this._layout.top + this._layout.height;
+	}
+	/**
+	* Get the computed padding for a specific edge after layout.
+	*/
+	getComputedPadding(edge) {
+		return getEdgeValue(this._style.padding, edge).value;
+	}
+	/**
+	* Get the computed margin for a specific edge after layout.
+	*/
+	getComputedMargin(edge) {
+		return getEdgeValue(this._style.margin, edge).value;
+	}
+	/**
+	* Get the computed border width for a specific edge after layout.
+	*/
+	getComputedBorder(edge) {
+		return getEdgeBorderValue(this._style.border, edge);
+	}
+	get children() {
+		return this._children;
+	}
+	get style() {
+		return this._style;
+	}
+	get layout() {
+		return this._layout;
+	}
+	get measureFunc() {
+		return this._measureFunc;
+	}
+	get baselineFunc() {
+		return this._baselineFunc;
+	}
+	/**
+	* Set the width to a fixed value in points.
+	*
+	* @param value - Width in points
+	*/
+	setWidth(value) {
+		if (Number.isNaN(value)) this._style.width = {
+			value: 0,
+			unit: 3
+		};
+		else this._style.width = {
+			value,
+			unit: 1
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the width as a percentage of the parent's width.
+	*
+	* @param value - Width as a percentage (0-100)
+	*/
+	setWidthPercent(value) {
+		this._style.width = {
+			value,
+			unit: 2
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the width to auto (determined by layout algorithm).
+	*/
+	setWidthAuto() {
+		this._style.width = {
+			value: 0,
+			unit: 3
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the height to a fixed value in points.
+	*
+	* @param value - Height in points
+	*/
+	setHeight(value) {
+		if (Number.isNaN(value)) this._style.height = {
+			value: 0,
+			unit: 3
+		};
+		else this._style.height = {
+			value,
+			unit: 1
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the height as a percentage of the parent's height.
+	*
+	* @param value - Height as a percentage (0-100)
+	*/
+	setHeightPercent(value) {
+		this._style.height = {
+			value,
+			unit: 2
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the height to auto (determined by layout algorithm).
+	*/
+	setHeightAuto() {
+		this._style.height = {
+			value: 0,
+			unit: 3
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the minimum width in points.
+	*
+	* @param value - Minimum width in points
+	*/
+	setMinWidth(value) {
+		this._style.minWidth = {
+			value,
+			unit: 1
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the minimum width as a percentage of the parent's width.
+	*
+	* @param value - Minimum width as a percentage (0-100)
+	*/
+	setMinWidthPercent(value) {
+		this._style.minWidth = {
+			value,
+			unit: 2
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the minimum height in points.
+	*
+	* @param value - Minimum height in points
+	*/
+	setMinHeight(value) {
+		this._style.minHeight = {
+			value,
+			unit: 1
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the minimum height as a percentage of the parent's height.
+	*
+	* @param value - Minimum height as a percentage (0-100)
+	*/
+	setMinHeightPercent(value) {
+		this._style.minHeight = {
+			value,
+			unit: 2
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the maximum width in points.
+	*
+	* @param value - Maximum width in points
+	*/
+	setMaxWidth(value) {
+		this._style.maxWidth = {
+			value,
+			unit: 1
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the maximum width as a percentage of the parent's width.
+	*
+	* @param value - Maximum width as a percentage (0-100)
+	*/
+	setMaxWidthPercent(value) {
+		this._style.maxWidth = {
+			value,
+			unit: 2
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the maximum height in points.
+	*
+	* @param value - Maximum height in points
+	*/
+	setMaxHeight(value) {
+		this._style.maxHeight = {
+			value,
+			unit: 1
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the maximum height as a percentage of the parent's height.
+	*
+	* @param value - Maximum height as a percentage (0-100)
+	*/
+	setMaxHeightPercent(value) {
+		this._style.maxHeight = {
+			value,
+			unit: 2
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the aspect ratio of the node.
+	* When set, the node's width/height relationship is constrained.
+	* If width is defined, height = width / aspectRatio.
+	* If height is defined, width = height * aspectRatio.
+	*
+	* @param value - Aspect ratio (width/height). Use NaN to unset.
+	*/
+	setAspectRatio(value) {
+		this._style.aspectRatio = value;
+		this.markDirty();
+	}
+	/**
+	* Set the flex grow factor.
+	* Determines how much the node will grow relative to siblings when there is extra space.
+	*
+	* @param value - Flex grow factor (typically 0 or 1+)
+	* @example
+	* ```typescript
+	* const child = Node.create();
+	* child.setFlexGrow(1); // Will grow to fill available space
+	* ```
+	*/
+	setFlexGrow(value) {
+		this._style.flexGrow = value;
+		this.markDirty();
+	}
+	/**
+	* Set the flex shrink factor.
+	* Determines how much the node will shrink relative to siblings when there is insufficient space.
+	*
+	* @param value - Flex shrink factor (default is 1)
+	*/
+	setFlexShrink(value) {
+		this._style.flexShrink = value;
+		this.markDirty();
+	}
+	/**
+	* Set the flex basis to a fixed value in points.
+	* The initial size of the node before flex grow/shrink is applied.
+	*
+	* @param value - Flex basis in points
+	*/
+	setFlexBasis(value) {
+		this._style.flexBasis = {
+			value,
+			unit: 1
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the flex basis as a percentage of the parent's size.
+	*
+	* @param value - Flex basis as a percentage (0-100)
+	*/
+	setFlexBasisPercent(value) {
+		this._style.flexBasis = {
+			value,
+			unit: 2
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the flex basis to auto (based on the node's width/height).
+	*/
+	setFlexBasisAuto() {
+		this._style.flexBasis = {
+			value: 0,
+			unit: 3
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the flex direction (main axis direction).
+	*
+	* @param direction - FLEX_DIRECTION_ROW, FLEX_DIRECTION_COLUMN, FLEX_DIRECTION_ROW_REVERSE, or FLEX_DIRECTION_COLUMN_REVERSE
+	* @example
+	* ```typescript
+	* const container = Node.create();
+	* container.setFlexDirection(FLEX_DIRECTION_ROW); // Lay out children horizontally
+	* ```
+	*/
+	setFlexDirection(direction) {
+		this._style.flexDirection = direction;
+		this.markDirty();
+	}
+	/**
+	* Set the flex wrap behavior.
+	*
+	* @param wrap - WRAP_NO_WRAP, WRAP_WRAP, or WRAP_WRAP_REVERSE
+	*/
+	setFlexWrap(wrap) {
+		this._style.flexWrap = wrap;
+		this.markDirty();
+	}
+	/**
+	* Set how children are aligned along the cross axis.
+	*
+	* @param align - ALIGN_FLEX_START, ALIGN_CENTER, ALIGN_FLEX_END, ALIGN_STRETCH, or ALIGN_BASELINE
+	* @example
+	* ```typescript
+	* const container = Node.create();
+	* container.setFlexDirection(FLEX_DIRECTION_ROW);
+	* container.setAlignItems(ALIGN_CENTER); // Center children vertically
+	* ```
+	*/
+	setAlignItems(align) {
+		this._style.alignItems = align;
+		this.markDirty();
+	}
+	/**
+	* Set how this node is aligned along the parent's cross axis.
+	* Overrides the parent's alignItems for this specific child.
+	*
+	* @param align - ALIGN_AUTO, ALIGN_FLEX_START, ALIGN_CENTER, ALIGN_FLEX_END, ALIGN_STRETCH, or ALIGN_BASELINE
+	*/
+	setAlignSelf(align) {
+		this._style.alignSelf = align;
+		this.markDirty();
+	}
+	/**
+	* Set how lines are aligned in a multi-line flex container.
+	* Only affects containers with wrap enabled and multiple lines.
+	*
+	* @param align - ALIGN_FLEX_START, ALIGN_CENTER, ALIGN_FLEX_END, ALIGN_STRETCH, ALIGN_SPACE_BETWEEN, or ALIGN_SPACE_AROUND
+	*/
+	setAlignContent(align) {
+		this._style.alignContent = align;
+		this.markDirty();
+	}
+	/**
+	* Set how children are distributed along the main axis.
+	*
+	* @param justify - JUSTIFY_FLEX_START, JUSTIFY_CENTER, JUSTIFY_FLEX_END, JUSTIFY_SPACE_BETWEEN, JUSTIFY_SPACE_AROUND, or JUSTIFY_SPACE_EVENLY
+	* @example
+	* ```typescript
+	* const container = Node.create();
+	* container.setJustifyContent(JUSTIFY_SPACE_BETWEEN); // Space children evenly with edges at start/end
+	* ```
+	*/
+	setJustifyContent(justify) {
+		this._style.justifyContent = justify;
+		this.markDirty();
+	}
+	/**
+	* Set padding for one or more edges.
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, EDGE_BOTTOM, EDGE_HORIZONTAL, EDGE_VERTICAL, or EDGE_ALL
+	* @param value - Padding in points
+	* @example
+	* ```typescript
+	* node.setPadding(EDGE_ALL, 10); // Set 10pt padding on all edges
+	* node.setPadding(EDGE_HORIZONTAL, 5); // Set 5pt padding on left and right
+	* ```
+	*/
+	setPadding(edge, value) {
+		setEdgeValue(this._style.padding, edge, value, 1);
+		this.markDirty();
+	}
+	/**
+	* Set padding as a percentage of the parent's width.
+	* Per CSS spec, percentage padding always resolves against the containing block's width.
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, EDGE_BOTTOM, EDGE_HORIZONTAL, EDGE_VERTICAL, or EDGE_ALL
+	* @param value - Padding as a percentage (0-100)
+	*/
+	setPaddingPercent(edge, value) {
+		setEdgeValue(this._style.padding, edge, value, 2);
+		this.markDirty();
+	}
+	/**
+	* Set margin for one or more edges.
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, EDGE_BOTTOM, EDGE_HORIZONTAL, EDGE_VERTICAL, or EDGE_ALL
+	* @param value - Margin in points
+	* @example
+	* ```typescript
+	* node.setMargin(EDGE_ALL, 5); // Set 5pt margin on all edges
+	* node.setMargin(EDGE_TOP, 10); // Set 10pt margin on top only
+	* ```
+	*/
+	setMargin(edge, value) {
+		setEdgeValue(this._style.margin, edge, value, 1);
+		this.markDirty();
+	}
+	/**
+	* Set margin as a percentage of the parent's size.
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, EDGE_BOTTOM, EDGE_HORIZONTAL, EDGE_VERTICAL, or EDGE_ALL
+	* @param value - Margin as a percentage (0-100)
+	*/
+	setMarginPercent(edge, value) {
+		setEdgeValue(this._style.margin, edge, value, 2);
+		this.markDirty();
+	}
+	/**
+	* Set margin to auto (for centering items with margin: auto).
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, EDGE_BOTTOM, EDGE_HORIZONTAL, EDGE_VERTICAL, or EDGE_ALL
+	*/
+	setMarginAuto(edge) {
+		setEdgeValue(this._style.margin, edge, 0, 3);
+		this.markDirty();
+	}
+	/**
+	* Set border width for one or more edges.
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, EDGE_BOTTOM, EDGE_HORIZONTAL, EDGE_VERTICAL, or EDGE_ALL
+	* @param value - Border width in points
+	*/
+	setBorder(edge, value) {
+		setEdgeBorder(this._style.border, edge, value);
+		this.markDirty();
+	}
+	/**
+	* Set gap between flex items.
+	*
+	* @param gutter - GUTTER_COLUMN (horizontal gap), GUTTER_ROW (vertical gap), or GUTTER_ALL (both)
+	* @param value - Gap size in points
+	* @example
+	* ```typescript
+	* container.setGap(GUTTER_ALL, 8); // Set 8pt gap between all items
+	* container.setGap(GUTTER_COLUMN, 10); // Set 10pt horizontal gap only
+	* ```
+	*/
+	setGap(gutter, value) {
+		if (gutter === 0) this._style.gap[0] = value;
+		else if (gutter === 1) this._style.gap[1] = value;
+		else if (gutter === 2) {
+			this._style.gap[0] = value;
+			this._style.gap[1] = value;
+		}
+		this.markDirty();
+	}
+	/**
+	* Set the position type.
+	*
+	* @param positionType - POSITION_TYPE_STATIC, POSITION_TYPE_RELATIVE, or POSITION_TYPE_ABSOLUTE
+	* @example
+	* ```typescript
+	* node.setPositionType(POSITION_TYPE_ABSOLUTE);
+	* node.setPosition(EDGE_LEFT, 10);
+	* node.setPosition(EDGE_TOP, 20);
+	* ```
+	*/
+	setPositionType(positionType) {
+		this._style.positionType = positionType;
+		this.markDirty();
+	}
+	/**
+	* Set position offset for one or more edges.
+	* Only applies when position type is ABSOLUTE or RELATIVE.
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, EDGE_BOTTOM, EDGE_HORIZONTAL, EDGE_VERTICAL, or EDGE_ALL
+	* @param value - Position offset in points
+	*/
+	setPosition(edge, value) {
+		if (Number.isNaN(value)) setEdgeValue(this._style.position, edge, 0, 0);
+		else setEdgeValue(this._style.position, edge, value, 1);
+		this.markDirty();
+	}
+	/**
+	* Set position offset as a percentage.
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, EDGE_BOTTOM, EDGE_HORIZONTAL, EDGE_VERTICAL, or EDGE_ALL
+	* @param value - Position offset as a percentage of parent's corresponding dimension
+	*/
+	setPositionPercent(edge, value) {
+		setEdgeValue(this._style.position, edge, value, 2);
+		this.markDirty();
+	}
+	/**
+	* Set the display type.
+	*
+	* @param display - DISPLAY_FLEX or DISPLAY_NONE
+	*/
+	setDisplay(display) {
+		this._style.display = display;
+		this.markDirty();
+	}
+	/**
+	* Set the overflow behavior.
+	*
+	* @param overflow - OVERFLOW_VISIBLE, OVERFLOW_HIDDEN, or OVERFLOW_SCROLL
+	*/
+	setOverflow(overflow) {
+		this._style.overflow = overflow;
+		this.markDirty();
+	}
+	/**
+	* Get the width style value.
+	*
+	* @returns Width value with unit (points, percent, or auto)
+	*/
+	getWidth() {
+		return this._style.width;
+	}
+	/**
+	* Get the height style value.
+	*
+	* @returns Height value with unit (points, percent, or auto)
+	*/
+	getHeight() {
+		return this._style.height;
+	}
+	/**
+	* Get the minimum width style value.
+	*
+	* @returns Minimum width value with unit
+	*/
+	getMinWidth() {
+		return this._style.minWidth;
+	}
+	/**
+	* Get the minimum height style value.
+	*
+	* @returns Minimum height value with unit
+	*/
+	getMinHeight() {
+		return this._style.minHeight;
+	}
+	/**
+	* Get the maximum width style value.
+	*
+	* @returns Maximum width value with unit
+	*/
+	getMaxWidth() {
+		return this._style.maxWidth;
+	}
+	/**
+	* Get the maximum height style value.
+	*
+	* @returns Maximum height value with unit
+	*/
+	getMaxHeight() {
+		return this._style.maxHeight;
+	}
+	/**
+	* Get the aspect ratio.
+	*
+	* @returns Aspect ratio value (NaN if not set)
+	*/
+	getAspectRatio() {
+		return this._style.aspectRatio;
+	}
+	/**
+	* Get the flex grow factor.
+	*
+	* @returns Flex grow value
+	*/
+	getFlexGrow() {
+		return this._style.flexGrow;
+	}
+	/**
+	* Get the flex shrink factor.
+	*
+	* @returns Flex shrink value
+	*/
+	getFlexShrink() {
+		return this._style.flexShrink;
+	}
+	/**
+	* Get the flex basis style value.
+	*
+	* @returns Flex basis value with unit
+	*/
+	getFlexBasis() {
+		return this._style.flexBasis;
+	}
+	/**
+	* Get the flex direction.
+	*
+	* @returns Flex direction constant
+	*/
+	getFlexDirection() {
+		return this._style.flexDirection;
+	}
+	/**
+	* Get the flex wrap setting.
+	*
+	* @returns Flex wrap constant
+	*/
+	getFlexWrap() {
+		return this._style.flexWrap;
+	}
+	/**
+	* Get the align items setting.
+	*
+	* @returns Align items constant
+	*/
+	getAlignItems() {
+		return this._style.alignItems;
+	}
+	/**
+	* Get the align self setting.
+	*
+	* @returns Align self constant
+	*/
+	getAlignSelf() {
+		return this._style.alignSelf;
+	}
+	/**
+	* Get the align content setting.
+	*
+	* @returns Align content constant
+	*/
+	getAlignContent() {
+		return this._style.alignContent;
+	}
+	/**
+	* Get the justify content setting.
+	*
+	* @returns Justify content constant
+	*/
+	getJustifyContent() {
+		return this._style.justifyContent;
+	}
+	/**
+	* Get the padding for a specific edge.
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, or EDGE_BOTTOM
+	* @returns Padding value with unit
+	*/
+	getPadding(edge) {
+		return getEdgeValue(this._style.padding, edge);
+	}
+	/**
+	* Get the margin for a specific edge.
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, or EDGE_BOTTOM
+	* @returns Margin value with unit
+	*/
+	getMargin(edge) {
+		return getEdgeValue(this._style.margin, edge);
+	}
+	/**
+	* Get the border width for a specific edge.
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, or EDGE_BOTTOM
+	* @returns Border width in points
+	*/
+	getBorder(edge) {
+		return getEdgeBorderValue(this._style.border, edge);
+	}
+	/**
+	* Get the position offset for a specific edge.
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, or EDGE_BOTTOM
+	* @returns Position value with unit
+	*/
+	getPosition(edge) {
+		return getEdgeValue(this._style.position, edge);
+	}
+	/**
+	* Get the position type.
+	*
+	* @returns Position type constant
+	*/
+	getPositionType() {
+		return this._style.positionType;
+	}
+	/**
+	* Get the display type.
+	*
+	* @returns Display constant
+	*/
+	getDisplay() {
+		return this._style.display;
+	}
+	/**
+	* Get the overflow setting.
+	*
+	* @returns Overflow constant
+	*/
+	getOverflow() {
+		return this._style.overflow;
+	}
+	/**
+	* Get the gap for column or row.
+	*
+	* @param gutter - GUTTER_COLUMN or GUTTER_ROW
+	* @returns Gap size in points
+	*/
+	getGap(gutter) {
+		if (gutter === 0) return this._style.gap[0];
+		else if (gutter === 1) return this._style.gap[1];
+		return this._style.gap[0];
+	}
+};
+//#endregion
+export { ALIGN_AUTO, ALIGN_BASELINE, ALIGN_CENTER, ALIGN_FLEX_END, ALIGN_FLEX_START, ALIGN_SPACE_AROUND, ALIGN_SPACE_BETWEEN, ALIGN_SPACE_EVENLY, ALIGN_STRETCH, DIRECTION_INHERIT, DIRECTION_LTR, DIRECTION_RTL, DISPLAY_FLEX, DISPLAY_NONE, EDGE_ALL, EDGE_BOTTOM, EDGE_END, EDGE_HORIZONTAL, EDGE_LEFT, EDGE_RIGHT, EDGE_START, EDGE_TOP, EDGE_VERTICAL, FLEX_DIRECTION_COLUMN, FLEX_DIRECTION_COLUMN_REVERSE, FLEX_DIRECTION_ROW, FLEX_DIRECTION_ROW_REVERSE, GUTTER_ALL, GUTTER_COLUMN, GUTTER_ROW, JUSTIFY_CENTER, JUSTIFY_FLEX_END, JUSTIFY_FLEX_START, JUSTIFY_SPACE_AROUND, JUSTIFY_SPACE_BETWEEN, JUSTIFY_SPACE_EVENLY, MEASURE_MODE_AT_MOST, MEASURE_MODE_EXACTLY, MEASURE_MODE_UNDEFINED, Node, OVERFLOW_HIDDEN, OVERFLOW_SCROLL, OVERFLOW_VISIBLE, POSITION_TYPE_ABSOLUTE, POSITION_TYPE_RELATIVE, POSITION_TYPE_STATIC, UNIT_AUTO, UNIT_PERCENT, UNIT_POINT, UNIT_UNDEFINED, WRAP_NO_WRAP, WRAP_WRAP, WRAP_WRAP_REVERSE, createDefaultStyle, createValue, layoutCacheHits, layoutNodeCalls, layoutPositioningCalls, layoutSizingCalls, resetLayoutStats };
+
+//# sourceMappingURL=index-classic.mjs.map