Overview.bs

<pre class='metadata'>
Title: CSS Cascading and Inheritance Level 6
Shortname: css-cascade
Level: 6
Status: ED
Prepare for TR: no
Work Status: Revising
Group: csswg
ED: https://drafts.csswg.org/css-cascade-6/
TR: https://www.w3.org/TR/css-cascade-6/
Previous Version: https://www.w3.org/TR/2021/WD-css-cascade-6-20211221/
Editor: Elika J. Etemad / fantasai, Invited Expert, http://fantasai.inkedblade.net/contact, w3cid 35400
Editor: Miriam E. Suzanne, Invited Expert, http://miriamsuzanne.com/contact, w3cid 117151
Editor: Tab Atkins Jr., Google, http://xanthir.com/contact/, w3cid 42199
Abstract: This CSS module describes how to collate style rules and assign values to all properties on all elements. By way of cascading and inheritance, values are propagated for all properties on all elements.
Abstract:
Abstract: New in this level is [[#scoped-styles]].
Ignored Terms: auto, flex items, <supports-condition>
Informative Classes: ex
</pre>

<pre class=link-defaults>
spec:dom; type:dfn; text:shadow tree
spec:dom; type:dfn; for:tree; text:root
spec:css-color-4; type:property; text:color
spec:css-values-3; type: value; text:ex
spec:css-conditional-3; type:at-rule; text:@media
spec:mediaqueries-4; type:type; for:@media; text:all
spec:mediaqueries-4; type:type; text:<media-query>
spec:selectors-4; type:dfn; text:subject
spec:html; type:element; text:style
spec:css-scoping-1; type:dfn; text:shadow host
</pre>

<pre class=ignored-specs>
spec:mediaqueries-5
spec:css-values-4
spec:css-fonts-4
</pre>

<h2 id="intro" oldids='filtering,fragments,stages-examples,actual,used,computed,cascaded,declared,specified,value-stages,all-shorthand,aliasing,shorthand,content-type,import-processing,conditional-import,at-import,defaulting,initial-values,inheriting,defaulting-keywords,initial,inherit,inherit-initial,default'>
Introduction and Missing Sections</h2>

	Issue: This is a diff spec over <a href="https://www.w3.org/TR/css-cascade-5/">CSS Cascading and Inheritance Level 5</a>.
	It is currently an Exploratory Working Draft:
	if you are implementing anything, please use Level 5 as a reference.
	We will merge the Level 5 text into this draft once it reaches CR.

<!--
 ██████     ███     ██████   ██████     ███    ████████  ████████
██    ██   ██ ██   ██    ██ ██    ██   ██ ██   ██     ██ ██
██        ██   ██  ██       ██        ██   ██  ██     ██ ██
██       ██     ██  ██████  ██       ██     ██ ██     ██ ██████
██       █████████       ██ ██       █████████ ██     ██ ██
██    ██ ██     ██ ██    ██ ██    ██ ██     ██ ██     ██ ██
 ██████  ██     ██  ██████   ██████  ██     ██ ████████  ████████
-->

<h2 id='cascading'>
Cascading</h2>

	The <dfn export>cascade</dfn>
	takes an unordered list of <a>declared values</a>
	for a given property on a given element,
	sorts them by their [=declaration’s=] precedence as determined below,
	and outputs a single <a>cascaded value</a>.

<h3 id="cascade-sort">
Cascade Sorting Order</h3>

	The cascade sorts [=declarations=] according to the following criteria,
	in descending order of precedence:

	<dl>
		<dt id='cascade-origin'>Origin and Importance
		<dd>
			The <a>origin</a> of a [=declaration=] is based on where it comes from
			and its <a lt="important">importance</a> is
			whether or not it is declared with ''!important''
			(see [[#importance|below]]).
			The precedence of the various <a>origins</a> is, in descending order:

			<ol>
				<li>Transition declarations [[!css-transitions-1]]
				<li>[=Important=] [=user-agent origin|user agent=] declarations
				<li>[=Important=] [=user origin|user=] declarations
				<li>[=Important=] [=author origin|author=] declarations
				<li>Animation declarations [[!css-animations-1]]
				<li>[=Normal=] [=author origin|author=] declarations
				<li>[=Normal=] [=user origin|user=] declarations
				<li>[=Normal=] [=user-agent origin|user agent=] declarations
			</ol>

			Declarations from <a>origins</a> earlier in this list win over declarations from later <a>origins</a>.

		<dt id='cascade-context'>Context
		<dd>
			A document language can provide for blending [=declarations=] sourced
			from different <dfn local-lt="context">encapsulation contexts</dfn>,
			such as the nested [=tree contexts=] of [=shadow trees=] in the [[!DOM]].

			When comparing two declarations
			that are sourced from different [=encapsulation contexts=],
			then for [=normal=] rules
			the declaration from the outer context wins,
			and for [=important=] rules
			the declaration from the inner context wins.
			For this purpose,
			[[DOM]] [=tree contexts=] are considered to be nested
			in [=shadow-including tree order=].

			Note: This effectively means that
			[=normal=] declarations belonging to an [=encapsulation context=]
			can set defaults that are easily overridden by the outer context,
			while [=important=] declarations belonging to an [=encapsulation context=]
			can enforce requirements that cannot be overridden by the outer context.

		<dt id='style-attr'>The Style Attribute
		<dd>
			Separately for [=normal=] and [=important=] [=declarations=],
			declarations that are attached directly to an element
			(such as the <a href="https://www.w3.org/TR/css-style-attr/#interpret">contents of a style attribute</a>)
			rather than indirectly mapped by means of a style rule selector
			take precedence over declarations the same [=importance=]
			that are mapped via style rule.

		<dt id='cascade-layering'>Layers
		<dd>
			[=Declarations=] within each [=origin=] and [=context=]
			can be explicitly assigned to a [=cascade layer=].
			For the purpose of this step,
			any declaration not assigned to an explicit layer is added to an implicit final layer.

			Cascade layers (like declarations) are sorted by order of appearance,
			see [[#layer-ordering]].
			When comparing declarations that belong to different layers,
			then for [=normal=] rules the declaration whose [=cascade layer=] is latest in the layer order wins,
			and for [=important=] rules the declaration whose [=cascade layer=] is earliest wins.

			Note: This follows the same logic used for precedence of [=normal=] and [=important=] [=origins=],
			thus the ''!important'' flag maintains the same “override” purpose in both settings.

		<dt id='cascade-proximity-strong'><dfn>Strong Scoping Proximity</dfn>
		<dd>
			If two declarations both have elements
			selected by scoped descendant relationships
			applying [=strong scoping proximity=],
			then the declaration with the fewest generational hops
			between the ancestor/descendant element pair wins.

			If multiple such pairs are represented,
			their [=strong scoping proximity=] weights are compared
			from innermost scoping relationship to outermost scoping relationship
			(with any missing pairs weighted as infinity).

		<dt id='cascade-specificity'>Specificity
		<dd>
			The <a href="https://www.w3.org/TR/selectors/#specificity">Selectors module</a> [[!SELECT]] describes how to compute the specificity of a selector.
			Each declaration has the same specificity as the style rule it appears in.
			The declaration with the highest specificity wins.

		<dt id='cascade-proximity-weak'><dfn>Weak Scoping Proximity</dfn>
		<dd>
			If two declarations both have elements
			selected by scoped descendant relationships
			applying [=weak scoping proximity=],
			then the declaration with the fewest generational hops
			between the ancestor/descendant element pair wins.

			If multiple such pairs are represented,
			their [=weak scoping proximity=] weights are compared
			from innermost scoping relationship to outermost scoping relationship
			(with any missing pairs weighted as infinity).

		<dt id='cascade-order'>Order of Appearance
		<dd>
			The last declaration in document order wins.
			For this purpose:

			<ul>
				<li>Style sheets are ordered as in <a href="https://drafts.csswg.org/cssom/#documentorshadowroot-final-css-style-sheets">final CSS style sheets</a>.
				<li>Declarations from <a at-rule lt="@import">imported style sheets</a>
					are ordered as if their style sheets were substituted in place of the ''@import'' rule.
				<li>Declarations from style sheets independently linked by the originating document
					are treated as if they were concatenated in linking order,
					as determined by the host document language.
				<li>Declarations from style attributes
					are ordered according to the document order of the element the style attribute appears on,
					and are all placed after any style sheets.
					[[!CSSSTYLEATTR]]
			</ul>
	</dl>

	Issue(6790): Does <dfn>scope proximity</dfn> belong above or below specificity in the cascade?

	The <dfn export>output of the cascade</dfn>
	is a (potentially empty) sorted list of <a>declared values</a> for each property on each element.


<h3 id='cascading-origins'>
Cascading Origins</h3>

	Issue: [[css-cascade-5#cascading-origins]]

	<dfn id=origin export local-lt="origin">cascade origin</dfn>

<h3 id='importance'>
Important Declarations: the ''!important'' annotation</h3>

	Issue: [[css-cascade-5#importance]]

	<dfn export local-lt="importance">important</dfn>
	<dfn>normal</dfn>

<h3 id='layering'>
Cascade Layers</h3>

	Issue: [[css-cascade-5#layering]]

<h4 id="layer-ordering">
Layer Ordering</h4>

	Issue: [[css-cascade-5#layer-ordering]]


<!--
 ██████   ██████   ███████  ████████  ████ ██    ██  ██████
██    ██ ██    ██ ██     ██ ██     ██  ██  ███   ██ ██    ██
██       ██       ██     ██ ██     ██  ██  ████  ██ ██
 ██████  ██       ██     ██ ████████   ██  ██ ██ ██ ██   ████
      ██ ██       ██     ██ ██         ██  ██  ████ ██    ██
██    ██ ██    ██ ██     ██ ██         ██  ██   ███ ██    ██
 ██████   ██████   ███████  ██        ████ ██    ██  ██████
-->

<h3 id='scoped-styles' oldids="scope-atrule">
Scoping Styles: the ''@scope'' rule</h3>

	A <dfn>scope</dfn> is a subtree or fragment of a document,
	which can be used by selectors for more targeted matching.
	A [=scope=] is formed by determining:

	* The [=scoping root=] [=node=],
		which acts as the upper bound of the scope,
		and optionally:
	* The <dfn>scoping limit</dfn> elements,
		which act as the lower bounds.

	An element is <dfn>in scope</dfn> if:
	* It is an [=inclusive descendant=] of the [=scoping root=], and
	* It is not an [=inclusive descendant=] of a [=scoping limit=].

	Note: In contrast to [[CSS-SCOPING-1#shadow-dom|Shadow Encapsulation]],
	which describes a persistent one-to-one relationship in the DOM
	between a [=shadow host=] and its nested [=shadow tree=],
	multiple overlapping [=scopes=] can be defined in relation to the same elements.

	Scoped styles are described in CSS using
	the <dfn>@scope</dfn> [=block at-rule=],
	which declares a [=scoping root=] and optional [=scoping limits=]
	associated with a set of [=style rules=].

	<div class=example>
		For example,
		an author might have wide-reaching color-scheme scopes,
		which overlap more narrowly-scoped design patterns
		such as a media object.
		The selectors in the ''@scope'' rule
		establish [=scoping root=] and optional [=scoping limit=] elements,
		while the nested selectors only match elements
		that are [=in scope|in a resulting scope=]:

		<pre highlight=css>
		@scope (.light-scheme) {
		  /* Only match links inside a light-scheme */
		  a { color: darkmagenta; }
		}

		@scope (.dark-scheme) {
		  /* Only match links inside a dark-scheme */
		  a { color: plum; }
		}

		@scope (.media-object) {
		  /* Only match author images inside a media-object */
		  .author-image { border-radius: 50%; }
		}
		</pre>
	</div>

	<div class=example>
		By providing [=scoping limits=],
		an author can limit matching more deeply nested descendants.
		For example:

		<pre highlight=css>
		@scope (.media-object) to (.content > *) {
		  img { border-radius: 50%; }
		  .content { padding: 1em; }
		}
		</pre>

		The ''img'' selector will only match image tags that are in a DOM fragment
		starting with any ''.media-object'',
		and including all descendants up to
		any intervening children of the ''.content'' class.
	</div>

	Issue: Should scoping limits be added to the definition of [=scoped selectors=]?


<h4 id="scope-effects">
Effects of ''@scope''</h4>

	The ''@scope'' [=at-rule=] has three primary effects
	on the [=style rules=] it contains:

	* The [=style rules=] in an ''@scope'' <<stylesheet>>
		are [=scoped style rules=].

	* The '':scope'' selector is defined to match
		the ''@scope'' rule’s [=scoping root=].
		The ''&'' selector is defined to represent
		the selector representing the [=scoping root=]
		(the <<scope-start>> selector),
		or else '':scope'' if no selector was specified.

	* The [=cascade=] prioritizes declarations
		with a [=scope proximity|more proximate=] [=scoping root=],
		regardless of specificity or source order
		by applying [=weak scoping proximity=]
		between the [=scoping root=] and the [=subject=] of each [=scoped style rule=].
		<!-- This causes declarations [insert appropriate sentence from issue below]. -->

	Issue(6790): Should ''@scope'' use strong or weak scoping proximity?
	[=Strong scoping proximity=] causes declarations to be weighted more strongly
	by scope proximity than by their selector’s specificity.
	[=Weak scoping proximity=] causes declarations of the same specificity
	to be weighted by proximity to their scoping root
	before falling back to source ordering,
	but declarations of higher specificity win over more tightly-scoped declarations.
	The Working Group currently leans towards weak proximity,
	and recommends that as a starting point for prototypes.

	Note: Unlike <a href="https://www.w3.org/TR/css-nesting/">Nesting</a>,
	selectors within an ''@scope'' rule
	do not acquire the specificity of any parent selector(s) in the ''@scope'' prelude.

	<div class=example>
		The following selectors have the same specificity (0,0,1):

		<pre highlight=css>
		@scope (#hero) {
		  img { border-radius: 50%; }
		}

		:where(#hero) img { border-radius: 50%; }
		</pre>

		The additional specificity of the ''#hero'' selector
		is not applied to the specificity of the scoped selector.
		However, since one <{img}> selector is scoped,
		that selector is weighted more strongly in the cascade
		with the application of [=weak scoping proximity=].
	</div>

	<div class=example>
		Many existing tools implement "scoped styles"
		by applying a unique class or attribute
		to every element in a given scope
		or "single file component."
		In this example there are two scopes
		(<code>main-component</code> and <code>sub-component</code>)
		and every element is marked as part of one or both scopes
		using the <code>data-scope</code> attribute:

		<pre class=lang-html>
		&lt;section data-scope="main-component">
		  &lt;p data-scope="main-component">...&lt;p>

		  &lt;!-- sub-component root is in both scopes -->
		  &lt;section data-scope="main-component sub-component">
		    &lt;!-- children are only in the inner scope -->
		    &lt;p data-scope="sub-component">...&lt;p>
		  &lt;/section>
		&lt;/section>
		</pre>

		Those custom scope attributes are then
		appended to every single selector in CSS:

		<pre highlight=css>
		p[data-scope~='main-component'] { color: red; }
		p[data-scope~='sub-component'] { color: blue; }

		/* both sections are part of the outer scope */
		section[data-scope~='main-component'] { background: snow; }

		/* the inner section is also part of the inner scope */
		section[data-scope~='sub-component'] { color: ghostwhite; }
		</pre>

		Using the ''@scope'' rule,
		authors and tools can replicate similar behavior
		with the unique attribute or class
		applied only to the [=scoping roots=]:

		<pre class=lang-html>
		&lt;section data-scope="main-component">
		  &lt;p>...&lt;p>
		  &lt;section data-scope="sub-component">
		    &lt;p>...&lt;p>
		  &lt;/section>
		&lt;/section>
		</pre>

		Then the class or attribute can be used
		for establishing both upper and lower boundaries.
		Elements matched by a lower boundary selector
		are excluded from the resulting scope,
		which allows authors to create non-overlapping scopes by default:

		<pre highlight=css>
		@scope ([data-scope='main-component']) to ([data-scope]) {
		  p { color: red; }

		  /* only the outer section is part of the outer scope */
		  section { background: snow; }
		}

		@scope ([data-scope='sub-component']) to ([data-scope]) {
		  p { color: blue; }

		  /* the inner section is only part of the inner scope */
		  section { color: ghostwhite; }
		}
		</pre>

		However, authors can use the child combinator
		and universal selector to create scope boundaries that overlap,
		such that the inner scope root is part of both scopes:

		<pre highlight=css>
		@scope ([data-scope='main-component']) to ([data-scope] > *) {
		  p { color: red; }

		  /* both sections are part of the outer scope */
		  section { background: snow; }
		}
		</pre>
	</div>

<h4 id="scope-syntax">
Syntax of ''@scope''</h4>

	The syntax of the ''@scope'' rule is:

	<pre class="prod def">
	@scope [(<<scope-start>>)]? [to (<<scope-end>>)]? {
	  <<stylesheet>>
	}
	</pre>

	where:

	* <dfn><<scope-start>></dfn> is a <<forgiving-selector-list>> [=selector=]
		used to identify the [=scoping root=](s).
	* <dfn><<scope-end>></dfn> is a <<forgiving-selector-list>> [=selector=]
		used to identify any [=scoping limits=].
	* the <<stylesheet>> represents the [=scoped style rules=].

	[=Pseudo-elements=] cannot be [=scoping roots=] or [=scoping limits=];
	they are invalid both within <<scope-start>> and <<scope-end>>.

<h4 id="scoped-rules">
Scoped Style Rules</h4>

	<dfn>Scoped style rules</dfn> differ from non-scoped rules
	in the following ways:

	* Their selectors can only match elements that are [=in scope=].
		(This only applies to the [=subject=];
		the rest of the selector can match unrestricted.)

	* They accept a <<relative-selector-list>> as their prelude
		(rather than just a <<selector-list>>).
		Such [=relative selectors=]
		are relative to '':scope''.

	* Any selector in the <<relative-selector-list>>
		that does not start with a [=combinator=]
		but does [=contain the nesting selector=] or the '':scope'' selector,
		is interpreted as a non-[=relative selector=]
		(but the [=subject=] must still be [=in scope=] to match).

	<div class="example">
		By default, selectors in a [=scoped style rule=]
		are [=relative selectors=],
		with the [=scoping root=] and [=descendant combinator=]
		implied at the start.
		The following selectors will match the same elements:

		<pre highlight=css>
		@scope (#my-component) {
		  p { color: green; }
		  :scope p { color: green; }
		}
		</pre>

		Authors can adjust the implied relationship
		by adding an explicit combinator:

		<pre highlight=css>
		@scope (#my-component) {
		  > p { color: green; }
		  :scope > p { color: green; }
		}
		</pre>

		Authors can also target or explicitly position
		the [=scoping root=] in a selector
		by including either '':scope'' or ''&'' in a given selector:

		<pre highlight=css>
		@scope (#my-component) {
		  :scope { border: thin solid; }
		  & { border: thin solid; }

		  main :scope p { color: green; }
		  main & p { color: green; }
		}
		</pre>

		While the '':scope'' or ''&'' selectors
		can both refer to the [=scoping root=],
		they have otherwise different meanings in this context:

		: Differences in selector matching
		:: The '':scope'' selector will only match the [=scoping root=] itself,
			while the ''&'' selector is able to match any element
			that is matched by the <<scope-start>> selector list.
		: Differences in selector specificity
		:: The '':scope'' selector has a specificity
			equal to other pseudo-classes,
			while the ''&'' selector has the specificity
			equal to the most specific selector in <<scope-start>>.
	</div>

<h4 id="scope-limits">
Identifying Scoping Roots and Limits</h4>

	A ''@scope'' rule produces one or more [=scopes=] as follows:

	: Finding the [=scoping root=](s)
	:: For each element matched by <<scope-start>>,
		create a [=scope=] using that element as the [=scoping root=].
		If no <<scope-start>> is specified,
		the [=scoping root=] is the [=parent element=] of the [=owner node=]
		of the stylesheet where the ''@scope'' rule is defined.
		(If no such element exists,
		then the [=scoping root=] is the [=root=] of the containing [=node tree=].)
		Any '':scope'' or ''&'' selectors in <<scope-start>>
		are interpreted as defined for its outer context.

	: Finding any [=scoping limits=]
	:: For each [=scope=] created by a [=scoping root=],
		its [=scoping limits=] are set to all elements
		that are [=in scope=] and that match <<scope-end>>,
		interpreting '':scope'' and ''&''
		exactly as in [=scoped style rules=].

	<div class=example>
		Authors can establish local scoping
		for <{style}> elements by leaving out the <<scope-start>> selector.
		For example:

		<pre class=lang-html>
		&lt;div>
		  &lt;style>
		    @scope {
		      p { color: red; }
		    }
		  &lt;/style>
		  &lt;p>this is red&lt;/p>
		&lt;/div>
		&lt;p>not red&lt;/p>
		</pre>

		That would be equivalent to:

		<pre class=lang-html>
		&lt;div id="foo">
		  &lt;style>
		    @scope (#foo) {
		      p { color: red; }
		    }
		  &lt;/style>
		  &lt;p>this is red&lt;/p>
		&lt;/div>
		&lt;p>not red&lt;/p>
		</pre>
	</div>

	<div class=example>
		[=Scoping limits=] can use the '':scope'' pseudo-class
		to require a specific relationship to the [=scoping root=]:

		<pre highlight=css>
		/* .content is only a limit when it is a direct child of the :scope */
		@scope (.media-object) to (:scope > .content) { ... }
		</pre>

		[=Scoping limits=] can also reference elements outside their [=scoping root=]
		by using '':scope''.
		For example:

		<pre highlight=css>
		/* .content is only a limit when the :scope is inside .sidebar */
		@scope (.media-object) to (.sidebar :scope .content) { ... }
		</pre>
	</div>

<h4 id="scope-scope">
Scope Nesting</h4>

	''@scope'' rules can be nested.
	In this case, just as with the nested style rules,
	the selectors of the inner ''@scope''
	(including those defining its [=scope=])
	are [=scoped selectors|scoped by=]
	the selectors of the outer one.

	<div class=example>
		When nesting ''@scope'' rules inside other ''@scope'' rules,
		or inside other selectors,
		the <<scope-start>> selector is
		[=relative selector|relative to=] the nesting context,
		while the <<scope-end>> and any [=scoped style rules=]
		are [=relative selector|relative to=] the [=scoping root=]
		For example, the following code:

		<pre highlight=css>
		@scope (.parent-scope) {
		  @scope (:scope > .child-scope) to (:scope .limit) {
		    :scope .content {
		      color: red;
		    }
		  }
		}
		</pre>

		is equivalent to:

		<pre highlight=css>
		@scope (.parent-scope > .child-scope) to (.parent-scope > .child-scope .limit) {
		  .parent-scope > .child-scope .content {
		    color: red;
		  }
		}
		</pre>
	</div>

	Global name-defining [=at-rules=]
	such as ''@keyframes'' or ''@font-face'' or ''@layer''
	that are defined inside ''@scope'' are valid,
	but are not scoped or otherwise affected
	by the enclosing ''@scope'' rule.
	However, any [=style rules=] contained by such rules
	(e.g. within ''@layer'')
	are [=scoped style rules|scoped=].

<h3 id="scope-combinator">
Scoped Descendant Combinator</h3>

	The <dfn export>scoped descendant combinator</dfn>
	describes a descendant relationship between two elements.
	A selector of the form ''A >> B'' represents
	an element <code>B</code> that is an arbitrary descendant
	of some ancestor element <code>A</code>.

	This combinator differs from the [=descendant combinator=]
	in that it applies [=weak scoping proximity=]
	to the relationship between <css>A</css> and <css>B</css>.
	It does not change the '':scope'' element.

	ISSUE: Should the [=scoped descendant combinator=]
	use strong or weak scoping proximity?
	Should it even exist?
	It's defined here to work the way many people expected
	the regular [=descendant combinator=] to work...

	<div class="example">
		This means that style rules using the [=scoped descendant combinator=]
		are sorted by specificity just like the regular [=descendant combinator=],
		except that when their specificities are equal
		the more tightly-scoped declaration wins.

		In this example
		the <code>&lt;a></code> element's color will be determined
		by the nearest ancestor with either
		a ''light-scheme'' or ''dark-scheme'' class.
		(If the descendant selector had been used,
		its color would always be ''plum'',
		because it is later in the source order.)

		<pre>
			.light-scheme >> a { color: darkmagenta; }
			.dark-scheme >> a { color: plum; }
		</pre>

		However if the <code>&lt;a></code> element has a ''light-scheme''
		ancestor and is focused,
		its color will be ''teal''
		even if it has a nearer ''dark-scheme'' ancestor,
		because there is no equivalent ''dark-scheme'' rule.

		<pre>
			.light-scheme >> a:focus { color: teal; }
		</pre>
	</div>

<h3 id="preshint">
Precedence of Non-CSS Presentational Hints</h3>

	Issue: [[css-cascade-5#layering]]

<!--
 ██████   ██████   ██████   ███████  ██     ██
██    ██ ██    ██ ██    ██ ██     ██ ███   ███
██       ██       ██       ██     ██ ████ ████
██        ██████   ██████  ██     ██ ██ ███ ██
██             ██       ██ ██     ██ ██     ██
██    ██ ██    ██ ██    ██ ██     ██ ██     ██
 ██████   ██████   ██████   ███████  ██     ██
-->

CSSOM {#cssom}
==============


<h3 id="the-cssscoperule-interface">
The <code>CSSScopeRule</code> interface</h3>

	The {{CSSScopeRule}} interface represents the ''@scope'' rule:

	<pre class='idl' export>
	[Exposed=Window]
	interface CSSScopeRule : CSSGroupingRule {
	  readonly attribute CSSOMString? start;
	  readonly attribute CSSOMString? end;
	};
	</pre>

	<dl class='idl-attributes'>
		<dt><code>start</code> of type <code>CSSOMString</code>
		<dd>The <code>start</code> attribute
		returns the result of serializing the <<scope-start>> of the rule
		(without the enclosing parentheses),
		or null if there is no <<scope-start>>.

		<dt><code>end</code> of type <code>CSSOMString</code>
		<dd>The <code>end</code> attribute
		returns the result of serializing the <<scope-end>> of the rule
		(without the enclosing parentheses),
		or null if there is no <<scope-end>>.
	</dl>

<!--
████████ ████████  ██████
██          ██    ██    ██
██          ██    ██
██████      ██    ██
██          ██    ██
██          ██    ██    ██
████████    ██     ██████
-->

<h2 id="changes">
Changes</h2>

This appendix is <em>informative</em>.

<h3 id="changes-2022-08">
Changes since the 21 December 2021 First Public Working Draft</h3>

	Significant changes since the
	<a href="https://www.w3.org/TR/2021/WD-css-cascade-6-20211221/">21 December 2021 First Public Working Draft</a> include:

	* Clarified ''@scope'' effects on nested '':scope'' and ''&'' selectors.
		(<a href="https://github.com/w3c/csswg-drafts/issues/8377">Issue 8377</a>)

	* Removed ''@scope'' prelude from specificity calculation.
		(<a href="https://github.com/w3c/csswg-drafts/issues/8500">Issue 8500</a>)

	* Specified how name-defining [=at-rules=] behave in ''@scope''.
		(<a href="https://github.com/w3c/csswg-drafts/issues/6895">Issue 6895</a>)

	* Added the {{CSSScopeRule}} interface.
		(<a href="https://github.com/w3c/csswg-drafts/issues/8626">Issue 8626</a>)

	* Added implicit scopes by making ''<<scope-start>>'' optional.
		(<a href="https://github.com/w3c/csswg-drafts/issues/6606">Issue 6606</a>)

	* Disallowed [=pseudo-elements=] in the ''@scope'' prelude.
		(<a href="https://github.com/w3c/csswg-drafts/issues/7382">Issue 7382</a>)

	* Removed selector scoping notation.
		(<a href="https://github.com/w3c/csswg-drafts/issues/7709">Issue 7709</a>)

	* [=Scoping limit=] elements are excluded from the resulting [=scope=].
		(<a href="https://github.com/w3c/csswg-drafts/issues/6577">Issue 6577</a>)

<h3 id="additions-l5">
Additions Since Level 5</h3>

	The following features have been added since
	<a href="https://www.w3.org/TR/css-cascade-5/">Level 5</a>:

	* The definition of a [=scope=],
		as described by a combination of <<scope-start>> and <<scope-end>> selectors.
	* The in-scope ('':in()'') pseudo-class for selecting with lower-boundaries
	* The ''@scope'' rule for creating scoped stylesheets
	* The definition of [=scope proximity=] in the cascade


<h3 id="additions-l4">
Additions Since Level 4</h3>

	The following features have been added since
	<a href="https://www.w3.org/TR/css-cascade-4/">Level 4</a>:

	* Added [=cascade layers=] to the [=cascade=] sort criteria
		(and defined style attributes as a distinct step of the [=cascade=] sort criteria
		so that they interact appropriately).
	* Introduced the ''@layer'' rule for defining cascade layers.
	* Added ''layer''/''layer()'' option to ''@import'' definition.
	* Introduced the ''revert-layer'' keyword for rolling back values to previous layers.

<h3 id="additions-l3">
Additions Since Level 3</h3>

	The following features have been added since
	<a href="https://www.w3.org/TR/css-cascade-3/">Level 3</a>:

	* Introduced ''revert'' keyword, for rolling back the cascade.
	* Introduced ''supports()'' syntax for supports-conditional ''@import'' rules.
	* Added [=encapsulation context=] to the [=cascade=] sort criteria
		to accommodate Shadow DOM. [[DOM]]
	* Defined the property two aliasing mechanisms CSS uses to support legacy syntaxes. See [[css-cascade-4#aliasing]].
<!--
	* Added definition of how scoped styles would cascade
		(deferred from Level 3)
-->

<h3 id="changes-2">
Additions Since Level 2</h3>

	The following features have been added since
	<a href="http://www.w3.org/TR/CSS2/cascade.html">Level 2</a>:

	<ul>
		<li>The 'all' shorthand
		<li>The ''initial'' keyword
		<li>The ''unset'' keyword
		<li>Incorporation of animations and transitions into the <a>cascade</a>.
	</ul>

<h2 class="no-num" id="acknowledgments">Acknowledgments</h2>

	David Baron,
	Tantek Çelik,
	Keith Grant,
	Giuseppe Gurgone,
	Theresa O'Connor,
	Florian Rivoal,
	Noam Rosenthal,
	Simon Sapin,
	Jen Simmons,
	Nicole Sullivan,
	Lea Verou,
	and Boris Zbarsky
	contributed to this specification.

<h2 id="privacy">
Privacy Considerations</h2>

	* User preferences and UA defaults expressed via application of style rules
		are exposed by the cascade process,
		and can be inferred from the computed styles they apply to a document.

<h2 id="security">
Security Considerations</h2>

	* The cascade process does not distinguish between same-origin and cross-origin stylesheets,
		enabling the content of cross-origin stylesheets to be inferred
		from the computed styles they apply to a document.

	* The ''@import'' rule does not apply the [=CORS protocol=] to loading cross-origin stylesheets,
		instead allowing them to be freely imported and applied.

	* The ''@import'' rule assumes that resources without <a href="https://html.spec.whatwg.org/multipage/urls-and-fetching.html#content-type"><code>Content-Type</code> metadata</a>
		(or any same-origin file if the host document is in quirks mode)
		are <code>text/css</code>,
		potentially allowing arbitrary files to be imported into the page
		and interpreted as CSS,
		potentially allowing sensitive data to be inferred from the computed styles they apply to a document.