@alchemy.run/sigil 0.0.0-alpha.1 → 0.0.0-alpha.2

package/dist/yoga-5jKhYCJC.js

@@ -0,0 +1,3465 @@
+//#region src/yoga/generated/YGEnums.ts
+const Align = {
+	Auto: 0,
+	FlexStart: 1,
+	Center: 2,
+	FlexEnd: 3,
+	Stretch: 4,
+	Baseline: 5,
+	SpaceBetween: 6,
+	SpaceAround: 7,
+	SpaceEvenly: 8,
+	Start: 9,
+	End: 10
+};
+const BoxSizing = {
+	BorderBox: 0,
+	ContentBox: 1
+};
+const Dimension = {
+	Width: 0,
+	Height: 1
+};
+const Direction = {
+	Inherit: 0,
+	LTR: 1,
+	RTL: 2
+};
+const Display = {
+	Flex: 0,
+	None: 1,
+	Contents: 2,
+	Grid: 3
+};
+const Edge = {
+	Left: 0,
+	Top: 1,
+	Right: 2,
+	Bottom: 3,
+	Start: 4,
+	End: 5,
+	Horizontal: 6,
+	Vertical: 7,
+	All: 8
+};
+const Errata = {
+	None: 0,
+	StretchFlexBasis: 1,
+	AbsolutePositionWithoutInsetsExcludesPadding: 2,
+	AbsolutePercentAgainstInnerSize: 4,
+	MinSizeUndefinedInsteadOfAuto: 8,
+	All: 2147483647,
+	Classic: 2147483646
+};
+const ExperimentalFeature = {
+	WebFlexBasis: 0,
+	FixFlexBasisFitContent: 1
+};
+const FlexDirection = {
+	Column: 0,
+	ColumnReverse: 1,
+	Row: 2,
+	RowReverse: 3
+};
+const GridTrackType = {
+	Auto: 0,
+	Points: 1,
+	Percent: 2,
+	Fr: 3,
+	Minmax: 4
+};
+const Gutter = {
+	Column: 0,
+	Row: 1,
+	All: 2
+};
+const Justify = {
+	Auto: 0,
+	FlexStart: 1,
+	Center: 2,
+	FlexEnd: 3,
+	SpaceBetween: 4,
+	SpaceAround: 5,
+	SpaceEvenly: 6,
+	Stretch: 7,
+	Start: 8,
+	End: 9
+};
+const LogLevel = {
+	Error: 0,
+	Warn: 1,
+	Info: 2,
+	Debug: 3,
+	Verbose: 4,
+	Fatal: 5
+};
+const MeasureMode = {
+	Undefined: 0,
+	Exactly: 1,
+	AtMost: 2
+};
+const NodeType = {
+	Default: 0,
+	Text: 1
+};
+const Overflow = {
+	Visible: 0,
+	Hidden: 1,
+	Scroll: 2
+};
+const PositionType = {
+	Static: 0,
+	Relative: 1,
+	Absolute: 2
+};
+const Unit = {
+	Undefined: 0,
+	Point: 1,
+	Percent: 2,
+	Auto: 3,
+	MaxContent: 4,
+	FitContent: 5,
+	Stretch: 6
+};
+const Wrap = {
+	NoWrap: 0,
+	Wrap: 1,
+	WrapReverse: 2
+};
+const constants = {
+	ALIGN_AUTO: Align.Auto,
+	ALIGN_FLEX_START: Align.FlexStart,
+	ALIGN_CENTER: Align.Center,
+	ALIGN_FLEX_END: Align.FlexEnd,
+	ALIGN_STRETCH: Align.Stretch,
+	ALIGN_BASELINE: Align.Baseline,
+	ALIGN_SPACE_BETWEEN: Align.SpaceBetween,
+	ALIGN_SPACE_AROUND: Align.SpaceAround,
+	ALIGN_SPACE_EVENLY: Align.SpaceEvenly,
+	ALIGN_START: Align.Start,
+	ALIGN_END: Align.End,
+	BOX_SIZING_BORDER_BOX: BoxSizing.BorderBox,
+	BOX_SIZING_CONTENT_BOX: BoxSizing.ContentBox,
+	DIMENSION_WIDTH: Dimension.Width,
+	DIMENSION_HEIGHT: Dimension.Height,
+	DIRECTION_INHERIT: Direction.Inherit,
+	DIRECTION_LTR: Direction.LTR,
+	DIRECTION_RTL: Direction.RTL,
+	DISPLAY_FLEX: Display.Flex,
+	DISPLAY_NONE: Display.None,
+	DISPLAY_CONTENTS: Display.Contents,
+	DISPLAY_GRID: Display.Grid,
+	EDGE_LEFT: Edge.Left,
+	EDGE_TOP: Edge.Top,
+	EDGE_RIGHT: Edge.Right,
+	EDGE_BOTTOM: Edge.Bottom,
+	EDGE_START: Edge.Start,
+	EDGE_END: Edge.End,
+	EDGE_HORIZONTAL: Edge.Horizontal,
+	EDGE_VERTICAL: Edge.Vertical,
+	EDGE_ALL: Edge.All,
+	ERRATA_NONE: Errata.None,
+	ERRATA_STRETCH_FLEX_BASIS: Errata.StretchFlexBasis,
+	ERRATA_ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING: Errata.AbsolutePositionWithoutInsetsExcludesPadding,
+	ERRATA_ABSOLUTE_PERCENT_AGAINST_INNER_SIZE: Errata.AbsolutePercentAgainstInnerSize,
+	ERRATA_MIN_SIZE_UNDEFINED_INSTEAD_OF_AUTO: Errata.MinSizeUndefinedInsteadOfAuto,
+	ERRATA_ALL: Errata.All,
+	ERRATA_CLASSIC: Errata.Classic,
+	EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS: ExperimentalFeature.WebFlexBasis,
+	EXPERIMENTAL_FEATURE_FIX_FLEX_BASIS_FIT_CONTENT: ExperimentalFeature.FixFlexBasisFitContent,
+	FLEX_DIRECTION_COLUMN: FlexDirection.Column,
+	FLEX_DIRECTION_COLUMN_REVERSE: FlexDirection.ColumnReverse,
+	FLEX_DIRECTION_ROW: FlexDirection.Row,
+	FLEX_DIRECTION_ROW_REVERSE: FlexDirection.RowReverse,
+	GRID_TRACK_TYPE_AUTO: GridTrackType.Auto,
+	GRID_TRACK_TYPE_POINTS: GridTrackType.Points,
+	GRID_TRACK_TYPE_PERCENT: GridTrackType.Percent,
+	GRID_TRACK_TYPE_FR: GridTrackType.Fr,
+	GRID_TRACK_TYPE_MINMAX: GridTrackType.Minmax,
+	GUTTER_COLUMN: Gutter.Column,
+	GUTTER_ROW: Gutter.Row,
+	GUTTER_ALL: Gutter.All,
+	JUSTIFY_AUTO: Justify.Auto,
+	JUSTIFY_FLEX_START: Justify.FlexStart,
+	JUSTIFY_CENTER: Justify.Center,
+	JUSTIFY_FLEX_END: Justify.FlexEnd,
+	JUSTIFY_SPACE_BETWEEN: Justify.SpaceBetween,
+	JUSTIFY_SPACE_AROUND: Justify.SpaceAround,
+	JUSTIFY_SPACE_EVENLY: Justify.SpaceEvenly,
+	JUSTIFY_STRETCH: Justify.Stretch,
+	JUSTIFY_START: Justify.Start,
+	JUSTIFY_END: Justify.End,
+	LOG_LEVEL_ERROR: LogLevel.Error,
+	LOG_LEVEL_WARN: LogLevel.Warn,
+	LOG_LEVEL_INFO: LogLevel.Info,
+	LOG_LEVEL_DEBUG: LogLevel.Debug,
+	LOG_LEVEL_VERBOSE: LogLevel.Verbose,
+	LOG_LEVEL_FATAL: LogLevel.Fatal,
+	MEASURE_MODE_UNDEFINED: MeasureMode.Undefined,
+	MEASURE_MODE_EXACTLY: MeasureMode.Exactly,
+	MEASURE_MODE_AT_MOST: MeasureMode.AtMost,
+	NODE_TYPE_DEFAULT: NodeType.Default,
+	NODE_TYPE_TEXT: NodeType.Text,
+	OVERFLOW_VISIBLE: Overflow.Visible,
+	OVERFLOW_HIDDEN: Overflow.Hidden,
+	OVERFLOW_SCROLL: Overflow.Scroll,
+	POSITION_TYPE_STATIC: PositionType.Static,
+	POSITION_TYPE_RELATIVE: PositionType.Relative,
+	POSITION_TYPE_ABSOLUTE: PositionType.Absolute,
+	UNIT_UNDEFINED: Unit.Undefined,
+	UNIT_POINT: Unit.Point,
+	UNIT_PERCENT: Unit.Percent,
+	UNIT_AUTO: Unit.Auto,
+	UNIT_MAX_CONTENT: Unit.MaxContent,
+	UNIT_FIT_CONTENT: Unit.FitContent,
+	UNIT_STRETCH: Unit.Stretch,
+	WRAP_NO_WRAP: Wrap.NoWrap,
+	WRAP_WRAP: Wrap.Wrap,
+	WRAP_WRAP_REVERSE: Wrap.WrapReverse
+};
+//#endregion
+//#region src/yoga/core/config.ts
+function configUpdateInvalidatesLayout(oldConfig, newConfig) {
+	return oldConfig.getErrata() !== newConfig.getErrata() || oldConfig.getEnabledExperiments() !== newConfig.getEnabledExperiments() || oldConfig.getPointScaleFactor() !== newConfig.getPointScaleFactor() || oldConfig.useWebDefaults() !== newConfig.useWebDefaults();
+}
+var Config$1 = class {
+	useWebDefaults_ = false;
+	version_ = 0;
+	experimentalFeatures_ = 0;
+	errata_ = Errata.MinSizeUndefinedInsteadOfAuto;
+	pointScaleFactor_ = 1;
+	setUseWebDefaults(useWebDefaults) {
+		this.useWebDefaults_ = useWebDefaults;
+	}
+	useWebDefaults() {
+		return this.useWebDefaults_;
+	}
+	setExperimentalFeatureEnabled(feature, enabled) {
+		if (this.isExperimentalFeatureEnabled(feature) !== enabled) {
+			this.experimentalFeatures_ = enabled ? this.experimentalFeatures_ | 1 << feature : this.experimentalFeatures_ & ~(1 << feature);
+			this.version_++;
+		}
+	}
+	isExperimentalFeatureEnabled(feature) {
+		return (this.experimentalFeatures_ & 1 << feature) !== 0;
+	}
+	getEnabledExperiments() {
+		return this.experimentalFeatures_;
+	}
+	setErrata(errata) {
+		if (this.errata_ !== errata) {
+			this.errata_ = errata;
+			this.version_++;
+		}
+	}
+	addErrata(errata) {
+		if (!this.hasErrata(errata)) {
+			this.errata_ |= errata;
+			this.version_++;
+		}
+	}
+	removeErrata(errata) {
+		if (this.hasErrata(errata)) {
+			this.errata_ &= ~errata;
+			this.version_++;
+		}
+	}
+	getErrata() {
+		return this.errata_;
+	}
+	hasErrata(errata) {
+		return (this.errata_ & errata) !== Errata.None;
+	}
+	setPointScaleFactor(pointScaleFactor) {
+		const value = pointScaleFactor;
+		if (this.pointScaleFactor_ !== value) {
+			this.pointScaleFactor_ = value;
+			this.version_++;
+		}
+	}
+	getPointScaleFactor() {
+		return this.pointScaleFactor_;
+	}
+	getVersion() {
+		return this.version_;
+	}
+};
+let defaultConfig = null;
+function getDefaultConfig() {
+	if (defaultConfig === null) defaultConfig = new Config$1();
+	return defaultConfig;
+}
+//#endregion
+//#region src/yoga/config.ts
+/**
+* Public Config wrapper over the core config, exposing the same surface as
+* the WASM binding's ConfigImpl.
+*/
+var Config = class Config {
+	/** @internal */
+	core = new Config$1();
+	static create() {
+		return new Config();
+	}
+	/**
+	@deprecated No-op in the TypeScript port: the garbage collector owns this
+	config's lifetime. Kept only for yoga-layout binding compatibility.
+	*/
+	free() {}
+	setExperimentalFeatureEnabled(feature, enabled) {
+		this.core.setExperimentalFeatureEnabled(feature, enabled);
+	}
+	isExperimentalFeatureEnabled(feature) {
+		return this.core.isExperimentalFeatureEnabled(feature);
+	}
+	setPointScaleFactor(factor) {
+		if (!(factor >= 0)) throw new Error("Scale factor should not be less than zero");
+		this.core.setPointScaleFactor(factor);
+	}
+	getErrata() {
+		return this.core.getErrata();
+	}
+	setErrata(errata) {
+		this.core.setErrata(errata);
+	}
+	useWebDefaults() {
+		return this.core.useWebDefaults();
+	}
+	setUseWebDefaults(useWebDefaults) {
+		this.core.setUseWebDefaults(useWebDefaults);
+	}
+};
+//#endregion
+//#region src/yoga/core/numeric.ts
+function isUndefined(value) {
+	return Number.isNaN(value);
+}
+function isDefined(value) {
+	return !Number.isNaN(value);
+}
+function maxOrDefined(a, b) {
+	if (isDefined(a) && isDefined(b)) return Math.max(a, b);
+	return isUndefined(a) ? b : a;
+}
+function minOrDefined(a, b) {
+	if (isDefined(a) && isDefined(b)) return Math.min(a, b);
+	return isUndefined(a) ? b : a;
+}
+function inexactEquals(a, b) {
+	if (isDefined(a) && isDefined(b)) return Math.abs(a - b) < 1e-4;
+	return isUndefined(a) && isUndefined(b);
+}
+function optionalEquals(a, b) {
+	return a === b || isUndefined(a) && isUndefined(b);
+}
+//#endregion
+//#region src/yoga/core/helpers.ts
+const PhysicalEdge = {
+	Left: 0,
+	Top: 1,
+	Right: 2,
+	Bottom: 3
+};
+const SizingMode = {
+	StretchFit: 0,
+	MaxContent: 1,
+	FitContent: 2
+};
+function measureMode(mode) {
+	switch (mode) {
+		case SizingMode.StretchFit: return MeasureMode.Exactly;
+		case SizingMode.MaxContent: return MeasureMode.Undefined;
+		case SizingMode.FitContent: return MeasureMode.AtMost;
+	}
+}
+function isRow(flexDirection) {
+	return (flexDirection & FlexDirection.Row) !== 0;
+}
+function isColumn(flexDirection) {
+	return (flexDirection & FlexDirection.Row) === 0;
+}
+function resolveDirection(flexDirection, direction) {
+	if (direction === Direction.RTL) {
+		if (flexDirection === FlexDirection.Row) return FlexDirection.RowReverse;
+		else if (flexDirection === FlexDirection.RowReverse) return FlexDirection.Row;
+	}
+	return flexDirection;
+}
+function resolveCrossDirection(flexDirection, direction) {
+	return isColumn(flexDirection) ? resolveDirection(FlexDirection.Row, direction) : FlexDirection.Column;
+}
+const FLEX_START_EDGE = [
+	PhysicalEdge.Top,
+	PhysicalEdge.Bottom,
+	PhysicalEdge.Left,
+	PhysicalEdge.Right
+];
+const FLEX_END_EDGE = [
+	PhysicalEdge.Bottom,
+	PhysicalEdge.Top,
+	PhysicalEdge.Right,
+	PhysicalEdge.Left
+];
+const DIMENSION_OF_AXIS = [
+	Dimension.Height,
+	Dimension.Height,
+	Dimension.Width,
+	Dimension.Width
+];
+function flexStartEdge(flexDirection) {
+	return FLEX_START_EDGE[flexDirection];
+}
+function flexEndEdge(flexDirection) {
+	return FLEX_END_EDGE[flexDirection];
+}
+function inlineStartEdge(flexDirection, direction) {
+	if (isRow(flexDirection)) return direction === Direction.RTL ? PhysicalEdge.Right : PhysicalEdge.Left;
+	return PhysicalEdge.Top;
+}
+function inlineEndEdge(flexDirection, direction) {
+	if (isRow(flexDirection)) return direction === Direction.RTL ? PhysicalEdge.Left : PhysicalEdge.Right;
+	return PhysicalEdge.Bottom;
+}
+function dimension(flexDirection) {
+	return DIMENSION_OF_AXIS[flexDirection];
+}
+function resolveChildAlignment(node, child) {
+	const align = child.style.alignSelf() === Align.Auto ? node.style.alignItems() : child.style.alignSelf();
+	if (node.style.display() === Display.Flex && align === Align.Baseline && isColumn(node.style.flexDirection())) return Align.FlexStart;
+	return align;
+}
+function resolveChildJustification(node, child) {
+	return child.style.justifySelf() === Justify.Auto ? node.style.justifyItems() : child.style.justifySelf();
+}
+/**
+* Fallback alignment to use on overflow
+* https://www.w3.org/TR/css-align-3/#distribution-values
+*/
+function fallbackAlignment(align) {
+	switch (align) {
+		case Align.SpaceBetween:
+		case Align.Stretch: return Align.FlexStart;
+		case Align.SpaceAround:
+		case Align.SpaceEvenly: return Align.FlexStart;
+		default: return align;
+	}
+}
+function fallbackJustification(align) {
+	switch (align) {
+		case Justify.SpaceBetween: return Justify.FlexStart;
+		case Justify.SpaceAround:
+		case Justify.SpaceEvenly: return Justify.FlexStart;
+		default: return align;
+	}
+}
+function paddingAndBorderForAxis(node, axis, direction, widthSize) {
+	if (!node.style.hasPaddingOrBorder()) return 0;
+	return node.style.computeInlineStartPaddingAndBorder(axis, direction, widthSize) + node.style.computeInlineEndPaddingAndBorder(axis, direction, widthSize);
+}
+function boundAxisWithinMinAndMax(node, direction, axis, value, axisSize, widthSize) {
+	let min = NaN;
+	let max = NaN;
+	if (isColumn(axis)) {
+		min = node.style.resolvedMinDimension(direction, Dimension.Height, axisSize, widthSize);
+		max = node.style.resolvedMaxDimension(direction, Dimension.Height, axisSize, widthSize);
+	} else if (isRow(axis)) {
+		min = node.style.resolvedMinDimension(direction, Dimension.Width, axisSize, widthSize);
+		max = node.style.resolvedMaxDimension(direction, Dimension.Width, axisSize, widthSize);
+	}
+	if (max >= 0 && value > max) return max;
+	if (min >= 0 && value < min) return min;
+	return value;
+}
+function boundAxis(node, axis, direction, value, axisSize, widthSize) {
+	return maxOrDefined(boundAxisWithinMinAndMax(node, direction, axis, value, axisSize, widthSize), paddingAndBorderForAxis(node, axis, direction, widthSize));
+}
+function getPositionOfOppositeEdge(position, axis, containingNode, node) {
+	return containingNode.layout.measuredDimension(dimension(axis)) - node.layout.measuredDimension(dimension(axis)) - position;
+}
+function setChildTrailingPosition(node, child, axis) {
+	child.setLayoutPosition(getPositionOfOppositeEdge(child.layout.position(flexStartEdge(axis)), axis, node, child), flexEndEdge(axis));
+}
+function needsTrailingPosition(axis) {
+	return axis === FlexDirection.RowReverse || axis === FlexDirection.ColumnReverse;
+}
+//#endregion
+//#region src/yoga/core/absoluteLayout.ts
+function setFlexStartLayoutPosition(parent, child, direction, axis, containingBlockWidth) {
+	let position = child.style.computeFlexStartMargin(axis, direction, containingBlockWidth) + parent.layout.border(flexStartEdge(axis));
+	if (!child.hasErrata(Errata.AbsolutePositionWithoutInsetsExcludesPadding) && parent.style.display() !== Display.Grid) position += parent.layout.padding(flexStartEdge(axis));
+	child.setLayoutPosition(position, flexStartEdge(axis));
+}
+function setFlexEndLayoutPosition(parent, child, direction, axis, containingBlockWidth) {
+	let flexEndPosition = parent.layout.border(flexEndEdge(axis)) + child.style.computeFlexEndMargin(axis, direction, containingBlockWidth);
+	if (!child.hasErrata(Errata.AbsolutePositionWithoutInsetsExcludesPadding) && parent.style.display() !== Display.Grid) flexEndPosition += parent.layout.padding(flexEndEdge(axis));
+	child.setLayoutPosition(getPositionOfOppositeEdge(flexEndPosition, axis, parent, child), flexStartEdge(axis));
+}
+function setCenterLayoutPosition(parent, child, direction, axis, containingBlockWidth) {
+	let parentContentBoxSize = parent.layout.measuredDimension(dimension(axis)) - parent.layout.border(flexStartEdge(axis)) - parent.layout.border(flexEndEdge(axis));
+	if (!child.hasErrata(Errata.AbsolutePositionWithoutInsetsExcludesPadding) && parent.style.display() !== Display.Grid) {
+		parentContentBoxSize -= parent.layout.padding(flexStartEdge(axis));
+		parentContentBoxSize -= parent.layout.padding(flexEndEdge(axis));
+	}
+	const childOuterSize = child.layout.measuredDimension(dimension(axis)) + child.style.computeMarginForAxis(axis, containingBlockWidth);
+	let position = (parentContentBoxSize - childOuterSize) / 2 + parent.layout.border(flexStartEdge(axis)) + child.style.computeFlexStartMargin(axis, direction, containingBlockWidth);
+	if (!child.hasErrata(Errata.AbsolutePositionWithoutInsetsExcludesPadding) && parent.style.display() !== Display.Grid) position += parent.layout.padding(flexStartEdge(axis));
+	child.setLayoutPosition(position, flexStartEdge(axis));
+}
+function justifyAbsoluteChild(parent, child, direction, mainAxis, containingBlockWidth) {
+	switch (parent.style.display() === Display.Grid ? resolveChildJustification(parent, child) : parent.style.justifyContent()) {
+		case Justify.Start:
+		case Justify.Auto:
+		case Justify.Stretch:
+		case Justify.FlexStart:
+		case Justify.SpaceBetween:
+			setFlexStartLayoutPosition(parent, child, direction, mainAxis, containingBlockWidth);
+			break;
+		case Justify.End:
+		case Justify.FlexEnd:
+			setFlexEndLayoutPosition(parent, child, direction, mainAxis, containingBlockWidth);
+			break;
+		case Justify.Center:
+		case Justify.SpaceAround:
+		case Justify.SpaceEvenly: setCenterLayoutPosition(parent, child, direction, mainAxis, containingBlockWidth);
+	}
+}
+function alignAbsoluteChild(parent, child, direction, crossAxis, containingBlockWidth) {
+	let itemAlign = resolveChildAlignment(parent, child);
+	if (parent.style.flexWrap() === Wrap.WrapReverse) {
+		if (itemAlign === Align.FlexEnd) itemAlign = Align.FlexStart;
+		else if (itemAlign !== Align.Center) itemAlign = Align.FlexEnd;
+	}
+	switch (itemAlign) {
+		case Align.Start:
+		case Align.Auto:
+		case Align.FlexStart:
+		case Align.Baseline:
+		case Align.SpaceAround:
+		case Align.SpaceBetween:
+		case Align.Stretch:
+		case Align.SpaceEvenly:
+			setFlexStartLayoutPosition(parent, child, direction, crossAxis, containingBlockWidth);
+			break;
+		case Align.End:
+		case Align.FlexEnd:
+			setFlexEndLayoutPosition(parent, child, direction, crossAxis, containingBlockWidth);
+			break;
+		case Align.Center: setCenterLayoutPosition(parent, child, direction, crossAxis, containingBlockWidth);
+	}
+}
+function positionAbsoluteChild(containingNode, parent, child, direction, axis, isMainAxis, containingBlockWidth, containingBlockHeight) {
+	const containingBlockSize = isRow(axis) ? containingBlockWidth : containingBlockHeight;
+	if (child.style.isInlineStartPositionDefined(axis, direction) && !child.style.isInlineStartPositionAuto(axis, direction)) {
+		const positionRelativeToInlineStart = child.style.computeInlineStartPosition(axis, direction, containingBlockSize) + containingNode.style.computeInlineStartBorder(axis, direction) + child.style.computeInlineStartMargin(axis, direction, containingBlockSize);
+		const positionRelativeToFlexStart = inlineStartEdge(axis, direction) !== flexStartEdge(axis) ? getPositionOfOppositeEdge(positionRelativeToInlineStart, axis, containingNode, child) : positionRelativeToInlineStart;
+		child.setLayoutPosition(positionRelativeToFlexStart, flexStartEdge(axis));
+	} else if (child.style.isInlineEndPositionDefined(axis, direction) && !child.style.isInlineEndPositionAuto(axis, direction)) {
+		const positionRelativeToInlineStart = containingNode.layout.measuredDimension(dimension(axis)) - child.layout.measuredDimension(dimension(axis)) - containingNode.style.computeInlineEndBorder(axis, direction) - child.style.computeInlineEndMargin(axis, direction, containingBlockSize) - child.style.computeInlineEndPosition(axis, direction, containingBlockSize);
+		const positionRelativeToFlexStart = inlineStartEdge(axis, direction) !== flexStartEdge(axis) ? getPositionOfOppositeEdge(positionRelativeToInlineStart, axis, containingNode, child) : positionRelativeToInlineStart;
+		child.setLayoutPosition(positionRelativeToFlexStart, flexStartEdge(axis));
+	} else if (isMainAxis) justifyAbsoluteChild(parent, child, direction, axis, containingBlockWidth);
+	else alignAbsoluteChild(parent, child, direction, axis, containingBlockWidth);
+}
+function layoutAbsoluteChild(containingNode, node, child, containingBlockWidth, containingBlockHeight, widthMode, direction, layoutMarkerData, depth, generationCount) {
+	const mainAxis = node.style.display() === Display.Grid ? resolveDirection(FlexDirection.Row, direction) : resolveDirection(node.style.flexDirection(), direction);
+	const crossAxis = node.style.display() === Display.Grid ? FlexDirection.Column : resolveCrossDirection(mainAxis, direction);
+	const isMainAxisRow = isRow(mainAxis);
+	let childWidth = NaN;
+	let childHeight = NaN;
+	let childWidthSizingMode = SizingMode.MaxContent;
+	let childHeightSizingMode = SizingMode.MaxContent;
+	const marginRow = child.style.computeMarginForAxis(FlexDirection.Row, containingBlockWidth);
+	const marginColumn = child.style.computeMarginForAxis(FlexDirection.Column, containingBlockWidth);
+	if (child.hasDefiniteLength(Dimension.Width, containingBlockWidth)) childWidth = child.getResolvedDimension(direction, Dimension.Width, containingBlockWidth, containingBlockWidth) + marginRow;
+	else if (child.style.isFlexStartPositionDefined(FlexDirection.Row, direction) && child.style.isFlexEndPositionDefined(FlexDirection.Row, direction) && !child.style.isFlexStartPositionAuto(FlexDirection.Row, direction) && !child.style.isFlexEndPositionAuto(FlexDirection.Row, direction)) {
+		childWidth = containingNode.layout.measuredDimension(Dimension.Width) - (containingNode.style.computeFlexStartBorder(FlexDirection.Row, direction) + containingNode.style.computeFlexEndBorder(FlexDirection.Row, direction)) - (child.style.computeFlexStartPosition(FlexDirection.Row, direction, containingBlockWidth) + child.style.computeFlexEndPosition(FlexDirection.Row, direction, containingBlockWidth));
+		childWidth = boundAxis(child, FlexDirection.Row, direction, childWidth, containingBlockWidth, containingBlockWidth);
+	}
+	if (child.hasDefiniteLength(Dimension.Height, containingBlockHeight)) childHeight = child.getResolvedDimension(direction, Dimension.Height, containingBlockHeight, containingBlockWidth) + marginColumn;
+	else if (child.style.isFlexStartPositionDefined(FlexDirection.Column, direction) && child.style.isFlexEndPositionDefined(FlexDirection.Column, direction) && !child.style.isFlexStartPositionAuto(FlexDirection.Column, direction) && !child.style.isFlexEndPositionAuto(FlexDirection.Column, direction)) {
+		childHeight = containingNode.layout.measuredDimension(Dimension.Height) - (containingNode.style.computeFlexStartBorder(FlexDirection.Column, direction) + containingNode.style.computeFlexEndBorder(FlexDirection.Column, direction)) - (child.style.computeFlexStartPosition(FlexDirection.Column, direction, containingBlockHeight) + child.style.computeFlexEndPosition(FlexDirection.Column, direction, containingBlockHeight));
+		childHeight = boundAxis(child, FlexDirection.Column, direction, childHeight, containingBlockHeight, containingBlockWidth);
+	}
+	const childStyle = child.style;
+	if (isUndefined(childWidth) !== isUndefined(childHeight)) {
+		if (isDefined(childStyle.aspectRatio())) {
+			if (isUndefined(childWidth)) childWidth = marginRow + (childHeight - marginColumn) * childStyle.aspectRatio();
+			else if (isUndefined(childHeight)) childHeight = marginColumn + (childWidth - marginRow) / childStyle.aspectRatio();
+		}
+	}
+	if (isUndefined(childWidth) || isUndefined(childHeight)) {
+		childWidthSizingMode = isUndefined(childWidth) ? SizingMode.MaxContent : SizingMode.StretchFit;
+		childHeightSizingMode = isUndefined(childHeight) ? SizingMode.MaxContent : SizingMode.StretchFit;
+		if (!isMainAxisRow && isUndefined(childWidth) && widthMode !== SizingMode.MaxContent && isDefined(containingBlockWidth) && containingBlockWidth > 0) {
+			childWidth = containingBlockWidth;
+			childWidthSizingMode = SizingMode.FitContent;
+		}
+		calculateLayoutInternal(child, childWidth, childHeight, direction, childWidthSizingMode, childHeightSizingMode, containingBlockWidth, containingBlockHeight, false, LayoutPassReason.AbsMeasureChild, layoutMarkerData, depth, generationCount);
+		childWidth = child.layout.measuredDimension(Dimension.Width) + child.style.computeMarginForAxis(FlexDirection.Row, containingBlockWidth);
+		childHeight = child.layout.measuredDimension(Dimension.Height) + child.style.computeMarginForAxis(FlexDirection.Column, containingBlockWidth);
+	}
+	calculateLayoutInternal(child, childWidth, childHeight, direction, SizingMode.StretchFit, SizingMode.StretchFit, containingBlockWidth, containingBlockHeight, true, LayoutPassReason.AbsLayout, layoutMarkerData, depth, generationCount);
+	positionAbsoluteChild(containingNode, node, child, direction, mainAxis, true, containingBlockWidth, containingBlockHeight);
+	positionAbsoluteChild(containingNode, node, child, direction, crossAxis, false, containingBlockWidth, containingBlockHeight);
+}
+function layoutAbsoluteDescendants(containingNode, currentNode, widthSizingMode, currentNodeDirection, layoutMarkerData, currentDepth, generationCount, currentNodeLeftOffsetFromContainingBlock, currentNodeTopOffsetFromContainingBlock, containingNodeAvailableInnerWidth, containingNodeAvailableInnerHeight) {
+	let hasNewLayout = false;
+	for (const child of currentNode.getLayoutChildren()) if (child.style.display() === Display.None) continue;
+	else if (child.style.positionType() === PositionType.Absolute) {
+		const absoluteErrata = currentNode.hasErrata(Errata.AbsolutePercentAgainstInnerSize);
+		layoutAbsoluteChild(containingNode, currentNode, child, absoluteErrata ? containingNodeAvailableInnerWidth : containingNode.layout.measuredDimension(Dimension.Width) - containingNode.style.computeBorderForAxis(FlexDirection.Row), absoluteErrata ? containingNodeAvailableInnerHeight : containingNode.layout.measuredDimension(Dimension.Height) - containingNode.style.computeBorderForAxis(FlexDirection.Column), widthSizingMode, currentNodeDirection, layoutMarkerData, currentDepth, generationCount);
+		hasNewLayout = hasNewLayout || child.hasNewLayout_;
+		const parentMainAxis = resolveDirection(currentNode.style.flexDirection(), currentNodeDirection);
+		const parentCrossAxis = resolveCrossDirection(parentMainAxis, currentNodeDirection);
+		if (needsTrailingPosition(parentMainAxis)) setChildTrailingPosition((isRow(parentMainAxis) ? child.style.horizontalInsetsDefined() : child.style.verticalInsetsDefined()) ? containingNode : currentNode, child, parentMainAxis);
+		if (needsTrailingPosition(parentCrossAxis)) setChildTrailingPosition((isRow(parentCrossAxis) ? child.style.horizontalInsetsDefined() : child.style.verticalInsetsDefined()) ? containingNode : currentNode, child, parentCrossAxis);
+		const childLeftPosition = child.layout.position(PhysicalEdge.Left);
+		const childTopPosition = child.layout.position(PhysicalEdge.Top);
+		const childLeftOffsetFromParent = child.style.horizontalInsetsDefined() ? childLeftPosition - currentNodeLeftOffsetFromContainingBlock : childLeftPosition;
+		const childTopOffsetFromParent = child.style.verticalInsetsDefined() ? childTopPosition - currentNodeTopOffsetFromContainingBlock : childTopPosition;
+		child.setLayoutPosition(childLeftOffsetFromParent, PhysicalEdge.Left);
+		child.setLayoutPosition(childTopOffsetFromParent, PhysicalEdge.Top);
+	} else if (child.style.positionType() === PositionType.Static && !child.alwaysFormsContainingBlock) {
+		child.cloneChildrenIfNeeded();
+		const childDirection = child.resolveDirection(currentNodeDirection);
+		const childLeftOffsetFromContainingBlock = currentNodeLeftOffsetFromContainingBlock + child.layout.position(PhysicalEdge.Left);
+		const childTopOffsetFromContainingBlock = currentNodeTopOffsetFromContainingBlock + child.layout.position(PhysicalEdge.Top);
+		hasNewLayout = layoutAbsoluteDescendants(containingNode, child, widthSizingMode, childDirection, layoutMarkerData, currentDepth + 1, generationCount, childLeftOffsetFromContainingBlock, childTopOffsetFromContainingBlock, containingNodeAvailableInnerWidth, containingNodeAvailableInnerHeight) || hasNewLayout;
+		cleanupContentsNodesRecursively(child, hasNewLayout);
+		if (hasNewLayout) child.hasNewLayout_ = hasNewLayout;
+	}
+	return hasNewLayout;
+}
+//#endregion
+//#region src/yoga/core/baseline.ts
+function calculateBaseline(node) {
+	if (node.hasBaselineFunc()) {
+		const baseline = node.baseline(node.layout.measuredDimension(Dimension.Width), node.layout.measuredDimension(Dimension.Height));
+		if (Number.isNaN(baseline)) throw new Error("Expect custom baseline function to not return NaN");
+		return baseline;
+	}
+	let baselineChild = null;
+	for (const child of node.getLayoutChildren()) {
+		if (child.lineIndex > 0) break;
+		if (child.style.positionType() === PositionType.Absolute) continue;
+		if (resolveChildAlignment(node, child) === Align.Baseline || child.isReferenceBaseline_) {
+			baselineChild = child;
+			break;
+		}
+		if (baselineChild === null) baselineChild = child;
+	}
+	if (baselineChild === null) return node.layout.measuredDimension(Dimension.Height);
+	return calculateBaseline(baselineChild) + baselineChild.layout.position(PhysicalEdge.Top);
+}
+function isBaselineLayout(node) {
+	if (isColumn(node.style.flexDirection())) return false;
+	if (node.style.alignItems() === Align.Baseline) return true;
+	for (const child of node.getLayoutChildren()) if (child.style.positionType() !== PositionType.Absolute && child.style.alignSelf() === Align.Baseline) return true;
+	return false;
+}
+//#endregion
+//#region src/yoga/core/pixelGrid.ts
+function roundValueToPixelGrid(value, pointScaleFactor, forceCeil, forceFloor) {
+	if (pointScaleFactor === 1 && Number.isInteger(value)) return value === 0 ? 0 : value;
+	let scaledValue = value * pointScaleFactor;
+	let fractial = scaledValue % 1;
+	if (fractial < 0) ++fractial;
+	if (fractial < 1e-4) scaledValue = scaledValue - fractial;
+	else if (fractial - 1 > -1e-4) scaledValue = scaledValue - fractial + 1;
+	else if (forceCeil) scaledValue = scaledValue - fractial + 1;
+	else if (forceFloor) scaledValue = scaledValue - fractial;
+	else scaledValue = scaledValue - fractial + (fractial - .5 > -1e-4 ? 1 : 0);
+	return Number.isNaN(scaledValue) || Number.isNaN(pointScaleFactor) ? NaN : scaledValue / pointScaleFactor;
+}
+function roundLayoutResultsToPixelGrid(node, absoluteLeft, absoluteTop) {
+	const layout = node.layout;
+	const pointScaleFactor = node.config.getPointScaleFactor();
+	if (!layout.roundingDirty && layout.roundedAbsLeft === absoluteLeft && layout.roundedAbsTop === absoluteTop && layout.roundedScale === pointScaleFactor) return;
+	layout.roundedAbsLeft = absoluteLeft;
+	layout.roundedAbsTop = absoluteTop;
+	layout.roundedScale = pointScaleFactor;
+	layout.roundingDirty = false;
+	const nodeLeft = layout.position(PhysicalEdge.Left);
+	const nodeTop = layout.position(PhysicalEdge.Top);
+	const nodeWidth = layout.dimension(Dimension.Width);
+	const nodeHeight = layout.dimension(Dimension.Height);
+	const absoluteNodeLeft = absoluteLeft + nodeLeft;
+	const absoluteNodeTop = absoluteTop + nodeTop;
+	const absoluteNodeRight = absoluteNodeLeft + nodeWidth;
+	const absoluteNodeBottom = absoluteNodeTop + nodeHeight;
+	if (pointScaleFactor !== 0) {
+		const textRounding = node.nodeType === NodeType.Text;
+		layout.setPosition(PhysicalEdge.Left, roundValueToPixelGrid(nodeLeft, pointScaleFactor, false, textRounding));
+		layout.setPosition(PhysicalEdge.Top, roundValueToPixelGrid(nodeTop, pointScaleFactor, false, textRounding));
+		const scaledNodeWidth = nodeWidth * pointScaleFactor;
+		const hasFractionalWidth = !inexactEquals(Math.round(scaledNodeWidth), scaledNodeWidth);
+		const scaledNodeHeight = nodeHeight * pointScaleFactor;
+		const hasFractionalHeight = !inexactEquals(Math.round(scaledNodeHeight), scaledNodeHeight);
+		node.layout.setDimension(Dimension.Width, roundValueToPixelGrid(absoluteNodeRight, pointScaleFactor, textRounding && hasFractionalWidth, textRounding && !hasFractionalWidth) - roundValueToPixelGrid(absoluteNodeLeft, pointScaleFactor, false, textRounding));
+		node.layout.setDimension(Dimension.Height, roundValueToPixelGrid(absoluteNodeBottom, pointScaleFactor, textRounding && hasFractionalHeight, textRounding && !hasFractionalHeight) - roundValueToPixelGrid(absoluteNodeTop, pointScaleFactor, false, textRounding));
+	}
+	roundChildren(node, absoluteNodeLeft, absoluteNodeTop);
+}
+function roundChildren(node, absoluteNodeLeft, absoluteNodeTop) {
+	for (const child of node.children) {
+		const childLayout = child.layout;
+		if (childLayout.roundingDirty || childLayout.roundedAbsLeft !== absoluteNodeLeft || childLayout.roundedAbsTop !== absoluteNodeTop || childLayout.roundedScale !== child.config.getPointScaleFactor()) roundLayoutResultsToPixelGrid(child, absoluteNodeLeft, absoluteNodeTop);
+	}
+}
+//#endregion
+//#region src/yoga/core/cache.ts
+function sizeIsExactAndMatchesOldMeasuredSize(sizeMode, size, lastComputedSize) {
+	return sizeMode === SizingMode.StretchFit && inexactEquals(size, lastComputedSize);
+}
+function oldSizeIsMaxContentAndStillFits(sizeMode, size, lastSizeMode, lastComputedSize) {
+	return sizeMode === SizingMode.FitContent && lastSizeMode === SizingMode.MaxContent && (size >= lastComputedSize || inexactEquals(size, lastComputedSize));
+}
+function newSizeIsStricterAndStillValid(sizeMode, size, lastSizeMode, lastSize, lastComputedSize) {
+	return lastSizeMode === SizingMode.FitContent && sizeMode === SizingMode.FitContent && isDefined(lastSize) && isDefined(size) && isDefined(lastComputedSize) && lastSize > size && (lastComputedSize <= size || inexactEquals(size, lastComputedSize));
+}
+function canUseCachedMeasurement(widthMode, availableWidth, heightMode, availableHeight, lastWidthMode, lastAvailableWidth, lastHeightMode, lastAvailableHeight, lastComputedWidth, lastComputedHeight, marginRow, marginColumn, config) {
+	if (isDefined(lastComputedHeight) && lastComputedHeight < 0 || isDefined(lastComputedWidth) && lastComputedWidth < 0) return false;
+	const pointScaleFactor = config.getPointScaleFactor();
+	const useRoundedComparison = pointScaleFactor !== 0;
+	const effectiveWidth = useRoundedComparison ? roundValueToPixelGrid(availableWidth, pointScaleFactor, false, false) : availableWidth;
+	const effectiveHeight = useRoundedComparison ? roundValueToPixelGrid(availableHeight, pointScaleFactor, false, false) : availableHeight;
+	const effectiveLastWidth = useRoundedComparison ? roundValueToPixelGrid(lastAvailableWidth, pointScaleFactor, false, false) : lastAvailableWidth;
+	const effectiveLastHeight = useRoundedComparison ? roundValueToPixelGrid(lastAvailableHeight, pointScaleFactor, false, false) : lastAvailableHeight;
+	const hasSameWidthSpec = lastWidthMode === widthMode && inexactEquals(effectiveLastWidth, effectiveWidth);
+	const hasSameHeightSpec = lastHeightMode === heightMode && inexactEquals(effectiveLastHeight, effectiveHeight);
+	const widthIsCompatible = hasSameWidthSpec || sizeIsExactAndMatchesOldMeasuredSize(widthMode, availableWidth - marginRow, lastComputedWidth) || oldSizeIsMaxContentAndStillFits(widthMode, availableWidth - marginRow, lastWidthMode, lastComputedWidth) || newSizeIsStricterAndStillValid(widthMode, availableWidth - marginRow, lastWidthMode, lastAvailableWidth, lastComputedWidth);
+	const heightIsCompatible = hasSameHeightSpec || sizeIsExactAndMatchesOldMeasuredSize(heightMode, availableHeight - marginColumn, lastComputedHeight) || oldSizeIsMaxContentAndStillFits(heightMode, availableHeight - marginColumn, lastHeightMode, lastComputedHeight) || newSizeIsStricterAndStillValid(heightMode, availableHeight - marginColumn, lastHeightMode, lastAvailableHeight, lastComputedHeight);
+	return widthIsCompatible && heightIsCompatible;
+}
+//#endregion
+//#region src/yoga/core/flexLine.ts
+function calculateFlexLine(node, ownerDirection, ownerWidth, mainAxisOwnerSize, availableInnerWidth, availableInnerMainDim, layoutChildren, startIndex, lineCount, flexLine) {
+	const itemsInFlow = flexLine.itemsInFlow;
+	itemsInFlow.length = 0;
+	let sizeConsumed = 0;
+	let totalFlexGrowFactors = 0;
+	let totalFlexShrinkScaledFactors = 0;
+	let numberOfAutoMargins = 0;
+	let firstElementInLine = null;
+	let sizeConsumedIncludingMinConstraint = 0;
+	const direction = node.resolveDirection(ownerDirection);
+	const mainAxis = resolveDirection(node.style.flexDirection(), direction);
+	const isNodeFlexWrap = node.style.flexWrap() !== Wrap.NoWrap;
+	const gap = node.style.computeGapForAxis(mainAxis, availableInnerMainDim);
+	let index = startIndex;
+	for (; index < layoutChildren.length; index++) {
+		const child = layoutChildren[index];
+		if (child.style.display() === Display.None || child.style.positionType() === PositionType.Absolute) continue;
+		if (firstElementInLine === null) firstElementInLine = child;
+		if (child.style.flexStartMarginIsAuto(mainAxis, ownerDirection)) numberOfAutoMargins++;
+		if (child.style.flexEndMarginIsAuto(mainAxis, ownerDirection)) numberOfAutoMargins++;
+		child.lineIndex = lineCount;
+		const childMarginMainAxis = child.style.computeMarginForAxis(mainAxis, availableInnerWidth);
+		const childLeadingGapMainAxis = child === firstElementInLine ? 0 : gap;
+		const flexBasisWithMinAndMaxConstraints = boundAxisWithinMinAndMax(child, direction, mainAxis, child.layout.computedFlexBasis, mainAxisOwnerSize, ownerWidth);
+		if (sizeConsumedIncludingMinConstraint + flexBasisWithMinAndMaxConstraints + childMarginMainAxis + childLeadingGapMainAxis > availableInnerMainDim && isNodeFlexWrap && itemsInFlow.length > 0) break;
+		sizeConsumedIncludingMinConstraint += flexBasisWithMinAndMaxConstraints + childMarginMainAxis + childLeadingGapMainAxis;
+		sizeConsumed += flexBasisWithMinAndMaxConstraints + childMarginMainAxis + childLeadingGapMainAxis;
+		if (child.isNodeFlexible()) {
+			totalFlexGrowFactors += child.resolveFlexGrow();
+			totalFlexShrinkScaledFactors += -child.resolveFlexShrink() * child.layout.computedFlexBasis;
+		}
+		itemsInFlow.push(child);
+	}
+	if (totalFlexGrowFactors > 0 && totalFlexGrowFactors < 1) totalFlexGrowFactors = 1;
+	if (totalFlexShrinkScaledFactors > 0 && totalFlexShrinkScaledFactors < 1) totalFlexShrinkScaledFactors = 1;
+	flexLine.sizeConsumed = sizeConsumed;
+	flexLine.numberOfAutoMargins = numberOfAutoMargins;
+	flexLine.endIndex = index;
+	flexLine.layout.totalFlexGrowFactors = totalFlexGrowFactors;
+	flexLine.layout.totalFlexShrinkScaledFactors = totalFlexShrinkScaledFactors;
+	flexLine.layout.remainingFreeSpace = 0;
+	flexLine.layout.mainDim = 0;
+	flexLine.layout.crossDim = 0;
+}
+//#endregion
+//#region src/yoga/core/layoutResults.ts
+var CachedMeasurement = class {
+	availableWidth = -1;
+	availableHeight = -1;
+	widthSizingMode = SizingMode.MaxContent;
+	heightSizingMode = SizingMode.MaxContent;
+	computedWidth = -1;
+	computedHeight = -1;
+	equals(measurement) {
+		let isEqual = this.widthSizingMode === measurement.widthSizingMode && this.heightSizingMode === measurement.heightSizingMode;
+		if (!isUndefined(this.availableWidth) || !isUndefined(measurement.availableWidth)) isEqual = isEqual && this.availableWidth === measurement.availableWidth;
+		if (!isUndefined(this.availableHeight) || !isUndefined(measurement.availableHeight)) isEqual = isEqual && this.availableHeight === measurement.availableHeight;
+		if (!isUndefined(this.computedWidth) || !isUndefined(measurement.computedWidth)) isEqual = isEqual && this.computedWidth === measurement.computedWidth;
+		if (!isUndefined(this.computedHeight) || !isUndefined(measurement.computedHeight)) isEqual = isEqual && this.computedHeight === measurement.computedHeight;
+		return isEqual;
+	}
+};
+var LayoutResults = class {
+	static MaxCachedMeasurements = 8;
+	computedFlexBasisGeneration = 0;
+	computedFlexBasis = NaN;
+	computedAutoMinMainSize = NaN;
+	generationCount = 0;
+	configVersion = 0;
+	lastOwnerDirection = Direction.Inherit;
+	nextCachedMeasurementsIndex = 0;
+	cachedMeasurements = [];
+	roundingDirty = true;
+	roundedAbsLeft = NaN;
+	roundedAbsTop = NaN;
+	roundedScale = NaN;
+	cachedLayout = new CachedMeasurement();
+	flexLine = null;
+	flexLineStarts = null;
+	direction_ = Direction.Inherit;
+	hadOverflow_ = false;
+	values_ = initialLayoutValues();
+	direction() {
+		return this.direction_;
+	}
+	setDirection(direction) {
+		this.direction_ = direction;
+	}
+	hadOverflow() {
+		return this.hadOverflow_;
+	}
+	setHadOverflow(hadOverflow) {
+		this.hadOverflow_ = hadOverflow;
+	}
+	dimension(axis) {
+		return this.values_[axis];
+	}
+	setDimension(axis, dimension) {
+		this.values_[axis] = dimension;
+	}
+	measuredDimension(axis) {
+		return this.values_[2 + axis];
+	}
+	rawDimension(axis) {
+		return this.values_[4 + axis];
+	}
+	setMeasuredDimension(axis, dimension) {
+		this.values_[2 + axis] = dimension;
+	}
+	setRawDimension(axis, dimension) {
+		this.values_[4 + axis] = dimension;
+	}
+	position(physicalEdge) {
+		return this.values_[6 + physicalEdge];
+	}
+	setPosition(physicalEdge, dimension) {
+		this.values_[6 + physicalEdge] = dimension;
+	}
+	margin(physicalEdge) {
+		return this.values_[10 + physicalEdge];
+	}
+	setMargin(physicalEdge, dimension) {
+		this.values_[10 + physicalEdge] = dimension;
+	}
+	border(physicalEdge) {
+		return this.values_[14 + physicalEdge];
+	}
+	setBorder(physicalEdge, dimension) {
+		this.values_[14 + physicalEdge] = dimension;
+	}
+	padding(physicalEdge) {
+		return this.values_[18 + physicalEdge];
+	}
+	setPadding(physicalEdge, dimension) {
+		this.values_[18 + physicalEdge] = dimension;
+	}
+};
+function initialLayoutValues() {
+	return [
+		NaN,
+		NaN,
+		NaN,
+		NaN,
+		NaN,
+		NaN,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	];
+}
+//#endregion
+//#region src/yoga/core/calculateLayout.ts
+const LayoutPassReason = {
+	Initial: 0,
+	AbsLayout: 1,
+	Stretch: 2,
+	MultilineStretch: 3,
+	FlexLayout: 4,
+	MeasureChild: 5,
+	AbsMeasureChild: 6,
+	FlexMeasure: 7
+};
+function newLayoutData() {
+	return {
+		layouts: 0,
+		measures: 0,
+		maxMeasureCache: 0,
+		cachedLayouts: 0,
+		cachedMeasures: 0,
+		measureCallbacks: 0
+	};
+}
+let gCurrentGenerationCount = 0;
+function hasAutoHorizontalMargin(style) {
+	for (const direction of [Direction.LTR, Direction.RTL]) if (style.flexStartMarginIsAuto(FlexDirection.Row, direction) || style.flexEndMarginIsAuto(FlexDirection.Row, direction)) return true;
+	return false;
+}
+function isColumnStretchEdge(owner, child) {
+	if (owner === null || child === null) return false;
+	const ownerStyle = owner.style;
+	const childStyle = child.style;
+	const childWidth = child.getProcessedDimension(Dimension.Width);
+	return ownerStyle.display() === Display.Flex && isColumn(ownerStyle.flexDirection()) && ownerStyle.flexWrap() === Wrap.NoWrap && childStyle.positionType() !== PositionType.Absolute && !isDefined(childStyle.aspectRatio()) && (childWidth.isAuto() || childWidth.isUndefined()) && !hasAutoHorizontalMargin(childStyle) && resolveChildAlignment(owner, child) === Align.Stretch;
+}
+function isInColumnStretchScrollSubtree(node) {
+	let current = node;
+	while (current !== null) {
+		let owner = current.owner;
+		while (owner !== null && owner.style.display() === Display.Contents) owner = owner.owner;
+		if (owner === null || !isColumnStretchEdge(owner, current)) return false;
+		if (owner.style.overflow() === Overflow.Scroll) return true;
+		current = owner;
+	}
+	return false;
+}
+function isNonZeroLength(length) {
+	return length.isAuto() || isDefined(length.value) && length.value !== 0;
+}
+function hasNonZeroVerticalSpacing(style) {
+	const verticalEdges = [
+		Edge.Top,
+		Edge.Bottom,
+		Edge.Vertical,
+		Edge.All
+	];
+	for (const edge of verticalEdges) if (isNonZeroLength(style.margin(edge)) || isNonZeroLength(style.padding(edge)) || isNonZeroLength(style.border(edge))) return true;
+	return false;
+}
+function hasPercentageLength(style) {
+	const edges = [
+		Edge.Left,
+		Edge.Top,
+		Edge.Right,
+		Edge.Bottom,
+		Edge.Start,
+		Edge.End,
+		Edge.Horizontal,
+		Edge.Vertical,
+		Edge.All
+	];
+	for (const edge of edges) if (style.margin(edge).isPercent() || style.position(edge).isPercent() || style.padding(edge).isPercent() || style.border(edge).isPercent()) return true;
+	for (const dim of [Dimension.Width, Dimension.Height]) if (style.dimension(dim).isPercent() || style.minDimension(dim).isPercent() || style.maxDimension(dim).isPercent()) return true;
+	return style.flexBasis().isPercent() || style.gap(Gutter.Column).isPercent() || style.gap(Gutter.Row).isPercent() || style.gap(Gutter.All).isPercent();
+}
+function hasNonZeroFlex(node) {
+	const style = node.style;
+	const flex = style.flex();
+	const flexGrow = style.flexGrow();
+	const flexShrink = style.flexShrink();
+	const config = node.config;
+	const canGrow = isDefined(flexGrow) ? flexGrow !== 0 : isDefined(flex) && flex > 0;
+	const canShrink = isDefined(flexShrink) ? flexShrink !== 0 : config.useWebDefaults() || isDefined(flex) && flex < 0;
+	return canGrow || canShrink;
+}
+function isHeightFitContentIndependent(node) {
+	const style = node.style;
+	const height = style.dimension(Dimension.Height);
+	const flexBasis = style.flexBasis();
+	const hasRelativePercentPosition = style.position(Edge.Top).isPercent() || style.position(Edge.Bottom).isPercent() || style.position(Edge.Vertical).isPercent() || style.position(Edge.All).isPercent();
+	return !node.hasMeasureFunc() && !node.hasBaselineFunc() && !node.isReferenceBaseline_ && (height.isAuto() || height.isUndefined()) && style.minDimension(Dimension.Height).isUndefined() && style.maxDimension(Dimension.Height).isUndefined() && (flexBasis.isAuto() || flexBasis.isUndefined()) && !hasNonZeroFlex(node) && style.boxSizing() === 0 && !isDefined(style.aspectRatio()) && style.positionType() !== PositionType.Absolute && style.overflow() !== Overflow.Scroll && style.display() === Display.Flex && isColumn(style.flexDirection()) && style.alignItems() === Align.Stretch && (style.alignSelf() === Align.Auto || style.alignSelf() === Align.Stretch) && style.justifyContent() === Justify.FlexStart && style.flexWrap() === Wrap.NoWrap && !style.gap(Gutter.All).isDefined() && !style.gap(Gutter.Row).isDefined() && !hasRelativePercentPosition && !hasNonZeroVerticalSpacing(style) && !hasPercentageLength(style);
+}
+function canSkipHeightFitContent(root) {
+	if (root === null) return false;
+	const maxPendingNodes = 64;
+	const stack = [root];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (!isHeightFitContentIndependent(node)) return false;
+		for (const child of node.getLayoutChildren()) {
+			if (stack.length === maxPendingNodes) return false;
+			stack.push(child);
+		}
+	}
+	return true;
+}
+const scratchModeA = {
+	mode: SizingMode.StretchFit,
+	size: 0
+};
+const scratchModeB = {
+	mode: SizingMode.StretchFit,
+	size: 0
+};
+function constrainMaxSizeForMode(node, direction, axis, ownerAxisSize, ownerWidth, modeAndSize) {
+	const maxSize = node.style.resolvedMaxDimension(direction, dimension(axis), ownerAxisSize, ownerWidth) + node.style.computeMarginForAxis(axis, ownerWidth);
+	switch (modeAndSize.mode) {
+		case SizingMode.StretchFit:
+		case SizingMode.FitContent:
+			modeAndSize.size = isUndefined(maxSize) || modeAndSize.size < maxSize ? modeAndSize.size : maxSize;
+			break;
+		case SizingMode.MaxContent: if (isDefined(maxSize)) {
+			modeAndSize.mode = SizingMode.FitContent;
+			modeAndSize.size = maxSize;
+		}
+	}
+}
+function computeFlexBasisForChild(node, child, width, widthMode, height, ownerWidth, ownerHeight, heightMode, direction, layoutMarkerData, depth, generationCount) {
+	const mainAxis = resolveDirection(node.style.flexDirection(), direction);
+	const isMainAxisRow = isRow(mainAxis);
+	const mainAxisSize = isMainAxisRow ? width : height;
+	const mainAxisOwnerSize = isMainAxisRow ? ownerWidth : ownerHeight;
+	let childWidth = NaN;
+	let childHeight = NaN;
+	let childWidthSizingMode;
+	let childHeightSizingMode;
+	const resolvedFlexBasis = child.resolveFlexBasis(direction, mainAxis, mainAxisOwnerSize, ownerWidth);
+	const isRowStyleDimDefined = child.hasDefiniteLength(Dimension.Width, ownerWidth);
+	const isColumnStyleDimDefined = child.hasDefiniteLength(Dimension.Height, ownerHeight);
+	const fixFlexBasisFitContent = node.config.isExperimentalFeatureEnabled(ExperimentalFeature.FixFlexBasisFitContent);
+	if (isDefined(resolvedFlexBasis) && isDefined(mainAxisSize)) {
+		if (isUndefined(child.layout.computedFlexBasis) || child.config.isExperimentalFeatureEnabled(ExperimentalFeature.WebFlexBasis) && child.layout.computedFlexBasisGeneration !== generationCount) {
+			const paddingAndBorder = paddingAndBorderForAxis(child, mainAxis, direction, ownerWidth);
+			child.setLayoutComputedFlexBasis(maxOrDefined(resolvedFlexBasis, paddingAndBorder));
+		}
+	} else if (isMainAxisRow && isRowStyleDimDefined) {
+		const paddingAndBorder = paddingAndBorderForAxis(child, FlexDirection.Row, direction, ownerWidth);
+		child.setLayoutComputedFlexBasis(maxOrDefined(child.getResolvedDimension(direction, Dimension.Width, ownerWidth, ownerWidth), paddingAndBorder));
+	} else if (!isMainAxisRow && isColumnStyleDimDefined) {
+		const paddingAndBorder = paddingAndBorderForAxis(child, FlexDirection.Column, direction, ownerWidth);
+		child.setLayoutComputedFlexBasis(maxOrDefined(child.getResolvedDimension(direction, Dimension.Height, ownerHeight, ownerWidth), paddingAndBorder));
+	} else {
+		childWidthSizingMode = SizingMode.MaxContent;
+		childHeightSizingMode = SizingMode.MaxContent;
+		const marginRow = child.style.computeMarginForAxis(FlexDirection.Row, ownerWidth);
+		const marginColumn = child.style.computeMarginForAxis(FlexDirection.Column, ownerWidth);
+		if (isRowStyleDimDefined) {
+			childWidth = child.getResolvedDimension(direction, Dimension.Width, ownerWidth, ownerWidth) + marginRow;
+			childWidthSizingMode = SizingMode.StretchFit;
+		}
+		if (isColumnStyleDimDefined) {
+			childHeight = child.getResolvedDimension(direction, Dimension.Height, ownerHeight, ownerWidth) + marginColumn;
+			childHeightSizingMode = SizingMode.StretchFit;
+		}
+		if (!isMainAxisRow && node.style.overflow() === Overflow.Scroll || node.style.overflow() !== Overflow.Scroll) {
+			if (isUndefined(childWidth) && isDefined(width)) {
+				childWidth = width;
+				childWidthSizingMode = SizingMode.FitContent;
+			}
+		}
+		const parentDoesNotScroll = node.style.overflow() !== Overflow.Scroll;
+		let applyHeightFitContent = isMainAxisRow || parentDoesNotScroll;
+		if (fixFlexBasisFitContent) {
+			const childHadOverflow = child.isDirty() && child.layout.hadOverflow();
+			const hasHeightIndependentSubtree = !isMainAxisRow && parentDoesNotScroll && isUndefined(childHeight) && isDefined(height) && isColumnStretchEdge(node, child) && isInColumnStretchScrollSubtree(node) && canSkipHeightFitContent(child);
+			if (hasHeightIndependentSubtree && childHadOverflow) child.setLayoutHadOverflow(false);
+			if (hasHeightIndependentSubtree) applyHeightFitContent = false;
+		}
+		if (applyHeightFitContent && isUndefined(childHeight) && isDefined(height)) {
+			childHeight = height;
+			childHeightSizingMode = SizingMode.FitContent;
+		}
+		const childStyle = child.style;
+		if (isDefined(childStyle.aspectRatio())) {
+			if (!isMainAxisRow && childWidthSizingMode === SizingMode.StretchFit) {
+				childHeight = marginColumn + (childWidth - marginRow) / childStyle.aspectRatio();
+				childHeightSizingMode = SizingMode.StretchFit;
+			} else if (isMainAxisRow && childHeightSizingMode === SizingMode.StretchFit) {
+				childWidth = marginRow + (childHeight - marginColumn) * childStyle.aspectRatio();
+				childWidthSizingMode = SizingMode.StretchFit;
+			}
+		}
+		const hasExactWidth = isDefined(width) && widthMode === SizingMode.StretchFit;
+		const childWidthStretch = resolveChildAlignment(node, child) === Align.Stretch && childWidthSizingMode !== SizingMode.StretchFit;
+		if (!isMainAxisRow && !isRowStyleDimDefined && hasExactWidth && childWidthStretch) {
+			childWidth = width;
+			childWidthSizingMode = SizingMode.StretchFit;
+			if (isDefined(childStyle.aspectRatio())) {
+				childHeight = (childWidth - marginRow) / childStyle.aspectRatio();
+				childHeightSizingMode = SizingMode.StretchFit;
+			}
+		}
+		const hasExactHeight = isDefined(height) && heightMode === SizingMode.StretchFit;
+		const childHeightStretch = resolveChildAlignment(node, child) === Align.Stretch && childHeightSizingMode !== SizingMode.StretchFit;
+		if (isMainAxisRow && !isColumnStyleDimDefined && hasExactHeight && childHeightStretch) {
+			childHeight = height;
+			childHeightSizingMode = SizingMode.StretchFit;
+			if (isDefined(childStyle.aspectRatio())) {
+				childWidth = (childHeight - marginColumn) * childStyle.aspectRatio();
+				childWidthSizingMode = SizingMode.StretchFit;
+			}
+		}
+		const widthModeAndSize = scratchModeA;
+		widthModeAndSize.mode = childWidthSizingMode;
+		widthModeAndSize.size = childWidth;
+		constrainMaxSizeForMode(child, direction, FlexDirection.Row, ownerWidth, ownerWidth, widthModeAndSize);
+		const heightModeAndSize = scratchModeB;
+		heightModeAndSize.mode = childHeightSizingMode;
+		heightModeAndSize.size = childHeight;
+		constrainMaxSizeForMode(child, direction, FlexDirection.Column, ownerHeight, ownerWidth, heightModeAndSize);
+		calculateLayoutInternal(child, widthModeAndSize.size, heightModeAndSize.size, direction, widthModeAndSize.mode, heightModeAndSize.mode, ownerWidth, ownerHeight, false, LayoutPassReason.MeasureChild, layoutMarkerData, depth, generationCount);
+		child.setLayoutComputedFlexBasis(maxOrDefined(child.layout.measuredDimension(dimension(mainAxis)), paddingAndBorderForAxis(child, mainAxis, direction, ownerWidth)));
+	}
+	child.setLayoutComputedFlexBasisGeneration(generationCount);
+}
+function measureNodeWithMeasureFunc(node, direction, availableWidth, availableHeight, widthSizingMode, heightSizingMode, ownerWidth, ownerHeight, layoutMarkerData) {
+	if (widthSizingMode === SizingMode.MaxContent) availableWidth = NaN;
+	if (heightSizingMode === SizingMode.MaxContent) availableHeight = NaN;
+	const layout = node.layout;
+	const paddingAndBorderAxisRow = layout.padding(PhysicalEdge.Left) + layout.padding(PhysicalEdge.Right) + layout.border(PhysicalEdge.Left) + layout.border(PhysicalEdge.Right);
+	const paddingAndBorderAxisColumn = layout.padding(PhysicalEdge.Top) + layout.padding(PhysicalEdge.Bottom) + layout.border(PhysicalEdge.Top) + layout.border(PhysicalEdge.Bottom);
+	const innerWidth = isUndefined(availableWidth) ? availableWidth : maxOrDefined(0, availableWidth - paddingAndBorderAxisRow);
+	const innerHeight = isUndefined(availableHeight) ? availableHeight : maxOrDefined(0, availableHeight - paddingAndBorderAxisColumn);
+	if (widthSizingMode === SizingMode.StretchFit && heightSizingMode === SizingMode.StretchFit) {
+		node.setLayoutMeasuredDimension(boundAxis(node, FlexDirection.Row, direction, availableWidth, ownerWidth, ownerWidth), Dimension.Width);
+		node.setLayoutMeasuredDimension(boundAxis(node, FlexDirection.Column, direction, availableHeight, ownerHeight, ownerWidth), Dimension.Height);
+	} else {
+		const measuredSize = node.measure(innerWidth, measureMode(widthSizingMode), innerHeight, measureMode(heightSizingMode));
+		layoutMarkerData.measureCallbacks += 1;
+		node.setLayoutMeasuredDimension(boundAxis(node, FlexDirection.Row, direction, widthSizingMode === SizingMode.MaxContent || widthSizingMode === SizingMode.FitContent ? measuredSize.width + paddingAndBorderAxisRow : availableWidth, ownerWidth, ownerWidth), Dimension.Width);
+		node.setLayoutMeasuredDimension(boundAxis(node, FlexDirection.Column, direction, heightSizingMode === SizingMode.MaxContent || heightSizingMode === SizingMode.FitContent ? measuredSize.height + paddingAndBorderAxisColumn : availableHeight, ownerHeight, ownerWidth), Dimension.Height);
+	}
+}
+function measureNodeWithoutChildren(node, direction, availableWidth, availableHeight, widthSizingMode, heightSizingMode, ownerWidth, ownerHeight) {
+	const layout = node.layout;
+	let width = availableWidth;
+	if (widthSizingMode === SizingMode.MaxContent || widthSizingMode === SizingMode.FitContent) width = layout.padding(PhysicalEdge.Left) + layout.padding(PhysicalEdge.Right) + layout.border(PhysicalEdge.Left) + layout.border(PhysicalEdge.Right);
+	node.setLayoutMeasuredDimension(boundAxis(node, FlexDirection.Row, direction, width, ownerWidth, ownerWidth), Dimension.Width);
+	let height = availableHeight;
+	if (heightSizingMode === SizingMode.MaxContent || heightSizingMode === SizingMode.FitContent) height = layout.padding(PhysicalEdge.Top) + layout.padding(PhysicalEdge.Bottom) + layout.border(PhysicalEdge.Top) + layout.border(PhysicalEdge.Bottom);
+	node.setLayoutMeasuredDimension(boundAxis(node, FlexDirection.Column, direction, height, ownerHeight, ownerWidth), Dimension.Height);
+}
+function isFixedSize(dim, sizingMode) {
+	return sizingMode === SizingMode.StretchFit || isDefined(dim) && sizingMode === SizingMode.FitContent && dim <= 0;
+}
+function measureNodeWithFixedSize(node, direction, availableWidth, availableHeight, widthSizingMode, heightSizingMode, ownerWidth, ownerHeight) {
+	if (isFixedSize(availableWidth, widthSizingMode) && isFixedSize(availableHeight, heightSizingMode)) {
+		node.setLayoutMeasuredDimension(boundAxis(node, FlexDirection.Row, direction, isUndefined(availableWidth) || widthSizingMode === SizingMode.FitContent && availableWidth < 0 ? 0 : availableWidth, ownerWidth, ownerWidth), Dimension.Width);
+		node.setLayoutMeasuredDimension(boundAxis(node, FlexDirection.Column, direction, isUndefined(availableHeight) || heightSizingMode === SizingMode.FitContent && availableHeight < 0 ? 0 : availableHeight, ownerHeight, ownerWidth), Dimension.Height);
+		return true;
+	}
+	return false;
+}
+function zeroOutLayoutRecursively(node) {
+	node.layout = new LayoutResults();
+	node.setLayoutDimension(0, Dimension.Width);
+	node.setLayoutDimension(0, Dimension.Height);
+	node.hasNewLayout_ = true;
+	node.cloneChildrenIfNeeded();
+	for (const child of node.children) zeroOutLayoutRecursively(child);
+}
+function cleanupContentsNodesRecursively(node, didPerformLayout) {
+	if (node.hasContentsChildren()) {
+		node.cloneContentsChildrenIfNeeded();
+		for (const child of node.children) if (child.style.display() === Display.Contents) {
+			child.layout = new LayoutResults();
+			child.setLayoutDimension(0, Dimension.Width);
+			child.setLayoutDimension(0, Dimension.Height);
+			if (didPerformLayout) child.hasNewLayout_ = true;
+			child.setDirty(false);
+			child.cloneChildrenIfNeeded();
+			cleanupContentsNodesRecursively(child, didPerformLayout);
+		}
+	}
+}
+function calculateAvailableInnerDimension(node, direction, dim, availableDim, paddingAndBorder, ownerDim, ownerWidth) {
+	let availableInnerDim = availableDim - paddingAndBorder;
+	if (isDefined(availableInnerDim)) {
+		const minDimensionOptional = node.style.resolvedMinDimension(direction, dim, ownerDim, ownerWidth);
+		const minInnerDim = isUndefined(minDimensionOptional) ? 0 : minDimensionOptional - paddingAndBorder;
+		const maxDimensionOptional = node.style.resolvedMaxDimension(direction, dim, ownerDim, ownerWidth);
+		const maxInnerDim = isUndefined(maxDimensionOptional) ? Number.MAX_VALUE : maxDimensionOptional - paddingAndBorder;
+		availableInnerDim = maxOrDefined(minOrDefined(availableInnerDim, maxInnerDim), minInnerDim);
+	}
+	return availableInnerDim;
+}
+function computeFlexBasisForChildren(node, layoutChildren, availableInnerWidth, availableInnerHeight, ownerWidth, ownerHeight, widthSizingMode, heightSizingMode, direction, mainAxis, performLayout, layoutMarkerData, depth, generationCount) {
+	let totalOuterFlexBasis = 0;
+	let singleFlexChild = null;
+	if ((isRow(mainAxis) ? widthSizingMode : heightSizingMode) === SizingMode.StretchFit) {
+		for (const child of layoutChildren) if (child.isNodeFlexible()) {
+			if (singleFlexChild !== null || inexactEquals(child.resolveFlexGrow(), 0) || inexactEquals(child.resolveFlexShrink(), 0)) {
+				singleFlexChild = null;
+				break;
+			} else singleFlexChild = child;
+		}
+	}
+	for (const child of layoutChildren) {
+		child.processDimensions();
+		if (child.style.display() === Display.None) {
+			if (performLayout) {
+				zeroOutLayoutRecursively(child);
+				child.hasNewLayout_ = true;
+				child.setDirty(false);
+			}
+			continue;
+		}
+		if (performLayout) {
+			const childDirection = child.resolveDirection(direction);
+			child.setPositionFromStyle(childDirection, availableInnerWidth, availableInnerHeight);
+		}
+		if (child.style.positionType() === PositionType.Absolute) continue;
+		if (child === singleFlexChild) {
+			child.setLayoutComputedFlexBasisGeneration(generationCount);
+			child.setLayoutComputedFlexBasis(0);
+		} else computeFlexBasisForChild(node, child, availableInnerWidth, widthSizingMode, availableInnerHeight, ownerWidth, ownerHeight, heightSizingMode, direction, layoutMarkerData, depth, generationCount);
+		totalOuterFlexBasis += child.layout.computedFlexBasis + child.style.computeMarginForAxis(mainAxis, availableInnerWidth);
+	}
+	return totalOuterFlexBasis;
+}
+function computeMinContentMainSize(node, requestedAxis, ownerDirection, ownerWidth, ownerHeight) {
+	const wantRow = isRow(requestedAxis);
+	if (node.hasMeasureFunc()) {
+		const size = node.measure(wantRow ? 0 : NaN, wantRow ? MeasureMode.AtMost : MeasureMode.Undefined, wantRow ? NaN : 0, wantRow ? MeasureMode.Undefined : MeasureMode.AtMost);
+		const leafDirection = node.resolveDirection(ownerDirection);
+		const paddingAndBorder = node.style.computeFlexStartPaddingAndBorder(requestedAxis, leafDirection, ownerWidth) + node.style.computeFlexEndPaddingAndBorder(requestedAxis, leafDirection, ownerWidth);
+		return (wantRow ? size.width : size.height) + paddingAndBorder;
+	}
+	if (node.getChildCount() === 0) return 0;
+	const direction = node.resolveDirection(ownerDirection);
+	const nodeMainAxis = resolveDirection(node.style.flexDirection(), direction);
+	const nodeCrossAxis = resolveCrossDirection(nodeMainAxis, direction);
+	let mainTotal = 0;
+	let crossMax = 0;
+	for (let i = 0; i < node.getChildCount(); i++) {
+		const child = node.getChild(i);
+		if (child.style.display() === Display.None || child.style.positionType() === PositionType.Absolute) continue;
+		let childMain = computeMinContentMainSize(child, nodeMainAxis, direction, ownerWidth, ownerHeight);
+		childMain += child.style.computeMarginForAxis(nodeMainAxis, ownerWidth);
+		let childCross = computeMinContentMainSize(child, nodeCrossAxis, direction, ownerWidth, ownerHeight);
+		childCross += child.style.computeMarginForAxis(nodeCrossAxis, ownerWidth);
+		mainTotal += childMain;
+		crossMax = Math.max(crossMax, childCross);
+	}
+	mainTotal += node.style.computeFlexStartPaddingAndBorder(nodeMainAxis, direction, ownerWidth) + node.style.computeFlexEndPaddingAndBorder(nodeMainAxis, direction, ownerWidth);
+	crossMax += node.style.computeFlexStartPaddingAndBorder(nodeCrossAxis, direction, ownerWidth) + node.style.computeFlexEndPaddingAndBorder(nodeCrossAxis, direction, ownerWidth);
+	const nodeMainIsRow = isRow(nodeMainAxis);
+	return wantRow ? nodeMainIsRow ? mainTotal : crossMax : nodeMainIsRow ? crossMax : mainTotal;
+}
+function computeAutoMinMainSize(child, mainAxis, direction, ownerMainAxisSize, ownerWidth, ownerHeight) {
+	if (child.hasErrata(Errata.MinSizeUndefinedInsteadOfAuto)) return NaN;
+	if (child.style.display() === Display.None) return NaN;
+	if (child.style.minDimension(dimension(mainAxis)).isDefined()) return NaN;
+	if (child.style.overflow() !== Overflow.Visible) return 0;
+	const mainDim = dimension(mainAxis);
+	const crossDim = isRow(mainAxis) ? Dimension.Height : Dimension.Width;
+	const isMainAxisRow = isRow(mainAxis);
+	const specifiedMain = child.getResolvedDimension(direction, mainDim, ownerMainAxisSize, ownerWidth);
+	let transferredMain = NaN;
+	const aspectRatio = child.style.aspectRatio();
+	if (isDefined(aspectRatio)) {
+		const crossOwner = isMainAxisRow ? ownerHeight : ownerWidth;
+		const crossResolved = child.getResolvedDimension(direction, crossDim, crossOwner, ownerWidth);
+		if (isDefined(crossResolved)) transferredMain = isMainAxisRow ? crossResolved * aspectRatio : crossResolved / aspectRatio;
+	}
+	let floor = computeMinContentMainSize(child, mainAxis, direction, ownerWidth, ownerHeight);
+	if (isDefined(specifiedMain)) {
+		if (isUndefined(floor) || specifiedMain < floor) floor = specifiedMain;
+	} else if (isDefined(transferredMain)) {
+		if (isUndefined(floor) || transferredMain < floor) floor = transferredMain;
+	}
+	const maxMain = child.style.resolvedMaxDimension(direction, mainDim, ownerMainAxisSize, ownerWidth);
+	if (isDefined(maxMain) && floor > maxMain) floor = maxMain;
+	if (isUndefined(floor) || floor < 0) floor = 0;
+	return floor;
+}
+function boundAxisWithAutoMin(child, axis, direction, value, axisSize, widthSize) {
+	let bounded = boundAxis(child, axis, direction, value, axisSize, widthSize);
+	const autoMin = child.layout.computedAutoMinMainSize;
+	if (isDefined(autoMin) && bounded < autoMin) bounded = autoMin;
+	return bounded;
+}
+function distributeFreeSpaceSecondPass(flexLine, node, mainAxis, crossAxis, direction, ownerWidth, mainAxisOwnerSize, availableInnerMainDim, availableInnerCrossDim, availableInnerWidth, availableInnerHeight, mainAxisOverflows, sizingModeCrossDim, performLayout, layoutMarkerData, depth, generationCount) {
+	let childFlexBasis = 0;
+	let flexShrinkScaledFactor = 0;
+	let flexGrowFactor = 0;
+	let deltaFreeSpace = 0;
+	const isMainAxisRow = isRow(mainAxis);
+	const isNodeFlexWrap = node.style.flexWrap() !== Wrap.NoWrap;
+	for (const currentLineChild of flexLine.itemsInFlow) {
+		childFlexBasis = boundAxisWithinMinAndMax(currentLineChild, direction, mainAxis, currentLineChild.layout.computedFlexBasis, mainAxisOwnerSize, ownerWidth);
+		let updatedMainSize = childFlexBasis;
+		if (isDefined(flexLine.layout.remainingFreeSpace) && flexLine.layout.remainingFreeSpace < 0) {
+			flexShrinkScaledFactor = -currentLineChild.resolveFlexShrink() * childFlexBasis;
+			if (flexShrinkScaledFactor !== 0) {
+				let childSize = NaN;
+				if (isDefined(flexLine.layout.totalFlexShrinkScaledFactors) && flexLine.layout.totalFlexShrinkScaledFactors === 0) childSize = childFlexBasis + flexShrinkScaledFactor;
+				else childSize = childFlexBasis + flexLine.layout.remainingFreeSpace / flexLine.layout.totalFlexShrinkScaledFactors * flexShrinkScaledFactor;
+				updatedMainSize = boundAxisWithAutoMin(currentLineChild, mainAxis, direction, childSize, availableInnerMainDim, availableInnerWidth);
+			}
+		} else if (isDefined(flexLine.layout.remainingFreeSpace) && flexLine.layout.remainingFreeSpace > 0) {
+			flexGrowFactor = currentLineChild.resolveFlexGrow();
+			if (!Number.isNaN(flexGrowFactor) && flexGrowFactor !== 0) updatedMainSize = boundAxisWithAutoMin(currentLineChild, mainAxis, direction, childFlexBasis + flexLine.layout.remainingFreeSpace / flexLine.layout.totalFlexGrowFactors * flexGrowFactor, availableInnerMainDim, availableInnerWidth);
+		}
+		deltaFreeSpace += updatedMainSize - childFlexBasis;
+		const marginMain = currentLineChild.style.computeMarginForAxis(mainAxis, availableInnerWidth);
+		const marginCross = currentLineChild.style.computeMarginForAxis(crossAxis, availableInnerWidth);
+		let childCrossSize = NaN;
+		const childMainSize = updatedMainSize + marginMain;
+		let childCrossSizingMode;
+		const childMainSizingMode = SizingMode.StretchFit;
+		const crossDim = dimension(crossAxis);
+		const hasDefiniteCrossLength = currentLineChild.hasDefiniteLength(crossDim, availableInnerCrossDim);
+		const childAlignment = resolveChildAlignment(node, currentLineChild);
+		const crossStartMarginIsAuto = currentLineChild.style.flexStartMarginIsAuto(crossAxis, direction);
+		const crossEndMarginIsAuto = currentLineChild.style.flexEndMarginIsAuto(crossAxis, direction);
+		const childStyle = currentLineChild.style;
+		if (isDefined(childStyle.aspectRatio())) {
+			childCrossSize = isMainAxisRow ? (childMainSize - marginMain) / childStyle.aspectRatio() : (childMainSize - marginMain) * childStyle.aspectRatio();
+			childCrossSizingMode = SizingMode.StretchFit;
+			childCrossSize += marginCross;
+		} else if (!Number.isNaN(availableInnerCrossDim) && !hasDefiniteCrossLength && sizingModeCrossDim === SizingMode.StretchFit && !(isNodeFlexWrap && mainAxisOverflows) && childAlignment === Align.Stretch && !crossStartMarginIsAuto && !crossEndMarginIsAuto) {
+			childCrossSize = availableInnerCrossDim;
+			childCrossSizingMode = SizingMode.StretchFit;
+		} else if (!hasDefiniteCrossLength) {
+			childCrossSize = availableInnerCrossDim;
+			childCrossSizingMode = isUndefined(childCrossSize) ? SizingMode.MaxContent : SizingMode.FitContent;
+		} else {
+			childCrossSize = currentLineChild.getResolvedDimension(direction, crossDim, availableInnerCrossDim, availableInnerWidth) + marginCross;
+			const isLoosePercentageMeasurement = currentLineChild.getProcessedDimension(crossDim).isPercent() && sizingModeCrossDim !== SizingMode.StretchFit;
+			childCrossSizingMode = isUndefined(childCrossSize) || isLoosePercentageMeasurement ? SizingMode.MaxContent : SizingMode.StretchFit;
+		}
+		const mainModeAndSize = scratchModeA;
+		mainModeAndSize.mode = childMainSizingMode;
+		mainModeAndSize.size = childMainSize;
+		constrainMaxSizeForMode(currentLineChild, direction, mainAxis, availableInnerMainDim, availableInnerWidth, mainModeAndSize);
+		const crossModeAndSize = scratchModeB;
+		crossModeAndSize.mode = childCrossSizingMode;
+		crossModeAndSize.size = childCrossSize;
+		constrainMaxSizeForMode(currentLineChild, direction, crossAxis, availableInnerCrossDim, availableInnerWidth, crossModeAndSize);
+		const requiresStretchLayout = !hasDefiniteCrossLength && childAlignment === Align.Stretch && !crossStartMarginIsAuto && !crossEndMarginIsAuto;
+		const childWidth = isMainAxisRow ? mainModeAndSize.size : crossModeAndSize.size;
+		const childHeight = !isMainAxisRow ? mainModeAndSize.size : crossModeAndSize.size;
+		const childWidthSizingMode = isMainAxisRow ? mainModeAndSize.mode : crossModeAndSize.mode;
+		const childHeightSizingMode = !isMainAxisRow ? mainModeAndSize.mode : crossModeAndSize.mode;
+		const isLayoutPass = performLayout && !requiresStretchLayout;
+		calculateLayoutInternal(currentLineChild, childWidth, childHeight, node.layout.direction(), childWidthSizingMode, childHeightSizingMode, availableInnerWidth, availableInnerHeight, isLayoutPass, isLayoutPass ? LayoutPassReason.FlexLayout : LayoutPassReason.FlexMeasure, layoutMarkerData, depth, generationCount);
+		node.setLayoutHadOverflow(node.layout.hadOverflow() || currentLineChild.layout.hadOverflow());
+	}
+	return deltaFreeSpace;
+}
+function distributeFreeSpaceFirstPass(flexLine, direction, mainAxis, ownerWidth, mainAxisOwnerSize, availableInnerMainDim, availableInnerWidth) {
+	let flexShrinkScaledFactor = 0;
+	let flexGrowFactor = 0;
+	let baseMainSize = 0;
+	let boundMainSize = 0;
+	let deltaFreeSpace = 0;
+	for (const currentLineChild of flexLine.itemsInFlow) {
+		const childFlexBasis = boundAxisWithinMinAndMax(currentLineChild, direction, mainAxis, currentLineChild.layout.computedFlexBasis, mainAxisOwnerSize, ownerWidth);
+		if (flexLine.layout.remainingFreeSpace < 0) {
+			flexShrinkScaledFactor = -currentLineChild.resolveFlexShrink() * childFlexBasis;
+			if (isDefined(flexShrinkScaledFactor) && flexShrinkScaledFactor !== 0) {
+				baseMainSize = childFlexBasis + flexLine.layout.remainingFreeSpace / flexLine.layout.totalFlexShrinkScaledFactors * flexShrinkScaledFactor;
+				boundMainSize = boundAxisWithAutoMin(currentLineChild, mainAxis, direction, baseMainSize, availableInnerMainDim, availableInnerWidth);
+				if (isDefined(baseMainSize) && isDefined(boundMainSize) && baseMainSize !== boundMainSize) {
+					deltaFreeSpace += boundMainSize - childFlexBasis;
+					flexLine.layout.totalFlexShrinkScaledFactors -= -currentLineChild.resolveFlexShrink() * currentLineChild.layout.computedFlexBasis;
+				}
+			}
+		} else if (isDefined(flexLine.layout.remainingFreeSpace) && flexLine.layout.remainingFreeSpace > 0) {
+			flexGrowFactor = currentLineChild.resolveFlexGrow();
+			if (isDefined(flexGrowFactor) && flexGrowFactor !== 0) {
+				baseMainSize = childFlexBasis + flexLine.layout.remainingFreeSpace / flexLine.layout.totalFlexGrowFactors * flexGrowFactor;
+				boundMainSize = boundAxis(currentLineChild, mainAxis, direction, baseMainSize, availableInnerMainDim, availableInnerWidth);
+				if (isDefined(baseMainSize) && isDefined(boundMainSize) && baseMainSize !== boundMainSize) {
+					deltaFreeSpace += boundMainSize - childFlexBasis;
+					flexLine.layout.totalFlexGrowFactors -= flexGrowFactor;
+				}
+			}
+		}
+	}
+	flexLine.layout.remainingFreeSpace -= deltaFreeSpace;
+}
+function resolveFlexibleLength(node, flexLine, mainAxis, crossAxis, direction, ownerWidth, mainAxisOwnerSize, availableInnerMainDim, availableInnerCrossDim, availableInnerWidth, availableInnerHeight, mainAxisOverflows, sizingModeCrossDim, performLayout, layoutMarkerData, depth, generationCount) {
+	const originalFreeSpace = flexLine.layout.remainingFreeSpace;
+	if (!node.hasErrata(Errata.MinSizeUndefinedInsteadOfAuto)) for (const currentLineChild of flexLine.itemsInFlow) currentLineChild.layout.computedAutoMinMainSize = computeAutoMinMainSize(currentLineChild, mainAxis, direction, mainAxisOwnerSize, availableInnerWidth, availableInnerHeight);
+	else for (const currentLineChild of flexLine.itemsInFlow) currentLineChild.layout.computedAutoMinMainSize = NaN;
+	distributeFreeSpaceFirstPass(flexLine, direction, mainAxis, ownerWidth, mainAxisOwnerSize, availableInnerMainDim, availableInnerWidth);
+	const distributedFreeSpace = distributeFreeSpaceSecondPass(flexLine, node, mainAxis, crossAxis, direction, ownerWidth, mainAxisOwnerSize, availableInnerMainDim, availableInnerCrossDim, availableInnerWidth, availableInnerHeight, mainAxisOverflows, sizingModeCrossDim, performLayout, layoutMarkerData, depth, generationCount);
+	flexLine.layout.remainingFreeSpace = originalFreeSpace - distributedFreeSpace;
+}
+function justifyMainAxis(node, flexLine, mainAxis, crossAxis, direction, sizingModeMainDim, sizingModeCrossDim, mainAxisOwnerSize, ownerWidth, availableInnerMainDim, availableInnerCrossDim, availableInnerWidth, performLayout) {
+	const style = node.style;
+	const leadingPaddingAndBorderMain = node.style.computeFlexStartPaddingAndBorder(mainAxis, direction, ownerWidth);
+	const trailingPaddingAndBorderMain = node.style.computeFlexEndPaddingAndBorder(mainAxis, direction, ownerWidth);
+	const gap = node.style.computeGapForAxis(mainAxis, availableInnerMainDim);
+	if (sizingModeMainDim === SizingMode.FitContent && flexLine.layout.remainingFreeSpace > 0) {
+		if (style.minDimension(dimension(mainAxis)).isDefined() && isDefined(style.resolvedMinDimension(direction, dimension(mainAxis), mainAxisOwnerSize, ownerWidth))) {
+			const minAvailableMainDim = style.resolvedMinDimension(direction, dimension(mainAxis), mainAxisOwnerSize, ownerWidth) - leadingPaddingAndBorderMain - trailingPaddingAndBorderMain;
+			const occupiedSpaceByChildNodes = availableInnerMainDim - flexLine.layout.remainingFreeSpace;
+			flexLine.layout.remainingFreeSpace = maxOrDefined(0, minAvailableMainDim - occupiedSpaceByChildNodes);
+		} else flexLine.layout.remainingFreeSpace = 0;
+	}
+	let leadingMainDim = 0;
+	let betweenMainDim = gap;
+	const justifyContent = flexLine.layout.remainingFreeSpace >= 0 ? node.style.justifyContent() : fallbackJustification(node.style.justifyContent());
+	if (flexLine.numberOfAutoMargins === 0) switch (justifyContent) {
+		case Justify.Start:
+		case Justify.End:
+		case Justify.Auto: break;
+		case Justify.Stretch: break;
+		case Justify.Center:
+			leadingMainDim = flexLine.layout.remainingFreeSpace / 2;
+			break;
+		case Justify.FlexEnd:
+			leadingMainDim = flexLine.layout.remainingFreeSpace;
+			break;
+		case Justify.SpaceBetween:
+			if (flexLine.itemsInFlow.length > 1) betweenMainDim += flexLine.layout.remainingFreeSpace / (flexLine.itemsInFlow.length - 1);
+			break;
+		case Justify.SpaceEvenly:
+			leadingMainDim = flexLine.layout.remainingFreeSpace / (flexLine.itemsInFlow.length + 1);
+			betweenMainDim += leadingMainDim;
+			break;
+		case Justify.SpaceAround:
+			leadingMainDim = .5 * flexLine.layout.remainingFreeSpace / flexLine.itemsInFlow.length;
+			betweenMainDim += leadingMainDim * 2;
+			break;
+		case Justify.FlexStart:
+	}
+	flexLine.layout.mainDim = leadingPaddingAndBorderMain + leadingMainDim;
+	flexLine.layout.crossDim = 0;
+	let maxAscentForCurrentLine = 0;
+	let maxDescentForCurrentLine = 0;
+	const isNodeBaselineLayout = isBaselineLayout(node);
+	for (const child of flexLine.itemsInFlow) {
+		const childLayout = child.layout;
+		if (child.style.flexStartMarginIsAuto(mainAxis, direction) && flexLine.layout.remainingFreeSpace > 0) flexLine.layout.mainDim += flexLine.layout.remainingFreeSpace / flexLine.numberOfAutoMargins;
+		if (performLayout) child.setLayoutPosition(childLayout.position(flexStartEdge(mainAxis)) + flexLine.layout.mainDim, flexStartEdge(mainAxis));
+		if (child !== flexLine.itemsInFlow[flexLine.itemsInFlow.length - 1]) flexLine.layout.mainDim += betweenMainDim;
+		if (child.style.flexEndMarginIsAuto(mainAxis, direction) && flexLine.layout.remainingFreeSpace > 0) flexLine.layout.mainDim += flexLine.layout.remainingFreeSpace / flexLine.numberOfAutoMargins;
+		if (!performLayout && sizingModeCrossDim === SizingMode.StretchFit) {
+			flexLine.layout.mainDim += child.style.computeMarginForAxis(mainAxis, availableInnerWidth) + boundAxisWithinMinAndMax(child, direction, mainAxis, childLayout.computedFlexBasis, mainAxisOwnerSize, ownerWidth);
+			flexLine.layout.crossDim = availableInnerCrossDim;
+		} else {
+			flexLine.layout.mainDim += child.dimensionWithMargin(mainAxis, availableInnerWidth);
+			if (isNodeBaselineLayout) {
+				const ascent = calculateBaseline(child) + child.style.computeFlexStartMargin(FlexDirection.Column, direction, availableInnerWidth);
+				const descent = child.layout.measuredDimension(Dimension.Height) + child.style.computeMarginForAxis(FlexDirection.Column, availableInnerWidth) - ascent;
+				maxAscentForCurrentLine = maxOrDefined(maxAscentForCurrentLine, ascent);
+				maxDescentForCurrentLine = maxOrDefined(maxDescentForCurrentLine, descent);
+			} else flexLine.layout.crossDim = maxOrDefined(flexLine.layout.crossDim, child.dimensionWithMargin(crossAxis, availableInnerWidth));
+		}
+	}
+	flexLine.layout.mainDim += trailingPaddingAndBorderMain;
+	if (isNodeBaselineLayout) flexLine.layout.crossDim = maxAscentForCurrentLine + maxDescentForCurrentLine;
+}
+function calculateLayoutImpl(node, availableWidth, availableHeight, ownerDirection, widthSizingMode, heightSizingMode, ownerWidth, ownerHeight, performLayout, _reason, layoutMarkerData, depth, generationCount) {
+	if (isUndefined(availableWidth) && widthSizingMode !== SizingMode.MaxContent) throw new Error("availableWidth is indefinite so widthSizingMode must be SizingMode::MaxContent");
+	if (isUndefined(availableHeight) && heightSizingMode !== SizingMode.MaxContent) throw new Error("availableHeight is indefinite so heightSizingMode must be SizingMode::MaxContent");
+	if (performLayout) layoutMarkerData.layouts += 1;
+	else layoutMarkerData.measures += 1;
+	const direction = node.resolveDirection(ownerDirection);
+	node.setLayoutDirection(direction);
+	const fixFlexBasisFitContent = node.config.isExperimentalFeatureEnabled(ExperimentalFeature.FixFlexBasisFitContent);
+	if (fixFlexBasisFitContent && performLayout) node.setLayoutHadOverflow(false);
+	const flexRowDirection = resolveDirection(FlexDirection.Row, direction);
+	const flexColumnDirection = resolveDirection(FlexDirection.Column, direction);
+	const startEdge = direction === Direction.LTR ? PhysicalEdge.Left : PhysicalEdge.Right;
+	const endEdge = direction === Direction.LTR ? PhysicalEdge.Right : PhysicalEdge.Left;
+	const marginRowLeading = node.style.computeInlineStartMargin(flexRowDirection, direction, ownerWidth);
+	node.setLayoutMargin(marginRowLeading, startEdge);
+	const marginRowTrailing = node.style.computeInlineEndMargin(flexRowDirection, direction, ownerWidth);
+	node.setLayoutMargin(marginRowTrailing, endEdge);
+	const marginColumnLeading = node.style.computeInlineStartMargin(flexColumnDirection, direction, ownerWidth);
+	node.setLayoutMargin(marginColumnLeading, PhysicalEdge.Top);
+	const marginColumnTrailing = node.style.computeInlineEndMargin(flexColumnDirection, direction, ownerWidth);
+	node.setLayoutMargin(marginColumnTrailing, PhysicalEdge.Bottom);
+	const marginAxisRow = marginRowLeading + marginRowTrailing;
+	const marginAxisColumn = marginColumnLeading + marginColumnTrailing;
+	node.setLayoutBorder(node.style.computeInlineStartBorder(flexRowDirection, direction), startEdge);
+	node.setLayoutBorder(node.style.computeInlineEndBorder(flexRowDirection, direction), endEdge);
+	node.setLayoutBorder(node.style.computeInlineStartBorder(flexColumnDirection, direction), PhysicalEdge.Top);
+	node.setLayoutBorder(node.style.computeInlineEndBorder(flexColumnDirection, direction), PhysicalEdge.Bottom);
+	node.setLayoutPadding(node.style.computeInlineStartPadding(flexRowDirection, direction, ownerWidth), startEdge);
+	node.setLayoutPadding(node.style.computeInlineEndPadding(flexRowDirection, direction, ownerWidth), endEdge);
+	node.setLayoutPadding(node.style.computeInlineStartPadding(flexColumnDirection, direction, ownerWidth), PhysicalEdge.Top);
+	node.setLayoutPadding(node.style.computeInlineEndPadding(flexColumnDirection, direction, ownerWidth), PhysicalEdge.Bottom);
+	if (node.hasMeasureFunc()) {
+		measureNodeWithMeasureFunc(node, direction, availableWidth - marginAxisRow, availableHeight - marginAxisColumn, widthSizingMode, heightSizingMode, ownerWidth, ownerHeight, layoutMarkerData);
+		cleanupContentsNodesRecursively(node, performLayout);
+		return;
+	}
+	const layoutChildren = node.getLayoutChildren();
+	const childCount = layoutChildren.length;
+	if (childCount === 0) {
+		measureNodeWithoutChildren(node, direction, availableWidth - marginAxisRow, availableHeight - marginAxisColumn, widthSizingMode, heightSizingMode, ownerWidth, ownerHeight);
+		cleanupContentsNodesRecursively(node, performLayout);
+		return;
+	}
+	if (!performLayout && measureNodeWithFixedSize(node, direction, availableWidth - marginAxisRow, availableHeight - marginAxisColumn, widthSizingMode, heightSizingMode, ownerWidth, ownerHeight)) {
+		cleanupContentsNodesRecursively(node, false);
+		return;
+	}
+	node.cloneChildrenIfNeeded();
+	if (!fixFlexBasisFitContent || !performLayout) node.setLayoutHadOverflow(false);
+	cleanupContentsNodesRecursively(node, performLayout);
+	const mainAxis = resolveDirection(node.style.flexDirection(), direction);
+	const crossAxis = resolveCrossDirection(mainAxis, direction);
+	const isMainAxisRow = isRow(mainAxis);
+	const isNodeFlexWrap = node.style.flexWrap() !== Wrap.NoWrap;
+	const mainAxisOwnerSize = isMainAxisRow ? ownerWidth : ownerHeight;
+	const crossAxisOwnerSize = isMainAxisRow ? ownerHeight : ownerWidth;
+	const paddingAndBorderAxisMain = paddingAndBorderForAxis(node, mainAxis, direction, ownerWidth);
+	const paddingAndBorderAxisCross = paddingAndBorderForAxis(node, crossAxis, direction, ownerWidth);
+	const leadingPaddingAndBorderCross = node.style.computeFlexStartPaddingAndBorder(crossAxis, direction, ownerWidth);
+	let sizingModeMainDim = isMainAxisRow ? widthSizingMode : heightSizingMode;
+	const sizingModeCrossDim = isMainAxisRow ? heightSizingMode : widthSizingMode;
+	const paddingAndBorderAxisRow = isMainAxisRow ? paddingAndBorderAxisMain : paddingAndBorderAxisCross;
+	const paddingAndBorderAxisColumn = isMainAxisRow ? paddingAndBorderAxisCross : paddingAndBorderAxisMain;
+	const availableInnerWidth = calculateAvailableInnerDimension(node, direction, Dimension.Width, availableWidth - marginAxisRow, paddingAndBorderAxisRow, ownerWidth, ownerWidth);
+	const availableInnerHeight = calculateAvailableInnerDimension(node, direction, Dimension.Height, availableHeight - marginAxisColumn, paddingAndBorderAxisColumn, ownerHeight, ownerWidth);
+	let availableInnerMainDim = isMainAxisRow ? availableInnerWidth : availableInnerHeight;
+	const availableInnerCrossDim = isMainAxisRow ? availableInnerHeight : availableInnerWidth;
+	let totalMainDim = 0;
+	totalMainDim += computeFlexBasisForChildren(node, layoutChildren, availableInnerWidth, availableInnerHeight, availableInnerWidth, availableInnerHeight, widthSizingMode, heightSizingMode, direction, mainAxis, performLayout, layoutMarkerData, depth, generationCount);
+	if (childCount > 1) totalMainDim += node.style.computeGapForAxis(mainAxis, availableInnerMainDim) * (childCount - 1);
+	const mainAxisOverflows = sizingModeMainDim !== SizingMode.MaxContent && totalMainDim > availableInnerMainDim;
+	if (isNodeFlexWrap && mainAxisOverflows && sizingModeMainDim === SizingMode.FitContent) sizingModeMainDim = SizingMode.StretchFit;
+	let startOfLineIndex = 0;
+	let lineCount = 0;
+	let totalLineCrossDim = 0;
+	const crossAxisGap = node.style.computeGapForAxis(crossAxis, availableInnerCrossDim);
+	let maxLineMainDim = 0;
+	const flexLine = node.layout.flexLine ??= {
+		itemsInFlow: [],
+		sizeConsumed: 0,
+		numberOfAutoMargins: 0,
+		endIndex: 0,
+		layout: {
+			totalFlexGrowFactors: 0,
+			totalFlexShrinkScaledFactors: 0,
+			remainingFreeSpace: 0,
+			mainDim: 0,
+			crossDim: 0
+		}
+	};
+	const lineStarts = node.layout.flexLineStarts ??= [];
+	for (; startOfLineIndex < layoutChildren.length; lineCount++) {
+		lineStarts[lineCount] = startOfLineIndex;
+		calculateFlexLine(node, ownerDirection, ownerWidth, mainAxisOwnerSize, availableInnerWidth, availableInnerMainDim, layoutChildren, startOfLineIndex, lineCount, flexLine);
+		startOfLineIndex = flexLine.endIndex;
+		const canSkipFlex = !performLayout && sizingModeCrossDim === SizingMode.StretchFit;
+		let sizeBasedOnContent = false;
+		if (sizingModeMainDim !== SizingMode.StretchFit) {
+			const style = node.style;
+			const minInnerWidth = style.resolvedMinDimension(direction, Dimension.Width, ownerWidth, ownerWidth) - paddingAndBorderAxisRow;
+			const maxInnerWidth = style.resolvedMaxDimension(direction, Dimension.Width, ownerWidth, ownerWidth) - paddingAndBorderAxisRow;
+			const minInnerHeight = style.resolvedMinDimension(direction, Dimension.Height, ownerHeight, ownerWidth) - paddingAndBorderAxisColumn;
+			const maxInnerHeight = style.resolvedMaxDimension(direction, Dimension.Height, ownerHeight, ownerWidth) - paddingAndBorderAxisColumn;
+			const minInnerMainDim = isMainAxisRow ? minInnerWidth : minInnerHeight;
+			const maxInnerMainDim = isMainAxisRow ? maxInnerWidth : maxInnerHeight;
+			if (isDefined(minInnerMainDim) && flexLine.sizeConsumed < minInnerMainDim) availableInnerMainDim = minInnerMainDim;
+			else if (isDefined(maxInnerMainDim) && flexLine.sizeConsumed > maxInnerMainDim) availableInnerMainDim = maxInnerMainDim;
+			else {
+				const useLegacyStretchBehaviour = node.hasErrata(Errata.StretchFlexBasis);
+				if (!useLegacyStretchBehaviour && (isDefined(flexLine.layout.totalFlexGrowFactors) && flexLine.layout.totalFlexGrowFactors === 0 || isDefined(node.resolveFlexGrow()) && node.resolveFlexGrow() === 0)) availableInnerMainDim = flexLine.sizeConsumed;
+				sizeBasedOnContent = !useLegacyStretchBehaviour;
+			}
+		}
+		if (!sizeBasedOnContent && isDefined(availableInnerMainDim)) flexLine.layout.remainingFreeSpace = availableInnerMainDim - flexLine.sizeConsumed;
+		else if (flexLine.sizeConsumed < 0) flexLine.layout.remainingFreeSpace = -flexLine.sizeConsumed;
+		if (!canSkipFlex) resolveFlexibleLength(node, flexLine, mainAxis, crossAxis, direction, ownerWidth, mainAxisOwnerSize, availableInnerMainDim, availableInnerCrossDim, availableInnerWidth, availableInnerHeight, mainAxisOverflows, sizingModeCrossDim, performLayout, layoutMarkerData, depth, generationCount);
+		node.setLayoutHadOverflow(node.layout.hadOverflow() || flexLine.layout.remainingFreeSpace < 0);
+		justifyMainAxis(node, flexLine, mainAxis, crossAxis, direction, sizingModeMainDim, sizingModeCrossDim, mainAxisOwnerSize, ownerWidth, availableInnerMainDim, availableInnerCrossDim, availableInnerWidth, performLayout);
+		let containerCrossAxis = availableInnerCrossDim;
+		if (sizingModeCrossDim === SizingMode.MaxContent || sizingModeCrossDim === SizingMode.FitContent) containerCrossAxis = boundAxis(node, crossAxis, direction, flexLine.layout.crossDim + paddingAndBorderAxisCross, crossAxisOwnerSize, ownerWidth) - paddingAndBorderAxisCross;
+		if (!isNodeFlexWrap && sizingModeCrossDim === SizingMode.StretchFit) flexLine.layout.crossDim = availableInnerCrossDim;
+		if (!isNodeFlexWrap) flexLine.layout.crossDim = boundAxis(node, crossAxis, direction, flexLine.layout.crossDim + paddingAndBorderAxisCross, crossAxisOwnerSize, ownerWidth) - paddingAndBorderAxisCross;
+		if (performLayout) for (const child of flexLine.itemsInFlow) {
+			let leadingCrossDim = leadingPaddingAndBorderCross;
+			const alignItem = resolveChildAlignment(node, child);
+			if (alignItem === Align.Stretch && !child.style.flexStartMarginIsAuto(crossAxis, direction) && !child.style.flexEndMarginIsAuto(crossAxis, direction)) {
+				if (!child.hasDefiniteLength(dimension(crossAxis), availableInnerCrossDim)) {
+					let childMainSize = child.layout.measuredDimension(dimension(mainAxis));
+					const childStyle = child.style;
+					const childCrossSize = isDefined(childStyle.aspectRatio()) ? child.style.computeMarginForAxis(crossAxis, availableInnerWidth) + (isMainAxisRow ? childMainSize / childStyle.aspectRatio() : childMainSize * childStyle.aspectRatio()) : flexLine.layout.crossDim;
+					childMainSize += child.style.computeMarginForAxis(mainAxis, availableInnerWidth);
+					const childMainModeAndSize = scratchModeA;
+					childMainModeAndSize.mode = SizingMode.StretchFit;
+					childMainModeAndSize.size = childMainSize;
+					constrainMaxSizeForMode(child, direction, mainAxis, availableInnerMainDim, availableInnerWidth, childMainModeAndSize);
+					const childCrossModeAndSize = scratchModeB;
+					childCrossModeAndSize.mode = SizingMode.StretchFit;
+					childCrossModeAndSize.size = childCrossSize;
+					constrainMaxSizeForMode(child, direction, crossAxis, availableInnerCrossDim, availableInnerWidth, childCrossModeAndSize);
+					const childWidth = isMainAxisRow ? childMainModeAndSize.size : childCrossModeAndSize.size;
+					const childHeight = !isMainAxisRow ? childMainModeAndSize.size : childCrossModeAndSize.size;
+					const crossAxisDoesNotGrow = node.style.alignContent() !== Align.Stretch && isNodeFlexWrap;
+					calculateLayoutInternal(child, childWidth, childHeight, direction, isUndefined(childWidth) || !isMainAxisRow && crossAxisDoesNotGrow ? SizingMode.MaxContent : SizingMode.StretchFit, isUndefined(childHeight) || isMainAxisRow && crossAxisDoesNotGrow ? SizingMode.MaxContent : SizingMode.StretchFit, availableInnerWidth, availableInnerHeight, true, LayoutPassReason.Stretch, layoutMarkerData, depth, generationCount);
+				}
+			} else {
+				const remainingCrossDim = containerCrossAxis - child.dimensionWithMargin(crossAxis, availableInnerWidth);
+				if (child.style.flexStartMarginIsAuto(crossAxis, direction) && child.style.flexEndMarginIsAuto(crossAxis, direction)) leadingCrossDim += maxOrDefined(0, remainingCrossDim / 2);
+				else if (child.style.flexEndMarginIsAuto(crossAxis, direction)) {} else if (child.style.flexStartMarginIsAuto(crossAxis, direction)) leadingCrossDim += maxOrDefined(0, remainingCrossDim);
+				else if (alignItem === Align.FlexStart) {} else if (alignItem === Align.Center) leadingCrossDim += remainingCrossDim / 2;
+				else leadingCrossDim += remainingCrossDim;
+			}
+			child.setLayoutPosition(child.layout.position(flexStartEdge(crossAxis)) + totalLineCrossDim + leadingCrossDim, flexStartEdge(crossAxis));
+		}
+		const appliedCrossGap = lineCount !== 0 ? crossAxisGap : 0;
+		totalLineCrossDim += flexLine.layout.crossDim + appliedCrossGap;
+		maxLineMainDim = maxOrDefined(maxLineMainDim, flexLine.layout.mainDim);
+	}
+	if (performLayout && (isNodeFlexWrap || isBaselineLayout(node))) {
+		let leadPerLine = 0;
+		let currentLead = leadingPaddingAndBorderCross;
+		let extraSpacePerLine = 0;
+		const remainingAlignContentDim = boundAxis(node, crossAxis, direction, sizingModeCrossDim === SizingMode.StretchFit ? availableInnerCrossDim + paddingAndBorderAxisCross : node.hasDefiniteLength(dimension(crossAxis), crossAxisOwnerSize) ? node.getResolvedDimension(direction, dimension(crossAxis), crossAxisOwnerSize, ownerWidth) : totalLineCrossDim + paddingAndBorderAxisCross, crossAxisOwnerSize, ownerWidth) - paddingAndBorderAxisCross - totalLineCrossDim;
+		switch (remainingAlignContentDim >= 0 ? node.style.alignContent() : fallbackAlignment(node.style.alignContent())) {
+			case Align.Start:
+			case Align.End: break;
+			case Align.FlexEnd:
+				currentLead += remainingAlignContentDim;
+				break;
+			case Align.Center:
+				currentLead += remainingAlignContentDim / 2;
+				break;
+			case Align.Stretch:
+				extraSpacePerLine = remainingAlignContentDim / lineCount;
+				break;
+			case Align.SpaceAround:
+				currentLead += remainingAlignContentDim / (2 * lineCount);
+				leadPerLine = remainingAlignContentDim / lineCount;
+				break;
+			case Align.SpaceEvenly:
+				currentLead += remainingAlignContentDim / (lineCount + 1);
+				leadPerLine = remainingAlignContentDim / (lineCount + 1);
+				break;
+			case Align.SpaceBetween:
+				if (lineCount > 1) leadPerLine = remainingAlignContentDim / (lineCount - 1);
+				break;
+			case Align.Auto:
+			case Align.FlexStart:
+			case Align.Baseline:
+		}
+		for (let i = 0; i < lineCount; i++) {
+			const lineStart = lineStarts[i];
+			let lineHeight = 0;
+			let maxAscentForCurrentLine = 0;
+			let maxDescentForCurrentLine = 0;
+			let endIndex = lineStart;
+			for (let ii = lineStart; ii < layoutChildren.length; ii++) {
+				const child = layoutChildren[ii];
+				if (child.style.display() === Display.None) {
+					endIndex = ii + 1;
+					continue;
+				}
+				if (child.style.positionType() !== PositionType.Absolute) {
+					if (child.lineIndex !== i) break;
+					if (child.isLayoutDimensionDefined(crossAxis)) lineHeight = maxOrDefined(lineHeight, child.layout.measuredDimension(dimension(crossAxis)) + child.style.computeMarginForAxis(crossAxis, availableInnerWidth));
+					if (resolveChildAlignment(node, child) === Align.Baseline) {
+						const ascent = calculateBaseline(child) + child.style.computeFlexStartMargin(FlexDirection.Column, direction, availableInnerWidth);
+						const descent = child.layout.measuredDimension(Dimension.Height) + child.style.computeMarginForAxis(FlexDirection.Column, availableInnerWidth) - ascent;
+						maxAscentForCurrentLine = maxOrDefined(maxAscentForCurrentLine, ascent);
+						maxDescentForCurrentLine = maxOrDefined(maxDescentForCurrentLine, descent);
+						lineHeight = maxOrDefined(lineHeight, maxAscentForCurrentLine + maxDescentForCurrentLine);
+					}
+				}
+				endIndex = ii + 1;
+			}
+			currentLead += i !== 0 ? crossAxisGap : 0;
+			lineHeight += extraSpacePerLine;
+			for (let ii = lineStart; ii < endIndex; ii++) {
+				const child = layoutChildren[ii];
+				if (child.style.display() === Display.None) continue;
+				if (child.style.positionType() !== PositionType.Absolute) switch (resolveChildAlignment(node, child)) {
+					case Align.Start:
+					case Align.End: break;
+					case Align.FlexStart:
+						child.setLayoutPosition(currentLead + child.style.computeFlexStartPosition(crossAxis, direction, availableInnerWidth), flexStartEdge(crossAxis));
+						break;
+					case Align.FlexEnd:
+						child.setLayoutPosition(currentLead + lineHeight - child.style.computeFlexEndMargin(crossAxis, direction, availableInnerWidth) - child.layout.measuredDimension(dimension(crossAxis)), flexStartEdge(crossAxis));
+						break;
+					case Align.Center: {
+						const childHeight = child.layout.measuredDimension(dimension(crossAxis));
+						child.setLayoutPosition(currentLead + (lineHeight - childHeight) / 2, flexStartEdge(crossAxis));
+						break;
+					}
+					case Align.Stretch:
+						child.setLayoutPosition(currentLead + child.style.computeFlexStartMargin(crossAxis, direction, availableInnerWidth), flexStartEdge(crossAxis));
+						if (!child.hasDefiniteLength(dimension(crossAxis), availableInnerCrossDim)) {
+							const childWidth = isMainAxisRow ? child.layout.measuredDimension(Dimension.Width) + child.style.computeMarginForAxis(mainAxis, availableInnerWidth) : leadPerLine + lineHeight;
+							const childHeight = !isMainAxisRow ? child.layout.measuredDimension(Dimension.Height) + child.style.computeMarginForAxis(crossAxis, availableInnerWidth) : leadPerLine + lineHeight;
+							if (!(inexactEquals(childWidth, child.layout.measuredDimension(Dimension.Width)) && inexactEquals(childHeight, child.layout.measuredDimension(Dimension.Height)))) calculateLayoutInternal(child, childWidth, childHeight, direction, SizingMode.StretchFit, SizingMode.StretchFit, availableInnerWidth, availableInnerHeight, true, LayoutPassReason.MultilineStretch, layoutMarkerData, depth, generationCount);
+						}
+						break;
+					case Align.Baseline:
+						child.setLayoutPosition(currentLead + maxAscentForCurrentLine - calculateBaseline(child) + child.style.computeFlexStartPosition(FlexDirection.Column, direction, availableInnerCrossDim), PhysicalEdge.Top);
+						break;
+					case Align.Auto:
+					case Align.SpaceBetween:
+					case Align.SpaceAround:
+					case Align.SpaceEvenly:
+				}
+			}
+			currentLead = currentLead + leadPerLine + lineHeight;
+		}
+	}
+	node.setLayoutMeasuredDimension(boundAxis(node, FlexDirection.Row, direction, availableWidth - marginAxisRow, ownerWidth, ownerWidth), Dimension.Width);
+	node.setLayoutMeasuredDimension(boundAxis(node, FlexDirection.Column, direction, availableHeight - marginAxisColumn, ownerHeight, ownerWidth), Dimension.Height);
+	if (sizingModeMainDim === SizingMode.MaxContent || node.style.overflow() !== Overflow.Scroll && sizingModeMainDim === SizingMode.FitContent) node.setLayoutMeasuredDimension(boundAxis(node, mainAxis, direction, maxLineMainDim, mainAxisOwnerSize, ownerWidth), dimension(mainAxis));
+	else if (sizingModeMainDim === SizingMode.FitContent && node.style.overflow() === Overflow.Scroll) node.setLayoutMeasuredDimension(maxOrDefined(minOrDefined(availableInnerMainDim + paddingAndBorderAxisMain, boundAxisWithinMinAndMax(node, direction, mainAxis, maxLineMainDim, mainAxisOwnerSize, ownerWidth)), paddingAndBorderAxisMain), dimension(mainAxis));
+	if (sizingModeCrossDim === SizingMode.MaxContent || node.style.overflow() !== Overflow.Scroll && sizingModeCrossDim === SizingMode.FitContent) node.setLayoutMeasuredDimension(boundAxis(node, crossAxis, direction, totalLineCrossDim + paddingAndBorderAxisCross, crossAxisOwnerSize, ownerWidth), dimension(crossAxis));
+	else if (sizingModeCrossDim === SizingMode.FitContent && node.style.overflow() === Overflow.Scroll) node.setLayoutMeasuredDimension(maxOrDefined(minOrDefined(availableInnerCrossDim + paddingAndBorderAxisCross, boundAxisWithinMinAndMax(node, direction, crossAxis, totalLineCrossDim + paddingAndBorderAxisCross, crossAxisOwnerSize, ownerWidth)), paddingAndBorderAxisCross), dimension(crossAxis));
+	if (performLayout && node.style.flexWrap() === Wrap.WrapReverse) {
+		for (const child of node.getLayoutChildren()) if (child.style.positionType() !== PositionType.Absolute) child.setLayoutPosition(node.layout.measuredDimension(dimension(crossAxis)) - child.layout.position(flexStartEdge(crossAxis)) - child.layout.measuredDimension(dimension(crossAxis)), flexStartEdge(crossAxis));
+	}
+	if (performLayout) {
+		const needsMainTrailingPos = needsTrailingPosition(mainAxis);
+		const needsCrossTrailingPos = needsTrailingPosition(crossAxis);
+		if (needsMainTrailingPos || needsCrossTrailingPos) for (const child of node.getLayoutChildren()) {
+			if (child.style.display() === Display.None || child.style.positionType() === PositionType.Absolute) continue;
+			if (needsMainTrailingPos) setChildTrailingPosition(node, child, mainAxis);
+			if (needsCrossTrailingPos) setChildTrailingPosition(node, child, crossAxis);
+		}
+		if (node.style.positionType() !== PositionType.Static || node.alwaysFormsContainingBlock || depth === 1) layoutAbsoluteDescendants(node, node, isMainAxisRow ? sizingModeMainDim : sizingModeCrossDim, direction, layoutMarkerData, depth, generationCount, 0, 0, availableInnerWidth, availableInnerHeight);
+	}
+}
+function calculateLayoutInternal(node, availableWidth, availableHeight, ownerDirection, widthSizingMode, heightSizingMode, ownerWidth, ownerHeight, performLayout, reason, layoutMarkerData, depth, generationCount) {
+	if (isUndefined(availableWidth)) widthSizingMode = SizingMode.MaxContent;
+	if (isUndefined(availableHeight)) heightSizingMode = SizingMode.MaxContent;
+	const layout = node.layout;
+	depth++;
+	const needToVisitNode = node.isDirty() && layout.generationCount !== generationCount || layout.configVersion !== node.config.getVersion() || layout.lastOwnerDirection !== ownerDirection;
+	if (needToVisitNode) {
+		layout.nextCachedMeasurementsIndex = 0;
+		layout.cachedLayout.availableWidth = -1;
+		layout.cachedLayout.availableHeight = -1;
+		layout.cachedLayout.widthSizingMode = SizingMode.MaxContent;
+		layout.cachedLayout.heightSizingMode = SizingMode.MaxContent;
+		layout.cachedLayout.computedWidth = -1;
+		layout.cachedLayout.computedHeight = -1;
+	}
+	let cachedResults = null;
+	if (node.hasMeasureFunc()) {
+		const marginAxisRow = node.style.computeMarginForAxis(FlexDirection.Row, ownerWidth);
+		const marginAxisColumn = node.style.computeMarginForAxis(FlexDirection.Column, ownerWidth);
+		if (canUseCachedMeasurement(widthSizingMode, availableWidth, heightSizingMode, availableHeight, layout.cachedLayout.widthSizingMode, layout.cachedLayout.availableWidth, layout.cachedLayout.heightSizingMode, layout.cachedLayout.availableHeight, layout.cachedLayout.computedWidth, layout.cachedLayout.computedHeight, marginAxisRow, marginAxisColumn, node.config)) cachedResults = layout.cachedLayout;
+		else for (let i = 0; i < layout.nextCachedMeasurementsIndex; i++) if (canUseCachedMeasurement(widthSizingMode, availableWidth, heightSizingMode, availableHeight, layout.cachedMeasurements[i].widthSizingMode, layout.cachedMeasurements[i].availableWidth, layout.cachedMeasurements[i].heightSizingMode, layout.cachedMeasurements[i].availableHeight, layout.cachedMeasurements[i].computedWidth, layout.cachedMeasurements[i].computedHeight, marginAxisRow, marginAxisColumn, node.config)) {
+			cachedResults = layout.cachedMeasurements[i];
+			break;
+		}
+	} else if (performLayout) {
+		if (inexactEquals(layout.cachedLayout.availableWidth, availableWidth) && inexactEquals(layout.cachedLayout.availableHeight, availableHeight) && layout.cachedLayout.widthSizingMode === widthSizingMode && layout.cachedLayout.heightSizingMode === heightSizingMode) cachedResults = layout.cachedLayout;
+	} else for (let i = 0; i < layout.nextCachedMeasurementsIndex; i++) if (inexactEquals(layout.cachedMeasurements[i].availableWidth, availableWidth) && inexactEquals(layout.cachedMeasurements[i].availableHeight, availableHeight) && layout.cachedMeasurements[i].widthSizingMode === widthSizingMode && layout.cachedMeasurements[i].heightSizingMode === heightSizingMode) {
+		cachedResults = layout.cachedMeasurements[i];
+		break;
+	}
+	if (!needToVisitNode && cachedResults !== null) {
+		layout.setMeasuredDimension(Dimension.Width, cachedResults.computedWidth);
+		layout.setMeasuredDimension(Dimension.Height, cachedResults.computedHeight);
+		if (performLayout) layoutMarkerData.cachedLayouts += 1;
+		else layoutMarkerData.cachedMeasures += 1;
+	} else {
+		calculateLayoutImpl(node, availableWidth, availableHeight, ownerDirection, widthSizingMode, heightSizingMode, ownerWidth, ownerHeight, performLayout, reason, layoutMarkerData, depth, generationCount);
+		layout.lastOwnerDirection = ownerDirection;
+		layout.configVersion = node.config.getVersion();
+		if (cachedResults === null) {
+			layoutMarkerData.maxMeasureCache = Math.max(layoutMarkerData.maxMeasureCache, layout.nextCachedMeasurementsIndex + 1);
+			if (layout.nextCachedMeasurementsIndex === LayoutResults.MaxCachedMeasurements) layout.nextCachedMeasurementsIndex = 0;
+			let newCacheEntry;
+			if (performLayout) newCacheEntry = layout.cachedLayout;
+			else {
+				newCacheEntry = layout.cachedMeasurements[layout.nextCachedMeasurementsIndex] ??= new CachedMeasurement();
+				layout.nextCachedMeasurementsIndex++;
+			}
+			newCacheEntry.availableWidth = availableWidth;
+			newCacheEntry.availableHeight = availableHeight;
+			newCacheEntry.widthSizingMode = widthSizingMode;
+			newCacheEntry.heightSizingMode = heightSizingMode;
+			newCacheEntry.computedWidth = layout.measuredDimension(Dimension.Width);
+			newCacheEntry.computedHeight = layout.measuredDimension(Dimension.Height);
+		}
+	}
+	if (performLayout) {
+		node.setLayoutDimension(node.layout.measuredDimension(Dimension.Width), Dimension.Width);
+		node.setLayoutDimension(node.layout.measuredDimension(Dimension.Height), Dimension.Height);
+		node.hasNewLayout_ = true;
+		node.setDirty(false);
+	}
+	layout.generationCount = generationCount;
+	return needToVisitNode || cachedResults === null;
+}
+function calculateLayout(node, ownerWidth, ownerHeight, ownerDirection) {
+	const markerData = newLayoutData();
+	const currentGenerationCount = ++gCurrentGenerationCount;
+	node.processDimensions();
+	const direction = node.resolveDirection(ownerDirection);
+	let width = NaN;
+	let widthSizingMode = SizingMode.MaxContent;
+	const style = node.style;
+	if (node.hasDefiniteLength(Dimension.Width, ownerWidth)) {
+		width = node.getResolvedDimension(direction, dimension(FlexDirection.Row), ownerWidth, ownerWidth) + node.style.computeMarginForAxis(FlexDirection.Row, ownerWidth);
+		widthSizingMode = SizingMode.StretchFit;
+	} else if (isDefined(style.resolvedMaxDimension(direction, Dimension.Width, ownerWidth, ownerWidth))) {
+		width = style.resolvedMaxDimension(direction, Dimension.Width, ownerWidth, ownerWidth);
+		widthSizingMode = SizingMode.FitContent;
+	} else {
+		width = ownerWidth;
+		widthSizingMode = isUndefined(width) ? SizingMode.MaxContent : SizingMode.StretchFit;
+	}
+	let height = NaN;
+	let heightSizingMode = SizingMode.MaxContent;
+	if (node.hasDefiniteLength(Dimension.Height, ownerHeight)) {
+		height = node.getResolvedDimension(direction, dimension(FlexDirection.Column), ownerHeight, ownerWidth) + node.style.computeMarginForAxis(FlexDirection.Column, ownerWidth);
+		heightSizingMode = SizingMode.StretchFit;
+	} else if (isDefined(style.resolvedMaxDimension(direction, Dimension.Height, ownerHeight, ownerWidth))) {
+		height = style.resolvedMaxDimension(direction, Dimension.Height, ownerHeight, ownerWidth);
+		heightSizingMode = SizingMode.FitContent;
+	} else {
+		height = ownerHeight;
+		heightSizingMode = isUndefined(height) ? SizingMode.MaxContent : SizingMode.StretchFit;
+	}
+	const generationCount = node.config.isExperimentalFeatureEnabled(ExperimentalFeature.FixFlexBasisFitContent) ? currentGenerationCount : gCurrentGenerationCount;
+	if (calculateLayoutInternal(node, width, height, ownerDirection, widthSizingMode, heightSizingMode, ownerWidth, ownerHeight, true, LayoutPassReason.Initial, markerData, 0, generationCount)) {
+		node.setPositionFromStyle(node.layout.direction(), ownerWidth, ownerHeight);
+		roundLayoutResultsToPixelGrid(node, 0, 0);
+	}
+}
+//#endregion
+//#region src/yoga/core/types.ts
+function isInvalidValue(value) {
+	return isUndefined(value) || !Number.isFinite(value);
+}
+/**
+* A CSS <length-percentage> or keyword. `value` is NaN for keyword units.
+* Instances are immutable and may be shared.
+*/
+var StyleLength = class StyleLength {
+	value;
+	unit;
+	constructor(value, unit) {
+		this.value = value;
+		this.unit = unit;
+	}
+	static points(value) {
+		return isInvalidValue(value) ? StyleLength.undefined() : new StyleLength(value, Unit.Point);
+	}
+	static percent(value) {
+		return isInvalidValue(value) ? StyleLength.undefined() : new StyleLength(value, Unit.Percent);
+	}
+	static ofAuto() {
+		return AUTO;
+	}
+	static undefined() {
+		return UNDEFINED;
+	}
+	isAuto() {
+		return this.unit === Unit.Auto;
+	}
+	isUndefined() {
+		return this.unit === Unit.Undefined;
+	}
+	isDefined() {
+		return !this.isUndefined();
+	}
+	isPoints() {
+		return this.unit === Unit.Point;
+	}
+	isPercent() {
+		return this.unit === Unit.Percent;
+	}
+	resolve(referenceLength) {
+		switch (this.unit) {
+			case Unit.Point: return this.value;
+			case Unit.Percent: return this.value * referenceLength * .01;
+			default: return NaN;
+		}
+	}
+	equals(other) {
+		return optionalEquals(this.value, other.value) && this.unit === other.unit;
+	}
+	inexactEquals(other) {
+		return this.unit === other.unit && inexactEquals(this.value, other.value);
+	}
+};
+const AUTO = new class extends StyleLength {
+	constructor() {
+		super(NaN, Unit.Auto);
+	}
+}();
+const UNDEFINED = new class extends StyleLength {
+	constructor() {
+		super(NaN, Unit.Undefined);
+	}
+}();
+/**
+* A CSS value for sizes (width, min-width, flex-basis, ...) which additionally
+* allows the auto/max-content/fit-content/stretch keywords.
+*/
+var StyleSizeLength = class StyleSizeLength {
+	value;
+	unit;
+	constructor(value, unit) {
+		this.value = value;
+		this.unit = unit;
+	}
+	static points(value) {
+		return isInvalidValue(value) ? StyleSizeLength.undefined() : new StyleSizeLength(value, Unit.Point);
+	}
+	static percent(value) {
+		return isInvalidValue(value) ? StyleSizeLength.undefined() : new StyleSizeLength(value, Unit.Percent);
+	}
+	static ofAuto() {
+		return SIZE_AUTO;
+	}
+	static ofMaxContent() {
+		return SIZE_MAX_CONTENT;
+	}
+	static ofFitContent() {
+		return SIZE_FIT_CONTENT;
+	}
+	static ofStretch() {
+		return SIZE_STRETCH;
+	}
+	static undefined() {
+		return SIZE_UNDEFINED;
+	}
+	isAuto() {
+		return this.unit === Unit.Auto;
+	}
+	isMaxContent() {
+		return this.unit === Unit.MaxContent;
+	}
+	isFitContent() {
+		return this.unit === Unit.FitContent;
+	}
+	isStretch() {
+		return this.unit === Unit.Stretch;
+	}
+	isUndefined() {
+		return this.unit === Unit.Undefined;
+	}
+	isDefined() {
+		return !this.isUndefined();
+	}
+	isPoints() {
+		return this.unit === Unit.Point;
+	}
+	isPercent() {
+		return this.unit === Unit.Percent;
+	}
+	resolve(referenceLength) {
+		switch (this.unit) {
+			case Unit.Point: return this.value;
+			case Unit.Percent: return this.value * referenceLength * .01;
+			default: return NaN;
+		}
+	}
+	equals(other) {
+		return optionalEquals(this.value, other.value) && this.unit === other.unit;
+	}
+	inexactEquals(other) {
+		return this.unit === other.unit && inexactEquals(this.value, other.value);
+	}
+};
+const SIZE_AUTO = new class extends StyleSizeLength {
+	constructor() {
+		super(NaN, Unit.Auto);
+	}
+}();
+const SIZE_MAX_CONTENT = new class extends StyleSizeLength {
+	constructor() {
+		super(NaN, Unit.MaxContent);
+	}
+}();
+const SIZE_FIT_CONTENT = new class extends StyleSizeLength {
+	constructor() {
+		super(NaN, Unit.FitContent);
+	}
+}();
+const SIZE_STRETCH = new class extends StyleSizeLength {
+	constructor() {
+		super(NaN, Unit.Stretch);
+	}
+}();
+const SIZE_UNDEFINED = new class extends StyleSizeLength {
+	constructor() {
+		super(NaN, Unit.Undefined);
+	}
+}();
+//#endregion
+//#region src/yoga/core/style.ts
+const EDGE_COUNT = 9;
+const GUTTER_COUNT = 3;
+function undefinedLengths(count) {
+	return Array.from({ length: count }).fill(StyleLength.undefined());
+}
+var Style = class {
+	static DefaultFlexGrow = 0;
+	static DefaultFlexShrink = 0;
+	static WebDefaultFlexShrink = 1;
+	direction_ = Direction.Inherit;
+	flexDirection_ = FlexDirection.Column;
+	justifyContent_ = Justify.FlexStart;
+	justifyItems_ = Justify.Stretch;
+	justifySelf_ = Justify.Auto;
+	alignContent_ = Align.FlexStart;
+	alignItems_ = Align.Stretch;
+	alignSelf_ = Align.Auto;
+	positionType_ = PositionType.Relative;
+	flexWrap_ = Wrap.NoWrap;
+	overflow_ = Overflow.Visible;
+	display_ = Display.Flex;
+	boxSizing_ = BoxSizing.BorderBox;
+	flex_ = NaN;
+	flexGrow_ = NaN;
+	flexShrink_ = NaN;
+	flexBasis_ = StyleSizeLength.ofAuto();
+	margin_ = null;
+	position_ = null;
+	padding_ = null;
+	border_ = null;
+	gap_ = null;
+	marginResolved_ = null;
+	positionResolved_ = null;
+	paddingResolved_ = null;
+	borderResolved_ = null;
+	dimensions_ = [
+		StyleSizeLength.ofAuto(),
+		StyleSizeLength.ofAuto(),
+		StyleSizeLength.undefined(),
+		StyleSizeLength.undefined(),
+		StyleSizeLength.undefined(),
+		StyleSizeLength.undefined()
+	];
+	aspectRatio_ = NaN;
+	direction() {
+		return this.direction_;
+	}
+	setDirection(value) {
+		this.direction_ = value;
+	}
+	flexDirection() {
+		return this.flexDirection_;
+	}
+	setFlexDirection(value) {
+		this.flexDirection_ = value;
+	}
+	justifyContent() {
+		return this.justifyContent_;
+	}
+	setJustifyContent(value) {
+		this.justifyContent_ = value;
+	}
+	justifyItems() {
+		return this.justifyItems_;
+	}
+	setJustifyItems(value) {
+		this.justifyItems_ = value;
+	}
+	justifySelf() {
+		return this.justifySelf_;
+	}
+	setJustifySelf(value) {
+		this.justifySelf_ = value;
+	}
+	alignContent() {
+		return this.alignContent_;
+	}
+	setAlignContent(value) {
+		this.alignContent_ = value;
+	}
+	alignItems() {
+		return this.alignItems_;
+	}
+	setAlignItems(value) {
+		this.alignItems_ = value;
+	}
+	alignSelf() {
+		return this.alignSelf_;
+	}
+	setAlignSelf(value) {
+		this.alignSelf_ = value;
+	}
+	positionType() {
+		return this.positionType_;
+	}
+	setPositionType(value) {
+		this.positionType_ = value;
+	}
+	flexWrap() {
+		return this.flexWrap_;
+	}
+	setFlexWrap(value) {
+		this.flexWrap_ = value;
+	}
+	overflow() {
+		return this.overflow_;
+	}
+	setOverflow(value) {
+		this.overflow_ = value;
+	}
+	display() {
+		return this.display_;
+	}
+	setDisplay(value) {
+		this.display_ = value;
+	}
+	flex() {
+		return this.flex_;
+	}
+	setFlex(value) {
+		this.flex_ = value;
+	}
+	flexGrow() {
+		return this.flexGrow_;
+	}
+	setFlexGrow(value) {
+		this.flexGrow_ = value;
+	}
+	flexShrink() {
+		return this.flexShrink_;
+	}
+	setFlexShrink(value) {
+		this.flexShrink_ = value;
+	}
+	flexBasis() {
+		return this.flexBasis_;
+	}
+	setFlexBasis(value) {
+		this.flexBasis_ = value;
+	}
+	margin(edge) {
+		return this.margin_ !== null ? this.margin_[edge] : StyleLength.undefined();
+	}
+	setMargin(edge, value) {
+		(this.margin_ ??= undefinedLengths(EDGE_COUNT))[edge] = value;
+		this.marginResolved_ = null;
+	}
+	position(edge) {
+		return this.position_ !== null ? this.position_[edge] : StyleLength.undefined();
+	}
+	setPosition(edge, value) {
+		(this.position_ ??= undefinedLengths(EDGE_COUNT))[edge] = value;
+		this.positionResolved_ = null;
+	}
+	padding(edge) {
+		return this.padding_ !== null ? this.padding_[edge] : StyleLength.undefined();
+	}
+	setPadding(edge, value) {
+		(this.padding_ ??= undefinedLengths(EDGE_COUNT))[edge] = value;
+		this.paddingResolved_ = null;
+	}
+	border(edge) {
+		return this.border_ !== null ? this.border_[edge] : StyleLength.undefined();
+	}
+	setBorder(edge, value) {
+		(this.border_ ??= undefinedLengths(EDGE_COUNT))[edge] = value;
+		this.borderResolved_ = null;
+	}
+	gap(gutter) {
+		return this.gap_ !== null ? this.gap_[gutter] : StyleLength.undefined();
+	}
+	setGap(gutter, value) {
+		(this.gap_ ??= undefinedLengths(GUTTER_COUNT))[gutter] = value;
+	}
+	dimension(axis) {
+		return this.dimensions_[axis];
+	}
+	setDimension(axis, value) {
+		this.dimensions_[axis] = value;
+	}
+	minDimension(axis) {
+		return this.dimensions_[2 + axis];
+	}
+	setMinDimension(axis, value) {
+		this.dimensions_[2 + axis] = value;
+	}
+	maxDimension(axis) {
+		return this.dimensions_[4 + axis];
+	}
+	setMaxDimension(axis, value) {
+		this.dimensions_[4 + axis] = value;
+	}
+	resolvedMinDimension(direction, axis, referenceLength, ownerWidth) {
+		const minDimension = this.dimensions_[2 + axis];
+		if (minDimension.isUndefined()) return NaN;
+		const value = minDimension.resolve(referenceLength);
+		if (this.boxSizing_ === BoxSizing.BorderBox || !isDefined(value)) return value;
+		const dimensionPaddingAndBorder = this.computePaddingAndBorderForDimension(direction, axis, ownerWidth);
+		return value + (isDefined(dimensionPaddingAndBorder) ? dimensionPaddingAndBorder : 0);
+	}
+	resolvedMaxDimension(direction, axis, referenceLength, ownerWidth) {
+		const maxDimension = this.dimensions_[4 + axis];
+		if (maxDimension.isUndefined()) return NaN;
+		const value = maxDimension.resolve(referenceLength);
+		if (this.boxSizing_ === BoxSizing.BorderBox || !isDefined(value)) return value;
+		const dimensionPaddingAndBorder = this.computePaddingAndBorderForDimension(direction, axis, ownerWidth);
+		return value + (isDefined(dimensionPaddingAndBorder) ? dimensionPaddingAndBorder : 0);
+	}
+	aspectRatio() {
+		return this.aspectRatio_;
+	}
+	setAspectRatio(value) {
+		this.aspectRatio_ = value === 0 || value === Infinity || value === -Infinity ? NaN : value;
+	}
+	boxSizing() {
+		return this.boxSizing_;
+	}
+	setBoxSizing(value) {
+		this.boxSizing_ = value;
+	}
+	horizontalInsetsDefined() {
+		const position = this.position_;
+		return position !== null && (position[Edge.Left].isDefined() || position[Edge.Right].isDefined() || position[Edge.All].isDefined() || position[Edge.Horizontal].isDefined() || position[Edge.Start].isDefined() || position[Edge.End].isDefined());
+	}
+	verticalInsetsDefined() {
+		const position = this.position_;
+		return position !== null && (position[Edge.Top].isDefined() || position[Edge.Bottom].isDefined() || position[Edge.All].isDefined() || position[Edge.Vertical].isDefined());
+	}
+	hasPositionOrMargin() {
+		return this.position_ !== null || this.margin_ !== null;
+	}
+	hasPaddingOrBorder() {
+		return this.padding_ !== null || this.border_ !== null;
+	}
+	isFlexStartPositionDefined(axis, direction) {
+		if (this.position_ === null) return false;
+		return this.computePosition(flexStartEdge(axis), direction).isDefined();
+	}
+	isFlexStartPositionAuto(axis, direction) {
+		if (this.position_ === null) return false;
+		return this.computePosition(flexStartEdge(axis), direction).isAuto();
+	}
+	isInlineStartPositionDefined(axis, direction) {
+		if (this.position_ === null) return false;
+		return this.computePosition(inlineStartEdge(axis, direction), direction).isDefined();
+	}
+	isInlineStartPositionAuto(axis, direction) {
+		if (this.position_ === null) return false;
+		return this.computePosition(inlineStartEdge(axis, direction), direction).isAuto();
+	}
+	isFlexEndPositionDefined(axis, direction) {
+		if (this.position_ === null) return false;
+		return this.computePosition(flexEndEdge(axis), direction).isDefined();
+	}
+	isFlexEndPositionAuto(axis, direction) {
+		if (this.position_ === null) return false;
+		return this.computePosition(flexEndEdge(axis), direction).isAuto();
+	}
+	isInlineEndPositionDefined(axis, direction) {
+		if (this.position_ === null) return false;
+		return this.computePosition(inlineEndEdge(axis, direction), direction).isDefined();
+	}
+	isInlineEndPositionAuto(axis, direction) {
+		if (this.position_ === null) return false;
+		return this.computePosition(inlineEndEdge(axis, direction), direction).isAuto();
+	}
+	computeFlexStartPosition(axis, direction, axisSize) {
+		if (this.position_ === null) return 0;
+		return edgeValueOrZero(this.resolvedPosition(), direction * 4 + flexStartEdge(axis), axisSize);
+	}
+	computeInlineStartPosition(axis, direction, axisSize) {
+		if (this.position_ === null) return 0;
+		return edgeValueOrZero(this.resolvedPosition(), direction * 4 + inlineStartEdge(axis, direction), axisSize);
+	}
+	computeFlexEndPosition(axis, direction, axisSize) {
+		if (this.position_ === null) return 0;
+		return edgeValueOrZero(this.resolvedPosition(), direction * 4 + flexEndEdge(axis), axisSize);
+	}
+	computeInlineEndPosition(axis, direction, axisSize) {
+		if (this.position_ === null) return 0;
+		return edgeValueOrZero(this.resolvedPosition(), direction * 4 + inlineEndEdge(axis, direction), axisSize);
+	}
+	computeFlexStartMargin(axis, direction, widthSize) {
+		if (this.margin_ === null) return 0;
+		return edgeValueOrZero(this.resolvedMargin(), direction * 4 + flexStartEdge(axis), widthSize);
+	}
+	computeInlineStartMargin(axis, direction, widthSize) {
+		if (this.margin_ === null) return 0;
+		return edgeValueOrZero(this.resolvedMargin(), direction * 4 + inlineStartEdge(axis, direction), widthSize);
+	}
+	computeFlexEndMargin(axis, direction, widthSize) {
+		if (this.margin_ === null) return 0;
+		return edgeValueOrZero(this.resolvedMargin(), direction * 4 + flexEndEdge(axis), widthSize);
+	}
+	computeInlineEndMargin(axis, direction, widthSize) {
+		if (this.margin_ === null) return 0;
+		return edgeValueOrZero(this.resolvedMargin(), direction * 4 + inlineEndEdge(axis, direction), widthSize);
+	}
+	computeFlexStartBorder(axis, direction) {
+		if (this.border_ === null) return 0;
+		return edgeValueFloored(this.resolvedBorder(), direction * 4 + flexStartEdge(axis), 0);
+	}
+	computeInlineStartBorder(axis, direction) {
+		if (this.border_ === null) return 0;
+		return edgeValueFloored(this.resolvedBorder(), direction * 4 + inlineStartEdge(axis, direction), 0);
+	}
+	computeFlexEndBorder(axis, direction) {
+		if (this.border_ === null) return 0;
+		return edgeValueFloored(this.resolvedBorder(), direction * 4 + flexEndEdge(axis), 0);
+	}
+	computeInlineEndBorder(axis, direction) {
+		if (this.border_ === null) return 0;
+		return edgeValueFloored(this.resolvedBorder(), direction * 4 + inlineEndEdge(axis, direction), 0);
+	}
+	computeFlexStartPadding(axis, direction, widthSize) {
+		if (this.padding_ === null) return 0;
+		return edgeValueFloored(this.resolvedPadding(), direction * 4 + flexStartEdge(axis), widthSize);
+	}
+	computeInlineStartPadding(axis, direction, widthSize) {
+		if (this.padding_ === null) return 0;
+		return edgeValueFloored(this.resolvedPadding(), direction * 4 + inlineStartEdge(axis, direction), widthSize);
+	}
+	computeFlexEndPadding(axis, direction, widthSize) {
+		if (this.padding_ === null) return 0;
+		return edgeValueFloored(this.resolvedPadding(), direction * 4 + flexEndEdge(axis), widthSize);
+	}
+	computeInlineEndPadding(axis, direction, widthSize) {
+		if (this.padding_ === null) return 0;
+		return edgeValueFloored(this.resolvedPadding(), direction * 4 + inlineEndEdge(axis, direction), widthSize);
+	}
+	computeInlineStartPaddingAndBorder(axis, direction, widthSize) {
+		return this.computeInlineStartPadding(axis, direction, widthSize) + this.computeInlineStartBorder(axis, direction);
+	}
+	computeFlexStartPaddingAndBorder(axis, direction, widthSize) {
+		return this.computeFlexStartPadding(axis, direction, widthSize) + this.computeFlexStartBorder(axis, direction);
+	}
+	computeInlineEndPaddingAndBorder(axis, direction, widthSize) {
+		return this.computeInlineEndPadding(axis, direction, widthSize) + this.computeInlineEndBorder(axis, direction);
+	}
+	computeFlexEndPaddingAndBorder(axis, direction, widthSize) {
+		return this.computeFlexEndPadding(axis, direction, widthSize) + this.computeFlexEndBorder(axis, direction);
+	}
+	computePaddingAndBorderForDimension(direction, dimension, widthSize) {
+		const flexDirectionForDimension = dimension === Dimension.Width ? FlexDirection.Row : FlexDirection.Column;
+		return this.computeFlexStartPaddingAndBorder(flexDirectionForDimension, direction, widthSize) + this.computeFlexEndPaddingAndBorder(flexDirectionForDimension, direction, widthSize);
+	}
+	computeBorderForAxis(axis) {
+		const resolved = this.resolvedBorder();
+		if (resolved === null) return 0;
+		const startEdge = isRow(axis) ? PhysicalEdge.Left : PhysicalEdge.Top;
+		return edgeValueFloored(resolved, Direction.LTR * 4 + startEdge, 0) + edgeValueFloored(resolved, Direction.LTR * 4 + startEdge + 2, 0);
+	}
+	computeMarginForAxis(axis, widthSize) {
+		const resolved = this.resolvedMargin();
+		if (resolved === null) return 0;
+		const startEdge = isRow(axis) ? PhysicalEdge.Left : PhysicalEdge.Top;
+		return edgeValueOrZero(resolved, Direction.LTR * 4 + startEdge, widthSize) + edgeValueOrZero(resolved, Direction.LTR * 4 + startEdge + 2, widthSize);
+	}
+	computeGapForAxis(axis, ownerSize) {
+		if (this.gap_ === null) return 0;
+		return maxOrDefined((isRow(axis) ? this.computeColumnGap() : this.computeRowGap()).resolve(ownerSize), 0);
+	}
+	computeGapForDimension(dimension, ownerSize) {
+		if (this.gap_ === null) return 0;
+		return maxOrDefined((dimension === Dimension.Width ? this.computeColumnGap() : this.computeRowGap()).resolve(ownerSize), 0);
+	}
+	flexStartMarginIsAuto(axis, direction) {
+		if (this.margin_ === null) return false;
+		return this.computeMargin(flexStartEdge(axis), direction).isAuto();
+	}
+	flexEndMarginIsAuto(axis, direction) {
+		if (this.margin_ === null) return false;
+		return this.computeMargin(flexEndEdge(axis), direction).isAuto();
+	}
+	inlineStartMarginIsAuto(axis, direction) {
+		if (this.margin_ === null) return false;
+		return this.computeMargin(inlineStartEdge(axis, direction), direction).isAuto();
+	}
+	inlineEndMarginIsAuto(axis, direction) {
+		if (this.margin_ === null) return false;
+		return this.computeMargin(inlineEndEdge(axis, direction), direction).isAuto();
+	}
+	equals(other) {
+		const lengthsEqual = (a, b, count) => {
+			if (a === b) return true;
+			for (let i = 0; i < count; i++) {
+				const left = a !== null ? a[i] : StyleLength.undefined();
+				const right = b !== null ? b[i] : StyleLength.undefined();
+				if (!left.equals(right)) return false;
+			}
+			return true;
+		};
+		const numbersEqual = (a, b) => a === b || Number.isNaN(a) && Number.isNaN(b);
+		return this.direction_ === other.direction_ && this.flexDirection_ === other.flexDirection_ && this.justifyContent_ === other.justifyContent_ && this.justifyItems_ === other.justifyItems_ && this.justifySelf_ === other.justifySelf_ && this.alignContent_ === other.alignContent_ && this.alignItems_ === other.alignItems_ && this.alignSelf_ === other.alignSelf_ && this.positionType_ === other.positionType_ && this.flexWrap_ === other.flexWrap_ && this.overflow_ === other.overflow_ && this.display_ === other.display_ && this.boxSizing_ === other.boxSizing_ && numbersEqual(this.flex_, other.flex_) && numbersEqual(this.flexGrow_, other.flexGrow_) && numbersEqual(this.flexShrink_, other.flexShrink_) && this.flexBasis_.equals(other.flexBasis_) && lengthsEqual(this.margin_, other.margin_, EDGE_COUNT) && lengthsEqual(this.position_, other.position_, EDGE_COUNT) && lengthsEqual(this.padding_, other.padding_, EDGE_COUNT) && lengthsEqual(this.border_, other.border_, EDGE_COUNT) && lengthsEqual(this.gap_, other.gap_, GUTTER_COUNT) && this.dimensions_.every((value, i) => value.equals(other.dimensions_[i])) && numbersEqual(this.aspectRatio_, other.aspectRatio_);
+	}
+	copyFrom(other) {
+		this.direction_ = other.direction_;
+		this.flexDirection_ = other.flexDirection_;
+		this.justifyContent_ = other.justifyContent_;
+		this.justifyItems_ = other.justifyItems_;
+		this.justifySelf_ = other.justifySelf_;
+		this.alignContent_ = other.alignContent_;
+		this.alignItems_ = other.alignItems_;
+		this.alignSelf_ = other.alignSelf_;
+		this.positionType_ = other.positionType_;
+		this.flexWrap_ = other.flexWrap_;
+		this.overflow_ = other.overflow_;
+		this.display_ = other.display_;
+		this.boxSizing_ = other.boxSizing_;
+		this.flex_ = other.flex_;
+		this.flexGrow_ = other.flexGrow_;
+		this.flexShrink_ = other.flexShrink_;
+		this.flexBasis_ = other.flexBasis_;
+		this.margin_ = other.margin_ !== null ? other.margin_.slice() : null;
+		this.position_ = other.position_ !== null ? other.position_.slice() : null;
+		this.padding_ = other.padding_ !== null ? other.padding_.slice() : null;
+		this.border_ = other.border_ !== null ? other.border_.slice() : null;
+		this.gap_ = other.gap_ !== null ? other.gap_.slice() : null;
+		this.marginResolved_ = null;
+		this.positionResolved_ = null;
+		this.paddingResolved_ = null;
+		this.borderResolved_ = null;
+		this.dimensions_ = other.dimensions_.slice();
+		this.aspectRatio_ = other.aspectRatio_;
+	}
+	computeColumnGap() {
+		const gap = this.gap_;
+		if (gap === null) return StyleLength.undefined();
+		return gap[Gutter.Column].isDefined() ? gap[Gutter.Column] : gap[Gutter.All];
+	}
+	computeRowGap() {
+		const gap = this.gap_;
+		if (gap === null) return StyleLength.undefined();
+		return gap[Gutter.Row].isDefined() ? gap[Gutter.Row] : gap[Gutter.All];
+	}
+	computeLeftEdge(edges, layoutDirection) {
+		if (layoutDirection === Direction.LTR && edges[Edge.Start].isDefined()) return edges[Edge.Start];
+		else if (layoutDirection === Direction.RTL && edges[Edge.End].isDefined()) return edges[Edge.End];
+		else if (edges[Edge.Left].isDefined()) return edges[Edge.Left];
+		else if (edges[Edge.Horizontal].isDefined()) return edges[Edge.Horizontal];
+		else return edges[Edge.All];
+	}
+	computeTopEdge(edges) {
+		if (edges[Edge.Top].isDefined()) return edges[Edge.Top];
+		else if (edges[Edge.Vertical].isDefined()) return edges[Edge.Vertical];
+		else return edges[Edge.All];
+	}
+	computeRightEdge(edges, layoutDirection) {
+		if (layoutDirection === Direction.LTR && edges[Edge.End].isDefined()) return edges[Edge.End];
+		else if (layoutDirection === Direction.RTL && edges[Edge.Start].isDefined()) return edges[Edge.Start];
+		else if (edges[Edge.Right].isDefined()) return edges[Edge.Right];
+		else if (edges[Edge.Horizontal].isDefined()) return edges[Edge.Horizontal];
+		else return edges[Edge.All];
+	}
+	computeBottomEdge(edges) {
+		if (edges[Edge.Bottom].isDefined()) return edges[Edge.Bottom];
+		else if (edges[Edge.Vertical].isDefined()) return edges[Edge.Vertical];
+		else return edges[Edge.All];
+	}
+	buildResolvedEdges(edges) {
+		const lengths = Array.from({ length: 12 });
+		const units = /* @__PURE__ */ new Uint8Array(12);
+		const values = Array.from({ length: 12 });
+		for (const direction of [
+			Direction.Inherit,
+			Direction.LTR,
+			Direction.RTL
+		]) {
+			lengths[direction * 4 + PhysicalEdge.Left] = this.computeLeftEdge(edges, direction);
+			lengths[direction * 4 + PhysicalEdge.Top] = this.computeTopEdge(edges);
+			lengths[direction * 4 + PhysicalEdge.Right] = this.computeRightEdge(edges, direction);
+			lengths[direction * 4 + PhysicalEdge.Bottom] = this.computeBottomEdge(edges);
+		}
+		for (let i = 0; i < 12; i++) {
+			units[i] = lengths[i].unit;
+			values[i] = lengths[i].value;
+		}
+		return {
+			lengths,
+			units,
+			values
+		};
+	}
+	resolvedPosition() {
+		return this.position_ === null ? null : this.positionResolved_ ??= this.buildResolvedEdges(this.position_);
+	}
+	resolvedMargin() {
+		return this.margin_ === null ? null : this.marginResolved_ ??= this.buildResolvedEdges(this.margin_);
+	}
+	resolvedPadding() {
+		return this.padding_ === null ? null : this.paddingResolved_ ??= this.buildResolvedEdges(this.padding_);
+	}
+	resolvedBorder() {
+		return this.border_ === null ? null : this.borderResolved_ ??= this.buildResolvedEdges(this.border_);
+	}
+	computePosition(edge, direction) {
+		const resolved = this.resolvedPosition();
+		return resolved === null ? StyleLength.undefined() : resolved.lengths[direction * 4 + edge];
+	}
+	computeMargin(edge, direction) {
+		const resolved = this.resolvedMargin();
+		return resolved === null ? StyleLength.undefined() : resolved.lengths[direction * 4 + edge];
+	}
+	computePadding(edge, direction) {
+		const resolved = this.resolvedPadding();
+		return resolved === null ? StyleLength.undefined() : resolved.lengths[direction * 4 + edge];
+	}
+	computeBorder(edge, direction) {
+		const resolved = this.resolvedBorder();
+		return resolved === null ? StyleLength.undefined() : resolved.lengths[direction * 4 + edge];
+	}
+};
+function edgeValueOrZero(resolved, index, referenceLength) {
+	if (resolved === null) return 0;
+	const unit = resolved.units[index];
+	if (unit === Unit.Point) return resolved.values[index];
+	if (unit === Unit.Percent) {
+		const value = resolved.values[index] * referenceLength * .01;
+		return Number.isNaN(value) ? 0 : value;
+	}
+	return 0;
+}
+function edgeValueFloored(resolved, index, referenceLength) {
+	if (resolved === null) return 0;
+	const unit = resolved.units[index];
+	if (unit === Unit.Point) {
+		const value = resolved.values[index];
+		return value > 0 ? value : 0;
+	}
+	if (unit === Unit.Percent) {
+		const value = resolved.values[index] * referenceLength * .01;
+		return value > 0 ? value : 0;
+	}
+	return 0;
+}
+//#endregion
+//#region src/yoga/core/node.ts
+var Node$1 = class Node$1 {
+	hasNewLayout_ = true;
+	isReferenceBaseline_ = false;
+	isDirty_ = true;
+	alwaysFormsContainingBlock = false;
+	nodeType = NodeType.Default;
+	measureFunc_ = null;
+	measureResult_ = null;
+	baselineFunc_ = null;
+	dirtiedFunc_ = null;
+	style = new Style();
+	layout = new LayoutResults();
+	lineIndex = 0;
+	contentsChildrenCount_ = 0;
+	owner = null;
+	children = [];
+	config;
+	processedDimensionWidth_ = StyleSizeLength.undefined();
+	processedDimensionHeight_ = StyleSizeLength.undefined();
+	dimensionsDirty_ = true;
+	constructor(config = getDefaultConfig()) {
+		this.config = config;
+		if (config.useWebDefaults()) {
+			this.style.setFlexDirection(FlexDirection.Row);
+			this.style.setAlignContent(Align.Stretch);
+		}
+	}
+	hasMeasureFunc() {
+		return this.measureFunc_ !== null;
+	}
+	measure(availableWidth, widthMode, availableHeight, heightMode) {
+		const size = this.measureFunc_(availableWidth, widthMode, availableHeight, heightMode);
+		const width = size.width === void 0 || size.width === null ? NaN : size.width;
+		const height = size.height === void 0 || size.height === null ? NaN : size.height;
+		const result = this.measureResult_ ??= {
+			width: 0,
+			height: 0
+		};
+		if (isUndefined(height) || height < 0 || isUndefined(width) || width < 0) {
+			result.width = maxOrDefined(0, width);
+			result.height = maxOrDefined(0, height);
+		} else {
+			result.width = width;
+			result.height = height;
+		}
+		return result;
+	}
+	hasBaselineFunc() {
+		return this.baselineFunc_ !== null;
+	}
+	baseline(width, height) {
+		return this.baselineFunc_(width, height);
+	}
+	getDirtiedFunc() {
+		return this.dirtiedFunc_;
+	}
+	dimensionWithMargin(axis, widthSize) {
+		return this.layout.measuredDimension(dimension(axis)) + this.style.computeMarginForAxis(axis, widthSize);
+	}
+	isLayoutDimensionDefined(axis) {
+		const value = this.layout.measuredDimension(dimension(axis));
+		return isDefined(value) && value >= 0;
+	}
+	/**
+	* Whether the node has a "definite length" along the given axis.
+	* https://www.w3.org/TR/css-sizing-3/#definite
+	*/
+	hasDefiniteLength(dim, ownerSize) {
+		const usedValue = this.getProcessedDimension(dim).resolve(ownerSize);
+		return isDefined(usedValue) && usedValue >= 0;
+	}
+	hasErrata(errata) {
+		return this.config.hasErrata(errata);
+	}
+	hasContentsChildren() {
+		return this.contentsChildrenCount_ !== 0;
+	}
+	getChildCount() {
+		return this.children.length;
+	}
+	getChild(index) {
+		return this.children[index];
+	}
+	/**
+	* Children for layout purposes: skips display: contents nodes, splicing
+	* their children in place. Returns the raw children array when nothing
+	* needs splicing — do not mutate the result.
+	*/
+	getLayoutChildren() {
+		if (this.contentsChildrenCount_ === 0) return this.children;
+		const result = [];
+		appendLayoutChildren(this, result);
+		return result;
+	}
+	getLayoutChildCount() {
+		if (this.contentsChildrenCount_ === 0) return this.children.length;
+		return this.getLayoutChildren().length;
+	}
+	isDirty() {
+		return this.isDirty_;
+	}
+	getProcessedDimension(dim) {
+		return dim === Dimension.Width ? this.processedDimensionWidth_ : this.processedDimensionHeight_;
+	}
+	getResolvedDimension(direction, dim, referenceLength, ownerWidth) {
+		const value = this.getProcessedDimension(dim).resolve(referenceLength);
+		if (this.style.boxSizing() === BoxSizing.BorderBox) return value;
+		const dimensionPaddingAndBorder = this.style.computePaddingAndBorderForDimension(direction, dim, ownerWidth);
+		return value + (isDefined(dimensionPaddingAndBorder) ? dimensionPaddingAndBorder : 0);
+	}
+	setMeasureFunc(measureFunc) {
+		if (measureFunc === null) this.nodeType = NodeType.Default;
+		else {
+			if (this.children.length !== 0) throw new Error("Cannot set measure function: Nodes with measure functions cannot have children.");
+			this.nodeType = NodeType.Text;
+		}
+		this.measureFunc_ = measureFunc;
+		this.markLayoutWritten();
+	}
+	setBaselineFunc(baselineFunc) {
+		this.baselineFunc_ = baselineFunc;
+	}
+	setCoreDirtiedFunc(dirtiedFunc) {
+		this.dirtiedFunc_ = dirtiedFunc;
+	}
+	insertChild(child, index) {
+		if (child.style.display() === Display.Contents) this.contentsChildrenCount_++;
+		if (index === this.children.length) this.children.push(child);
+		else this.children.splice(index, 0, child);
+	}
+	setConfig(config) {
+		if (config.useWebDefaults() !== this.config.useWebDefaults()) throw new Error("UseWebDefaults may not be changed after constructing a Node");
+		if (configUpdateInvalidatesLayout(this.config, config)) {
+			this.markDirtyAndPropagate();
+			this.layout.configVersion = 0;
+		} else this.layout.configVersion = config.getVersion();
+		this.config = config;
+	}
+	setDirty(isDirty) {
+		if (isDirty === this.isDirty_) return;
+		this.isDirty_ = isDirty;
+		if (isDirty && this.dirtiedFunc_ !== null) this.dirtiedFunc_();
+	}
+	setChildren(children) {
+		this.children = children.slice();
+		this.contentsChildrenCount_ = 0;
+		for (const child of children) if (child.style.display() === Display.Contents) this.contentsChildrenCount_++;
+	}
+	removeChild(child) {
+		const index = this.children.indexOf(child);
+		if (index >= 0) {
+			if (child.style.display() === Display.Contents) this.contentsChildrenCount_--;
+			this.children.splice(index, 1);
+			return true;
+		}
+		return false;
+	}
+	removeChildAtIndex(index) {
+		if (this.children[index].style.display() === Display.Contents) this.contentsChildrenCount_--;
+		this.children.splice(index, 1);
+	}
+	clearChildren() {
+		this.children = [];
+	}
+	syncContentsChildrenCount() {
+		this.contentsChildrenCount_ = 0;
+		for (const child of this.children) if (child.style.display() === Display.Contents) this.contentsChildrenCount_++;
+	}
+	setLayoutDirection(direction) {
+		this.layout.setDirection(direction);
+	}
+	setLayoutMargin(margin, edge) {
+		this.layout.setMargin(edge, margin);
+	}
+	setLayoutBorder(border, edge) {
+		this.layout.setBorder(edge, border);
+	}
+	setLayoutPadding(padding, edge) {
+		this.layout.setPadding(edge, padding);
+	}
+	setLayoutLastOwnerDirection(direction) {
+		this.layout.lastOwnerDirection = direction;
+	}
+	setLayoutComputedFlexBasis(computedFlexBasis) {
+		this.layout.computedFlexBasis = computedFlexBasis;
+	}
+	markLayoutWritten() {
+		if (this.layout.roundingDirty) return;
+		this.layout.roundingDirty = true;
+		let node = this.owner;
+		while (node !== null && !node.layout.roundingDirty) {
+			node.layout.roundingDirty = true;
+			node = node.owner;
+		}
+	}
+	setLayoutPosition(position, edge) {
+		const value = position;
+		if (!Object.is(this.layout.position(edge), value)) {
+			this.layout.setPosition(edge, value);
+			this.markLayoutWritten();
+		}
+	}
+	setLayoutComputedFlexBasisGeneration(computedFlexBasisGeneration) {
+		this.layout.computedFlexBasisGeneration = computedFlexBasisGeneration;
+	}
+	setLayoutMeasuredDimension(measuredDimension, dim) {
+		this.layout.setMeasuredDimension(dim, measuredDimension);
+	}
+	setLayoutHadOverflow(hadOverflow) {
+		this.layout.setHadOverflow(hadOverflow);
+	}
+	setLayoutDimension(lengthValue, dim) {
+		const value = lengthValue;
+		if (!Object.is(this.layout.dimension(dim), value) || !Object.is(this.layout.rawDimension(dim), value)) {
+			this.layout.setDimension(dim, value);
+			this.layout.setRawDimension(dim, value);
+			this.markLayoutWritten();
+		}
+	}
+	relativePosition(axis, direction, axisSize) {
+		if (this.style.positionType() === PositionType.Static) return 0;
+		if (this.style.isInlineStartPositionDefined(axis, direction) && !this.style.isInlineStartPositionAuto(axis, direction)) return this.style.computeInlineStartPosition(axis, direction, axisSize);
+		return -1 * this.style.computeInlineEndPosition(axis, direction, axisSize);
+	}
+	setPositionFromStyle(direction, ownerWidth, ownerHeight) {
+		if (!this.style.hasPositionOrMargin()) {
+			this.setLayoutPosition(0, PhysicalEdge.Left);
+			this.setLayoutPosition(0, PhysicalEdge.Top);
+			this.setLayoutPosition(0, PhysicalEdge.Right);
+			this.setLayoutPosition(0, PhysicalEdge.Bottom);
+			return;
+		}
+		const directionRespectingRoot = this.owner !== null ? direction : Direction.LTR;
+		const mainAxis = resolveDirection(this.style.flexDirection(), directionRespectingRoot);
+		const crossAxis = resolveCrossDirection(mainAxis, directionRespectingRoot);
+		const relativePositionMain = this.relativePosition(mainAxis, directionRespectingRoot, isRow(mainAxis) ? ownerWidth : ownerHeight);
+		const relativePositionCross = this.relativePosition(crossAxis, directionRespectingRoot, isRow(mainAxis) ? ownerHeight : ownerWidth);
+		const mainAxisLeadingEdge = inlineStartEdge(mainAxis, direction);
+		const mainAxisTrailingEdge = inlineEndEdge(mainAxis, direction);
+		const crossAxisLeadingEdge = inlineStartEdge(crossAxis, direction);
+		const crossAxisTrailingEdge = inlineEndEdge(crossAxis, direction);
+		this.setLayoutPosition(this.style.computeInlineStartMargin(mainAxis, direction, ownerWidth) + relativePositionMain, mainAxisLeadingEdge);
+		this.setLayoutPosition(this.style.computeInlineEndMargin(mainAxis, direction, ownerWidth) + relativePositionMain, mainAxisTrailingEdge);
+		this.setLayoutPosition(this.style.computeInlineStartMargin(crossAxis, direction, ownerWidth) + relativePositionCross, crossAxisLeadingEdge);
+		this.setLayoutPosition(this.style.computeInlineEndMargin(crossAxis, direction, ownerWidth) + relativePositionCross, crossAxisTrailingEdge);
+	}
+	processFlexBasis() {
+		const flexBasis = this.style.flexBasis();
+		if (!flexBasis.isAuto() && !flexBasis.isUndefined()) return flexBasis;
+		if (isDefined(this.style.flex()) && this.style.flex() > 0) return this.config.useWebDefaults() ? StyleSizeLength.ofAuto() : StyleSizeLength.points(0);
+		return StyleSizeLength.ofAuto();
+	}
+	resolveFlexBasis(direction, flexDirection, referenceLength, ownerWidth) {
+		const value = this.processFlexBasis().resolve(referenceLength);
+		if (this.style.boxSizing() === BoxSizing.BorderBox) return value;
+		const dim = dimension(flexDirection);
+		const dimensionPaddingAndBorder = this.style.computePaddingAndBorderForDimension(direction, dim, ownerWidth);
+		return value + (isDefined(dimensionPaddingAndBorder) ? dimensionPaddingAndBorder : 0);
+	}
+	processDimensions() {
+		if (!this.dimensionsDirty_) return;
+		for (let dim = Dimension.Width; dim <= Dimension.Height; dim++) {
+			const maxDimension = this.style.maxDimension(dim);
+			const processed = maxDimension.isDefined() && maxDimension.inexactEquals(this.style.minDimension(dim)) ? maxDimension : this.style.dimension(dim);
+			if (dim === Dimension.Width) this.processedDimensionWidth_ = processed;
+			else this.processedDimensionHeight_ = processed;
+		}
+		this.dimensionsDirty_ = false;
+	}
+	invalidateProcessedDimensions() {
+		this.dimensionsDirty_ = true;
+	}
+	resolveDirection(ownerDirection) {
+		if (this.style.direction() === Direction.Inherit) return ownerDirection !== Direction.Inherit ? ownerDirection : Direction.LTR;
+		else return this.style.direction();
+	}
+	cloneChildrenIfNeeded() {}
+	cloneContentsChildrenIfNeeded() {}
+	markDirtyAndPropagate() {
+		if (!this.isDirty_) {
+			this.setDirty(true);
+			this.setLayoutComputedFlexBasis(NaN);
+			if (this.owner !== null) this.owner.markDirtyAndPropagate();
+		}
+	}
+	resolveFlexGrow() {
+		if (this.owner === null) return 0;
+		if (isDefined(this.style.flexGrow())) return this.style.flexGrow();
+		if (isDefined(this.style.flex()) && this.style.flex() > 0) return this.style.flex();
+		return Style.DefaultFlexGrow;
+	}
+	resolveFlexShrink() {
+		if (this.owner === null) return 0;
+		if (isDefined(this.style.flexShrink())) return this.style.flexShrink();
+		if (!this.config.useWebDefaults() && isDefined(this.style.flex()) && this.style.flex() < 0) return -this.style.flex();
+		return this.config.useWebDefaults() ? Style.WebDefaultFlexShrink : Style.DefaultFlexShrink;
+	}
+	isNodeFlexible() {
+		return this.style.positionType() !== PositionType.Absolute && (this.resolveFlexGrow() !== 0 || this.resolveFlexShrink() !== 0);
+	}
+	reset() {
+		if (this.children.length !== 0) throw new Error("Cannot reset a node which still has children attached");
+		if (this.owner !== null) throw new Error("Cannot reset a node still attached to a owner");
+		const fresh = new Node$1(this.config);
+		this.hasNewLayout_ = fresh.hasNewLayout_;
+		this.isReferenceBaseline_ = fresh.isReferenceBaseline_;
+		this.isDirty_ = true;
+		this.alwaysFormsContainingBlock = fresh.alwaysFormsContainingBlock;
+		this.nodeType = fresh.nodeType;
+		this.measureFunc_ = null;
+		this.measureResult_ = null;
+		this.baselineFunc_ = null;
+		this.dirtiedFunc_ = null;
+		this.style = fresh.style;
+		this.layout = fresh.layout;
+		this.lineIndex = 0;
+		this.contentsChildrenCount_ = 0;
+		this.children = [];
+		this.processedDimensionWidth_ = StyleSizeLength.undefined();
+		this.processedDimensionHeight_ = StyleSizeLength.undefined();
+		this.dimensionsDirty_ = true;
+	}
+};
+function appendLayoutChildren(node, out) {
+	for (const child of node.children) if (child.style.display() === Display.Contents) appendLayoutChildren(child, out);
+	else out.push(child);
+}
+//#endregion
+//#region src/yoga/node.ts
+function styleValue(length) {
+	return {
+		value: length.value,
+		unit: length.unit
+	};
+}
+function dispatchSetter(self, fnName, pointFn, args) {
+	const value = args.pop();
+	let unit;
+	let asNumber;
+	if (value === "auto") {
+		unit = Unit.Auto;
+		asNumber = void 0;
+	} else if (value === "max-content") {
+		unit = Unit.MaxContent;
+		asNumber = void 0;
+	} else if (value === "fit-content") {
+		unit = Unit.FitContent;
+		asNumber = void 0;
+	} else if (value === "stretch") {
+		unit = Unit.Stretch;
+		asNumber = void 0;
+	} else if (typeof value === "object" && value !== null) {
+		unit = value.unit;
+		asNumber = value.valueOf();
+	} else {
+		unit = typeof value === "string" && value.endsWith("%") ? Unit.Percent : Unit.Point;
+		asNumber = parseFloat(value);
+		if (value !== void 0 && !Number.isNaN(value) && Number.isNaN(asNumber)) throw new Error(`Invalid value ${JSON.stringify(value) ?? "undefined"} for ${fnName}`);
+	}
+	if (unit === Unit.Point) return pointFn.call(self, ...args, asNumber);
+	const suffix = {
+		[Unit.Percent]: "Percent",
+		[Unit.Auto]: "Auto",
+		[Unit.MaxContent]: "MaxContent",
+		[Unit.FitContent]: "FitContent",
+		[Unit.Stretch]: "Stretch"
+	}[unit];
+	if (suffix === void 0) throw new Error(`Failed to execute "${fnName}": Unsupported unit '${JSON.stringify(value) ?? "undefined"}'`);
+	const method = self[`${fnName}${suffix}`];
+	if (!method) throw new Error(`Failed to execute "${fnName}": Unsupported unit '${JSON.stringify(value) ?? "undefined"}'`);
+	if (asNumber !== void 0) return method.call(self, ...args, asNumber);
+	else return method.call(self, ...args);
+}
+//#endregion
+//#region src/yoga/index.ts
+const Yoga = {
+	Config,
+	Node: class Node extends Node$1 {
+		constructor(config) {
+			super(config ? config.core : getDefaultConfig());
+		}
+		static create(config) {
+			return new Node(config);
+		}
+		static createDefault() {
+			return new Node();
+		}
+		static createWithConfig(config) {
+			return new Node(config);
+		}
+		/**
+		@deprecated No-op in the TypeScript port: the garbage collector owns this
+		node's lifetime. Kept only for yoga-layout binding compatibility (WASM
+		nodes require explicit destruction).
+		*/
+		free() {}
+		/**
+		@deprecated No-op in the TypeScript port: garbage collection handles
+		object graphs and cycles. Kept only for yoga-layout binding compatibility.
+		*/
+		freeRecursive() {}
+		insertChild(child, index) {
+			if (child.owner !== null) throw new Error("Child already has a owner, it must be removed first.");
+			if (this.hasMeasureFunc()) throw new Error("Cannot add child: Nodes with measure functions cannot have children.");
+			super.insertChild(child, index);
+			child.owner = this;
+			this.markDirtyAndPropagate();
+		}
+		removeChild(child) {
+			let removed = false;
+			if (super.getChildCount() > 0) {
+				if (super.removeChild(child)) {
+					removed = true;
+					child.layout = new LayoutResults();
+					child.owner = null;
+					const dirtiedFunc = child.getDirtiedFunc();
+					child.setCoreDirtiedFunc(null);
+					child.setDirty(true);
+					child.setCoreDirtiedFunc(dirtiedFunc);
+					this.markDirtyAndPropagate();
+				}
+			}
+			return removed;
+		}
+		getChildCount() {
+			return super.getChildCount();
+		}
+		getChild(index) {
+			return super.getChild(index);
+		}
+		getParent() {
+			return this.owner;
+		}
+		setChildren(children) {
+			while (super.getChildCount() !== 0) this.removeChild(this.getChild(super.getChildCount() - 1));
+			children.forEach((child, index) => this.insertChild(child, index));
+		}
+		reset() {
+			super.reset();
+		}
+		copyStyle(other) {
+			if (!this.style.equals(other.style)) {
+				this.style.copyFrom(other.style);
+				this.invalidateProcessedDimensions();
+				this.markDirtyAndPropagate();
+			}
+		}
+		updateStyleLength(get, set, value) {
+			if (!get().equals(value)) {
+				set(value);
+				this.markDirtyAndPropagate();
+			}
+		}
+		updateStyleSize(get, set, value) {
+			if (!get().equals(value)) {
+				set(value);
+				this.markDirtyAndPropagate();
+			}
+		}
+		updateStyleEnum(get, set, value) {
+			if (get() !== value) {
+				set(value);
+				this.markDirtyAndPropagate();
+			}
+		}
+		setDimensionValue(dim, value) {
+			if (!this.style.dimension(dim).equals(value)) {
+				this.style.setDimension(dim, value);
+				this.invalidateProcessedDimensions();
+				this.markDirtyAndPropagate();
+			}
+		}
+		setMinDimensionValue(dim, value) {
+			if (!this.style.minDimension(dim).equals(value)) {
+				this.style.setMinDimension(dim, value);
+				this.invalidateProcessedDimensions();
+				this.markDirtyAndPropagate();
+			}
+		}
+		setMaxDimensionValue(dim, value) {
+			if (!this.style.maxDimension(dim).equals(value)) {
+				this.style.setMaxDimension(dim, value);
+				this.invalidateProcessedDimensions();
+				this.markDirtyAndPropagate();
+			}
+		}
+		setPositionType(positionType) {
+			this.updateStyleEnum(() => this.style.positionType(), (v) => this.style.setPositionType(v), positionType);
+		}
+		setPosition(edge, position) {
+			if (typeof position === "number" || position === void 0) {
+				this.updateStyleLength(() => this.style.position(edge), (v) => this.style.setPosition(edge, v), StyleLength.points(position === void 0 ? NaN : position));
+				return;
+			}
+			dispatchSetter(this, "setPosition", (e, value) => this.updateStyleLength(() => this.style.position(e), (v) => this.style.setPosition(e, v), StyleLength.points(value === void 0 ? NaN : value)), [edge, position]);
+		}
+		setPositionPercent(edge, position) {
+			this.updateStyleLength(() => this.style.position(edge), (v) => this.style.setPosition(edge, v), StyleLength.percent(position === void 0 ? NaN : position));
+		}
+		setPositionAuto(edge) {
+			this.updateStyleLength(() => this.style.position(edge), (v) => this.style.setPosition(edge, v), StyleLength.ofAuto());
+		}
+		setAlignContent(alignContent) {
+			this.updateStyleEnum(() => this.style.alignContent(), (v) => this.style.setAlignContent(v), alignContent);
+		}
+		setAlignItems(alignItems) {
+			this.updateStyleEnum(() => this.style.alignItems(), (v) => this.style.setAlignItems(v), alignItems);
+		}
+		setAlignSelf(alignSelf) {
+			this.updateStyleEnum(() => this.style.alignSelf(), (v) => this.style.setAlignSelf(v), alignSelf);
+		}
+		setFlexDirection(flexDirection) {
+			if (this.style.flexDirection() !== flexDirection) {
+				this.style.setFlexDirection(flexDirection);
+				this.markDirtyAndPropagate();
+			}
+		}
+		setFlexWrap(flexWrap) {
+			this.updateStyleEnum(() => this.style.flexWrap(), (v) => this.style.setFlexWrap(v), flexWrap);
+		}
+		setJustifyContent(justifyContent) {
+			this.updateStyleEnum(() => this.style.justifyContent(), (v) => this.style.setJustifyContent(v), justifyContent);
+		}
+		setDirection(direction) {
+			this.updateStyleEnum(() => this.style.direction(), (v) => this.style.setDirection(v), direction);
+		}
+		setMargin(edge, margin) {
+			if (typeof margin === "number" || margin === void 0) {
+				this.updateStyleLength(() => this.style.margin(edge), (v) => this.style.setMargin(edge, v), StyleLength.points(margin === void 0 ? NaN : margin));
+				return;
+			}
+			dispatchSetter(this, "setMargin", (e, value) => this.updateStyleLength(() => this.style.margin(e), (v) => this.style.setMargin(e, v), StyleLength.points(value === void 0 ? NaN : value)), [edge, margin]);
+		}
+		setMarginPercent(edge, margin) {
+			this.updateStyleLength(() => this.style.margin(edge), (v) => this.style.setMargin(edge, v), StyleLength.percent(margin === void 0 ? NaN : margin));
+		}
+		setMarginAuto(edge) {
+			this.updateStyleLength(() => this.style.margin(edge), (v) => this.style.setMargin(edge, v), StyleLength.ofAuto());
+		}
+		setOverflow(overflow) {
+			this.updateStyleEnum(() => this.style.overflow(), (v) => this.style.setOverflow(v), overflow);
+		}
+		setDisplay(display) {
+			if (this.style.display() !== display) {
+				this.style.setDisplay(display);
+				this.owner?.syncContentsChildrenCount();
+				this.markDirtyAndPropagate();
+			}
+		}
+		setFlex(flex) {
+			const value = flex === void 0 ? NaN : flex;
+			const current = this.style.flex();
+			if (current !== value && !(Number.isNaN(current) && Number.isNaN(value))) {
+				this.style.setFlex(value);
+				this.markDirtyAndPropagate();
+			}
+		}
+		setFlexBasis(flexBasis) {
+			if (typeof flexBasis === "number" || flexBasis === void 0) {
+				this.updateStyleSize(() => this.style.flexBasis(), (v) => this.style.setFlexBasis(v), StyleSizeLength.points(flexBasis === void 0 ? NaN : flexBasis));
+				return;
+			}
+			dispatchSetter(this, "setFlexBasis", (value) => this.updateStyleSize(() => this.style.flexBasis(), (v) => this.style.setFlexBasis(v), StyleSizeLength.points(value === void 0 ? NaN : value)), [flexBasis]);
+		}
+		setFlexBasisPercent(flexBasis) {
+			this.updateStyleSize(() => this.style.flexBasis(), (v) => this.style.setFlexBasis(v), StyleSizeLength.percent(flexBasis === void 0 ? NaN : flexBasis));
+		}
+		setFlexBasisAuto() {
+			this.updateStyleSize(() => this.style.flexBasis(), (v) => this.style.setFlexBasis(v), StyleSizeLength.ofAuto());
+		}
+		setFlexBasisMaxContent() {
+			this.updateStyleSize(() => this.style.flexBasis(), (v) => this.style.setFlexBasis(v), StyleSizeLength.ofMaxContent());
+		}
+		setFlexBasisFitContent() {
+			this.updateStyleSize(() => this.style.flexBasis(), (v) => this.style.setFlexBasis(v), StyleSizeLength.ofFitContent());
+		}
+		setFlexBasisStretch() {
+			this.updateStyleSize(() => this.style.flexBasis(), (v) => this.style.setFlexBasis(v), StyleSizeLength.ofStretch());
+		}
+		setFlexGrow(flexGrow) {
+			const value = flexGrow === void 0 ? NaN : flexGrow;
+			const current = this.style.flexGrow();
+			if (current !== value && !(Number.isNaN(current) && Number.isNaN(value))) {
+				this.style.setFlexGrow(value);
+				this.markDirtyAndPropagate();
+			}
+		}
+		setFlexShrink(flexShrink) {
+			const value = flexShrink === void 0 ? NaN : flexShrink;
+			const current = this.style.flexShrink();
+			if (current !== value && !(Number.isNaN(current) && Number.isNaN(value))) {
+				this.style.setFlexShrink(value);
+				this.markDirtyAndPropagate();
+			}
+		}
+		setWidth(width) {
+			if (typeof width === "number" || width === void 0) {
+				this.setDimensionValue(Dimension.Width, StyleSizeLength.points(width === void 0 ? NaN : width));
+				return;
+			}
+			dispatchSetter(this, "setWidth", (value) => this.setDimensionValue(Dimension.Width, StyleSizeLength.points(value === void 0 ? NaN : value)), [width]);
+		}
+		setWidthPercent(width) {
+			this.setDimensionValue(Dimension.Width, StyleSizeLength.percent(width === void 0 ? NaN : width));
+		}
+		setWidthAuto() {
+			this.setDimensionValue(Dimension.Width, StyleSizeLength.ofAuto());
+		}
+		setWidthMaxContent() {
+			this.setDimensionValue(Dimension.Width, StyleSizeLength.ofMaxContent());
+		}
+		setWidthFitContent() {
+			this.setDimensionValue(Dimension.Width, StyleSizeLength.ofFitContent());
+		}
+		setWidthStretch() {
+			this.setDimensionValue(Dimension.Width, StyleSizeLength.ofStretch());
+		}
+		setHeight(height) {
+			if (typeof height === "number" || height === void 0) {
+				this.setDimensionValue(Dimension.Height, StyleSizeLength.points(height === void 0 ? NaN : height));
+				return;
+			}
+			dispatchSetter(this, "setHeight", (value) => this.setDimensionValue(Dimension.Height, StyleSizeLength.points(value === void 0 ? NaN : value)), [height]);
+		}
+		setHeightPercent(height) {
+			this.setDimensionValue(Dimension.Height, StyleSizeLength.percent(height === void 0 ? NaN : height));
+		}
+		setHeightAuto() {
+			this.setDimensionValue(Dimension.Height, StyleSizeLength.ofAuto());
+		}
+		setHeightMaxContent() {
+			this.setDimensionValue(Dimension.Height, StyleSizeLength.ofMaxContent());
+		}
+		setHeightFitContent() {
+			this.setDimensionValue(Dimension.Height, StyleSizeLength.ofFitContent());
+		}
+		setHeightStretch() {
+			this.setDimensionValue(Dimension.Height, StyleSizeLength.ofStretch());
+		}
+		setMinWidth(minWidth) {
+			if (typeof minWidth === "number" || minWidth === void 0) {
+				this.setMinDimensionValue(Dimension.Width, StyleSizeLength.points(minWidth === void 0 ? NaN : minWidth));
+				return;
+			}
+			dispatchSetter(this, "setMinWidth", (value) => this.setMinDimensionValue(Dimension.Width, StyleSizeLength.points(value === void 0 ? NaN : value)), [minWidth]);
+		}
+		setMinWidthPercent(minWidth) {
+			this.setMinDimensionValue(Dimension.Width, StyleSizeLength.percent(minWidth === void 0 ? NaN : minWidth));
+		}
+		setMinWidthMaxContent() {
+			this.setMinDimensionValue(Dimension.Width, StyleSizeLength.ofMaxContent());
+		}
+		setMinWidthFitContent() {
+			this.setMinDimensionValue(Dimension.Width, StyleSizeLength.ofFitContent());
+		}
+		setMinWidthStretch() {
+			this.setMinDimensionValue(Dimension.Width, StyleSizeLength.ofStretch());
+		}
+		setMinHeight(minHeight) {
+			if (typeof minHeight === "number" || minHeight === void 0) {
+				this.setMinDimensionValue(Dimension.Height, StyleSizeLength.points(minHeight === void 0 ? NaN : minHeight));
+				return;
+			}
+			dispatchSetter(this, "setMinHeight", (value) => this.setMinDimensionValue(Dimension.Height, StyleSizeLength.points(value === void 0 ? NaN : value)), [minHeight]);
+		}
+		setMinHeightPercent(minHeight) {
+			this.setMinDimensionValue(Dimension.Height, StyleSizeLength.percent(minHeight === void 0 ? NaN : minHeight));
+		}
+		setMinHeightMaxContent() {
+			this.setMinDimensionValue(Dimension.Height, StyleSizeLength.ofMaxContent());
+		}
+		setMinHeightFitContent() {
+			this.setMinDimensionValue(Dimension.Height, StyleSizeLength.ofFitContent());
+		}
+		setMinHeightStretch() {
+			this.setMinDimensionValue(Dimension.Height, StyleSizeLength.ofStretch());
+		}
+		setMaxWidth(maxWidth) {
+			if (typeof maxWidth === "number" || maxWidth === void 0) {
+				this.setMaxDimensionValue(Dimension.Width, StyleSizeLength.points(maxWidth === void 0 ? NaN : maxWidth));
+				return;
+			}
+			dispatchSetter(this, "setMaxWidth", (value) => this.setMaxDimensionValue(Dimension.Width, StyleSizeLength.points(value === void 0 ? NaN : value)), [maxWidth]);
+		}
+		setMaxWidthPercent(maxWidth) {
+			this.setMaxDimensionValue(Dimension.Width, StyleSizeLength.percent(maxWidth === void 0 ? NaN : maxWidth));
+		}
+		setMaxWidthMaxContent() {
+			this.setMaxDimensionValue(Dimension.Width, StyleSizeLength.ofMaxContent());
+		}
+		setMaxWidthFitContent() {
+			this.setMaxDimensionValue(Dimension.Width, StyleSizeLength.ofFitContent());
+		}
+		setMaxWidthStretch() {
+			this.setMaxDimensionValue(Dimension.Width, StyleSizeLength.ofStretch());
+		}
+		setMaxHeight(maxHeight) {
+			if (typeof maxHeight === "number" || maxHeight === void 0) {
+				this.setMaxDimensionValue(Dimension.Height, StyleSizeLength.points(maxHeight === void 0 ? NaN : maxHeight));
+				return;
+			}
+			dispatchSetter(this, "setMaxHeight", (value) => this.setMaxDimensionValue(Dimension.Height, StyleSizeLength.points(value === void 0 ? NaN : value)), [maxHeight]);
+		}
+		setMaxHeightPercent(maxHeight) {
+			this.setMaxDimensionValue(Dimension.Height, StyleSizeLength.percent(maxHeight === void 0 ? NaN : maxHeight));
+		}
+		setMaxHeightMaxContent() {
+			this.setMaxDimensionValue(Dimension.Height, StyleSizeLength.ofMaxContent());
+		}
+		setMaxHeightFitContent() {
+			this.setMaxDimensionValue(Dimension.Height, StyleSizeLength.ofFitContent());
+		}
+		setMaxHeightStretch() {
+			this.setMaxDimensionValue(Dimension.Height, StyleSizeLength.ofStretch());
+		}
+		setAspectRatio(aspectRatio) {
+			const value = aspectRatio === void 0 ? NaN : aspectRatio;
+			const current = this.style.aspectRatio();
+			const normalized = value === 0 || value === Infinity || value === -Infinity ? NaN : value;
+			if (current !== normalized && !(Number.isNaN(current) && Number.isNaN(normalized))) {
+				this.style.setAspectRatio(value);
+				this.markDirtyAndPropagate();
+			}
+		}
+		setBorder(edge, borderWidth) {
+			this.updateStyleLength(() => this.style.border(edge), (v) => this.style.setBorder(edge, v), StyleLength.points(borderWidth === void 0 ? NaN : borderWidth));
+		}
+		setPadding(edge, padding) {
+			if (typeof padding === "number" || padding === void 0) {
+				this.updateStyleLength(() => this.style.padding(edge), (v) => this.style.setPadding(edge, v), StyleLength.points(padding === void 0 ? NaN : padding));
+				return;
+			}
+			dispatchSetter(this, "setPadding", (e, value) => this.updateStyleLength(() => this.style.padding(e), (v) => this.style.setPadding(e, v), StyleLength.points(value === void 0 ? NaN : value)), [edge, padding]);
+		}
+		setPaddingPercent(edge, padding) {
+			this.updateStyleLength(() => this.style.padding(edge), (v) => this.style.setPadding(edge, v), StyleLength.percent(padding === void 0 ? NaN : padding));
+		}
+		setGap(gutter, gapLength) {
+			if (typeof gapLength === "number" || gapLength === void 0) {
+				this.updateStyleLength(() => this.style.gap(gutter), (v) => this.style.setGap(gutter, v), StyleLength.points(gapLength === void 0 ? NaN : gapLength));
+				return;
+			}
+			dispatchSetter(this, "setGap", (g, value) => this.updateStyleLength(() => this.style.gap(g), (v) => this.style.setGap(g, v), StyleLength.points(value === void 0 ? NaN : value)), [gutter, gapLength]);
+		}
+		setGapPercent(gutter, gapLength) {
+			this.updateStyleLength(() => this.style.gap(gutter), (v) => this.style.setGap(gutter, v), StyleLength.percent(gapLength === void 0 ? NaN : gapLength));
+		}
+		setBoxSizing(boxSizing) {
+			this.updateStyleEnum(() => this.style.boxSizing(), (v) => this.style.setBoxSizing(v), boxSizing);
+		}
+		setIsReferenceBaseline(isReferenceBaseline) {
+			if (this.isReferenceBaseline_ !== isReferenceBaseline) {
+				this.isReferenceBaseline_ = isReferenceBaseline;
+				this.markDirtyAndPropagate();
+			}
+		}
+		setAlwaysFormsContainingBlock(alwaysFormsContainingBlock) {
+			this.alwaysFormsContainingBlock = alwaysFormsContainingBlock;
+		}
+		getPositionType() {
+			return this.style.positionType();
+		}
+		getPosition(edge) {
+			return styleValue(this.style.position(edge));
+		}
+		getAlignContent() {
+			return this.style.alignContent();
+		}
+		getAlignItems() {
+			return this.style.alignItems();
+		}
+		getAlignSelf() {
+			return this.style.alignSelf();
+		}
+		getFlexDirection() {
+			return this.style.flexDirection();
+		}
+		getFlexWrap() {
+			return this.style.flexWrap();
+		}
+		getJustifyContent() {
+			return this.style.justifyContent();
+		}
+		getDirection() {
+			return this.style.direction();
+		}
+		getMargin(edge) {
+			return styleValue(this.style.margin(edge));
+		}
+		getOverflow() {
+			return this.style.overflow();
+		}
+		getDisplay() {
+			return this.style.display();
+		}
+		getFlexBasis() {
+			return styleValue(this.style.flexBasis());
+		}
+		getFlexGrow() {
+			const flexGrow = this.style.flexGrow();
+			return Number.isNaN(flexGrow) ? 0 : flexGrow;
+		}
+		getFlexShrink() {
+			const flexShrink = this.style.flexShrink();
+			return Number.isNaN(flexShrink) ? this.config.useWebDefaults() ? 1 : 0 : flexShrink;
+		}
+		getWidth() {
+			return styleValue(this.style.dimension(Dimension.Width));
+		}
+		getHeight() {
+			return styleValue(this.style.dimension(Dimension.Height));
+		}
+		getMinWidth() {
+			return styleValue(this.style.minDimension(Dimension.Width));
+		}
+		getMinHeight() {
+			return styleValue(this.style.minDimension(Dimension.Height));
+		}
+		getMaxWidth() {
+			return styleValue(this.style.maxDimension(Dimension.Width));
+		}
+		getMaxHeight() {
+			return styleValue(this.style.maxDimension(Dimension.Height));
+		}
+		getAspectRatio() {
+			return this.style.aspectRatio();
+		}
+		getBorder(edge) {
+			const border = this.style.border(edge);
+			if (border.isUndefined() || border.isAuto()) return NaN;
+			return border.value;
+		}
+		getPadding(edge) {
+			return styleValue(this.style.padding(edge));
+		}
+		getGap(gutter) {
+			return styleValue(this.style.gap(gutter));
+		}
+		getBoxSizing() {
+			return this.style.boxSizing();
+		}
+		isReferenceBaseline() {
+			return this.isReferenceBaseline_;
+		}
+		setMeasureFunc(measureFunc) {
+			if (measureFunc) super.setMeasureFunc(measureFunc);
+			else this.unsetMeasureFunc();
+		}
+		unsetMeasureFunc() {
+			super.setMeasureFunc(null);
+		}
+		setDirtiedFunc(dirtiedFunc) {
+			if (dirtiedFunc) this.setCoreDirtiedFunc(() => dirtiedFunc(this));
+			else this.unsetDirtiedFunc();
+		}
+		unsetDirtiedFunc() {
+			this.setCoreDirtiedFunc(null);
+		}
+		markDirty() {
+			if (!this.hasMeasureFunc()) throw new Error("Only leaf nodes with custom measure functions should manually mark themselves as dirty");
+			this.markDirtyAndPropagate();
+		}
+		isDirty() {
+			return super.isDirty();
+		}
+		markLayoutSeen() {
+			this.hasNewLayout_ = false;
+		}
+		hasNewLayout() {
+			return this.hasNewLayout_;
+		}
+		calculateLayout(width = NaN, height = NaN, direction = Direction.LTR) {
+			calculateLayout(this, typeof width === "number" ? width : NaN, typeof height === "number" ? height : NaN, direction);
+		}
+		getComputedLeft() {
+			return this.layout.position(PhysicalEdge.Left);
+		}
+		getComputedRight() {
+			return this.layout.position(PhysicalEdge.Right);
+		}
+		getComputedTop() {
+			return this.layout.position(PhysicalEdge.Top);
+		}
+		getComputedBottom() {
+			return this.layout.position(PhysicalEdge.Bottom);
+		}
+		getComputedWidth() {
+			return this.layout.dimension(Dimension.Width);
+		}
+		getComputedHeight() {
+			return this.layout.dimension(Dimension.Height);
+		}
+		getComputedHadOverflow() {
+			return this.layout.hadOverflow();
+		}
+		getComputedLayout() {
+			return {
+				left: this.getComputedLeft(),
+				right: this.getComputedRight(),
+				top: this.getComputedTop(),
+				bottom: this.getComputedBottom(),
+				width: this.getComputedWidth(),
+				height: this.getComputedHeight(),
+				hadOverflow: this.getComputedHadOverflow()
+			};
+		}
+		resolvedLayoutProperty(getter, edge) {
+			if (edge > Edge.End) throw new Error("Cannot get layout properties of multi-edge shorthands");
+			if (edge === Edge.Start) return this.layout.direction() === Direction.RTL ? getter(PhysicalEdge.Right) : getter(PhysicalEdge.Left);
+			if (edge === Edge.End) return this.layout.direction() === Direction.RTL ? getter(PhysicalEdge.Left) : getter(PhysicalEdge.Right);
+			return getter(edge);
+		}
+		getComputedMargin(edge) {
+			return this.resolvedLayoutProperty((e) => this.layout.margin(e), edge);
+		}
+		getComputedBorder(edge) {
+			return this.resolvedLayoutProperty((e) => this.layout.border(e), edge);
+		}
+		getComputedPadding(edge) {
+			return this.resolvedLayoutProperty((e) => this.layout.padding(e), edge);
+		}
+	},
+	...constants
+};
+//#endregion
+export { Overflow as _, Direction as a, Wrap as b, Errata as c, GridTrackType as d, Gutter as f, NodeType as g, MeasureMode as h, Dimension as i, ExperimentalFeature as l, LogLevel as m, Align as n, Display as o, Justify as p, BoxSizing as r, Edge as s, Yoga as t, FlexDirection as u, PositionType as v, constants as x, Unit as y };