css

type AlignContent uint8

type AlignItems uint8

type AlignSelf uint8

type BgImage struct {
	Kind BgImageKind
	URL  string    // raw url() argument (BgURL); resolved by the engine
	Grad *Gradient // gradient spec (BgGradient)
}

type BgImageKind uint8

type BgPosition struct {
	X, Y Length
}

type BgRepeat uint8

type BgSize struct {
	Kind BgSizeKind
	W    Length // meaningful when SizeExplicit
	H    Length // meaningful when SizeExplicit; Auto keeps aspect ratio
}

type BgSizeKind uint8

type BorderSide struct {
	Width float64
	Style BorderStyle
	Color Color
}

type BorderStyle uint8

type Borders struct{ Top, Right, Bottom, Left BorderSide }

type BoxShadow struct {
	OffsetX, OffsetY float64
	Blur, Spread     float64
	Color            Color
	Inset            bool
}

type BoxSizing uint8

type Break uint8

type BreakInside uint8

type Clear uint8

type Color struct{ R, G, B, A uint8 }

type ColorScheme uint8

type ColorStop struct {
	Color  Color
	Pos    Length
	HasPos bool
}

type ContainerCondition struct {
	// Name filters which ancestor container this condition may match against
	// ("" means: the nearest ancestor container of ANY name).
	Name string
	// Cond is the lowercased, trimmed size-feature condition text (e.g.
	// "(min-width: 400px)"), or "" for a name-only condition with no size
	// feature (matches unconditionally once a qualifying container exists).
	Cond string
}

type ContainerSize struct {
	InlineSize float64
	BlockSize  float64
}

type ContainerType uint8

type Declaration struct {
	Property  string
	Value     string
	Important bool
}

type Display uint8

type Edges struct{ Top, Right, Bottom, Left float64 }

type Filter struct {
	Kind   FilterKind
	Amount float64 // multiplier / fraction / blur sigma (px) / hue radians

	// Drop-shadow parameters (only meaningful when Kind == FilterDropShadow).
	OffsetX, OffsetY float64
	Blur             float64
	Color            Color
	UseCurrentColor  bool // resolve Color from the element's `color` at paint time
}

type FilterKind int

type FlexDirection uint8

type FlexWrap uint8

type Float uint8

type FontFace struct {
	// Family is the family name, lowercased: `font-family` inside the rule,
	// which is what a `font-family` declaration elsewhere has to name to
	// reach this face.
	Family string
	// Srcs are the `src` entries in declaration order — a consumer takes the
	// first whose Format it can decode. `local()` entries are dropped: there
	// is no system font database here to look a face up in.
	Srcs []FontSrc
	// Weight is the weight the files carry, 400 when the rule gives none. A
	// range ("font-weight: 100 900", a variable font) collapses to its first
	// value, since only a static instance can be loaded.
	Weight int
	// Italic is set for `font-style: italic` or `oblique`.
	Italic bool
}

type FontFamily struct {
	// Names are the non-generic families named, lowercased and joined with
	// commas in declaration order. Empty when the declaration named only
	// generic keywords.
	Names string
	// Generic is the bucket to use when no named family is available — the
	// generic keyword the declaration ended with, or the one implied by a
	// name the engine recognises ("helvetica" means sans).
	Generic Generic
}

type FontSrc struct {
	// URL is the url() as written — relative to the stylesheet it came from,
	// which is the caller's to resolve.
	URL string
	// Format is the format() hint, lowercased and unquoted ("truetype",
	// "woff2", "opentype", …), or empty when the rule gave none. It is a
	// HINT: a consumer that cannot decode a format should skip the entry,
	// but an entry without one may still be anything.
	Format string
}

type Generic uint8

type Gradient struct {
	Radial bool

	// Linear direction. Corner is 0 for an explicit angle (AngleDeg), else a
	// corner code 1..4 (top-right/bottom-right/bottom-left/top-left) whose angle
	// depends on the box size and is resolved in the sampler.
	AngleDeg float64
	Corner   uint8

	// Radial geometry.
	Shape            RadialShape
	Extent           RadialExtent
	RadiusX, RadiusY Length // meaningful when Extent==ExtentExplicit
	PosX, PosY       Length // centre; default 50% 50%

	Stops []ColorStop
}

type GradientGeometry struct {
	Radial         bool
	X0, Y0, X1, Y1 float64
	CX, CY, RX, RY float64
	Stops          []GradientStop
}

type GradientSampler struct {
	// contains filtered or unexported fields
}

type GradientStop struct {
	Pos   float64
	Color Color
}

type GridFlow uint8

type GridLine struct {
	Auto bool
	Span bool
	N    int
}

type ImageRendering uint8

type Justify uint8

type Length struct {
	Px        float64
	Percent   float64 // 0..1; only meaningful when IsPercent
	IsPercent bool
	Auto      bool
}

type LineHeight struct {
	Px     float64
	Factor float64 // unitless multiplier of the element's own font-size (0 = none)
	Normal bool
}

type LinkRef struct {
	Href  string // the raw href attribute value (unresolved)
	Media string // the raw media attribute value ("" when absent)
}

type ListStylePosition uint8

type ListStyleType uint8

type Media struct {
	Type  string  // Screen ("" or "screen") or Print; compared case-insensitively
	Width float64 // viewport width, CSS px
	// Scale is the device pixel ratio: device pixels per CSS px (CSSOM View
	// devicePixelRatio). 0 means 1. It is what the `resolution` media feature
	// reports (Media Queries 4 §5.1, in dppx), and a cascade run against it
	// computes every absolute length in device pixels (see scaleLengths).
	Scale float64
}

type ObjectFit uint8

type Overflow uint8

type PageRule struct {
	Selector     string
	Declarations []Declaration
}

type PageSpec struct {
	Width, Height float64
	Margin        [4]float64 // top, right, bottom, left, CSS px
	MarginSet     [4]bool
}

type Position uint8

type RadialExtent uint8

type RadialShape uint8

type Rule struct {
	Selectors    []Selector
	Declarations []Declaration

	// Container is non-nil when this rule came from (directly, or via nested
	// @media/@layer) an `@container` at-rule: its selectors only take effect
	// for a matched element when the condition holds against that element's
	// nearest qualifying ancestor container, evaluated at cascade time (see
	// container.go — this is deferred, unlike @media, because it depends on
	// per-element ancestor geometry rather than a single known viewport
	// width).
	Container *ContainerCondition
}

type Selector struct {
	// contains filtered or unexported fields
}

type Style struct {
	Display    Display
	Visibility Visibility // inherited; see the Visibility doc comment
	Color      Color
	Background Color
	FontSize   float64 // px
	FontWeight int     // 400 = normal, 700 = bold
	FontFamily FontFamily
	Italic     bool // font-style: italic|oblique (inherited)
	// Underline is set by `text-decoration`/`text-decoration-line: underline`,
	// cleared by any other explicit line value (including "none"). Real CSS
	// text-decoration-line is NOT an inherited property — instead, a line set
	// on a block/inline CONTAINER visually propagates through its descendant
	// inline boxes unless a descendant sets its own line explicitly. This
	// engine approximates that (real) propagation the same way an actually-
	// inherited property would: copied from parent to child, then
	// overwritten by an explicit declaration on the child itself — correct
	// for the overwhelming majority of real content (an <a> or a heading
	// carries `text-decoration:underline`; its own descendant <strong>/<code>
	// inherits the line via this field exactly as it should), and only wrong
	// for the rare case of a descendant deliberately opting OUT with its own
	// `text-decoration-line:none` while an ancestor's line is meant to still
	// show through — not modelled here. Only the "underline" line is tracked
	// (line-through/overline/blink are not) and text-decoration-color/style/
	// thickness are not modelled: the rendered line is always solid, in the
	// text's own current colour — deliberately narrow, matching the
	// overwhelmingly common real-world "a hyperlink is underlined" pattern
	// this was found missing for entirely: text-decoration had NO Style
	// field, no parser case and no paint code at all before this — every
	// underline on every page this engine has ever rendered was silently
	// dropped, confirmed live on developer.mozilla.org's own in-article
	// links (`:is(.content-section a):not([href^="#"])
	// {text-decoration:underline}`, present in real Chrome, absent here).
	Underline bool

	// Fill/Stroke are the SVG paint properties (inherited, like Color).
	// FillSet/StrokeSet distinguish "CSS resolved a concrete colour" from
	// "left to the SVG document's own presentation attribute" — svg.go's
	// serializeSVG is the only reader: unset changes nothing (the element's
	// own `fill`/`stroke` XML attribute, if any, survives untouched), set
	// overrides it with the CSS value. FillNone/StrokeNone models
	// `fill:none`/`stroke:none` (paint suppressed) separately, since Color{}
	// (transparent black) is also a legitimate real colour value. Confirmed
	// load-bearing live: tailwindcss.com's nav icons (search glyph, version-
	// badge chevron, logo mark) and CTA underline are coloured entirely via
	// Tailwind's `fill-*`/`stroke-*` utility classes, never an XML `fill=`
	// attribute — before this, every such icon rasterised with SVG's initial
	// fill (black), often invisible against a dark background.
	Fill       Color
	FillSet    bool
	FillNone   bool
	Stroke     Color
	StrokeSet  bool
	StrokeNone bool

	Margin    Edges
	Padding   Edges
	Border    Borders
	Width     Length // Auto by default
	MinWidth  Length // Auto (== none) by default
	MaxWidth  Length // Auto (== none) by default
	Height    Length // Auto by default
	MinHeight Length // Auto (== none) by default
	MaxHeight Length // Auto (== none) by default
	// AspectRatio is the preferred width/height ratio from `aspect-ratio:
	// <W>/<H>` (0 means "auto", i.e. unset — no ratio constrains sizing).
	// Confirmed load-bearing live (round 86): Next.js's own auto-generated
	// image-placeholder wrapper divs (tailwindcss.com's blog/changelog cover
	// images) size themselves ENTIRELY via `aspect-ratio` plus a resolved
	// width, with no explicit height at all — reserving the correct space
	// before the image itself loads, to avoid a layout shift. Only the
	// width-known/height-auto direction is resolved (see usedHeight); the
	// reverse (height known, width auto) has no confirmed real caller and is
	// not attempted.
	AspectRatio float64
	// ObjectFit controls how a replaced element's OWN content (the loaded
	// image bitmap) is scaled into its box when the two aspect ratios don't
	// match — see ObjectFit's own doc comment. Fill (the zero value) is this
	// engine's own pre-existing behaviour (stretch to exactly fill the box).
	ObjectFit     ObjectFit
	BoxSizing     BoxSizing
	TextAlign     TextAlign
	WhiteSpace    WhiteSpace
	TextTransform TextTransform
	LineHeight    LineHeight

	// LetterSpacing is `letter-spacing`'s resolved value in px (0 = `normal`,
	// the initial value), added after EVERY character of a text run
	// (including its last, matching real browsers — this is why a run's
	// measured width grows even for a single-character string). Inherited,
	// per spec. Only the line-wrapping width (layout.appendWords, the
	// confirmed real path — tailwindcss.com's own large `tracking-tighter`
	// hero heading and `tracking-widest` sidebar labels) and painting
	// (paint.drawText) apply it; the shrink-to-fit/min-content intrinsic-
	// sizing paths (preferredWidth, minContentWidth, flex/table sizing) do
	// not add it to their own measurements — a documented, narrower scope
	// than every possible consumer of Measure, matching this engine's
	// established practice of shipping the confirmed-reachable path first.
	LetterSpacing float64

	// BorderSpacingH/V are `border-spacing`'s horizontal/vertical values in
	// px (both 0 = the initial value, no gap). Inherited, per spec (one of a
	// handful of table-specific properties CSS inherits despite table
	// layout itself not otherwise being inherited). Confirmed real on
	// en.wikipedia.org's own infobox (`.infobox{border-spacing:3px}`, cells
	// styled with only a `border-bottom` — the gap this property adds
	// between rows IS the infobox's visible row-to-row breathing room, not
	// merely a cosmetic nicety). layout.table applies it unconditionally,
	// without checking `border-collapse` (not modelled at all yet, so every
	// table is implicitly always "separate", the default) — spec says
	// border-spacing has no effect under `border-collapse:collapse`, but
	// both of this engine's own confirmed real cases are unaffected by that
	// simplification: Wikipedia's infobox never sets border-collapse at all
	// (stays at the default 'separate' this engine already assumes), and
	// pkg.go.dev's own `table{border-collapse:collapse;border-spacing:0}`
	// reset sets spacing to zero anyway, so applying it unconditionally
	// there is a no-op regardless.
	BorderSpacingH, BorderSpacingV float64

	// CenterAsBlock is TextAlign == AlignCenterBlocks for every element,
	// EXCEPT it stays true for a <table> whose PARENT has TextAlign ==
	// AlignCenterBlocks even in quirks mode, where the table's OWN TextAlign
	// is separately reset to AlignLeft (see css/ua.go's quirks-mode table
	// rule) so its cells' text is correctly left-, not centre-, aligned.
	// Layout's "centre a definite-width block within its container" rule
	// (the legacy <center>/align=center effect) reads THIS field rather than
	// TextAlign directly, because real browsers keep the two questions
	// (should MY OWN text be centred vs. should I, as a block, be centred
	// within my parent) independent for exactly this one quirks-mode case —
	// confirmed against the HTML standard, whose quirks-mode reset is scoped
	// to the `table` selector alone. Every other element (including a
	// <center> with its own definite width, which must centre ITSELF using
	// its own AlignCenterBlocks default regardless of its parent) is
	// unaffected: CenterAsBlock and TextAlign==AlignCenterBlocks always
	// agree for it.
	CenterAsBlock bool

	// ImageRendering selects the scaling filter for raster images (inherited).
	// The initial value IRAuto means high-quality (bicubic); IRPixelated asks
	// for nearest-neighbour (pixel art).
	ImageRendering ImageRendering

	// ListItem marks a display:list-item box (it generates a marker). It is not
	// inherited. ListStyleType and ListStylePosition are inherited and select the
	// marker glyph and its placement.
	ListItem          bool
	ListStyleType     ListStyleType
	ListStylePosition ListStylePosition

	// BorderRadius is the corner radius applied to the border box when painting
	// the background and border. It is a single (uniform) radius: the common real
	// case (Tailwind `rounded-*`, pills, circles) sets all four corners equal.
	// Differing per-corner radii are approximated by the last-applied value
	// (documented in FIDELITY.md). A px length is used as-is; a percentage
	// resolves against the box's smaller side at paint time. Zero (the initial
	// value) means square corners.
	BorderRadius Length

	// Auto-margin flags: a margin explicitly set to `auto` centres or pushes the
	// box; distinct from a 0 margin.
	MarginLeftAuto  bool
	MarginRightAuto bool
	// MarginLeft/RightIsPercent + MarginLeft/RightPercent (0..1) record a
	// percentage margin-left/margin-right — resolved against the containing
	// block's WIDTH at layout time in resolveWidths, the one place that
	// already has cw available for exactly this purpose (mirroring how Width/
	// Height keep percentages unresolved in a Length rather than eagerly
	// computing a wrong value against an unknown containing block). Margin is
	// a plain Edges (float64), not Length, everywhere else, so this is a
	// narrower, side-channel addition rather than a wholesale type change.
	// Scoped to margin-LEFT/RIGHT only — the confirmed real need (Wikipedia's
	// own `.ambox{margin:0 10%}`, `@media(min-width:720px)`-gated, centring
	// article cleanup-notice boxes within their column) only ever needs
	// horizontal percentages; margin-top/margin-bottom percentages (also
	// resolved against the containing block's WIDTH per spec, a common CSS
	// quirk) have no confirmed real caller and are not modelled — a
	// documented scope limit, not a silent gap for the case that matters.
	MarginLeftIsPercent  bool
	MarginLeftPercent    float64
	MarginRightIsPercent bool
	MarginRightPercent   float64

	// Overflow per axis (not inherited; initial value visible). Any non-visible
	// value clips descendant painting to this box's padding box.
	OverflowX Overflow
	OverflowY Overflow

	// HasClip/ClipRect model the legacy `clip: rect(top, right, bottom, left)`
	// property — deprecated in favour of clip-path, but still a live, real-
	// world pattern: confirmed load-bearing on pkg.go.dev's own "skip to main
	// content" link (`clip:rect(0 0 0 0)`, the CSS2-era screen-reader-only
	// idiom, predating the now-common `width:1px;height:1px;overflow:hidden`
	// version this engine already honours via Overflow above — that one has
	// no effect here since this element sets no explicit small width/height,
	// only `clip`). Per spec this only applies when Position is absolute or
	// fixed, and all four edges are distances from the box's own top-left
	// BORDER edge (not the CSS shorthand's usual top/right/bottom/left box
	// edges) — `rect(0,0,0,0)` is therefore a zero-size rectangle at the
	// box's own corner, clipping it and its content to nothing while it
	// still occupies its normal layout position (unlike display:none). Only
	// the common case (all four values explicit lengths) is modelled; a
	// `clip: auto` per edge, or any other value this engine's length parsing
	// does not resolve, leaves HasClip false — clip:rect() with a genuinely
	// variable edge is rare in practice (the sr-only idiom always hard-codes
	// all four to 0), so this is not a real-world loss.
	HasClip  bool
	ClipRect Edges // Top, Right, Bottom, Left offsets from the box's own corner

	// Positioning that affects normal flow.
	Float Float
	Clear Clear

	// CSS position and the box-offset properties. Top/Right/Bottom/Left are Auto
	// by default (the initial value of each offset). ZIndex is meaningful only
	// when ZIndexAuto is false; the initial value is auto (paint in tree order).
	Position   Position
	Top        Length // Auto by default
	Right      Length // Auto by default
	Bottom     Length // Auto by default
	Left       Length // Auto by default
	ZIndex     int
	ZIndexAuto bool // true == "auto" (the initial value)

	// TranslateX/TranslateY and RotateDeg are the TWO subsets of the
	// `transform` property this engine understands, EACH ONLY on its own —
	// a value naming any other function (scale, skew, matrix, 3D), or
	// mixing more than one of these two together (`translate(...)
	// rotate(...)` on the same element), is unsupported and leaves every
	// transform field at zero, same as before either was understood at all
	// — see FIDELITY.md's Known gaps. Translate (see parseTransformTranslate
	// in parse.go) is a paint-time offset applied like a relative position
	// shift, not a layout input; the initial/reset value (Length's Go zero
	// value) is exactly "no translation", so unlike most other reset-not-
	// inherited fields there is nothing to list explicitly in inheritFrom.
	//
	// RotateDeg (`rotate()`/`rotatez()`, see parseTransformRotate) is the
	// angle in degrees to rotate the element's own border-box rectangle by,
	// clockwise for a positive value — CSS's own convention. go-images'
	// own Rotate is the OPPOSITE sign convention (its own doc comment:
	// "rotated by angle degrees counter-clockwise", matching scikit-image),
	// so paint.paintRotated negates the angle it passes in; get this backward
	// and a page with any asymmetric rotated content (readable text/icons,
	// not just tailwindcss.com's own near-symmetric card shapes) would spin
	// the visibly wrong way, caught by checking the sign convention against
	// the dependency's own doc comment before writing any code, not
	// discovered after the fact. Unlike translate, this DOES need real
	// coordinate-transform machinery: paint.paintRotated renders the box's
	// own border-box rectangle to an offscreen buffer and rotates the
	// PIXELS with go-images' Rotate (bilinear, growing the buffer to fit the
	// rotated corners), rather than transforming any drawing coordinates —
	// so it does not compose with `filter`/opacity/`mask-image` on the same
	// element (paintBox only takes this path when none of those apply): no
	// confirmed real trigger combines rotate with any of them, and doing so
	// correctly needs the two offscreen-buffer mechanisms unified, a larger
	// change than this one evidenced case justifies. transform-origin is
	// not modelled either — always the default 50% 50% (the box's own
	// centre), which is what every confirmed trigger already uses.
	//
	// This field backs BOTH `transform: rotate()`/`rotateZ()` (parsed by
	// parseTransformRotate) and the newer, independent CSS Transforms Level
	// 2 `rotate` property (parsed directly in `case "rotate"`, a bare
	// angle with no function-call syntax at all — `rotate:90deg`,
	// `rotate:none`) — two different spellings of the identical visual
	// capability. Confirmed live (round 145): modern Tailwind (v4) compiles
	// its `rotate-*` utilities to the STANDALONE property, not the
	// `transform` function — `.rotate-(--angle){rotate:var(--angle)}` on
	// tailwindcss.com's own "P3 colors" section, a grid of diagonal colour-
	// name labels ("red", "orange", …) tilted -45°, confirmed directly from
	// its compiled CSS bundle rather than assumed from the class name alone
	// (an assumption that would have targeted the wrong property entirely
	// and shipped a fix that silently did nothing on the one confirmed real
	// page). `transform: rotate()` itself has no independently confirmed
	// trigger of its own in this session's corpus — kept anyway since it is
	// the same underlying, now-evidenced capability under CSS's older
	// syntax, not a distinct speculative addition.
	//
	// Both spellings write the SAME field and so cannot compose with each
	// other, or with `transform: translate()`/the (unimplemented) standalone
	// `translate`/`scale` properties, correctly per spec — whichever this
	// engine's cascade applies LAST simply overwrites the field. No
	// confirmed trigger combines any of these, so this is disclosed rather
	// than engineered around.
	TranslateX Length
	TranslateY Length
	RotateDeg  float64

	// AppearanceNone is `appearance: none` (or `-webkit-appearance: none`),
	// which suppresses a form control's native OS chrome so the author's own
	// background/background-image/border/border-radius paint instead. Not
	// inherited; the zero value (false) is the initial `auto`, matching every
	// other form control this engine already renders with its own hardcoded
	// UA-default look (see paintFormControl/paintCheckboxLike). Confirmed
	// load-bearing live: developer.mozilla.org's own `<mdn-switch>` custom
	// toggle-switch component styles a real `<input type=checkbox>` with
	// exactly `appearance:none;background-color:...;background-image:radial-
	// gradient(...);border-radius:9999px` UNCONDITIONALLY (not gated behind
	// `:checked` — only the knob's position/colour REFINES on `:checked`), so
	// a checkbox that sets this must stop taking this engine's own generic
	// checkbox square and instead paint like any other styled box. Only the
	// bare `none`/`auto` keywords are modelled; the CSS Basic UI vendor-
	// specific appearance keywords (`textfield`, `menulist-button`, etc.) have
	// no confirmed trigger and are left unsupported (equivalent to `auto`).
	AppearanceNone bool

	// Flex container properties (meaningful when Display == DisplayFlex).
	FlexDirection  FlexDirection
	FlexWrap       FlexWrap
	JustifyContent Justify
	AlignItems     AlignItems
	AlignContent   AlignContent

	// Gaps between flex lines/items and between grid tracks. RowGap is the
	// cross-line / block-axis gap; ColumnGap is the main-axis / inline-axis gap.
	RowGap    Length
	ColumnGap Length

	// Flex/grid item properties (meaningful for a child of a flex/grid container).
	FlexGrow   float64
	FlexShrink float64
	FlexBasis  Length // Auto == "auto" (use the item's width/content)
	Order      int    // reorders items within a line (ascending)
	AlignSelf  AlignSelf

	// Grid container properties (meaningful when Display == DisplayGrid).
	GridTemplateColumns []TrackSize
	GridTemplateRows    []TrackSize
	GridAutoRows        TrackSize
	GridAutoColumns     TrackSize
	GridAutoFlow        GridFlow
	// GridAutoFlowDense is the "dense" keyword on grid-auto-flow: the
	// auto-placement cursor restarts from the very first grid cell before
	// placing EACH item (potentially reordering items visually, out of DOM
	// order, to backfill an earlier gap a bigger item left open) instead of
	// only ever advancing forward from wherever the previous item landed
	// (the default, "sparse", packing). See layout.placeItems.
	GridAutoFlowDense bool
	GridTemplateAreas [][]string // row-major grid of area names ("" == empty)
	JustifyItems      AlignItems // inline-axis alignment of items in their cell

	// Grid item placement (meaningful for a child of a grid container).
	GridColumnStart GridLine
	GridColumnEnd   GridLine
	GridRowStart    GridLine
	GridRowEnd      GridLine
	GridArea        string // named area this item is placed into (via grid-area)
	JustifySelf     AlignSelf

	// CustomProps holds the element's resolved CSS custom properties (--name ->
	// raw value). It is inherited from the parent and overridden by matched
	// rules; var() references consult it at computed-value time. Nil until an
	// element (or an ancestor) defines a custom property.
	CustomProps map[string]string

	// ColorScheme is the inherited `color-scheme` (CSS Color Adjust 1 §2.2);
	// its UsedDark picks light-dark()'s branch. Zero value: `normal`.
	ColorScheme ColorScheme

	// Background image layers (gradients and url() bitmaps) and their paint
	// parameters. Each list is indexed per layer (first-listed paints on top);
	// a shorter size/position/repeat list repeats its last value. All nil == no
	// background image (only the solid Background colour paints).
	BackgroundImages   []BgImage
	BackgroundSize     []BgSize
	BackgroundPosition []BgPosition
	BackgroundRepeat   []BgRepeat

	// MaskImage is the resolved absolute URL of a `mask-image`/
	// `-webkit-mask-image: url(...)` — empty means no mask (the common case).
	// Unlike background-image, a mask does not paint its own pixels: it is an
	// alpha stencil applied over everything the ELEMENT ITSELF paints (colour,
	// background, borders, text, children), stretched to fill the element's
	// border box (this engine's one deliberate simplification — the real
	// mask-size/mask-position/mask-repeat grammar is not modelled, matching
	// how far this engine narrowly scoped `transform: translate()`). Confirmed
	// load-bearing live: modern MediaWiki (Wikipedia's Vector-2022 skin, and
	// most of its UI icon systems generally) renders EVERY toolbar icon —
	// hamburger menu, search, language switcher — as an empty, solid-coloured
	// <span> cut into shape by exactly this mechanism, so the icon recolours
	// for dark mode without needing a second image asset. A gradient or other
	// non-url() mask value is not modelled and leaves this empty.
	MaskImage string

	// BoxShadows are the element's box-shadow layers (first-listed paints on top).
	BoxShadows []BoxShadow

	// Opacity is the element's group opacity in [0,1]; HasOpacity distinguishes a
	// genuine opacity from the zero value (an unset Style is fully opaque).
	Opacity    float64
	HasOpacity bool

	// Filters is the element's `filter` function chain, applied in order to the
	// element's rendered output (its box plus subtree) as a group. Nil == no
	// filter. Not inherited (`filter` is a non-inherited property).
	Filters []Filter
	// BackdropFilters is `backdrop-filter`'s function chain (same grammar and
	// Filter type as Filters — see parseFilterList) applied to whatever has
	// already been painted BEHIND this box's own border-box, before the box's
	// own background/border/content paint on top — the standard "frosted
	// glass" idiom (a translucent bar over blurred page content). Confirmed
	// live on react.dev's own sticky nav bar and code-sandbox title bars
	// (`backdrop-filter:blur(16px) saturate(2)` via Tailwind's `backdrop-blur-
	// lg backdrop-saturate-200`, composed through CSS custom properties). Not
	// inherited, matching Filters.
	BackdropFilters []Filter

	// ContainerType and ContainerName are `container-type`/`container-name`
	// (or the `container` shorthand): whether this element establishes a
	// query container for descendant `@container` rules, and under what
	// name. Neither is inherited; the initial value is ContainerNormal / "".
	ContainerType ContainerType
	ContainerName string

	// Fragmentation (CSS Fragmentation Level 3), as far as paged media is
	// concerned — this engine's own screen layout ignores all five; a
	// paginating consumer (the paginate package, go-pdfkit/html2pdf) reads
	// them. break-before / break-after / break-inside are NOT inherited
	// (initial auto); the legacy page-break-before/after/inside properties
	// are aliases (always → page). orphans / widows ARE inherited (initial
	// 2; only a positive integer is a valid value, anything else leaves the
	// declaration ignored).
	BreakBefore, BreakAfter Break
	BreakInside             BreakInside
	Orphans, Widows         int

	// Multi-column layout (CSS Multi-column Layout Level 1): ColumnCount (0 =
	// not set) and ColumnWidth (Auto = not set) are NOT inherited — a plain
	// block box unless one or the other is set, exactly like `columns`'s own
	// two longhands. The column gap itself is the SAME `column-gap`/`gap`
	// property flex/grid already use (ColumnGap, declared with RowGap
	// above) — real CSS defines it once, in the Box Alignment module, for
	// all three layout modes, not a per-mode property. Its shared "unset"
	// default is Length{Auto:true} (see initialStyle/inheritFrom), which
	// flex/grid's own gapLen/gapPxCSS already treat identically to an
	// explicit 0 — safe to give the field this default without touching
	// their behaviour at all. Multi-column layout alone resolves Auto
	// differently: to 1em (see layoutMultiCol), matching every browser's
	// implementation of a value the spec itself only describes as "a
	// reasonable value comparable to the width of a typical typeface's
	// space character" — unlike flex/grid, where `normal` is defined to
	// compute to a plain 0.
	//
	// Confirmed live (round 143/144): pkg.go.dev's own `.UnitFiles-fileList{
	// columns:12.5rem 5;...}` — its package-documentation "Source Files"
	// list, real Chrome laying ~29 short filenames out in up to 5 narrow
	// columns instead of one long single column.
	//
	// What layout.layoutMultiCol actually models, deliberately narrower than
	// the full spec, is exactly what that one confirmed trigger needs: N
	// columns of even width, each in-flow ELEMENT child of the container
	// (never a bare text node — no confirmed trigger mixes one into a
	// columns container) placed as a single ATOMIC unit into whichever
	// column a simple cumulative-height greedy pass assigns it to, never
	// split across two columns even when a single child is themselves taller
	// than a whole column (the same "atomic child, no fragmentation"
	// simplification this engine already applies to a replaced element or a
	// table row elsewhere). NOT modelled: column-span (spec keyword `all`,
	// letting one child cross every column — no confirmed trigger),
	// column-rule (the vertical divider line between columns — pure
	// decoration, not modelled since the plain column gap alone is already
	// the confirmed visual difference from a single column), TRUE column
	// balancing (the real spec's iterative algorithm that minimises the
	// tallest column's own height while respecting break-inside/break-before
	// avoidance — this engine's single greedy pass, target = total÷count,
	// approximates it closely for a roughly-uniform list like the confirmed
	// trigger, but can leave a visibly taller last column for adversarial,
	// very unevenly-sized content), and fragmenting a SINGLE child's own
	// internal content (its own child elements, or its own wrapped text
	// lines) across two columns — a browser's real balancing can split one
	// long paragraph's lines between columns; this engine cannot, matching
	// its own "atomic child" scope decision above.
	ColumnCount int
	ColumnWidth Length

	// TabSize (CSS Text Module Level 3) is INHERITED, initial 8 — a preserved
	// tab (white-space:pre/pre-wrap) advances to the next multiple of this
	// many space-widths, counted as columns from the line's own start (see
	// layout's own expandTabs). Confirmed live (round 91): pkg.go.dev's own
	// `pre,textarea.code{tab-size:4}` on its real, tab-indented Go source
	// samples — this engine's tab expansion already existed but read a
	// hardcoded 8 regardless of this property, over-indenting by 2x. Only a
	// bare, non-negative `<number>` is parsed; the sibling `<length>` form is
	// spec-flagged "at risk" (may be dropped) and has no confirmed real use
	// here, so an unparseable/negative value leaves the inherited value in
	// place rather than resetting to some sentinel (0 is itself a valid,
	// meaningful value: "don't render tabs").
	TabSize int

	// TextWrapBalance (CSS Text Module Level 4, `text-wrap`/`text-wrap-style`)
	// is INHERITED, initial false ("auto", ordinary greedy wrapping) — `true`
	// requests the `balance` value: redistribute a SHORT block's own line
	// breaks so each line's leftover space is more even (a real browser's own
	// algorithm is UA-defined; layout's own balanceLines approximates it by
	// finding the narrowest width that still wraps to the SAME line count a
	// plain greedy wrap already produces, then re-breaking at that width —
	// the spec's own explicit invariant: balancing must never change the line
	// count for 5 lines or fewer, and a UA "may" give up and fall back to
	// `auto` past 10). Confirmed live (round 93): tailwindcss.com's own hero
	// `<h1 class="... text-balance ...">` heading. Only `balance` itself is
	// modelled — `pretty`/`stable`/`avoid-short-last-line` have no confirmed
	// real use in this engine's own corpus and fall back to ordinary
	// wrapping, same as the property's own initial `auto`.
	TextWrapBalance bool

	// TextWrapNowrap (CSS Text 4 `text-wrap`/`text-wrap-mode`) is INHERITED,
	// initial false ("wrap") — `true` requests `nowrap`: per spec, "lines
	// only break at forced line breaks; content that does not fit overflows"
	// — exactly this engine's EXISTING white-space:nowrap wrapping behaviour
	// (see layout.layoutInline's own `nowrap` parameter), but WITHOUT
	// white-space's OTHER effect of collapsing runs of whitespace: the spec
	// is explicit that text-wrap-mode affects line-breaking opportunities
	// only, never whitespace collapsing/preservation. Confirmed live (round
	// 93, flagged then as a follow-up rather than folded into that round's
	// own `balance` fix): tailwindcss.com's own `.text-nowrap{text-wrap:
	// nowrap}` on its code-toolbar filename labels.
	TextWrapNowrap bool

	// WordBreakAll is `word-break: break-all`, INHERITED, initial false. Per
	// spec it makes any character boundary a break opportunity for a line
	// that would otherwise overflow — this engine models only the ONE
	// visible effect that has a confirmed real-world trigger: a single
	// unbreakable "word" (one InlineItem — see appendWords) WIDER than the
	// whole line gets split at a rune boundary instead of overflowing its
	// container (layoutInline's splitOverlongWord). The stronger, more
	// aggressive part of the real spec — breaking mid-word EAGERLY even when
	// the word would otherwise have fit on its own line, purely for more
	// even line lengths — is not modelled: no corpus page's own confirmed
	// trigger (see OverflowWrapAnywhere below) needs it, and it would also
	// change ordinary greedy-wrap line counts for text that already fits,
	// a much larger blast radius for an unevidenced refinement. `keep-all`
	// (suppress even CJK's own default inter-character breaks) is not
	// modelled either — this engine does not implement CJK line-breaking in
	// the first place, so there is nothing for it to suppress.
	//
	// See the Style method BreaksOverlongWords, which OR-combines this with
	// OverflowWrapAnywhere: the two properties are independent (either one
	// requests the same one effect this engine models), so they are kept as
	// separate fields rather than one shared boolean — collapsing them at
	// parse time would let an unrelated `word-break: normal` on a LATER
	// declaration silently cancel an EARLIER `overflow-wrap: break-word`'s
	// own effect, which real CSS's cascade would not do (they are different
	// properties; each keeps its own computed value independently).
	WordBreakAll bool

	// OverflowWrapAnywhere is `overflow-wrap`/`word-wrap: break-word` (the
	// unprefixed and legacy-alias property names for the same property) or
	// `anywhere`, and also the deprecated `word-break: break-word` value
	// (per spec, an alias for `word-break: normal; overflow-wrap: anywhere`,
	// so it sets THIS field, not WordBreakAll). INHERITED, initial false.
	// The spec distinguishes `break-word` (breaks only as an overflow-
	// avoidance last resort, like this engine's one modelled effect) from
	// `anywhere` (also affects min-/max-content intrinsic-size calculations,
	// letting a container shrink narrower than its longest unbreakable
	// word) — that intrinsic-sizing distinction is not modelled, since
	// every confirmed real trigger (see BreaksOverlongWords) only needs the
	// line-breaking effect the two values already share.
	//
	// Confirmed live: developer.mozilla.org sets `overflow-wrap:break-word`
	// on `html` itself (inherited page-wide); pkg.go.dev's own package-doc
	// pages set `word-break:break-all` on `.UnitFiles-fileList` (a `<ul>` of
	// long bare filenames with no natural break points) and `word-break:
	// break-word` on `.UnitDirectories td` (a subdirectory-listing table
	// cell); news.ycombinator.com sets `word-break:break-word` on `.title a`
	// (every story headline link, which occasionally IS a long bare URL).
	// Before this, a real production page like any of these would overflow
	// its own container with unbroken text exactly where a real browser
	// wraps mid-word instead.
	OverflowWrapAnywhere bool

	// LineClamp is `-webkit-line-clamp`/`line-clamp`'s value: the maximum
	// number of lines an element's inline content renders before being cut
	// off, 0 meaning "not set" (unclamped — the CSS `none` keyword resolves
	// to this too). Not inherited, matching `overflow` and `display`, the two
	// properties `-webkit-line-clamp` is always paired with in real CSS (the
	// "-webkit-box" multi-line-truncation idiom: `display:-webkit-box;
	// -webkit-box-orient:vertical;-webkit-line-clamp:N;overflow:hidden`) —
	// this engine models the actual clamping this idiom exists for without
	// requiring the paired display/overflow declarations to also be present,
	// since the confirmed real-world callers (see layout's own consumer)
	// always clamp regardless of exactly which vendor ceremony wraps it.
	// Truncating to N lines by DROPPING the rest is modelled; the trailing
	// ellipsis glyph real browsers additionally insert on the last kept line
	// is not — a documented, narrower scope than the full feature, matching
	// the confirmed need (tailwindcss.com's own `line-clamp-2` on a `<p>`,
	// which primarily needs the container to stop growing past two lines,
	// not the exact glyph at the cut point).
	LineClamp int

	// VerticalAlign is `vertical-align`'s keyword value; VAlignBaseline (the
	// zero value) is the default. Only VAlignTextBottom currently shifts an
	// inline-level replaced element's position in its line — the sole
	// confirmed real need (github.com's own octicon SVG icons, styled
	// `vertical-align:text-bottom` throughout its Primer design system to
	// align an icon's bottom edge with the surrounding text's font, not its
	// baseline). The other keyword values are recognised here (so they don't
	// silently fall through to some unrelated case) but not yet given
	// positional effect — a narrower scope than the full property, matching
	// this engine's established practice of shipping the confirmed-reachable
	// value first. Not inherited, per spec.
	VerticalAlign VerticalAlign

	// TextOverflowEllipsis is `text-overflow:ellipsis` (vs. the default
	// `clip`, false). It only has a visible effect combined with
	// `white-space:nowrap` and a clipping `overflow-x` — the real, confirmed
	// idiom (Tailwind's own `.truncate` utility: `overflow:hidden;
	// text-overflow:ellipsis;white-space:nowrap`, found live on
	// tailwindcss.com's own team-member role labels). `overflow:hidden`
	// alone already clips the raw overflowing text with no code here at
	// all; this field's only job is swapping that raw clip for a "…"-
	// terminated one. Scoped to a line made ENTIRELY of plain text items (no
	// nested inline element, image or forced break) — the confirmed real
	// shape — a line mixing in any of those is left as plain overflow, a
	// documented narrower scope than the full property (which also allows a
	// custom replacement string, not modelled). Not inherited, per spec.
	TextOverflowEllipsis bool
}

type StyleMap map[*dom.Node]*Style

type TextAlign uint8

type TextTransform uint8

type TrackKind uint8

type TrackSize struct {
	Kind     TrackKind
	Px       float64    // TrackPx
	Percent  float64    // TrackPercent (0..1)
	Fr       float64    // TrackFr
	Min, Max *TrackSize // TrackMinMax bounds
}

type VerticalAlign uint8

type Visibility uint8

type WhiteSpace uint8