spec:css2; type:property;

text:vertical-align

text:max-width

text:max-height

text:min-width

text:min-height

spec:css-cascade-3; type:value; text:initial

spec:css-display-3; type:property; text:display

spec:css-flexbox-1; type:dfn;

text:flex line

spec:css-grid-1; type:dfn;

text:collapsed gutter

spec:css-inline-3; type:property;

text:dominant-baseline

text:alignment-baseline

spec:css-multicol-1; type:dfn;

text:multi-column container

text:column box

spec:css-overflow-3; type:dfn; text:scroll container

spec:css-position-3; type:property; text:left

spec:css-writing-modes-3; type:dfn;

text:dominant baseline

text:start

text:end

spec:selectors-3; type:dfn; text:first formatted line

spec:css2; type:dfn; text:line box

.issue th:first-child { text-align: left !important; }

[rowspan] > img { float: right; }

[rowspan] { vertical-align: middle; }

table small { display: block; }

table.align-details { width: 100%; }

.align-details th {

font: inherit;

font-style: italic;

white-space: nowrap; width: 1em;

vertical-align: baseline; }

.align-details td { vertical-align: baseline; }

CSS Levels 1 and 2 allowed for the alignment of text via 'text-align'

and the alignment of blocks by balancing ''margin/auto'' margins.

However, except in table cells,

vertical alignment was not possible.

As CSS adds further capabilities,

the ability to align boxes in various dimensions becomes more critical.

This module attempts to create a cohesive and common box alignment model to share among all of CSS.

Note: The alignment of text and inline-level content is defined in [[CSS-TEXT-3]] and [[CSS-INLINE-3]].

Note: This specification is not intended to change any of the behavior

defined in <a href="https://www.w3.org/TR/CSS2/">CSS2.1</a>

when the properties defined here are set to their initial values.

If implementors or anyone else notices a discrepancy,

please report this to the CSSWG as an error.

<em>This section (above) is not normative.</em>

This module adds some new alignment capabilities

to the block layout model described in [[!CSS2]] <a href="https://www.w3.org/TR/CSS2/visuren.html">chapters 9</a>

and <a href="https://www.w3.org/TR/CSS2/visudet.html">10</a>,

<a href="#justify-block">redefines how overconstrained block-level box margins are resolved</a>,

and defines the interaction of these new alignment properties

with the alignment of table cell content using 'vertical-align',

as defined in [[!CSS2]] <a href="https://www.w3.org/TR/CSS2/tables.html#height-layout">chapter 17</a>.

The interaction of these properties with

Grid Layout [[!CSS-GRID-1]]

and Flexible Box Layout [[!CSS-FLEXBOX-1]]

is defined in their respective modules.

The property definitions here supersede those in [[!CSS-FLEXBOX-1]]

(which have a smaller, earlier subset of permissible values).

No properties in this module apply to the <code>::first-line</code>

or <code>::first-letter</code> pseudo-elements.

This specification follows the <a href="https://www.w3.org/TR/CSS2/about.html#property-defs">CSS property definition conventions</a> from [[!CSS2]]

using the <a href="https://www.w3.org/TR/css-values-3/#value-defs">value definition syntax</a> from [[!CSS-VALUES-3]].

Value types not defined in this specification are defined in CSS Values &amp; Units [[!CSS-VALUES-3]].

Combination with other CSS modules may expand the definitions of these value types.

In addition to the property-specific values listed in their definitions,

all properties defined in this specification

also accept the <a>CSS-wide keywords</a> as their property value.

For readability they have not been repeated explicitly.

Since it is expected that support for the features in this module

will be deployed in stages corresponding to the various layout models affected,

it is hereby clarified that

the <a href="https://www.w3.org/TR/CSS/#partial">rules for partial implementations</a>

that require treating as invalid any unsupported feature

apply to any alignment keyword

which is not supported across all layout modules to which it applies

for layout models in which the implementation supports the property in general.

For example,

if an implementation supports 'align-self' in [[CSS-GRID-1]] and [[CSS-FLEXBOX-1]],

then it must treat ''align-content/start'' as invalid

unless it is supported in both grid and flex containers.

However if that same implementation does not support 'align-self' for block-level elements at all,

then a lack of implementation of ''align-self: start''

does not trigger this requirement to treat it as invalid.

The <dfn export>box alignment properties</dfn> in CSS are a set of 6 properties

that control alignment of boxes within other boxes.

They can be described along two axises:

<ul>

<li>which dimension they apply to ([=main axis|main=]/[=inline axis|inline=] vs. [=cross axis|cross=]/[=block axis|block=]), and

<li>whether they control the position of the box within its parent, or the box's content within itself.

</ul>

Note: This specification uses the terms “justify” and “align” to distinguish

between alignment in the main/inline and cross/block dimensions, respectively.

The choice is somewhat arbitrary, but having the two terms allows for

a consistent naming scheme that works across all of CSS's layout models

(including [[css-flexbox-1#box-model]])

The following table summarizes the <a>box alignment properties</a>

and the display types they can apply to.

<table class=data>

<colgroup span=1></colgroup>

<colgroup span=2></colgroup>

<colgroup span=1></colgroup>

<thead>

<tr>

<th>Common

<th>Axis

<th>Aligns

<th>Applies to

<tbody>

<tr>

<th>'justify-content'

<td>main/inline

<td rowspan=2>

<img src="images/content-example.svg" width=106 height=106 alt="">

content within element

<small>(effectively adjusts padding)</small>

<td rowspan=2>[=block containers=], <a>flex containers</a>, and <a>grid containers</a>

<tr>

<th>'align-content'

<td>cross/block

<tbody>

<tr>

<th>'justify-self'

<td>inline

<td rowspan=2>

<img src="images/self-example.svg" width=106 height=106 alt="">

element within parent

<small>(effectively adjusts margins)</small>

<td>block-level boxes, absolutely-positioned boxes, and <a>grid items</a>

<tr>

<th>'align-self'

<td>cross/block

<td>absolutely-positioned boxes, <a>flex items</a>, and <a>grid items</a>

<tbody>

<tr>

<th>'justify-items'

<td>inline

<td rowspan=2>

<img src="images/items-example.svg" width=106 height=106 alt="">

items inside box

<small>(controls child items&rsquo; ''align/justify-self: auto'')</small>

<td>[=block containers=] and <a>grid containers</a>

<tr>

<th>'align-items'

<td>cross/block

<td><a>flex containers</a> and <a>grid containers</a>

</table>

Note: The '*-items' properties don't affect the element itself.

When set on a container,

they specify the interpretation of any ''*-self: auto'' used on children of the container element.

Since this module defines alignment properties for all layout modes in CSS,

some abstract terminology is introduced:

<dl>

<dt><dfn export>alignment subject</dfn>

<dd>

The <a>alignment subject</a> is the thing or things being aligned by the property.

For 'justify-self' and 'align-self',

the <a>alignment subject</a> is the margin box of the box the property is set on,

and assumes the <a>writing mode</a> of that box.

For 'justify-content' and 'align-content',

the <a>alignment subject</a> is defined by the layout mode

and refers to some aspect of its contents;

it also assumes the <a>writing mode</a> of the box the property is set on.

<dt><dfn export>alignment container</dfn>

<dd>

The <a>alignment container</a> is the rectangle that the <a>alignment subject</a> is aligned within.

This is defined by the layout mode,

but is usually the <a>alignment subject</a>’s containing block,

and assumes the [=writing mode=] of the box establishing the containing block.

<dt><dfn export>fallback alignment</dfn>

<dd>

Some alignments can only be fulfilled in certain situations

or are limited in how much space they can consume;

for example, ''space-between'' can only operate when there is more than one <a>alignment subject</a>,

and baseline alignment, once fulfilled, might not be enough to absorb all the excess space.

In these cases a fallback alignment takes effect

(as defined below)

to fully consume the excess space.

</dl>

All of the alignment properties use a common set of keyword values,

which are defined in this section.

Keywords fall into three categories:

<dl>

<dt><a href="#positional-values">positional alignment</a>

<dd>These keywords define alignment as an absolute position within the <a>alignment container</a>.

<dt><a href="#baseline-values">baseline alignment</a>

<dd>These keywords define alignment as a relationship

among the baselines of multiple [=alignment subjects=] within an <a>alignment context</a>.

<dt><a href="#distribution-values">distributed alignment</a>

<dd>These keywords define alignment as a distribution of space among <a>alignment subjects</a>.

</dl>

The <dfn>positional alignment</dfn> keywords specify a position for an <a>alignment subject</a>

with respect to its <a>alignment container</a>.

Values have the following meanings:

<dl dfn-type="value">

<dt><dfn for="<self-position>, <content-position>, justify-self, align-self, justify-content, align-content">center</dfn> <small>([[#self-alignment|self]], [[#content-distribution|content]])</small>

<dd>Centers the <a>alignment subject</a> within its <a>alignment container</a>.

<dt><dfn for="<self-position>, <content-position>, justify-self, align-self, justify-content, align-content">start</dfn> <small>([[#self-alignment|self]], [[#content-distribution|content]])</small>

<dd>Aligns the <a>alignment subject</a> to be flush with the <a>alignment container</a>’s start edge in the appropriate axis.

<dt><dfn for="<self-position>, <content-position>, justify-self, align-self, justify-content, align-content">end</dfn> <small>([[#self-alignment|self]], [[#content-distribution|content]])</small>

<dd>Aligns the <a>alignment subject</a> to be flush with the <a>alignment container</a>’s end edge in the appropriate axis.

<dt><dfn for="<self-position>, justify-self, align-self">self-start</dfn> <small>([[#self-alignment|self]])</small>

<dd>Aligns the <a>alignment subject</a> to be flush with the edge of the <a>alignment container</a>

corresponding to the <a>alignment subject</a>’s start side in the appropriate axis.

<dt><dfn for="<self-position>, justify-self, align-self">self-end</dfn> <small>([[#self-alignment|self]])</small>

<dd>Aligns the <a>alignment subject</a> to be flush with the edge of the <a>alignment container</a>

corresponding to the <a>alignment subject</a>’s end side in the appropriate axis.

<dt><dfn for="<self-position>, <content-position>, justify-self, align-self, justify-content, align-content">flex-start</dfn> <small>([[#self-alignment|self]], [[#content-distribution|content]])</small>

<dd><strong>Only used in flex layout.</strong> [[!CSS-FLEXBOX-1]]

Aligns the <a>alignment subject</a> to be flush with the edge of the <a>alignment container</a>

corresponding to the <a>flex container</a>’s main-start or cross-start side, as appropriate.

When used outside of a <a>flex formatting context</a>, this value behaves as ''start''.

That is, on boxes that are not <a>flex items</a>

(or pretending to be <a>flex items</a>,

such as when determining the [=static position=] of an absolutely-positioned box

that is a child of a <a>flex container</a>),

this value behaves as ''start'' when used in the <a>self-alignment properties</a>,

and on boxes that are not <a>flex containers</a>,

this value behaves as ''start'' when used in the <a>content-distribution properties</a>.

<dt><dfn for="<self-position>, <content-position>, justify-self, align-self, justify-content, align-content">flex-end</dfn> <small>([[#self-alignment|self]], [[#content-distribution|content]])</small>

<dd><strong>Only used in flex layout.</strong>

Aligns the <a>alignment subject</a> to be flush with the edge of the <a>alignment container</a>

corresponding to the <a>flex container</a>’s main-end or cross-end side, as appropriate.

When used outside of a <a>flex formatting context</a>, this value behaves as ''end''.

That is, on boxes that are not <a>flex items</a>

(or pretending to be <a>flex items</a>,

such as when determining the [=static position=] of an absolutely-positioned box

that is a child of a <a>flex container</a>),

this value behaves as ''end'' when used in the <a>self-alignment properties</a>,

and on boxes that are not <a>flex containers</a>,

this value behaves as ''end'' when used in the <a>content-distribution properties</a>.

<dt><dfn for="justify-content, justify-self, justify-items">left</dfn> <small>(only 'justify-*')</small>

<dd>Aligns the <a>alignment subject</a> to be flush with

the <a>alignment container</a>’s <a href="https://www.w3.org/TR/css3-writing-modes/#line-left">line-left</a>

or <a>physical left</a> edge,

whichever is in the appropriate axis.

If the property's axis is not parallel with either left↔right axis,

this value behaves as ''start''.

<span class=note>Currently, the only case where the property's axis

is not parallel with either left↔right axis

is in a column flexbox.</span>

<dt><dfn for="justify-content, justify-self, justify-items">right</dfn> <small>(only 'justify-*')</small>

<dd>Aligns the <a>alignment subject</a> to be flush with

the <a>alignment container</a>’s <a href="https://www.w3.org/TR/css3-writing-modes/#line-right">line-right</a>

or <a>physical right</a> edge,

whichever is in the appropriate axis.

If the property's axis is not parallel with either left↔right axis,

this value behaves as ''start''.

<span class=note>Currently, the only case where the property's axis

is not parallel with either left↔right axis

is in a column flexbox.</span>

</dl>

Two grammar terms are used to denote certain subsets of these values:

<dl>

<dt><<self-position>>

<dd>

This set is used by 'justify-self' and 'align-self'

to align the box within its <a>alignment container</a>,

and also by 'justify-items' and 'align-items'

(to specify default values for 'justify-self' and 'align-self').

<pre class='prod'>

<dt><<content-position>>

<dd>

This set is used by 'justify-content' and 'align-content'

to align the box's contents within itself.

<pre class='prod'>

</dl>

Note: ''left'' and ''right'' are excluded from <<self-position>> and <<content-position>>,

despite being valid [=positional alignment=] values for 'justify-content'/'justify-self'/'justify-items',

because they are not allowed in the 'align-*' properties.

They are instead explicitly included in the 'justify-*' properties’ grammars.

<aside class=example>

The ''<self-position>/start'' and ''<self-position>/end'' keywords

are <a>flow-relative</a>:

they use the <a>writing mode</a> to determine which side to align to.

<figure>

<img src="images/start-inline-tb.svg"

<img src="images/end-inline-tb.svg"

<figcaption>

''<self-position>/start'' vs ''<self-position>/end'' in the <a>inline axis</a>

(<a href="#flexbox-exception">typically^†</a> 'justify-*')

</figcaption>

</figure>

The ''justify-self/left'' and ''justify-self/right'' keywords

are absolute (not <a>flow-relative</a>).

<figure>

<img src="images/left-inline-tb.svg"

<img src="images/right-inline-tb.svg"

<figcaption>

''justify-self/left'' vs ''justify-self/right''

</figcaption>

</figure>

The ''<self-position>/start'' and ''<self-position>/end'' keywords

have meaning in both the <a lt="inline axis">inline</a> and <a lt="block axis">block</a> axes:

''<self-position>/start'' always orients to the start of the text

(top left for left-to-right/top-to-bottom languages like English)

while ''<self-position>/end'' always orients to the end of the text.

<figure>

<img src="images/start-block-tb.svg"

<img src="images/end-block-tb.svg"

<figcaption>

''<self-position>/start'' vs ''<self-position>/end'' in the <a>block axis</a>

(<a href="#flexbox-exception">typically^†</a> 'align-*')

</figcaption>

</figure>

The ''<self-position>/start'' and ''<self-position>/end'' keywords

use the <a>writing mode</a> of the <a>alignment container</a>,

to help keep things consistent.

But if alignment using the <a>alignment subject</a>’s <a>writing mode</a> is needed,

the ''<self-position>/self-start'' and ''<self-position>/self-end'' keywords can be used.

<figure>

<img src="images/self-v-context-start-tb.svg"

<img src="images/self-v-context-self-start-tb.svg"

<figcaption>

''<self-position>/start'' vs ''<self-position>/self-start'' on the individual items

</figcaption>

</figure>

</aside>

<aside class=example>

The behavior of the alignment keywords is analogous in <a>vertical writing modes</a>:

''<self-position>/start'' and ''<self-position>/end''

are relative to the start/end of the text in the relevant axis.

The ''justify-self/left'' and ''justify-self/right'' keywords

are interpreted as <a>line-left</a> and <a>line-right</a>,

relative to the “left” and “right” sides of LTR/RTL text.

<figure>

<img src="images/start-inline-rl.svg"

<img src="images/end-inline-rl.svg"

<figcaption>

''<self-position>/start'' vs ''<self-position>/end'' in the <a>inline axis</a>

(<a href="#flexbox-exception">typically^†</a> 'justify-*')

</figcaption>

</figure>

<figure>

<img src="images/left-inline-rl.svg"

<img src="images/right-inline-rl.svg"

<figcaption>

''justify-self/left'' vs ''justify-self/right''

</figcaption>

</figure>

<figure>

<img src="images/start-block-rl.svg"

<img src="images/end-block-rl.svg"

<figcaption>

''<self-position>/start'' vs ''<self-position>/end'' in the <a>block axis</a>

(<a href="#flexbox-exception">typically^†</a> 'align-*')

</figcaption>

</figure>

<figure>

<img src="images/self-v-context-start-rl.svg"

<img src="images/self-v-context-self-start-rl.svg"

<figcaption>

''<self-position>/start'' vs ''<self-position>/self-start'' on the individual items

</figcaption>

</figure>

</aside>

<div class=note id=flexbox-exception>

For most layout models (block, table, grid, etc),

the 'justify-*' properties always align things in the <a>inline axis</a>,

while the 'align-*' properties always align things in the <a>block axis</a>.

Flexbox, on the other hand, has 'justify-*' align things in the <a>main axis</a>

and 'align-*' align things in the <a>cross axis</a>.

This depends on the value of 'flex-direction':

when 'flex-direction' is ''flex-direction/row'' or ''flex-direction/row-reverse'',

it matches the other layout modes

(<a>inline axis</a> with 'justify-*', <a>block axis</a> with 'align-*');

when 'flex-direction' is ''flex-direction/column'' or ''flex-direction/column-reverse'',

it has the opposite correspondence.

</div>

<p class='issue'>

Make it easier to understand the dual-axis nature of "start" and "end" wrt orthogonal flows.

See [[css-writing-modes-3#intro-baselines]].

<dfn export>Baseline alignment</dfn> is a form of positional alignment

that aligns multiple <a>alignment subjects</a>

within a <a>shared alignment context</a>

(such as cells within a row)

by matching up their <a>alignment baselines</a>.

If the position of the <a>alignment subjects</a> within a <a>baseline-sharing group</a>

is not fully constrained by <a>baseline alignment</a>

(i.e., they could be shifted within their respective <a>alignment containers</a>

while maintaining baseline-alignment),

they are [=fallback alignment|fallback-aligned=] insofar as possible while preserving their <a>baseline alignment</a>.

The baseline alignment keywords are represented with the <<baseline-position>> grammar term:

<pre class='prod'>

The ''first'' and ''last'' values give a box a <dfn export>baseline alignment preference</dfn>:

either “first” or “last”, respectively,

defaulting to “first”.

Values have the following meanings:

<dl dfn-type=value dfn-for="justify-self, justify-items, align-content, align-self, align-items, <baseline-position>">

<dt><dfn>baseline</dfn>

<dd>

Computes to ''first baseline'', defined below.

<dt><dfn lt="first baseline | first">first baseline</dfn>

<dd>

Specifies participation in <dfn dfn for export>first-baseline alignment</dfn>:

aligns the <a>alignment baseline</a> of the box's <a>first baseline set</a>

with the corresponding baseline

of its [=baseline-sharing group=].

See [[#align-by-baseline]] for more details.

The <a>fallback alignment</a> for ''first baseline'' is

''safe self-start'' (for [=self-alignment=])

or ''safe start'' (for [=content-distribution=]).

<dt><dfn lt="last baseline | last">last baseline</dfn>

<dd>

Specifies participation in <dfn dfn for export>last-baseline alignment</dfn>:

aligns the <a>alignment baseline</a> of the box's <a>last baseline set</a>

with the corresponding baseline

of its [=baseline-sharing group=].̣

See [[#align-by-baseline]] for more details.

The <a>fallback alignment</a> for ''last baseline'' is

''safe self-end'' (for [=self-alignment=])

or ''safe end'' (for [=content-distribution=]).

</dl>

When specified for 'align-content',

these values trigger <a>baseline content-alignment</a>,

shifting the content of the box within its content box,

and may also affect the sizing of the box itself.

See [[#baseline-align-content]].

When specified for 'align-self'/'justify-self',

these values trigger <a>baseline self-alignment</a>,

shifting the entire box within its container,

which may affect the sizing of its container.

See [[#baseline-align-self]].

When [=baseline self-alignment=] is specified on a box,

[=content distribution=] is performed first,

then the resulting box and its contents

are [=baseline self-alignment|self-aligned=]

However, if the box also has [=baseline content-alignment=] in the same axis

or if its [=content-distribution property=] in the same axis is ''align-content/normal'',

its [=used value|used=] [=content-distribution property=] in that axis

is ''align-content/start'' or ''safe end''

for a [=baseline alignment preference=] of its [=baseline self-alignment=]

of “first” or “last”, respectively.

<p class='issue'>Add example images here.

If a box does not belong to a <a>shared alignment context</a>,

then the <a>fallback alignment</a> is used.

For example, ''align-content: baseline'' on a block box

falls back to ''align-content/start'' alignment.

The [=fallback alignment=] is also used to align the [=baseline-sharing group=]

within its [=alignment container=].

Note: Because they are equivalent, and ''baseline'' is shorter,

the CSSOM serializes ''first baseline'' as ''baseline''.

See [[cssom-1#serializing-css-values]].

Note: For the somewhat-related 'vertical-align' property,

due to inconsistent design decisions in CSS2.1,

''baseline'' is not equivalent to ''first baseline''

as an inline-level box’s <a>baseline alignment preference</a> depends on 'display'.

(E.g., ''inline-block'' uses its last baseline by default,

while ''inline-table'' uses its first baseline by default.)

The <dfn export>distributed alignment</dfn> values are used by 'justify-content' and 'align-content'

to disperse a container’s extra space among its <a>alignment subjects</a>.

<figure>

<img src="images/distribute.svg" alt="space-between | space-around | space-evenly | stretch" width="504" height="218">

<figcaption>The <a>distributed alignment</a> values</figcaption>

</figure>

When space cannot be distributed in this way,

these values behave as their <a>fallback alignment</a>.

Each distribution value has an associated default <a>fallback alignment</a>.

(A future level of this module may allow the <a>fallback alignment</a> to be specified explicitly.)

<dl dfn-type="value" dfn-for="align-content, justify-content, <content-distribution>">

<dt><dfn>space-between</dfn>

<dd>

The <a>alignment subjects</a> are evenly distributed in the <a>alignment container</a>.

The first <a>alignment subject</a> is placed flush with the start edge of the <a>alignment container</a>,

the last <a>alignment subject</a> is placed flush with the end edge of the <a>alignment container</a>,

and the remaining <a>alignment subjects</a> are distributed so that the spacing between any two adjacent <a>alignment subjects</a> is the same.

<figure>

<img src="images/space-between.svg"

</figure>

The default [=fallback alignment=] for this value is ''safe flex-start''.

<span class='note'>(For layout modes other than flex layout, ''flex-start'' is identical to ''start''.)</span>

<dt><dfn>space-around</dfn>

<dd>

The <a>alignment subjects</a> are evenly distributed in the <a>alignment container</a>,

with a half-size space on either end.

The <a>alignment subjects</a> are distributed so that the spacing between any two adjacent <a>alignment subjects</a> is the same,

and the spacing before the first and after the last <a>alignment subject</a> is half the size of the other spacing.

<figure>

<img src="images/space-around.svg"

</figure>

The default [=fallback alignment=] for this value is ''safe center''.

<dt><dfn>space-evenly</dfn>

<dd>

The <a>alignment subjects</a> are evenly distributed in the <a>alignment container</a>,

with a full-size space on either end.

The <a>alignment subjects</a> are distributed so that the spacing between any two adjacent <a>alignment subjects</a>,

before the first <a>alignment subject</a>,

and after the last <a>alignment subject</a>

is the same.

<figure>

<img src="images/space-evenly.svg"

</figure>

The default [=fallback alignment=] for this value is ''safe center''.

<dt><dfn>stretch</dfn>

<dd>

If the combined size of the <a>alignment subjects</a> is less than the size of the <a>alignment container</a>,

any <css>auto</css>-sized <a>alignment subjects</a> have their size increased equally (not proportionally),

while still respecting the constraints imposed by 'max-height'/'max-width'

(or equivalent functionality),

so that the combined size exactly fills the <a>alignment container</a>.

<figure>

<img src="images/space-stretch.svg"

</figure>

The default [=fallback alignment=] for this value is ''flex-start''.

<span class='note'>(For layout modes other than flex layout, ''flex-start'' is identical to ''start''.)</span>

Note: This `align-content/stretch` definition applies to the [=content-distribution properties=];

the [=self-alignment properties=] 'justify-self'/'align-self' have their own ''justify-self/stretch'' value,

which can grow <em>or shrink</em> the [=alignment subject=]

to ensure it exactly fits the [=alignment container=].

</dl>

These values are represented with the <<content-distribution>> grammar term:

<pre class='prod'>

When the <a>alignment subject</a> is larger than the <a>alignment container</a>,

it will overflow.

Some alignment modes, if honored in this situation,

may cause data loss:

for example, if the contents of a sidebar are centered,

when they overflow they may send part of their boxes past the viewport's start edge,

which can't be scrolled to.

<div class='example'>

The figure below illustrates the difference in “safe” versus “unsafe” centering,

using a column flexbox as an example:

<figure>

<style>

.cross-auto-figure > div {

margin: 0 auto;

width: 70px;

background: #888;

padding: 0 .5em;

border-radius: 1em;

border: 1px solid transparent;

}

.cross-auto-figure > div > div {

border-spacing: 0;

display: table;

background: #ddd;

color: black;

text-align: center;

margin: .5em auto;

padding: .5em;

border-radius: .5em;

}

</style>

<div style="display:table; margin: 0 auto 1em;">

<div style="display:table-cell; padding-right: 70px;" class='cross-auto-figure'>

<div>

<div>About</div>

<div style="white-space: nowrap;">Authoritarianism</div>

<div>Blog</div>

</div>

</div>

<div style="display:table-cell; padding-left: 70px;" class='cross-auto-figure'>

<div>

<div>About</div>

<div style="white-space: nowrap; margin-left: -31px;">Authoritarianism</div>

<div>Blog</div>

</div>

</div>

</div>

<figcaption>

An example of "safe" (on the left)

vs "unsafe" (on the right)

centering,

when the centered item is larger than its container.

</figcaption>

</figure>

The items in the figure on the left are centered unless they overflow,

in which case all the overflow goes off the end edge,

while those in the figure on the right are are all strictly centered,

even if the one that is too long to fit overflows on both sides.

If the container was placed

against the left edge of the page,

the “safe” behavior would be more desirable,

as the long item would be fully readable,

rather than clipped by the left edge of the screen.

In other circumstances,

the “unsafe” centering behavior might be better,

as it correctly centers all the items.

</div>

To control this situation,

an <dfn export>overflow alignment</dfn> mode can be explicitly specified.

“Unsafe” alignment honors the specified alignment mode in overflow situations, even if it causes data loss,

while “safe” alignment changes the alignment mode in overflow situations in an attempt to avoid data loss.

The default behavior is to contain the alignment subject within the scrollable area,

though at the time of writing this safety feature is not yet implemented.

<pre class='prod'><dfn>&lt;overflow-position></dfn> = unsafe | safe</pre>

<dl dfn-type="value" dfn-for="<overflow-position>">

<dt><dfn>safe</dfn>

<dd>

If the size of the <a>alignment subject</a> overflows the <a>alignment container</a>,

the <a>alignment subject</a> is instead aligned as if the alignment mode were ''start''.

<dt><dfn>unsafe</dfn>

<dd>

Regardless of the relative sizes of the <a>alignment subject</a> and <a>alignment container</a>,

the given alignment value is honored.

<dt>(no value specified)

<dd>

If the <a>overflow alignment</a> isn't explicitly specified,

the default <a>overflow alignment</a> is a blend of “safe” and “unsafe”.

See [[#auto-safety]] for details.

</dl>

If no [=overflow alignment=] mode is specified for a property,

the default behavior lies somewhere between ''safe'' and ''unsafe'',

and also varies by layout mode.

The default [=overflow alignment=] behavior

for [=content distribution=] on [=scroll containers=] is ''unsafe''.

Non-''justify-content/normal'' values of the [=content-distribution properties=] instead

alter the [=scrollable overflow area=] in order to allow access to the overflowing content.

See [[#overflow-scroll-position]].

For [=absolutely positioned=] [=alignment subjects=]

whose relevant [=self-alignment property=] is not ''justify-self/normal'',

the default [=overflow alignment=] behavior is as follows:

<div algorithm="default overflow self-alignment for abspos">

1. Let the |default overflow rect| be the bounding rectangle

of the [=alignment subject's=] [=inset-modified containing block=]

and its [=original containing block=].

2. If the [=alignment subject=] overflows its [=inset-modified containing block=]

(its normal [=alignment container=]),

but does not overflow |default overflow rect|

align as specified (''unsafe'').

3. If the <em>size</em> of the [=alignment subject=]

fits within the |default overflow rect|,

but its specified alignment would cause it to overflow the |default overflow rect|,

it is instead shifted the minimum amount

to stay within the |default overflow rect|

while honoring the alignment as much as possible

(i.e., flush with the edge of the [=original containing block=]

it was trying to overflow over).

4. If the size of the [=alignment subject=]

overflows the |default overflow rect|,

it is instead start-aligned within the |default overflow rect|

(similar to ''safe'').

</div>

(For [=absolutely-positioned=] [=alignment subjects=] that fail the above condition,

see [[#auto-safety-default]].)

For all other elements:

1. If the [=alignment subject=] overflows its [=alignment container=],

align as specified (''unsafe'').

2. If the [=alignment subject=] would overflow

the [=scrollable overflow area=] of its nearest ancestor [=scroll container=],

(thus extending into the “unscrollable” region),

then its overflow in that direction is limited

by biasing any remaining overflow to the opposite side.

Issue: It may not be Web-compatible to implement the “smart” default behavior

(though we hope so, and believe it to be likely),

so UAs should pass any feedback on this point to the WG.

UAs that have not implemented the “smart” default behavior

must behave as ''safe'' for 'align-content' on [=block containers=]

and ''unsafe'' otherwise.

<!-- Big Text: *-content

███▌ ███▌ █ █▌ █████▌ █████▌ █ █▌ █████▌

█ █ █▌ █▌ █▌ █▌ █▌ █▌ █▌ █▌ █▌ █▌ █▌

█ █ █▌ █▌ █▌ ██▌ █▌ █▌ █▌ ██▌ █▌ █▌

███████ ████▌ █▌ █▌ █▌ █▌▐█ █▌ █▌ ████ █▌▐█ █▌ █▌

█ █ █▌ █▌ █▌ █▌ ██▌ █▌ █▌ █▌ ██▌ █▌

█ █ █▌ █▌ █▌ █▌ █▌ █▌ █▌ █▌ █▌ █▌ █▌

███▌ ███▌ █▌ ▐▌ █▌ █████▌ █▌ ▐▌ █▌

-->

<dfn export id="content-distribute" lt="content distribution | content-distribution">Content distribution</dfn> controls alignment of the box's content within its content box.

It is specified by the <dfn export>content-distribution properties</dfn> 'align-content' and 'justify-content'

(and their 'place-content' shorthand).

<div class="figure">

<img alt="Diagram showing that the alignment of the content within the element is affected." src="images/content-example.svg" width=212 height=212>

</div>

<pre class="propdef">

<pre class="propdef">

Aligns the contents of the box as a whole (as the <a>alignment subject</a>)

within the box itself (as the <a>alignment container</a>):

along the inline/row/main axis of the box (for 'justify-content')

or the block/column/cross axis of the box (for 'align-content').