GeezerVisonThe World Wide Web, restored to 800 pixels of glory. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| Home|About|Gaming cabinet|Archives|How it works|Starter sites | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
GeezerVison is showing drafts.csswg.org — CSS Lists and Counters Module Level 3 1. IntroductionThis specification defines the ::marker pseudo-element, the list-item display type that generates markers, and several properties controlling the placement and styling of markers. It also defines counters, which are special numerical objects often used to generate the default contents of markers.
For instance, the following example illustrates
how markers can be used to add parentheses around each numbered list item:
It should produce something like this: (i) This is the first item. (ii) This is the second item. (iii) This is the third item. Note: Note that this example is far more verbose than is usually needed in HTML, as the UA default style sheet takes care of most of the necessary styling. With descendant selectors and child selectors, it’s possible to specify different marker types depending on the depth of embedded lists. 1.1. Value DefinitionsThis specification follows the CSS property definition conventions from [CSS2] using the value definition syntax from [CSS-VALUES-3]. Value types not defined in this specification are defined in CSS Values & 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 CSS-wide keywords as their property value. For readability they have not been repeated explicitly. 2. Declaring a List ItemA list item is any element with its display property set to list-item. List items generate ::marker pseudo-elements; no other elements do. Additionally, list items automatically increment an implied list-item counter (see § 4.6 The Implicit list-item Counter). 3. MarkersThe defining feature of the list item display type is its marker, a symbol or ordinal that helps denote the beginning of each list item in a list. In the CSS layout model, list item markers are represented by a marker box associated with each list item. The contents of this marker can be controlled with the list-style-type and list-style-image properties on the list item and by assigning properties to its ::marker pseudo-element. 3.1. The ::marker Pseudo-ElementThe marker box is generated by the ::marker pseudo-element of a list item as the list item’s first child, before the ::before pseudo-element (if it exists on the element). It is filled with content as defined in § 3.2 Generating Marker Contents.
In this example, markers are used to number paragraphs that are designated as "notes":
It should render something like this: This is the first paragraph
in this document.
Note 1: This is a very short
document.
This is the end.
By using the ::marker pseudo-element,
a list’s markers can be styled
independently from the text of the list item itself:
The preceding document should render something like this: This is a long preceding
paragraph ...
i. This is the first item.
ii. This is the second item.
iii. This is the third item.
This is a long following
paragraph ...
Previously the only way to style a marker was through inheritance; one had to put the desired marker styling on the list item, and then revert that on a wrapper element around the list item’s actual contents. Marker boxes only exist for list items: on any other element, the ::marker pseudo-element’s content property must compute to none, which suppresses its creation. 3.1.1. Properties Applying to ::markerAll properties can be set on a ::marker pseudo-element and will have a computed value which will then inherit to its text content.
Inheritable properties that apply to text
can be set on the ::marker pseudo-element:
these will inherit to and take effect on its text contents.
Some examples of such properties include:
However, only the following CSS properties actually apply to a marker box:
Other properties should not have an effect on the marker box when declared directly on ::marker in the author or user origin of the cascade. UAs may either treat such properties as not applying, or enforce their value or inheritance from the originating element by setting a user-agent origin !important rule. NOTE: It is expected that future specifications will extend this list of properties and relax the restriction on which properties can take effect. However at the moment outside marker box layout is not fully defined, so to avoid future compatibility problems only these properties are allowed. Additionally, UAs must add the following rule to their default style sheet: ::marker, ::before::marker, ::after::marker {
unicode-bidi: isolate;
font-variant-numeric: tabular-nums;
white-space: pre;
text-transform: none;
}
white-space: pre doesn’t have quite the right behavior; white-space-collapse: preserve-spaces + white-space-trim: discard-after might be closer to what’s needed here. See discussion in Issue 4448 and Issue 4891. Note: Although the ::marker pseudo-element can represent the marker box of a ::before or ::after pseudo-element, the compound selector ::marker, which expands to *::marker [SELECTORS-4], will not select these markers—an originating element that is a pseudo-element needs to be explicitly specified in the selector, e.g. ::before::marker. 3.2. Generating Marker ContentsThe contents of a marker box are determined by the first of these conditions that is true:
Additionally, the UA may transform into spaces or discard any preserved forced line breaks. 3.3. Image Markers: the list-style-image property
Specifies the marker image, which is used to fill the list item’s marker when its content is normal. The values are as follows:
The marker image is sized using the default sizing algorithm [css-images-3] with no specified size and a default object size of 1em square.
The following example sets the marker at the beginning of each list item to
be the image "ellipse.png".
li 3.4. Text-based Markers: the list-style-type property
Specifies the marker string, which is used to fill the list item’s marker when its content value is normal and there is no marker image. The values are as follows:
The following examples illustrate how to set markers to various values:
ul 3.5. Positioning Markers: The list-style-position property
This property dictates whether the ::marker is rendered inline, or positioned just outside of the list item. The values are as follows:
For example:
<style>
ul.compact { list-style: inside; }
ul { list-style: outside; }
</style>
<ul class=compact>
<li>first "inside" list item comes first</li>
<li>second "inside" list item comes first</li>
</ul>
<hr>
<ul>
<li>first "outside" list item comes first</li>
<li>second "outside" list item comes first</li>
</ul>
The above example may be formatted as: * first "inside" list item comes first * second "inside" list item comes second ======================== * first "outside" list item comes first * second "outside" list item comes second 3.6. Styling Markers: the list-style shorthand property
The list-style property is a shorthand notation for setting the three properties list-style-type, list-style-image, and list-style-position at the same place in the style sheet.
For example:
ul Using a value of none in the shorthand is potentially ambiguous, as none is a valid value for both list-style-image and list-style-type. To resolve this ambiguity, a value of none in the shorthand must be applied to whichever of the two properties aren’t otherwise set by the shorthand.
Note: The <counter-style> values of list-style-type can also create grammatical ambiguities. As such values are ultimately <custom-ident> values, the parsing rules in [CSS-VALUES-3] apply.
Although authors may specify list-style information directly on list item elements
(e.g.,
li in HTML),
they should do so with care.
Consider the following rules:
ol.alpha li The above won’t work as expected.
If you nest a ol.alpha > li These work as intended. ol.alpha These are even better, since inheritance will transfer the list-style value to the list items. 3.7. The marker-side property
The marker-side property specifies whether an outside marker box is positioned based on the directionality of the list item itself (i.e. its originating element) or the directionality of the list container (i.e. the originating element’s parent). In the first case, the position of the marker can vary across items in the same list, based on the directionality assigned to each list item individually; in the second case they will all align on the same side, as determined by the directionality assigned to the list as a whole.
By default, elements or ::marker pseudo-elements
position themselves according to their list item’s directionality.
However, if the list item is grouped with several other list items which may have different directionality
(for example, multiple <li>s with different "dir" attributes in an <ol> in HTML),
it is sometimes more useful to have all the markers line up on one side,
so the author can specify a single "gutter" on that side
and be assured that all the markers will lie in that gutter and be visible.
Both of the following example renderings are generated from the following HTML, with the only difference being the value of marker-side on the list:
For this order punctuation inside the marker correctly, it would also need to take the direction value of the parent. [Issue #4202] There are issues open on renaming the keywords and on merging with list-style-position. 4. Automatic Numbering With CountersA counter is a special numeric tracker used, among other things, to automatically number list items in CSS. Every element has a collection of zero or more counters, which are inherited through the document tree in a way similar to inherited property values. Counters have a name and creator, which identify the counter, a boolean reversed (false by default), and an integer value (optional when the counter is reversed). They are created and manipulated with the counter properties counter-increment, counter-set and counter-reset, and used with the counter() and counters() functional notations. Counters are referred to in CSS syntax using the <counter-name> type, which represents their name as a <custom-ident>. A <counter-name> name cannot match the keyword none; such an identifier is invalid as a <counter-name>. A reversed counter is created with the reversed() functional notation, which is defined as follows: <reversed-counter-name> = reversed( <counter-name> ) Resolving counter values on a given element is a multi-step process:
UAs may have implementation-specific limits on the maximum or minimum value of a counter. If a counter reset, set, or increment would push the value outside of that range, the value must be clamped to that range. 4.1. Creating Counters: the counter-reset property
User agents are expected to support this property on all media, including non-visual ones. The counter-reset property instantiates new counters on an element and sets them to the specified integer values. Its values are defined as follows:
Note that counter properties follow the cascading rules as normal.
Thus, due to cascading, the following style sheet:
h1 will only reset imagenum. To reset both counters, they have to be specified together: H1 The same principles apply to the counter-set and counter-increment properties. See [css-cascade-4]. If multiple instances of the same <counter-name> occur in the property value, only the last one is honored. 4.2. Manipulating Counter Values: the counter-increment and counter-set properties
User agents are expected to support this property on all media, including non-visual ones.
User agents are expected to support this property on all media, including non-visual ones. The counter-increment and counter-set properties manipulate the value of existing counters. They only instantiate new counters if there is no counter of the given name on the element yet. Their values are defined as follows:
This example shows a way to number chapters and sections with "Chapter 1", "1.1", "1.2", etc.
If multiple instances of the same <counter-name> occur in the property value, they are all processed, in order. Thus increments will compound, but only the last set value will take effect. 4.3. Nested Counters and ScopeCounters are “self-nesting”; instantiating a new counter on an element which inherited an identically-named counter from its parent creates a new counter of the same name, nested inside the existing counter. This is important for situations like lists in HTML, where lists can be nested inside lists to arbitrary depth: it would be impossible to define uniquely named counters for each level. The counter() function only retrieves the innermost counter of a given name on the element, whereas the counters() function uses all counters of a given name that contain the element. The scope of a counter therefore starts at the first element in the document that instantiates that counter and includes the element’s descendants and its following siblings with their descendants. However, it does not include any elements in the scope of a counter with the same name created by a counter-reset on a later sibling of the element, allowing such explicit counter instantiations to obscure those earlier siblings. See § 4.4 Creating and Inheriting Counters for the exact rules governing the scope of counters and their values.
The following code numbers nested list items.
The result is very similar to that of setting display:list-item and list-style: inside on the LI element:
ol In this example, an ol will create a counter, and all children of the ol will refer to that counter. If we denote the nth instance of the item counter by itemn, then the following HTML fragment will use the indicated counters. <ol> item0 is created, set to 0
<li> item0 is incremented to 1<li> item0 is incremented to 2
<ol> item1 is created, set to 0, nested in item0
<li> item1 is incremented to 1<li> item1 is incremented to 2<li> item1 is incremented to 3
<ol> item2 is created, set to 0, nested in item1
<li> item2 is incremented to 1</ol>
<li> item1 is incremented to 4
<ol> item3 is created, set to 0, nested in item1
<li> item3 is incremented to 1</ol>
<li> item1 is incremented to 5</ol>
<li> item0 is incremented to 3<li> item0 is incremented to 4</ol>
<ol> item4 is created, set to 0
<li> item4 is incremented to 1<li> item4 is incremented to 2</ol>
4.4. Creating and Inheriting CountersEach element or pseudo-element in a document has a (possibly empty) set of counters in the scope of that element, either through inheritance from another element or through instantiation on the element directly. These counters are represented as a CSS counters set, which is a set whose values are each a tuple of: a string (representing a counter’s name), an element (representing the counter’s creator), a boolean (representing whether the counter is reversed), and optionally an integer (representing the counter’s value). The latest counter of a given name in that set represents the innermost counter of that name. 4.4.1. Inheriting Counters
An element inherits its initial set of counters
from its parent and preceding sibling.
It then takes the values for those counters
from the values of the matching counters
on its preceding element in tree order
(which might be its parent,
its preceding sibling,
or a descendant of its previous sibling).
To inherit counters
into an element:
Take the following code as an example:
<ul style='counter-reset: example 0;'>
<li id='foo' style='counter-increment: example;'>
foo
<div id='bar' style='counter-increment: example;'>bar</div>
</li>
<li id='baz'>
baz
</li>
</ul>
Recall that tree order turns a document tree into an ordered list, where an element comes before its children, and its children come before its next sibling. In other words, for a language like HTML, it’s the order in which the parser encounters start tags as it reads the document. In here, the The same happens with the #bar element. It inherits the example counter from #foo, and inherits the value 1 from it as well and increments it to 2. However, the #baz element is a bit different. It inherits the example counter from the #foo element, its previous sibling. However, rather than inheriting the value 1 from #foo along with the counter, in inherits the value 2 from #bar, the previous element in tree order. This behavior allows a single counter to be used throughout a document, continuously incrementing, without the author having to worry about the nested structure of their document. Note: Counter inheritance, like regular CSS inheritance, operates on the “flattened element tree” in the context of the [DOM]. 4.4.2. Instantiating Counters
Counters are instantiated when named in counter-reset,
and also when not otherwise present if named in
counter-increment, counter-set, or the counter() or counters() notations.
(Newly instantiated counters replace identically-named counters originating from previous siblings,
but are added in addition to identically-named counters originating from ancestor elements,
see § 4.3 Nested Counters and Scope.)
To instantiate a counter
of a given name
on an element,
optionally reversed,
with an optional starting value:
When a counter is instantiated without an initial value, the user agent must dynamically calculate the initial value at layout-time to be the value returned by the following algorithm:
Note: Only reversed counters can be instantiated without an initial value. 4.5. Counters in elements that do not generate boxesAn element that does not generate a box (for example, an element with display set to none, or a pseudo-element with content set to none) cannot set, reset, or increment a counter. The counter properties are still valid on such an element, but they must have no effect.
For example, with the following style sheet,
H2s with class "secret" do not increment count2.
h2 Note: Other methods of “hiding” elements, such as setting visibility to hidden, still cause the element to generate a box, and so are not excepted here. Whether a replaced element’s descendants
(such as HTML Note: The behavior on replaced element descendants is currently undefined due to a lack of interoperability across implementations. 4.6. The Implicit list-item CounterIn addition to any explicitly defined counters that authors write in their styles, list items automatically increment a special list-item counter, which is used when generating the default marker string on list items (see list-style-type). Specifically, unless the counter-increment property explicitly specifies a different increment for the list-item counter, it must be incremented by 1 on every list item, or if the counter is reversed, it must be incremented by -1 on every list item instead, at the same time that counters are normally incremented (exactly as if the list item had list-item 1 or list-item -1 appended to their counter-increment value, including side-effects such as possibly instantiating a new counter, etc). This does not affect the specified or computed values of counter-increment.
Because each list item automatically increments
the list-item counter by 1,
consecutive list items with a numeric list-style-type
will be consecutively numbered by default—even if the author sets counter-increment to another value
such as counter-increment: itemnumber or even none.
This protects the automatic list-item counter
from inadvertently being overridden
by declarations intended to address other counters.
However, since the automatic list-item increment does not happen if the list item’s counter-increment explicitly mentions the list-item counter, li { counter-increment: list-item 2; } will increment list-item by 2 as specified, not by 3 as would happen if list-item 1 were unconditionally appended. This also allows to turn off the automatic list-item counter increment, by overriding it explicitly, e.g. counter-increment: list-item 0;. In all other respects, the list-item counter behaves like any other counter and can be used and manipulated by authors to adjust list item styling or for other purposes. In the following example, the list is modified to count by twos: ol.evens > li { counter-increment: list-item 2; }
A three-item list would be rendered as 2. First Item 4. Second Item 6. Third Item UAs and host languages should ensure that the list-item counter values by default reflect the underlying numeric value dictated by host language semantics when setting up list item styling in their UA style sheet and presentational hint style mappings. See, e.g. Appendix A: Sample Style Sheet For HTML.
In the following example,
the content property is used to create tiered numbering
that hooks into the list-item counter,
and thus respects any numbering changes inflicted through HTML:
ol > li::marker { content: counters(list-item,'.') '.'; }
Nested lists using this rule would be rendered like 1. First top-level item
5. Second top-level item, value=5
5.3. First second-level item, list start=3
5.4. Second second-level item, list start=3
5.4.4. First third-level item in reversed list
5.4.3. Second third-level item in reversed list
5.4.2. Third third-level item in reversed list
5.4.1. Fourth third-level item in reversed list
5.5. Third second-level item, list start=3
6. Third top-level item
given markup such as <ol>
<li>First top-level item
<li value=5>Second top-level item, value=5
<ol start=3>
<li>First second-level item, list start=3
<li>Second second-level item, list start=3
<ol reversed>
<li>First third-level item in reversed list
<li>Second third-level item in reversed list
<li>Third third-level item in reversed list
<li>Fourth third-level item in reversed list
</ol>
<li>Third second-level item, list start=3
</ol>
<li>Third top-level item
</ol>
4.7. Outputting Counters: the counter() and counters() functionsCounters have no visible effect by themselves, but their values can be used with the counter() and counters() functions, whose used values represent counter values as strings or images. They are defined as follows: <counter> = <counter()> | <counters()> <counter()> = counter( <counter-name>, <counter-style>? ) <counters()> = counters( <counter-name>, <string>, <counter-style>? ) where <counter-style> specifies the counter style for generating a representation of the named counter(s) as defined in [css-counter-styles-3] and
In both cases, if the <counter-style> argument is omitted it defaults to decimal. Note: If the <counter-style> is one of the predefined symbolic styles, like disc, it might look different than when used in list-style-type. See CSS Counter Styles 3 § 6.3 Symbolic: disc, circle, square, disclosure-open, disclosure-closed. If no counter named <counter-name> exists on an element where counter() or counters() is used, one is first instantiated with a starting value of 0. H1::before { content: counter(chno, upper-latin) ". " }
/* Generates headings like "A. A History of Discontent" */
H2::before { content: counter(section, upper-roman) " - " }
/* Generates headings like "II - The Discontent Part" */
BLOCKQUOTE::after { content: " [" counter(bq, decimal) "]" }
/* Generates blockquotes that end like "... [3]" */
DIV.note::before { content: counter(notecntr, disc) " " }
/* Simply generates a bullet before every div.note */
P::before { content: counter(p, none) }
/* inserts nothing */
The following example shows a simple use of the counters() function:
The preceding document should render something like this: (1) one (2) two (2.1) nested one (2.2) nested two (3) three
Because counters inherit to siblings as well,
they can be used to number headings and subheadings,
which aren’t nested within each other.
Unfortunately,
this prevents the use of counters() as counters from siblings don’t nest,
but one can create multiple counters and manually concatenate them instead:
The preceding document should render something like this: A First H1 ... A.1 First H2 in H1 ... A.2 Second H2 in H1 ... A.2.i First H3 in H2 ... B Second H1 ... B.1 First H2 in H1 ...
Counters are sometimes useful for things other than printing markers.
In general, they provide the ability to number elements in sequence,
which can be useful for other properties to reference.
For example, using order to put an element between two other specific elements
currently requires you to explicitly put order on every element before and/or after the desired insertion point.
If you can set the order value of everything to a counter though,
you can more easily insert an element into an arbitrary spot between two others.
Other use-cases involve nested or sibling elements with transforms that are meant to be slightly different from each other. Today you have to use a preprocessor to do this in a reasonable way, but a counter would make it work well in "plain" CSS. (You can built up successive values in the nested case today by using custom properties and stacking up nested calc()s, but this is a *little bit* clumsy, and doesn’t work for siblings.) Suggestion is to add a counter-value(<counter-name>) function, which returns the value of the named counter as an integer, rather than returning a string. See Issue 1026. Appendix A: Sample Style Sheet For HTMLThis section is informative, not normative. The [HTML] Rendering chapter defines the normative default properties that apply to HTML lists; this sample style sheet is provided to illustrate the CSS features using familiar markup conventions. /* Set up list items */
li {
display: list-item; /* implies 'counter-increment: list-item' */
}
/* Set up ol and ul so that they scope the list-item counter */
ol, ul {
counter-reset: list-item;
}
/* Default list style types for lists */
ol { list-style-type: decimal; }
ul { list-style-type: toggle(disc, circle, square); }
/* The type attribute on ol and ul elements */
ul[type="disc"] { list-style-type: disc; }
ul[type="circle"] { list-style-type: circle; }
ul[type="square"] { list-style-type: square; }
ol[type="1"] { list-style-type: decimal; }
ol[type="a"] { list-style-type: lower-alpha; }
ol[type="A"] { list-style-type: upper-alpha; }
ol[type="i"] { list-style-type: lower-roman; }
ol[type="I"] { list-style-type: upper-roman; }
/* The start attribute on ol elements */
ol[start] {
counter-reset: list-item calc(attr(start integer, 1) - 1);
}
/* The value attribute on li elements */
li[value] {
counter-set: list-item attr(value integer, 1);
}
/* Handling reversed lists */
ol[reversed] {
counter-reset: reversed(list-item);
}
ol[reversed][start] {
counter-reset: reversed(list-item) calc(attr(start integer) + 1);
}
/* Box Model Rules */
ol, ul {
display: block;
margin-block: 1em;
marker-side: match-parent;
padding-inline-start: 40px;
}
ol ol, ol ul, ul ul, ul ol {
margin-block: 0;
}
li {
text-align: match-parent;
}
AcknowledgmentsThis specification is made possible by input from Aharon Lanin, Arron Eicholz, Brad Kemper, David Baron, Emilio Cobos Álvarez, Mats Palmgren, Oriol Brufau, Simon Sapin, Xidorn Quan ChangesThis section documents the changes since previous publications. Changes since the 9 July 2020 WD
Changes since the 17 August 2019 WD
Changes since the 25 April 2019 WD
Changes since the 20 March 2014 WD
Changes From CSS Level 2As described in the introduction section, there are significant changes in this module when compared to CSS2.1.
Privacy ConsiderationsNo new privacy considerations have been reported on this specification. Security ConsiderationsNo new security considerations have been reported on this specification. | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| You are visitor 01402503 — GeezerVison does not store the pages you look up. Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required. |