inert attribute was originally specced as part of the
<dialog> element specification.
<dialog> required the concept of
inert to be defined in order to describe the blocking behaviour of dialogs,
inert attribute was introduced “so you could do
The attribute was later removed as it was argued that its only use case was subsumed by
<dialog>. However, later discussion on the original bug proposed several use cases which could not be handled, or only handled poorly, using
The spec for the
with the existing definition of “inert” already specified,
is extremely straightforward:
inertattribute is a boolean attribute that indicates, by its presence, that the element is to be made inert.
When an element has an
inertattribute, the user agent must mark that element as inert.
By default, there is no visual indication of a subtree being inert. Authors are encouraged to clearly mark what parts of their document are active and which are inert, to avoid user confusion. In particular, it is worth remembering that not all users can see all parts of a page at once; for example, users of screen readers, users on small devices or with magnifiers, and even users just using particularly small windows might not be able to see the active part of a page and may get frustrated if inert sections are not obviously inert. For individual controls, the
disabledattribute is probably more appropriate.
inerthas on the subtree of the element marked as
inert, however it is implied by the note that
inertcauses the entire subtree of the element with the
inertattribute to be made inert. The polyfill makes the assumption that the entire subtree becomes inert.
The existing description of inert is not specific about where pointer events which would have been targeted to an element in an inert subtree should go. (See also: discussion on the WHATWG pull request.) Does the event:
pointer-events would suggest (ii). The polyfill uses
pointer-events: none and so models its behaviour.
inertas a primitive
Developers find themselves in situations where they’d like to be able to mark a part of the page “un-tabbable”. Rob Dodson lays out one such example in his article “Building better accessibility primitives”:
One problem: to [achieve a performance optimisation for animation] we must leave the drawer in the DOM at all times. Meaning its focusable children are just sitting there offscreen, and as the user is tabbing through the page eventually their focus will just disappear into the drawer and they won’t know where it went. I see this on responsive websites all the time. This is just one example but I’ve also run into the need to disable tabindex when I’m animating between elements with opacity: 0, or temporarily disabling large lists of custom controls, and as others have pointed out, you’d hit if you tried to build something like coverflow where you can see a preview of the next element but can’t actually interact with it yet.
inert would also allow slightly more straightforward polyfilling of both
and the proposed, more primitive
based on this polyfill,
for an example of how
inert may be used for this purpose.
Currently, since there is no way to express the “inertness” concept,
polyfilling these APIs requires both focus event trapping
to avoid focus cycling out of the dialog/blocking element
(and thus as a side effect may prevent focus from walking out of the page at all)
and a tree-walk
(usually neglected by developers)
aria-hidden on all sibling elements of the dialog or blocking element.
On the implementer side,
the vast majority of work involved in implementing
inert is a necessary pre-cursor to both
so by implementing
implementers may get useful functionality into the hands of developers sooner while still laying the groundwork for one or both of these more complex APIs.
Temporarily offscreen/hidden content
As discussed in the article, there are a range of circumstances in which case it’s desirable to add content to the DOM to be rendered but remain offscreen.
In these cases, without
inert, authors are forced to choose between
an accessible experience for keyboard and assistive technology users,
or the factors (such as performance) which make offscreen rendering desirable -
or, performing all the contortions necessary to keep the offscreen content functionally “inert”.
These cases include:
opacityto zero, and animates transitions between items;
On-screen but non-interactive content
Occasionally, UI designs require that certain content be visible or partially visible,
but clearly non-interactive.
Typically, this content is made non-interactive for pointer device users
either via a semi-transparent overlay which provides a visual cue as well as intercepting pointer events,
or via using
In these cases developers are once again required to perform contortions in order to ensure that this content is not an accessibility issue.
These cases include:
A slide show or “cover flow” style carousel may have non-active items partially visible, as a preview - they may be transformed or partially obscured to indicate that they are non-interactive.
Form content which is not currently relevant, e.g. fading out and disabling the “Shipping Address” fields when the “Same as billing address” checkbox has been checked.
A CSS property?
inert encompasses the behaviour of at least two other things which are CSS properties -
pointer-events: none and
user-select: none, plus another attribute,
These behaviours, along with the currently near-impossible to achieve behaviour of preventing tabbing/programmatic focus, are very frequently applied together
(or if one, such as
aria-hidden, is omitted, it is more often through lack of awareness than deliberate).
There is scope for a more primitive CSS property to “explain” the ability of
inert to prevent focus, however that could easily coexist with the
blockingElements (or, potentially, a single
blockingElement) represents roughly the opposite use case to
a per-document, single element which blocks the document, analogous to the blocking behaviour of a modal dialog.
It’s not always the case that we will want a single subtree to be non-inert. Ideally, we would have both concepts available;
inert allows reasonable approximation of
blockingElements whereas the reverse is not true.
inert, it’s most straightforward to insert a non-_inert_ element as a sibling element to the main page content, and then use
inertto mark the main page content as inert. More generally, all siblings of the desired “blocking” element, plus all siblings of all of its ancestors, could be marked inert.
A programmatic API?
This would require waiting for script execution before parts of the page became inert, which can take some time.