Title: CSS Pseudo-Elements Module Level 4
Shortname: css-pseudo
Level: 4
Status: ED
Work Status: Exploring
Group: csswg
ED: https://drafts.csswg.org/css-pseudo-4/
TR: https://www.w3.org/TR/css-pseudo-4/
Previous Version: https://www.w3.org/TR/2016/WD-css-pseudo-4-20160607/
Previous Version: https://www.w3.org/TR/2015/WD-css-pseudo-4-20150115/
!Issues List: Tracked in Editor's Draft
Editor: Daniel Glazman, Disruptive Innovations, w3cid 13329
Editor: Elika J. Etemad / fantasai, Invited Expert, http://fantasai.inkedblade.net/contact, w3cid 35400
Editor: Alan Stearns, Adobe Systems Inc., stearns@adobe.com, w3cid 46659
Abstract: This CSS module defines pseudo-elements, abstract elements that represent portions of the CSS render tree that can be selected and styled.
Ignored Terms: initial-letter, PseudoElement, pseudo(), selectors
Default Highlight: css

spec:css-color-3; type:value; text:currentcolor
spec:css-color-3; type:property; text:color
spec:fill-stroke-3; type:property; text:stroke-width

Introduction

This section is informative. Pseudo-elements represent abstract elements of the document beyond those elements explicitly created by the document language. Since they are not restricted to fitting into the document tree, they can be used to select and style portions of the document that do not necessarily map to the document's tree structure. For instance, the ''::first-line'' pseudo-element can select content on the first formatted line of an element after text wrapping, allowing just that line to be styled differently from the rest of the paragraph. Each pseudo-element is associated with an originating element and has syntax of the form ''::name-of-pseudo''. This module defines the pseudo-elements that exist in CSS and how they can be styled. For more information on pseudo-elements in general, and on their syntax and interaction with other selectors, see [[!SELECTORS4]].

Typographic Pseudo-elements

The ::first-line pseudo-element

The ::first-line pseudo-element describes the contents of the first formatted line of its originating element.
The rule below means “change the letters of the first line of every p element to uppercase”: 
p::first-line { text-transform: uppercase }
The selector ''p::first-line'' does not match any real document element. It does match a pseudo-element that conforming user agents will insert at the beginning of every p element.
Note: Note that the length of the first line depends on a number of factors, including the width of the page, the font size, etc.
For example, given an ordinary HTML [[HTML5]] paragraph such as: 
      <P>This is a somewhat long HTML
      paragraph that will be broken into several
      lines. The first line will be identified
      by a fictional tag sequence. The other lines
      will be treated as ordinary lines in the
      paragraph.</P>
The lines might be broken as follows: 
      THIS IS A SOMEWHAT LONG HTML PARAGRAPH THAT
      will be broken into several lines. The first
      line will be identified by a fictional tag
      sequence. The other lines will be treated as
      ordinary lines in the paragraph.
This paragraph might be “rewritten” by user agents to include a fictional tag sequence to represent ''::first-line''. This fictional tag sequence helps to show how properties are inherited. 
      <P><P::first-line> This is a somewhat long HTML
      paragraph that </P::first-line> will be broken into several
      lines. The first line will be identified
      by a fictional tag sequence. The other lines
      will be treated as ordinary lines in the
      paragraph.</P>
If a pseudo-element breaks up a real element, the desired effect can often be described by a fictional tag sequence that closes and then re-opens the element.
Thus, if we mark up the previous paragraph with a span element encompassing the first sentence: 
      <P><SPAN class="test"> This is a somewhat long HTML
      paragraph that will be broken into several
      lines.</SPAN> The first line will be identified
      by a fictional tag sequence. The other lines
      will be treated as ordinary lines in the
      paragraph.</P>
the user agent could simulate start and end tags for span when inserting the fictional tag sequence for ''::first-line'' to get the correct inheritance behavior. 
      <P><P::first-line><SPAN class="test"> This is a somewhat long HTML
      paragraph that will </SPAN></P::first-line><SPAN class="test"> be broken into several
      lines.</SPAN> The first line will be identified
      by a fictional tag sequence. The other lines
      will be treated as ordinary lines in the
      paragraph.</P>

Finding the First Formatted Line

In CSS, the ''::first-line'' pseudo-element can only have an effect when attached to a block container. The first formatted line of an element must occur inside a block-level descendant in the same flow (i.e., a block-level descendant that is not out-of-flow due to floating or positioning).
For example, the first line of the DIV in <DIV><P>This line...</P></DIV> is the first line of the P (assuming that both P and DIV are blocks).
The first line of a table-cell or inline-block cannot be the first formatted line of an ancestor element. Thus, in <DIV><P STYLE="display: inline-block">Hello<BR>Goodbye</P> etcetera</DIV> the first formatted line of the DIV is not the line "Hello". Note: Note that the first line of the p in this fragment: <p><br>First... doesn't contain any letters (assuming the default style for br). The word "First" is not on the first formatted line. A user agent must act as if the fictional start tags of a ''::first-line'' pseudo-element were nested just inside the innermost enclosing block-level element.
For example, the fictional tag sequence for 
      <DIV>
        <P>First paragraph</P>
        <P>Second paragraph</P>
      </DIV>
is 
      <DIV>
        <P><DIV::first-line><P::first-line>First paragraph</P::first-line></DIV::first-line></P>
        <P><P::first-line>Second paragraph</P::first-line></P>
      </DIV>

Styling the First Line Pseudo-element

The ''::first-line'' pseudo-element’s generated box behaves similar to that of an inline-level element, but with certain restrictions. The following CSS properties apply to a ''::first-line'' pseudo-element: User agents may apply other properties as well.

Inheritance and the ''::first-line'' Pseudo-element

During CSS inheritance, the portion of a child element that occurs on the first line only inherits properties applicable to the ''::first-line'' pseudo-element from the ''::first-line'' pseudo-element. For all other properties inheritance is from the non-pseudo-element parent of the first line pseudo element. (The portion of a child element that does not occur on the first line always inherits from the parent of that child.)

The ::first-letter pseudo-element

The ::first-letter pseudo-element represents the first typographic letter unit [[!CSS3TEXT]] on the first formatted line of its originating element, if it is not preceded by any other content (such as images or inline tables) on its line. The ''::first-letter'' pseudo-element can be used to create “initial caps” and “drop caps”, which are common typographic effects.
For example, the following rule creates a 2-line drop-letter on every paragraph following a level-2 header, using the 'initial-letter' property defined in [[CSS-INLINE-3]]: 
h2 + p::first-letter { initial-letter: 2; }
Punctuation (i.e, characters that belong to the Punctuation (P*) Unicode general category [[!UAX44]]) that precedes or follows the first typographic letter unit must also be included in the ''::first-letter'' pseudo-element.
Quotes that precede the first letter should be included.
As explained in [[!CSS3TEXT]], a typographic letter unit can include more than one Unicode codepoint. For example, combining characters must be kept with their base character. Also, languages may have additional rules about how to treat certain letter combinations. In Dutch, for example, if the letter combination "ij" appears at the beginning of an element, both letters should be considered within the ''::first-letter'' pseudo-element. [[UAX29]] The UA should tailor its definition of typographic letter unit to reflect the first-letter traditions of the ''::first-letter'' pseudo-element’s containing block’s content language. Note: Note that the first typographic letter unit may in fact be a digit, e.g., the “6” in “67 million dollars is a lot of money.” If the characters that would form the ''::first-letter'' are not in the same element, such as ‘T in <p>‘<em>T..., the user agent may create a ''::first-letter'' pseudo-element from one of the elements, both elements, or simply not create a pseudo-element. Additionally, if the first letter(s) of the block are not at the start of the line (for example due to bidirectional reordering), then the user agent need not create the pseudo-element(s). The ''::first-letter'' pseudo-element is contained within any ''::first-line'' pseudo-elements, and thus inherits from ''::first-line''.

Finding the First Letter

The first letter must occur on the first formatted line. For example, in this HTML fragment: <p><br>First... the first line doesn't contain any letters and ''::first-letter'' doesn't match anything. In particular, it does not match the “F” of “First”. In CSS, the ''::first-letter'' pseudo-element only applies to block containers. A future version of this specification may allow this pseudo-element to apply to more display types. The ''::first-letter'' pseudo-element can be used with all such elements that contain text, or that have a descendant in the same flow that contains text. A user agent should act as if the fictional start tag of the ::first-letter pseudo-element is just before the first text of the element, even if that first text is in a descendant.
Example: The fictional tag sequence for this HTML fragment: 
      <div>
      <p>The first text.
is: 
      <div>
      <p><div::first-letter><p::first-letter>T</...></...>he first text.
In CSS the first letter of a table-cell or inline-block cannot be the first letter of an ancestor element. Thus, in <DIV><P STYLE="display: inline-block">Hello<BR>Goodbye</P> etcetera</DIV> the first letter of the DIV is not the letter "H". In fact, the DIV doesn't have a first letter. If an element is a list item (''display: list-item''), the ''::first-letter'' applies to the first letter in the principal box after the marker. User-Agents may ignore ''::first-letter'' on list items with ''list-style-position: inside''. If an element has ''::before'' or ''::after'' content, the ''::first-letter'' applies to the first letter of the element including that content.
Example: After the rule ''p::before {content: "Note: "}'', the selector ''p::first-letter'' matches the "N" of "Note".

Styling the ''::first-letter'' Pseudo-element

In CSS a ::first-letter pseudo-element is similar to an inline-level element. The following properties that apply to ''::first-letter'' pseudo-elements: User agents may apply other properties as well. Note: In previous levels of CSS, User Agents were allowed to choose a line height, width and height based on the shape of the letter, approximate font sizes, or to take the glyph outline into account when formatting. This possibility has been intentionally removed, as it proved to be a poor solution for the intended use case (Drop Caps), yet caused interoperability problems.
Example: This CSS and HTML example shows a possible rendering of an initial cap. Note that the fictional start tag of the first letter is inside the span, and thus the font weight of the first letter is normal, not bold as the span: 
      p { line-height: 1.1 }
      p::first-letter { font-size: 3em; font-weight: normal }
      span { font-weight: bold }
      ...
      <p><span>Het hemelsche</span> gerecht heeft zich ten lange lesten<br>
      Erbarremt over my en mijn benaeuwde vesten<br>
      En arme burgery, en op mijn volcx gebed<br>
      En dagelix geschrey de bange stad ontzet.
Image illustrating the ::first-letter pseudo-element
The following CSS will make a drop cap initial letter span about two lines: 
      <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
      <HTML>
       <HEAD>
        <TITLE>Drop cap initial letter</TITLE>
        <STYLE type="text/css">
         P               { font-size: 12pt; line-height: 1.2 }
         P::first-letter { font-size: 200%; font-weight: bold; float: left }
         SPAN            { text-transform: uppercase }
        </STYLE>
       </HEAD>
       <BODY>
        <P><SPAN>The first</SPAN> few words of an article
          in The Economist.</P>
       </BODY>
      </HTML>
This example might be formatted as follows:
Image illustrating the combined effect of the ::first-letter and ::first-line pseudo-elements
The fictional tag sequence is: 
      <P>
        <SPAN>
          <P::first-letter>
            T
          </P::first-letter>he first
        </SPAN>
        few words of an article in the Economist.
      </P>
Note that the ''::first-letter'' pseudo-element tags abut the content (i.e., the initial character), while the ::first-line pseudo-element start tag is inserted right after the start tag of the block element.

Highlight Pseudo-elements

Selecting Highlighted Content: the ''::selection'', ''::inactive-selection'', ''::spelling-error'', and ''::grammar-error'' pseudo-elements

The highlight pseudo-elements represent portions of a document that have been given a particular status and are typically styled differently to indicate that status to the user. For example, selected portions of the document are typically highlighted (given alternate background and foreground colors, or a color wash) to indicate their selected status. The following highlight pseudo-elements are defined:
::selection
::inactive-selection
The ''::selection'' and ''::inactive-selection'' pseudo-elements represent the portion of a document that has been selected as the target or object of some possible future user-agent operation(s). They apply, for example, to selected text within an editable text field, which would be copied by a copy operation or replaced by a paste operation. ''::selection'' applies to active selections, whereas ''::inactive-selection'' applies to inactive selections (e.g. when the document window is inactive and therefore not receiving events).
::spelling-error
The ''::spelling-error'' pseudo-element represents a portion of text that has been flagged by the user agent as misspelled.
::grammar-error
The ''::grammar-error'' pseudo-element represents a portion of text that has been flagged by the user agent as grammatically incorrect.
The highlight pseudo-elements do not necessarily fit into the element tree, and can arbitrarily cross element boundaries without honoring its nesting structure. The following addition is made to the default UA stylesheet: 

		::spelling-error { text-decoration-line: spelling-error; }
		::grammar-error { text-decoration-line: grammar-error; }
Note: A future level of CSS may introduce ways to create custom highlight pseudo-elements.

Styling Highlights

The highlight pseudo-elements can only be styled by a limited set of properties that do not affect layout. The following properties apply to the highlight pseudo-elements: Issue: Are there any other properties that should be included here? The 'color' property specifies the color of both the text and all line decorations (underline, overline, line-through) and emphasis marks ('text-emphasis') applied to the text by the originating element and its ancestors and descendants. Note: Historically (and at the time of writing) only 'color' and 'background-color' have been interoperably supported.

Area of a Highlight

For each type of highlighting (see [[#highlight-selectors]]) there exists a single highlight overlay for the entire document, the active portions of which are represented by the corresponding highlight pseudo-element. Each box owns the piece of the overlay corresponding to any text or replaced content directly contained by the box.

Issue: See F2F minutes, dbaron's message, Daniel's thread, Gecko notes, Opera notes, Webkit notes Issue: Not sure if this is the correct way of describing the way things work.

Cascading and Per-Element Highlight Styles

Each element draws its own active portions of the highlight overlays, which receives the styles specified by the corresponding highlight pseudo-element styles for which that element is the originating element. When multiple styles conflict, the winning style is determined by the cascade. When any supported property is not given a value by the cascade, it's value is determined by inheritance from the corresponding highlight pseudo-element of its originating element's parent element (regardless of whether that property is an inherited property).
For example, if the following rules were applied: 
      p::selection      { color: yellow; background: green; }
      p > em::selection { color: orange; }
      em::selection     { color:    red; }
to the following markup: 
      <p>Highlight this <em>and this</em>.</p>
The selection highlight would be green throughout, with yellow text outside the <em> element and orange text inside it.

Authors wanting multiple selections styles should use '':root::selection'' for their document-wide selection style, since this will allow clean overriding in descendants. ''::selection'' alone applies to every element in the tree, overriding the more specific styles of any ancestors.

For example, if an author specified 
      ::selection          { background: blue; }
      p.warning::selection { background:  red; }
and the document included 
      <p class="warning">Some <strong>very important information</strong></p>
The highlight would be blue over “very important information” because the <strong> element´s ''::selection'' also matches the ''::selection { background: blue; }'' rule. (Remember that ''*'' is implied when a tag selector is missing.) The style rules that would give the intended behavior (red highlight within p.warning, blue elsewhere) are 
      :root::selection     { background: blue; }
      p.warning::selection { background:  red; }
The UA should use the OS-default highlight colors for ''::selection'' when neither 'color' nor 'background-color' has been specified by the author. Note: This paired-cascading behavior does not allow using the normal cascade (i.g. '':root::selection'' rules in the UA style sheet) to represent the OS default selection colors. However it has been interoperably implemented in browsers and is thus probably a Web-compatibility requirement.

Painting the Highlight

Each highlight pseudo-element draws its background over the corresponding portion of the highlight overlay, painting it immediately below any positioned descendants (i.e. just before step 8 in CSS2.1§E.2). The ''::selection'' overlay is drawn over the ''::spelling-error'' overlay which is drawn over the ''::grammar-error'' overlay. A highlight pseudo-element also suppresses the drawing of any selected text (and any text decorations applied to that text). Instead the topmost active highlight overlay redraws that text (and its decorations) over the highlight overlay backgrounds using its own 'color', with ''currentColor'' on its 'color' property representing the 'color' of the next highlight pseudo-element layer below, falling back finally to that of the originating element (the colors that would otherwise be used). Any text decorations introduced by each highlight pseudo-element are stacked in the same order as their backgrounds over the text’s original decorations and are all drawn, in their own colors. Note: The element’s own text decorations (both line decorations and emphasis marks) are thus drawn in the pseudo-element’s own 'color' when that is not ''currentColor'', regardless of their original color or fill specifications. Issue: What should happen with text shadows? Drawing them in their original color is disconcerting if that color is not a shade of gray. Maybe if the overlay has a background, suppress any text shadows below it? For non-replaced content, the UA must honor the 'color' and 'background-color' (including their alpha channels) as specified. However, for replaced content, the UA should create a semi-transparent wash to coat the content so that it can show through the selection. This wash should be of the specified 'background-color' if that is not ''transparent'', else of the specified 'color'; however the UA may adjust the alpha channel.

Security and Privacy Considerations

Because the styling of spelling and grammar errors can leak information about the contents of a user's dictionary (which can include the user's name and even includes the contents of his/her address book!) UAs that implement ''::spelling-error'' and ''::grammar-error'' must prevent pages from being able to read the styling of such highlighted segments.

Tree-Abiding Pseudo-elements

Tree-abiding pseudo-elements always fit within the box tree. They inherit any inheritable properties from their originating element; non-inheritable properties take their initial values as usual. [[CSS3CASCADE]]

Generated Content Pseudo-elements: ''::before'' and ''::after''

When their computed 'content' value is not ''content/none'', these pseudo-elements generate boxes as if they were immediate children of their originating element, and can be styled exactly like any normal document-sourced element in the document tree.
::before
Represents a styleable child pseudo-element immediately before the originating element's actual content.
::after
Represents a styleable child pseudo-element immediately after the originating element's actual content.
For example, the following rule inserts the string “Note: ” before the content of every <p> element whose class attribute has the value note: 
p.note::before { content: "Note: " }
Since the initial value of 'display' is ''display/inline'', this will generate an inline box. Like other inline children of <p>, it will participate in <p>’s inline formatting context, potentially sharing a line with other content.
As with the content of regular elements, the generated content of ''::before'' and '':after'' pseudo-elements may be included in any ''::first-line'' and ''::first-letter'' pseudo-elements applied to its originating element.

List Markers: the ''::marker'' pseudo-element

The ::marker pseudo-element represents the automatically generated marker box of a list item. (See ''display: list-item''.) The following CSS properties apply to a ''::marker'' pseudo-element:

It is expected that future specifications will extend this list of properties; however at the moment marker box layout is not fully defined, so only these properties are allowed. UAs must add the following rule to their default style sheet: 

::marker { font-variant-numeric: tabular-nums; }

Placeholder Input: the ''::placeholder'' pseudo-element

The ::placeholder pseudo-element represents placeholder text in an input field: text that represents the input and provides a hint to the user on how to fill out the form. For example, a date-input field might have the placeholder text “YYYY/MM/DD” to clarify that numeric dates are to be entered in year-month-day order. Note: There also exists a '':placeholder-shown'' pseudo-class, which applies to (real) elements while they are showing placeholder text, and can be used to style such elements specially. ''::placeholder'' specifically selects a pseudo-element representing the placeholder text, and is thus relatively limited in its abilities. All properties that apply to the ''::first-line'' pseudo-element also apply to the ''::placeholder'' pseudo-element. In interactive media, placeholder text is often hidden once the user has entered input; however this is not a requirement, and both the input value and the placeholder text may be visible simultaneously. The exact behavior is UA-defined. Note that in static media (such as print) placeholder text will be present even after the user has entered input. Issue: Authors seem to want 'text-align' on the list of supported properties. See e.g. comments here. Note: It's been requested that ''::placeholder'' also refer to a placeholder which has a corresponding element in the element tree. It's not clear how this should work, but it may be worth doing. See Issue 2417.

Overlapping Pseudo-element Interactions

Recall that The following CSS and HTML example illustrates how overlapping pseudo-elements interact: <style> p { color: red; font-size: 12pt } p::first-letter { color: green; font-size: 200% } p::first-line { color: blue } </style> <p>Some text that ends up on two lines</p> The first letter of each P element will be green with a font size of ’24pt'. The rest of the first formatted line will be blue while the rest of the paragraph will be red. Assuming that a line break will occur before the word "ends", the fictional tag sequence for this fragment might be: <p> <p::first-line> <p::first-letter> S </p::first-letter> ome text that </p::first-line> ends up on two lines </p>

Additions to the CSS Object Model

Interface CSSPseudoElement

The {{CSSPseudoElement}} interface allows pseudo-elements to be event targets. 
    [Exposed=Window]
    interface CSSPseudoElement : EventTarget {
        readonly attribute CSSOMString type;
        readonly attribute Element element;
    };
The type attribute is a string representing the type of the pseudo-element. This can be one of the following values:
‘::before’
The pseudo-element was created before the element's contents.
‘::after’
The pseudo-element was created after the element's contents.
The element attribute is the [=originating element=] of the pseudo-element. Note: This interface may be extended in the future to other pseudo-element types and/or to allow setting style information through a {{CSSStyleDeclaration}} style attribute. The current functionality is limited to that which is needed to support [[web-animations-1]].

Addition to the {{Element}} interface

A new method is added to the {{Element}} interface to retrieve pseudo-elements created by a given element for a given type: 
    partial interface Element {
      CSSPseudoElement? pseudo(CSSOMString type);
    };
The pseudo(CSSOMString type) method is used to retrieve the {{CSSPseudoElement}} instance created by the element of the type matching {{type!!argument}}. Its return value is a {{CSSPseudoElement}}, potentially null if no such pseudo-element exists. Pseudo-elements of unsupported types are considered to simply not exist; unrecognized {{type!!argument}} values are not an error. ISSUE: The identity, lifetime, and nullness of the return value (and potential error cases) of the {{pseudo()}} method is still under discussion. See Issue 3607 and Issue 3603.

Compatibilitiy Syntax

For compatibility with existing style sheets written against CSS Level 2 [[CSS21]], user agents must also accept the previous one-colon notation (:before, :after, :first-letter, :first-line) for the ''::before'', ''::after'', ''::first-letter'', and ''::first-line'' pseudo-elements.

Changes

Changes since the 7 June 2016 Working Draft include:

Acknowledgements

The editors would like to thank the following individuals for their contributions, either during the conception of the specification or during its development and specification review process: Tab Atkins, David Baron, Razvan Caliman, Chris Coyier, Anders Grimsrud, Vincent Hardy.