flexily 0.5.2 → 0.6.0

package/dist/index.mjs

@@ -0,0 +1,3279 @@
+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, X as UNIT_SNUG_CONTENT, 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, q as UNIT_FIT_CONTENT, 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, u as traversalStack } from "./types--IozHd4V.mjs";
+//#region src/trace.ts
+let _trace = null;
+/** Get the current trace recorder (null when tracing is disabled). */
+function getTrace() {
+	return _trace;
+}
+//#endregion
+//#region src/layout-helpers.ts
+/**
+* Layout Helper Functions
+*
+* Edge resolution helpers for margins, padding, borders.
+* These are pure functions with no state — safe to extract.
+*/
+/**
+* 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.
+*
+* EDGE_START/EDGE_END always resolve along the inline (horizontal) axis,
+* regardless of flex direction. Direction (LTR/RTL) determines the mapping:
+* - LTR: START->left, END->right
+* - RTL: START->right, END->left
+*/
+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.
+*
+* EDGE_START/EDGE_END always resolve along the inline (horizontal) axis,
+* regardless of flex direction. Direction (LTR/RTL) determines the mapping:
+* - LTR: START->left, END->right
+* - RTL: START->right, END->left
+*/
+/**
+* Resolve logical (START/END) position edges to physical values.
+* Returns the resolved Value for a physical position index, considering
+* logical EDGE_START/EDGE_END. Logical takes precedence over physical.
+*
+* EDGE_START/EDGE_END always resolve along the inline (horizontal) axis:
+* - LTR: START->left, END->right
+* - RTL: START->right, END->left
+*/
+function resolvePositionEdge(arr, physicalIndex, direction = 1) {
+	const logicalValue = getLogicalEdgeValue(arr, physicalIndex, 0, direction);
+	if (logicalValue && logicalValue.unit !== 0) return logicalValue;
+	return arr[physicalIndex];
+}
+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];
+}
+//#endregion
+//#region src/layout-traversal.ts
+/**
+* Mark subtree as having new layout and clear dirty flags (iterative to avoid stack overflow).
+* This is called after layout completes to reset dirty tracking for all nodes.
+*/
+function markSubtreeLayoutSeen(node) {
+	traversalStack.length = 0;
+	traversalStack.push(node);
+	while (traversalStack.length > 0) {
+		const current = traversalStack.pop();
+		current["_isDirty"] = false;
+		current["_hasNewLayout"] = true;
+		for (const child of current.children) traversalStack.push(child);
+	}
+}
+/**
+* Count total nodes in tree (iterative to avoid stack overflow).
+*/
+function countNodes(node) {
+	let count = 0;
+	traversalStack.length = 0;
+	traversalStack.push(node);
+	while (traversalStack.length > 0) {
+		const current = traversalStack.pop();
+		count++;
+		for (const child of current.children) traversalStack.push(child);
+	}
+	return count;
+}
+/**
+* Propagate position delta to all descendants (iterative to avoid stack overflow).
+* Used when parent position changes but layout is cached.
+*
+* Only updates the constraint fingerprint's lastOffset values, NOT layout.top/left.
+* layout.top/left store RELATIVE positions (relative to parent's border box),
+* so they don't change when an ancestor moves — only the absolute offset
+* (tracked via lastOffsetX/Y) changes.
+*/
+function propagatePositionDelta(node, deltaX, deltaY) {
+	traversalStack.length = 0;
+	for (const child of node.children) traversalStack.push(child);
+	while (traversalStack.length > 0) {
+		const current = traversalStack.pop();
+		current.flex.lastOffsetX += deltaX;
+		current.flex.lastOffsetY += deltaY;
+		for (const child of current.children) traversalStack.push(child);
+	}
+}
+//#endregion
+//#region src/layout-stats.ts
+/**
+* Layout Statistics Counters
+*
+* Mutable counters for debugging and benchmarking.
+* Separated to avoid circular dependencies between layout modules.
+*/
+let layoutNodeCalls = 0;
+let measureNodeCalls = 0;
+let layoutSizingCalls = 0;
+let layoutPositioningCalls = 0;
+let layoutCacheHits = 0;
+function resetLayoutStats() {
+	layoutNodeCalls = 0;
+	measureNodeCalls = 0;
+	layoutSizingCalls = 0;
+	layoutPositioningCalls = 0;
+	layoutCacheHits = 0;
+}
+function incLayoutNodeCalls() {
+	layoutNodeCalls++;
+}
+function incMeasureNodeCalls() {
+	measureNodeCalls++;
+}
+function incLayoutSizingCalls() {
+	layoutSizingCalls++;
+}
+function incLayoutPositioningCalls() {
+	layoutPositioningCalls++;
+}
+function incLayoutCacheHits() {
+	layoutCacheHits++;
+}
+//#endregion
+//#region src/layout-measure.ts
+/**
+* Node Measurement (Intrinsic Sizing)
+*
+* measureNode() computes a node's width and height without calculating positions.
+* It's a lightweight alternative to layoutNode() used during Phase 5 for
+* intrinsic sizing of auto-sized container children.
+*
+* IMPORTANT: measureNode() overwrites layout.width/layout.height as a side effect.
+* Callers MUST save/restore these fields around calls to avoid corrupting
+* the fingerprint cache (see "Bug 1: measureNode corruption" in CLAUDE.md).
+*/
+/**
+* Measure a node to get its intrinsic size without computing positions.
+* This is a lightweight alternative to layoutNode for sizing-only passes.
+*
+* Sets layout.width and layout.height but NOT layout.left/top.
+*
+* @param node - The node to measure
+* @param availableWidth - Available width (NaN for unconstrained)
+* @param availableHeight - Available height (NaN for unconstrained)
+* @param direction - Layout direction (LTR or RTL)
+*/
+function measureNode(node, availableWidth, availableHeight, direction = 1) {
+	incMeasureNodeCalls();
+	const style = node.style;
+	const layout = node.layout;
+	if (style.display === 1) {
+		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;
+			nodeWidth = applyMinMax(nodeWidth, style.minWidth, style.maxWidth, availableWidth);
+		} 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);
+	if (node.hasMeasureFunc() && node.children.length === 0) {
+		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 measureWidth = Number.isNaN(contentWidth) ? Infinity : contentWidth;
+		const measureHeight = Number.isNaN(contentHeight) ? Infinity : contentHeight;
+		const measured = node.cachedMeasure(measureWidth, widthMode, measureHeight, 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);
+		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);
+		return;
+	}
+	let relativeChildCount = 0;
+	for (const c of node.children) {
+		if (c.style.display === 1) continue;
+		if (c.style.positionType !== 2) relativeChildCount++;
+	}
+	if (relativeChildCount === 0) {
+		if (Number.isNaN(nodeWidth)) nodeWidth = minInnerWidth;
+		if (Number.isNaN(nodeHeight)) nodeHeight = minInnerHeight;
+		layout.width = Math.round(nodeWidth);
+		layout.height = Math.round(nodeHeight);
+		return;
+	}
+	const isRow = isRowDirection(style.flexDirection);
+	const crossAxisSize = isRow ? contentHeight : contentWidth;
+	const mainGap = isRow ? style.gap[0] : style.gap[1];
+	let totalMainSize = 0;
+	let maxCrossSize = 0;
+	let itemCount = 0;
+	for (const child of node.children) {
+		if (child.style.display === 1) continue;
+		if (child.style.positionType === 2) continue;
+		const childStyle = child.style;
+		const childMarginMain = isRow ? resolveEdgeValue(childStyle.margin, 0, style.flexDirection, contentWidth, direction) + resolveEdgeValue(childStyle.margin, 2, style.flexDirection, contentWidth, direction) : resolveEdgeValue(childStyle.margin, 1, style.flexDirection, contentWidth, direction) + resolveEdgeValue(childStyle.margin, 3, style.flexDirection, contentWidth, direction);
+		const childMarginCross = 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 childAvailW = isRow ? NaN : crossAxisSize;
+		const childAvailH = isRow ? crossAxisSize : NaN;
+		let measuredW = 0;
+		let measuredH = 0;
+		const cached = child.getCachedLayout(childAvailW, childAvailH);
+		if (cached) incLayoutCacheHits();
+		else {
+			const savedW = child.layout.width;
+			const savedH = child.layout.height;
+			measureNode(child, childAvailW, childAvailH, direction);
+			measuredW = child.layout.width;
+			measuredH = child.layout.height;
+			child.layout.width = savedW;
+			child.layout.height = savedH;
+			child.setCachedLayout(childAvailW, childAvailH, measuredW, measuredH);
+		}
+		const childMainSize = cached ? isRow ? cached.width : cached.height : isRow ? measuredW : measuredH;
+		const childCrossSize = cached ? isRow ? cached.height : cached.width : isRow ? measuredH : measuredW;
+		totalMainSize += childMainSize + childMarginMain;
+		maxCrossSize = Math.max(maxCrossSize, childCrossSize + childMarginCross);
+		itemCount++;
+	}
+	if (itemCount > 1) totalMainSize += mainGap * (itemCount - 1);
+	if (Number.isNaN(nodeWidth)) nodeWidth = (isRow ? totalMainSize : maxCrossSize) + innerLeft + innerRight;
+	if (Number.isNaN(nodeHeight)) nodeHeight = (isRow ? maxCrossSize : totalMainSize) + innerTop + innerBottom;
+	nodeWidth = applyMinMax(nodeWidth, style.minWidth, style.maxWidth, availableWidth);
+	nodeHeight = applyMinMax(nodeHeight, style.minHeight, style.maxHeight, availableHeight);
+	layout.width = Math.round(nodeWidth);
+	layout.height = Math.round(nodeHeight);
+}
+//#endregion
+//#region src/layout-flex-lines.ts
+/**
+* Flex Line Breaking and Space Distribution
+*
+* Pre-allocated arrays for zero-allocation flex-wrap layout,
+* plus the line-breaking and flex-distribution algorithms.
+*
+* Re-entrancy: A user measureFunc or baselineFunc may synchronously call
+* calculateLayout() on a separate tree. saveLineState/restoreLineState
+* bracket such nested calls to protect the outer pass's scratch arrays.
+*/
+/**
+* Maximum number of flex lines supported without dynamic allocation.
+* If a layout exceeds this, arrays grow automatically (rare edge case).
+* 32 lines covers virtually all real-world layouts while using minimal memory.
+*/
+let MAX_FLEX_LINES = 32;
+/**
+* Pre-allocated array for line cross sizes (reused across layout passes).
+* Stores the computed cross-axis size of each flex line.
+*/
+let _lineCrossSizes = new Float64Array(MAX_FLEX_LINES);
+/**
+* Pre-allocated array for line cross offsets (reused across layout passes).
+* Stores the cross-axis position offset for each flex line.
+*/
+let _lineCrossOffsets = new Float64Array(MAX_FLEX_LINES);
+/**
+* Pre-allocated array for line lengths (number of children per line).
+* Uint16 supports up to 65535 children per line (more than sufficient).
+*/
+let _lineLengths = new Uint16Array(MAX_FLEX_LINES);
+/**
+* Pre-allocated 2D array for children per line.
+* Avoids O(n*m) iteration when processing multi-line flex layouts.
+* Each slot holds array of Node references for that line.
+*/
+let _lineChildren = Array.from({ length: MAX_FLEX_LINES }, () => []);
+/**
+* Pre-allocated array for per-line justify-content start offsets.
+* Stores the main-axis starting position for each flex line.
+*/
+let _lineJustifyStarts = new Float64Array(MAX_FLEX_LINES);
+/**
+* Pre-allocated array for per-line item spacing (justify-content gaps).
+* Stores the spacing between items for each flex line.
+*/
+let _lineItemSpacings = new Float64Array(MAX_FLEX_LINES);
+/**
+* Grow pre-allocated line arrays if needed.
+* Called when a layout has more lines than current capacity.
+* This is rare (>32 lines) and acceptable as a one-time allocation.
+*/
+function growLineArrays(needed) {
+	const newSize = Math.max(needed, MAX_FLEX_LINES * 2);
+	MAX_FLEX_LINES = newSize;
+	_lineCrossSizes = new Float64Array(newSize);
+	_lineCrossOffsets = new Float64Array(newSize);
+	_lineLengths = new Uint16Array(newSize);
+	_lineJustifyStarts = new Float64Array(newSize);
+	_lineItemSpacings = new Float64Array(newSize);
+	while (_lineChildren.length < newSize) _lineChildren.push([]);
+}
+/** Current re-entrancy depth. 0 = outermost (no save needed). */
+let _layoutDepth = 0;
+/**
+* Enter a layout pass. If re-entrant (depth > 0), saves current line state.
+* @returns The saved state (to pass to restoreLineState), or null at depth 0.
+*/
+function enterLayout() {
+	if (_layoutDepth++ === 0) return null;
+	return {
+		crossSizes: _lineCrossSizes.slice(),
+		crossOffsets: _lineCrossOffsets.slice(),
+		lengths: _lineLengths.slice(),
+		justifyStarts: _lineJustifyStarts.slice(),
+		itemSpacings: _lineItemSpacings.slice(),
+		children: _lineChildren.map((arr) => arr.slice()),
+		maxLines: MAX_FLEX_LINES
+	};
+}
+/**
+* Exit a layout pass. If re-entrant, restores saved line state.
+* @param saved - The state returned by enterLayout (null at depth 0).
+*/
+function exitLayout(saved) {
+	_layoutDepth--;
+	if (!saved) return;
+	MAX_FLEX_LINES = saved.maxLines;
+	_lineCrossSizes = saved.crossSizes;
+	_lineCrossOffsets = saved.crossOffsets;
+	_lineLengths = saved.lengths;
+	_lineJustifyStarts = saved.justifyStarts;
+	_lineItemSpacings = saved.itemSpacings;
+	_lineChildren = saved.children;
+}
+/**
+* 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.
+* Zero-allocation: Sets child.flex.lineIndex directly, uses pre-allocated _lineStarts/_lineLengths.
+*
+* @param parent - Parent node whose children to wrap
+* @param relativeCount - Number of relative children (those with flex.relativeIndex >= 0)
+* @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 Number of lines created
+*/
+function breakIntoLines(parent, relativeCount, mainAxisSize, mainGap, wrap) {
+	if (wrap === 0 || Number.isNaN(mainAxisSize) || relativeCount === 0) {
+		const lineArr = _lineChildren[0];
+		let idx = 0;
+		for (const child of parent.children) if (child.flex.relativeIndex >= 0) {
+			child.flex.lineIndex = 0;
+			lineArr[idx++] = child;
+		}
+		lineArr.length = idx;
+		_lineLengths[0] = relativeCount;
+		_lineCrossSizes[0] = 0;
+		_lineCrossOffsets[0] = 0;
+		return 1;
+	}
+	let lineIndex = 0;
+	let lineMainSize = 0;
+	let lineChildCount = 0;
+	let lineChildIdx = 0;
+	for (const child of parent.children) {
+		if (child.flex.relativeIndex < 0) continue;
+		const flex = child.flex;
+		const childMainSize = Math.max(flex.minMain, Math.min(flex.maxMain, flex.baseSize)) + flex.mainMargin;
+		const gapIfNotFirst = lineChildCount > 0 ? mainGap : 0;
+		if (lineChildCount > 0 && lineMainSize + gapIfNotFirst + childMainSize > mainAxisSize) {
+			_lineChildren[lineIndex].length = lineChildIdx;
+			_lineLengths[lineIndex] = lineChildCount;
+			lineIndex++;
+			if (lineIndex >= MAX_FLEX_LINES) growLineArrays(lineIndex + 16);
+			lineChildIdx = 0;
+			lineMainSize = childMainSize;
+			lineChildCount = 1;
+		} else {
+			lineMainSize += gapIfNotFirst + childMainSize;
+			lineChildCount++;
+		}
+		flex.lineIndex = lineIndex;
+		_lineChildren[lineIndex][lineChildIdx++] = child;
+	}
+	if (lineChildCount > 0) {
+		_lineChildren[lineIndex].length = lineChildIdx;
+		_lineLengths[lineIndex] = lineChildCount;
+		lineIndex++;
+	}
+	const numLines = lineIndex;
+	for (let i = 0; i < numLines; i++) {
+		_lineCrossSizes[i] = 0;
+		_lineCrossOffsets[i] = 0;
+	}
+	if (wrap === 2 && numLines > 1) {
+		for (let i = 0; i < Math.floor(numLines / 2); i++) {
+			const j = numLines - 1 - i;
+			const lineI = _lineChildren[i];
+			const lineJ = _lineChildren[j];
+			const lenI = lineI.length;
+			const lenJ = lineJ.length;
+			const maxLen = Math.max(lenI, lenJ);
+			for (let k = 0; k < maxLen; k++) {
+				const hasI = k < lenI;
+				const hasJ = k < lenJ;
+				const tmpI = hasI ? lineI[k] : null;
+				const tmpJ = hasJ ? lineJ[k] : null;
+				if (hasJ) lineI[k] = tmpJ;
+				if (hasI) lineJ[k] = tmpI;
+			}
+			lineI.length = lenJ;
+			lineJ.length = lenI;
+		}
+		for (let i = 0; i < numLines; i++) {
+			const lc = _lineChildren[i];
+			for (let c = 0; c < lc.length; c++) lc[c].flex.lineIndex = i;
+		}
+	}
+	return numLines;
+}
+/**
+* Distribute flex space for a single line of children.
+* Implements CSS Flexbox section 9.7: Resolving Flexible Lengths.
+*
+* Takes pre-collected children array to avoid O(n*m) iteration pattern.
+* Previously iterated through ALL parent.children 8 times per line.
+*
+* @param lineChildren - Pre-collected children for this line (from _lineChildren)
+* @param initialFreeSpace - Free space to distribute (positive=grow, negative=shrink)
+*/
+function distributeFlexSpaceForLine(lineChildren, initialFreeSpace) {
+	const isGrowing = initialFreeSpace > 0;
+	if (initialFreeSpace === 0) return;
+	const childCount = lineChildren.length;
+	if (childCount === 0) return;
+	if (childCount === 1) {
+		const flex = lineChildren[0].flex;
+		if (isGrowing ? flex.flexGrow > 0 : flex.flexShrink > 0) {
+			const target = flex.baseSize + initialFreeSpace;
+			flex.mainSize = Math.max(flex.minMain, Math.min(flex.maxMain, target));
+		}
+		return;
+	}
+	let totalBase = 0;
+	for (let i = 0; i < childCount; i++) totalBase += lineChildren[i].flex.baseSize;
+	const containerInner = initialFreeSpace + totalBase;
+	for (let i = 0; i < childCount; i++) lineChildren[i].flex.frozen = false;
+	let freeSpace = initialFreeSpace;
+	let iterations = 0;
+	const maxIterations = childCount + 1;
+	while (iterations++ < maxIterations) {
+		let totalFlex = 0;
+		for (let i = 0; i < childCount; i++) {
+			const flex = lineChildren[i].flex;
+			if (flex.frozen) continue;
+			if (isGrowing) totalFlex += flex.flexGrow;
+			else totalFlex += flex.flexShrink * flex.baseSize;
+		}
+		if (totalFlex === 0) break;
+		let effectiveFreeSpace = freeSpace;
+		if (isGrowing && totalFlex < 1) effectiveFreeSpace = freeSpace * totalFlex;
+		let totalViolation = 0;
+		for (let i = 0; i < childCount; i++) {
+			const flex = lineChildren[i].flex;
+			if (flex.frozen) continue;
+			const flexFactor = isGrowing ? flex.flexGrow : flex.flexShrink * flex.baseSize;
+			const ratio = totalFlex > 0 ? flexFactor / totalFlex : 0;
+			const target = flex.baseSize + effectiveFreeSpace * ratio;
+			const clamped = Math.max(flex.minMain, Math.min(flex.maxMain, target));
+			totalViolation += clamped - target;
+			flex.mainSize = clamped;
+		}
+		let anyFrozen = false;
+		if (Math.abs(totalViolation) < EPSILON_FLOAT) {
+			for (let i = 0; i < childCount; i++) lineChildren[i].flex.frozen = true;
+			break;
+		} else if (totalViolation > 0) for (let i = 0; i < childCount; i++) {
+			const flex = lineChildren[i].flex;
+			if (flex.frozen) continue;
+			const target = flex.baseSize + (isGrowing ? flex.flexGrow : flex.flexShrink * flex.baseSize) / totalFlex * effectiveFreeSpace;
+			if (flex.mainSize > target + EPSILON_FLOAT) {
+				flex.frozen = true;
+				anyFrozen = true;
+			}
+		}
+		else for (let i = 0; i < childCount; i++) {
+			const flex = lineChildren[i].flex;
+			if (flex.frozen) continue;
+			const flexFactor = isGrowing ? flex.flexGrow : flex.flexShrink * flex.baseSize;
+			const target = flex.baseSize + flexFactor / totalFlex * effectiveFreeSpace;
+			if (flex.mainSize < target - EPSILON_FLOAT) {
+				flex.frozen = true;
+				anyFrozen = true;
+			}
+		}
+		if (!anyFrozen) break;
+		let frozenSpace = 0;
+		let unfrozenBase = 0;
+		for (let i = 0; i < childCount; i++) {
+			const flex = lineChildren[i].flex;
+			if (flex.frozen) frozenSpace += flex.mainSize;
+			else unfrozenBase += flex.baseSize;
+		}
+		freeSpace = containerInner - frozenSpace - unfrozenBase;
+	}
+}
+//#endregion
+//#region src/layout-zero.ts
+/**
+* Flexily Layout Algorithm — Main Entry Point
+*
+* Core flexbox layout computation. This file contains:
+* - computeLayout(): top-level entry point
+* - layoutNode(): recursive layout algorithm (11 phases)
+*
+* Helper modules (split for maintainability, zero-allocation preserved):
+* - layout-helpers.ts: Edge resolution (margins, padding, borders)
+* - layout-traversal.ts: Tree traversal (markSubtreeLayoutSeen, countNodes)
+* - layout-flex-lines.ts: Pre-allocated arrays, line breaking, flex distribution
+* - layout-measure.ts: Intrinsic sizing (measureNode)
+* - layout-stats.ts: Debug/benchmark counters
+*
+* Based on Planning-nl/flexbox.js reference implementation.
+*/
+/**
+* Compute layout for a node tree.
+*/
+function computeLayout(root, availableWidth, availableHeight, direction = 1) {
+	const saved = enterLayout();
+	try {
+		resetLayoutStats();
+		getTrace()?.resetCounter();
+		root.resetLayoutCache();
+		layoutNode(root, availableWidth, availableHeight, 0, 0, 0, 0, direction);
+	} finally {
+		exitLayout(saved);
+	}
+}
+/**
+* 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)
+*/
+function layoutNode(node, availableWidth, availableHeight, offsetX, offsetY, absX, absY, direction = 1) {
+	incLayoutNodeCalls();
+	if (offsetX === 0 && offsetY === 0 && absX === 0 && absY === 0 && node.children.length > 0) incLayoutSizingCalls();
+	else incLayoutPositioningCalls();
+	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 _t = getTrace();
+	const _tn = _t?.nextNode() ?? 0;
+	_t?.layoutEnter(_tn, availableWidth, availableHeight, node.isDirty(), 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 flex = node.flex;
+	if (flex.layoutValid && !node.isDirty() && Object.is(flex.lastAvailW, availableWidth) && Object.is(flex.lastAvailH, availableHeight) && flex.lastDir === direction && flex.lastAbsX === absX && flex.lastAbsY === absY) {
+		_t?.fingerprintHit(_tn, availableWidth, availableHeight);
+		const deltaX = offsetX - flex.lastOffsetX;
+		const deltaY = offsetY - flex.lastOffsetY;
+		if (deltaX !== 0 || deltaY !== 0) {
+			layout.left += deltaX;
+			layout.top += deltaY;
+			flex.lastOffsetX = offsetX;
+			flex.lastOffsetY = offsetY;
+			propagatePositionDelta(node, deltaX, deltaY);
+		}
+		return;
+	}
+	_t?.fingerprintMiss(_tn, availableWidth, availableHeight, {
+		layoutValid: flex.layoutValid,
+		isDirty: node.isDirty(),
+		sameW: Object.is(flex.lastAvailW, availableWidth),
+		sameH: Object.is(flex.lastAvailH, availableHeight),
+		sameDir: flex.lastDir === direction,
+		sameAbsX: flex.lastAbsX === absX,
+		sameAbsY: flex.lastAbsY === absY
+	});
+	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;
+	const isFitContentWidth = style.width.unit === 4 || style.width.unit === 5;
+	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;
+			nodeWidth = applyMinMax(nodeWidth, style.minWidth, style.maxWidth, availableWidth);
+		} 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 = resolvePositionEdge(style.position, 0, direction);
+		const topPos = style.position[1];
+		const rightPos = resolvePositionEdge(style.position, 2, direction);
+		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 widthIsAuto = style.width.unit === 3 || style.width.unit === 0 || Number.isNaN(nodeWidth);
+		const widthIsFitContent = isFitContentWidth;
+		const heightIsAuto = style.height.unit === 3 || style.height.unit === 0 || Number.isNaN(nodeHeight);
+		const widthMode = widthIsAuto || widthIsFitContent ? 2 : 1;
+		const heightMode = heightIsAuto ? 0 : 1;
+		const measureWidth = Number.isNaN(contentWidth) ? Infinity : contentWidth;
+		const measureHeight = Number.isNaN(contentHeight) ? Infinity : contentHeight;
+		const measured = node.cachedMeasure(measureWidth, widthMode, measureHeight, heightMode);
+		if (widthIsAuto || widthIsFitContent) 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) || isFitContentWidth) 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 isRow = isRowDirection(style.flexDirection);
+	const isReverse = isReverseDirection(style.flexDirection);
+	const effectiveReverse = isRow ? direction === 2 !== isReverse : isReverse;
+	const mainAxisSize = isRow ? contentWidth : contentHeight;
+	const crossAxisSize = isRow ? contentHeight : contentWidth;
+	const mainGap = isRow ? style.gap[0] : style.gap[1];
+	let totalBaseMain = 0;
+	let relativeCount = 0;
+	let totalAutoMargins = 0;
+	let hasBaselineAlignment = style.alignItems === 5;
+	for (const child of node.children) {
+		if (child.style.display === 1 || child.style.positionType === 2) {
+			child.flex.relativeIndex = -1;
+			continue;
+		}
+		child.flex.relativeIndex = relativeCount++;
+		const childStyle = child.style;
+		const cflex = child.flex;
+		const mainStartIndex = isRow ? effectiveReverse ? 2 : 0 : isReverse ? 3 : 1;
+		const mainEndIndex = isRow ? effectiveReverse ? 0 : 2 : isReverse ? 1 : 3;
+		cflex.mainStartMarginAuto = isEdgeAuto(childStyle.margin, mainStartIndex, style.flexDirection, direction);
+		cflex.mainEndMarginAuto = isEdgeAuto(childStyle.margin, mainEndIndex, style.flexDirection, direction);
+		cflex.marginL = resolveEdgeValue(childStyle.margin, 0, style.flexDirection, contentWidth, direction);
+		cflex.marginT = resolveEdgeValue(childStyle.margin, 1, style.flexDirection, contentWidth, direction);
+		cflex.marginR = resolveEdgeValue(childStyle.margin, 2, style.flexDirection, contentWidth, direction);
+		cflex.marginB = resolveEdgeValue(childStyle.margin, 3, style.flexDirection, contentWidth, direction);
+		cflex.mainStartMarginValue = cflex.mainStartMarginAuto ? 0 : isRow ? effectiveReverse ? cflex.marginR : cflex.marginL : isReverse ? cflex.marginB : cflex.marginT;
+		cflex.mainEndMarginValue = cflex.mainEndMarginAuto ? 0 : isRow ? effectiveReverse ? cflex.marginL : cflex.marginR : isReverse ? cflex.marginT : cflex.marginB;
+		cflex.mainMargin = cflex.mainStartMarginValue + cflex.mainEndMarginValue;
+		let baseSize = 0;
+		if (childStyle.flexBasis.unit === 1) baseSize = childStyle.flexBasis.value;
+		else if (childStyle.flexBasis.unit === 2) baseSize = Number.isNaN(mainAxisSize) ? 0 : 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 = Number.isNaN(mainAxisSize) ? 0 : mainAxisSize * (sizeVal.value / 100);
+			else if (child.hasMeasureFunc()) {
+				const availCross = crossAxisSize - (isRow ? cflex.marginT + cflex.marginB : cflex.marginL + cflex.marginR);
+				const wantMaxContent = childStyle.flexGrow > 0;
+				const mW = isRow ? wantMaxContent ? Infinity : Number.isNaN(mainAxisSize) ? Infinity : mainAxisSize : Number.isNaN(availCross) ? Infinity : availCross;
+				const mH = isRow ? Number.isNaN(availCross) ? Infinity : availCross : wantMaxContent ? Infinity : Number.isNaN(mainAxisSize) ? Infinity : mainAxisSize;
+				const mWMode = isRow ? wantMaxContent ? 0 : 2 : Number.isNaN(availCross) ? 0 : 2;
+				const mHMode = isRow ? 0 : wantMaxContent ? 0 : 2;
+				const measured = child.cachedMeasure(mW, mWMode, mH, mHMode);
+				baseSize = isRow ? measured.width : measured.height;
+			} else if (child.children.length > 0) {
+				const sizingW = isRow ? NaN : crossAxisSize;
+				const sizingH = isRow ? crossAxisSize : NaN;
+				const cached = child.getCachedLayout(sizingW, sizingH);
+				if (cached) {
+					incLayoutCacheHits();
+					_t?.cacheHit(_tn, sizingW, sizingH, cached.width, cached.height);
+					baseSize = isRow ? cached.width : cached.height;
+				} else {
+					_t?.cacheMiss(_tn, sizingW, sizingH);
+					const savedW = child.layout.width;
+					const savedH = child.layout.height;
+					measureNode(child, sizingW, sizingH, direction);
+					const measuredW = child.layout.width;
+					const measuredH = child.layout.height;
+					child.layout.width = savedW;
+					child.layout.height = savedH;
+					_t?.measureSaveRestore(_tn, savedW, savedH, measuredW, measuredH);
+					baseSize = isRow ? measuredW : measuredH;
+					child.setCachedLayout(sizingW, sizingH, measuredW, measuredH);
+				}
+			} 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;
+		cflex.minMain = minVal.unit !== 0 ? resolveValue(minVal, mainAxisSize) : 0;
+		cflex.maxMain = maxVal.unit !== 0 ? resolveValue(maxVal, mainAxisSize) : Infinity;
+		cflex.flexGrow = childStyle.flexGrow;
+		let shrink = childStyle.flexShrink;
+		if (childStyle.overflow !== 0) shrink = Math.max(shrink, 1);
+		if (child.hasMeasureFunc() && childStyle.flexGrow > 0) shrink = Math.max(shrink, 1);
+		const mainDim = isRow ? childStyle.width : childStyle.height;
+		if (mainDim.unit === 4 || mainDim.unit === 5) shrink = Math.max(shrink, 1);
+		cflex.flexShrink = shrink;
+		cflex.baseSize = baseSize;
+		cflex.mainSize = baseSize;
+		cflex.frozen = false;
+		totalBaseMain += baseSize + cflex.mainMargin;
+		if (cflex.mainStartMarginAuto) totalAutoMargins++;
+		if (cflex.mainEndMarginAuto) totalAutoMargins++;
+		if (!hasBaselineAlignment && childStyle.alignSelf === 5) hasBaselineAlignment = true;
+	}
+	log.debug?.("layoutNode: node.children=%d, relativeCount=%d", node.children.length, relativeCount);
+	if (relativeCount > 0) {
+		const numLines = breakIntoLines(node, relativeCount, mainAxisSize, mainGap, style.flexWrap);
+		const crossGap = isRow ? style.gap[1] : style.gap[0];
+		for (let lineIdx = 0; lineIdx < numLines; lineIdx++) {
+			const lineChildren = _lineChildren[lineIdx];
+			const lineLength = lineChildren.length;
+			if (lineLength === 0) continue;
+			let lineTotalBaseMain = 0;
+			for (let i = 0; i < lineLength; i++) {
+				const c = lineChildren[i];
+				lineTotalBaseMain += c.flex.baseSize + c.flex.mainMargin;
+			}
+			const lineTotalGaps = lineLength > 1 ? mainGap * (lineLength - 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)) distributeFlexSpaceForLine(lineChildren, effectiveMainSize - lineTotalBaseMain - lineTotalGaps);
+			for (let i = 0; i < lineLength; i++) {
+				const f = lineChildren[i].flex;
+				f.mainSize = Math.max(f.minMain, Math.min(f.maxMain, f.mainSize));
+			}
+		}
+		for (let lineIdx = 0; lineIdx < numLines; lineIdx++) {
+			const lineChildren = _lineChildren[lineIdx];
+			const lineLength = lineChildren.length;
+			if (lineLength === 0) {
+				_lineJustifyStarts[lineIdx] = 0;
+				_lineItemSpacings[lineIdx] = mainGap;
+				continue;
+			}
+			let lineUsedMain = 0;
+			let lineAutoMargins = 0;
+			for (let i = 0; i < lineLength; i++) {
+				const c = lineChildren[i];
+				lineUsedMain += c.flex.mainSize + c.flex.mainMargin;
+				if (c.flex.mainStartMarginAuto) lineAutoMargins++;
+				if (c.flex.mainEndMarginAuto) lineAutoMargins++;
+			}
+			const lineGaps = lineLength > 1 ? mainGap * (lineLength - 1) : 0;
+			lineUsedMain += lineGaps;
+			const lineRemainingSpace = Number.isNaN(mainAxisSize) ? 0 : mainAxisSize - lineUsedMain;
+			const lineHasAutoMargins = lineAutoMargins > 0;
+			if (lineHasAutoMargins) {
+				const autoMarginValue = Math.max(0, lineRemainingSpace) / lineAutoMargins;
+				for (let i = 0; i < lineLength; i++) {
+					const child = lineChildren[i];
+					if (child.flex.mainStartMarginAuto) child.flex.mainStartMarginValue = autoMarginValue;
+					if (child.flex.mainEndMarginAuto) child.flex.mainEndMarginValue = autoMarginValue;
+				}
+			}
+			let lineStartOffset = 0;
+			let lineItemSpacing = mainGap;
+			if (!lineHasAutoMargins) switch (style.justifyContent) {
+				case 2:
+					lineStartOffset = lineRemainingSpace;
+					break;
+				case 1:
+					lineStartOffset = lineRemainingSpace / 2;
+					break;
+				case 3:
+					if (lineLength > 1 && lineRemainingSpace > 0) lineItemSpacing = mainGap + lineRemainingSpace / (lineLength - 1);
+					break;
+				case 4:
+					if (lineLength > 0 && lineRemainingSpace > 0) {
+						const extraSpace = lineRemainingSpace / lineLength;
+						lineStartOffset = extraSpace / 2;
+						lineItemSpacing = mainGap + extraSpace;
+					}
+					break;
+				case 5:
+					if (lineLength > 0 && lineRemainingSpace > 0) {
+						const extraSpace = lineRemainingSpace / (lineLength + 1);
+						lineStartOffset = extraSpace;
+						lineItemSpacing = mainGap + extraSpace;
+					}
+					break;
+			}
+			_lineJustifyStarts[lineIdx] = lineStartOffset;
+			_lineItemSpacings[lineIdx] = lineItemSpacing;
+		}
+		const startOffset = _lineJustifyStarts[0];
+		const itemSpacing = _lineItemSpacings[0];
+		let maxBaseline = 0;
+		let baselineZoneHeight = 0;
+		const alignItemsIsBaseline = style.alignItems === 5;
+		if (hasBaselineAlignment && isRow) {
+			let maxChildHeight = 0;
+			for (const child of node.children) {
+				if (child.flex.relativeIndex < 0) continue;
+				const childStyle = child.style;
+				const topMargin = child.flex.marginT;
+				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 = child.flex.mainSize;
+				if (heightDim.unit === 1) childHeight = heightDim.value;
+				else if (heightDim.unit === 2 && !Number.isNaN(crossAxisSize)) childHeight = crossAxisSize * (heightDim.value / 100);
+				else {
+					const cached = child.getCachedLayout(child.flex.mainSize, NaN);
+					if (cached) {
+						incLayoutCacheHits();
+						_t?.cacheHit(_tn, child.flex.mainSize, NaN, cached.width, cached.height);
+						childWidth = cached.width;
+						childHeight = cached.height;
+					} else {
+						_t?.cacheMiss(_tn, child.flex.mainSize, NaN);
+						const savedW = child.layout.width;
+						const savedH = child.layout.height;
+						measureNode(child, child.flex.mainSize, NaN, direction);
+						childWidth = child.layout.width;
+						childHeight = child.layout.height;
+						child.layout.width = savedW;
+						child.layout.height = savedH;
+						_t?.measureSaveRestore(_tn, savedW, savedH, childWidth, childHeight);
+						child.setCachedLayout(child.flex.mainSize, NaN, childWidth, childHeight);
+					}
+				}
+				if (child.baselineFunc !== null) child.flex.baseline = topMargin + child.baselineFunc(childWidth, childHeight);
+				else child.flex.baseline = topMargin + childHeight;
+				maxChildHeight = Math.max(maxChildHeight, topMargin + childHeight + child.flex.marginB);
+				if (alignItemsIsBaseline || childStyle.alignSelf === 5) maxBaseline = Math.max(maxBaseline, child.flex.baseline);
+			}
+			baselineZoneHeight = Math.max(maxBaseline, maxChildHeight);
+		}
+		let cumulativeCrossOffset = 0;
+		const isWrapReverse = style.flexWrap === 2;
+		for (let lineIdx = 0; lineIdx < numLines; lineIdx++) {
+			_lineCrossOffsets[lineIdx] = cumulativeCrossOffset;
+			const lineChildren = _lineChildren[lineIdx];
+			const lineLength = lineChildren.length;
+			let maxLineCross = 0;
+			for (let i = 0; i < lineLength; i++) {
+				const child = lineChildren[i];
+				const childStyle = child.style;
+				const crossDim = isRow ? childStyle.height : childStyle.width;
+				const crossMarginStart = isRow ? child.flex.marginT : child.flex.marginL;
+				const crossMarginEnd = isRow ? child.flex.marginB : child.flex.marginR;
+				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 (child.hasMeasureFunc()) {
+					const crossMargin = crossMarginStart + crossMarginEnd;
+					const availCross = Number.isNaN(crossAxisSize) ? Infinity : crossAxisSize - crossMargin;
+					const childMainSize = child.flex.mainSize;
+					const mW = isRow ? childMainSize : availCross;
+					const mH = isRow ? availCross : childMainSize;
+					const mWMode = Number.isNaN(mW) ? 0 : 2;
+					const mHMode = Number.isNaN(mH) ? 0 : 2;
+					const measured = child.cachedMeasure(Number.isNaN(mW) ? Infinity : mW, mWMode, Number.isNaN(mH) ? Infinity : mH, mHMode);
+					if (measured) childCross = isRow ? measured.height : measured.width;
+				} else if (child.children.length > 0) {
+					const savedW = child.layout.width;
+					const savedH = child.layout.height;
+					measureNode(child, NaN, NaN, direction);
+					childCross = isRow ? child.layout.height : child.layout.width;
+					child.layout.width = savedW;
+					child.layout.height = savedH;
+				}
+				maxLineCross = Math.max(maxLineCross, childCross + crossMarginStart + crossMarginEnd);
+			}
+			const lineCrossSize = maxLineCross;
+			_lineCrossSizes[lineIdx] = lineCrossSize;
+			cumulativeCrossOffset += lineCrossSize + crossGap;
+		}
+		if (!Number.isNaN(crossAxisSize) && numLines > 0) {
+			const freeSpace = crossAxisSize - (cumulativeCrossOffset - crossGap);
+			switch (style.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 (freeSpace > 0 && numLines > 1) {
+						const gap = freeSpace / (numLines - 1);
+						for (let i = 1; i < numLines; i++) _lineCrossOffsets[i] += gap * i;
+					}
+					break;
+				case 7:
+					if (freeSpace > 0) {
+						const halfGap = freeSpace / (numLines * 2);
+						for (let i = 0; i < numLines; i++) _lineCrossOffsets[i] += halfGap + halfGap * 2 * i;
+					} else {
+						const centerOffset = freeSpace / 2;
+						for (let i = 0; i < numLines; i++) _lineCrossOffsets[i] += centerOffset;
+					}
+					break;
+				case 8:
+					if (freeSpace > 0 && numLines > 0) {
+						const gap = freeSpace / (numLines + 1);
+						for (let i = 0; i < numLines; i++) _lineCrossOffsets[i] += gap * (i + 1);
+					} else if (freeSpace < 0) {
+						const centerOffset = freeSpace / 2;
+						for (let i = 0; i < numLines; i++) _lineCrossOffsets[i] += centerOffset;
+					}
+					break;
+				case 4:
+					if (freeSpace > 0 && numLines > 0) {
+						const extraPerLine = freeSpace / numLines;
+						for (let i = 0; i < numLines; i++) {
+							_lineCrossSizes[i] += extraPerLine;
+							if (i > 0) _lineCrossOffsets[i] = _lineCrossOffsets[i - 1] + _lineCrossSizes[i - 1] + crossGap;
+						}
+					}
+					break;
+			}
+			if (isWrapReverse) {
+				let totalLineCrossSize = 0;
+				for (let i = 0; i < numLines; i++) totalLineCrossSize += _lineCrossSizes[i];
+				totalLineCrossSize += crossGap * (numLines - 1);
+				const crossStartOffset = crossAxisSize - totalLineCrossSize;
+				for (let i = 0; i < numLines; i++) _lineCrossOffsets[i] += crossStartOffset;
+			}
+		}
+		let savedLineCrossSizes = null;
+		let savedLineCrossOffsets = null;
+		let savedLineJustifyStarts = null;
+		let savedLineItemSpacings = null;
+		if (numLines > 1) {
+			savedLineCrossSizes = new Float64Array(numLines);
+			savedLineCrossOffsets = new Float64Array(numLines);
+			savedLineJustifyStarts = new Float64Array(numLines);
+			savedLineItemSpacings = new Float64Array(numLines);
+			for (let i = 0; i < numLines; i++) {
+				savedLineCrossSizes[i] = _lineCrossSizes[i];
+				savedLineCrossOffsets[i] = _lineCrossOffsets[i];
+				savedLineJustifyStarts[i] = _lineJustifyStarts[i];
+				savedLineItemSpacings[i] = _lineItemSpacings[i];
+			}
+		}
+		let effectiveMainAxisSize = mainAxisSize;
+		const mainIsAuto = isRow ? style.width.unit !== 1 && style.width.unit !== 2 : style.height.unit !== 1 && style.height.unit !== 2;
+		const totalGaps = relativeCount > 1 ? mainGap * (relativeCount - 1) : 0;
+		if (effectiveReverse && mainIsAuto) {
+			let totalContent = 0;
+			for (const child of node.children) {
+				if (child.flex.relativeIndex < 0) continue;
+				totalContent += child.flex.mainSize + child.flex.mainStartMarginValue + child.flex.mainEndMarginValue;
+			}
+			totalContent += totalGaps;
+			effectiveMainAxisSize = totalContent;
+		}
+		let mainPos = effectiveReverse ? effectiveMainAxisSize - startOffset : startOffset;
+		let currentLineIdx = -1;
+		let relIdx = 0;
+		let lineChildIdx = 0;
+		let currentLineLength = 0;
+		let currentItemSpacing = itemSpacing;
+		log.debug?.("positioning children: isRow=%s, startOffset=%d, relativeCount=%d, effectiveReverse=%s, numLines=%d", isRow, startOffset, relativeCount, effectiveReverse, numLines);
+		for (const child of node.children) {
+			if (child.flex.relativeIndex < 0) continue;
+			const cflex = child.flex;
+			const childStyle = child.style;
+			const childLineIdx = cflex.lineIndex;
+			if (childLineIdx !== currentLineIdx) {
+				currentLineIdx = childLineIdx;
+				lineChildIdx = 0;
+				currentLineLength = _lineChildren[childLineIdx].length;
+				const lineOffset = savedLineJustifyStarts ? savedLineJustifyStarts[childLineIdx] : _lineJustifyStarts[childLineIdx];
+				currentItemSpacing = savedLineItemSpacings ? savedLineItemSpacings[childLineIdx] : _lineItemSpacings[childLineIdx];
+				mainPos = effectiveReverse ? effectiveMainAxisSize - lineOffset : lineOffset;
+			}
+			const lineCrossOffset = savedLineCrossOffsets ? savedLineCrossOffsets[childLineIdx] : childLineIdx < MAX_FLEX_LINES ? _lineCrossOffsets[childLineIdx] : 0;
+			let childMarginLeft;
+			let childMarginTop;
+			let childMarginRight;
+			let childMarginBottom;
+			if (isRow) {
+				childMarginLeft = cflex.mainStartMarginAuto && !effectiveReverse ? cflex.mainStartMarginValue : cflex.mainEndMarginAuto && effectiveReverse ? cflex.mainEndMarginValue : cflex.marginL;
+				childMarginRight = cflex.mainEndMarginAuto && !effectiveReverse ? cflex.mainEndMarginValue : cflex.mainStartMarginAuto && effectiveReverse ? cflex.mainStartMarginValue : cflex.marginR;
+				childMarginTop = cflex.marginT;
+				childMarginBottom = cflex.marginB;
+			} else {
+				childMarginTop = cflex.mainStartMarginAuto && !isReverse ? cflex.mainStartMarginValue : cflex.mainEndMarginAuto && isReverse ? cflex.mainEndMarginValue : cflex.marginT;
+				childMarginBottom = cflex.mainEndMarginAuto && !isReverse ? cflex.mainEndMarginValue : cflex.mainStartMarginAuto && isReverse ? cflex.mainStartMarginValue : cflex.marginB;
+				childMarginLeft = cflex.marginL;
+				childMarginRight = cflex.marginR;
+			}
+			const childMainSize = cflex.mainSize;
+			let alignment = style.alignItems;
+			if (childStyle.alignSelf !== 0) alignment = childStyle.alignSelf;
+			const childCrossDimForAR = isRow ? childStyle.height : childStyle.width;
+			const childCrossIsAutoForAR = childCrossDimForAR.unit === 3 || childCrossDimForAR.unit === 0;
+			if (alignment === 4 && childStyle.alignSelf === 0 && !Number.isNaN(childStyle.aspectRatio) && childStyle.aspectRatio > 0 && childCrossIsAutoForAR) alignment = 1;
+			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 (crossDim.unit === 4 || crossDim.unit === 5) childCrossSize = NaN;
+			else if (parentHasDefiniteCross && alignment === 4) childCrossSize = (numLines > 1 ? savedLineCrossSizes ? savedLineCrossSizes[childLineIdx] : _lineCrossSizes[childLineIdx] : 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 hasDefiniteFlexBasis = childStyle.flexBasis.unit === 1 || childStyle.flexBasis.unit === 2;
+			const mainIsAutoChild = (mainDim.unit === 3 || mainDim.unit === 0) && !hasDefiniteFlexBasis;
+			const hasFlexGrow = cflex.flexGrow > 0;
+			const effectiveMainSize = childMainSize;
+			let childWidth = isRow ? effectiveMainSize : childCrossSize;
+			let childHeight = isRow ? childCrossSize : effectiveMainSize;
+			const shouldMeasure = child.hasMeasureFunc() && child.children.length === 0 && !hasFlexGrow;
+			if (shouldMeasure) {
+				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.cachedMeasure(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 = resolvePositionEdge(childStyle.position, 0, direction);
+				const relTopPos = childStyle.position[1];
+				const relRightPos = resolvePositionEdge(childStyle.position, 2, direction);
+				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 posRound = shouldMeasure ? Math.floor : Math.round;
+			const childLeft = posRound(fractionalLeft + posOffsetX);
+			const childTop = posRound(fractionalTop + posOffsetY);
+			const crossDimForLayoutCall = isRow ? childStyle.height : childStyle.width;
+			const crossIsAutoForLayoutCall = crossDimForLayoutCall.unit === 3 || crossDimForLayoutCall.unit === 0 || crossDimForLayoutCall.unit === 4 || crossDimForLayoutCall.unit === 5;
+			const mainIsPercentForLayoutCall = (isRow ? childStyle.width : childStyle.height).unit === 2;
+			const crossIsPercentForLayoutCall = crossDimForLayoutCall.unit === 2;
+			const flexDistChanged = child.flex.mainSize !== child.flex.baseSize;
+			const hasMeasureLeaf = child.hasMeasureFunc() && child.children.length === 0;
+			const crossIsFitContent = crossDimForLayoutCall.unit === 4 || crossDimForLayoutCall.unit === 5;
+			layoutNode(child, isRow && mainIsAutoChild && !hasFlexGrow && !flexDistChanged && !hasMeasureLeaf ? NaN : !isRow && crossIsAutoForLayoutCall && !parentHasDefiniteCross && !crossIsFitContent ? NaN : isRow && mainIsPercentForLayoutCall ? mainAxisSize : !isRow && crossIsPercentForLayoutCall ? crossAxisSize : !isRow && crossIsFitContent ? crossAxisSize : childWidth, !isRow && mainIsAutoChild && !hasFlexGrow && !flexDistChanged && !hasMeasureLeaf ? NaN : isRow && crossIsAutoForLayoutCall && !parentHasDefiniteCross && !crossIsFitContent ? NaN : !isRow && mainIsPercentForLayoutCall ? mainAxisSize : isRow && crossIsPercentForLayoutCall ? crossAxisSize : isRow && crossIsFitContent ? crossAxisSize : childHeight, childLeft, childTop, absChildLeft - childMarginLeft, absChildTop - childMarginTop, direction);
+			if (childWidth < childMinW) childWidth = childMinW;
+			if (childHeight < childMinH) childHeight = childMinH;
+			const hasMeasure = child.hasMeasureFunc() && child.children.length === 0;
+			const flexDistributionChangedSize = child.flex.mainSize !== child.flex.baseSize;
+			if (!mainIsAuto && !mainIsAutoChild || hasFlexGrow || hasMeasure || flexDistributionChangedSize) if (isRow) {
+				_t?.parentOverride(_tn, "main", child.layout.width, edgeBasedMainSize);
+				child.layout.width = edgeBasedMainSize;
+			} else {
+				_t?.parentOverride(_tn, "main", child.layout.height, edgeBasedMainSize);
+				child.layout.height = edgeBasedMainSize;
+			}
+			const crossDimForCheck = isRow ? childStyle.height : childStyle.width;
+			const crossDimIsFitContent = crossDimForCheck.unit === 4 || crossDimForCheck.unit === 5;
+			const crossIsAuto = crossDimForCheck.unit === 3 || crossDimForCheck.unit === 0 || crossDimIsFitContent;
+			const parentCrossIsAuto = !parentHasDefiniteCross;
+			const hasCrossMinMax = crossMinVal.unit !== 0 || crossMaxVal.unit !== 0;
+			if (!crossIsAuto || !crossDimIsFitContent && !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 crossStartIndex = isRow ? 1 : 0;
+			const crossEndIndex = isRow ? 3 : 2;
+			const hasAutoStartMargin = isEdgeAuto(childStyle.margin, crossStartIndex, style.flexDirection, direction);
+			const hasAutoEndMargin = isEdgeAuto(childStyle.margin, crossEndIndex, style.flexDirection, direction);
+			const availableCrossSpace = (hasBaselineAlignment && isRow && !alignItemsIsBaseline && alignment !== 5 && baselineZoneHeight > 0 ? baselineZoneHeight : crossAxisSize) - finalCrossSize - crossMargin;
+			if (hasAutoStartMargin && hasAutoEndMargin) crossOffset = Math.max(0, availableCrossSpace) / 2;
+			else if (hasAutoStartMargin) crossOffset = Math.max(0, availableCrossSpace);
+			else if (hasAutoEndMargin) crossOffset = 0;
+			else switch (alignment) {
+				case 3:
+					crossOffset = availableCrossSpace;
+					break;
+				case 2:
+					crossOffset = availableCrossSpace / 2;
+					break;
+				case 5:
+					if (isRow && hasBaselineAlignment) crossOffset = maxBaseline - child.flex.baseline;
+					break;
+			}
+			if (crossOffset !== 0) {
+				const crossRound = shouldMeasure ? Math.floor : Math.round;
+				if (isRow) child.layout.top += crossRound(crossOffset);
+				else child.layout.left += crossRound(crossOffset);
+			}
+			const fractionalMainSize = !mainIsAuto && !mainIsAutoChild || hasFlexGrow || hasMeasure || flexDistributionChangedSize ? constrainedMainSize : isRow ? child.layout.width : child.layout.height;
+			const totalMainMargin = cflex.mainStartMarginValue + cflex.mainEndMarginValue;
+			log.debug?.("  child %d: mainPos=%d -> top=%d (fractionalMainSize=%d, totalMainMargin=%d)", relIdx, mainPos, child.layout.top, fractionalMainSize, totalMainMargin);
+			if (effectiveReverse) {
+				mainPos -= fractionalMainSize + totalMainMargin;
+				if (lineChildIdx < currentLineLength - 1) mainPos -= currentItemSpacing;
+			} else {
+				mainPos += fractionalMainSize + totalMainMargin;
+				if (lineChildIdx < currentLineLength - 1) mainPos += currentItemSpacing;
+			}
+			relIdx++;
+			lineChildIdx++;
+		}
+		let actualUsedMain = 0;
+		for (const child of node.children) {
+			if (child.flex.relativeIndex < 0) continue;
+			const childMainSize = isRow ? child.layout.width : child.layout.height;
+			const totalMainMargin = child.flex.mainStartMarginValue + child.flex.mainEndMarginValue;
+			actualUsedMain += childMainSize + totalMainMargin;
+		}
+		actualUsedMain += totalGaps;
+		const hasAR = !Number.isNaN(aspectRatio) && aspectRatio > 0;
+		if (isRow && style.width.unit !== 1 && style.width.unit !== 2 && !hasAR) nodeWidth = actualUsedMain + innerLeft + innerRight;
+		if (!isRow && style.height.unit !== 1 && style.height.unit !== 2 && !hasAR) nodeHeight = actualUsedMain + innerTop + innerBottom;
+		let totalCrossSize = 0;
+		if (numLines > 1) {
+			for (let i = 0; i < numLines; i++) totalCrossSize += savedLineCrossSizes ? savedLineCrossSizes[i] : _lineCrossSizes[i];
+			totalCrossSize += crossGap * (numLines - 1);
+		} else for (const child of node.children) {
+			if (child.flex.relativeIndex < 0) continue;
+			const childCross = isRow ? child.layout.height : child.layout.width;
+			const childMargin = isRow ? resolveEdgeValue(child.style.margin, 1, style.flexDirection, contentWidth, direction) + resolveEdgeValue(child.style.margin, 3, style.flexDirection, contentWidth, direction) : resolveEdgeValue(child.style.margin, 0, style.flexDirection, contentWidth, direction) + resolveEdgeValue(child.style.margin, 2, style.flexDirection, contentWidth, direction);
+			totalCrossSize = Math.max(totalCrossSize, childCross + childMargin);
+		}
+		if (isRow && style.height.unit !== 1 && style.height.unit !== 2 && Number.isNaN(availableHeight) && !hasAR) nodeHeight = totalCrossSize + innerTop + innerBottom;
+		if (!isRow && style.width.unit !== 1 && style.width.unit !== 2 && Number.isNaN(availableWidth) && !hasAR) nodeWidth = totalCrossSize + innerLeft + innerRight;
+	}
+	if (isFitContentWidth && !Number.isNaN(nodeWidth) && !Number.isNaN(availableWidth)) {
+		const availForNode = availableWidth - marginLeft - marginRight;
+		if (availForNode >= 0 && nodeWidth > availForNode) nodeWidth = availForNode;
+	}
+	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;
+	if (Number.isNaN(crossAxisSize) && relativeCount > 0) {
+		const finalCross = isRow ? nodeHeight - innerTop - innerBottom : nodeWidth - innerLeft - innerRight;
+		if (!Number.isNaN(finalCross) && finalCross > 0) {
+			for (const child of node.children) {
+				if (child.flex.relativeIndex < 0) continue;
+				const cstyle = child.style;
+				let childAlign = style.alignItems;
+				if (cstyle.alignSelf !== 0) childAlign = cstyle.alignSelf;
+				const cCrossDim = isRow ? cstyle.height : cstyle.width;
+				const cCrossIsAuto = cCrossDim.unit === 3 || cCrossDim.unit === 0;
+				if (childAlign === 4 && cstyle.alignSelf === 0 && !Number.isNaN(cstyle.aspectRatio) && cstyle.aspectRatio > 0 && cCrossIsAuto) childAlign = 1;
+				if (childAlign !== 4) continue;
+				if (!cCrossIsAuto) continue;
+				const stretchedCross = finalCross - (isRow ? resolveEdgeValue(cstyle.margin, 1, style.flexDirection, contentWidth, direction) + resolveEdgeValue(cstyle.margin, 3, style.flexDirection, contentWidth, direction) : resolveEdgeValue(cstyle.margin, 0, style.flexDirection, contentWidth, direction) + resolveEdgeValue(cstyle.margin, 2, style.flexDirection, contentWidth, direction));
+				const currentCross = isRow ? child.layout.height : child.layout.width;
+				if (Math.round(stretchedCross) <= currentCross) continue;
+				const savedLeft = child.layout.left;
+				const savedTop = child.layout.top;
+				const cMarginL = resolveEdgeValue(cstyle.margin, 0, style.flexDirection, contentWidth, direction);
+				const cMarginT = resolveEdgeValue(cstyle.margin, 1, style.flexDirection, contentWidth, direction);
+				const cAbsX = absX + innerLeft + savedLeft - cMarginL;
+				const cAbsY = absY + innerTop + savedTop - cMarginT;
+				layoutNode(child, isRow ? child.layout.width : stretchedCross, isRow ? stretchedCross : child.layout.height, savedLeft, savedTop, cAbsX, cAbsY, direction);
+				child.layout.left = savedLeft;
+				child.layout.top = savedTop;
+				if (isRow) child.layout.height = Math.round(stretchedCross);
+				else child.layout.width = Math.round(stretchedCross);
+			}
+			if (Number.isNaN(crossAxisSize) && relativeCount > 0) {
+				const finalCross9c = isRow ? nodeHeight - innerTop - innerBottom : nodeWidth - innerLeft - innerRight;
+				if (!Number.isNaN(finalCross9c) && finalCross9c > 0) for (const child of node.children) {
+					if (child.flex.relativeIndex < 0) continue;
+					const cstyle = child.style;
+					let childAlign = style.alignItems;
+					if (cstyle.alignSelf !== 0) childAlign = cstyle.alignSelf;
+					const cCrossDim = isRow ? cstyle.height : cstyle.width;
+					const cCrossIsAuto = cCrossDim.unit === 3 || cCrossDim.unit === 0;
+					if (childAlign === 4 && cstyle.alignSelf === 0 && !Number.isNaN(cstyle.aspectRatio) && cstyle.aspectRatio > 0 && cCrossIsAuto) childAlign = 1;
+					const crossStartIdx = isRow ? 1 : 0;
+					const crossEndIdx = isRow ? 3 : 2;
+					const hasAutoStart = isEdgeAuto(cstyle.margin, crossStartIdx, style.flexDirection, direction);
+					const hasAutoEnd = isEdgeAuto(cstyle.margin, crossEndIdx, style.flexDirection, direction);
+					if (!(hasAutoStart || hasAutoEnd || childAlign === 2 || childAlign === 3)) continue;
+					const childCrossSize = isRow ? child.layout.height : child.layout.width;
+					const cCrossMargin = isRow ? resolveEdgeValue(cstyle.margin, 1, style.flexDirection, contentWidth, direction) + resolveEdgeValue(cstyle.margin, 3, style.flexDirection, contentWidth, direction) : resolveEdgeValue(cstyle.margin, 0, style.flexDirection, contentWidth, direction) + resolveEdgeValue(cstyle.margin, 2, style.flexDirection, contentWidth, direction);
+					const availSpace = finalCross9c - childCrossSize - cCrossMargin;
+					let crossOffset = 0;
+					if (hasAutoStart && hasAutoEnd) crossOffset = Math.max(0, availSpace) / 2;
+					else if (hasAutoStart) crossOffset = Math.max(0, availSpace);
+					else if (hasAutoEnd) crossOffset = 0;
+					else switch (childAlign) {
+						case 3:
+							crossOffset = availSpace;
+							break;
+						case 2:
+							crossOffset = availSpace / 2;
+							break;
+					}
+					if (isRow) {
+						if (Number.isNaN(child.layout.top)) {
+							const cMarginT = resolveEdgeValue(cstyle.margin, 1, style.flexDirection, contentWidth, direction);
+							child.layout.top = Math.round(cMarginT + crossOffset);
+						} else if (crossOffset !== 0) child.layout.top += Math.round(crossOffset);
+					} else if (Number.isNaN(child.layout.left)) {
+						const cMarginL = resolveEdgeValue(cstyle.margin, 0, style.flexDirection, contentWidth, direction);
+						child.layout.left = Math.round(cMarginL + crossOffset);
+					} else if (crossOffset !== 0) child.layout.left += Math.round(crossOffset);
+				}
+			}
+		}
+	}
+	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;
+	for (const child of node.children) {
+		if (child.style.display === 1) continue;
+		if (child.style.positionType !== 2) continue;
+		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 hasAutoMarginLeft = isEdgeAuto(childStyle.margin, 0, style.flexDirection, direction);
+		const hasAutoMarginRight = isEdgeAuto(childStyle.margin, 2, style.flexDirection, direction);
+		const hasAutoMarginTop = isEdgeAuto(childStyle.margin, 1, style.flexDirection, direction);
+		const hasAutoMarginBottom = isEdgeAuto(childStyle.margin, 3, style.flexDirection, direction);
+		const leftPos = resolvePositionEdge(childStyle.position, 0, direction);
+		const topPos = childStyle.position[1];
+		const rightPos = resolvePositionEdge(childStyle.position, 2, direction);
+		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) {
+			if (widthIsAuto) child.layout.width = Math.round(childAvailWidth);
+			else if (hasAutoMarginLeft || hasAutoMarginRight) {
+				const freeSpace = Math.max(0, contentW - leftOffset - rightOffset - childWidth);
+				if (hasAutoMarginLeft && hasAutoMarginRight) childX = leftOffset + freeSpace / 2;
+				else if (hasAutoMarginLeft) childX = leftOffset + freeSpace;
+			}
+		}
+		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) {
+			if (heightIsAuto) child.layout.height = Math.round(childAvailHeight);
+			else if (hasAutoMarginTop || hasAutoMarginBottom) {
+				const freeSpace = Math.max(0, contentH - topOffset - bottomOffset - childHeight);
+				if (hasAutoMarginTop && hasAutoMarginBottom) childY = topOffset + freeSpace / 2;
+				else if (hasAutoMarginTop) childY = topOffset + freeSpace;
+			}
+		}
+		child.layout.left = Math.round(absInnerLeft + childX);
+		child.layout.top = Math.round(absInnerTop + childY);
+	}
+	flex.lastAvailW = availableWidth;
+	flex.lastAvailH = availableHeight;
+	flex.lastOffsetX = offsetX;
+	flex.lastOffsetY = offsetY;
+	flex.lastAbsX = absX;
+	flex.lastAbsY = absY;
+	flex.lastDir = direction;
+	flex.layoutValid = true;
+	_t?.layoutExit(_tn, layout.width, layout.height);
+}
+//#endregion
+//#region src/node-zero.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;
+	_m0;
+	_m1;
+	_m2;
+	_m3;
+	_lc0;
+	_lc1;
+	_measureResult = {
+		width: 0,
+		height: 0
+	};
+	_layoutResult = {
+		width: 0,
+		height: 0
+	};
+	static measureCalls = 0;
+	static measureCacheHits = 0;
+	/**
+	* Reset measure statistics (call before calculateLayout).
+	*/
+	static resetMeasureStats() {
+		Node.measureCalls = 0;
+		Node.measureCacheHits = 0;
+	}
+	_layout = {
+		left: 0,
+		top: 0,
+		width: 0,
+		height: 0
+	};
+	_flex = {
+		mainSize: 0,
+		baseSize: 0,
+		mainMargin: 0,
+		flexGrow: 0,
+		flexShrink: 0,
+		minMain: 0,
+		maxMain: Infinity,
+		mainStartMarginAuto: false,
+		mainEndMarginAuto: false,
+		mainStartMarginValue: 0,
+		mainEndMarginValue: 0,
+		marginL: 0,
+		marginT: 0,
+		marginR: 0,
+		marginB: 0,
+		frozen: false,
+		lineIndex: 0,
+		relativeIndex: -1,
+		baseline: 0,
+		lastAvailW: NaN,
+		lastAvailH: NaN,
+		lastOffsetX: NaN,
+		lastOffsetY: NaN,
+		lastAbsX: NaN,
+		lastAbsY: NaN,
+		layoutValid: false,
+		lastDir: 0
+	};
+	_isDirty = true;
+	_hasNewLayout = false;
+	_lastCalcW = NaN;
+	_lastCalcH = NaN;
+	_lastCalcDir = 0;
+	/**
+	* 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;
+		const clampedIndex = Math.max(0, Math.min(index, this._children.length));
+		this._children.splice(clampedIndex, 0, child);
+		for (let i = clampedIndex + 1; i < this._children.length; i++) this._children[i]._flex.layoutValid = false;
+		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.
+	* Invalidates layout validity of remaining siblings whose positions may change.
+	*
+	* @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;
+			for (let i = index; i < this._children.length; i++) this._children[i]._flex.layoutValid = false;
+			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.
+	* Uses iterative traversal to avoid stack overflow on deep trees.
+	*/
+	freeRecursive() {
+		const nodes = [];
+		traversalStack.length = 0;
+		traversalStack.push(this);
+		while (traversalStack.length > 0) {
+			const current = traversalStack.pop();
+			nodes.push(current);
+			for (const child of current._children) traversalStack.push(child);
+		}
+		for (let i = nodes.length - 1; i >= 0; i--) nodes[i].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;
+	}
+	/**
+	* Call the measure function with caching.
+	* Uses a 4-entry numeric cache for fast lookup without allocations.
+	* Cache is cleared when markDirty() is called.
+	*
+	* @returns Measured dimensions or null if no measure function
+	*/
+	cachedMeasure(w, wm, h, hm) {
+		if (!this._measureFunc) return null;
+		Node.measureCalls++;
+		const m0 = this._m0;
+		if (m0 && m0.w === w && m0.wm === wm && m0.h === h && m0.hm === hm) {
+			Node.measureCacheHits++;
+			this._measureResult.width = m0.rw;
+			this._measureResult.height = m0.rh;
+			getTrace()?.measureCacheHit(0, w, h, m0.rw, m0.rh);
+			return this._measureResult;
+		}
+		const m1 = this._m1;
+		if (m1 && m1.w === w && m1.wm === wm && m1.h === h && m1.hm === hm) {
+			Node.measureCacheHits++;
+			this._measureResult.width = m1.rw;
+			this._measureResult.height = m1.rh;
+			getTrace()?.measureCacheHit(0, w, h, m1.rw, m1.rh);
+			return this._measureResult;
+		}
+		const m2 = this._m2;
+		if (m2 && m2.w === w && m2.wm === wm && m2.h === h && m2.hm === hm) {
+			Node.measureCacheHits++;
+			this._measureResult.width = m2.rw;
+			this._measureResult.height = m2.rh;
+			getTrace()?.measureCacheHit(0, w, h, m2.rw, m2.rh);
+			return this._measureResult;
+		}
+		const m3 = this._m3;
+		if (m3 && m3.w === w && m3.wm === wm && m3.h === h && m3.hm === hm) {
+			Node.measureCacheHits++;
+			this._measureResult.width = m3.rw;
+			this._measureResult.height = m3.rh;
+			getTrace()?.measureCacheHit(0, w, h, m3.rw, m3.rh);
+			return this._measureResult;
+		}
+		getTrace()?.measureCacheMiss(0, w, h);
+		const result = this._measureFunc(w, wm, h, hm);
+		if (this._m2) {
+			if (!this._m3) this._m3 = {
+				w: 0,
+				wm: 0,
+				h: 0,
+				hm: 0,
+				rw: 0,
+				rh: 0
+			};
+			this._m3.w = this._m2.w;
+			this._m3.wm = this._m2.wm;
+			this._m3.h = this._m2.h;
+			this._m3.hm = this._m2.hm;
+			this._m3.rw = this._m2.rw;
+			this._m3.rh = this._m2.rh;
+		}
+		if (this._m1) {
+			if (!this._m2) this._m2 = {
+				w: 0,
+				wm: 0,
+				h: 0,
+				hm: 0,
+				rw: 0,
+				rh: 0
+			};
+			this._m2.w = this._m1.w;
+			this._m2.wm = this._m1.wm;
+			this._m2.h = this._m1.h;
+			this._m2.hm = this._m1.hm;
+			this._m2.rw = this._m1.rw;
+			this._m2.rh = this._m1.rh;
+		}
+		if (this._m0) {
+			if (!this._m1) this._m1 = {
+				w: 0,
+				wm: 0,
+				h: 0,
+				hm: 0,
+				rw: 0,
+				rh: 0
+			};
+			this._m1.w = this._m0.w;
+			this._m1.wm = this._m0.wm;
+			this._m1.h = this._m0.h;
+			this._m1.hm = this._m0.hm;
+			this._m1.rw = this._m0.rw;
+			this._m1.rh = this._m0.rh;
+		}
+		if (!this._m0) this._m0 = {
+			w: 0,
+			wm: 0,
+			h: 0,
+			hm: 0,
+			rw: 0,
+			rh: 0
+		};
+		this._m0.w = w;
+		this._m0.wm = wm;
+		this._m0.h = h;
+		this._m0.hm = hm;
+		this._m0.rw = result.width;
+		this._m0.rh = result.height;
+		this._measureResult.width = result.width;
+		this._measureResult.height = result.height;
+		return this._measureResult;
+	}
+	/**
+	* Check layout cache for a previously computed size with same available dimensions.
+	* Returns cached (width, height) or null if not found.
+	*
+	* NaN dimensions are handled specially via Object.is (NaN === NaN is false, but Object.is(NaN, NaN) is true).
+	*/
+	getCachedLayout(availW, availH) {
+		if (this._isDirty) return null;
+		const lc0 = this._lc0;
+		if (lc0 && Object.is(lc0.availW, availW) && Object.is(lc0.availH, availH)) {
+			this._layoutResult.width = lc0.computedW;
+			this._layoutResult.height = lc0.computedH;
+			return this._layoutResult;
+		}
+		const lc1 = this._lc1;
+		if (lc1 && Object.is(lc1.availW, availW) && Object.is(lc1.availH, availH)) {
+			this._layoutResult.width = lc1.computedW;
+			this._layoutResult.height = lc1.computedH;
+			return this._layoutResult;
+		}
+		return null;
+	}
+	/**
+	* Cache a computed layout result for the given available dimensions.
+	* Zero-allocation: lazily allocates cache entries once, then reuses.
+	*/
+	setCachedLayout(availW, availH, computedW, computedH) {
+		if (this._lc0) {
+			if (!this._lc1) this._lc1 = {
+				availW: NaN,
+				availH: NaN,
+				computedW: 0,
+				computedH: 0
+			};
+			this._lc1.availW = this._lc0.availW;
+			this._lc1.availH = this._lc0.availH;
+			this._lc1.computedW = this._lc0.computedW;
+			this._lc1.computedH = this._lc0.computedH;
+		}
+		if (!this._lc0) this._lc0 = {
+			availW: 0,
+			availH: 0,
+			computedW: 0,
+			computedH: 0
+		};
+		this._lc0.availW = availW;
+		this._lc0.availH = availH;
+		this._lc0.computedW = computedW;
+		this._lc0.computedH = computedH;
+	}
+	/**
+	* Clear layout cache for this node and all descendants.
+	* Called at the start of each calculateLayout pass.
+	* Zero-allocation: invalidates entries (availW = NaN) rather than deallocating.
+	* Uses iterative traversal to avoid stack overflow on deep trees.
+	*/
+	resetLayoutCache() {
+		traversalStack.length = 0;
+		traversalStack.push(this);
+		while (traversalStack.length > 0) {
+			const node = traversalStack.pop();
+			if (node._lc0) node._lc0.availW = -1;
+			if (node._lc1) node._lc1.availW = -1;
+			for (const child of node._children) traversalStack.push(child);
+		}
+	}
+	/**
+	* 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.
+	* Uses iterative approach to avoid stack overflow on deep trees.
+	*/
+	markDirty() {
+		let current = this;
+		while (current !== null) {
+			current._m0 = current._m1 = current._m2 = current._m3 = void 0;
+			current._lc0 = current._lc1 = void 0;
+			if (current._isDirty) break;
+			current._isDirty = true;
+			current._flex.layoutValid = false;
+			current = current._parent;
+		}
+	}
+	/**
+	* 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) {
+		const availableWidth = width ?? NaN;
+		const availableHeight = height ?? NaN;
+		if (!this._isDirty && Object.is(this._lastCalcW, availableWidth) && Object.is(this._lastCalcH, availableHeight) && this._lastCalcDir === direction) {
+			log.debug?.("layout skip (not dirty, constraints unchanged)");
+			return;
+		}
+		this._lastCalcW = availableWidth;
+		this._lastCalcH = availableHeight;
+		this._lastCalcDir = direction;
+		const start = log.debug ? Date.now() : 0;
+		const nodeCount = log.debug ? countNodes(this) : 0;
+		Node.resetMeasureStats();
+		computeLayout(this, availableWidth, availableHeight, direction);
+		this._isDirty = false;
+		this._hasNewLayout = true;
+		markSubtreeLayoutSeen(this);
+		log.debug?.("layout: %dx%d, %d nodes in %dms (measure: calls=%d hits=%d)", width, height, nodeCount, Date.now() - start, Node.measureCalls, Node.measureCacheHits);
+	}
+	/**
+	* 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).
+	*
+	* @returns The right edge position in points
+	*/
+	getComputedRight() {
+		return this._layout.left + this._layout.width;
+	}
+	/**
+	* Get the computed bottom edge position after layout (top + height).
+	*
+	* @returns The bottom edge position in points
+	*/
+	getComputedBottom() {
+		return this._layout.top + this._layout.height;
+	}
+	/**
+	* Get the computed padding for a specific edge after layout.
+	* Returns the resolved padding value (percentage and logical edges resolved).
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, or EDGE_BOTTOM
+	* @returns Padding value in points
+	*/
+	getComputedPadding(edge) {
+		return getEdgeValue(this._style.padding, edge).value;
+	}
+	/**
+	* Get the computed margin for a specific edge after layout.
+	* Returns the resolved margin value (percentage and logical edges resolved).
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, or EDGE_BOTTOM
+	* @returns Margin value in points
+	*/
+	getComputedMargin(edge) {
+		return getEdgeValue(this._style.margin, edge).value;
+	}
+	/**
+	* Get the computed border width for a specific edge after layout.
+	*
+	* @param edge - EDGE_LEFT, EDGE_TOP, EDGE_RIGHT, or EDGE_BOTTOM
+	* @returns Border width in points
+	*/
+	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;
+	}
+	get flex() {
+		return this._flex;
+	}
+	/**
+	* 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 width to fit-content mode.
+	*
+	* CSS fit-content = min(max-content, max(min-content, available-width)).
+	* For terminals: min(max-content, available-width) since min-content
+	* floor is rarely relevant.
+	*
+	* The layout algorithm measures unconstrained content width (max-content),
+	* then clamps to the available width from the parent.
+	*/
+	setWidthFitContent() {
+		this._style.width = {
+			value: 0,
+			unit: 4
+		};
+		this.markDirty();
+	}
+	/**
+	* Set the width to snug-content mode.
+	*
+	* Like fit-content but signals that the consumer wants the tightest
+	* possible width (binary-search shrinkwrap). The layout engine treats
+	* this identically to fit-content for sizing; the consuming framework
+	* (e.g., silvery) can further tighten via its own binary search.
+	*/
+	setWidthSnugContent() {
+		this._style.width = {
+			value: 0,
+			unit: 5
+		};
+		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
+//#region src/monospace-measurer.ts
+const segmenter$1 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+/**
+* Create a monospace text measurement service.
+*
+* @param charWidth - Width of each character cell (default: 1 for terminal grids)
+* @param charHeight - Height of each character cell (default: 1 for terminal grids)
+*/
+function createMonospaceMeasurer(charWidth = 1, charHeight = 1) {
+	return { prepare(input) {
+		const { text } = input;
+		let graphemeCount = 0;
+		for (const _ of segmenter$1.segment(text)) graphemeCount++;
+		const totalWidth = graphemeCount * charWidth;
+		return {
+			intrinsicSizes() {
+				return {
+					minContentWidth: totalWidth,
+					maxContentWidth: totalWidth
+				};
+			},
+			layout(constraints) {
+				const width = constraints.maxWidth !== void 0 ? Math.min(totalWidth, constraints.maxWidth) : totalWidth;
+				return {
+					width,
+					height: charHeight,
+					lineCount: 1,
+					firstBaseline: charHeight,
+					lastBaseline: charHeight,
+					truncated: width < totalWidth
+				};
+			}
+		};
+	} };
+}
+/**
+* Plugin: add monospace text measurement to the engine.
+*
+* @param charWidth - Width per character cell (default: 1)
+* @param charHeight - Height per character cell (default: 1)
+*/
+function withMonospace(charWidth = 1, charHeight = 1) {
+	return (engine) => {
+		engine.textLayout = createMonospaceMeasurer(charWidth, charHeight);
+		return engine;
+	};
+}
+//#endregion
+//#region src/create-flexily.ts
+/**
+* Composable Flexily engine — createFlexily, createBareFlexily, pipe.
+*
+* FlexilyNode = Node + { setTextContent, getTextContent }.
+* No wrapper — text methods are mixed directly onto the Node instance.
+*/
+const DEFAULT_TEXT_STYLE = {
+	fontShorthand: "1ch monospace",
+	fontFamily: "monospace",
+	fontSize: 1,
+	fontWeight: 400,
+	fontStyle: "normal",
+	lineHeight: 1
+};
+/** Mix text content methods onto a Node. Returns the same node typed as FlexilyNode. */
+function mixTextContent(node, engine) {
+	let textContent = null;
+	let prepared = null;
+	const origSetMeasure = node.setMeasureFunc.bind(node);
+	const origUnsetMeasure = node.unsetMeasureFunc.bind(node);
+	const flexNode = node;
+	flexNode.setTextContent = function(text, style) {
+		if (!engine.textLayout) throw new Error("No TextLayoutService. Add a text plugin (withMonospace, withPretext, withTestMeasurer).");
+		textContent = text;
+		const resolved = {
+			...DEFAULT_TEXT_STYLE,
+			...style
+		};
+		prepared = engine.textLayout.prepare({
+			text,
+			style: resolved
+		});
+		const p = prepared;
+		origSetMeasure((width, widthMode) => {
+			if (widthMode === 0) {
+				const sizes = p.intrinsicSizes();
+				const result = p.layout({ maxWidth: sizes.maxContentWidth });
+				return {
+					width: result.width,
+					height: result.height
+				};
+			}
+			const result = p.layout({ maxWidth: width });
+			return {
+				width: widthMode === 2 ? Math.min(width, result.width) : width,
+				height: result.height
+			};
+		});
+	};
+	flexNode.getTextContent = function() {
+		return textContent;
+	};
+	flexNode.setMeasureFunc = function(fn) {
+		textContent = null;
+		prepared = null;
+		origSetMeasure(fn);
+	};
+	flexNode.unsetMeasureFunc = function() {
+		textContent = null;
+		prepared = null;
+		origUnsetMeasure();
+	};
+	return flexNode;
+}
+/**
+* Create a bare Flexily engine — no plugins, just nodes and layout.
+* Add plugins via pipe() for text measurement.
+*/
+function createBareFlexily() {
+	const engine = {
+		createNode() {
+			return mixTextContent(Node.create(), engine);
+		},
+		calculateLayout(root, width, height, direction) {
+			root.calculateLayout(width, height, direction ?? 1);
+		}
+	};
+	return engine;
+}
+/**
+* Apply plugins to an engine, left to right.
+*
+* @example
+* ```typescript
+* const flex = pipe(createBareFlexily(), withMonospace(), withTestMeasurer())
+* ```
+*/
+function pipe(engine, ...plugins) {
+	let result = engine;
+	for (const plugin of plugins) result = plugin(result);
+	return result;
+}
+/**
+* Create a batteries-included Flexily engine.
+*
+* Includes monospace text measurement (1 char = charWidth units).
+* For terminal UIs, the default charWidth/charHeight of 1 maps to terminal cells.
+*
+* @example
+* ```typescript
+* import { createFlexily } from "flexily"
+* const flex = createFlexily()
+* const node = flex.createNode()
+* node.setTextContent("Hello world")
+* flex.calculateLayout(node, 80, 24)
+* ```
+*/
+function createFlexily(options) {
+	const engine = createBareFlexily();
+	engine.textLayout = createMonospaceMeasurer(options?.charWidth ?? 1, options?.charHeight ?? 1);
+	return engine;
+}
+//#endregion
+//#region src/test-measurer.ts
+const segmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+/** Measure a single grapheme cluster with the deterministic width table. */
+function graphemeWidth(grapheme, fontSize) {
+	const cp = grapheme.codePointAt(0) ?? 0;
+	if (cp >= 127744 && cp <= 129791 || cp >= 9728 && cp <= 10175 || cp >= 65024 && cp <= 65039 || cp === 8205 || cp >= 129280 && cp <= 129535 || grapheme.length > 2) return fontSize * 1.8;
+	if (cp >= 19968 && cp <= 40959 || cp >= 12288 && cp <= 12351 || cp >= 12352 && cp <= 12447 || cp >= 12448 && cp <= 12543 || cp >= 44032 && cp <= 55215 || cp >= 65280 && cp <= 65519) return fontSize * 1;
+	return fontSize * .8;
+}
+function segmentText(text, fontSize) {
+	const segments = [];
+	let current = "";
+	let currentWidth = 0;
+	let isWhitespace = false;
+	for (const { segment } of segmenter.segment(text)) {
+		const isSpace = segment === " " || segment === "	";
+		if (segments.length === 0 && current === "") {
+			isWhitespace = isSpace;
+			current = segment;
+			currentWidth = isSpace ? fontSize * .8 : graphemeWidth(segment, fontSize);
+			continue;
+		}
+		if (isSpace !== isWhitespace) {
+			if (current) segments.push({
+				text: current,
+				width: currentWidth,
+				isWhitespace
+			});
+			current = segment;
+			currentWidth = isSpace ? fontSize * .8 : graphemeWidth(segment, fontSize);
+			isWhitespace = isSpace;
+		} else {
+			current += segment;
+			currentWidth += isSpace ? fontSize * .8 : graphemeWidth(segment, fontSize);
+		}
+	}
+	if (current) segments.push({
+		text: current,
+		width: currentWidth,
+		isWhitespace
+	});
+	return segments;
+}
+function measureString(text, fontSize) {
+	let width = 0;
+	for (const { segment } of segmenter.segment(text)) width += graphemeWidth(segment, fontSize);
+	return width;
+}
+/**
+* Create a deterministic text measurement service for testing.
+*
+* Uses fixed grapheme widths: Latin 0.8, CJK 1.0, emoji 1.8 (relative to fontSize).
+*/
+function createTestMeasurer() {
+	return { prepare(input) {
+		const { text, style } = input;
+		const fontSize = style.fontSize;
+		const lineHeight = style.lineHeight || fontSize;
+		const segments = segmentText(text, fontSize);
+		let maxContentWidth = 0;
+		let minContentWidth = 0;
+		for (const seg of segments) {
+			maxContentWidth += seg.width;
+			if (!seg.isWhitespace && seg.width > minContentWidth) minContentWidth = seg.width;
+		}
+		return {
+			intrinsicSizes() {
+				return {
+					minContentWidth,
+					maxContentWidth
+				};
+			},
+			layout(constraints, options) {
+				const maxWidth = constraints.maxWidth ?? Infinity;
+				const maxLines = constraints.maxLines ?? Infinity;
+				const wrap = constraints.wrap ?? "normal";
+				const includeLines = options?.includeLines ?? false;
+				if (wrap === "none" || maxWidth >= maxContentWidth) {
+					const truncated = maxLines < 1;
+					return {
+						width: constraints.shrinkWrap ? maxContentWidth : Math.min(maxWidth, maxContentWidth),
+						height: truncated ? 0 : lineHeight,
+						lineCount: truncated ? 0 : 1,
+						firstBaseline: lineHeight,
+						lastBaseline: lineHeight,
+						truncated: maxWidth < maxContentWidth,
+						lines: includeLines ? [{
+							text,
+							width: maxContentWidth,
+							startIndex: 0,
+							endIndex: text.length
+						}] : void 0
+					};
+				}
+				const lines = [];
+				let lineWidth = 0;
+				let lineText = "";
+				let lineStart = 0;
+				let charIndex = 0;
+				for (const seg of segments) {
+					if (seg.isWhitespace) {
+						if (lineText) {
+							lineWidth += seg.width;
+							lineText += seg.text;
+						}
+						charIndex += seg.text.length;
+						continue;
+					}
+					if (lineWidth + seg.width > maxWidth && lineText) {
+						const trimmed = lineText.trimEnd();
+						lines.push({
+							text: trimmed,
+							width: measureString(trimmed, fontSize),
+							startIndex: lineStart,
+							endIndex: charIndex
+						});
+						if (lines.length >= maxLines) break;
+						lineText = seg.text;
+						lineWidth = seg.width;
+						lineStart = charIndex;
+					} else {
+						lineText += seg.text;
+						lineWidth += seg.width;
+					}
+					charIndex += seg.text.length;
+				}
+				if (lineText && lines.length < maxLines) {
+					const trimmed = lineText.trimEnd();
+					lines.push({
+						text: trimmed,
+						width: measureString(trimmed, fontSize),
+						startIndex: lineStart,
+						endIndex: charIndex
+					});
+				}
+				const lineCount = lines.length;
+				const height = lineCount * lineHeight;
+				const widestLine = lines.reduce((max, l) => Math.max(max, l.width), 0);
+				return {
+					width: constraints.shrinkWrap ? widestLine : Math.min(maxWidth, widestLine),
+					height,
+					lineCount,
+					firstBaseline: lineHeight,
+					lastBaseline: lineCount > 0 ? (lineCount - 1) * lineHeight + lineHeight : lineHeight,
+					truncated: lines.length >= maxLines && charIndex < text.length,
+					lines: includeLines ? lines : void 0
+				};
+			}
+		};
+	} };
+}
+/**
+* Plugin: add deterministic test text measurement to the engine.
+*/
+function withTestMeasurer() {
+	return (engine) => {
+		engine.textLayout = createTestMeasurer();
+		return engine;
+	};
+}
+//#endregion
+//#region src/pretext-measurer.ts
+/**
+* Create a Pretext-based text measurement service.
+*
+* @param pretext - The pretext module (import from "@chenglou/pretext")
+*/
+function createPretextMeasurer(pretext) {
+	return { prepare(input) {
+		const { text, style } = input;
+		const pretextPrepared = pretext.prepare(text, style.fontShorthand);
+		const lineHeight = style.lineHeight || style.fontSize;
+		let cachedIntrinsic = null;
+		return {
+			intrinsicSizes() {
+				if (cachedIntrinsic) return cachedIntrinsic;
+				const unconstrained = pretextPrepared.layout(Infinity, lineHeight);
+				cachedIntrinsic = {
+					minContentWidth: pretextPrepared.layout(0, lineHeight).width,
+					maxContentWidth: unconstrained.width
+				};
+				return cachedIntrinsic;
+			},
+			layout(constraints) {
+				const maxWidth = constraints.maxWidth ?? Infinity;
+				const result = pretextPrepared.layout(maxWidth, lineHeight);
+				const lineCount = result.lines?.length ?? 1;
+				return {
+					width: constraints.shrinkWrap ? result.width : Math.min(maxWidth, result.width),
+					height: result.height,
+					lineCount,
+					firstBaseline: lineHeight,
+					lastBaseline: lineCount > 0 ? (lineCount - 1) * lineHeight + lineHeight : lineHeight,
+					truncated: false
+				};
+			}
+		};
+	} };
+}
+/**
+* Plugin: add Pretext-based proportional text measurement.
+*
+* @param pretext - The pretext module (import from "@chenglou/pretext")
+*/
+function withPretext(pretext) {
+	return (engine) => {
+		engine.textLayout = createPretextMeasurer(pretext);
+		return engine;
+	};
+}
+//#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_FIT_CONTENT, UNIT_PERCENT, UNIT_POINT, UNIT_SNUG_CONTENT, UNIT_UNDEFINED, WRAP_NO_WRAP, WRAP_WRAP, WRAP_WRAP_REVERSE, createBareFlexily, createDefaultStyle, createFlexily, createMonospaceMeasurer, createPretextMeasurer, createTestMeasurer, createValue, layoutCacheHits, layoutNodeCalls, layoutPositioningCalls, layoutSizingCalls, pipe, resetLayoutStats, withMonospace, withPretext, withTestMeasurer };
+
+//# sourceMappingURL=index.mjs.map