HTML

Living Standard — Last Updated 31 October 2022

1. ~~7.11~~ 7.4 ~~Browsing the web~~ Navigation and session history

Welcome to the dragon's maw. Navigation, session history, and the traversal through that session history are some of the most complex parts of this standard.

The ~~PopStateEvent~~ basic concept may not seem so difficult:

The user is looking at a navigable that is presenting its active document . They navigate it to another URL .
The browser fetches the given URL from the network, using it to populate a new session history entry with a newly- created Document.
The browser updates the navigable 's active session history entry to the newly-populated one, and thus updates the active document that it is showing to the user.
At some point later, the user presses the browser back button to go back to the previous session history entry .
The browser looks at the URL stored in that session history entry , and uses it to re-fetch and populate that entry's document .
The browser again updates the navigable 's active session history entry .

You can see some of the intertwined complexity peeking through here, in how traversal can cause a navigation (i.e., a network fetch to a stored URL), and how a navigation necessarily needs to interface with the session history list to ensure that when it finishes the user is looking at the right thing. But the real problems come in with the various edge cases and interacting web platform features:

Nested navigables (e.g., iframe s) can also navigate and traverse, but those navigations need to be linearized into a single session history list since the user only has a single back/forward interface for the entire traversable navigable (e.g., browser tab).
Since the user can traverse back more than a single step in the session history (e.g., by holding down their back button), they can end up traversing multiple navigables at the same time when nested navigables are involved. This needs to be synchronized across all of the involved navigables, which might involve multiple event loops or even agent clusters .
During navigation, servers can respond with 204 or 205 status codes or with ` Content-Disposition: attachment ` headers, which cause navigation to abort and the navigable to stay on its original active document . (This is much worse if it happens during a traversal-initiated navigation!)
Various other HTTP headers, such as ` Location `, ` Refresh `, ` X-Frame-Options `, and those for Content Security Policy, contribute to either the fetching process , or the Document -creation process , or both. The ` Cross-Origin-Opener-Policy ` header even contributes to the browsing context selection and creation process!
Some navigations (namely fragment navigations and single-page app navigations ) are synchronous, meaning that JavaScript code expects to observe the navigation's results instantly. This then needs to be synchronized with the view of the session history that all other navigables in the tree see, which can be subject to race conditions and necessitate resolving conflicting views of the session history.
The platform has accumulated various exciting navigation-related features that need special-casing, such as javascript: URLs, srcdociframe s, and the beforeunload event.

In what follows, we have attempted to guide the reader through these complexities by appropriately cordoning them off into labeled sections and algorithms, and giving appropriate words of introduction where possible. Nevertheless, if you wish to truly understand navigation and session history, the usual advice will be invaluable.

7.11.10.3 7.4.1 The Session history

7.4.1.1 Session history entries

A session history entry is a struct with the following items :

step , a non-negative integer or " HashChangeEvent pending ~~interface~~ ", initially " pending ".
URL , a URL
document state , a document state .
serialized state , which is serialized state or null, initially null.
scroll restoration mode , a scroll restoration mode , initially " auto ".
scroll position data , which is scroll position data for the document 's restorable scrollable regions .
persisted user state , which is implementation-defined , initially null
For example, some user agents might want to persist the values of form controls.
User agents that persist the value of form controls are encouraged to also persist their directionality (the value of the element's dir attribute). This prevents values from being displayed incorrectly after a history traversal when the user had originally entered the values with an explicit, non-default directionality.

To get a session history entry 's document , return its document state 's document .

Serialized state is a serialization (via StructuredSerializeForStorage ) of an object representing a user interface state. We sometimes informally refer to "state objects", which are the objects representing user interface state supplied by the author, or alternately the objects created by deserializing (via StructuredDeserialize ) serialized state.

Pages can add serialized state to the session history. These are then deserialized and returned to the script when the user (or script) goes back in the history, thus enabling authors to use the "navigation" metaphor even in one-page applications.

Serialized state is intended to be used for two main purposes: first, storing a preparsed description of the state in the URL so that in the simple case an author doesn't have to do the parsing (though one would still need the parsing for handling URLs passed around by users, so it's only a minor optimization). Second, so that the author can store state that one wouldn't store in the URL because it only applies to the current Document instance and it would have to be reconstructed if a new Document were opened.

An example of the latter would be something like keeping track of the precise coordinate from which a popup div was made to animate, so that if the user goes back, it can be made to animate to the same location. Or alternatively, it could be used to keep a pointer into a cache of data that would be fetched from the server based on the information in the URL , so that when going back and forward, the information doesn't have to be fetched again.

A scroll restoration mode indicates whether the user agent should restore the persisted scroll position (if any) when traversing to an entry . A scroll restoration mode is one of the following:

" auto ": The user agent is responsible for restoring the scroll position upon navigation.
" manual ": The page is responsible for restoring the scroll position and the user agent does not attempt to do so automatically

7.11.10.4 7.4.1.2 Document state

Document state holds state inside a session history entry regarding how to present and, if necessary, recreate, a Document. It has:

A document , a Document or null, initially null.
When a history entry is active , it has a Document in its document state . However, when a Document is not fully active , it's possible for it to be destroyed to free resources. In such cases, this document item will be nulled out. The URL and other data in the session history entry and document state is then used to bring a new Document into being to take the place of the original, in the case where the user agent finds itself having to traverse to the entry.
If the Document is not destroyed , then during history traversal , it can be reactivated . The cache in which browsers store such Document s is often called a back-forward cache , or bfcache (or perhaps "blazingly fast" cache).
A history policy container , a policy container or " PageTransitionEvent client ~~interface~~ ", initially " client ".
A request referrer , which is " no-referrer ", " client ", or a URL , initially " client ".
A request referrer policy , which is a referrer policy , initially the default referrer policy .
The request referrer policy is distinct from the history policy container 's referrer policy . The former is used for fetches of this document, whereas the latter controls fetches by this document.
An initiator origin , which is an origin or null, initially null.
An origin , which is an origin or null, initially null.
This is the origin that we set " about: "-schemed Document s' origin to. We store it here because it is also used when restoring these Document s during traversal, since they are reconstructed locally without visiting the network. It is also used to compare the origin before and after the session history entry is repopulated . If the origins change, the navigable target name is cleared.
~~7.11.11 Loading~~ Nested histories , a list of nested histories , initially an empty list .
A resource , a string, POST resource or null, initially null.
A string is treated as HTML. It's used to store the source of an iframesrcdoc document .
A reload pending boolean, initially false.
An ever populated boolean, initially false.
A navigable target name string, initially the empty string.

User agents may destroy the documents of document states with non-null documents , as long as the Document is not fully active .

Apart from that restriction, this standard does not specify when user agents should destroy the document stored in a document state , versus keeping it cached.

A POST resource has:

A request body , a byte sequence or failure.
This is only ever accessed in parallel , so it doesn't need to be stored in memory. However, it must return the same byte sequence each time. If this isn't possible due to resources changing on disk, or if resources can no longer be accessed, then this must be set to failure.
A request content-type , which is ` application/x-www-form-urlencoded `, ` multipart/form-data `, or ` text/plain `.

A nested history has:

An id , a unique internal value .
This is used to associate the nested history with a navigable .
Entries , a list of session history entries .

This will later contain ways to identify a nested navigable across reloads.

Several contiguous entries in a session history can share the same document state . This can occur when the initial entry is reached via normal navigation , and the following entry is added via history.pushState(). Or it can occur via navigation to a fragment .

All entries that share the same document state (and that are therefore merely different states of one particular document) are contiguous by construction.

A Document has a latest entry , a session history entry or null.

This is the entry that was most recently represented by a given Document. A single Document can represent many session history entries over time, as many contiguous session history entries can share the same document state as explained above.

7.11.12 7.4.1.3 Unloading documents Centralized modifications of session history

To maintain a single source of truth, all modifications to a traversable navigable 's session history entries need to be synchronized. This is especially important due to how session history is influenced by all of the descendant navigables , and thus by multiple event loops . To accomplish this, we use the session history traversal parallel queue structure.

A session history traversal parallel queue is very similar to a parallel queue . It has an algorithm set , an ordered set .

The items in a session history traversal parallel queue 's algorithm set are either algorithm steps, or synchronous navigation steps , which are a particular brand of algorithm steps involving a target navigable (a navigable ).

To append session history traversal steps to a traversable navigable traversable given algorithm steps steps, append steps to traversable 's session history traversal queue 's algorithm set .

To append session history synchronous navigation steps to a traversable navigable traversable given algorithm steps steps and a navigable targetNavigable, append steps as synchronous navigation steps targeting target navigable targetNavigable to traversable 's session history traversal queue 's algorithm set .

To start a new session history traversal parallel queue :

Let sessionHistoryTraversalQueue be a new session history traversal parallel queue .
Run the following steps in parallel :
1. While true:
  1. If sessionHistoryTraversalQueue 's algorithm set is empty, then continue .
  2. Let steps be the result of dequeuing from sessionHistoryTraversalQueue 's algorithm set .
  3. Run steps.
Return sessionHistoryTraversalQueue.

Imagine the joint session history depicted by this Jake diagram :

	0	1
`top`	/a	/b

And the following code runs at the top level:

history.back();
location.href
=
'#foo';

The desired result is:

	0	1	2
`BeforeUnloadEvent top` ~~interface~~	/a	/b	/b#foo

This isn't straightforward, as the sync navigation wins the race in terms of being observable, whereas the traversal wins the race in terms of queuing steps on the session history traversal parallel queue . To achieve this result, the following happens:

history.back() appends steps intended to traverse by a delta of −1.
location.href = '#foo' synchronously changes the active session history entry entry to a newly-created one, with the URL /b#foo, and appends synchronous steps to notify the central source of truth about that new entry. Note that this does not yet update the current session history entry , current session history step , or the session history entries list; those updates cannot be done synchronously, and instead must be done as part of the queued steps.
On the session history traversal parallel queue , the steps queued by history.back() 7.11.13 Aborting run:
1. The target history step is determined to be 0: the current session history step (i.e., 1) plus the intended delta of −1.
2. We enter the main apply the history step algorithm.
  The entry at step 0, for the /a URL, has its document populated .
  Meanwhile, the queue is checked for synchronous navigation steps . The steps queued by the location.href setter now run, and block the traversal from performing effects beyond document population (such as, unloading documents and switching active history entries) until they are finished. Those steps cause the following to happen:
  1. The entry with URL /b#foo is added, with its step determined to be 2: the current session history step (i.e., 1) plus 1.
  2. We fully switch to that newly added entry, including a nested call to apply the history step . This ultimately results in updating the document by dispatching events like hashchange.
  Only once that is all complete, and the /a history entry has been fully populated with a document ~~load~~ , do we move on with applying the history step given the target step of 0.
  At this point, the Document with URL /b#foo unloads , and we finish moving to our target history step 0, which makes the entry with URL /a become the active session history entry and 0 become the current session history step .

Here is another more complex example, involving races between populating two different iframe s, and a synchronous navigation once one of those iframes loads. We start with this setup:

	0	1	2
`top`	/t
`frames[0]`	/i-0-a	/i-0-b
`frames[1]`	/i-1-a		/i-1-b

and then call history.go(-2). The following then occurs:

7.11.14 history.go(-2) appends steps intended to traverse by a delta of −2. Once those steps run:
1. The ` target step is determined to be 2 + (−2) = 0.
2. In parallel, the fetches are made to populate the two iframes, fetching X-Frame-Options /i-0-a ~~` header~~ and /i-1-a respectively.
  Meanwhile, the queue is checked for synchronous navigation steps . There aren't any right now.
3. In the fetch race, the fetch for /i-0-a wins. We proceed onward to finish all of apply the history step 's work for how the traversal impacts the frames[0] navigable , including updating its active session history entry to the entry with URL /i-0-a.
4. Before the fetch for /i-1-a finishes, we reach the point where scripts may run for the newly-created document in the frames[0] navigable 's active document . Some such script does run:
```
location.href
=
'#foo'
```
  This synchronously changes the frames[0] navigable's active session history entry entry to a newly-created one, with the URL /i-0-a#foo, and appends synchronous steps to notify the central source of truth about that new entry.
  Unlike in the previous example , these synchronous steps do not "jump the queue" and update the traversable before we finish the fetch for /i-1-a. This is because the navigable in question, frames[0], has already been altered as part of the traversal, so we know that with the current session history step being 2, adding the new entry as a step 3 doesn't make sense.
5. One the fetch for /i-1-a finally finishes, we proceed to finish updating the frames[1] navigable for the traversal, including updating its active session history entry to the entry with URL /i-1-a.
6. ~~7.11.15~~
  Now that both navigables have finished processing the traversal, we update the current session history step to the target step of 0.
Now we can process the steps that were queued for the synchronous navigation:
1. The ` Refresh /i-0-a#foo ~~` header~~ entry is added, with its step determined to be 1: the current session history step (i.e., 0) plus 1. This also clears existing forward history .
2. We fully switch to that newly added entry, including calling apply the history step . This ultimately results in updating the document by dispatching events like hashchange, as well as updating the current session history step to the target step of 1.

The end result is:

	0	1
`top`	/t
`frames[0]`	/i-0-a	/i-0-a#foo
`frames[1]`	/i-1-a

7.11 7.4.1.4 Browsing Low-level operations on session history

This section contains a miscellaneous grab-bag of operations that we perform throughout the ~~web~~ standard when manipulating session history. The best way to get a sense of what they do is to look at their call sites.

To get session history entries for a navigable ,navigable:

Let traversable be navigable 's traversable navigable .
Assert : this is running within traversable 's session history traversal queue .
If navigable is traversable, return traversable 's session history entries .
Let docStates be an empty ordered set of document states .
For each entry of traversable 's session history entries , append entry 's document state to docStates.
For each docState of docStates:
1. For each nestedHistory of docState 's nested histories :
  1. If nestedHistory 's id equals navigable 's id , return nestedHistory 's entries .
  2. For each entry of nestedHistory 's entries , append entry 's document state to docStates.
Assert : this step is not reached.

To clear the forward session history of a traversable navigable navigable:

Assert : this is running within navigable 's session history traversal queue .
Let step be the navigable 's current session history step .
Let entryLists be the ordered set « navigable 's session history entries ».
For each entryList of entryLists:
1. Remove every session history entry from entryList that has a step greater than step.
2. For each entry of entryList:
  1. For each nestedHistory of entry 's document state 's nested histories , append nestedHistory 's entries list to entryLists.

To get all used history steps that are part of traversable navigable traversable:

Assert : this is running within traversable 's session history traversal queue .
Let steps be an empty ordered set of non-negative integers.
Let entryLists be the ordered set « traversable 's session history entries ».
For each entryList of entryLists:
1. For each entry of entryList:
  1. Append entry 's step to steps.
  2. For each nestedHistory of entry 's document state 's nested histories , append nestedHistory 's entries list to entryLists.
Return steps, sorted .

To apply pending history changes to a traversable navigable traversable with optional boolean checkForUserCancelation (default false):

Let targetStep be traversable 's current session history step .
Apply the history step targetStep to traversable with checkForUserCancelation set to checkForUserCancelation.

7.11.1 7.4.2 Navigating across documents Navigation

Certain actions cause ~~the browsing context~~ a navigable to navigate to a new resource. ~~A user agent may provide various ways for the user to explicitly cause a browsing context to navigate, in addition to those defined in this specification.~~

For example, following a hyperlink , form submission , and the window.open() and location.assign() methods can all cause ~~a browsing context~~ navigation.

Although in this standard the word "navigation" refers specifically to ~~navigate.~~ the navigate algorithm, this doesn't always line up with web developer or user perceptions. For example:

~~A resource has a URL,~~

The URL and history update steps are often used during so-called "single-page app navigations" or "same-document navigations", but ~~that might~~ they do not be trigger the ~~only information necessary~~ navigate algorithm.
Reloads and traversals are sometimes talked about as a type of navigation, since all three will often attempt to ~~identify it. For example,~~ populate the history entry's document and thus could perform navigational fetches. See, e.g., the APIs exposed Navigation Timing . But they have their own entry point algorithms, separate from the navigate algorithm. [NAVIGATIONTIMING]
Although fragment navigations are always done through the navigate algorithm, a ~~form submission~~ user might perceive them as more like jumping around a single page, than as a true navigation.

Before we can jump into the navigation algorithm itself, we need to establish several important structures that ~~uses HTTP POST would also have~~ it uses.

The source snapshot params struct is used to capture data from a Document initiating a navigation. It is snapshotted at the ~~HTTP method~~ beginning of a navigation and ~~payload. Similarly,~~ used throughout the navigation's lifetime. It has the following items :

has transient activation: a boolean
sandboxing flags: a sandboxing flag set
allows downloading: a boolean
fetch client: an ~~iframe srcdoc~~ environment settings object , only to be used as a request client
source policy container: a policy container

To snapshot source snapshot params given a Document ~~document~~ sourceDocument, return a new source snapshot params ~~needs to know~~ with

has transient activation: true if sourceDocument 's relevant global object has transient activation ; otherwise false
sandboxing flags: sourceDocument 's active sandboxing flag set
allows downloading: false if sourceDocument 's active sandboxing flag set has the sandboxed downloads browsing context flag set; otherwise true
fetch client: sourceDocument 's relevant settings object
source policy container: sourceDocument 's policy container

The target snapshot params struct is used to capture data from a navigable being navigated. Like source snapshot params , it is snapshotted at the beginning of a navigation and used throughout the navigation's lifetime. It has the following items :

sandboxing flags: a sandboxing flag set

To snapshot target snapshot params given a navigable targetNavigable, return a new target snapshot params with sandboxing flags set to ~~use.~~ the result of determining the creation sandboxing flags given targetNavigable 's active browsing context and targetNavigable 's container .

Much of the navigation process is concerned with determining how to create a new Document, which ultimately happens in the create and initialize a Document object algorithm. The parameters to ~~this~~ that algorithm are tracked via a navigation params struct , which has the following items :

id: null or a navigation id ID
request: null or a request that started the navigation
response: a response that ultimately was navigated to (potentially a network error )
origin: an origin to use for the new Document
policy container: a policy container to use for the new Document
final sandboxing flag set: a sandboxing flag set to impose on the new Document
cross-origin opener policy: a cross-origin opener policy to use for the new Document
COOP enforcement result: a cross-origin opener policy enforcement result , used for reporting and potentially for causing a browsing context group switch
reserved environment: null or an environment reserved for the new Document
~~browsing context~~ navigable: the ~~browsing context~~ navigable to be navigated ~~(or discarded, if a browsing context group switch occurs)~~
~~history handling~~ navigation timing type: a ~~history handling behavior~~ NavigationTimingType used for creating the navigation timing entry for the new Document
~~process response end of body~~ fetch controller: ~~an algorithm expecting~~ null or a ~~response~~ fetch controller
commit early hints: null or an algorithm accepting a Document, once it has been created

Once a navigation params struct is created, this standard does not mutate any of its items . They are only passed onward to other algorithms.

A navigation ID is a UUID string generated during navigation. It is used to interface with the WebDriver BiDi specification as well as to track the ongoing navigation . [WEBDRIVERBIDI]

After Document creation, the relevant traversable navigable 's session history gets updated. A history handling behavior is used to track the desired type of session history update throughout the navigation process. It is one of the following:

" default push ": A regular navigation which adds a new ~~entry to the session history. " entry update " A navigation to an existing~~ session history entry ~~to recreate that entry's document~~ , ~~which was previously discarded . " reload " A navigation intended to reload the current page~~ and ~~replace~~ will clear the ~~current~~ forward session history ~~entry~~ .
" replace ": A ~~non-reload~~ navigation that will replace the ~~current~~ active session history entry .

Navigation always involves source browsing context , which is the browsing context which was responsible for starting the navigation. As explained in issue #1130 the use of a browsing context as source might not be the correct architecture. A

Each navigable has a an ongoing navigation id , which is a ~~unique string.~~ navigation ID , " traversal ", or null, initially null. It is used to track navigation aborting and to prevent any navigations from taking place during traversal .

To navigate a ~~browsing context~~ navigable browsingContext navigable to a ~~resource~~ URL resource url using a DocumentsourceDocument, with an optional POST resource , string, or null documentResource (default null), an optional response -or-null response (default null), an optional boolean exceptionsEnabled (default false), an optional history handling behavior historyHandling (default " default push "), an optional ~~policy container -or-null historyPolicyContainer (default null), an optional~~ string navigationType cspNavigationType (default " other "), and an optional ~~navigation id~~ referrer policy navigationId referrerPolicy (default ~~null), and an optional processResponseEndOfBody , which is an algorithm receiving a response (default an algorithm that does nothing):~~ the empty string):

~~If resource is a URL , then set~~ Let resource sourceSnapshotParams ~~to a new request whose URL~~ be the result of snapshotting source snapshot params is given resource sourceDocument.
~~If resource is a request and~~ Let historyHandling initiatorOriginSnapshot ~~is " reload ", then set~~ be resource sourceDocument 's ~~reload-navigation flag~~ origin .
If ~~the source browsing context~~ sourceDocument 's node navigable is not allowed by sandboxing to navigate browsingContext navigable given and sourceSnapshotParams, then:
1. If exceptionsEnabled is ~~given and is~~ true, then throw a " SecurityError " DOMException.
2. Otherwise, the user agent may instead offer to open resource in a new top-level browsing context or in the top-level browsing context of the source browsing context , at the user's option, in which case the user agent must navigate that designated top-level browsing context to resource as if the user had requested it independently. Doing so, however, can be dangerous, as it means that the user is overriding the author's explicit request to sandbox the content. Return.
If Let navigationId ~~is null:~~ be the result of generating a random UUID . [WEBCRYPTO]
~~historyHandling is " reload~~ If the surrounding agent ~~", and~~ is equal to browsingContext navigable 's active document 's relevant agent , then continue these steps. Otherwise, queue a global task on the navigation id and traversal task source ~~is not null, let~~ given navigationId navigable be 's active window to continue these steps.
We do this because we are about to look at a lot of properties of browsingContext navigable 's active document ~~'s navigation id~~ , which are in theory only accessible over in the appropriate event loop . ~~Otherwise let navigation id~~ (But, we do not want to unconditionally queue a task, since — for example — same-event-loop fragment navigations need to take effect synchronously.)
Another implementation strategy would be to replicate the ~~result of generating~~ relevant information across event loops, or into a ~~random UUID . [UUID]~~ canonical "browser process", so that it can be consulted without queueing a task. This could give different results than what we specify here in edge cases, where the relevant properties have changed over in the target event loop but not yet been replicated. Further testing is needed to determine which of these strategies best matches browser behavior, in such racy edge cases.
If browsingContext navigable 's active document 's unload counter is greater than 0, then invoke WebDriver BiDi navigation failed with a WebDriver BiDi navigation status whose id is navigationId, status is " canceled ", and url is resource 's url ,, and return.
If ~~historyHandling is " default ", and~~ any of the following are true:
~~browsingContext is still on its initial about:blank Document~~
- resource url ~~is a request whose URL~~ equals browsingContext navigable 's active document 's URL ;
- resource url ~~is a request whose URL~~ 's scheme is " javascript " "; or
- navigable 's active document 's is initial about:blank is true
then set historyHandling to " replace ".
If all of the following are true:
- historyHandling documentResource is ~~not "~~ null;
- ~~reload~~
  ", resource response is ~~a request ,~~ null;
- resource url ~~'s URL~~ equals browsingContext navigable 's active ~~document~~ session history entry 's URL with exclude fragments set to ~~true,~~ true; and
- resource url 's ~~URL 's~~ fragment is ~~non-null,~~ non-null
then:
1. Navigate to a fragment given browsingContext navigable, resource 's URL , url, historyHandling, and navigationId.
2. Return.
~~Let~~ If incumbentNavigationOrigin navigable ~~be the origin of the incumbent settings object , or if no script was involved, the origin~~ 's parent ~~of the node document~~ is non-null, then set navigable 's is delaying load events ~~of the element that initiated the navigation .~~ to true.
Let initiatorPolicyContainer targetBrowsingContext be ~~a clone of the source browsing context~~ navigable 's active ~~document 's policy container~~ browsing context .
~~If resource is a request , then set~~ Let resource targetSnapshotParams ~~'s policy container~~ be the result of snapshotting target snapshot params to given initiatorPolicyContainer navigable.
~~Cancel any preexisting but not yet mature~~ Invoke WebDriver BiDi navigation started ~~attempt to navigate~~ with browsingContext targetBrowsingContext, ~~including canceling any instances of the fetch algorithm started by those attempts. If one of those attempts has already created~~ and ~~initialized~~ a new ~~Document object , abort that Document also. (Navigation attempts that have matured~~ WebDriver BiDi navigation status ~~already have session history entries, and are therefore handled during the update the session history with the new page~~ whose id ~~algorithm, later.) Let~~ is unloadPromptResult be the result of calling prompt to unload with the active document navigationId, url of is browsingContext . If this instance of the navigation url, and status ~~algorithm gets canceled while this step~~ is ~~running, the prompt to unload~~ " pending algorithm must nonetheless be run to completion. ".
If unloadPromptResult navigable 's ongoing navigation is " refuse traversal ", ~~then return~~ then:
1. Invoke WebDriver BiDi navigation failed with targetBrowsingContext and a new WebDriver BiDi navigation status whose id is navigationId and, status is " canceled ". ", and url is url.
2. ~~Abort~~ Return.
Any attempts to navigate a navigable ~~the active document~~ that is currently traversing of are ignored.
Set browsingContext navigable 's ongoing navigation to navigationId.

This will have the effect of aborting other ongoing navigations of navigable, since at certain points during navigation changes to the ongoing navigation will cause further work to be abandoned.
If browsingContext url 's scheme is ~~a child browsing context , then put it in the delaying load~~ " javascript ~~events mode .~~ ", then:
1. ~~The user agent must take this child browsing context~~ Queue a global task ~~out of~~ on the ~~delaying~~ navigation and traversal task source given navigable 's active window to navigate to a load javascript: ~~events mode when this navigation~~ URL ~~algorithm later matures~~ given navigable,url,historyHandling,initiatorOriginSnapshot, and cspNavigationType.
2. Return.
In parallel , ~~or when it terminates (whether due to having~~ run ~~all the steps, or being canceled, or being aborted), whichever happens first.~~ these steps:
1. Let sandboxFlags unloadPromptCanceled be the result of ~~determining the creation sandboxing flags~~ checking if unloading is user-canceled ~~given browsingContext and~~ for browsingContext navigable 's ~~container~~ active document 's inclusive descendant navigables .
2. ~~Let~~ If allowedToDownload unloadPromptCanceled ~~be the result of running the allowed to download algorithm given the source browsing context and browsingContext . Let~~ is true, or hasTransientActivation navigable ~~be true if the source browsing context~~ 's ~~active window has transient activation~~ ongoing navigation ~~; otherwise false.~~ is no longer navigationId, then:
  1. Invoke WebDriver BiDi navigation ~~started~~ failed with browsingContext , targetBrowsingContext and a new WebDriver BiDi navigation status whose id is navigationId, ~~url is resource 's url , and~~ status is " pending canceled ". ", and url is url.
  2. ~~Return, and continue running~~ Abort these ~~steps in parallel .~~ steps.
3. ~~This is~~ Queue a global task on the ~~step that attempts to obtain~~ navigation and traversal task source given resource , if necessary. Jump navigable 's active window to ~~the first appropriate substep:~~ abort navigable 's active document .
4. Let documentState be a new document state with
  
  If request referrer policy
  referrerPolicy
  initiator origin
  initiatorOriginSnapshot
  resource
  documentResource ~~is a response~~
  navigable target name
  navigable 's target name
  The navigable target name can get cleared under various conditions later in the navigation process, before the document state is finalized.
5. ~~Assert :~~ If browsingContext url is ~~not a top-level browsing context~~ about:blank, then set documentState 's origin to documentState 's initiator origin .
6. ~~Let~~ Otherwise, if finalSandboxFlags url ~~be the union~~ is about:srcdoc of, then set browsingContext documentState 's ~~sandboxing flags~~ origin ~~and~~ to resource navigable 's ~~forced sandboxing flag set~~ parent 's active document 's origin .
7. Let responseOrigin historyEntry be ~~the result of determining the origin~~ a new session history entry , with its URL ~~given browsingContext ,~~ set to resource 's url , finalSandboxFlags , and its document state set to incumbentNavigationOrigin documentState.
8. Let coop navigationParams be ~~a new cross-origin opener policy .~~ null.
9. ~~Let~~ If coopEnforcementResult response ~~be a new cross-origin opener policy enforcement result whose needs a browsing context group switch~~ is ~~false, would need a browsing context group switch due to report-only is false, url~~ non-null:
  The navigate algorithm is ~~resource 's url , origin~~ only supplied with a response ~~is responseOrigin , cross-origin opener policy~~ as part of the object is coop , and ~~current context is navigation source~~ embed is false. processing models, or for processing parts of multipart/x-mixed-replace responses after the initial response.
  1. Let policyContainer be the result of determining navigation params policy container given response 's URL , null, a clone of the resource sourceDocument 's ~~url~~ policy container , historyPolicyContainer , initiatorPolicyContainer , browsingContext navigable 's ~~parent browsing context 's active~~ container document 's policy container , and null.
  2. Let navigationParams finalSandboxFlags be a new navigation params whose id is navigationId , request is null, response is resource , origin is responseOrigin , policy container is policyContainer , final sandboxing flag set is finalSandboxFlags , cross-origin opener policy is coop , COOP enforcement result is coopEnforcementResult , reserved environment is null, browsing context is browsingContext , history handling the union ~~is historyHandling , process response end~~ of ~~body is~~ processResponseEndOfBody , and commit early hints is null. Run process a navigate response with navigationType , allowedToDownload , hasTransientActivation , and navigationParams . If resource targetSnapshotParams ~~is a request whose URL~~ 's ~~scheme is " javascript " Queue a global task on the DOM manipulation task source~~ sandboxing flags ~~given~~ and browsingContext policyContainer 's ~~active window~~ CSP list ~~to run these steps:~~ 's CSP-derived sandboxing flags .
  3. Let response responseOrigin be the result of ~~executing a javascript: URL request~~ determining the origin given resource , response 's URL , browsingContext finalSandboxFlags, ~~and~~ incumbentNavigationOrigin . documentState 's initiator origin , and null.
  4. Let finalSandboxFlags coop be ~~the union of browsingContext 's sandboxing flags and response 's forced sandboxing flag set~~ a new cross-origin opener policy .
  5. Let coopEnforcementResult be a new cross-origin opener policy enforcement result whose needs a browsing context group switch is false, would need a browsing context group switch due to report-only is false, url is resource response 's URL , origin is browsingContext 's active document 's origin , responseOrigin, cross-origin opener policy is browsingContext 's active document 's cross-origin opener policy , coop, and current context is navigation source is false.
  6. ~~Let~~ Set navigationParams be to a new navigation params ~~whose~~ , with
    id is
    navigationId ,
    request ~~is resource ,~~
    null
    response is
    response ,
    origin is
    browsingContext responseOrigin ~~'s active document 's origin ,~~
    policy container is
    browsingContext policyContainer ~~'s active document 's policy container ,~~
    final sandboxing flag set is
    finalSandboxFlags ,
    cross-origin opener policy is
    browsingContext coop ~~'s active document 's cross-origin opener policy ,~~
    COOP enforcement result is coopEnforcementResult , reserved environment is null, browsing context is browsingContext , history handling is historyHandling , process response end of body is processResponseEndOfBody , and commit early hints is null. Run process a navigate response with navigationType , allowedToDownload , hasTransientActivation , and navigationParams . So for example a ~~javascript: URL in an~~
    ~~href~~ coopEnforcementResult ~~attribute of an~~
    a reserved environment ~~element would only be evaluated when the link was followed , while such a URL in the~~
    null
    ~~src~~ navigable ~~attribute of an~~
    ~~iframe~~ navigable ~~element would be evaluated in the context of the~~
    ~~iframe~~ navigation timing type ~~'s nested browsing context when the~~
    " iframe navigate ~~is being set up. Once evaluated, its return value (if it was a string) would replace that browsing context 's active document , thus also changing the corresponding~~ "
    ~~Window~~ fetch controller ~~object.~~
    null
    ~~If resource is a request whose URL 's scheme is a fetch scheme~~ commit early hints
    null
10. ~~Run process a navigate fetch given navigationId , resource ,~~ Attempt to populate the ~~source browsing context , browsingContext , navigationType ,~~ history entry's document for sandboxFlags historyEntry, given historyPolicyContainer navigable, " navigate ", initiatorPolicyContainer sourceSnapshotParams, allowedToDownload targetSnapshotParams, hasTransientActivation navigationId, incumbentNavigationOrigin navigationParams, historyHandling cspNavigationType, ~~and processResponseEndOfBody . Otherwise, resource is a request whose URL 's scheme is neither "~~ with ~~javascript~~ allowPOST ~~" nor a fetch scheme~~ set to true and completionSteps set to the following step:
  1. ~~Run process a navigate URL scheme~~ Append session history traversal steps ~~given~~ to resource navigable 's ~~URL ,~~ traversable 's session history traversal queue to finalize a cross-document navigation given browsingContext navigable, sandboxFlags historyHandling, and hasTransientActivation historyEntry.
  ~~To process a navigate fetch , given a~~

Although the usual cross-document navigation case will first foray into populating a ~~string navigationType ,~~ session history entry with a ~~sandboxing flag set~~ Document sandboxFlags , two policy containers, all navigations that don't get aborted will ultimately end up calling into one of the below algorithms.

To finalize a ~~boolean allowedToDownload ,~~ cross-document navigation given a ~~boolean hasTransientActivation , an origin~~ navigable incumbentNavigationOrigin navigable, a history handling behavior historyHandling, and session history entry processResponseEndOfBody , which is an algorithm accepting a response : historyEntry:

~~Let response be null.~~ Set request 's client to sourceBrowsingContext 's active document 's relevant settings object , destination to " document ", mode to " navigate ", credentials mode to " include ", use-URL-credentials flag , redirect mode to " manual ", and replaces client id to Assert : this is running on browsingContext navigable 's ~~active document 's relevant settings object~~ traversable navigable's ~~'s id~~ session history traversal queue .
~~If hasTransientActivation is true, then set~~ Set request navigable 's ~~user-activation~~ is delaying load events to ~~true.~~ false.
If browsingContext historyEntry 's ~~container~~ document is ~~non-null:~~ null, then return.
If
This means that attempting to populate the ~~browsingContext 's container~~ history entry's document ~~has~~ ended up not creating a ~~browsing context scope origin , then set request 's origin to that browsing context scope origin .~~ document, as a result of e.g., the navigation being canceled by a subsequent navigation, a 204 No Content response, etc.
If all of the following are true:
- ~~Set request 's destination to~~ browsingContext navigable 's ~~container~~ parent ~~'s local name .~~ is null;
- ~~Let responseOrigin be null.~~ ~~Let~~ currentContextIsSource be the result of whether browsingContext historyEntry 's ~~active~~ document ~~is same origin with sourceBrowsingContext~~ 's ~~active document . Let coopEnforcementResult be a new cross-origin opener policy enforcement result whose needs a~~ browsing context ~~group switch~~ is ~~false, would need a~~ not an auxiliary browsing context ~~group switch due to report-only~~ ~~is false, url~~ whose disowned is false; and
- browsingContext historyEntry 's ~~active~~ document 's ~~url ,~~ origin is not browsingContext navigable 's active document 's origin ~~, cross-origin opener policy~~ is
then set browsingContext historyEntry 's ~~active~~ document state 's ~~cross-origin opener policy , and current context is navigation source~~ navigable target name ~~is currentContextIsSource .~~ to the empty string.
Let finalSandboxFlags entryToReplace be ~~an empty sandboxing flag set . Let~~ responseCOOP navigable ~~be a new cross-origin opener policy . Let~~ 's active session history entry if locationURL historyHandling be is " replace ", otherwise null.
Let currentURL traversable be request navigable 's ~~current URL~~ traversable navigable .
Let hasCrossOriginRedirects be false. Let commitEarlyHints targetStep be null.
Let fetchController targetEntries be ~~null. While true:~~ the result of getting session history entries for navigable.
If locationURL entryToReplace is ~~non-null,~~ null, then:
1. ~~If locationURL 's origin is not~~ Clear the ~~same~~ forward session history ~~as currentURL 's origin , then set~~ of hasCrossOriginRedirects to true. traversable.
2. Set currentURL targetStep to locationURL . If request traversable 's ~~reserved client~~ current session history step ~~is not null and~~ + 1.
3. Set currentURL historyEntry 's ~~origin~~ step ~~is not the same~~ to targetStep.
4. Append as request historyEntry ~~'s reserved client 's creation URL 's origin , then:~~ to targetEntries.
Otherwise:
1. ~~Run the environment discarding steps~~ Replace ~~for~~ request entryToReplace ~~'s reserved client .~~ with historyEntry in targetEntries.
2. Set request historyEntry 's ~~reserved client~~ step to ~~null.~~ entryToReplace 's step .
3. Set commitEarlyHints targetStep to ~~null. Preloaded links from early hint headers remain in the preload cache after a same origin redirect, but get discarded when the redirect is cross-origin. If~~ request traversable 's ~~reserved client is null, then:~~ current session history step .
~~Let~~ Apply the history step topLevelCreationURL targetStep be to currentURL traversable.

7.4.2.3.2 The `javascript:` URL special case

javascript: URLs have a dedicated label on the issue tracker documenting various problems with their specification.

~~Let~~ To navigate to a javascript: URL , given a navigable topLevelOrigin be null. If targetNavigable, a URL browsingContext is not url, a ~~top-level browsing context , then:~~ history handling behavior historyHandling, an origin initiatorOrigin, and a string cspNavigationType:

~~Let parentEnvironment be~~ Assert : browsingContext historyHandling ~~'s container~~ is " replace 's relevant settings object . ".
Set topLevelCreationURL to parentEnvironment targetNavigable 's ~~top-level creation URL~~ ongoing navigation ~~and~~ to null.
If topLevelOrigin initiatorOrigin to is not same origin-domain with parentEnvironment targetNavigable 's ~~top-level~~ active document 's origin . , then return.
~~Set~~ Let request ~~'s reserved client to~~ be a new ~~environment~~ request whose ~~id is a unique opaque string, target browsing context is browsingContext , creation URL is currentURL , top-level creation~~ URL is topLevelCreationURL , and top-level origin is topLevelOrigin url.

~~The created environment's active service worker~~ This is ~~set in the Handle Fetch~~ a synthetic request ~~algorithm during~~ solely for plumbing into the ~~fetch if~~ next step. It will never hit the ~~request URL matches a service worker registration. [SW]~~ network.
If the result of ~~Should~~ should navigation request of type be blocked by Content Security Policy? given request and navigationType cspNavigationType is " Blocked ", then ~~set response to a network error and break .~~ return. [CSP]
~~Otherwise:~~
~~If fetchController is null, then set~~ Let fetchController newDocument to be the result of ~~fetching~~ evaluating a javascript: URL given request targetNavigable, ~~with processEarlyHintsResponse set to the following step given a response~~ earlyResponse : url, and initiatorOrigin.
If commitEarlyHints newDocument is null, then ~~set commitEarlyHints to the result of processing early hint headers given earlyResponse and request 's reserved client .~~ return.
In this case, some JavaScript code was executed, but no new Otherwise, process the next manual redirect Document given fetchController . Wait for the task on the networking task source to process response and set response to the result. was created, so we will not perform a navigation.
~~Set finalSandboxFlags to the union of~~ Let browsingContext entryToReplace ~~'s sandboxing flags and~~ be response targetNavigable 's ~~forced sandboxing flag set~~ active session history entry .
~~Set~~ Let responseOrigin oldDocState ~~to the result of determining the origin given browsingContext ,~~ be request entryToReplace 's ~~URL , finalSandboxFlags , and incumbentNavigationOrigin .~~ document state .
If Let browsingContext documentState is be a ~~top-level browsing context , then:~~ new document state with

document
~~Set~~ responseCOOP newDocument ~~to the result of obtaining a cross-origin opener~~
history policy container ~~given response and~~
a clone of the request oldDocState 's ~~reserved client .~~ history policy container
request referrer
~~Set~~ coopEnforcementResult oldDocState ~~to the result of enforcing the response's cross-origin opener~~ 's request referrer
request referrer policy ~~given browsingContext ,~~
request oldDocState 's ~~URL , responseOrigin ,~~ request referrer policy or should this be the responseCOOP , referrerPolicy that was passed to navigate ?
origin
coopEnforcementResult initiatorOriginSnapshot ~~and~~
resource
null
ever populated
true
navigable target name
request oldDocState 's ~~referrer .~~ navigable target name
If Let sandboxFlags historyEntry ~~is not empty and~~ be a new session history entry , with
URL
responseCOOP entryToReplace 's ~~value~~ URL ~~is not "~~ ~~unsafe-none~~
document state ~~", then set~~
response documentState ~~to an appropriate network error~~
serialized state ~~and break .~~
StructuredSerializeForStorage (null)

For the URL , we do not use url, i.e. the actual javascript: URL that the navigate algorithm was called with. This ~~results~~ means javascript: URLs are never stored in ~~a network error as one cannot simultaneously provide a clean slate to a response using cross-origin opener policy~~ session history, and ~~sandbox the result of navigating to that response.~~ so can never be traversed to.
~~If response is not a network error , browsingContext is a child browsing context , and the result of performing a cross-origin resource policy check~~ Append session history traversal steps ~~with~~ to browsingContext targetNavigable 's ~~container document~~ traversable 's ~~origin , browsingContext 's container document~~ session history traversal queue ~~'s relevant settings object ,~~ to finalize a cross-document navigation with request 's destination , targetNavigable, response historyHandling, and ~~true is blocked , then set~~ response to historyEntry.

To evaluate a ~~network error~~ javascript: URL given a navigable targetNavigable, a URL url, and ~~break .~~ an origin newDocumentOrigin:

~~Here we're running~~

Let urlString be the ~~cross-origin resource policy check against~~ result of running the ~~parent browsing context~~ URL serializer ~~rather than~~ on sourceBrowsingContext url. ~~This is because we care about~~
Let encodedScriptSource be the ~~same-originness~~ result of removing the ~~embedded content against~~ leading " javascript: " from urlString.
Let scriptSource be the ~~parent context, not~~ UTF-8 decoding of the ~~navigation source.~~ percent-decoding of encodedScriptSource.
~~Set~~ Let locationURL settings to be response targetNavigable 's ~~location URL~~ active document ~~given currentURL~~ 's ~~fragment~~ relevant settings object .
If Let locationURL baseURL ~~is not a~~ be settings 's API base URL ~~whose scheme is an HTTP(S) scheme , then break~~ . Navigation handles redirects manually as navigation is the only place in the web platform that cares for redirects to mailto: URLs and such. By the end of this loop we will be in one of these scenarios:
Let response script is be the result of creating a ~~network error~~ classic script given scriptSource,settings,baseURL, and the default classic script fetch options .
Let locationURL evaluationStatus ~~is failure, because~~ be the result of ~~an unparseable ` Location ` header.~~ running the classic script script.
Let locationURL result ~~is null, because we successfully fetched a non- network error HTTP(S) response with no ` Location ` header.~~ be null.
If locationURL evaluationStatus is a ~~URL with a non- HTTP(S) scheme . If~~ normal completion, and locationURL evaluationStatus.[[Value]] is ~~failure,~~ a String, then set response result to ~~a network error .~~ evaluationStatus.[[Value]].
Otherwise, if return null.
Let locationURL response is be a new response with
URL ~~whose scheme~~
targetNavigable 's active document ~~is a fetch scheme~~ 's URL ~~or "~~
header list
« (` Content-Type `, ` javascript text/html;charset=utf-8 ~~", then set~~ `) »
body
the UTF-8 encoding of response to result, as a ~~network error .~~ body
The encoding to UTF-8 means that unpaired surrogates will not roundtrip, once the HTML parser decodes the response body.
~~Otherwise, if~~ Let locationURL policyContainer ~~is a URL , then process a navigate URL scheme given locationURL , browsingContext , sandboxFlags , and~~ be hasTransientActivation , and return. targetNavigable 's active document 's policy container .
Let responsePolicyContainer finalSandboxFlags be ~~the result of creating a policy container from a fetch response~~ policyContainer 's CSP list ~~given~~ 's CSP-derived sandboxing flags .
Let response coop ~~and~~ be request targetNavigable 's ~~reserved client~~ active document 's cross-origin opener policy .
Let resultPolicyContainer coopEnforcementResult be ~~the result of determining navigation params~~ a new cross-origin opener policy ~~container~~ enforcement result ~~given~~ with
needs a browsing context group switch
false
would need a browsing context group switch due to report-only
false
url
response url ~~'s URL , historyPolicyContainer ,~~
origin
initiatorPolicyContainer , null, and initiatorOrigin
cross-origin opener policy
responsePolicyContainer . coop
current context is navigation source
false
Let navigationParams be a new navigation params ~~whose~~ , with
id is
navigationId ,
request
null this will cause the referrer of the resulting Document to be null; is ~~request ,~~ that correct?
response is
response ,
origin is
responseOrigin , initiatorOrigin
policy container is
resultPolicyContainer , policyContainer
final sandboxing flag set is
finalSandboxFlags ,
cross-origin opener policy is
responseCOOP , coop
COOP enforcement result is
coopEnforcementResult ,
reserved environment is
null
navigable
request targetNavigable ~~'s reserved client , browsing context~~
navigation timing type ~~is browsingContext , history handling~~
" navigate is historyHandling , process response end of body "
fetch controller ~~is processResponseEndOfBody , and~~
null
commit early hints ~~is commitEarlyHints .~~
null
~~Run process a navigate response~~ Return the result of loading an HTML document ~~with navigationType , allowedToDownload , hasTransientActivation , and~~ given navigationParams.

7.4.2.3.3 Fragment navigations

To ~~process a~~ navigate ~~response ,~~ to a fragment given a ~~string~~ navigable navigationType navigable, a ~~boolean~~ URL allowedToDownload url, a ~~boolean~~ history handling behavior hasTransientActivation historyHandling, and a navigation ~~params~~ ID navigationParams navigationId:

Let response historyEntry be a new session history entry , with
URL
navigationParams url ~~'s response .~~ ~~Let~~
document state
browsingContext navigable be 's active session history entry 's document state
serialized state
StructuredSerializeForStorage (null)
scroll restoration mode
navigationParams navigable 's ~~browsing context .~~ active session history entry 's scroll restoration mode
Let failure entryToReplace be ~~false. If~~ response is a network error , then set failure to true. Otherwise, if the result of Should navigation response to navigation request of type in target be blocked by Content Security Policy? given navigationParams 's request , response , navigationParams navigable 's ~~policy container~~ active session history entry ~~'s CSP list , navigationType , and~~ if browsingContext historyHandling is " ~~Blocked~~ replace ", ~~then set failure to true. [CSP]~~ otherwise null.
~~Otherwise, if~~ Let navigationParams history ~~'s reserved environment is non-null and the result of checking a navigation response's adherence to its embedder policy given response , browsingContext , and~~ be navigationParams navigable 's ~~policy container~~ active document 's ~~embedder policy is false, then set failure to true.~~ history object .
~~Otherwise, if the result of checking a navigation response's adherence to ` X-Frame-Options ` given response ,~~ Let browsingContext , and scriptHistoryIndex be navigationParams history 's ~~origin is false, then set~~ index .
Let failure scriptHistoryLength ~~to true.~~ be history 's length .
If failure historyHandling is ~~true,~~ " push ", then:
1. ~~Call~~ Set navigationParams history 's ~~process response end of body~~ state ~~with~~ to null.
2. Increment response scriptHistoryIndex.
3. ~~Display the inline content with an appropriate error shown~~ Set scriptHistoryLength to ~~the user given~~ browsingContext . scriptHistoryIndex + 1.
~~Run the environment discarding steps for~~ Set navigationParams navigable 's ~~reserved environment .~~ active session history entry to historyEntry.
~~Invoke WebDriver BiDi navigation failed~~ Update document for history step application ~~with~~ given browsingContext navigable 's active document ,historyEntry, true, scriptHistoryIndex, and scriptHistoryLength.
This algorithm will be called twice as a ~~new WebDriver BiDi navigation status whose id is~~ result of a single fragment navigation: once synchronously, where best-guess values navigationParams scriptHistoryIndex ~~'s id , status~~ and scriptHistoryLength are set, history.state is " nulled out, and various events are fired; and once asynchronously, where the final values for index and length are set, canceled history.state ", remains untouched, and ~~url~~ no events are fired.
Scroll to the fragment is given response navigable 's ~~URL~~ active document . ~~Return.~~

~~This is where~~ If the ~~network errors defined~~ scrolling fails because the Document is new and ~~propagated by Fetch , such as DNS or TLS errors, end up being displayed~~ the relevant ID has not yet been parsed, then the second asynchronous call to ~~users. [FETCH]~~ update document for history step application will take care of scrolling.
If Let response traversable ~~'s status is 204 or 205, then call~~ be navigationParams navigable 's ~~process response end of body with response , and return.~~ traversable navigable .
~~If response has a ` Content-Disposition~~ ~~` header specifying~~ Append the ~~attachment disposition type, then:~~ following session history synchronous navigation steps involving navigable to traversable:
1. If Finalize a same-document navigation given allowedToDownload is true, then handle traversable, response as a download . navigable,historyEntry, and entryToReplace.
2. Invoke WebDriver BiDi ~~download started~~ fragment navigated with browsingContext navigable 's active browsing context and a new WebDriver BiDi navigation status whose id is navigationParams navigationId, url is resource 's id url , and status is " complete ", ".

To finalize a same-document navigation given a traversable navigable traversable, a navigable targetNavigable, a session history entry targetEntry, and ~~url~~ session history entry -or-null entryToReplace:

This is used by both fragment navigations and by the URL and history update steps , which are the only synchronous updates to session history. By virtue of being synchronous, those algorithms are performed outside of the top-level traversable 's session history traversal queue . This puts them out of sync with the top-level traversable 's current session history step , so this algorithm is used to resolve conflicts due to race conditions.

Assert : this is running on response traversable 's ~~URL~~ session history traversal queue .
~~Return.~~ If targetNavigable 's active session history entry is not targetEntry, then return.
Let type targetStep be null.
Let targetEntries be the ~~computed type~~ result of getting session history entries for response . targetNavigable.
If ~~the user agent has been configured to process resources of the given~~ type using some mechanism other than rendering the content in a browsing context , then skip this step. Otherwise, if the type entryToReplace is ~~one of the following types, jump to the appropriate entry in the following list, and process response as described there:~~ null, then:
1. ~~Follow the steps given in~~
  Clear the ~~HTML document~~ forward session history ~~section providing~~ of navigationParams traversable. ~~Once the steps have completed, return. an XML MIME type that is not an explicitly supported XML MIME type~~
2. ~~Follow the steps given in the XML document section providing~~
  Set navigationParams targetStep ~~and~~ to type . Once the steps have completed, return. a JavaScript MIME type a JSON MIME type that is not an explicitly supported JSON MIME type " text/css traversable 's current session history step + 1.
3. ~~" " text/plain~~
  Set targetEntry 's step to targetStep.
4. ~~" " text/vtt~~
  ~~" Follow the steps given in the plain text file~~ Append ~~section providing~~ navigationParams targetEntry ~~and~~ to type targetEntries. ~~Once the steps have completed, return. "~~
Otherwise:
1. ~~" Follow the steps given in the multipart/x-mixed-replace~~
  Replace ~~section providing~~ navigationParams . Once the steps have completed, return. A supported image, video, or audio type Follow the steps given in the media section providing entryToReplace with navigationParams targetEntry ~~and~~ in type targetEntries. ~~Once the steps have completed, return. " application/pdf " " text/pdf "~~
2. ~~If the user agent's PDF viewer supported is true, then either follow the steps given in the plugin~~ Set targetEntry 's step ~~section providing~~ to navigationParams entryToReplace ~~and~~ 's step .
3. Set type , or display the inline content given targetStep to browsingContext . Once traversable 's current session history step .
Apply the ~~steps have completed, return. See issue #6003~~ history step ~~for discussion on picking one of these two behaviors~~ targetStep to ~~standardize. Otherwise, proceed onward.~~ traversable.
~~An explicitly supported XML MIME type is an XML MIME type for which the user agent~~
This is ~~configured to use an external application to render the content (either a plugin rendering directly in browsingContext , or a separate application), or one~~ done even for ~~which the user agent has dedicated processing rules (e.g., a web browser with a built-in Atom feed viewer would be said to explicitly support the~~ " application/atom+xml replace ~~MIME type), or one for which the user agent has a dedicated handler.~~ " navigations, as it resolves race conditions across multiple synchronous navigations.

7.4.2.3.4 Non-fetch schemes and external software

~~An explicitly supported JSON MIME type is~~ One input to attempt to create a ~~JSON MIME type~~ non-fetch scheme document ~~for which the user agent~~ is ~~configured to use an external application to render~~ the ~~content (either~~ non-fetch scheme navigation params struct . It is a ~~plugin~~ light weight version of navigation params ~~rendering directly in browsingContext , or a separate application), or one for~~ which only carries parameters relevant to the ~~user agent~~ non- fetch scheme navigation case. It has ~~dedicated processing rules, or one for which~~ the ~~user agent has a dedicated handler.~~ following items :

initiator origin

~~If, given type , the new resource is to be handled by displaying some sort of inline content, e.g., a native rendering of the content or~~ an ~~error message because the specified type is not supported, then display the inline content~~ origin ~~given browsingContext , and then return. Otherwise, the document's type is such that the resource will not affect browsingContext , e.g., because the resource is to be handed~~ possibly for use in a user-facing prompt to confirm the invocation of an external ~~application or because it is an unknown type~~ software package

This differs slightly from a document state 's initiator origin in that ~~will be processed as~~ a ~~download . Hand-off to external software~~ non-fetch scheme navigation params ~~given response , browsingContext , navigationParams~~ 's ~~final sandboxing flag set , and hasTransientActivation .~~ initiator origin follows redirects up to the last fetch scheme URL in a redirect chain that ends in a non- fetch scheme URL.

To ~~process~~ attempt to create a ~~navigate URL~~ non-fetch scheme document , given a URL url, a ~~browsing context~~ navigable browsingContext navigable, a sandboxing flag set sandboxFlags, ~~and~~ a navigation ID navigationId, a NavigationTimingTypenavTimingType, a boolean hasTransientActivation, and an origin initiatorOrigin:

If url is to be handled using a mechanism that does not affect browsingContext navigable, e.g., because url 's scheme is handled externally, ~~then hand-off~~ then:
1. Hand-off to external software given url, browsingContext navigable, sandboxFlags, ~~and~~ hasTransientActivation, and initiatorOrigin.
2. ~~Otherwise,~~ Return null.
Handle url ~~is to be handled~~ by displaying some sort of inline content, e.g., an error message because the specified scheme is not one of the supported protocols, or an inline prompt to allow the user to select a registered handler for the given scheme. ~~Display~~ Return the result of displaying the inline content given browsingContext navigable,navigationId, and navTimingType.

In the case of a registered handler being used, navigate will be invoked with a new URL.

To hand-off to external software given a URL or response resource, a ~~browsing context~~ navigable browsingContext navigable, a sandboxing flag set sandboxFlags, ~~and~~ a boolean hasTransientActivation, and an origin initiatorOrigin user agents should:

~~Return without invoking the external sofware package if~~ If all of ~~these~~ the following conditions hold:
- browsingContext navigable is not a top-level ~~browsing context~~ traversable ;
- sandboxFlags has its sandboxed custom protocols navigation browsing context flag set; and
- sandboxFlags has its sandboxed top-level navigation with user activation browsing context flag set, or hasTransientActivation is ~~false.~~ false
then return without invoking the external software package.

Navigation inside an iframe toward external software can be seen by users as a new popup or a new top-level navigation. That's why its is allowed in sandboxed iframe only when one of allow-popups, allow-top-navigation, allow-top-navigation-by-user-activation, or allow-top-navigation-to-custom-protocols is specified.
Perform the appropriate handoff of resource while attempting to mitigate the risk that this is an attempt to exploit the target software. For example, user agents could prompt the user to confirm that ~~the source browsing context 's active document 's origin~~ initiatorOrigin is to be allowed to invoke the external software in question. In particular, if hasTransientActivation is false, then the user agent should not invoke the external software package without prior user confirmation.

For example, there could be a vulnerability in the target software's URL handler which a hostile page would attempt to exploit by tricking a user into clicking a link.

~~To execute~~ A couple of scenarios can intervene early in the navigation process and put the whole thing to a ~~javascript: URL request , given~~ halt. This can be especially exciting when multiple navigables are navigating at the same time, due to a ~~request~~ session history traversal.

A navigable request , source is allowed by sandboxing to navigate a ~~browsing context~~ second navigable browsingContext target, ~~and an origin~~ given a source snapshot params initiatorOrigin : sourceSnapshotParams, if the following steps return true:

~~Let~~ If response source ~~be a response whose status~~ is ~~204 .~~ target, then return true.
If ~~both~~ source is an ancestor of ~~the following are true:~~ target, then return true.
If target is an ancestor of source, then:
1. If initiatorOrigin target is ~~same origin-domain~~ not a top-level traversable , then return true.
2. If sourceSnapshotParams 's has transient activation ~~with~~ is true, and browsingContext sourceSnapshotParams 's ~~active document~~ sandboxing flags 's ~~origin .~~ sandboxed top-level navigation with user activation browsing context flag is set, then return false.
3. ~~The result of Should navigation request of type be blocked by Content Security Policy? given~~ If request sourceSnapshotParams 's has transient activation is false, and navigationType sourceSnapshotParams ~~is " Allowed ". [CSP]~~ 's sandboxing flags 's sandboxed top-level navigation without user activation browsing context flag is set, then return false.
4. ~~then:~~ Return true.
If target is a top-level traversable :
1. ~~Let~~ If urlString source ~~be the result of running~~ is the ~~URL serializer~~ one permitted sandboxed navigator on of request target, then return true.
2. If sourceSnapshotParams 's ~~URL .~~ sandboxing flags 's sandboxed navigation browsing context flag is set, then return false.
3. ~~Let~~ Return true.
If encodedScriptSource sourceSnapshotParams ~~be the result~~ 's sandboxing flags 's sandboxed navigation browsing context flag is set, then return false.
Return true.

To check if unloading is user-canceled for list of ~~removing the leading " javascript: " from~~ navigables urlString . navigables:

Let scriptSource documents be the ~~UTF-8 decoding~~ active document of ~~the percent-decoding~~ each item of in encodedScriptSource navigables.
~~Append browsingContext 's active document 's URL to~~ Let request unloadPromptShown ~~'s URL list .~~ be false.
Let settings unloadPromptCanceled be ~~browsingContext 's active document 's relevant settings object .~~ false.
Let baseURL totalTasks be the size of settings 's API base URL . documents.
Let script completedTasks be ~~the result~~ 0.
For each document of ~~creating~~ documents, queue a ~~classic script~~ global task on the navigation and traversal task source given scriptSource , settings , document 's relevant global object to run the steps:
1. Increase the baseURL , and document 's unload counter by 1.
2. Increase the ~~default classic script fetch options .~~ event loop 's termination nesting level by 1.
3. Let evaluationStatus event be the result of ~~running the classic script~~ creating an event using BeforeUnloadEvent.
4. Initialize script . event 's type attribute to beforeunload and its cancelable attribute true.
5. ~~Let~~ Dispatch result event ~~be undefined if~~ at evaluationStatus document ~~is an abrupt completion~~ 's relevant global object .
6. Decrease the event loop ~~or evaluationStatus .[[Value]] is empty, or evaluationStatus .[[Value]] otherwise.~~ 's termination nesting level by 1.
7. If ~~Type (~~ all of the following are true:
  - result unloadPromptShown ) is ~~String, then~~ false;
  - document 's active sandboxing flag set does not have its sandboxed modals flag set;
  - response document ~~to a response~~ 's relevant global object ~~whose header list~~ has sticky activation ;
  - event 's canceled flag is ~~« (`~~ set, or the Content-Type returnValue ~~`, `~~ attribute of event is not the empty string; and
  - showing an unload prompt is unlikely to be annoying, deceptive, or pointless
  then:
  1. Set unloadPromptShown to true.
  2. Invoke WebDriver BiDi user prompt opened with document 's relevant global object , " text/html;charset=utf-8 beforeunload ~~`) »,~~ ", and ~~whose body is~~ "".
  3. Ask the ~~result of UTF-8 encoding~~ user to confirm that they wish to unload the document, and pause ~~result .~~ while waiting for the user's response.
    
    The ~~encoding~~ message shown to ~~UTF-8 means that unpaired surrogates will~~ the user is not ~~roundtrip, once~~ customizable, but instead determined by the ~~HTML parser decodes~~ user agent. In particular, the ~~response body.~~ actual value of the returnValue attribute is ignored.
  4. If the user did not confirm the page navigation, set unloadPromptCanceled to true.
  5. Invoke WebDriver BiDi user prompt closed with document 's relevant global object and true if unloadPromptCanceled is false or false otherwise.
8. ~~Return~~ Decrease the response document 's unload counter by 1.
9. Increment completedTasks.
~~In addition~~
Wait for completedTasks to ~~the specific issues linked above,~~ be totalTasks.
Return unloadPromptCanceled.

7.4.3 Reloading and traversing javascript: URLs have

To reload a ~~dedicated label~~ navigable on navigable:

Set navigable 's active session history entry 's document state 's reload pending to true.
Let traversable be navigable 's traversable navigable .
Append the ~~issue tracker documenting various problems with their specification.~~ following session history traversal steps to traversable:
1. ~~Some of~~ Apply pending history changes to traversable with true.
  It is intentional that the ~~sections below,~~ resulting call to ~~which~~ apply the ~~above algorithm defers~~ history step does not pass sourceSnapshotParams or initiatorToCheck . Reloading is always treated as if it were done by navigable itself, even in ~~certain cases, use~~ cases like parent.location.reload().

To traverse the ~~following steps to create and initialize~~ history by a ~~Document object ,~~ delta given a ~~type~~ traversable navigable type traversable, ~~content type~~ an integer contentType delta, and ~~navigation params~~ an optional Document navigationParams sourceDocument:

Let browsingContext sourceSnapshotParams and initiatorToCheck be null.
If sourceDocument is given, then:
1. Set sourceSnapshotParams to the result of ~~the obtaining a browsing context to use for a navigation response~~ snapshotting source snapshot params given navigationParams 's browsing context , navigationParams 's final sandboxing flag set , sourceDocument.
2. Set navigationParams initiatorToCheck ~~'s cross-origin opener policy , and~~ to navigationParams sourceDocument 's ~~COOP enforcement result~~ node navigable .
Append the following session history traversal steps to traversable:
1. Let permissionsPolicy allSteps be the result of ~~creating a permissions policy from a response~~ getting all used history steps ~~given~~ for browsingContext , traversable.
2. Let navigationParams currentStepIndex be the index of traversable 's ~~origin~~ current session history step within allSteps.
3. Let targetStepIndex be currentStepIndex plus delta.
4. If allSteps [ targetStepIndex ] does not exist , ~~and~~ then abort these steps.
5. Apply the history step navigationParams allSteps ~~'s response . [PERMISSIONSPOLICY]~~ [ targetStepIndex ] to traversable, with checkForUserCancelation set to true, sourceSnapshotParams set to sourceSnapshotParams, and initiatorToCheck set to initiatorToCheck.

7.4.4 Non-fragment synchronous "navigations"

~~The creating a permissions policy~~ Apart from ~~a response~~ the navigate ~~algorithm makes use of~~ algorithm, session history entries can be pushed or replaced via one more mechanism, the ~~passed origin~~ URL and history update steps . If The most well-known callers of these steps are the document.domain history.replaceState() ~~has been used for browsingContext 's container document , then its origin cannot be same origin-domain~~ and history.pushState() with APIs, but various other parts of the ~~passed origin, because~~ standard also need to perform updates to the active history entry , and they use these steps ~~run before the~~ to do so.

The URL and history update steps , given a Document document, a URL newURL, an optional serialized state -or-null serializedData ~~is created, so it cannot itself yet have used~~ ~~document.domain~~ (default null), and an optional history handling behavior ~~. Note that this means that Permissions Policy checks are less permissive compared to doing a same origin~~ historyHandling (default " replace check instead. See below for some examples of this in action. "), are:

Let creationURL navigable be navigationParams document 's ~~response 's URL~~ node navigable .
If Let navigationParams activeEntry be navigable 's ~~request~~ active session history entry .
Let newEntry be a new session history entry , with
URL
newURL
serialized state
if serializedData is ~~non-null, then set~~ not null, creationURL serializedData to ; otherwise navigationParams activeEntry 's ~~request~~ serialized state
document state
activeEntry 's ~~current URL .~~ document state
scroll restoration mode
activeEntry 's scroll restoration mode
persisted user state
activeEntry 's persisted user state
If browsingContext document 's is ~~still on its~~ initial about:blank ~~Document~~ ~~, and navigationParams 's history handling~~ is true, then set historyHandling to " replace ~~", and browsingContext 's active document 's origin is same origin-domain with navigationParams 's origin , then do nothing.~~ ".

This means that ~~both the~~ pushState() on an initial about:blank ~~Document , and the new~~ Document ~~that is about to be created, will share the same~~ behaves as a Window replaceState() ~~object. Otherwise:~~ call.
Let oacHeader entryToReplace be ~~the result of getting a structured field value given `~~ activeEntry if historyHandling is " Origin-Agent-Cluster replace ~~` and~~ ", otherwise null.
If historyHandling is " ~~item~~ push ~~" from~~ ", then:
1. Increment response document 's ~~header list~~ history object 's index .
2. ~~Let~~ Set requestsOAC document ~~be true if~~ 's history object 's length to its index + 1.
These are temporary best-guess values for immediate synchronous access.
If oacHeader serializedData is not ~~null~~ null, then restore the history object state given document and oacHeader newEntry.
Set document ~~[0]~~ 's URL to newURL.
Since this is ~~the boolean~~ neither a navigation ~~true; otherwise false.~~ nor a history traversal , it does not cause a hashchange event to be fired.
If Set navigationParams document 's ~~reserved environment~~ latest entry ~~is a non-secure context , then set~~ to requestsOAC newEntry.
Set navigable 's active session history entry to ~~false.~~ newEntry.
Let agent traversable be ~~the result of obtaining a similar-origin window agent given~~ navigationParams navigable 's ~~origin ,~~ traversable navigable .
Append the following session history synchronous navigation steps involving browsingContext navigable ~~'s group , and~~ to requestsOAC . traversable:
1. ~~Let~~ Finalize a same-document navigation given realm execution context be traversable,navigable,newEntry, and entryToReplace.

Although both fragment navigation and the ~~result~~ URL and history update steps perform synchronous history updates, only fragment navigation contains a synchronous call to update document for history step application . The URL and history update steps instead perform a few select updates inside the above algorithm, omitting others. This is somewhat of an unfortunate historical accident, and generally leads to web-developer sadness about the inconsistency. For example, this means that popstate events fire for fragment navigations, but not for history.pushState() calls.

7.4.5 Populating a session history entry

As explained in the overview , both navigation and traversal involve creating a ~~new realm~~ session history entry ~~given agent~~ and then attempting to populate its document member, so that it can be presented inside the ~~following customizations:~~ navigable .

This involves either: using an already-given response ; using the srcdoc resource stored in the session history entry ; or fetching . The process has several failure modes, which can either result in doing nothing (leaving the navigable on its currently- active Document ) or can result in populating the session history entry with an error document .

~~For~~ To attempt to populate the ~~global object, create~~ history entry's document for a ~~new~~ session history entry entry, given a navigable navigable, a Window NavigationTimingType ~~object.~~ navTimingType, a source snapshot params sourceSnapshotParams, a target snapshot params targetSnapshotParams, an optional navigation ID -or-null navigationId (default null), an optional navigation params -or-null navigationParams (default null), an optional string cspNavigationType (default " other "), an optional boolean allowPOST (default false), and optional algorithm steps completionSteps (default an empty algorithm):

~~For the global~~ Assert : this ~~binding, use~~ is running in parallel .
Assert : if browsingContext navigationParams is non-null, then navigationParams 's ~~WindowProxy~~ response ~~object.~~ is non-null.
Let topLevelCreationURL currentBrowsingContext be creationURL . navigable 's active browsing context .
Let topLevelOrigin documentResource be navigationParams entry 's ~~origin~~ document state 's resource .
If browsingContext navigationParams is ~~not a top-level browsing context ,~~ null, then:
1. ~~Let~~ If parentEnvironment documentResource be is a string, then set browsingContext navigationParams ~~'s container~~ to the result of creating navigation params from a srcdoc resource ~~'s relevant settings object .~~ given entry,navigable,targetSnapshotParams,navigationId, and navTimingType.
2. Otherwise, if both of the following are true:
  - ~~Set topLevelCreationURL to~~ parentEnvironment entry 's ~~top-level creation~~ URL . is a fetch scheme ; and
  - ~~Set~~ topLevelOrigin documentResource to is null, or parentEnvironment allowPOST is true and documentResource 's ~~top-level origin .~~ request body is not failure
  ~~Set up a window environment settings object~~ then set navigationParams to the result of creating navigation params by fetching ~~with~~ given creationURL entry, realm execution context navigable, navigationParams 's reserved environment , sourceSnapshotParams, topLevelCreationURL targetSnapshotParams,cspNavigationType,navigationId, and topLevelOrigin navTimingType. ~~This~~
3. Otherwise, if entry 's URL 's scheme is ~~the usual case, where the~~ not a fetch scheme , then set navigationParams to a new non-fetch scheme navigation params , with
  ~~Document~~
  initiator origin ~~we're about to create gets a new~~
  ~~Window~~ entry 's document state 's initiator origin
Queue a global task on the navigation and traversal task source , given navigable 's active window , to ~~go along with it.~~ run these steps:
1. If navigable 's ongoing navigation no longer equals navigationId, then run completionSteps and return.
2. Let loadTimingInfo failure be false.
3. If navigationParams is a ~~new~~ non-fetch scheme navigation params , then set entry 's document ~~load timing info~~ state ~~with its navigation start time~~ 's document ~~set~~ to the result of running attempt to create a non-fetch scheme document given response entry 's ~~timing info~~ URL ,navigable,targetSnapshotParams 's ~~start time~~ sandboxing flags ,navigationId,navTimingType,sourceSnapshotParams 's has transient activation , and navigationParams 's initiator origin . ~~Let~~
  
  The document entry ~~be a new Document~~ 's URL might have been changed within the previous step of this algorithm following an HTTP redirect.
4. ~~, whose type~~
  Otherwise, if navigationParams is null, then set failure to true.
5. Otherwise, if the result of should navigation response to navigation request of type ~~, content type~~ in target be blocked by Content Security Policy? is given contentType , origin is navigationParams 's request , navigationParams 's ~~origin~~ response , ~~policy container is~~ navigationParams 's policy container ~~, permissions policy~~ is 's CSP list , permissionsPolicy cspNavigationType, ~~active sandboxing flag~~ and currentBrowsingContext is " Blocked ", then set failure to true. [CSP] is
6. Otherwise, if navigationParams 's ~~final sandboxing flag set ,~~ reserved environment is non-null and ~~cross-origin opener~~ the result of checking a navigation response's adherence to its embedder policy is given navigationParams 's ~~cross-origin opener policy~~ response , ~~load timing info is~~ loadTimingInfo navigable, and ~~navigation id is~~ navigationParams 's ~~id . The new Window~~ policy container 's ~~associated Document~~ embedder policy is false, then set to document failure ~~later, when the caller of this algorithm updates the session history with the new page . That algorithm sets~~ to true.
7. Otherwise, if the ~~active document as part of its larger role~~ result of ~~synchronizing the Window~~ checking a navigation response's adherence to ` X-Frame-Options ` ~~, Document~~ given navigationParams 's response ,navigable,navigationParams 's policy container ~~, browsing context~~ 's CSP list , and ~~session history . Set~~ document navigationParams 's ~~URL~~ origin is false, then set failure to true.
8. If creationURL . failure is true, then:
  1. Set document entry 's ~~current~~ document state 's document ~~readiness~~ to ~~" loading ". Run CSP initialization~~ the result of creating a document for inline content that doesn't have a ~~Document~~ DOM , given document navigable, null, and navTimingType. ~~[CSP]~~ The inline content should indicate to the user the sort of error that occurred.
  2. Set entry 's document state 's document 's salvageable to false.
  3. If navigationParams ~~'s request~~ is ~~non-null,~~ not null, then:
    1. ~~Set~~ Run the environment discarding steps for document navigationParams 's ~~referrer to the empty string.~~ reserved environment .
    2. ~~Let~~ Invoke WebDriver BiDi navigation failed with referrer currentBrowsingContext be and a new WebDriver BiDi navigation status whose id is navigationId, status is " canceled ", and url is navigationParams 's ~~request~~ response 's ~~referrer~~ URL .
9. ~~If referrer is a URL record , then set~~ Otherwise, if document navigationParams 's ~~referrer~~ response ~~to the serialization~~ 's status of is 204 or 205, then:
  1. Run referrer completionSteps. ~~Per Fetch ,~~
  2. Return.
10. Otherwise, if referrer navigationParams ~~will be either~~ 's response has a ~~URL record~~ ` Content-Disposition or " ` header specifying the no-referrer attachment ~~" at this point.~~ disposition type, then:
  1. Let historyHandling sourceAllowsDownloading be navigationParams sourceSnapshotParams 's ~~history handling~~ allows downloading .
  2. Let navigationTimingType targetAllowsDownloading be ~~the result of switching on~~ false if navigationParams 's ~~history handling : " default " " replace " " navigate " " reload " " reload " " entry update~~ final sandboxing flag set ~~" " back_forward~~ has the sandboxed downloads browsing context flag " set; otherwise true.
  3. ~~Let~~ If the result of running allowed to download with redirectCount sourceAllowsDownloading ~~be 0 if~~ and navigationParams targetAllowsDownloading ~~'s response 's has-cross-origin-redirects~~ is ~~true; otherwise~~ true, then handle navigationParams 's ~~request~~ response ~~'s redirect count~~ as a download .
  4. ~~Create the navigation timing entry~~ Invoke WebDriver BiDi download started ~~for document ,~~ with navigationParams currentBrowsingContext ~~'s response~~ and a new WebDriver BiDi navigation status ~~'s timing info , redirectCount ,~~ whose id is navigationTimingType navigationId, status is " complete ", and url is navigationParams 's response 's ~~service worker timing info~~ URL .
  5. If Run navigationParams 's response has a ` Refresh completionSteps.
  6. ~~` header, then:~~
    Return.
11. Otherwise:
  1. Let value document be the ~~isomorphic decoding of the value~~ result of ~~the header. Run the shared declarative refresh steps~~ loading a document ~~with~~ given document navigationParams,sourceSnapshotParams, and value . We do not currently have a spec for how to handle multiple ` Refresh entry 's document state ~~` headers. This is tracked as issue #2900~~ 's initiator origin .
  2. If navigationParams document ~~'s commit early hints~~ is ~~not~~ null, then ~~call~~ run navigationParams completionSteps and return.
  3. Set entry 's ~~commit early hints~~ document state ~~with~~ 's document to document.
  4. ~~Process link headers given~~ Set entry 's document , state 's origin to navigationParams document 's ~~response , and " pre-media ".~~ origin .
12. ~~Return~~ If entry 's document ~~. In this example, the child document is not allowed to use PaymentRequest~~ state ~~, despite being same origin-domain~~ 's request referrer ~~at the time the child document tries~~ is " client ", then set it to request 's referrer .
  This ensures that if we traverse back entry and have to refetch, we use ~~it. At~~ the ~~time the child document is initialized, only~~ same referrer , instead of deriving the ~~parent document has set document.domain , and~~ referrer from the ~~child document has not.~~ fetch client.
   <!doctype html> <script> document.domain = 'example.com'; </script> <iframe src=b.html></iframe>  <!doctype html> <script> document.domain = 'example.com'; // This happens after the document is initialized new PaymentRequest(…); // Not allowed to use </script>
13. ~~In this example, the child~~ If entry 's document ~~is allowed to use PaymentRequest , despite not being same origin-domain~~ state ~~at the time the child document tries to use it. At the time the child~~ 's document is ~~initialized, none of the documents have~~ not null, then set ~~document.domain~~ entry 's document state ~~yet so same origin-domain~~ 's ever populated ~~falls back~~ to a normal same origin check.  <!doctype html> <iframe src=b.html></iframe>  <script> document.domain = 'example.com'; </script>  <!doctype html> <script> new PaymentRequest(…); // Allowed to use </script> true.
14. ~~Some of the sections below, to which the above algorithm defers in certain cases, require the user agent to update the session history with the new page , given some~~ Run completionSteps.

To create navigation params from a srcdoc resource given a session history entry navigationParams and entry, a ~~Document~~ navigable newDocument . When a user agent is required to do this, it must queue navigable, a ~~global task~~ target snapshot params ~~on the networking task source , given the relevant global object~~ targetSnapshotParams, a navigation ID ~~of the~~ -or-null navigationId, and a Document NavigationTimingType ~~object of the current entry (not the new one), to run the following steps:~~ navTimingType:

Let sessionHistory documentResource be navigationParams entry 's ~~browsing context~~ document state 's ~~session history~~ resource .
Let unloadTimingInfo response be a new ~~document unload timing info .~~ response with
URL
about:srcdoc
header list
« (` Content-Type `, ` text/html `) »
body
the UTF-8 encoding of documentResource, as a body
Let previousDocument responseOrigin be the result of determining the origin given sessionHistory response 's ~~current~~ URL ,targetSnapshotParams 's sandboxing flags , null, and entry 's document state 's origin .
~~Unload~~
Let previousDocument coop ~~with~~ be a new cross-origin opener policy .
Let unloadTimingInfo coopEnforcementResult ~~and~~ be a new cross-origin opener policy enforcement result whose needs a browsing context group switch is false, would need a browsing context group switch due to report-only is false, url is newDocument response 's ~~relevant global object . If this instance of the navigation~~ URL , origin ~~algorithm~~ is ~~canceled while this step is running the unload a document algorithm, then the unload a document~~ responseOrigin, cross-origin opener policy ~~algorithm must be allowed to run to completion, but this instance of the~~ is coop, and current context is navigation source algorithm must not run beyond this step. (In particular, for instance, the cancelation of this algorithm does not abort any event dispatch or script execution occurring as part of unloading the document or its descendants.) is false.
If Let newDocument policyContainer ~~'s event loop~~ be the result of determining navigation params policy container ~~is not~~ given previousDocument response 's ~~event loop~~ URL , ~~then the user agent may unload~~ previousDocument entry ~~in parallel~~ 's document state 's history policy container , ~~In that case, the user agent should set~~ null, unloadTimingInfo navigable to 's container document 's policy container , and null.
If Return a new navigation params , with
id
navigationParams navigationId ~~'s response~~
request ~~'s has-cross-origin-redirects~~
null
response ~~is false, and~~
newDocument response 's
origin ~~is the same~~
responseOrigin
policy container as
previousDocument policyContainer ~~'s origin , then~~
final sandboxing flag set
newDocument targetSnapshotParams's ~~'s previous document unload timing~~ sandboxing flags to
cross-origin opener policy
unloadTimingInfo . Switch on coop
COOP enforcement result
navigationParams coopEnforcementResult ~~'s history handling :~~
" ~~entry update~~ reserved environment "
null
" ~~reload~~ navigable "
navigable
navigation timing type
navTimingType
fetch controller
null
commit early hints
null

To create navigation params by fetching given a session history entry entry, a navigable navigable, a source snapshot params sourceSnapshotParams, a target snapshot params targetSnapshotParams, a string cspNavigationType, a navigation ID -or-null navigationId, and a NavigationTimingTypenavTimingType, perform the following steps. They return a navigation params , a non-fetch scheme navigation params , or null.

This algorithm mutates entry.

Assert : this is running in parallel .
Let oldDocument documentResource be sessionHistory entry 's ~~current entry~~ document state 's ~~document~~ resource .
Let request be a new request , with
~~For each~~
url
entry ~~of sessionHistory : if~~ 's URL
policy container
entry 's document state is 's history policy container
client
oldDocument , then sourceSnapshotParams 's fetch client
destination
" document "
credentials mode
" include "
use-URL-credentials flag
set
redirect mode
" manual "
replaces client id
entry navigable 's active document ~~to newDocument .~~ 's relevant settings object 's id
~~Traverse the history~~ mode to
" navigate "
referrer
sessionHistory entry 's ~~current~~ document state 's request referrer
referrer policy
entry 's document state 's request referrer policy ~~with~~ ~~historyHandling~~
If documentResource is a POST resource , then:
1. Set request 's method to ` POST `.
2. Set request ~~set~~ 's body to navigationParams documentResource 's ~~history handling~~ request body . "
3. ~~replace~~
  Set ` Content-Type " ` to documentResource 's request content-type in request 's header list .
~~Let~~ If newEntry be a new session history entry 's document state ~~whose URL~~ 's reload pending is true, then set newDocument request 's ~~URL and~~ reload-navigation flag .
Otherwise, if entry 's document state 's ever populated is true, then set newDocument . Some browsers copy over the serialized state request 's history-navigation flag .
If sessionHistory sourceSnapshotParams 's ~~current entry in cases where its URL~~ has transient activation ~~equals~~ is true, then set request 's user-activation ~~that of~~ to true.
If newDocument , but this is inconsistent. See issue #6213 navigable 's container ~~for more discussion on this.~~ is non-null:
1. If the newDocument navigable 's ~~URL requires storing the policy~~ container ~~in history~~ has a browsing context scope origin , then set newEntry request 's ~~policy container~~ origin to that browsing context scope origin .
2. Set navigationParams request 's ~~policy~~ destination and initiator type to navigable 's container 's local name .
~~Insert~~ Let newEntry response ~~into~~ be null.
Let sessionHistory responseOrigin ~~after its current entry .~~ be null.
~~Traverse the history to~~ Let newEntry fetchController be null.
Let coopEnforcementResult be a new cross-origin opener policy enforcement result , with

~~historyHandling~~
needs a browsing context group switch ~~set~~
false
would need a browsing context group switch due to " report-only ~~replace~~
false
url
navigable 's active document 's URL ".
" ~~default~~ origin "
~~Remove all the entries in~~ sessionHistory navigable ~~after its current entry . (If the current entry~~ 's active document ~~is the last entry in the session history, then no entries are removed.) This doesn't necessarily have to affect~~ 's origin ~~the user agent's user interface.~~ ~~Let~~
cross-origin opener policy
newEntry navigable ~~be a new session history entry~~ 's active document ~~whose URL~~ 's cross-origin opener policy
current context is navigation source
true if newDocument navigable 's ~~URL and~~ active document 's origin is same origin with newDocument . entry 's document state 's initiator origin otherwise false
If Let newDocument finalSandboxFlags ~~'s URL requires storing the policy container in history , then~~ be an empty sandboxing flag set .
Let newEntry responsePolicyContainer ~~'s policy container to~~ be null.
Let navigationParams responseCOOP 's be a new cross-origin opener policy ~~container~~ .
~~Append~~ Let newEntry locationURL ~~to sessionHistory .~~ be null.
~~Traverse the history to~~ Let newEntry . currentURL be request 's current URL .
~~The navigation algorithm has now matured .~~ Let commitEarlyHints be null.

While true:

~~Try to scroll to the fragment~~

If request 's reserved client ~~for~~ is not null and newDocument . To try to scroll to currentURL 's origin is not the ~~fragment for a Document~~ same as document , perform the following steps in parallel : request 's reserved client 's creation URL 's origin , then:
1. ~~Wait~~ Run the environment discarding steps for ~~an implementation-defined~~ request 's reserved client .
2. Set request 's reserved client ~~amount of time. (This is intended~~ to ~~allow the user agent~~ null.
3. Set commitEarlyHints to ~~optimize the user experience~~ null.
  Preloaded links from early hint headers remain in the ~~face of performance concerns.) Queue~~ preload cache after a ~~global task~~ same origin on redirect, but get discarded when the ~~networking task source given~~ redirect is cross-origin.
If document request 's ~~relevant global object~~ reserved client ~~to run these steps:~~ is null, then:
1. Let topLevelCreationURL be currentURL.
2. Let topLevelOrigin be null.
3. If document navigable ~~has no parser, or its parser has stopped parsing , or the user agent has reason to believe the user~~ is ~~no longer interested in scrolling to the fragment~~ not a top-level traversable , ~~then abort these steps.~~ then:
  1. Let parentEnvironment be navigable 's parent 's active document 's relevant settings object .
  2. ~~Scroll~~
    Set topLevelCreationURL to ~~the fragment given in~~ document parentEnvironment 's top-level creation URL . ~~If this does not find an indicated part of the document , then try~~
  3. Set topLevelOrigin to ~~scroll~~ parentEnvironment 's top-level origin .
4. Set request 's reserved client to ~~the fragment~~ a new environment ~~for~~ whose id is a unique opaque string, target browsing context is document . 7.11.2 Page load processing model for HTML files navigable 's active browsing context , creation URL ~~When an HTML document~~ is ~~to be loaded , given navigation params~~ currentURL, top-level creation URL is navigationParams topLevelCreationURL, and top-level origin is topLevelOrigin.
  The created environment's active service worker is set in the ~~user agent must queue a task~~ Handle Fetch on algorithm during the ~~networking task source~~ fetch if the request URL matches a service worker registration. [SW] ~~to:~~
~~Let document be~~ If the result of ~~creating and initializing a Document object~~ should navigation request of type be blocked by Content Security Policy? given request and cspNavigationType is " html ", " text/html Blocked ", then set response to a network error and break . [CSP]
Set navigationParams . response to null.
~~Create an HTML parser and associate it with the~~ If document . Each task that the networking task source places on the task queue while fetching runs must fetchController is null, then ~~fill~~ set fetchController to the ~~parser's input byte stream~~ result of fetching request, with ~~the fetched bytes~~ processEarlyHintsResponse set to processEarlyHintsResponse, processResponse set to processResponse, and ~~cause the HTML parser~~ useParallelQueue set to ~~perform the appropriate processing of the input stream.~~ true.

~~The first task that~~ Let processEarlyHintsResponse be the ~~networking task source~~ following algorithm given a response ~~places on~~ earlyResponse:
1. If commitEarlyHints is null, then set commitEarlyHints to the ~~task queue while fetching runs must process link~~ result of processing early hint headers given document , earlyResponse and navigationParams request 's ~~response , and " media ", after the task has been procesed by the HTML parser~~ reserved client .
Let processResponse be the following algorithm given a response fetchedResponse:
~~The input byte stream~~
1. Set response to fetchedResponse.
Otherwise, process the next manual redirect ~~converts bytes into characters~~ for ~~use in the tokenizer .~~ fetchController.
This ~~process relies, in part, on character encoding information found~~ will result in calling the ~~real Content-Type metadata~~ processResponse ~~of the resource;~~ we supplied above, during our first iteration through the ~~computed type is not used for this purpose.~~ loop, and thus setting response.
~~When no more bytes are available, the user agent must queue a global task on~~
Navigation handles redirects manually as navigation is the ~~networking task source given~~ only place in the ~~newly-created~~ web platform that cares for redirects to Document mailto: URLs and such.
Wait until either response is non-null, or navigable 's ~~relevant global object~~ ongoing navigation changes to ~~run~~ no longer equal navigationId.
If the ~~following steps:~~ latter condition occurs, then abort fetchController, and return.
Otherwise, proceed onward.
~~Call~~ If navigationParams request 's ~~process response end of~~ body ~~with~~ is null, then set navigationParams entry 's ~~response .~~ document state 's resource to null.
Fetch unsets the body for particular redirects.
~~Have the parser process~~ Set responsePolicyContainer to the ~~implied EOF character, which eventually causes~~ result of creating a ~~load~~ policy container from a fetch response given response and request 's reserved client .
~~event to be fired.~~
~~After creating~~ Set finalSandboxFlags to the ~~Document~~ union of targetSnapshotParams 's sandboxing flags and responsePolicyContainer 's CSP list 's CSP-derived sandboxing flags .
~~object, but before any script execution, certainly before the parser stops , the user agent must update~~
Set responseOrigin to the ~~session history with~~ result of determining the ~~new page~~ origin given navigationParams response ~~and the newly-created Document~~ 's URL ,finalSandboxFlags,entry 's document state . 's initiator origin , and null.
If navigable is a top-level traversable , then:
~~7.11.3 Page load processing model for XML files~~
1. ~~When faced with displaying an XML file inline, provided navigation params~~ Set navigationParams responseCOOP ~~and a string type , user agents must follow the requirements defined in XML and Namespaces in XML , XML Media Types , DOM , and other relevant specifications~~ to ~~create and initialize~~ the result of obtaining a ~~Document object~~ cross-origin opener policy ~~document ,~~ given ~~" xml ",~~ type , response and navigationParams . They must also create a corresponding XML parser request 's reserved client . ~~[XML] [XMLNS] [RFC7303] [DOM]~~
2. ~~The first task that~~ Set coopEnforcementResult to the ~~networking task source places on~~ result of enforcing the ~~task queue while fetching runs must process link headers~~ response's cross-origin opener policy given document , navigable 's active browsing context , navigationParams request 's ~~response~~ URL , responseOrigin,responseCOOP,coopEnforcementResult and request 's referrer .
3. If sandboxFlags is not empty and responseCOOP 's value is not " ~~media~~ unsafe-none ", ~~after the task has been procesed by the XML parser~~ then set response to an appropriate network error and break .
  
  At the time of writing, the XML specification community had not actually yet specified how XML and the DOM interact. The actual HTTP headers and other metadata, not the headers as mutated or implied by the algorithms given This results in ~~this specification, are the ones that must be used when determining the character encoding according~~ a network error as one cannot simultaneously provide a clean slate to a response using cross-origin opener policy and sandbox the ~~rules given in the above specifications. Once the character encoding is established, the document's character encoding must be set~~ result of navigating to that ~~character encoding.~~ response.
~~Then, with document , the user agent must update the session history with the new page given~~ If navigationParams response ~~and~~ is not a network error , document . User agents may do this before the complete document has been parsed (thus achieving incremental rendering ), navigable is a child navigable , and ~~must do this before any scripts are to be executed. When no more bytes are available,~~ the ~~user agent must queue~~ result of performing a ~~global task on the networking task source~~ cross-origin resource policy check ~~given~~ with document navigable 's ~~relevant global object~~ container document ~~to call~~ 's origin , navigationParams navigable 's ~~process response end of body~~ container document ~~with~~ 's relevant settings object , navigationParams request 's destination ,response . Once parsing, and true is ~~complete, the user agent must~~ blocked , then set document response ~~'s navigation id~~ to ~~null.~~ a network error and break .

~~For HTML documents this is reset when parsing~~ Here we're running the cross-origin resource policy check against the parent navigable rather than navigable itself. This is ~~complete, after firing~~ because we care about the ~~load event. Error messages from~~ same-originness of the ~~parse process (e.g., XML namespace well-formedness errors) may be reported inline by mutating~~ embedded content against the ~~Document .~~ parent context, not the navigation source.
~~7.11.4 Page load processing model for text files~~
~~When a plain text document is to be loaded, provided navigation params~~ Set navigationParams locationURL ~~and a string~~ to type , the user agent must queue a task on the networking task source response 's location URL ~~to:~~ given currentURL 's fragment .
If locationURL is failure or null, then break .
~~Let~~ Assert : document locationURL ~~be the result of creating and initializing~~ is a ~~Document object given " html ", type , and navigationParams .~~ URL .
Set document entry 's ~~parser cannot change the mode flag~~ serialized state to ~~true.~~ null.
~~Set~~ Let document oldDocState be entry 's ~~mode to " no-quirks ".~~ document state .

~~Create an HTML parser and associate it with the~~ Set entry 's document ~~. Act as if the tokenizer had emitted a start tag token with the tag name "pre" followed by a single U+000A LINE FEED (LF) character, and switch the HTML parser~~ state ~~'s tokenizer~~ to ~~the PLAINTEXT~~ a new document state ~~. Each task that the networking task source places on the task queue while fetching runs must then fill the parser's input byte stream~~ , with ~~the fetched bytes and cause the HTML parser~~

history policy container to perform the appropriate processing of the input stream. The rules for how to convert the bytes of the plain text document into actual characters, and the rules for actually rendering the text to the user, are defined by the specifications for the computed MIME type: a clone of the ~~resource (i.e.,~~ type oldDocState ~~). The document's character encoding must be set to the character encoding used to decode the document. The first task~~ 's history policy container ~~that the networking task source~~
request referrer ~~places on the task queue~~: oldDocState 's request referrer ~~while fetching runs must process link headers~~
request referrer policy ~~given document ,~~: navigationParams oldDocState 's ~~response , and " media ", after the task has been procesed by the HTML parser . When no more bytes are available, the user agent must queue a global task on the networking task source~~ request referrer policy ~~given the newly-created~~ ~~Document~~
origin: oldDocState 's ~~relevant global object~~ origin ~~to run the following steps:~~
resource: ~~Call~~ navigationParams oldDocState 's ~~process response end of body~~ resource ~~with~~
ever populated: navigationParams oldDocState 's ~~response .~~ ever populated ~~Have the parser process the implied EOF character, which eventually causes a~~
~~load~~ navigable target name ~~event to be fired. After creating the~~: ~~Document~~ oldDocState 's navigable target name ~~object, but potentially before~~

For the ~~page has finished parsing,~~ navigation case, only entry referenced oldDocState, which was created early in the ~~user agent must~~ navigate algorithm . So for navigations, this is functionally just an update to entry 's document state . For the traversal case, it's possible adjacent session history ~~with the new page~~ entries ~~given~~ also reference navigationParams oldDocState, in which case they will continue doing so even after we've updated entry ~~and the newly-created Document .~~ 's document state .

~~User agents may add content to~~ The setup is given by the following Jake diagram :

~~head~~ ~~element of the~~ ~~Document~~ ~~title~~ . In particular, if the user agent supports the Format=Flowed feature of RFC 3676 then the user agent would need to apply extra styling to cause the text to wrap correctly and to handle the quoting feature. This could be performed using, e.g., a CSS extension.

~~, e.g., linking to a style sheet, providing script, or giving the document a~~	0	1	2	3
~~7.11.5 Page load processing model for~~ `multipart/x-mixed-replace top` ~~resources~~	/a	/a#foo	/a#bar	/b

~~When a resource with~~ Also assume that the ~~type multipart/x-mixed-replace~~ document state ~~is to be loaded~~ shared by the entries in steps 0, 1, and 2 has a ~~browsing context~~ null document , ~~the user agent must parse the resource using the rules for multipart types. [RFC2046]~~ i.e., bfcache ~~This algorithm~~ is ~~passed navigation params , but it's unclear how exactly to use them.~~ not in play.

~~For each body part obtained from the resource, the user agent must run process a navigate response using the new body part and~~ Now consider the ~~same browsing context , with history handling set~~ scenario where we traverse back to ~~" replace " if a previous body part from~~ step 2, but this time when fetching /a, the ~~same resource resulted in a creating and initializing~~ server responds with a ` Document Location ` header pointing to /c. That is, locationURL points to /c ~~object ,~~ and ~~otherwise using the same setup as the navigate attempt that caused~~ so we have reached this ~~section to be invoked in~~ step instead of breaking out of the ~~first place.~~ loop.

~~For~~ In this case, we replace the ~~purposes~~ document state of ~~algorithms processing these body parts as if they were complete stand-alone resources,~~ the ~~user agent must act as if there were no more bytes for those resources whenever~~ session history entry occupying step 2, but we do not replace the ~~boundary following~~ document state of the ~~body part is reached.~~ entries occupying steps 0 and 1. The resulting Jake diagram looks like this:

~~Thus,~~ ~~load~~ ~~events (and for that matter~~ ~~unload~~ ~~7.11.6 Page load processing model for media~~

~~events) do fire for each body part loaded.~~	0	1	2	3
`top`	/a	/a#foo	/c#bar	/b

~~When an image, video, or audio resource is to be loaded, provided navigation params navigationParams and~~ Note that we perform this replacement even if we end up in a ~~string type , the user agent should: Let document be~~ redirect chain back to the ~~result of creating and initializing a~~ original URL, for example if Document /c ~~object given "~~ itself had a ` html Location ~~", type , and navigationParams . Set document 's mode~~ ` header pointing to " no-quirks ". Append an html element to document . Append /a. Such a case would end up like so:

~~head~~ ~~element to the~~ ~~html~~ ~~Append a~~ ~~body~~

~~element.~~	0	1	2	3
`top` ~~element to the~~ ~~html~~	/a	/a#foo	/a#bar	/b

If locationURL 's scheme is not an HTTP(S) scheme , then:
1. ~~Append an element~~ Set host element entry ~~for the media, as described below,~~ 's document state 's resource to ~~the~~ null.
2. ~~body~~
  ~~element.~~ Break .
Set ~~the appropriate attribute of the element~~ host element , as described below, currentURL to ~~the address of the image, video, or audio resource.~~ locationURL.
~~Process link headers given document ,~~ Set navigationParams entry 's ~~response , and " media ".~~ URL to currentURL.

~~The element host element to create for the media is the element given in the table below in~~ By the ~~second cell~~ end of ~~the row whose first cell describes the media. The appropriate attribute to set is the one given by the third cell~~ this loop we will be in ~~that same row.~~ one of these scenarios:

~~Type~~ locationURL is failure, because of ~~media Element for the media Appropriate attribute Image img src~~ an unparseable ` Location ~~Video video~~ ` header.
~~src~~ locationURL is null, either because response is a network error ~~Audio audio~~ or because we successfully fetched a non- network error HTTP(S) response with no ` Location ~~src~~ ` header.
~~Then, the user agent must act as if it had stopped parsing . After creating the~~ ~~Document~~ locationURL is a URL ~~object, but potentially before the page has finished fully loading, the user agent must update the session history~~ with ~~the new page~~ a non- HTTP(S) ~~given~~ scheme .

If navigationParams locationURL ~~and the newly-created Document~~ is a URL . whose scheme is not a fetch scheme , then return a new non-fetch scheme navigation params , with
~~User agents may add content to the~~
~~head~~
initiator origin ~~element of the~~
~~Document~~ request 's current URL ~~, or attributes to the element~~

At this point, host element , e.g., to link to a style sheet, to provide a script, to give the document a title request 's current URL ~~, or to make~~ is the ~~media autoplay . When no more bytes are available,~~ last URL in the ~~user agent must queue~~ redirect chain with a ~~global task~~ fetch ~~on the networking task source~~ scheme ~~given the newly-created Document~~ before redirecting to a non- fetch scheme URL . It is this URL 's ~~relevant global object~~ origin that will be used as the initiator origin for navigations to ~~call navigationParams 's process response end of body~~ non- fetch scheme ~~with navigationParams 's response~~ URLs .
If any of the following are true:
- response is a network error ;
- ~~When~~ locationURL is failure; or
- locationURL is a ~~resource that requires an external resource to be rendered~~ URL whose scheme is a fetch scheme
then return null.
We allow redirects to ~~be loaded, provided navigation params~~ non- fetch scheme URLs , but redirects to fetch scheme URLs that aren't HTTP(S) are treated like network errors.
Assert : navigationParams locationURL is null and ~~a string~~ type , the user agent should: response is not a network error .
Let document resultPolicyContainer be the result of ~~creating and initializing a Document object~~ determining navigation params policy container given ~~" html ",~~ type , and navigationParams . Set document response 's ~~mode to " no-quirks ". Mark~~ URL , document entry ~~as being a plugin~~ 's document ~~Append an html~~ state ~~element to~~ 's history policy container , document sourceSnapshotParams 's source policy container , null, and responsePolicyContainer.
~~Append~~ Return a new navigation params , with
~~head~~
id ~~element to the~~
~~html~~ navigationId
request ~~element.~~
~~Append a~~ request ~~body~~
response ~~element to the~~
~~html~~ response
origin ~~element.~~
~~Append an~~ responseOrigin ~~embed~~
policy container ~~to the~~
~~body~~ resultPolicyContainer
final sandboxing flag set ~~element.~~
~~Set the~~ finalSandboxFlags ~~src~~
cross-origin opener policy ~~attribute of the~~
~~embed~~ responseCOOP
COOP enforcement result ~~element to the address of the resource.~~
coopEnforcementResult ~~Process link headers~~
reserved environment ~~given document ,~~
navigationParams request 's ~~response , and " media ". The term plugin document~~ reserved client ~~is used by Content Security Policy as part of the mechanism that ensures~~ ~~iframe~~
~~s can't be used to evade plugin-types directives. [CSP]~~ navigable ~~Then, the user agent must act as if it had stopped parsing . After creating the~~
~~Document~~ navigable ~~object, but potentially before the page has finished fully loading, the user agent must update the session history with the new page~~
navigation timing type ~~given~~
navigationParams navTimingType ~~and the newly-created~~ ~~Document~~
fetch controller ~~. User agents may add content to the~~
~~head~~ fetchController
commit early hints
commitEarlyHints

An element ~~of the~~ has a browsing context scope origin if its Document , or attributes to the embed ~~element, e.g. to link to a style sheet or to give the document~~ 's node navigable is a ~~title~~ top-level traversable ~~. If the~~ or if all of its Document 's ancestor navigables all have active ~~sandboxing flag set~~ documents whose origins are the same origin as the element's node document 's origin . If an element has ~~its sandboxed plugins~~ a browsing context ~~flag set,~~ scope origin , then its value is the ~~synthesized embed~~ origin ~~element will fail to render~~ of the ~~content~~ element's node document .

~~7.11.8 Page~~

This definition is broken and needs investigation to see what it was intended to express: see issue #4703 .

To load ~~processing model for inline content that doesn't have~~ a ~~DOM~~ document given navigation params ~~When the user agent is to display a user agent page inline, provided a browsing context~~ navigationParams, source snapshot params browsingContext sourceSnapshotParams, and origin initiatorOrigin, perform the ~~user agent should:~~ following steps. They return a Document or null.

Let navigationParams type be ~~a new navigation params whose request~~ the computed type ~~is null,~~ of navigationParams 's response ~~is null, origin is~~ .
If the user agent has been configured to process resources of the given type using some mechanism other than rendering the content in a ~~new opaque origin~~ navigable , ~~final sandboxing flag set~~ then skip this step. Otherwise, if the type is one of the following types:
an ~~empty set, cross-origin opener policy is a new cross-origin opener policy , COOP enforcement result~~ HTML MIME type ~~is a new cross-origin opener policy enforcement~~
Return the result ~~, reserved environment is null, process response end~~ of ~~body is~~ loading an ~~algorithm that does nothing, and browsing context is~~ HTML document , given browsingContext navigationParams. ~~The algorithm called in the next step~~
an XML MIME type that is not ~~prepared to deal with a null response . Probably we should synthesize one instead.~~ an explicitly supported XML MIME type ~~Let document be~~
Return the result of ~~creating and initializing a Document object~~ loading an XML document given ~~" html ", " text/html ", and~~ navigationParams . Set document ~~'s mode~~ and type.
a JavaScript MIME type ~~to " no-quirks ".~~ ~~Either associate document with~~
a ~~custom rendering~~ JSON MIME type that is not ~~rendered using the normal~~ an explicitly supported JSON MIME type ~~Document~~
" text/css rendering rules, or mutate document until it represents the content the user agent wants to render. Once the page has been set up, the user agent must act as if it had stopped parsing . After creating the "
" Document text/plain ~~object, but potentially before the page has been completely set up, the user agent must update the session history with~~ "
" text/vtt "
Return the ~~new page~~ result of loading a text document given navigationParams and ~~the newly-created Document . 7.11.9 Navigating to a fragment~~ type.
" multipart/x-mixed-replace To navigate to "
Return the result of loading a ~~fragment~~ multipart/x-mixed-replace document , given ~~a browsing context~~ browsingContext navigationParams, ~~a URL~~ url sourceSnapshotParams, and initiatorOrigin.
A supported image, video, or audio type
Return the result of loading a ~~history handling behavior~~ media document given historyHandling , navigationParams and type.
" application/pdf "
" text/pdf "
If the user agent's PDF viewer supported is true, return the result of creating a ~~navigation id~~ document for inline content that doesn't have a DOM given navigationId : navigationParams 's navigable .
Otherwise, proceed onward.

~~If historyHandling~~ An explicitly supported XML MIME type is ~~not "~~ an XML MIME type for which the user agent is configured to use an external application to render the content, or for which the user agent has dedicated processing rules. For example, a web browser with a built-in Atom feed viewer would be said to explicitly support the replace application/atom+xml ~~", then remove all the entries in browsingContext 's session history~~ MIME type.
An explicitly supported JSON MIME type is a JSON MIME type ~~after the current entry . (If~~ for which the ~~current entry~~ user agent is configured to use an external application to render the ~~last entry in~~ content, or for which the ~~session history, then no entries are removed.)~~ user agent has dedicated processing rules.

~~This doesn't necessarily have to affect~~ In both cases, the external application or user ~~agent's user interface. Remove any tasks queued by~~ agent will either display the ~~history traversal task source that are associated with any Document~~ content inline ~~objects~~ directly in browsingContext navigationParams 's ~~top-level browsing context 's document family~~ navigable , or hand it off to external software . Both happen in the steps below.
~~Append a~~ If, given type, the new ~~session history entry~~ resource is to be handled by displaying some sort of inline content, e.g., a native rendering of the ~~session history whose URL is url , document~~ content or an error message because the specified type is not supported, then return the ~~current entry~~ result of creating a document for inline content that doesn't have a DOM given navigationParams 's ~~document~~ navigable , ~~policy container is the current entry~~ navigationParams 's ~~policy-container~~ id , and ~~scroll restoration mode is the current entry~~ navigationParams 's ~~scroll restoration mode~~ navigation timing type .
~~Traverse~~ Otherwise, the ~~history to~~ document's type is such that the ~~new entry, with historyHandling~~ resource will not affect navigationParams ~~set~~ 's navigable , e.g., because the resource is to ~~historyHandling . This will scroll~~ be handed to ~~the fragment given in what~~ an external application or because it is ~~now the document's URL~~ an unknown type that will be processed as a download . ~~Invoke WebDriver BiDi fragment navigated~~ Hand-off to external software ~~with~~ given browsingContext , and a new WebDriver BiDi navigation status whose id is navigationParams 's response , navigationId , url is navigationParams 's navigable , resource navigationParams 's ~~url~~ final sandboxing flag set ,sourceSnapshotParams 's has transient activation , and ~~status is "~~ initiatorOrigin.
Return null.

7.4.6 Applying the history step complete ". If

For both navigation and traversal, once we have an idea of where we want to head to in the ~~scrolling fails because~~ session history, much of the ~~relevant ID has not yet been parsed, then~~ work comes about in applying that notion to the ~~original navigation~~ traversable navigable ~~algorithm will take care of~~ and the ~~scrolling instead, as~~ relevant Document. For navigations, this work generally occurs toward the ~~last few steps~~ end of ~~its update~~ the ~~session history with~~ process; for traversals, it is the ~~new page algorithm.~~ beginning.

7.4.6.1 Updating the traversable

~~When~~ Ensuring a traversable ends up at the ~~user agent~~ right session history step is ~~required to scroll to~~ particularly complex, as it can involve coordinating across multiple navigable descendants of the ~~fragment~~ traversable, populating them in parallel, and then synchronizing back up to ensure everyone has the ~~indicated part~~ same view of the ~~document , if any,~~ result. This is ~~being rendered , the user agent must either change the scrolling position of the document using the following algorithm, or perform some other action such that~~ further complicated by the ~~indicated part~~ existence of ~~the document~~ synchronous same-document navigations being mixed together with cross-document navigations, and how web pages have come to have certain relative timing expectations.

A changing navigable continuation state is ~~brought~~ used to store information during the ~~user's attention. If there is no indicated part, or if~~ apply the ~~indicated part is not being rendered , then~~ history step algorithm, allowing parts of the ~~user agent must do nothing. The aforementioned~~ algorithm to continue only after other parts have finished. It is ~~as follows:~~ a struct with:

~~If there is no indicated part of the~~ displayed document ~~, set the~~: A Document 's
target ~~element to null. If the indicated part of the document~~ entry: A session history entry ~~is the top of the document, then:~~
~~Set the~~ navigable ~~Document~~: A navigable ~~'s target element to null.~~
update only ~~Scroll to the beginning of~~: A boolean

To apply the ~~document~~ history step non-negative integer step to a traversable navigable ~~for the~~ traversable, with optional boolean ~~Document~~ checkForUserCancelation (default false), optional source snapshot params -or-null ~~. [CSSOMVIEW]~~ sourceSnapshotParams (default null), and optional navigable ~~Otherwise:~~ initiatorToCheck:

sourceSnapshotParams and initiatorToCheck are always either both given or both not given. They are usually not given, as most callers do not need the extra checks on the navigation initiator that they cause. (Possibly because the caller has already performed such checks themselves.)

~~Let~~ Assert : This is running within target traversable ~~be element that is the indicated part of the document~~ 's session history traversal queue .
~~Set~~ Let targetStep be the ~~Document 's target element~~ result of getting the used step to given target traversable and step.
~~Run the ancestor details revealing algorithm on~~ If target . initiatorToCheck is given, then:
1. ~~Run the ancestor hidden-until-found revealing algorithm on~~ Assert : target . sourceSnapshotParams is not null.
2. ~~Scroll~~ For each target navigable ~~into view , with~~ of get all navigables whose current session history entry will change or reload : if behavior initiatorToCheck ~~set~~ is not allowed by sandboxing to ~~"auto",~~ navigate block navigable ~~set to "start", and~~ given inline set to "nearest". [CSSOMVIEW] sourceSnapshotParams, then return.
~~Run the focusing steps for~~ Let target , with navigablesCrossingDocuments be the ~~Document 's viewport~~ result of getting all navigables that might experience a cross-document traversal ~~as the~~ given fallback target traversable and targetStep.
~~Move the sequential focus navigation starting point to~~ If target . The indicated part of the document checkForUserCancelation is true, and the ~~one that the fragment , if any, identifies. The semantics of the fragment in terms~~ result of ~~mapping it to a node~~ checking if unloading is ~~defined by the specification that defines the MIME type used by the Document (for example, the processing of fragments for XML MIME types~~ user-canceled given navigablesCrossingDocuments given traversable and targetStep is ~~the responsibility of RFC7303). [RFC7303]~~ true, then return.
~~There~~
Some algorithms check if unloading is ~~also a target element for each Document~~ user-canceled ~~, which is used in defining~~ as a prerequisite to modifying the ~~:target pseudo-class and is updated by~~ history tree. Those algorithms will set checkForUserCancelation to false when calling this algorithm to avoid performing the ~~above algorithm. It is initially null.~~ check twice.
~~For HTML documents (and HTML MIME types ), the following processing model must~~
It might not be ~~followed~~ correct to ~~determine what the indicated part of the document is.~~ block on beforeunload results here. This may have observable consequences.
Let fragment changingNavigables be the ~~document's URL~~ result of get all navigables whose current session history entry will change or reload ~~'s fragment .~~ given traversable and targetStep.
If Let fragment nonchangingNavigablesThatStillNeedUpdates ~~is the empty string, then~~ be the ~~indicated part~~ result of ~~the document~~ getting all navigables that only need history object length/index update ~~is the top of the document; return.~~ given traversable and targetStep.
~~If find a potential indicated element~~ For each ~~with~~ fragment navigable ~~returns non-null, then the return value is the indicated part~~ of ~~the document ; return.~~ changingNavigables:
1. Let fragmentBytes targetEntry be the result of ~~percent-decoding~~ getting the target history entry given fragment navigable and targetStep.
2. ~~Let~~ Set decodedFragment navigable ~~be the result of running UTF-8 decode without BOM~~ 's current session history entry on to fragmentBytes targetEntry.
3. ~~If find a potential indicated element with~~ Set decodedFragment navigable ~~returns non-null, then the return value is the indicated part of the document~~ 's ongoing navigation ~~; return.~~ to " traversal ".
If Let decodedFragment totalChangeJobs ~~is an ASCII case-insensitive match for the string top , then the indicated part of~~ be the ~~document~~ size ~~is the top~~ of ~~the document; return.~~ changingNavigables.
~~There is no indicated part of the document . To find a potential indicated element given a string~~ Let fragment , run these steps: completedChangeJobs be 0.
~~If there is an element in the document tree that has~~ Let changingNavigableContinuations be an ID empty queue ~~equal~~ of changing navigable continuation states .
This queue is used to split the operations on fragment , then return changingNavigables into two parts. Specifically, changingNavigableContinuations holds data for the ~~first such element in tree order~~ second part .
~~If there is an~~ For each navigable of changingNavigables, queue a global task ~~element in~~ on the ~~document tree~~ navigation and traversal task source ~~that has a name~~ of navigable 's active window ~~attribute whose value is equal~~ to ~~fragment , then return~~ run the ~~first such element~~ steps:
This set of steps are split into two parts to allow synchronous navigations to be processed before documents unload. State is stored in ~~tree order~~ changingNavigableContinuations for the second part .
1. ~~Return null. 7.11.10 History traversal~~ Let displayedEntry be navigable 's active session history entry .
2. ~~To traverse the history to a~~ Let targetEntry be navigable 's current session history entry .
3. Let changingNavigableContinuation be a changing navigable continuation state with:
  displayed document
  displayedEntry 's document
  target entry ~~, with an optional history handling behavior~~
  historyHandling targetEntry ~~(default "~~
  ~~default~~ navigable ~~"), and an optional boolean~~
  explicitHistoryNavigation navigable ~~(default false): This algorithm is not just invoked when explicitly going back or forwards in the session history~~
  update-only ~~— it is also invoked in other situations, for example when navigating a browsing context , as part of updating the session history with the new page .~~
  false
4. If entry displayedEntry is targetEntry and targetEntry 's document state 's reload pending is ~~null,~~ false, then:
  1. ~~Assert :~~ Set historyHandling changingNavigableContinuation ~~is "~~ 's update-only to true.
  2. ~~default~~
    Enqueue changingNavigableContinuation on changingNavigableContinuations.
  3. ".
    Abort these steps.
  This case occurs due to a synchronous navigation which already updated the active session history entry .
5. Let request oldOrigin be ~~a new request whose URL is~~ entry targetEntry 's ~~URL~~ document state 's origin .
6. If explicitHistoryNavigation targetEntry 's document is ~~true, then set~~ null, or request targetEntry 's ~~history-navigation flag . Navigate~~ document state ~~the browsing context~~ 's reload pending ~~to request with~~ is true, then:
  1. Let navTimingType ~~set to~~ be " entry update back_forward " ~~and with~~ if targetEntry 's document is null; otherwise " historyPolicyContainer reload set to ".
  2. Let entry targetSnapshotParams ~~'s policy container . The navigation must~~ be ~~done using~~ the ~~same source browsing context~~ result of snapshotting target snapshot params ~~as was used the first time~~ given entry navigable.
  3. Let potentiallyTargetSpecificSourceSnapshotParams ~~was created. The " navigate " algorithm reinvokes this "traverse" algorithm~~ be sourceSnapshotParams.
  4. If potentiallyTargetSpecificSourceSnapshotParams is null, then set it to ~~complete~~ the ~~traversal, at which point~~ result of snapshotting source snapshot params given entry navigable 's active document ~~is non-null.~~ .
    
    ~~If the resource was obtained using a non-idempotent action, for example a POST form submission, or if the resource~~ In this case there is no ~~longer available, for example because the computer is now offline and~~ clear source of the ~~page wasn't cached, navigating to it again might not be possible. In~~ traversal/reload. We treat this ~~case, the navigation will result~~ situation as if navigable navigated itself, but note that some properties of targetEntry 's original initiator are preserved in ~~a different page than previously; for example, it might be an error message explaining~~ targetEntry 's document state , such as the ~~problem or offering to resubmit~~ initiator origin and referrer , which will appropriately influence the ~~form.~~ navigation.
  5. ~~Return. Save persisted~~ Set targetEntry 's document state 's reload pending to ~~the current entry .~~ false.
  6. Let newDocument allowPOST be entry targetEntry 's document state 's reload pending .
  7. ~~Assert :~~ In parallel , attempt to populate the history entry's document for newDocument targetEntry, given navigable,potentiallyTargetSpecificSourceSnapshotParams,targetSnapshotParams, with allowPOST set to allowPOST ~~'s is initial about:blank~~ and completionSteps ~~is false, i.e., we never traverse back~~ set to queue a global task on the ~~initial about:blank~~ navigation and traversal task source ~~Document~~ given navigable 's active window to run afterDocumentPopulated.
  Otherwise, run afterDocumentPopulated immediately .
  In both cases, let afterDocumentPopulated be the following steps:
  1. If newDocument targetEntry ~~is different than the current entry~~ 's document ~~, or~~ is null, then set historyHandling changingNavigableContinuation ~~is " entry update " or " reload~~ 's update-only ~~", then:~~ to true.
    This means we tried to populate the document, but were unable to do so, e.g. because of the server returning a 204.
  2. If newDocument targetEntry 's ~~suspended timer handles~~ document 's origin is not ~~empty :~~ oldOrigin, then set targetEntry 's serialized state to null.
    
    This clears history state when the origin changed vs a previous load of targetEntry without a redirect occuring. This can happen due to a change in CSP sandbox headers.
  3. If all of the following are true:
    - ~~Assert :~~ newDocument navigable 's ~~suspension time~~ parent is ~~not zero.~~ null;
    - ~~Let~~ suspendDuration targetEntry ~~be the current high resolution time~~ 's document ~~minus newDocument~~ 's ~~suspension time .~~ browsing context is not an auxiliary browsing context whose disowned is false; and
    - ~~Let activeTimers be~~ newDocument targetEntry 's ~~relevant global object~~ document 's ~~map of active timers . For each~~ origin is not handle oldOrigin in
    then set newDocument targetEntry 's ~~suspended timer handles , if~~ document state 's navigable target name to the empty string.
  4. Enqueue activeTimers changingNavigableContinuation [ on handle ] exists , then increase changingNavigableContinuations.
    The rest of this job runs later in this algorithm.
Let activeTimers navigablesThatMustWaitBeforeHandlingSyncNavigation [ be an empty set .
While handle completedChangeJobs ~~] by~~ does not equal suspendDuration . totalChangeJobs:
1. ~~Remove any tasks queued by the~~ If traversable 's running nested apply history ~~traversal task source that are associated with any Document~~ step is false, then:
  1. If While newDocument traversable 's ~~origin~~ session history traversal queue ~~is not same origin~~ 's algorithm set contains one or more synchronous navigation steps with ~~the current entry~~ a target navigable ~~'s document~~ not contained ~~'s origin , then:~~ in navigablesThatMustWaitBeforeHandlingSyncNavigation:
    1. Let entriesToUpdate steps be ~~all entries~~ the first item in ~~the~~ traversable 's session history ~~whose document~~ traversal queue 's ~~origin~~ algorithm set that is ~~same origin as the active document~~ synchronous navigation steps ~~and that are contiguous~~ with ~~the current entry .~~ a target navigable not contained in navigablesThatMustWaitBeforeHandlingSyncNavigation.
    2. ~~For each~~ Remove entryToUpdate steps of from entriesToUpdate , traversable 's session history traversal queue 's algorithm set .
    3. Set entryToUpdate traversable 's ~~browsing context name~~ running nested apply history step to ~~the current browsing context name .~~ true.
    4. ~~If the browsing context is a top-level browsing context , but not an auxiliary browsing context whose disowned~~ Run steps.
    5. Set traversable 's running nested apply history step ~~is false, then set~~ to false.
    Synchronous navigations that are intended to take place before this traversal jump the ~~browsing context's name~~ queue at this point, so they can be added to the ~~empty string.~~ correct place in traversable 's session history entries before this traversal potentially unloads their document. More details can be found here .
2. ~~Set~~ Let changingNavigableContinuation be the ~~active document~~ result of ~~the browsing context~~ dequeuing to from newDocument changingNavigableContinuations.
3. If entry changingNavigableContinuation ~~'s browsing context name~~ is ~~not null, then:~~ nothing, then continue .
4. ~~Set the browsing context's name to~~ Let entry displayedDocument be changingNavigableContinuation 's ~~browsing context name~~ displayed document .
5. Let entriesToUpdate targetEntry be ~~all entries in the session history whose document 's origin is same origin as the new active document 's origin and that are contiguous with~~ changingNavigableContinuation 's target entry . .
6. ~~For each~~ Let entryToUpdate navigable of be entriesToUpdate , set changingNavigableContinuation 's navigable .
7. Set entryToUpdate navigable 's ~~browsing context name~~ ongoing navigation to null.
  
  This allows new navigations of navigable to start, whereas during the traversal they were blocked.
8. If Let ( newDocument scriptHistoryLength,scriptHistoryIndex ~~has any form controls whose autofill field name is " off ", invoke~~ ) be the ~~reset algorithm of each~~ result of ~~those elements.~~ getting the history object length and index given traversable and targetStep.
  These values might have changed since they were last calculated.
9. If Append newDocument navigable ~~'s current document readiness " complete ", then queue~~ to navigablesThatMustWaitBeforeHandlingSyncNavigation.
  Once a navigable has reached this point in traversal, additionally queued synchronous navigation steps are likely to be intended to occur after this traversal rather than before it, so they no longer jump the queue. More details can be found here .
10. Queue a global task on the ~~DOM manipulation~~ navigation and traversal task source given newDocument navigable 's ~~relevant global object~~ active window to run the ~~following~~ steps:
  1. If newDocument changingNavigableContinuation 's ~~page showing~~ update-only ~~flag~~ is ~~true, then abort these steps.~~ false, then:
    1. ~~Update the visibility state~~ Unload of newDocument displayedDocument ~~to " hidden ".~~ given targetEntry 's document .
    2. ~~Fire a page transition event named pageshow at~~ For each newDocument childNavigable of displayedDocument 's ~~relevant~~ descendant navigables , queue a global ~~object~~ task ~~with true. Set~~ on the navigation and traversal task source given newDocument childNavigable 's ~~URL~~ active window to unload entry childNavigable 's ~~URL~~ active document .
    3. ~~Let hashChanged be false, and let~~ Activate history entry oldURL targetEntry ~~and~~ for newURL be null. navigable.
  2. If entry targetEntry 's ~~URL 's fragment~~ document is not ~~identical~~ equal to displayedDocument, then queue a global task on the ~~current entry 's URL 's fragment ,~~ navigation and traversal task source given entry targetEntry 's document ~~equals~~ 's relevant global object to perform the ~~current entry~~ following step. Otherwise, continue onward to perform the following step within the currently-queued task.
  3. Update document for history step application given targetEntry 's document , ~~then set~~ hashChanged to true, set targetEntry, oldURL changingNavigableContinuation ~~to the current entry~~ 's ~~URL~~ update-only , ~~and set~~ newURL to scriptHistoryLength, and entry 's URL . scriptHistoryIndex.
  4. If Increment historyHandling completedChangeJobs.
Let totalNonchangingJobs ~~is " replace ", then remove~~ be the ~~entry immediately before~~ size of entry in nonchangingNavigablesThatStillNeedUpdates.
This step onwards deliberately waits for all the ~~session~~ previous operations to complete, as they include processing synchronous navigations which will also post tasks to update history . length and index.
If Let entry completedNonchangingJobs ~~'s persisted user state is null, and its URL 's fragment is non-null, then scroll to the fragment .~~ be 0.
~~Set~~ Let ( scriptHistoryLength,scriptHistoryIndex ) be the ~~current entry~~ result of getting the history object length and index to given entry traversable and targetStep.
~~Let~~ For each targetRealm navigable be of nonchangingNavigablesThatStillNeedUpdates, queue a global task on the ~~current realm .~~ navigation and traversal task source given navigable 's active window to run the steps:
1. Let state document be ~~null.~~ navigable 's active document .
2. If Set entry document 's ~~serialized state is not null, then set state to StructuredDeserialize~~ history object ~~( entry~~ 's ~~serialized state ,~~ index to targetRealm ). If this throws an exception, catch it and ignore the exception. scriptHistoryIndex.
3. Set newDocument document 's ~~History~~ history object ~~object's state~~ 's length to state scriptHistoryLength.
4. ~~Let~~ Increment stateChanged be true if completedNonchangingJobs.
Wait for newDocument completedNonchangingJobs ~~has a latest entry , and that entry is not~~ to equal entry ; otherwise let it be false. totalNonchangingJobs.
Set newDocument traversable 's ~~latest entry~~ current session history step to entry targetStep.

~~If stateChanged is true, then fire an event named popstate~~ To activate history entry session history entry at newDocument entry ~~'s relevant global object , using PopStateEvent , with the state~~ for navigable ~~attribute initialized to~~ state . navigable:

~~Restore~~ Save persisted state ~~from~~ to the navigable 's active session history entry . .
If Let hashChanged newDocument ~~is true, then queue a global task on the DOM manipulation task source given~~ be newDocument entry 's ~~relevant global object to fire an event named~~ document .
~~hashchange~~
at Assert : newDocument 's ~~relevant global object , using~~ is initial about:blank ~~HashChangeEvent~~ ~~, with~~ is false, i.e., we never traverse back to the initial about:blank ~~oldURL~~ Document ~~attribute initialized to~~ because it always gets replaced when we navigate away from it.
Set oldURL navigable ~~and the newURL~~ 's active session history entry ~~attribute initialized~~ to newURL entry.
~~7.11.10.1 Persisted history entry state~~
Make active newDocument.

To ~~save persisted state~~ get the used step to given a ~~session history entry~~ traversable navigable entry : traversable, and a non-negative integer step, perform the following steps. They return a non-negative integer.

~~Set the scroll position data of~~ Let entry steps ~~to contain~~ be the ~~scroll positions for all~~ result of ~~entry 's document~~ getting all used history steps ~~'s restorable scrollable regions .~~ within traversable.
~~Optionally, update~~ Return the greatest item in entry steps ~~'s persisted user state to reflect any state~~ that ~~the user agent wishes~~ is less than or equal to step.
This caters for situations where there's no session history entry with step step, due to ~~persist, such as~~ the ~~values~~ removal of ~~form fields.~~ a navigable .

To ~~restore persisted state~~ get the history object length and index ~~from~~ given a ~~session history entry~~ traversable navigable entry : traversable, and a non-negative integer step, perform the following steps. They return a tuple of two non-negative integers.

If Let entry steps ~~'s scroll restoration mode is " auto~~ be the result of getting all used history steps within traversable.
~~", then the user agent may use~~
Let entry scriptHistoryLength ~~'s scroll position data to restore~~ be the ~~scroll positions~~ size of entry steps.
Assert :steps ~~'s document~~ contains ~~'s restorable scrollable regions .~~ step.

~~The user agent not restoring scroll positions does not imply~~ It is assumed that ~~scroll positions will be left at any particular value (e.g., (0,0)). The actual scroll position depends on the navigation type and~~ step has been adjusted by getting the ~~user agent's particular caching strategy. So web applications cannot assume any particular scroll position but rather are urged to set it to what they want it to be.~~ used step .
~~Optionally, update other aspects~~ Let scriptHistoryIndex be the index of entry step ~~'s document~~ in sessionSteps.
Return ( scriptHistoryLength,scriptHistoryIndex ).

To get all navigables whose current session history entry will change or reload given a traversable navigable traversable, and ~~its rendering, for instance values of form fields, that~~ a non-negative integer targetStep, perform the ~~user agent had previously recorded in~~ following steps. They return a list of navigables .

Let entry results ~~'s persisted user state~~ be an empty list .
Let navigablesToCheck be « traversable ».

This ~~can even include updating~~ list is extended in the loop below.
~~dir~~ For each ~~attribute~~ navigable of ~~textarea elements or input~~ navigablesToCheck:
1. ~~type~~
  Let targetEntry be the result of getting the target history entry given navigable and targetStep.
2. ~~attribute~~
  If targetEntry is ~~in either the Text~~ not navigable 's current session history entry ~~state~~ or ~~the Search state, if the persisted~~ targetEntry 's document state ~~includes the directionality of user input in such controls. Restoring the value of form controls as part of this process does not fire any input~~ ~~or change~~ 's reload pending ~~events, but can trigger the formStateRestoreCallback of form-associated custom elements . The restorable scrollable regions of a Document~~ is true, then append document navigable ~~are~~ to results.
3. If targetEntry 's document is navigable 's ~~viewport~~ document , and ~~all of~~ document targetEntry 's ~~scrollable regions excepting any~~ document state 's reload pending is false, then extend navigablesToCheck with the child ~~browsing contexts~~ navigables of document navigable.
  
  ~~Child browsing context~~ Adding child navigables ~~scroll restoration is handled~~ to navigablesToCheck means those navigables will also be checked by this loop. Child navigables are only checked if the ~~history entry for those browsing contexts' Document~~ navigable 's active document s. will not change as part of this traversal.
  ~~7.11.10.2 The PopStateEvent interface ✔ MDN~~
PopStateEvent Support in all current engines. Firefox 4+ Safari 6+ Chrome 4+ Opera 12.1+ Edge 79+ Edge (Legacy) 12+ Internet Explorer 10+ Firefox Android ? Safari iOS ? Chrome Android ? WebView Android ? Samsung Internet ? Opera Android 12.1+ [Exposed=Window] interface { constructor(DOMString type, optional eventInitDict = {}); readonly attribute any ; }; dictionary { any state = null; }; Return event results. ~~state~~

~~Returns~~ To get all navigables that only need history object length/index update given a ~~copy of~~ traversable navigable traversable, and a non-negative integer targetStep, perform the ~~information that was provided to pushState()~~ following steps. They return a list ~~or replaceState()~~ of navigables .

Other navigables ~~. The state attribute must return the value it was initialized to. It represents the context information for~~ might not be impacted by the ~~event, or null,~~ traversal. For example, if the ~~state represented~~ response is a 204, the ~~initial state of~~ currently active document will remain. Additionally, going 'back' after a 204 will change the ~~Document~~ current session history entry , but the active session history entry . will already be correct.

~~7.11.10.3 The HashChangeEvent interface ✔ MDN~~

HashChangeEvent Support in all current engines. Firefox 3.6+ Safari 5+ Chrome 8+ Opera 10.6+ Edge 79+ Edge (Legacy) 12+ Internet Explorer 8+ Firefox Android ? Safari iOS 5+ Chrome Android ? WebView Android ? Samsung Internet ? Opera Android 11+ [Exposed=Window] interface { constructor(DOMString type, optional eventInitDict = {}); readonly attribute USVString ; readonly attribute USVString ; }; dictionary { USVString oldURL = ""; USVString newURL = ""; }; Let event . oldURL ✔ MDN results be an empty list .
~~HashChangeEvent/oldURL Support~~ Let navigablesToCheck be « traversable ».
This list is extended in all current engines. Firefox 6+ Safari 5.1+ Chrome 8+ Opera 12.1+ Edge 79+ Edge (Legacy) 12+ Internet Explorer No Firefox Android ? Safari iOS ? Chrome Android ? WebView Android ? Samsung Internet ? Opera Android 12.1+ the loop below.
For each navigable of navigablesToCheck:
1. ~~Returns~~ Let targetEntry be the ~~URL~~ result of getting the ~~session~~ target history entry ~~that was previously current.~~ given event navigable and targetStep. ~~newURL~~
2. If targetEntry is navigable 's current session history entry and targetEntry 's document state 's reload pending is false, then:
  1. ~~HashChangeEvent/newURL~~ Append Support in all current engines. Firefox 6+ Safari 5.1+ Chrome 8+ Opera 12.1+ Edge 79+ Edge (Legacy) 12+ Internet Explorer No Firefox Android ? Safari iOS ? Chrome Android ? WebView Android ? Samsung Internet ? Opera Android 12.1+ navigable to results.
  2. ~~Returns~~ Extend navigablesToCheck with navigable 's child navigables .
    Adding child navigables to navigablesToCheck means those navigables will also be checked by this loop. child navigables are only checked if the ~~URL~~ navigable 's active document will not change as part of this traversal.
Return results.

To get the ~~session~~ target history entry ~~that is now current. The oldURL~~ ~~attribute must return the value it was initialized to. It represents context information for the event, specifically the URL of~~ given a navigable navigable, and a non-negative integer step, perform the following steps. They return a session history entry ~~that was traversed from.~~ .

~~The~~

~~newURL~~

~~attribute must return the value it was initialized to. It represents context information for the event, specifically~~
Let entries be the ~~URL~~ result of ~~the~~ getting session history ~~entry that was traversed to. 7.11.10.4 The PageTransitionEvent interface~~ entries ~~✔ MDN~~ for navigable.
~~PageTransitionEvent~~ Return the item ~~Support~~ in all current engines. Firefox 1.5+ Safari 5+ Chrome 4+ Opera ? Edge 79+ Edge (Legacy) 12+ Internet Explorer 11 Firefox Android ? Safari iOS 4+ Chrome Android ? WebView Android 37+ Samsung Internet ? Opera Android ? [Exposed=Window] interface { constructor(DOMString type, optional eventInitDict = {}); readonly attribute boolean ; }; dictionary { boolean persisted = false; }; event . persisted entries that has the greatest step ~~✔ MDN~~ less than or equal to step.

~~PageTransitionEvent/persisted~~ To see why getting the target history entry returns the entry with the greatest step less than or equal to the input step, consider the following Jake diagram :

Support in all current engines. Firefox 11+ Safari 5+ Chrome 4+ Opera ? Edge 79+ Edge (Legacy) 12+ Internet Explorer 11 Firefox Android ? Safari iOS 4+ Chrome Android ? WebView Android 37+ Samsung Internet ? ~~Opera Android~~ ?

	0	1	2	3
`top`	/t			/t#foo
`frames[0]`	/i-0-a	/i-0-b

For the ~~pageshow event, returns false if~~ input step 1, the ~~page is newly being loaded (and~~ target history entry for the ~~load~~ top ~~event will fire). Otherwise, returns true. For~~ navigable is the ~~pagehide~~ /t ~~event, returns false if the page~~ entry, whose step is ~~going away for the last time. Otherwise, returns true, meaning that~~ 0, while the ~~page might be reused if~~ target history entry for the ~~user navigates back to this page (if~~ frames[0] navigable is the ~~Document~~ /i-0-b entry, whose step is 1:

's ~~salvageable~~ ~~state stays true). Things that can cause the page to be unsalvageable include:~~ ~~Document~~ ~~iframe~~

~~The user agent decided to not keep the~~	0	1	2	3
`top` ~~alive in a session history entry after unload~~ ~~Having~~	/t			/t#foo
`frames[0]` ~~s that are not~~ ~~salvageable~~	/i-0-a	/i-0-b

Similarly, given the input step 3 we get the top entry whose step is 3, and the frames[0] entry whose step is 1:

~~Active~~ ~~WebSocket~~ ~~The~~

~~objects~~	0	1	2	3
~~Aborting a~~ `Document top`	/t			/t#foo
`persisted frames[0]` ~~attribute must return the value it was initialized to. It represents the context information for the event.~~	/i-0-a	/i-0-b

To ~~fire~~ get all navigables that might experience a ~~page transition event~~ cross-document traversal ~~named eventName at a Window window with~~ given a ~~boolean persisted , fire an event~~ traversable navigable ~~named~~ eventName at window traversable, ~~using PageTransitionEvent , with the persisted attribute initialized to~~ and a non-negative integer persisted targetStep, perform the ~~cancelable attribute initialized to true, the bubbles~~ following steps. They return a list ~~attribute initialized to true, and~~ of navigables .

From legacy target override flag traversable ~~set. The values for cancelable and bubbles~~ 's session history traversal queue ~~don't make any sense, since canceling~~ 's perspective, these documents are candidates for going cross-document during the ~~event does nothing and it's~~ traversal described by targetStep. They will not ~~possible to bubble past~~ experience a cross-document traversal if the ~~Window object. They are set to true~~ status code for ~~historical reasons. 7.11.11 Loading documents A Document has a completely loaded time (a time or null), which~~ their target document is ~~initially null.~~ HTTP 204 No Content.

~~A Document is considered completely loaded~~ Note that if ~~its completely loaded time~~ a given navigable ~~is non-null. To completely finish loading~~ might experience a ~~Document~~ cross-document traversal, this algorithm will return navigable ~~document :~~ but not its child navigables . Those would end up unloaded , not traversed.

~~Assert : document 's browsing context is non-null. Set~~ Let document results ~~'s completely loaded time to the current time.~~ be an empty list .
Let container navigablesToCheck be « document traversable ~~'s browsing context 's container .~~ ».

This ~~will be null in the case where document~~ list is ~~the initial about:blank Document~~ extended in ~~a frame or iframe , since at~~ the ~~point of browsing context creation which calls this algorithm, the container relationship has not yet been established. (That happens in a subsequent step of create a new nested browsing context .)~~ loop below.
~~The consequence of this is that the following steps do nothing, i.e., we do not fire an asynchronous load~~ ~~event on the container element for such cases. Instead, a synchronous load~~ For each ~~event is fired in a special initial-insertion case in the shared attribute processing steps for iframe and frame elements .~~ navigable of navigablesToCheck:
1. If Let container targetEntry ~~is an iframe element, then queue an element task on~~ be the ~~DOM manipulation task source~~ result of getting the target history entry given container navigable ~~to run the iframe load event steps given~~ and container targetStep.
2. ~~Otherwise, if~~ If container targetEntry ~~is non-null, then queue an element task~~ 's document ~~on the DOM manipulation task source~~ is not navigable 's document ~~given~~ or container targetEntry ~~to fire an event~~ 's document state ~~named load~~ 's reload pending is true, then append at container navigable to results.
  ~~7.11.12 Unloading documents~~
  Although navigable 's active history entry A can change synchronously, the new entry will always have the same Document has a salvageable state, which must initially be true, and a page showing flag, which must initially be false. The page showing, so accessing navigable 's document ~~flag~~ is ~~used to ensure that scripts receive pageshow and pagehide events in a consistent manner (e.g. that they never receive two pagehide events in a row without an intervening pageshow , or vice versa).~~ reliable.
3. ~~A Document has a DOMHighResTimeStamp~~ Otherwise, extend ~~suspension time , initially 0.~~ navigablesToCheck with navigable 's child navigables .
  ~~A Document~~
  Adding child navigables ~~has a list~~ to navigablesToCheck means those navigables will also be checked by this loop. Child navigables are only checked if the navigable 's active document will not change as part of ~~suspended timer handles , initially empty.~~ this traversal.
~~Event loops have a termination nesting level counter, which must initially be 0.~~
Return results.

7.4.6.2 Updating the document Document objects have an unload counter , which is used to ignore certain operations while the below algorithms run. Initially, the counter must be set to zero.

To ~~prompt to unload ,~~ update document for history step application given a Document ~~object~~ document and optionally, a session history entry recursiveFlag entry, ~~run these steps:~~ a boolean doNotReactivate, and integers scriptHistoryLength and scriptHistoryIndex:

~~Increase the event loop 's termination nesting level by 1. Increase the~~ Let documentIsNew be true if document 's ~~unload counter~~ latest entry ~~by 1.~~ is null; otherwise false.
Let event documentsEntryChanged be ~~the result of creating an event using BeforeUnloadEvent~~ true if document 's latest entry . is not entry ; otherwise false.
~~Initialize~~ Set event document 's ~~type attribute to beforeunload~~ history object ~~and its cancelable~~ 's index ~~attribute true.~~ to scriptHistoryIndex.
~~Dispatch event at~~ Set document 's ~~relevant global~~ history object ~~. Decrease the event loop~~ 's ~~termination nesting level~~ length ~~by 1. Let~~ to result be " no-prompt ". scriptHistoryLength.
If ~~all of the following are true:~~ documentsEntryChanged is true, then:
1. Let oldURL be document 's ~~active sandboxing flag set does not have its sandboxed modals flag~~ latest entry ~~set~~ 's URL .
2. Set document 's ~~relevant global object has sticky activation~~ latest entry to entry.
3. Restore the history object state given event document and entry.
4. If documentIsNew ~~'s canceled flag~~ is ~~set, or the~~ false, then fire an event named returnValue popstate ~~attribute of~~ at event document is not the empty string then the user agent may ask the user to confirm that they wish to unload the document. The message shown to the user is not customizable, but instead determined by the user agent. In particular, the actual value of 's relevant global object , using PopStateEvent, with the returnValue state attribute ~~is ignored. The user agent is encouraged~~ initialized to avoid asking the user for confirmation if it judges that doing so would be annoying, deceptive, or pointless. If the user agent asks the user for confirmation, it must: Invoke WebDriver BiDi user prompt opened with document 's ~~relevant global~~ history object ~~, " beforeunload ", and "".~~ 's state .
5. ~~Pause~~ Restore persisted state ~~while waiting for the user's response.~~ given entry.
6. If ~~the user confirmed the page navigation, then set~~ result documentIsNew is false, and oldURL 's fragment is not equal to ~~" confirm "; otherwise to " refuse ". Invoke WebDriver BiDi user prompt closed~~ entry 's URL ~~with~~ 's fragment , then queue a global task on the DOM manipulation task source given document 's relevant global object ~~and true if result is " confirm~~ to fire an event named hashchange ~~" or false otherwise. If the~~ at recursiveFlag document ~~is not set, then:~~ 's relevant global object , using HashChangeEvent Let, with the oldURL attribute initialized to the serialization of descendants oldURL be and the ~~list of~~ newURL attribute initialized to the ~~descendant browsing contexts~~ serialization of document . entry 's URL .
~~For each~~ If browsingContext documentIsNew ~~in descendants :~~ is true, then:
1. ~~Let internalResult be the result of calling prompt~~ Try to ~~unload~~ scroll to the fragment for browsingContext 's active document with the recursiveFlag set..
2. ~~If internalResult is " refuse ", then return~~ At this point scripts may run for the newly-created document internalResult document.
Otherwise, if internalResult documentsEntryChanged is ~~" confirm ", set~~ false and result doNotReactivate to is false, then reactivate internalResult document.

~~Decrease the~~ documentsEntryChanged can be false for one of two reasons: either we are restoring from bfcache , or we are asynchronously finishing up a synchronous navigation which already synchronously set document 's ~~unload counter by 1. Return~~ latest entry . The result . doNotReactivate argument distinguishes between these two cases.

To ~~unload~~ restore the history object state a given Document document , given an optional recursiveFlag , a document unload timing info -or-null unloadTimingInfo ~~(default null),~~ and ~~an optional global object~~ session history entry newGlobal entry:

~~Increase the event loop~~ Let targetRealm be document 's ~~termination nesting level by one.~~ relevant realm .
~~Increase~~ Let document state ~~'s unload counter by 1.~~ be null.
If ~~the user agent does not intend to keep~~ document alive in a session history entry (such that it can be reused later on history traversal ), set document 's ~~salvageable~~ serialized state is not null, then set state to ~~false. If~~ StructuredDeserialize ( document entry 's ~~page showing flag is true:~~ serialized state ,targetRealm ). If this throws an exception, catch it and ignore the exception.
Set document 's ~~page showing~~ history object 's state ~~flag~~ to ~~false.~~ state.

~~Fire~~ To make active a ~~page transition event named~~ pagehide Document at document:

Let window be document 's relevant global object ~~with~~ .
Set document 's ~~salvageable~~ browsing context 's state. WindowProxy Update the visibility state 's [[Window]] ~~of newDocument~~ internal slot value to ~~" hidden ".~~ window.
~~If unloadTimingInfo is not null, then set~~ Set unloadTimingInfo document 's ~~unload event start time~~ visibility state to ~~the current high resolution time given newGlobal , coarsened given~~ document 's ~~relevant settings object~~ node navigable 's ~~cross-origin isolated capability~~ traversable navigable 's system visibility state .
If Set document window 's ~~salvageable state is false, then fire an event~~ relevant settings object ~~named~~ 's execution ready flag .

To reactivate a unload Document at document 's relevant global object , with:

This algorithm updates legacy target override flag document ~~set.~~ after it has come out of bfcache , i.e., after it has been made fully active again.

If For each unloadTimingInfo formControl ~~is not null, then set~~ of form controls in unloadTimingInfo document ~~'s unload event end time~~ with an autofill field name to of " off ", invoke the ~~current high resolution time~~ reset algorithm ~~given~~ for newGlobal , coarsened given formControl.
If document 's ~~relevant settings object~~ suspended timer handles ~~'s cross-origin isolated capability .~~ is not empty :
1. ~~Set~~ Assert : document 's suspension time to is not zero.
2. Let suspendDuration be the current high resolution time ~~given~~ minus document 's ~~relevant global object~~ suspension time .
3. ~~Set~~ Let activeTimers be document 's ~~suspended timer handles to the result of getting the keys~~ relevant global object ~~for the~~ 's map of active timers .
4. ~~Run any unloading document cleanup steps for~~ For each handle in document ~~that are defined by this specification and other applicable specifications . If the~~ 's suspended timer handles , if recursiveFlag activeTimers ~~is not set, then: Let~~ [ descendants handle ~~be the list of the descendant browsing contexts of~~ ] exists , then increase document activeTimers [ handle ] by suspendDuration.
~~For each~~ If browsingContext document in 's current document readiness is " complete ", and descendants : document 's page showing flag is false, then:
1. ~~Unload the active document of browsingContext with the~~ Set recursiveFlag document ~~set.~~ 's page showing flag to true.
2. ~~If the~~ ~~salvageable state of the active document of browsingContext is false, then set~~ Update the ~~salvageable~~ visibility state of document to ~~false also.~~ " visible ".
3. ~~If document 's~~ ~~salvageable~~ Fire a page transition event named state is false, then discard pageshow document . Decrease at document 's ~~unload counter~~ relevant global object ~~by 1.~~ with true.

~~This specification defines~~ To try to scroll to the ~~following unloading document cleanup steps . Other specifications can define more. Given~~ fragment for a Document document :, perform the following steps in parallel :

~~Let window be document 's relevant global object .~~ Wait for an implementation-defined amount of time. (This is intended to allow the user agent to optimize the user experience in the face of performance concerns.)
~~For each~~ ~~WebSocket object webSocket whose relevant~~ Queue a global ~~object is window , make disappear~~ task ~~webSocket . If this affected any WebSocket~~ on the navigation and traversal task source ~~objects, then set~~ given document 's ~~salvageable~~ relevant global object ~~state~~ to ~~false.~~ run these steps:
1. If document ~~'s salvageable state~~ has no parser, or its parser has stopped parsing , or the user agent has reason to believe the user is ~~false, then:~~ no longer interested in scrolling to the fragment , then abort these steps.
2. ~~For each EventSource~~ ~~object eventSource whose relevant global object is equal~~ Scroll to ~~window , forcibly close~~ the fragment given eventSource document.
3. ~~Clear~~ If window document 's map of active timers . 7.11.12.1 The BeforeUnloadEvent interface ✔ MDN BeforeUnloadEvent Support in all current engines. Firefox 1.5+ Safari 7+ Chrome 30+ Opera ? Edge 79+ Edge (Legacy) 12+ Internet Explorer 4+ Firefox Android ? Safari iOS ? Chrome Android ? WebView Android 37+ Samsung Internet 3.0+ Opera Android ? [Exposed=Window] interface { attribute DOMString ; }; There are no BeforeUnloadEvent -specific initialization methods. The BeforeUnloadEvent indicated part ~~interface~~ is ~~a legacy interface which allows prompting to unload~~ still null, then try to ~~be controlled not only by canceling the event, but by setting the returnValue attribute~~ scroll to ~~a value besides~~ the ~~empty string. Authors should use the preventDefault() method, or other means of canceling events, instead of using returnValue~~ fragment . The returnValue attribute controls the process of prompting to unload . When the event is created, the attribute must be set to the empty string. On getting, it must return the last value it was set to. On setting, the attribute must be set to the new value. This attribute is a DOMString only for ~~historical reasons. Any value besides the empty string will be treated as a request to ask the user for confirmation.~~ document.

7.11.13 7.4.6.3 Aborting Scrolling to a document load fragment

To ~~abort~~ scroll to the fragment given a Document document:

~~Abort the active documents of every child browsing context .~~ If ~~this results in any of those Document objects having their salvageable state set to false, then set~~ document 's salvageable state to false also. Cancel any instances of the fetch algorithm in the context of document , discarding any tasks queued for them, and discarding any further data received from the network for them. If this resulted in any instances of the fetch algorithm being canceled or any queued tasks indicated part ~~or any network data getting discarded,~~ is null, then set document 's ~~salvageable~~ target element ~~state~~ to ~~false.~~ null.
If Otherwise, if document 's ~~navigation id~~ indicated part is ~~non-null,~~ top of the document , then:
1. ~~Invoke WebDriver BiDi navigation aborted with document 's browsing context , and new WebDriver BiDi navigation status whose whose id is~~ Set document 's ~~navigation id , status~~ target element ~~is "~~ to null.
2. ~~canceled~~
  ~~", and url~~ Scroll to the beginning of the document is for document 's URL .. [CSSOMVIEW]
3. ~~Set document 's navigation id to null.~~ Return.
~~If document has an active parser , then:~~ Otherwise:
1. ~~Set~~ Assert : document 's ~~active parser was aborted~~ indicated part ~~to true.~~ is an element.
2. ~~Abort that parser~~ Let target be document 's indicated part .
3. Set document 's ~~salvageable~~ target element ~~state~~ to ~~false. User agents may allow users to explicitly invoke the stop document loading for a Document~~ target.
4. .
  ~~To stop document loading given a Document~~ Run the ancestor details revealing algorithm ~~object~~ on document , run these steps: target.
5. ~~Let browsingContext be~~ Run the ancestor hidden-until-found revealing algorithm on document 's browsing context . target.
6. If Scroll browsingContext target ~~'s active document is not~~ into view , with document , then return. If there is an existing attempt behavior set to ~~navigate~~ "auto", browsingContext block set to "start", and document inline ~~'s unload counter~~ set to "nearest". [CSSOMVIEW] ~~is 0, then cancel that navigation .~~
7. ~~Abort~~ Run the focusing steps for document . 7.11.14 The ` target, with the X-Frame-Options Document ~~` header~~ 's viewport ~~✔ MDN~~ as the fallback target.
8. ~~Headers/X-Frame-Options~~ Move the sequential focus navigation starting point Support in all current engines. Firefox 4+ Safari 4+ Chrome 4+ Opera 10.5+ Edge 79+ Edge (Legacy) 12+ Internet Explorer 8+ Firefox Android Yes Safari iOS Yes Chrome Android Yes WebView Android ? Samsung Internet ? Opera Android ? to target.

~~The ` X-Frame-Options ` HTTP response header is a legacy way of controlling whether and how a~~ A Document ~~may be loaded inside~~ 's indicated part is the one that its URL 's fragment identifies, or null if the fragment does not identify anything. The semantics of the fragment in terms of mapping it to a ~~child browsing context . It~~ node is ~~obsoleted~~ defined by the specification that defines the MIME type used by the frame-ancestors Document ~~CSP directive, which provides more granular control over the same situations. It was originally defined in HTTP Header Field X-Frame-Options , but~~ (for example, the ~~definition and~~ processing ~~model here supersedes that document. [CSP]~~ of fragments ~~[RFC7034]~~ for XML MIME types ~~In particular, HTTP Header Field X-Frame-Options specified an ` ALLOW-FROM ` variant of the header, but that~~ is ~~not to be implemented. Per~~ the ~~below processing model, if both a CSP frame-ancestors~~ responsibility of RFC7303). [RFC7303] ~~directive and an `~~

There is also a target element for each X-Frame-Options Document ` header are, which is used in defining the ~~same response , then `~~ X-Frame-Options :target ` pseudo-class and is ~~ignored.~~ updated by the above algorithm. It is initially null.

For web developers and conformance checkers, its value ABNF is: X-Frame-Options = "DENY" / "SAMEORIGIN" To check a navigation response's adherence to ` X-Frame-Options ` , given navigationParams navigationParams , a browsing context browsingContext , and an ~~origin~~ HTML document destinationOrigin : document, the following processing model must be followed to determine its indicated part :

~~If browsingContext is not a child browsing context , then return true. For each~~ Let policy fragment of be navigationParams document 's ~~policy container~~ URL 's ~~CSP list :~~ fragment .
If policy fragment ~~'s disposition~~ is ~~not " enforce ",~~ the empty string, then ~~continue .~~ return the special value top of the document .
If Let policy potentialIndicatedElement ~~'s directive set contains~~ be the result of finding a ~~frame-ancestors~~ potential indicated element given document and fragment.
~~directive,~~
If potentialIndicatedElement is not null, then return ~~true.~~ potentialIndicatedElement.
Let rawXFrameOptions fragmentBytes be the result of ~~getting, decoding, and splitting ` X-Frame-Options~~ percent-decoding ~~` from~~ navigationParams 's response 's header list . fragment.
Let xFrameOptions decodedFragment be ~~a new set .~~ the result of running UTF-8 decode without BOM on fragmentBytes.
~~For each~~ Set value potentialIndicatedElement to the result of ~~rawXFrameOptions , append~~ finding a potential indicated element given value , converted to ASCII lowercase , to document and xFrameOptions decodedFragment.
If xFrameOptions potentialIndicatedElement ~~'s size~~ is ~~greater than 1, and~~ not null, then return xFrameOptions potentialIndicatedElement.
If decodedFragment ~~contains~~ is an ASCII case-insensitive ~~any of " deny ", " allowall ", or "~~ match for the string sameorigin ", top, then return ~~false. The intention here is to block any attempts at applying ` X-Frame-Options ` which were trying to do something valid, but appear confused. This is~~ the ~~only impact~~ top of the ~~legacy ` ALLOWALL~~ document .
Return null.

To find a potential indicated element given a Document ~~` value on the processing model.~~ document and a string fragment, run these steps:

If there is an element in the document tree whose root is xFrameOptions document ~~'s size~~ and that has an ID ~~is greater than 1,~~ equal to fragment, then return ~~true. This means it contains multiple invalid values, which we treat~~ the ~~same way as if the header was omitted entirely.~~ first such element in tree order .
If there is an a element in the document tree whose root is xFrameOptions document ~~[0] is " deny~~ that has a name ", attribute whose value is equal to fragment, then return ~~false.~~ the first such element in tree order .
If Return null.

7.4.6.4 Persisted history entry state

To save persisted state to a session history entry xFrameOptions [0] is " sameorigin ", then: entry:

~~Let~~ Set the scroll position data of containerDocument entry be to contain the scroll positions for all of browsingContext entry 's ~~container~~ document 's restorable scrollable regions .
~~While~~
Optionally, update containerDocument entry ~~is not null:~~ 's persisted user state to reflect any state that the user agent wishes to persist, such as the values of form fields.

To restore persisted state from a session history entry entry:

If containerDocument entry 's ~~origin~~ scroll restoration mode is ~~not same origin~~ " auto with destinationOrigin , then return false. Let containerBC be ", then the user agent may use containerDocument entry 's ~~browsing context . Set containerDocument~~ scroll position data to restore the scroll positions of containerBC entry 's ~~container~~ document ~~, if containerBC is non-null; otherwise, null. Return true.~~ 's restorable scrollable regions .

~~If we've reached this point then we have a lone invalid value (which could potentially~~ The user agent not restoring scroll positions does not imply that scroll positions will be ~~one~~ left at any particular value (e.g., (0,0)). The actual scroll position depends on the ~~legacy ` ALLOWALL ` or ` ALLOW-FROM ` forms). These are treated as if~~ navigation type and the ~~header were omitted entirely.~~ user agent's particular caching strategy. So web applications cannot assume any particular scroll position but rather are urged to set it to what they want it to be.
~~The following table illustrates the processing~~ Optionally, update other aspects of ~~various values~~ entry 's document and its rendering, for instance values of form fields, that the ~~header, including non-conformant ones:~~ user agent had previously recorded in entry 's persisted user state .
`
This can even include updating the X-Frame-Options dir ` Valid Result ` DENY ` ✅ embedding disallowed ` SAMEORIGIN ` ✅ same-origin embedding allowed ` INVALID ` ❌ embedding allowed ` ALLOWALL ` ❌ embedding allowed ` ALLOW-FROM=https://example.com/ ` ❌ embedding allowed (from anywhere) The following table illustrates how various non-conformant cases involving multiple values are processed: ` attribute of X-Frame-Options textarea ~~` Result ` SAMEORIGIN, SAMEORIGIN ` same-origin embedding allowed ` SAMEORIGIN, DENY ` embedding disallowed ` SAMEORIGIN, ` embedding disallowed ` SAMEORIGIN, ALLOWALL ` embedding disallowed~~ elements or ` SAMEORIGIN, INVALID ` embedding disallowed input ` ALLOWALL, INVALID ~~` embedding disallowed~~ elements whose ` ALLOWALL, ` embedding disallowed type ` INVALID, INVALID ~~` embedding allowed The same results are obtained whether the values are delivered in a single header whose value~~ attribute is ~~comma-delimited,~~ in either the Text state or the Search state, if the persisted state includes the directionality of user input in ~~multiple headers.~~ such controls.
~~7.11.15 The `~~
Restoring the value of form controls as part of this process does not fire any Refresh input ~~` header~~ or change The ` events, but can trigger the Refresh formStateRestoreCallback of form-associated custom elements .

The restorable scrollable regions ~~` HTTP response header is the HTTP-equivalent to~~ of a meta Document ~~element with an~~ document are document 's viewport , and all of document 's scrollable regions excepting any navigable containers .

~~http-equiv~~ Child navigable ~~attribute in the Refresh~~ scroll restoration is handled as part of state ~~. It takes~~ restoration for the ~~same value~~ session history entry ~~and works largely the same. Its processing model is detailed in create and initialize a~~ for those navigables ' Document ~~object .~~ s.

0 of 8845

‹ previous

next ›

HTML

Living Standard — Last Updated 31 October 2022

7.11.10.2 7.4 Navigation and session history

7.11.10.3 7.4.1 The Session history

7.4.1.1 Session history entries

7.11.10.4 7.4.1.2 Document state

7.11.12 7.4.1.3 Unloading documents Centralized modifications of session history

7.11 7.4.1.4 Browsing Low-level operations on session history

7.11.1 7.4.2 Navigating across documents Navigation

7.4.2.1 Supporting concepts

7.4.2.2 Beginning navigation

7.4.2.3 Ending navigation id navigationId , request request , two browsing contexts sourceBrowsingContext and browsingContext ,

7.4.2.3.1 The usual cross-document navigation case historyPolicyContainer and initiatorPolicyContainer ,

7.4.2.3.2 The `javascript:` URL special case

7.4.2.3.3 Fragment navigations

7.4.2.3.4 Non-fetch schemes and external software

7.4.2.4 Preventing navigation

7.4.3 Reloading and traversing javascript: URLs have

7.4.4 Non-fragment synchronous "navigations"

7.4.5 Populating a session history entry

7.4.6 Applying the history step complete ". If

7.4.6.1 Updating the traversable

7.4.6.2 Updating the document Document objects have an unload counter , which is used to ignore certain operations while the below algorithms run. Initially, the counter must be set to zero.

7.11.13 7.4.6.3 Aborting Scrolling to a document load fragment

7.4.6.4 Persisted history entry state

7.11.10.2 7.4 Navigation and session history

7.11.10.3 7.4.1 The Session history

7.4.1.1 Session history entries

7.11.10.4 7.4.1.2 Document state

7.11.12 7.4.1.3 Unloading documents Centralized modifications of session history

7.11 7.4.1.4 Browsing Low-level operations on session history

7.11.1 7.4.2 Navigating across documents Navigation

7.4.2.1 Supporting concepts

7.4.2.2 Beginning navigation

7.4.2.3 Ending navigation id navigationId , request request , two browsing contexts sourceBrowsingContext and browsingContext ,

7.4.2.3.1 The usual cross-document navigation case historyPolicyContainer and initiatorPolicyContainer ,

7.4.2.3.2 The javascript: URL special case

7.4.2.3.3 Fragment navigations

7.4.2.3.4 Non-fetch schemes and external software

7.4.2.4 Preventing navigation

7.4.3 Reloading and traversing javascript: URLs have

7.4.4 Non-fragment synchronous "navigations"

7.4.5 Populating a session history entry

7.4.6 Applying the history step complete ". If

7.4.6.1 Updating the traversable

7.4.6.2 Updating the document Document objects have an unload counter , which is used to ignore certain operations while the below algorithms run. Initially, the counter must be set to zero.

7.11.13 7.4.6.3 Aborting Scrolling to a document load fragment

7.4.6.4 Persisted history entry state

7.4.2.3.2 The `javascript:` URL special case