func (node *Node) LayoutGetPadding(edge Edge) float32 {
	assertWithNode(node, edge < EdgeEnd,
		"Cannot get layout properties of multi-edge shorthands")
	if edge == EdgeLeft {
		if node.Layout.Direction == DirectionRTL {
			return node.Layout.Padding[EdgeEnd]
		}
		return node.Layout.Padding[EdgeStart]
	}
	if edge == EdgeRight {
		if node.Layout.Direction == DirectionRTL {
			return node.Layout.Padding[EdgeStart]
		}
		return node.Layout.Padding[EdgeEnd]
	}
	return node.Layout.Padding[edge]
}
LayoutGetPadding gets padding
package flex
func (node *Node) StyleSetWidth(width float32) {
	dim := &node.Style.Dimensions[DimensionWidth]
	if dim.Value != width || dim.Unit != UnitPoint {
		dim.Value = width
		dim.Unit = UnitPoint
		if FloatIsUndefined(width) {
			dim.Unit = UnitAuto
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetWidthPercent(width float32) {
	dim := &node.Style.Dimensions[DimensionWidth]
	if dim.Value != width || dim.Unit != UnitPercent {
		dim.Value = width
		dim.Unit = UnitPercent
		if FloatIsUndefined(width) {
			dim.Unit = UnitAuto
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetWidthAuto() {
	dim := &node.Style.Dimensions[DimensionWidth]
	if dim.Unit != UnitAuto {
		dim.Value = Undefined
		dim.Unit = UnitAuto
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleGetWidth() Value {
	return node.Style.Dimensions[DimensionWidth]
}
func (node *Node) StyleSetHeight(height float32) {
	dim := &node.Style.Dimensions[DimensionHeight]
	if dim.Value != height || dim.Unit != UnitPoint {
		dim.Value = height
		dim.Unit = UnitPoint
		if FloatIsUndefined(height) {
			dim.Unit = UnitAuto
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetHeightPercent(height float32) {
	dim := &node.Style.Dimensions[DimensionHeight]
	if dim.Value != height || dim.Unit != UnitPercent {
		dim.Value = height
		dim.Unit = UnitPercent
		if FloatIsUndefined(height) {
			dim.Unit = UnitAuto
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetHeightAuto() {
	dim := &node.Style.Dimensions[DimensionHeight]
	if dim.Unit != UnitAuto {
		dim.Value = Undefined
		dim.Unit = UnitAuto
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleGetHeight() Value {
	return node.Style.Dimensions[DimensionHeight]
}
func (node *Node) StyleSetPositionType(positionType PositionType) {
	if node.Style.PositionType != positionType {
		node.Style.PositionType = positionType
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetPosition(edge Edge, position float32) {
	pos := &node.Style.Position[edge]
	if pos.Value != position || pos.Unit != UnitPoint {
		pos.Value = position
		pos.Unit = UnitPoint
		if FloatIsUndefined(position) {
			pos.Unit = UnitUndefined
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetPositionPercent(edge Edge, position float32) {
	pos := &node.Style.Position[edge]
	if pos.Value != position || pos.Unit != UnitPercent {
		pos.Value = position
		pos.Unit = UnitPercent
		if FloatIsUndefined(position) {
			pos.Unit = UnitUndefined
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleGetPosition(edge Edge) Value {
	return node.Style.Position[edge]
}
func (node *Node) StyleSetDirection(direction Direction) {
	if node.Style.Direction != direction {
		node.Style.Direction = direction
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetFlexDirection(flexDirection FlexDirection) {
	if node.Style.FlexDirection != flexDirection {
		node.Style.FlexDirection = flexDirection
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetJustifyContent(justifyContent Justify) {
	if node.Style.JustifyContent != justifyContent {
		node.Style.JustifyContent = justifyContent
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetAlignContent(alignContent Align) {
	if node.Style.AlignContent != alignContent {
		node.Style.AlignContent = alignContent
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetAlignItems(alignItems Align) {
	if node.Style.AlignItems != alignItems {
		node.Style.AlignItems = alignItems
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetAlignSelf(alignSelf Align) {
	if node.Style.AlignSelf != alignSelf {
		node.Style.AlignSelf = alignSelf
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetFlexWrap(flexWrap Wrap) {
	if node.Style.FlexWrap != flexWrap {
		node.Style.FlexWrap = flexWrap
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetOverflow(overflow Overflow) {
	if node.Style.Overflow != overflow {
		node.Style.Overflow = overflow
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetDisplay(display Display) {
	if node.Style.Display != display {
		node.Style.Display = display
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetFlex(flex float32) {
	if node.Style.Flex != flex {
		node.Style.Flex = flex
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetFlexGrow(flexGrow float32) {
	if node.Style.FlexGrow != flexGrow {
		node.Style.FlexGrow = flexGrow
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetFlexShrink(flexShrink float32) {
	if node.Style.FlexShrink != flexShrink {
		node.Style.FlexShrink = flexShrink
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetFlexBasis(flexBasis float32) {
	if node.Style.FlexBasis.Value != flexBasis ||
		node.Style.FlexBasis.Unit != UnitPoint {
		node.Style.FlexBasis.Value = flexBasis
		node.Style.FlexBasis.Unit = UnitPoint
		if FloatIsUndefined(flexBasis) {
			node.Style.FlexBasis.Unit = UnitAuto
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetFlexBasisPercent(flexBasis float32) {
	if node.Style.FlexBasis.Value != flexBasis ||
		node.Style.FlexBasis.Unit != UnitPercent {
		node.Style.FlexBasis.Value = flexBasis
		node.Style.FlexBasis.Unit = UnitPercent
		if FloatIsUndefined(flexBasis) {
			node.Style.FlexBasis.Unit = UnitAuto
		}
		nodeMarkDirtyInternal(node)
	}
}
func NodeStyleSetFlexBasisAuto(node *Node) {
	if node.Style.FlexBasis.Unit != UnitAuto {
		node.Style.FlexBasis.Value = Undefined
		node.Style.FlexBasis.Unit = UnitAuto
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetMargin(edge Edge, margin float32) {
	if node.Style.Margin[edge].Value != margin ||
		node.Style.Margin[edge].Unit != UnitPoint {
		node.Style.Margin[edge].Value = margin
		node.Style.Margin[edge].Unit = UnitPoint
		if FloatIsUndefined(margin) {
			node.Style.Margin[edge].Unit = UnitUndefined
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetMarginPercent(edge Edge, margin float32) {
	if node.Style.Margin[edge].Value != margin ||
		node.Style.Margin[edge].Unit != UnitPercent {
		node.Style.Margin[edge].Value = margin
		node.Style.Margin[edge].Unit = UnitPercent
		if FloatIsUndefined(margin) {
			node.Style.Margin[edge].Unit = UnitUndefined
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleGetMargin(edge Edge) Value {
	return node.Style.Margin[edge]
}
func (node *Node) StyleSetMarginAuto(edge Edge) {
	if node.Style.Margin[edge].Unit != UnitAuto {
		node.Style.Margin[edge].Value = Undefined
		node.Style.Margin[edge].Unit = UnitAuto
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetPadding(edge Edge, padding float32) {
	if node.Style.Padding[edge].Value != padding ||
		node.Style.Padding[edge].Unit != UnitPoint {
		node.Style.Padding[edge].Value = padding
		node.Style.Padding[edge].Unit = UnitPoint
		if FloatIsUndefined(padding) {
			node.Style.Padding[edge].Unit = UnitUndefined
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetPaddingPercent(edge Edge, padding float32) {
	if node.Style.Padding[edge].Value != padding ||
		node.Style.Padding[edge].Unit != UnitPercent {
		node.Style.Padding[edge].Value = padding
		node.Style.Padding[edge].Unit = UnitPercent
		if FloatIsUndefined(padding) {
			node.Style.Padding[edge].Unit = UnitUndefined
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleGetPadding(edge Edge) Value {
	return node.Style.Padding[edge]
}
func (node *Node) StyleSetBorder(edge Edge, border float32) {
	if node.Style.Border[edge].Value != border ||
		node.Style.Border[edge].Unit != UnitPoint {
		node.Style.Border[edge].Value = border
		node.Style.Border[edge].Unit = UnitPoint
		if FloatIsUndefined(border) {
			node.Style.Border[edge].Unit = UnitUndefined
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleGetBorder(edge Edge) float32 {
	return node.Style.Border[edge].Value
}
func (node *Node) StyleSetMinWidth(minWidth float32) {
	if node.Style.MinDimensions[DimensionWidth].Value != minWidth ||
		node.Style.MinDimensions[DimensionWidth].Unit != UnitPoint {
		node.Style.MinDimensions[DimensionWidth].Value = minWidth
		node.Style.MinDimensions[DimensionWidth].Unit = UnitPoint
		if FloatIsUndefined(minWidth) {
			node.Style.MinDimensions[DimensionWidth].Unit = UnitAuto
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetMinWidthPercent(minWidth float32) {
	if node.Style.MinDimensions[DimensionWidth].Value != minWidth ||
		node.Style.MinDimensions[DimensionWidth].Unit != UnitPercent {
		node.Style.MinDimensions[DimensionWidth].Value = minWidth
		node.Style.MinDimensions[DimensionWidth].Unit = UnitPercent
		if FloatIsUndefined(minWidth) {
			node.Style.MinDimensions[DimensionWidth].Unit = UnitAuto
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleGetMinWidth() Value {
	return node.Style.MinDimensions[DimensionWidth]
}
func (node *Node) StyleSetMinHeight(minHeight float32) {
	if node.Style.MinDimensions[DimensionHeight].Value != minHeight ||
		node.Style.MinDimensions[DimensionHeight].Unit != UnitPoint {
		node.Style.MinDimensions[DimensionHeight].Value = minHeight
		node.Style.MinDimensions[DimensionHeight].Unit = UnitPoint
		if FloatIsUndefined(minHeight) {
			node.Style.MinDimensions[DimensionHeight].Unit = UnitAuto
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetMinHeightPercent(minHeight float32) {
	if node.Style.MinDimensions[DimensionHeight].Value != minHeight ||
		node.Style.MinDimensions[DimensionHeight].Unit != UnitPercent {
		node.Style.MinDimensions[DimensionHeight].Value = minHeight
		node.Style.MinDimensions[DimensionHeight].Unit = UnitPercent
		if FloatIsUndefined(minHeight) {
			node.Style.MinDimensions[DimensionHeight].Unit = UnitAuto
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleGetMinHeight() Value {
	return node.Style.MinDimensions[DimensionHeight]
}
func (node *Node) StyleSetMaxWidth(maxWidth float32) {
	if node.Style.MaxDimensions[DimensionWidth].Value != maxWidth ||
		node.Style.MaxDimensions[DimensionWidth].Unit != UnitPoint {
		node.Style.MaxDimensions[DimensionWidth].Value = maxWidth
		node.Style.MaxDimensions[DimensionWidth].Unit = UnitPoint
		if FloatIsUndefined(maxWidth) {
			node.Style.MaxDimensions[DimensionWidth].Unit = UnitAuto
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetMaxWidthPercent(maxWidth float32) {
	if node.Style.MaxDimensions[DimensionWidth].Value != maxWidth ||
		node.Style.MaxDimensions[DimensionWidth].Unit != UnitPercent {
		node.Style.MaxDimensions[DimensionWidth].Value = maxWidth
		node.Style.MaxDimensions[DimensionWidth].Unit = UnitPercent
		if FloatIsUndefined(maxWidth) {
			node.Style.MaxDimensions[DimensionWidth].Unit = UnitAuto
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleGetMaxWidth() Value {
	return node.Style.MaxDimensions[DimensionWidth]
}
func (node *Node) StyleSetMaxHeight(maxHeight float32) {
	if node.Style.MaxDimensions[DimensionHeight].Value != maxHeight ||
		node.Style.MaxDimensions[DimensionHeight].Unit != UnitPoint {
		node.Style.MaxDimensions[DimensionHeight].Value = maxHeight
		node.Style.MaxDimensions[DimensionHeight].Unit = UnitPoint
		if FloatIsUndefined(maxHeight) {
			node.Style.MaxDimensions[DimensionHeight].Unit = UnitAuto
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleSetMaxHeightPercent(maxHeight float32) {
	if node.Style.MaxDimensions[DimensionHeight].Value != maxHeight ||
		node.Style.MaxDimensions[DimensionHeight].Unit != UnitPercent {
		node.Style.MaxDimensions[DimensionHeight].Value = maxHeight
		node.Style.MaxDimensions[DimensionHeight].Unit = UnitPercent
		if FloatIsUndefined(maxHeight) {
			node.Style.MaxDimensions[DimensionHeight].Unit = UnitAuto
		}
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) StyleGetMaxHeight() Value {
	return node.Style.MaxDimensions[DimensionHeight]
}
func (node *Node) StyleSetAspectRatio(aspectRatio float32) {
	if node.Style.AspectRatio != aspectRatio {
		node.Style.AspectRatio = aspectRatio
		nodeMarkDirtyInternal(node)
	}
}
func (node *Node) LayoutGetLeft() float32 {
	return node.Layout.Position[EdgeLeft]
}
func (node *Node) LayoutGetTop() float32 {
	return node.Layout.Position[EdgeTop]
}
func (node *Node) LayoutGetRight() float32 {
	return node.Layout.Position[EdgeRight]
}
func (node *Node) LayoutGetBottom() float32 {
	return node.Layout.Position[EdgeBottom]
}
func (node *Node) LayoutGetWidth() float32 {
	return node.Layout.Dimensions[DimensionWidth]
}
func (node *Node) LayoutGetHeight() float32 {
	return node.Layout.Dimensions[DimensionHeight]
}
func (node *Node) LayoutGetMargin(edge Edge) float32 {
	assertWithNode(node, edge < EdgeEnd, "Cannot get layout properties of multi-edge shorthands")
	if edge == EdgeLeft {
		if node.Layout.Direction == DirectionRTL {
			return node.Layout.Margin[EdgeEnd]
		}
		return node.Layout.Margin[EdgeStart]
	}
	if edge == EdgeRight {
		if node.Layout.Direction == DirectionRTL {
			return node.Layout.Margin[EdgeStart]
		}
		return node.Layout.Margin[EdgeEnd]
	}
	return node.Layout.Margin[edge]
}
func (node *Node) LayoutGetBorder(edge Edge) float32 {
	assertWithNode(node, edge < EdgeEnd,
		"Cannot get layout properties of multi-edge shorthands")
	if edge == EdgeLeft {
		if node.Layout.Direction == DirectionRTL {
			return node.Layout.Border[EdgeEnd]
		}
		return node.Layout.Border[EdgeStart]
	}
	if edge == EdgeRight {
		if node.Layout.Direction == DirectionRTL {
			return node.Layout.Border[EdgeStart]
		}
		return node.Layout.Border[EdgeEnd]
	}
	return node.Layout.Border[edge]
}