@silvery/examples 0.17.3 → 0.17.5

package/dist/flexily-zero-adapter-ByVzLTFP.mjs

@@ -0,0 +1,3374 @@
+import { o as __toESM } from "./chunk-BSw8zbkd.mjs";
+//#region ../../flexily/src/utils.ts
+/**
+* Flexily Utility Functions
+*
+* Helper functions for edge value manipulation and value resolution.
+*/
+/**
+* Shared traversal stack for iterative tree operations.
+* Avoids recursion (prevents stack overflow on deep trees) and avoids
+* allocation during layout passes.
+*/
+const traversalStack = [];
+/**
+* Set a value on an edge array (supports all edge types including logical START/END).
+*/
+function setEdgeValue(arr, edge, value, unit) {
+	const v = {
+		value,
+		unit
+	};
+	switch (edge) {
+		case 0:
+			arr[0] = v;
+			break;
+		case 1:
+			arr[1] = v;
+			break;
+		case 2:
+			arr[2] = v;
+			break;
+		case 3:
+			arr[3] = v;
+			break;
+		case 6:
+			arr[0] = v;
+			arr[2] = v;
+			break;
+		case 7:
+			arr[1] = v;
+			arr[3] = v;
+			break;
+		case 8:
+			arr[0] = v;
+			arr[1] = v;
+			arr[2] = v;
+			arr[3] = v;
+			break;
+		case 4:
+			arr[4] = v;
+			break;
+		case 5:
+			arr[5] = v;
+			break;
+	}
+}
+/**
+* Set a border value on an edge array.
+*/
+function setEdgeBorder(arr, edge, value) {
+	switch (edge) {
+		case 0:
+			arr[0] = value;
+			break;
+		case 1:
+			arr[1] = value;
+			break;
+		case 2:
+			arr[2] = value;
+			break;
+		case 3:
+			arr[3] = value;
+			break;
+		case 6:
+			arr[0] = value;
+			arr[2] = value;
+			break;
+		case 7:
+			arr[1] = value;
+			arr[3] = value;
+			break;
+		case 8:
+			arr[0] = value;
+			arr[1] = value;
+			arr[2] = value;
+			arr[3] = value;
+			break;
+		case 4:
+			arr[4] = value;
+			break;
+		case 5:
+			arr[5] = value;
+			break;
+	}
+}
+/**
+* Get a value from an edge array.
+*/
+function getEdgeValue(arr, edge) {
+	switch (edge) {
+		case 0: return arr[0];
+		case 1: return arr[1];
+		case 2: return arr[2];
+		case 3: return arr[3];
+		case 4: return arr[4];
+		case 5: return arr[5];
+		default: return arr[0];
+	}
+}
+/**
+* Get a border value from an edge array.
+*/
+function getEdgeBorderValue(arr, edge) {
+	switch (edge) {
+		case 0: return arr[0];
+		case 1: return arr[1];
+		case 2: return arr[2];
+		case 3: return arr[3];
+		case 4: return arr[4];
+		case 5: return arr[5];
+		default: return arr[0];
+	}
+}
+/**
+* Resolve a value (point or percent) to an absolute number.
+*/
+function resolveValue(value, availableSize) {
+	switch (value.unit) {
+		case 1: return value.value;
+		case 2:
+			if (Number.isNaN(availableSize)) return 0;
+			return availableSize * (value.value / 100);
+		default: return 0;
+	}
+}
+/**
+* Apply min/max constraints to a size.
+*
+* CSS behavior:
+* - min: Floor constraint. Does NOT affect children's layout — the container expands
+*   after shrink-wrap. When size is NaN (auto-sized), min is NOT applied here;
+*   the post-shrink-wrap applyMinMax call (Phase 9) handles it.
+* - max: Ceiling constraint. DOES affect children's layout — content wraps/clips
+*   within the max. When size is NaN (auto-sized), max constrains the container
+*   so children are laid out within the max bound.
+*
+* Percent constraints that can't resolve (available is NaN) are skipped entirely,
+* since resolveValue returns 0 for percent-against-NaN, which would incorrectly
+* clamp sizes to 0.
+*/
+function applyMinMax(size, min, max, available) {
+	let result = size;
+	if (max.unit !== 0) if (max.unit === 2 && Number.isNaN(available)) {} else {
+		const maxValue = resolveValue(max, available);
+		if (!Number.isNaN(maxValue)) if (Number.isNaN(result)) {
+			if (maxValue !== Infinity) result = maxValue;
+		} else result = Math.min(result, maxValue);
+	}
+	if (min.unit !== 0) if (min.unit === 2 && Number.isNaN(available)) {} else {
+		const minValue = resolveValue(min, available);
+		if (!Number.isNaN(minValue)) {
+			if (!Number.isNaN(result)) result = Math.max(result, minValue);
+		}
+	}
+	return result;
+}
+//#endregion
+//#region ../../flexily/src/logger.ts
+let _logger = null;
+async function createFallbackLogger(namespace) {
+	try {
+		const { default: createDebug } = await import("./src-9ZhfQyzD.mjs").then((m) => /* @__PURE__ */ __toESM(m.default, 1));
+		const debug = createDebug(namespace);
+		return { debug: debug.enabled ? debug : void 0 };
+	} catch {
+		return { debug: void 0 };
+	}
+}
+async function detectLogger(namespace) {
+	try {
+		const { createLogger } = await import("loggily");
+		const logger = createLogger(namespace);
+		if (logger.debug) {
+			const originalDebug = logger.debug;
+			return { debug: (msg, ...args) => {
+				let i = 0;
+				originalDebug(msg.replace(/%[sdOo]/g, () => {
+					const arg = args[i++];
+					if (arg === void 0) return "";
+					if (arg === null) return "null";
+					if (typeof arg === "object") return JSON.stringify(arg);
+					return String(arg);
+				}));
+			} };
+		}
+		return { debug: void 0 };
+	} catch {
+		return createFallbackLogger(namespace);
+	}
+}
+_logger = await detectLogger("flexily:layout");
+/** Logger instance - use with optional chaining: `log.debug?.('message')` */
+const log = { get debug() {
+	return _logger?.debug;
+} };
+//#endregion
+//#region ../../flexily/src/trace.ts
+let _trace = null;
+/** Get the current trace recorder (null when tracing is disabled). */
+function getTrace() {
+	return _trace;
+}
+//#endregion
+//#region ../../flexily/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 ../../flexily/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 ../../flexily/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 ../../flexily/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 ../../flexily/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 ../../flexily/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;
+	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 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);
+		layout.left = Math.round(offsetX + marginLeft);
+		layout.top = Math.round(offsetY + marginTop);
+		return;
+	}
+	if (node.children.length === 0) {
+		if (Number.isNaN(nodeWidth)) nodeWidth = innerLeft + innerRight;
+		if (Number.isNaN(nodeHeight)) nodeHeight = innerTop + innerBottom;
+		layout.width = Math.round(nodeWidth);
+		layout.height = Math.round(nodeHeight);
+		layout.left = Math.round(offsetX + marginLeft);
+		layout.top = Math.round(offsetY + marginTop);
+		return;
+	}
+	const 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);
+		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 (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;
+			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;
+			layoutNode(child, isRow && mainIsAutoChild && !hasFlexGrow && !flexDistChanged && !hasMeasureLeaf ? NaN : !isRow && crossIsAutoForLayoutCall && !parentHasDefiniteCross ? NaN : isRow && mainIsPercentForLayoutCall ? mainAxisSize : !isRow && crossIsPercentForLayoutCall ? crossAxisSize : childWidth, !isRow && mainIsAutoChild && !hasFlexGrow && !flexDistChanged && !hasMeasureLeaf ? NaN : isRow && crossIsAutoForLayoutCall && !parentHasDefiniteCross ? NaN : !isRow && mainIsPercentForLayoutCall ? mainAxisSize : isRow && crossIsPercentForLayoutCall ? 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 crossIsAuto = crossDimForCheck.unit === 3 || crossDimForCheck.unit === 0;
+			const parentCrossIsAuto = !parentHasDefiniteCross;
+			const hasCrossMinMax = crossMinVal.unit !== 0 || crossMaxVal.unit !== 0;
+			if (!crossIsAuto || !parentCrossIsAuto && alignment === 4 || hasCrossMinMax && !Number.isNaN(childCrossSize)) if (isRow) child.layout.height = Math.round(childHeight);
+			else child.layout.width = Math.round(childWidth);
+			child.layout.left = childLeft;
+			child.layout.top = childTop;
+			childWidth = child.layout.width;
+			childHeight = child.layout.height;
+			const finalCrossSize = isRow ? child.layout.height : child.layout.width;
+			let crossOffset = 0;
+			const 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;
+	}
+	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 ../../flexily/src/types.ts
+/**
+* Create a default Value (undefined).
+*/
+function createValue(value = 0, unit = 0) {
+	return {
+		value,
+		unit
+	};
+}
+/**
+* Create default style.
+*
+* Comments indicate where Yoga and CSS defaults differ.
+* Flexily follows Yoga defaults for API compatibility.
+*/
+function createDefaultStyle() {
+	return {
+		display: 0,
+		positionType: 1,
+		position: [
+			createValue(),
+			createValue(),
+			createValue(),
+			createValue(),
+			createValue(),
+			createValue()
+		],
+		flexDirection: 2,
+		flexWrap: 0,
+		flexGrow: 0,
+		flexShrink: 0,
+		flexBasis: createValue(0, 3),
+		alignItems: 4,
+		alignSelf: 0,
+		alignContent: 1,
+		justifyContent: 0,
+		width: createValue(0, 3),
+		height: createValue(0, 3),
+		minWidth: createValue(),
+		minHeight: createValue(),
+		maxWidth: createValue(),
+		maxHeight: createValue(),
+		aspectRatio: NaN,
+		margin: [
+			createValue(),
+			createValue(),
+			createValue(),
+			createValue(),
+			createValue(),
+			createValue()
+		],
+		padding: [
+			createValue(),
+			createValue(),
+			createValue(),
+			createValue(),
+			createValue(),
+			createValue()
+		],
+		border: [
+			0,
+			0,
+			0,
+			0,
+			NaN,
+			NaN
+		],
+		gap: [0, 0],
+		overflow: 0
+	};
+}
+//#endregion
+//#region ../../flexily/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 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];
+	}
+};
+new Intl.Segmenter(void 0, { granularity: "grapheme" });
+new Intl.Segmenter(void 0, { granularity: "grapheme" });
+//#endregion
+//#region ../packages/ag-term/src/adapters/flexily-zero-adapter.ts
+/**
+* Flexily Layout Engine Adapter
+*
+* Wraps Flexily to implement the LayoutEngine interface.
+* Uses the default zero-allocation algorithm from flexily.
+*/
+/**
+* Wraps a Flexily zero-alloc node to implement LayoutNode interface.
+* Since Flexily already has a Yoga-compatible API, this is mostly delegation.
+*/
+var FlexilyZeroNodeAdapter = class {
+	node;
+	constructor(node) {
+		this.node = node;
+	}
+	/** Get the underlying Flexily node (for tree operations) */
+	getFlexilyNode() {
+		return this.node;
+	}
+	insertChild(child, index) {
+		const flexilyChild = child.getFlexilyNode();
+		this.node.insertChild(flexilyChild, index);
+	}
+	removeChild(child) {
+		const flexilyChild = child.getFlexilyNode();
+		this.node.removeChild(flexilyChild);
+	}
+	free() {
+		this.node.free();
+	}
+	setMeasureFunc(measureFunc) {
+		this.node.setMeasureFunc((width, widthMode, height, heightMode) => {
+			return measureFunc(width, this.measureModeToString(widthMode), height, this.measureModeToString(heightMode));
+		});
+	}
+	markDirty() {
+		this.node.markDirty();
+	}
+	measureModeToString(mode) {
+		if (mode === 1) return "exactly";
+		if (mode === 2) return "at-most";
+		return "undefined";
+	}
+	setWidth(value) {
+		this.node.setWidth(value);
+	}
+	setWidthPercent(value) {
+		this.node.setWidthPercent(value);
+	}
+	setWidthAuto() {
+		this.node.setWidthAuto();
+	}
+	setHeight(value) {
+		this.node.setHeight(value);
+	}
+	setHeightPercent(value) {
+		this.node.setHeightPercent(value);
+	}
+	setHeightAuto() {
+		this.node.setHeightAuto();
+	}
+	setMinWidth(value) {
+		this.node.setMinWidth(value);
+	}
+	setMinWidthPercent(value) {
+		this.node.setMinWidthPercent(value);
+	}
+	setMinHeight(value) {
+		this.node.setMinHeight(value);
+	}
+	setMinHeightPercent(value) {
+		this.node.setMinHeightPercent(value);
+	}
+	setMaxWidth(value) {
+		this.node.setMaxWidth(value);
+	}
+	setMaxWidthPercent(value) {
+		this.node.setMaxWidthPercent(value);
+	}
+	setMaxHeight(value) {
+		this.node.setMaxHeight(value);
+	}
+	setMaxHeightPercent(value) {
+		this.node.setMaxHeightPercent(value);
+	}
+	setFlexGrow(value) {
+		this.node.setFlexGrow(value);
+	}
+	setFlexShrink(value) {
+		this.node.setFlexShrink(value);
+	}
+	setFlexBasis(value) {
+		this.node.setFlexBasis(value);
+	}
+	setFlexBasisPercent(value) {
+		this.node.setFlexBasisPercent(value);
+	}
+	setFlexBasisAuto() {
+		this.node.setFlexBasisAuto();
+	}
+	setFlexDirection(direction) {
+		this.node.setFlexDirection(direction);
+	}
+	setFlexWrap(wrap) {
+		this.node.setFlexWrap(wrap);
+	}
+	setAlignItems(align) {
+		this.node.setAlignItems(align);
+	}
+	setAlignSelf(align) {
+		this.node.setAlignSelf(align);
+	}
+	setAlignContent(align) {
+		this.node.setAlignContent(align);
+	}
+	setJustifyContent(justify) {
+		this.node.setJustifyContent(justify);
+	}
+	setPadding(edge, value) {
+		this.node.setPadding(edge, value);
+	}
+	setMargin(edge, value) {
+		this.node.setMargin(edge, value);
+	}
+	setBorder(edge, value) {
+		this.node.setBorder(edge, value);
+	}
+	setGap(gutter, value) {
+		this.node.setGap(gutter, value);
+	}
+	setDisplay(display) {
+		this.node.setDisplay(display);
+	}
+	setPositionType(positionType) {
+		this.node.setPositionType(positionType);
+	}
+	setPosition(edge, value) {
+		this.node.setPosition(edge, value);
+	}
+	setPositionPercent(edge, value) {
+		this.node.setPositionPercent(edge, value);
+	}
+	setOverflow(overflow) {
+		this.node.setOverflow(overflow);
+	}
+	setAspectRatio(value) {
+		this.node.setAspectRatio(value);
+	}
+	calculateLayout(width, height, direction) {
+		this.node.calculateLayout(width, height, direction ?? 1);
+	}
+	getComputedLeft() {
+		return this.node.getComputedLeft();
+	}
+	getComputedTop() {
+		return this.node.getComputedTop();
+	}
+	getComputedWidth() {
+		return this.node.getComputedWidth();
+	}
+	getComputedHeight() {
+		return this.node.getComputedHeight();
+	}
+};
+/**
+* Layout engine implementation using Flexily zero-allocation variant.
+* Optimized for high-frequency layout with reduced GC pressure.
+*/
+var FlexilyZeroLayoutEngine = class {
+	_constants = {
+		FLEX_DIRECTION_COLUMN: 0,
+		FLEX_DIRECTION_COLUMN_REVERSE: 1,
+		FLEX_DIRECTION_ROW: 2,
+		FLEX_DIRECTION_ROW_REVERSE: 3,
+		WRAP_NO_WRAP: 0,
+		WRAP_WRAP: 1,
+		WRAP_WRAP_REVERSE: 2,
+		ALIGN_AUTO: 0,
+		ALIGN_FLEX_START: 1,
+		ALIGN_CENTER: 2,
+		ALIGN_FLEX_END: 3,
+		ALIGN_STRETCH: 4,
+		ALIGN_BASELINE: 5,
+		ALIGN_SPACE_BETWEEN: 6,
+		ALIGN_SPACE_AROUND: 7,
+		ALIGN_SPACE_EVENLY: 8,
+		JUSTIFY_FLEX_START: 0,
+		JUSTIFY_CENTER: 1,
+		JUSTIFY_FLEX_END: 2,
+		JUSTIFY_SPACE_BETWEEN: 3,
+		JUSTIFY_SPACE_AROUND: 4,
+		JUSTIFY_SPACE_EVENLY: 5,
+		EDGE_LEFT: 0,
+		EDGE_TOP: 1,
+		EDGE_RIGHT: 2,
+		EDGE_BOTTOM: 3,
+		EDGE_HORIZONTAL: 6,
+		EDGE_VERTICAL: 7,
+		EDGE_ALL: 8,
+		GUTTER_COLUMN: 0,
+		GUTTER_ROW: 1,
+		GUTTER_ALL: 2,
+		DISPLAY_FLEX: 0,
+		DISPLAY_NONE: 1,
+		POSITION_TYPE_STATIC: 0,
+		POSITION_TYPE_RELATIVE: 1,
+		POSITION_TYPE_ABSOLUTE: 2,
+		OVERFLOW_VISIBLE: 0,
+		OVERFLOW_HIDDEN: 1,
+		OVERFLOW_SCROLL: 2,
+		DIRECTION_LTR: 1,
+		MEASURE_MODE_UNDEFINED: 0,
+		MEASURE_MODE_EXACTLY: 1,
+		MEASURE_MODE_AT_MOST: 2
+	};
+	createNode() {
+		return new FlexilyZeroNodeAdapter(Node.create());
+	}
+	get constants() {
+		return this._constants;
+	}
+	get name() {
+		return "flexily-zero";
+	}
+};
+/**
+* Create a Flexily zero-allocation layout engine.
+* Unlike Yoga, Flexily doesn't require async initialization.
+*/
+function createFlexilyZeroEngine() {
+	return new FlexilyZeroLayoutEngine();
+}
+//#endregion
+export { createFlexilyZeroEngine };