css

const (
	// AlignContentStretch stretches lines to fill the cross axis (initial).
	AlignContentStretch AlignContent = iota
	// AlignContentStart packs lines at the cross-start edge.
	AlignContentStart
	// AlignContentEnd packs lines at the cross-end edge.
	AlignContentEnd
	// AlignContentCenter centres the lines as a group.
	AlignContentCenter
	// AlignContentSpaceBetween spreads lines with the ends flush.
	AlignContentSpaceBetween
	// AlignContentSpaceAround spreads lines with half-gaps at the ends.
	AlignContentSpaceAround
	// AlignContentSpaceEvenly spreads lines with equal gaps incl. the ends.
	AlignContentSpaceEvenly
)

const (
	// AlignStretch stretches items to fill the cross axis (initial value).
	AlignStretch AlignItems = iota
	// AlignFlexStart aligns items at the cross-start edge.
	AlignFlexStart
	// AlignFlexEnd aligns items at the cross-end edge.
	AlignFlexEnd
	// AlignCenterItems centres items on the cross axis.
	AlignCenterItems
)

const (
	// AlignSelfAuto uses the container's align-items value (initial).
	AlignSelfAuto AlignSelf = iota
	// AlignSelfStretch stretches this item on the cross axis.
	AlignSelfStretch
	// AlignSelfStart aligns this item at the cross-start edge.
	AlignSelfStart
	// AlignSelfEnd aligns this item at the cross-end edge.
	AlignSelfEnd
	// AlignSelfCenter centres this item on the cross axis.
	AlignSelfCenter
)

const (
	// BgNone is an empty layer (the keyword `none`).
	BgNone BgImageKind = iota
	// BgURL is a url(...) bitmap layer.
	BgURL
	// BgGradient is a linear/radial gradient layer.
	BgGradient
)

const (
	// RepeatBoth tiles on both axes (initial value).
	RepeatBoth BgRepeat = iota
	// RepeatX tiles horizontally only.
	RepeatX
	// RepeatY tiles vertically only.
	RepeatY
	// NoRepeat paints the image once.
	NoRepeat
)

const (
	// SizeAuto uses the image's intrinsic size (gradients fill the box).
	SizeAuto BgSizeKind = iota
	// SizeCover scales to cover the whole box (may crop).
	SizeCover
	// SizeContain scales to fit inside the box (may letterbox).
	SizeContain
	// SizeExplicit uses the given width/height lengths (a length or auto each).
	SizeExplicit
)

const (
	// BorderNone is the initial value: no border line (even if width > 0).
	BorderNone BorderStyle = iota
	// BorderSolid renders a solid line of the border colour.
	BorderSolid
)

const (
	// ContentBox is the initial value: width is the content width.
	ContentBox BoxSizing = iota
	// BorderBox: width includes padding and border.
	BorderBox
)

const (
	// ClearNone is the initial value.
	ClearNone Clear = iota
	// ClearLeft clears past left floats.
	ClearLeft
	// ClearRight clears past right floats.
	ClearRight
	// ClearBoth clears past floats on both sides.
	ClearBoth
)

const (
	// DisplayInline is the default for unknown/inline elements.
	DisplayInline Display = iota
	// DisplayBlock stacks the box vertically in block flow.
	DisplayBlock
	// DisplayNone removes the element (and subtree) from layout.
	DisplayNone
	// DisplayInlineBlock is an atomic inline-level block (laid out as a block
	// but participating inline; Phase 1 treats it as block for simplicity).
	DisplayInlineBlock
	// DisplayFlex is a block-level flex container.
	DisplayFlex
	// DisplayTable is a block-level table box.
	DisplayTable
	// DisplayTableRow is a table row box.
	DisplayTableRow
	// DisplayTableCell is a table cell box.
	DisplayTableCell
	// DisplayTableRowGroup is a thead/tbody/tfoot grouping box (transparent to
	// the table's row collection).
	DisplayTableRowGroup
	// DisplayGrid is a block-level CSS grid container.
	DisplayGrid
)

const (
	// FlexRow lays items along the inline (horizontal) axis.
	FlexRow FlexDirection = iota
	// FlexColumn lays items along the block (vertical) axis.
	FlexColumn
)

const (
	// FlexNoWrap keeps all items on a single line (initial value).
	FlexNoWrap FlexWrap = iota
	// FlexWrapOn wraps items onto new lines toward the cross-end.
	FlexWrapOn
	// FlexWrapReverse wraps items with the cross axis reversed.
	FlexWrapReverse
)

const (
	// FloatNone is the initial value (no float).
	FloatNone Float = iota
	// FloatLeft floats the box to the left of its container.
	FloatLeft
	// FloatRight floats the box to the right of its container.
	FloatRight
)

const (
	// Sans is the default sans-serif family.
	Sans FontFamily = iota
	// Serif is the serif family.
	Serif
	// Mono is the monospace family.
	Mono
)

const (
	// GridFlowRow fills each row before moving to the next (initial).
	GridFlowRow GridFlow = iota
	// GridFlowColumn fills each column before moving to the next.
	GridFlowColumn
)

const (
	// JustifyStart packs items at the main-start edge (initial value).
	JustifyStart Justify = iota
	// JustifyEnd packs items at the main-end edge.
	JustifyEnd
	// JustifyCenter centres items on the main axis.
	JustifyCenter
	// JustifySpaceBetween distributes free space between items.
	JustifySpaceBetween
	// JustifySpaceAround distributes free space around items.
	JustifySpaceAround
	// JustifySpaceEvenly distributes free space evenly incl. the ends.
	JustifySpaceEvenly
)

const (
	// ListOutside places the marker in the indent to the left of the content box
	// (the initial value).
	ListOutside ListStylePosition = iota
	// ListInside places the marker inside the content box, before the first line.
	ListInside
)

const (
	// ListDisc is a filled circle (the initial value / <ul> default).
	ListDisc ListStyleType = iota
	// ListCircle is a hollow (stroked) circle.
	ListCircle
	// ListSquare is a filled square.
	ListSquare
	// ListDecimal is an ascending decimal number ("1.", "2.", …) — the <ol> default.
	ListDecimal
	// ListNone paints no marker.
	ListNone
)

const (
	// OverflowVisible is the initial value: content is not clipped.
	OverflowVisible Overflow = iota
	OverflowHidden
	OverflowClip
	OverflowScroll
	OverflowAuto
)

const (
	// PositionStatic is the initial value: the box is in normal flow with no
	// top/right/bottom/left offset applied.
	PositionStatic Position = iota
	// PositionRelative keeps the box in normal flow (it still reserves space) but
	// paints it shifted by its top/left/right/bottom offset.
	PositionRelative
	// PositionAbsolute removes the box from normal flow and positions it against
	// the padding box of the nearest positioned ancestor (else the initial
	// containing block).
	PositionAbsolute
	// PositionFixed removes the box from normal flow and positions it against the
	// initial containing block (the viewport). For a full-page static render it is
	// resolved to document coordinates so it paints once at its place.
	PositionFixed
	// PositionSticky is approximated as relative for a full-page static shot.
	PositionSticky
)

const (
	// ExtentFarthestCorner is the default extent.
	ExtentFarthestCorner RadialExtent = iota
	// ExtentClosestSide sizes to the nearest edge.
	ExtentClosestSide
	// ExtentClosestCorner sizes to the nearest corner.
	ExtentClosestCorner
	// ExtentFarthestSide sizes to the farthest edge.
	ExtentFarthestSide
	// ExtentExplicit uses explicit RadiusX/RadiusY lengths.
	ExtentExplicit
)

const (
	// RadialEllipse is the default radial shape.
	RadialEllipse RadialShape = iota
	// RadialCircle forces equal radii.
	RadialCircle
)

const (
	// AlignLeft is the initial value.
	AlignLeft TextAlign = iota
	// AlignCenter centres each line.
	AlignCenter
	// AlignRight right-aligns each line.
	AlignRight
	// AlignCenterBlocks centres inline content like AlignCenter and additionally
	// centres a definite-width block/table child within its container — the legacy
	// behaviour of the <center> element and the align="center" attribute (browsers'
	// -moz-center / -webkit-center). A plain text-align:center author rule never
	// produces it, so standards-mode blocks are unaffected.
	AlignCenterBlocks
)

const (
	// TrackAuto sizes the track to its content (initial for implicit tracks).
	TrackAuto TrackKind = iota
	// TrackPx is a fixed pixel size.
	TrackPx
	// TrackPercent is a percentage of the container's content size on that axis.
	TrackPercent
	// TrackFr is a flexible fraction of the leftover space.
	TrackFr
	// TrackMinMax is a minmax(min,max) range; Min and Max are non-nil.
	TrackMinMax
)

const (
	// WSNormal collapses runs of whitespace and wraps at the block width.
	WSNormal WhiteSpace = iota
	// WSPre preserves spaces and newlines and does not wrap (as in <pre>).
	WSPre
)