HTML

The attribute's missing value default is the Not Hidden state, and its invalid value default and empty value default are both the Hidden state.

The hidden getter steps are:

1. If the hidden attribute is in the Hidden Until Found state, then return " until-found ".

2. If the hidden attribute is set, then return true.

3. Return false.

The hidden setter steps are:

1. If the given value is a string that is an ASCII case-insensitive match for " until-found ", then set the hidden attribute to " until-found ".

2. Otherwise, if the given value is false, then remove the hidden attribute.

3. Otherwise, if the given value is the empty string, then remove the hidden attribute.

4. Otherwise, if the given value is null, then remove the hidden attribute.

5. Otherwise, if the given value is 0, then remove the hidden attribute.

6. Otherwise, if the given value is NaN, then remove the hidden attribute.

7. Otherwise, set the hidden attribute to the empty string.

The ancestor revealing algorithm given a node target is:

1. Let ancestorsToReveal be « ».

2. Let ancestor be target .

3. While ancestor has a parent node within the flat tree :

   1. If ancestor has a hidden attribute in the Hidden Until Found state, then append ( ancestor , " until-found ") to ancestorsToReveal .

   2. If ancestor is slotted into the second slot of a details element which does not have an open attribute, then append ( ancestor 's parent node, " details ") to ancestorsToReveal .

   3. Set ancestor to the parent node of ancestor within the flat tree .

4. For each ( ancestorToReveal , revealType ) of ancestorsToReveal :

   1. If ancestorToReveal is not connected , then return.

   2. If revealType is " until-found ":

      1. If ancestorToReveal 's hidden attribute is not in the Hidden Until Found state, then return.

      2. Fire an event named beforematch at ancestorToReveal with the bubbles attribute initialized to true.

      3. If ancestorToReveal is not connected , then return.

      4. If ancestorToReveal 's hidden attribute is not in the Hidden Until Found state, then return.

      5. Remove the hidden attribute from ancestorToReveal .

   3. Otherwise:

      1. Assert : revealType is " details ".

      2. If ancestorToReveal has an open attribute, then return.

      3. Set ancestorToReveal 's open attribute to the empty string.

When a user agent determines that the system visibility state for traversable navigable traversable has changed to newState , it must run the following steps:

1. Let navigables be the inclusive descendant navigables of traversable 's active document .

2. For each navigable of navigables in what order? :

   1. Let document be navigable 's active document .

   2. Queue a global task on the user interaction task source given document 's relevant global object to update the visibility state of document with newState .

The visibilityState getter steps are to return this 's visibility state .

The hidden getter steps are to return true if this 's visibility state is " hidden ", otherwise false.

To update the visibility state of Document document to visibilityState :

1. If document 's visibility state equals visibilityState , then return.

2. Set document 's visibility state to visibilityState .

3. Queue a new VisibilityStateEntry whose visibility state is visibilityState and whose timestamp is the current high resolution time given document 's relevant global object .

4. Run the screen orientation change steps with document . [SCREENORIENTATION]

5. Run the view transition page visibility change steps with document .

6. Run any page visibility change steps which may be defined in other specifications, with visibility state and document .

   It would be better if specification authors sent a pull request to add calls from here into their specifications directly, instead of using the page visibility change steps hook, to ensure well-defined cross-specification call order. As of the time of this writing the following specifications are known to have page visibility change steps , which will be run in an unspecified order: Device Posture API and Web NFC . [DEVICEPOSTURE] [WEBNFC]

7. Fire an event named visibilitychange at document , with its bubbles attribute initialized to true.

The name getter steps are to return this 's visibility state .

The entryType getter steps are to return " visibility-state ".

The startTime getter steps are to return this 's timestamp .

The duration getter steps are to return zero.

A Document document is blocked by a modal dialog subject if subject is the topmost dialog element in document 's top layer . While document is so blocked, every node that is connected to document , with the exception of the subject element and its flat tree descendants, must become inert .

subject can additionally become inert via the inert attribute, but only if specified on subject itself (i.e., subject escapes inertness of ancestors); subject 's flat tree descendants can become inert in a similar fashion.

For the purpose of tracking user activation, each Window W has two relevant values:

• A last activation timestamp , which is either a DOMHighResTimeStamp , positive infinity (indicating that W has never been activated), or negative infinity (indicating that the activation has been consumed ). Initially positive infinity.

• A last history-action activation timestamp , which is either a DOMHighResTimeStamp or positive infinity, initially positive infinity.

We then have the following boolean user activation states for W :

Sticky activation

When the current high resolution time given W is greater than or equal to the last activation timestamp in W , W is said to have sticky activation .

This is W 's historical activation state, indicating whether the user has ever interacted in W . It starts false, then changes to true (and never changes back to false) when W gets the very first activation notification .

Transient activation

When the current high resolution time given W is greater than or equal to the last activation timestamp in W , and less than the last activation timestamp in W plus the transient activation duration , then W is said to have transient activation .

This is W 's current activation state, indicating whether the user has interacted in W recently. This starts with a false value, and remains true for a limited time after every activation notification W gets.

The transient activation state is considered expired if it becomes false because the transient activation duration time has elapsed since the last user activation. Note that it can become false even before the expiry time through an activation consumption .

History-action activation

When the last history-action activation timestamp of W is not equal to the last activation timestamp of W , then W is said to have history-action activation .

This is a special variant of user activation, used to allow access to certain session history APIs which, if used too frequently, would make it harder for the user to traverse back using browser UI . It starts with a false value, and becomes true whenever the user interacts with W , but is reset to false through history-action activation consumption . This ensures such APIs cannot be used multiple times in a row without an intervening user activation. But unlike transient activation , there is no time limit within which such APIs must be used.

When a user interaction causes firing of an activation triggering input event in a Document document , the user agent must perform the following activation notification steps before dispatching the event:

1. Assert : document is fully active .

2. Let windows be « document 's relevant global object ».

3. Extend windows with the active window of each of document 's ancestor navigables .

4. Extend windows with the active window of each of document 's descendant navigables , filtered to include only those navigables whose active document 's origin is same origin with document 's origin .

5. For each window in windows :

   1. Set window 's last activation timestamp to the current high resolution time .

   2. Notify the close watcher manager about user activation given window .

An activation triggering input event is any event whose isTrusted attribute is true and whose type is one of:

• " keydown ", provided the key is neither the Esc key nor a shortcut key reserved by the user agent;

• " mousedown ";

• " pointerdown ", provided the event's pointerType is " mouse ";

• " pointerup ", provided the event's pointerType is not " mouse "; or

• " touchend ".

Activation consuming APIs defined in this and other specifications can consume user activation by performing the following steps, given a Window W :

1. If W 's navigable is null, then return.

2. Let top be W 's navigable 's top-level traversable .

3. Let navigables be the inclusive descendant navigables of top 's active document .

4. Let windows be the list of Window objects constructed by taking the active window of each item in navigables .

5. For each window in windows , if window 's last activation timestamp is not positive infinity, then set window 's last activation timestamp to negative infinity.

History-action activation-consuming APIs can consume history-action user activation by performing the following steps, given a Window W :

1. If W 's navigable is null, then return.

2. Let top be W 's navigable 's top-level traversable .

3. Let navigables be the inclusive descendant navigables of top 's active document .

4. Let windows be the list of Window objects constructed by taking the active window of each item in navigables .

5. For each window in windows , set window 's last history-action activation timestamp to window 's last activation timestamp .

Each Window has an associated UserActivation , which is a UserActivation object. Upon creation of the Window object, its associated UserActivation must be set to a new UserActivation object created in the Window object's relevant realm .

The userActivation getter steps are to return this 's relevant global object 's associated UserActivation .

The hasBeenActive getter steps are to return true if this 's relevant global object has sticky activation , and false otherwise.

The isActive getter steps are to return true if this 's relevant global object has transient activation , and false otherwise.

The remote end steps are:

1. Let window be the current browsing context 's active window .

2. Let consume be true if window has transient activation ; otherwise false.

3. If consume is true, then consume user activation of window .

4. Return success with data consume .

The click() method must run the following steps:

1. If this element is a form control that is disabled , then return.

2. If this element's click in progress flag is set, then return.

3. Set this element's click in progress flag .

4. Fire a synthetic pointer event named click at this element, with the not trusted flag set.

5. Unset this element's click in progress flag .

The oldState and newState attributes must return the values they are initialized to.

The source getter steps are to return the result of retargeting source against this 's currentTarget .

The command attribute must return the value it was initialized to.

The source getter steps are to return the result of retargeting source against this 's currentTarget .

A top-level traversable has system focus when it can receive keyboard input channeled from the operating system, possibly targeted at one of its active document 's descendant navigables .

A Document d is a fully active descendant of a top-level traversable with user attention when d is fully active and d 's node navigable 's top-level traversable has user attention .

The currently focused area of a top-level traversable traversable is the focusable area -or-null returned by this algorithm:

1. If traversable does not have system focus , then return null.

2. Let candidate be traversable 's active document .

3. While candidate 's focused area is a navigable container with a non-null content navigable : set candidate to the active document of that navigable container 's content navigable .

4. If candidate 's focused area is non-null, set candidate to candidate 's focused area .

5. Return candidate .

The current focus chain of a top-level traversable traversable is the focus chain of the currently focused area of traversable , if traversable is non-null, or an empty list otherwise.

An element that is the DOM anchor of a focusable area is said to gain focus when that focusable area becomes the currently focused area of a top-level traversable . When an element is the DOM anchor of a focusable area of the currently focused area of a top-level traversable , it is focused .

The focus chain of a focusable area subject is the ordered list constructed as follows:

1. Let output be an empty list .

2. Let currentObject be subject .

3. While true:

   1. Append currentObject to output .

   2. If currentObject is an area element's shape, then append that area element to output .

      Otherwise, if currentObject 's DOM anchor is an element that is not currentObject itself, then append currentObject 's DOM anchor to output .

   3. If currentObject is a focusable area , then set currentObject to currentObject 's DOM anchor 's node document .

      Otherwise, if currentObject is a Document whose node navigable 's parent is non-null, then set currentObject to currentObject 's node navigable 's parent .

      Otherwise, break .

4. Return output .

   The chain starts with subject and (if subject is or can be the currently focused area of a top-level traversable ) continues up the focus hierarchy up to the Document of the top-level traversable .

When a user activates a click focusable focusable area , the user agent must run the focusing steps on the focusable area with focus trigger set to " click ".

A node is a focus navigation scope owner if it is a Document , a shadow host , a slot , or an element which is the popover trigger of an element in the popover showing state .

Each focus navigation scope owner has a focus navigation scope , which is a list of elements. Its contents are determined as follows:

Every element element has an associated focus navigation owner , which is either null or a focus navigation scope owner . It is determined by the following algorithm:

1. If element 's parent is null, then return null.

2. If element 's parent is a shadow host , then return element 's assigned slot .

3. If element 's parent is a shadow root , then return the parent's host .

4. If element 's parent is the document element , then return the parent's node document .

5. If element is in the popover showing state and has a popover trigger set, then return element 's popover trigger .

6. Return element 's parent's associated focus navigation owner .

Then, the contents of a given focus navigation scope owner owner 's focus navigation scope are all elements whose associated focus navigation owner is owner .

A tabindex-ordered focus navigation scope is a list of focusable areas and focus navigation scope owners . Every focus navigation scope owner owner has tabindex-ordered focus navigation scope , whose contents are determined as follows:

• It contains all elements in owner 's focus navigation scope that are themselves focus navigation scope owners , except the elements whose tabindex value is a negative integer.

• It contains all of the focusable areas whose DOM anchor is an element in owner 's focus navigation scope , except the focusable areas whose tabindex value is a negative integer.

A flattened tabindex-ordered focus navigation scope is a list of focusable areas . Every focus navigation scope owner owner owns a distinct flattened tabindex-ordered focus navigation scope , whose contents are determined by the following algorithm:

1. Let result be a clone of owner 's tabindex-ordered focus navigation scope .

2. For each item of result :

   1. If item is not a focus navigation scope owner , then continue .

   2. If item is not a focusable area , then replace item with all of the items in item 's flattened tabindex-ordered focus navigation scope .

   3. Otherwise, insert the contents of item 's flattened tabindex-ordered focus navigation scope after item .

The tabindex value of an element is the value of its tabindex attribute, parsed using the rules for parsing integers . If parsing fails or the attribute is not specified, then the tabindex value is null.

The tabindex value of a focusable area is the tabindex value of its DOM anchor .

The tabIndex getter steps are:

1. Let attribute be this 's tabindex attribute.

2. If attribute is not null:

   1. Let parsedValue be the result of integer parsing attribute 's value .

   2. If parsedValue is not an error and is within the long range, then return parsedValue .

3. Return 0 if this is an a , area , button , frame , iframe , input , object , select , textarea , or SVG a element, or is a summary element that is a summary for its parent details ; otherwise 1.

To get the focusable area for a focus target that is either an element that is not a focusable area , or is a navigable , given an optional string focus trigger (default " other "), run the first matching set of steps from the following list:

If focus target is an area element with one or more shapes that are focusable areas

Return the shape corresponding to the first img element in tree order that uses the image map to which the area element belongs.

If focus target is an element with one or more scrollable regions that are focusable areas

Return the element's first scrollable region, according to a pre-order, depth-first traversal of the flat tree . [CSSSCOPING]

If focus target is the document element of its Document

Return the Document 's viewport .

If focus target is a navigable

Return the navigable 's active document .

If focus target is a navigable container with a non-null content navigable

Return the navigable container 's content navigable 's active document .

If focus target is a shadow host whose shadow root 's delegates focus is true

1. Let focusedElement be the currently focused area of a top-level traversable 's DOM anchor .

2. If focus target is a shadow-including inclusive ancestor of focusedElement , then return focusedElement .

3. Return the focus delegate for focus target given focus trigger .

For sequential focusability , the handling of shadow hosts and delegates focus is done when constructing the sequential focus navigation order . That is, the focusing steps will never be called on such shadow hosts as part of sequential focus navigation.

Otherwise

Return null.

The focus delegate for a focusTarget , given an optional string focusTrigger (default " other "), is given by the following steps:

1. If focusTarget is a shadow host and its shadow root 's delegates focus is false, then return null.

2. Let whereToLook be focusTarget .

3. If whereToLook is a shadow host , then set whereToLook to whereToLook 's shadow root .

4. Let autofocusDelegate be the autofocus delegate for whereToLook given focusTrigger .

5. If autofocusDelegate is not null, then return autofocusDelegate .

6. For each descendant of whereToLook 's descendants , in tree order :

   1. Let focusableArea be null.

   2. If focusTarget is a dialog element and descendant is sequentially focusable , then set focusableArea to descendant .

   3. Otherwise, if focusTarget is not a dialog and descendant is a focusable area , set focusableArea to descendant .

   4. Otherwise, set focusableArea to the result of getting the focusable area for descendant given focusTrigger .

      This step can end up recursing, i.e., the get the focusable area steps might return the focus delegate of descendant .

   5. If focusableArea is not null, then return focusableArea .

   It's important that we are not looking at the shadow-including descendants here, but instead only at the descendants . Shadow hosts are instead handled by the recursive case mentioned above.

7. Return null.

The above algorithm essentially returns the first suitable focusable area where the path between its DOM anchor and focusTarget delegates focus at any shadow tree boundaries.

The autofocus delegate for a focus target given a focus trigger is given by the following steps:

1. For each descendant descendant of focus target , in tree order :

   1. If descendant does not have an autofocus content attribute, then continue .

   2. Let focusable area be descendant , if descendant is a focusable area ; otherwise let focusable area be the result of getting the focusable area for descendant given focus trigger .

   3. If focusable area is null, then continue .

   4. If focusable area is not click focusable and focus trigger is " click ", then continue .

   5. Return focusable area .

2. Return null.

The focusing steps for an object new focus target that is either a focusable area , or an element that is not a focusable area , or a navigable , are as follows. They can optionally be run with a fallback target and a string focus trigger .

1. If new focus target is not a focusable area , then set new focus target to the result of getting the focusable area for new focus target , given focus trigger if it was passed.

2. If new focus target is null, then:

   1. If no fallback target was specified, then return.

   2. Otherwise, set new focus target to the fallback target .

3. If new focus target is a navigable container with non-null content navigable , then set new focus target to the content navigable 's active document .

4. If new focus target is a focusable area and its DOM anchor is inert , then return.

5. If new focus target is the currently focused area of a top-level traversable , then return.

6. Let old chain be the current focus chain of the top-level traversable in which new focus target finds itself.

7. Let new chain be the focus chain of new focus target .

8. Run the focus update steps with old chain , new chain , and new focus target respectively.

User agents must immediately run the focusing steps for a focusable area or navigable candidate whenever the user attempts to move the focus to candidate .

The unfocusing steps for an object old focus target that is either a focusable area or an element that is not a focusable area are as follows:

1. If old focus target is a shadow host whose shadow root 's delegates focus is true, and old focus target 's shadow root is a shadow-including inclusive ancestor of the currently focused area of a top-level traversable 's DOM anchor , then set old focus target to that currently focused area of a top-level traversable .

2. If old focus target is inert , then return.

3. If old focus target is an area element and one of its shapes is the currently focused area of a top-level traversable , or, if old focus target is an element with one or more scrollable regions, and one of them is the currently focused area of a top-level traversable , then let old focus target be that currently focused area of a top-level traversable .

4. Let old chain be the current focus chain of the top-level traversable in which old focus target finds itself.

5. If old focus target is not one of the entries in old chain , then return.

6. If old focus target is not a focusable area , then return.

7. Let topDocument be old chain 's last entry.

8. If topDocument 's node navigable has system focus , then run the focusing steps for topDocument 's viewport .

   Otherwise, apply any relevant platform-specific conventions for removing system focus from topDocument 's node navigable , and run the focus update steps given old chain , an empty list, and null.

The focus update steps , given an old chain , a new chain , and a new focus target respectively, are as follows:

1. If the last entry in old chain and the last entry in new chain are the same, pop the last entry from old chain and the last entry from new chain and redo this step.

2. For each entry entry in old chain , in order, run these substeps:

   1. If entry is an input element, and the change event applies to the element, and the element does not have a defined activation behavior , and the user has changed the element's value or its list of selected files while the control was focused without committing that change (such that it is different to what it was when the control was first focused), then:

      1. Set entry 's user validity to true.

      2. Fire an event named change at the element, with the bubbles attribute initialized to true.

   2. If entry is an element, let blur event target be entry .

      If entry is a Document object, let blur event target be that Document object's relevant global object .

      Otherwise, let blur event target be null.

   3. If entry is the last entry in old chain , and entry is an Element , and the last entry in new chain is also an Element , then let related blur target be the last entry in new chain . Otherwise, let related blur target be null.

   4. If blur event target is not null, null:

      1. fire Fire a focus event named blur at blur event target , with related blur target as the related target.

         In some cases, e.g., if entry is an area element's shape, a scrollable region, or a viewport , no event is fired.

      2. Handle interest change for blur event target and false.

3. Apply any relevant platform-specific conventions for focusing new focus target . (For example, some platforms select the contents of a text control when that control is focused.)

4. For each entry entry in new chain , in reverse order, run these substeps:

   1. If entry is a focusable area , and the focused area of the document is not entry :

      1. Set document 's relevant global object 's navigation API 's focus changed during ongoing navigation to true.

      2. Designate entry as the focused area of the document .

   2. If entry is an element, let focus event target be entry .

      If entry is a Document object, let focus event target be that Document object's relevant global object .

      Otherwise, let focus event target be null.

   3. If entry is the last entry in new chain , and entry is an Element , and the last entry in old chain is also an Element , then let related focus target be the last entry in old chain . Otherwise, let related focus target be null.

   4. If focus event target is not null, null:

      1. fire Fire a focus event named focus at focus event target , with related focus target as the related target.

         In some cases, e.g. e.g., if entry is an area element's shape, a scrollable region, or a viewport , no event is fired.

      2. Handle interest change for focus event target and true.

To fire a focus event named e at an element t with a given related target r , fire an event named e at t , using FocusEvent , with the relatedTarget attribute initialized to r , the view attribute initialized to t 's node document 's relevant global object , and the composed flag set.

When a key event is to be routed in a top-level traversable , the user agent must run the following steps:

1. Let target area be the currently focused area of the top-level traversable .

2. Assert : target area is not null, since key events are only routed to top-level traversables that have system focus . Therefore, target area is a focusable area .

3. Let target node be target area 's DOM anchor .

4. If target node is a Document that has a body element , then let target node be the body element of that Document .

   Otherwise, if target node is a Document object that has a non-null document element , then let target node be that document element .

5. If target node is not inert , then:

   1. Let canHandle be the result of dispatching the key event at target node .

   2. If canHandle is true, then let target area handle the key event. This might include firing a click event at target node .

The has focus steps , given a Document object target , are as follows:

1. If target 's node navigable 's top-level traversable does not have system focus , then return false.

2. Let candidate be target 's node navigable 's top-level traversable 's active document .

3. While true:

   1. If candidate is target , then return true.

   2. If the focused area of candidate is a navigable container with a non-null content navigable , then set candidate to the active document of that navigable container 's content navigable .

   3. Otherwise, return false.