HTML Standard

HTML Standard
Common infrastructure
2.1
Terminology
2.1.1
Parallelism
2.1.2
Resources
2.1.3
XML compatibility
2.1.4
DOM trees
2.1.5
Scripting
2.1.6
Plugins
2.1.7
Character encodings
2.1.8
Conformance classes
2.1.9
Dependencies
2.1.10
Extensibility
2.1.11
Interactions with XPath and XSLT
2.2
Policy-controlled features
Common infrastructure
This specification depends on
Infra
[INFRA]
2.1
Terminology
This specification refers to both HTML and XML attributes and IDL attributes, often in the same
context. When it is not clear which is being referred to, they are referred to as
content attributes
for HTML and XML attributes,
and
IDL attributes
for those defined on IDL interfaces. Similarly, the term
"properties" is used for both JavaScript object properties and CSS properties. When these are
ambiguous they are qualified as
object properties
and
CSS properties
respectively.
Generally, when the specification states that a feature applies to
the HTML syntax
or
the XML syntax
, it also includes the other. When a feature specifically only
applies to one of the two languages, it is called out by explicitly stating that it does not apply
to the other format, as in "for HTML, ... (this does not apply to XML)".
This specification uses the term
document
to refer to any use of HTML,
ranging from short static documents to long essays or reports with rich multimedia, as well as to
fully-fledged interactive applications. The term is used to refer both to
Document
objects and their descendant DOM trees, and to serialized byte streams using the
HTML syntax
or the
XML syntax
, depending
on context.
In the context of the DOM structures, the terms
HTML
document
and
XML document
are used as defined in
DOM
, and refer specifically to two different modes that
Document
objects
can find themselves in.
[DOM]
(Such uses are always hyperlinked to their
definition.)
In the context of byte streams, the term HTML document refers to resources labeled as
text/html
, and the term XML document refers to resources labeled with an
XML
MIME type
For simplicity, terms such as
shown
displayed
, and
visible
might sometimes be used when referring to the way a document is
rendered to the user. These terms are not meant to imply a visual medium; they must be considered
to apply to other media in equivalent ways.
2.1.1
Parallelism
To run steps
in parallel
means those steps are to be run, one after another,
at the same time as other logic in the standard (e.g., at the same time as the
event
loop
). This standard does not define the precise mechanism by which this is achieved, be it
time-sharing cooperative multitasking, fibers, threads, processes, using different hyperthreads,
cores, CPUs, machines, etc. By contrast, an operation that is to run
immediately
must
interrupt the currently running task, run itself, and then resume the previously running task.
For guidance on writing specifications that leverage parallelism, see
Dealing with the event loop from other specifications
To avoid race conditions between different
in parallel
algorithms that operate on
the same data, a
parallel queue
can be used.
parallel queue
represents a queue of algorithm steps that must be run in
series.
parallel queue
has an
algorithm queue
(a
queue
),
initially empty.
To
enqueue steps
to a
parallel queue
enqueue
the algorithm steps to the
parallel queue
's
algorithm
queue
To
start a new parallel queue
, run the following steps:
Let
parallelQueue
be a new
parallel queue
Run the following steps
in parallel
While true:
Let
steps
be the result of
dequeuing
from
parallelQueue
's
algorithm queue
If
steps
is not nothing, then run
steps
Assert
: running
steps
did not throw an exception, as steps
running
in parallel
are not allowed to throw.
Implementations are not expected to implement this as a continuously running
loop. Algorithms in standards are to be easy to understand and are not necessarily great for
battery life or performance.
Return
parallelQueue
Steps running
in parallel
can themselves run other steps in
in
parallel
. E.g., inside a
parallel queue
it can be useful to run a series of
steps in parallel with the queue.
Imagine a standard defined
nameList
(a
list
), along with a method to
add a
name
to
nameList
, unless
nameList
already
contains
name
, in which case it rejects.
The following solution suffers from race conditions:
Let
be a new promise created in
this
's
relevant realm
Let
global
be
this
's
relevant global
object
Run the following steps
in parallel
If
nameList
contains
name
then
queue a global task
on the
DOM manipulation task source
given
global
to reject
with a
TypeError
, and abort these
steps.
Do some potentially lengthy work.
Append
name
to
nameList
Queue a global task
on the
DOM manipulation task source
given
global
to resolve
with undefined.
Return
Two invocations of the above could run simultaneously, meaning
name
isn't in
nameList
during step 3.1, but it
might be added
before step 3.3 runs,
meaning
name
ends up in
nameList
twice.
Parallel queues solve this. The standard would let
nameListQueue
be the result of
starting a new parallel queue
, then:
Let
be a new promise created in
this
's
relevant realm
Let
global
be
this
's
relevant global
object
Enqueue the following steps
to
nameListQueue
If
nameList
contains
name
then
queue a global task
on the
DOM manipulation task source
given
global
to reject
with a
TypeError
, and abort these
steps.
Do some potentially lengthy work.
Append
name
to
nameList
Queue a global task
on the
DOM manipulation task source
given
global
to resolve
with undefined.
Return
The steps would now queue and the race is avoided.
2.1.2
Resources
The specification uses the term
supported
when referring to whether a user
agent has an implementation capable of decoding the semantics of an external resource. A format or
type is said to be
supported
if the implementation can process an external resource of that
format or type without critical aspects of the resource being ignored. Whether a specific resource
is
supported
can depend on what features of the resource's format are in use.
For example, a PNG image would be considered to be in a supported format if its
pixel data could be decoded and rendered, even if, unbeknownst to the implementation, the image
also contained animation data.
An MPEG-4 video file would not be considered to be in a supported format if the
compression format used was not supported, even if the implementation could determine the
dimensions of the movie from the file's metadata.
What some specifications, in particular the HTTP specifications, refer to as a
representation
is referred to in this specification as a
resource
[HTTP]
A resource's
critical subresources
are those that the resource needs to have
available to be correctly processed. Which resources are considered critical or not is defined by
the specification that defines the resource's format.
For
CSS style sheets
, we tentatively define here that
their critical subresources are other style sheets imported via
@import
rules, including those indirectly imported by other imported style sheets.
This definition is not fully interoperable; furthermore, some user agents seem to
count resources like background images or web fonts as critical subresources. Ideally, the CSS
Working Group would define this; see
w3c/csswg-drafts issue #1088
to track
progress on that front.
2.1.3
XML compatibility
To ease migration from HTML to XML, user agents conforming to this
specification will place elements in HTML in the
namespace, at least for the purposes of the DOM and
CSS. The term "
HTML elements
" refers to any element in that namespace, even in
XML documents.
Except where otherwise stated, all elements defined or mentioned in this specification are in
the
HTML namespace
("
"), and all
attributes defined or mentioned in this specification have no namespace.
The term
element type
is used to refer to the set of elements that have a given
local name and namespace. For example,
button
elements are elements with the element
type
button
, meaning they have the local name "
button
" and
(implicitly as defined above) the
HTML namespace
2.1.4
DOM trees
When it is stated that some element or attribute is
ignored
, or
treated as some other value, or handled as if it was something else, this refers only to the
processing of the node after it is in the DOM. A user agent must not mutate the
DOM in such situations.
A content attribute is said to
change
value only if its new value is
different than its previous value; setting an attribute to a value it already has does not change
it.
The term
empty
, when used for an attribute value,
Text
node,
or string, means that the
length
of the text is zero (i.e., not even containing
controls
or U+0020 SPACE).
An HTML element can have specific
HTML element insertion steps
HTML element
post-connection steps
HTML element removing steps
, and
HTML element moving
steps
all defined for the element's
local
name
The
insertion steps
for the HTML Standard, given
insertedNode
, are defined as the following:
If
insertedNode
is an element whose
namespace
is the
HTML namespace
, and this
standard defines
HTML element insertion steps
for
insertedNode
's
local name
, then
run the corresponding
HTML element insertion steps
given
insertedNode
If
insertedNode
is a
form-associated element
or the ancestor of a
form-associated element
, then:
If the
form-associated element
's
parser inserted flag
is set,
then return.
Reset the form owner
of the
form-associated element
If
insertedNode
is an
Element
that is not on the
stack of open elements
of an
HTML parser
, then
process internal resource links
given
insertedNode
's
node document
The
post-connection steps
for the HTML
Standard, given
insertedNode
, are defined as the following:
If
insertedNode
is an element whose
namespace
is the
HTML namespace
, and this
standard defines
HTML element post-connection
steps
for
insertedNode
's
local
name
, then run the corresponding
HTML element post-connection steps
given
insertedNode
The
removing steps
for the HTML Standard, given
removedNode
isSubtreeRoot
, and
oldAncestor
, are defined as the
following:
Let
document
be
removedNode
's
node document
If
document
's
focused area
is
removedNode
, then set
document
's
focused area
to
document
's
viewport
, and set
document
's
relevant global object
's
navigation API
's
focus changed during ongoing
to false.
This does
not
perform the
unfocusing steps
focusing steps
, or
focus update steps
, and thus no
blur
or
change
events are
fired.
If
removedNode
is an element whose
namespace
is the
HTML namespace
, and this
standard defines
HTML element removing steps
for
removedNode
's
local name
, then
run the corresponding
HTML element removing steps
given
removedNode
isSubtreeRoot
, and
oldAncestor
If
removedNode
is a
form-associated element
with a non-null
form owner
and
removedNode
and its
form owner
are no longer
in the same
tree
, then
reset the form owner
of
removedNode
If
removedNode
's
popover
attribute is not in
the
No Popover
state, then run the
hide
popover algorithm
given
removedNode
, false, false, false, and null.
The
moving steps
for the HTML Standard, given
movedNode
isSubtreeRoot
, and
oldAncestor
, are defined as the
following:
If
movedNode
is an element whose
namespace
is the
HTML namespace
, and this
standard defines
HTML element moving steps
for
movedNode
's
local name
, then run the corresponding
HTML
element moving steps
given
movedNode
isSubtreeRoot
, and
oldAncestor
If
movedNode
is a
form-associated element
with a non-null
form owner
and
movedNode
and its
form owner
are no longer in
the same
tree
, then
reset the form owner
of
movedNode
node is inserted into a
document
when the
insertion steps
are invoked
with it as the argument and it is now
in a document tree
. Analogously, a
node is removed from a document
when
the
removing steps
are invoked with it as the
argument and it is now no longer
in a document tree
A node
becomes connected
when the
insertion steps
are invoked with it as the argument and it
is now
connected
. Analogously, a node
becomes disconnected
when the
removing
steps
are invoked with it as the argument and it is now no longer
connected
A node is
browsing-context connected
when it is
connected
and
its
shadow-including root
's
browsing context
is non-null. A node
becomes browsing-context connected
when the
insertion steps
are invoked with it as the argument and it
is now
browsing-context connected
. A node
becomes browsing-context disconnected
either when the
removing steps
are invoked with it as the argument and it
is now no longer
browsing-context connected
, or when its
shadow-including
root
's
browsing context
becomes null.
2.1.5
Scripting
The construction "a
Foo
object", where
Foo
is
actually an interface, is sometimes used instead of the more accurate "an object implementing the
interface
Foo
".
An IDL attribute is said to be
getting
when its value is being retrieved
(e.g. by author script), and is said to be
setting
when a new value is
assigned to it.
If a DOM object is said to be
live
, then the attributes and methods on that object
must operate on the actual underlying data, not a snapshot of the
data.
2.1.6
Plugins
The term
plugin
refers to an
implementation-defined
set of content
handlers used by the user agent that can take part in the user agent's rendering of a
Document
object, but that neither act as
child
navigables
of the
Document
nor introduce any
Node
objects to the
Document
's DOM.
Typically such content handlers are provided by third parties, though a user agent can also
designate built-in content handlers as plugins.
A user agent must not consider the types
text/plain
and
application/octet-stream
as having a registered
plugin
One example of a plugin would be a PDF viewer that is instantiated in a
navigable
when the user navigates to a PDF file. This would count as a plugin
regardless of whether the party that implemented the PDF viewer component was the same as that
which implemented the user agent itself. However, a PDF viewer application that launches separate
from the user agent (as opposed to using the same interface) is not a plugin by this
definition.
This specification does not define a mechanism for interacting with plugins, as it
is expected to be user-agent- and platform-specific. Some UAs might opt to support a plugin
mechanism such as the Netscape Plugin API; others might use remote content converters or have
built-in support for certain types. Indeed, this specification doesn't require user agents to
support plugins at all.
[NPAPI]
Browsers should take extreme care when interacting with external content
intended for
plugins
. When third-party software is run with the same
privileges as the user agent itself, vulnerabilities in the third-party software become as
dangerous as those in the user agent.
Since different users having different sets of
plugins
provides a
tracking vector that increases the chances of users being uniquely identified, user agents are
encouraged to support the exact same set of
plugins
for each
user.
2.1.7
Character encodings
character
encoding
, or just
encoding
where that is not ambiguous, is a defined way to convert
between byte streams and Unicode strings, as defined in
Encoding
. An
encoding
has an
encoding
name
and one or more
encoding labels
, referred to as the
encoding's
name
and
labels
in the Encoding standard.
[ENCODING]
2.1.8
Conformance classes
This specification describes the conformance criteria for user agents
(relevant to implementers) and documents (relevant to authors and
authoring tool implementers).
Conforming documents
are those that comply with all the conformance criteria for
documents. For readability, some of these conformance requirements are phrased as conformance
requirements on authors; such requirements are implicitly requirements on documents: by
definition, all documents are assumed to have had an author. (In some cases, that author may
itself be a user agent — such user agents are subject to additional rules, as explained
below.)
For example, if a requirement states that "authors must not
use the
foobar
element", it would imply that documents are not allowed to
contain elements named
foobar
There is no implied relationship between document conformance requirements
and implementation conformance requirements. User agents are not free to handle non-conformant
documents as they please; the processing model described in this specification applies to
implementations regardless of the conformity of the input documents.
User agents fall into several (overlapping) categories with different conformance
requirements.
Web browsers and other interactive user agents
Web browsers that support
the XML syntax
must process elements and attributes
from the
HTML namespace
found in XML documents as described in this specification,
so that users can interact with them, unless the semantics of those elements have been
overridden by other specifications.
A conforming web browser would, upon finding a
script
element in
an XML document, execute the script contained in that element. However, if the element is found
within a transformation expressed in XSLT (assuming the user agent also supports XSLT), then the
processor would instead treat the
script
element as an opaque element that forms
part of the transform.
Web browsers that support
the HTML syntax
must process documents labeled with an
HTML MIME type
as described in this specification, so that users can interact with
them.
User agents that support scripting must also be conforming implementations of the IDL
fragments in this specification, as described in
Web IDL
[WEBIDL]
Unless explicitly stated, specifications that override the semantics of HTML
elements do not override the requirements on DOM objects representing those elements. For
example, the
script
element in the example above would still implement the
HTMLScriptElement
interface.
Non-interactive presentation user agents
User agents that process HTML and XML documents purely to render non-interactive versions of
them must comply to the same conformance criteria as web browsers, except that they are exempt
from requirements regarding user interaction.
Typical examples of non-interactive presentation user agents are printers
(static UAs) and overhead displays (dynamic UAs). It is expected that most static
non-interactive presentation user agents will also opt to
lack scripting
support
A non-interactive but dynamic presentation UA would still execute scripts,
allowing forms to be dynamically submitted, and so forth. However, since the concept of "focus"
is irrelevant when the user cannot interact with the document, the UA would not need to support
any of the focus-related DOM APIs.
Visual user agents that support the suggested default rendering
User agents, whether interactive or not, may be designated (possibly as a user option) as
supporting the suggested default rendering defined by this specification.
This is not required. In particular, even user agents that do implement the suggested default
rendering are encouraged to offer settings that override this default to improve the experience
for the user, e.g. changing the color contrast, using different focus styles, or otherwise
making the experience more accessible and usable to the user.
User agents that are designated as supporting the suggested default rendering must, while so
designated, implement the rules
the Rendering section
defines as the
behavior that user agents are
expected
to implement.
User agents with no scripting support
Implementations that do not support scripting (or which have their scripting features
disabled entirely) are exempt from supporting the events and DOM interfaces mentioned in this
specification. For the parts of this specification that are defined in terms of an events model
or in terms of the DOM, such user agents must still act as if events and the DOM were
supported.
Scripting can form an integral part of an application. Web browsers that do not
support scripting, or that have scripting disabled, might be unable to fully convey the author's
intent.
Conformance checkers
Conformance checkers must verify that a document conforms to the applicable conformance
criteria described in this specification. Automated conformance checkers are exempt from
detecting errors that require interpretation of the author's intent (for example, while a
document is non-conforming if the content of a
blockquote
element is not a quote,
conformance checkers running without the input of human judgement do not have to check that
blockquote
elements only contain quoted material).
Conformance checkers must check that the input document conforms when parsed without a
browsing context
(meaning that no scripts are run, and
that the parser's
scripting mode
is
Disabled
), and should also check that the input document
conforms when parsed with a
browsing context
in which
scripts execute, and that the scripts never cause non-conforming states to occur other than
transiently during script execution itself. (This is only a "SHOULD" and not a "MUST"
requirement because it has been proven to be impossible.
[COMPUTABLE]
The term "HTML validator" can be used to refer to a conformance checker that itself conforms
to the applicable requirements of this specification.
XML DTDs cannot express all the conformance requirements of this specification. Therefore, a
validating XML processor and a DTD cannot constitute a conformance checker. Also, since neither
of the two authoring formats defined in this specification are applications of SGML, a
validating SGML system cannot constitute a conformance checker either.
To put it another way, there are three types of conformance criteria:
Criteria that can be expressed in a DTD.
Criteria that cannot be expressed by a DTD, but can still be checked by a machine.
Criteria that can only be checked by a human.
A conformance checker must check for the first two. A simple DTD-based validator only checks
for the first class of errors and is therefore not a conforming conformance checker according
to this specification.
Data mining tools
Applications and tools that process HTML and XML documents for reasons other than to either
render the documents or check them for conformance should act in accordance with the semantics
of the documents that they process.
A tool that generates
document outlines
but
increases the nesting level for each paragraph and does not increase the nesting level for
headings
would not be conforming.
Authoring tools and markup generators
Authoring tools and markup generators must generate
conforming documents
Conformance criteria that apply to authors also apply to authoring tools, where appropriate.
Authoring tools are exempt from the strict requirements of using elements only for their
specified purpose, but only to the extent that authoring tools are not yet able to determine
author intent. However, authoring tools must not automatically misuse elements or encourage
their users to do so.
For example, it is not conforming to use an
address
element for
arbitrary contact information; that element can only be used for marking up contact information
for its nearest
article
or
body
element ancestor. However, since an
authoring tool is likely unable to determine the difference, an authoring tool is exempt from
that requirement. This does not mean, though, that authoring tools can use
address
elements for any block of italics text (for instance); it just means that the authoring tool
doesn't have to verify that when the user uses a tool for inserting contact information for an
article
element, that the user really is doing that and not inserting something
else instead.
In terms of conformance checking, an editor has to output documents that conform
to the same extent that a conformance checker will verify.
When an authoring tool is used to edit a non-conforming document, it may preserve the
conformance errors in sections of the document that were not edited during the editing session
(i.e. an editing tool is allowed to round-trip erroneous content). However, an authoring tool
must not claim that the output is conformant if errors have been so preserved.
Authoring tools are expected to come in two broad varieties: tools that work from structure
or semantic data, and tools that work on a What-You-See-Is-What-You-Get media-specific editing
basis (WYSIWYG).
The former is the preferred mechanism for tools that author HTML, since the structure in the
source information can be used to make informed choices regarding which HTML elements and
attributes are most appropriate.
However, WYSIWYG tools are legitimate. WYSIWYG tools should use elements they know are
appropriate, and should not use elements that they do not know to be appropriate. This might in
certain extreme cases mean limiting the use of flow elements to just a few elements, like
div
, and
span
and making liberal use
of the
style
attribute.
All authoring tools, whether WYSIWYG or not, should make a best effort attempt at enabling
users to create well-structured, semantically rich, media-independent content.
For compatibility with existing content and prior specifications, this specification describes
two authoring formats: one based on
XML
, and one using a
custom format
inspired by SGML (referred to as
the HTML syntax
).
Implementations must support at least one of these two formats, although supporting both is
encouraged.
Some conformance requirements are phrased as requirements on elements, attributes, methods or
objects. Such requirements fall into two categories: those describing content model restrictions,
and those describing implementation behavior. Those in the former category are requirements on
documents and authoring tools. Those in the second category are requirements on user agents.
Similarly, some conformance requirements are phrased as requirements on authors; such requirements
are to be interpreted as conformance requirements on the documents that authors produce. (In other
words, this specification does not distinguish between conformance criteria on authors and
conformance criteria on documents.)
2.1.9
Dependencies
This specification relies on several other underlying specifications.
Infra
The following terms are defined in
Infra
[INFRA]
The general iteration terms
while
continue
, and
break
Assert
implementation-defined
willful violation
tracking vector
code point
and its synonym
character
surrogate
scalar value
tuple
noncharacter
string
code unit
code unit prefix
code unit less than
starts with
ends with
length
, and
code point length
The string equality operations
is
and
identical to
scalar value string
convert
ASCII string
ASCII tab or newline
ASCII whitespace
control
ASCII digit
ASCII upper hex digit
ASCII lower hex digit
ASCII hex digit
ASCII upper alpha
ASCII lower alpha
ASCII alpha
ASCII alphanumeric
isomorphic decode
isomorphic encode
ASCII lowercase
ASCII uppercase
ASCII case-insensitive
strip newlines
normalize newlines
strip leading and trailing ASCII whitespace
strip and collapse ASCII whitespace
split a string on ASCII whitespace
split a string on commas
collect a sequence of code points
and its associated
position variable
skip ASCII whitespace
The
ordered map
data structure and the associated definitions for
key
value
empty
entry
exists
getting the value of an entry
setting the value of an entry
removing an entry
clear
getting the keys
getting the values
sorting in descending order
size
, and
iterate
The
list
data structure and the associated definitions for
append
extend
prepend
replace
remove
empty
contains
size
indices
is empty
item
iterate
, and
clone
sort in ascending order
sort in descending order
The
stack
data structure and the associated definitions for
push
and
pop
The
queue
data structure and the associated definitions for
enqueue
and
dequeue
The
ordered set
data structure and the associated definition for
append
and
union
The
struct
specification type and the associated definition for
item
The
byte sequence
data structure
The
forgiving-base64 encode
and
forgiving-base64 decode
algorithms
exclusive range
parse a JSON string to an Infra value
HTML namespace
MathML namespace
SVG namespace
XLink namespace
XML namespace
XMLNS namespace
Unicode and Encoding
The Unicode character set is used to represent textual data, and
Encoding
defines requirements around
character encodings
[UNICODE]
This specification
introduces terminology
based on the terms defined in those specifications, as described earlier.
The following terms are used as defined in
Encoding
[ENCODING]
Getting an
encoding
Get an output
encoding
The generic
decode
algorithm which takes a byte stream and an encoding and returns a character stream
The
UTF-8 decode
algorithm which takes a byte stream and returns a character stream, additionally stripping one
leading UTF-8 Byte Order Mark (BOM), if any
The
UTF-8
decode without BOM
algorithm which is identical to
UTF-8 decode
except that
it does not strip one leading UTF-8 Byte Order Mark (BOM)
The
encode
algorithm
which takes a character stream and an encoding and returns a byte stream
The
UTF-8 encode
algorithm which takes a character stream and returns a byte stream
The
BOM sniff
algorithm which takes a byte stream and returns an encoding or null.
XML and related specifications
Implementations that support
the XML syntax
for HTML must support some version
of XML, as well as its corresponding namespaces specification, because that syntax uses an XML
serialization with namespaces.
[XML]
[XMLNS]
Data mining tools and other user agents that perform operations on content without running
scripts, evaluating CSS or XPath expressions, or otherwise exposing the resulting DOM to
arbitrary content, may "support namespaces" by just asserting that their DOM node analogues are
in certain namespaces, without actually exposing the namespace strings.
In
the HTML syntax
, namespace prefixes and namespace declarations
do not have the same effect as in XML. For instance, the colon has no special meaning in HTML
element names.
The attribute with the name
space
in the
XML namespace
is defined by
Extensible Markup Language
XML
).
[XML]
The
Name
production is defined in
XML
[XML]
This specification also references the

processing instruction, defined in
Associating Style Sheets with XML documents
[XMLSSPI]
This specification also non-normatively mentions the
XSLTProcessor
interface and its
transformToFragment()
and
transformToDocument()
methods.
[XSLTP]
URLs
The following terms are defined in
URL
[URL]
host
public suffix
domain
IP address
URL
Origin
of URLs
Absolute URL
Relative URL
registrable domain
The
URL parser
The
basic URL parser
and its
url
and
state override
arguments, as well as these parser states:
scheme start state
host state
hostname state
port state
path start state
query state
fragment state
URL record
, as well as its
individual components:
scheme
username
password
host
port
path
query
fragment
blob URL entry
valid URL string
The
cannot have a username/password/port
concept
The
opaque path
concept
URL serializer
and its
exclude fragment
argument
URL path serializer
The
host parser
The
host serializer
Host equals
URL equals
and its
exclude fragments
argument
serialize an integer
Default encode set
component percent-encode set
UTF-8 percent-encode
percent-decode
set the username
set the password
The
application/x-www-form-urlencoded
format
The
application/x-www-form-urlencoded
serializer
is special
A number of schemes and protocols are referenced by this specification also:
The
about:
scheme
[ABOUT]
The
blob:
scheme
[FILEAPI]
The
data:
scheme
[RFC2397]
The
http:
scheme
[HTTP]
The
https:
scheme
[HTTP]
The
mailto:
scheme
[MAILTO]
The
sms:
scheme
[SMS]
The
urn:
scheme
[URN]
Media fragment
syntax
is defined in
Media Fragments URI
[MEDIAFRAG]
URL Pattern
The following terms are defined in
URL Pattern
[URLPATTERN]
URL pattern
match
build a URL pattern from an Infra value
parse a URL pattern constructor string
URLPatternInit
HTTP and related specifications
The following terms are defined in the HTTP specifications:
[HTTP]
Accept
` header
Accept-Language
` header
Cache-Control
` header
Content-Disposition
` header
Content-Language
` header
Content-Range
` header
Last-Modified
` header
Range
` header
Referer
` header
The following terms are defined in
HTTP State Management Mechanism
[COOKIES]
cookie-string
receives a set-cookie-string
` header
The following term is defined in
Web Linking
[WEBLINK]
Link
` header
Parsing a `
Link
` field value
The following terms are defined in
Structured Field Values for HTTP
[STRUCTURED-FIELDS]
structured header
boolean
list
parameters
string
token
The following terms are defined in
MIME Sniffing
[MIMESNIFF]
MIME type
MIME type essence
valid MIME type string
valid MIME type string with no parameters
HTML MIME type
JavaScript MIME type
and
JavaScript MIME type essence match
JSON MIME type
XML MIME type
image MIME type
audio or video MIME type
font MIME type
parse a MIME type
is MIME type supported by the user agent?
Fetch
The following terms are defined in
Fetch
[FETCH]
ABNF
about:blank
Sec-Purpose
An
HTTP(S) scheme
A URL which
is local
local scheme
fetch scheme
CORS protocol
environment default `
User-Agent
` value
extract a MIME type
legacy extract an encoding
fetch
fetch controller
process the next manual redirect
ok status
navigation request
network error
aborted network error
Origin
` header
Cross-Origin-Resource-Policy
` header
getting a structured field value
header list
set
get, decode, and split
abort
cross-origin resource policy check
the
RequestCredentials
enumeration
the
RequestDestination
enumeration
the
fetch()
method
report timing
serialize a response URL for reporting
safely extracting a body
incrementally reading a body
processResponseConsumeBody
processResponseEndOfBody
processResponse
useParallelQueue
processEarlyHintsResponse
connection pool
obtain a connection
determine the network partition key
extract full timing info
as a body
response body info
resolve an origin
credentials
reserve deferred fetch quota
potentially free deferred fetch quota
is offline
response
and its
associated:
type
URL
URL list
status
header list
body
body info
internal response
location URL
timing info
service worker timing info
has-cross-origin-redirects
timing allow passed
extract content-range values
request
and its associated:
URL
method
header list
body
client
URL list
current URL
reserved client
replaces client id
initiator
destination
potential destination
translating
potential destination
script-like
destinations
priority
origin
referrer
synchronous flag
mode
credentials mode
use-URL-credentials flag
unsafe-request flag
cache mode
redirect count
redirect mode
policy container
referrer policy
cryptographic nonce metadata
integrity metadata
parser metadata
reload-navigation flag
history-navigation flag
user-activation
render-blocking
initiator type
service-workers mode
traversable for user prompts
top-level navigation initiator origin
add a range header
destination type
fetch timing info
and its
associated:
start time
end time
The following terms are defined in
Referrer Policy
[REFERRERPOLICY]
referrer policy
The `
Referrer-Policy
` HTTP header
The
parse a referrer policy from a `
Referrer-Policy
` header
algorithm
The "
no-referrer
",
no-referrer-when-downgrade
",
origin-when-cross-origin
", and
unsafe-url
" referrer policies
The
default referrer policy
The following terms are defined in
Mixed Content
[MIX]
a priori
authenticated URL
mixed content
The following terms are defined in
Subresource Integrity
[SRI]
parse integrity metadata
the requirements of the integrity attribute
get the strongest metadata from set
integrity policy
parse Integrity-Policy headers
The No-Vary-Search HTTP Response Header Field
The following terms are defined in
The No-Vary-Search HTTP Response Header
Field
[NOVARYSEARCH]
No-Vary-Search
parse a URL search variance
URL search variance
default URL search variance
equivalent modulo search variance
Paint Timing
The following terms are defined in
Paint Timing
[PAINTTIMING]
mark paint timing
Navigation Timing
The following terms are defined in
Navigation Timing
[NAVIGATIONTIMING]
create the navigation timing entry
queue the navigation timing entry
NavigationTimingType
and its
navigate
",
reload
", and
back_forward
" values.
Resource Timing
The following terms are defined in
Resource Timing
[RESOURCETIMING]
Mark resource timing
Performance Timeline
The following terms are defined in
Performance Timeline
[PERFORMANCETIMELINE]
PerformanceEntry
and its
name
entryType
startTime
, and
duration
attributes.
Queue a performance entry
Long Animation Frames
The following terms are defined in
Long Animation Frames
[LONGANIMATIONFRAMES]
record task start time
record task end time
record rendering time
record classic script creation time
record classic script execution start time
record module script execution start time
Record pause duration
record timing info for timer handler
record timing info for microtask checkpoint
Long Tasks
The following terms are defined in
Long Tasks
[LONGTASKS]
report long tasks
Web IDL
The IDL fragments in this specification must be interpreted as required for conforming IDL
fragments, as described in
Web IDL
[WEBIDL]
The following terms are defined in
Web IDL
this
extended attribute
named constructor
constructor operation
overridden constructor steps
internally create a new object implementing the interface
array index property name
buffer source byte length
supports indexed properties
supported property indices
determine the value of an indexed property
set the value of an existing indexed property
set the value of a new indexed property
support named properties
supported property names
determine the value of a named property
set the value of an existing named property
set the value of a new named property
delete an existing named property
perform a security check
platform object
legacy platform object
primary interface
interface object
named properties object
include
inherit
interface prototype object
implements
associated realm
[[Realm]] field of a platform object
[[GetOwnProperty]] internal method of a named properties object
callback context
frozen array
and
creating a frozen array
create a new object implementing the interface
callback this value
converting
between Web IDL types and JS types
invoking
and
constructing
callback functions
overload resolution algorithm
exposed
a promise resolved with
a promise rejected with
wait for all
upon rejection
upon fulfillment
mark as handled
[Global]
[LegacyFactoryFunction]
[LegacyLenientThis]
[LegacyNullToEmptyString]
[LegacyOverrideBuiltIns]
LegacyPlatformObjectGetOwnProperty
[LegacyTreatNonObjectAsNull]
[LegacyUnenumerableNamedProperties]
[LegacyUnforgeable]
set entries
Web IDL
also defines the following types that are used in this specification:
ArrayBuffer
ArrayBufferView
boolean
DOMString
double
enumeration
Float16Array
Function
long
object
Promise
Uint8ClampedArray
unrestricted double
unsigned long
USVString
VoidFunction
QuotaExceededError
The term
throw
in this
specification is used as defined in
Web IDL
. The
DOMException
type and the following exception names are defined by Web IDL and used by this
specification:
IndexSizeError
HierarchyRequestError
InvalidCharacterError
NoModificationAllowedError
NotFoundError
NotSupportedError
InvalidStateError
SyntaxError
InvalidAccessError
SecurityError
NetworkError
AbortError
DataCloneError
EncodingError
NotAllowedError
When this specification requires a user agent to
create a
Date
object
representing a particular time (which could be the special value Not-a-Number), the milliseconds
component of that time, if any, must be truncated to an integer, and the time value of the newly
created
Date
object must represent the resulting truncated time.
For instance, given the time 23045 millionths of a second after 01:00 UTC on
January 1st 2000, i.e. the time 2000-01-01T00:00:00.023045Z, then the
Date
object
created representing that time would represent the same time as that created representing the
time 2000-01-01T00:00:00.023Z, 45 millionths earlier. If the given time is NaN, then the result
is a
Date
object that represents a time value NaN (indicating that the object does
not represent a specific instant of time).
JavaScript
Some parts of the language described by this specification only support JavaScript as the
underlying scripting language.
[JAVASCRIPT]
The term "JavaScript" is used to refer to ECMA-262, rather than the official
term ECMAScript, since the term JavaScript is more widely known.
The following terms are defined in the JavaScript specification and used in this
specification:
active function object
agent
and
agent cluster
automatic semicolon insertion
candidate execution
The
current realm
clamping
a mathematical value
early error
forward progress
invariants of the essential internal methods
JavaScript execution context
JavaScript execution context stack
realm
JobCallback Record
NewTarget
running JavaScript execution context
surrounding agent
abstract closure
immutable prototype exotic object
Well-Known Symbols
, including
%Symbol.hasInstance%
%Symbol.isConcatSpreadable%
%Symbol.toPrimitive%
, and
%Symbol.toStringTag%
Well-Known Intrinsic Objects
, including
%Array.prototype%
%Error.prototype%
%EvalError.prototype%
%Function.prototype%
%Object.prototype%
%Object.prototype.valueOf%
%RangeError.prototype%
%ReferenceError.prototype%
%SyntaxError.prototype%
%TypeError.prototype%
, and
%URIError.prototype%
The
FunctionBody
production
The
Module
production
The
Pattern
production
The
Script
production
The
BigInt
Boolean
Number
String
Symbol
and
Object
ECMAScript language types
The
Completion Record
specification type
The
List
and
Record
specification types
The
Property Descriptor
specification type
The
ModuleRequest Record
specification type
The
Script Record
specification type
The
Synthetic Module Record
specification type
The
Cyclic Module Record
specification type
The
Source Text Module Record
specification type and its
Evaluate
Link
and
LoadRequestedModules
methods
The
ArrayCreate
abstract operation
The
Call
abstract operation
The
ClearKeptObjects
abstract operation
The
CleanupFinalizationRegistry
abstract operation
The
Construct
abstract operation
The
CopyDataBlockBytes
abstract operation
The
CreateBuiltinFunction
abstract operation
The
CreateByteDataBlock
abstract operation
The
CreateDataProperty
abstract operation
The
CreateDefaultExportSyntheticModule
abstract operation
The
DefinePropertyOrThrow
abstract operation
The
DetachArrayBuffer
abstract operation
The
EnumerableOwnProperties
abstract operation
The
FinishLoadingImportedModule
abstract operation
The
OrdinaryFunctionCreate
abstract operation
The
Get
abstract operation
The
GetActiveScriptOrModule
abstract operation
The
GetFunctionRealm
abstract operation
The
HasOwnProperty
abstract operation
The
HostCallJobCallback
abstract operation
The
HostEnqueueFinalizationRegistryCleanupJob
abstract operation
The
HostEnqueueGenericJob
abstract operation
The
HostEnqueuePromiseJob
abstract operation
The
HostEnqueueTimeoutJob
abstract operation
The
HostEnsureCanAddPrivateElement
abstract operation
The
HostGetSupportedImportAttributes
abstract operation
The
HostLoadImportedModule
abstract operation
The
HostMakeJobCallback
abstract operation
The
HostPromiseRejectionTracker
abstract operation
The
InitializeHostDefinedRealm
abstract operation
The
IsArrayBufferViewOutOfBounds
abstract operation
The
IsAccessorDescriptor
abstract operation
The
IsCallable
abstract operation
The
IsConstructor
abstract operation
The
IsDataDescriptor
abstract operation
The
IsDetachedBuffer
abstract operation
The
IsSharedArrayBuffer
abstract operation
The
NewObjectEnvironment
abstract operation
The
NormalCompletion
abstract operation
The
OrdinaryGetPrototypeOf
abstract operation
The
OrdinarySetPrototypeOf
abstract operation
The
OrdinaryIsExtensible
abstract operation
The
OrdinaryPreventExtensions
abstract operation
The
OrdinaryGetOwnProperty
abstract operation
The
OrdinaryDefineOwnProperty
abstract operation
The
OrdinaryGet
abstract operation
The
OrdinarySet
abstract operation
The
OrdinaryDelete
abstract operation
The
OrdinaryOwnPropertyKeys
abstract operation
The
OrdinaryObjectCreate
abstract operation
The
ParseJSONModule
abstract operation
The
ParseModule
abstract operation
The
ParseScript
abstract operation
The
NewPromiseReactionJob
abstract operation
The
NewPromiseResolveThenableJob
abstract operation
The
RegExpBuiltinExec
abstract operation
The
RegExpCreate
abstract operation
The
RunJobs
abstract operation
The
SameValue
abstract operation
The
ScriptEvaluation
abstract operation
The
SetSyntheticModuleExport
abstract operation
The
SetImmutablePrototype
abstract operation
The
ThrowCompletion
abstract operation
The
ToBoolean
abstract operation
The
ToString
abstract operation
The
ToUint32
abstract operation
The
TypedArrayCreate
abstract operation
The
IsLooselyEqual
abstract operation
The
IsStrictlyEqual
abstract operation
The
Atomics
object
The
Atomics.waitAsync
object
The
Date
class
The
FinalizationRegistry
class
The
RegExp
class
The
SharedArrayBuffer
class
The
SyntaxError
class
The
TypeError
class
The
RangeError
class
The
WeakRef
class
The
eval()
function
The
WeakRef.prototype.deref()
function
The
[[IsHTMLDDA]]
internal slot
import()
import.meta
The
HostGetImportMetaProperties
abstract operation
The
typeof
operator
The
delete
operator
The
TypedArray
Constructors
table
User agents that support JavaScript must also implement the
Dynamic Code Brand
Checks
proposal. The following terms are defined there, and used in this specification:
[JSDYNAMICCODEBRANDCHECKS]
The
HostEnsureCanCompileStrings
abstract operation
The
HostGetCodeForEval
abstract operation
User agents that support JavaScript must also implement the
Import Text
proposal.
The following term is defined there, and used in this specification:
[JSIMPORTTEXT]
The
CreateTextModule
abstract operation
User agents that support JavaScript must also implement
ECMAScript
Internationalization API
[JSINTL]
User agents that support JavaScript must also implement the
Temporal
proposal.
The following terms are defined there, and used in this specification:
[JSTEMPORAL]
The
HostSystemUTCEpochNanoseconds
abstract operation
The
nsMaxInstant
and
nsMinInstant
values
WebAssembly
The following term is defined in
WebAssembly JavaScript Interface
[WASMJS]
WebAssembly.Module
DOM
The Document Object Model (DOM) is a representation — a model — of a document and
its content. The DOM is not just an API; the conformance criteria of HTML implementations are
defined, in this specification, in terms of operations on the DOM.
[DOM]
Implementations must support DOM and the events defined in UI Events, because this
specification is defined in terms of the DOM, and some of the features are defined as extensions
to the DOM interfaces.
[DOM]
[UIEVENTS]
In particular, the following features are defined in
DOM
[DOM]
Attr
interface
CharacterData
interface
Comment
interface
DOMImplementation
interface
Document
interface and its
doctype
attribute
DocumentOrShadowRoot
interface
DocumentFragment
interface
DocumentType
interface
ChildNode
interface
Element
interface
attachShadow()
method.
An element's
shadow root
shadow root
's
mode
shadow root
's
declarative
member
The
attach a shadow root
algorithm
The
retargeting algorithm
Node
interface
NodeList
interface
ProcessingInstruction
interface
ShadowRoot
interface
Text
interface
Range
interface
node document
concept
document type
concept
host
concept
The
shadow root
concept, and its
delegates focus
available to element internals
clonable
serializable
custom element registry
, and
keep custom element registry null
The
shadow host
concept
HTMLCollection
interface, its
length
attribute, and its
item()
and
namedItem()
methods
The terms
collection
and
represented by the collection
DOMTokenList
interface, and its
value
attribute and
supports
operation
createDocument()
method
createHTMLDocument()
method
createElement()
method
createElementNS()
method
getElementById()
method
getElementsByClassName()
method
append()
method
appendChild()
method
cloneNode()
method
moveBefore()
method
importNode()
method
preventDefault()
method
id
attribute
setAttribute()
method
textContent
attribute
The
tree
shadow tree
, and
node tree
concepts
The
tree order
and
shadow-including tree order
concepts
The
element
concept
The
child
concept
The
root
and
shadow-including root
concepts
The
inclusive ancestor
ancestor
descendant
shadow-including ancestor
shadow-including descendant
shadow-including inclusive descendant
, and
shadow-including inclusive ancestor
concepts
The
first child
last child
next sibling
previous sibling
, and
parent
concepts
The
parent element
concept
The
document element
concept
The
in a document tree
in a document
(legacy), and
connected
concepts
The
slot
concept, and its
name
and
assigned nodes
The
assigned slot
concept
The
slot assignment
concept
The
slottable
concept
The
assign slottables for a tree
algorithm
The
slotchange
event
The
inclusive descendant
concept
The
find flattened slottables
algorithm
The
manual slot assignment
concept
The
assign a slot
algorithm
The
pre-insert
insert
append
replace
replace all
string replace all
remove
, and
adopt
algorithms for nodes
The
descendant
concept
The
insertion steps
The
post-connection steps
removing steps
moving steps
adopting steps
, and
children changed steps
hooks for elements
The
change
append
remove
replace
get an attribute by namespace and local name
set value
, and
remove an attribute by namespace and local name
algorithms for attributes
The
attribute change steps
hook for attributes
The
value
concept for attributes
The
local name
concept for attributes
The
attribute list
concept
The
data
of a
CharacterData
node and its
replace data
algorithm
The
child text content
of a node
The
descendant text content
of a node
The
name
public ID
, and
system ID
of a doctype
Event
interface
Event
and derived interfaces constructor behavior
EventTarget
interface
The
activation behavior
hook
The
legacy-pre-activation behavior
hook
The
legacy-canceled-activation behavior
hook
The
create an event
algorithm
The
fire an event
algorithm
The
canceled flag
The
dispatch flag
The
dispatch
algorithm
EventInit
dictionary type
type
attribute
An event's
target
currentTarget
attribute
bubbles
attribute
cancelable
attribute
composed
attribute
composed flag
isTrusted
attribute
initEvent()
method
add an event listener
addEventListener()
method
The
remove an event listener
and
remove all event listeners
algorithms
EventListener
callback interface
The
type
of an event
An
event listener
and its
type
and
callback
The
encoding
(herein the
character encoding
),
mode
custom element registry
allow declarative shadow roots
, and
content type
of a
Document
The distinction between
XML documents
and
HTML documents
The terms
quirks mode
limited-quirks mode
, and
no-quirks mode
The algorithm
clone a node
with its arguments
document
subtree
parent
, and
fallbackRegistry
, and the concept of
cloning steps
The concept of an element's
unique identifier (ID)
The concept of an element's
classes
The term
supported tokens
The concept of a DOM
range
, and the terms
start node
start
end
, and
boundary point
as applied to ranges.
The
create an element
algorithm
The
element interface
concept
The concepts of
custom element state
, and of
defined
and
custom
elements
An element's
namespace
namespace prefix
local name
custom element registry
custom element definition
, and
is
value
MutationObserver
interface and
mutation observers
in general
AbortController
and its
signal
AbortSignal
aborted
signal abort
add
valid attribute local name
valid element local name
is a global custom element registry
The following features are defined in
UI Events
[UIEVENTS]
The
FocusEvent
interface
The
FocusEvent
interface's
relatedTarget
attribute
The
UIEvent
interface
The
UIEvent
interface's
view
attribute
beforeinput
event
contextmenu
event
input
event
keydown
event
keypress
event
keyup
event
The following features are defined in
Touch Events
[TOUCH]
Touch
interface
Touch point
concept
touchend
event
The following features are defined in
Pointer Events
[POINTEREVENTS]
The
MouseEvent
interface
The
MouseEvent
interface's
relatedTarget
attribute
The
MouseEvent
interface's
button
attribute
MouseEventInit
dictionary type
The
PointerEvent
interface
The
PointerEvent
interface's
pointerType
attribute
fire a pointer event
auxclick
event
click
event
dblclick
event
mousedown
event
mouseenter
event
mouseleave
event
mousemove
event
mouseout
event
mouseover
event
mouseup
event
pointerdown
event
pointerup
event
pointercancel
event
wheel
event
The following events are defined in
Clipboard API and events
[CLIPBOARD-APIS]
copy
event
cut
event
paste
event
This specification sometimes uses the term
name
to refer to the event's
type
; as in, "an event named
click
" or "if the event name is
keypress
". The terms
"name" and "type" for events are synonymous.
The following features are defined in
DOM Parsing and Serialization
[DOMPARSING]
XML serialization
The following features are defined in
Selection API
[SELECTION]
selection
Selection
User agents are encouraged to implement the features described in
execCommand
[EXECCOMMAND]
The following features are defined in
Fullscreen API
[FULLSCREEN]
requestFullscreen()
fullscreenchange
run the fullscreen steps
fully exit fullscreen
fullscreen element
fullscreen flag
High Resolution Time
provides the following features:
[HRT]
current high resolution time
relative high resolution time
unsafe shared current time
shared monotonic clock
unsafe moment
duration from
coarsen time
current wall time
Unix epoch
DOMHighResTimeStamp
File API
This specification uses the following features defined in
File API
[FILEAPI]
The
Blob
interface and its
type
attribute
The
File
interface and its
name
and
lastModified
attributes
The
FileList
interface
The concept of a
Blob
's
snapshot state
The concept of
read errors
Blob URL Store
blob URL entry
and its
environment
The
obtain a blob object
algorithm
Indexed Database API
The following terms are defined in
Indexed Database API
[INDEXEDDB]
cleanup Indexed Database transactions
IDBVersionChangeEvent
Media Source Extensions
The following terms are defined in
Media Source Extensions
[MEDIASOURCE]
MediaSource
interface
detaching from a media element
Media Capture and Streams
The following terms are defined in
Media Capture and Streams
[MEDIASTREAM]
MediaStream
interface
MediaStreamTrack
live state
getUserMedia()
Reporting
The following terms are defined in
Reporting
[REPORTING]
Queue a report
report type
visible to
ReportingObserver
XMLHttpRequest
The following features and terms are defined in
XMLHttpRequest
[XHR]
The
XMLHttpRequest
interface, and its
responseXML
attribute
The
ProgressEvent
interface, and its
lengthComputable
loaded
, and
total
attributes
The
FormData
interface, and its associated
entry list
Battery Status
The following features are defined in
Battery Status API
[BATTERY]
getBattery()
method
Media Queries
Implementations must support
Media Queries
. The

feature is defined therein.
[MQ]
CSS modules
While support for CSS as a whole is not required of implementations of this specification
(though it is encouraged, at least for web browsers), some features are defined in terms of
specific CSS requirements.
When this specification requires that something be
parsed according
to a particular CSS grammar
, the relevant algorithm in
CSS Syntax
must be
followed, including error handling rules.
[CSSSYNTAX]
For example, user agents are required to close all open constructs upon
finding the end of a style sheet unexpectedly. Thus, when parsing the string "
rgb(0,0,0
" (with a missing close-parenthesis) for a color value, the close
parenthesis is implied by this error handling rule, and a value is obtained (the color 'black').
However, the similar construct "
rgb(0,0,
" (with both a missing
parenthesis and a missing "blue" value) cannot be parsed, as closing the open construct does not
result in a viable value.
The following terms and features are defined in
Cascading Style Sheets
CSS
):
[CSS]
viewport
line box
out-of-flow
in-flow
collapsing margins
containing block
inline box
block box
The
'top'
'bottom'
'left'
, and
'right'
properties
The
'float'
property
The
'clear'
property
The
'width'
property
The
'height'
property
The
'min-width'
property
The
'min-height'
property
The
'max-width'
property
The
'max-height'
property
The
'line-height'
property
The
'vertical-align'
property
The
'content'
property
The
'inline-block'
value of the
'display'
property
The
'visibility'
property
The basic version of the
'display'
property
is defined in
CSS
, and the property is extended by other CSS modules.
[CSS]
[CSSRUBY]
[CSSTABLE]
The following terms and features are defined in
CSS Box Model
[CSSBOX]
content area
content box
border box
margin box
border edge
margin edge
The
'margin-top'
'margin-bottom'
'margin-left'
, and
'margin-right'
properties
The
'padding-top'
'padding-bottom'
'padding-left'
, and
'padding-right'
properties
The following features are defined in
CSS Logical Properties
[CSSLOGICAL]
The
'margin-block'
'margin-block-start'
'margin-block-end'
'margin-inline'
'margin-inline-start'
, and
'margin-inline-end'
properties
The
'padding-block'
'padding-block-start'
'padding-block-end'
'padding-inline'
'padding-inline-start'
, and
'padding-inline-end'
properties
The
'border-block-width'
'border-block-start-width'
'border-block-end-width'
'border-inline-width'
'border-inline-start-width'
'border-inline-end-width'
'border-block-style'
'border-block-start-style'
'border-block-end-style'
'border-inline-style'
'border-inline-start-style'
'border-inline-end-style'
'border-block-start-color'
'border-block-end-color'
'border-inline-start-color'
'border-inline-end-color'
'border-start-start-radius'
'border-start-end-radius'
'border-end-start-radius'
, and
'border-end-end-radius'
properties
The
'block-size'
property
The
'inline-size'
property
The
'inset-block-start'
property
The
'inset-block-end'
property
The following terms and features are defined in
CSS Color
[CSSCOLOR]
named color

The
'color'
property
The
'currentcolor'
value
opaque black
transparent black
'srgb'
color space
'srgb-linear'
color space
'display-p3'
color space
'display-p3-linear'
color space
'relative-colorimetric'
rendering intent
parse a CSS value
serialize a CSS value
including
HTML-compatible serialization is requested
Converting Colors
'color()'
The following terms are defined in
CSS Images
[CSSIMAGES]
default object size
default sizing algorithm
concrete object size
natural dimensions
natural height
natural width
The
'image-orientation'
property
'conic-gradient'
The
'object-fit'
property
The term
paint
source
is used as defined in
CSS Images Level 4
to define the interaction of certain HTML elements with the CSS 'element()' function.
[CSSIMAGES4]
The following features are defined in
CSS Backgrounds and Borders
[CSSBG]
The
'background-color'
'background-image'
'background-repeat'
'background-attachment'
'background-position'
'background-clip'
'background-origin'
, and
'background-size'
properties
The
'border-radius'
'border-top-left-radius'
'border-top-right-radius'
'border-bottom-right-radius'
'border-bottom-left-radius'
properties
The
'border-image-source'
'border-image-slice'
'border-image-width'
'border-image-outset'
, and
'border-image-repeat'
properties
CSS Backgrounds and Borders
also defines the following border properties:
[CSSBG]
Border properties
Top
Bottom
Left
Right
Width
'border-top-width'
'border-bottom-width'
'border-left-width'
'border-right-width'
Style
'border-top-style'
'border-bottom-style'
'border-left-style'
'border-right-style'
Color
'border-top-color'
'border-bottom-color'
'border-left-color'
'border-right-color'
The following features are defined in
CSS Box Alignment
[CSSALIGN]
The
'align-content'
property
The
'align-items'
property
The
'align-self'
property
The
'justify-self'
property
The
'justify-content'
property
The
'justify-items'
property
The following terms and features are defined in
CSS Display
[CSSDISPLAY]
outer display type
inner display type
block-level
block container
formatting context
block formatting context
inline formatting context
replaced element
CSS box
The following features are defined in
CSS Flexible Box Layout
[CSSFLEXBOX]
The
'flex-direction'
property
The
'flex-wrap'
property
The following terms and features are defined in
CSS Fonts
[CSSFONTS]
first available font
The
'font-family'
property
The
'font-weight'
property
The
'font-size'
property
The
'font'
property
The
'font-kerning'
property
The
'font-stretch'
property
The
'font-variant-caps'
property
The
'small-caps'
value
The
'all-small-caps'
value
The
'petite-caps'
value
The
'all-petite-caps'
value
The
'unicase'
value
The
'titling-caps'
value
The
'ultra-condensed'
value
The
'extra-condensed'
value
The
'condensed'
value
The
'semi-condensed'
value
The
'semi-expanded'
value
The
'expanded'
value
The
'extra-expanded'
value
The
'ultra-expanded'
value
The following features are defined in
CSS Forms
[CSSFORMS]
'::picker'
'::checkmark'
'::picker-icon'
picker form control identifier
The following features are defined in
CSS Grid Layout
[CSSGRID]
The
'grid-auto-columns'
property
The
'grid-auto-flow'
property
The
'grid-auto-rows'
property
The
'grid-column-gap'
property
The
'grid-row-gap'
property
The
'grid-template-areas'
property
The
'grid-template-columns'
property
The
'grid-template-rows'
property
The following terms are defined in
CSS Inline Layout
[CSSINLINE]
alphabetic baseline
ascent metric
descent metric
em-over baseline
em-under baseline
hanging baseline
ideographic-under baseline
The following terms and features are defined in
CSS Box Sizing
[CSSSIZING]
fit-content inline size
'aspect-ratio'
property
intrinsic size
The following features are defined in
CSS Lists and Counters
[CSSLISTS]
list item
The
'counter-reset'
property
The
'counter-set'
property
The
'list-style-type'
property
The following features are defined in
CSS Overflow
[CSSOVERFLOW]
The
'overflow'
property and its
'hidden'
value
The
'text-overflow'
property
The term
scroll container
The following terms and features are defined in
CSS Positioned Layout
[CSSPOSITION]
absolutely-positioned
The
'position'
property and its
'static'
value
The
top layer
(an
ordered set
add an element to the top layer
request an element to be removed from the top layer
remove an element from the top layer immediately
process top layer removals
The following features are defined in
CSS Multi-column Layout
[CSSMULTICOL]
The
'column-count'
property
The
'column-fill'
property
The
'column-gap'
property
The
'column-rule'
property
The
'column-width'
property
The
'ruby-base'
value of the
'display'
property is defined in
CSS Ruby Layout
[CSSRUBY]
The following features are defined in
CSS Table
[CSSTABLE]
The
'border-spacing'
property
The
'border-collapse'
property
The
'table-cell'
'table-row'
'table-caption'
, and
'table'
values of the
'display'
property
The following features are defined in
CSS Text
[CSSTEXT]
The
content language
concept
The
'text-transform'
property
The
'white-space'
property
The
'text-align'
property
The
'letter-spacing'
property
The
'word-spacing'
property
The following features are defined in
CSS Writing Modes
[CSSWM]
The
'direction'
property
The
'unicode-bidi'
property
The
'writing-mode'
property
The
block flow direction
block axis
inline axis
block size
inline size
block-start
block-end
inline-start
inline-end
line-left
, and
line-right
concepts
The following features are defined in
CSS Basic User Interface
[CSSUI]
The
'outline'
property
The
'cursor'
property
The
'appearance'
property, its

non-terminal value type, its
'textfield'
value, and its
'menulist-button'
value.
The
'field-sizing'
property, and its
'content'
value.
The concept
widget
The concept
native appearance
The concept
primitive appearance
The concept
base appearance
The concept
element with default preferred size
The
non-devolvable widget
and
devolvable widget
classification, and the related
devolved widget
state.
The
'pointer-events'
property
The
'user-select'
property
The algorithm to
update
animations and send events
is defined in
Web Animations
[WEBANIMATIONS]
Implementations that support scripting must support the CSS Object Model. The following
features and terms are defined in the CSSOM specifications:
[CSSOM]
[CSSOMVIEW]
Screen
interface
LinkStyle
interface
CSSStyleDeclaration
interface
style
IDL attribute
cssText
attribute of
CSSStyleDeclaration
StyleSheet
interface
CSSStyleSheet
interface
create a CSS style sheet
remove a CSS style sheet
associated CSS style sheet
create a constructed
CSSStyleSheet
synchronously replace the rules of a
CSSStyleSheet
disable a CSS style sheet
CSS style sheets
and their
properties:
type
location
parent CSS style sheet
owner node
owner CSS rule
media
title
alternate flag
disabled flag
CSS rules
origin-clean flag
CSS style sheet set
CSS style sheet set name
preferred CSS style sheet set name
change the preferred CSS style sheet set name
Serializing a CSS value
run the resize steps
run the scroll steps
evaluate media queries and report changes
Scroll a target into view
Scroll to the beginning of the document
The
resize
event
The
scroll
event
The
scrollend
event
set up browsing context features
The
clientX
and
clientY
extension attributes of the
MouseEvent
interface
The following features and terms are defined in
CSS Syntax
[CSSSYNTAX]
conformant style sheet
parse a list of component values
parse a comma-separated list of component values
component value
environment encoding

The following terms are defined in
Selectors
[SELECTORS]

parse a selector
selector
type selector
attribute selector
pseudo-class
:focus-visible
pseudo-class
indicate focus
pseudo-element
match a selector against an element
scoping root
The following features are defined in
CSS Values and Units
[CSSVALUES]

The
'em'
unit
The
'ex'
unit
The
'vw'
unit
The
'in'
unit
The
'px'
unit
The
'pt'
unit
The
'attr()'
function
The
math functions
The following features are defined in
CSS View Transitions
[CSSVIEWTRANSITIONS]
perform pending transition operations
rendering suppression for view transitions
activate view transition
ViewTransition
view transition page visibility change steps
resolving inbound cross-document view-transition
setting up a cross-document view-transition
can navigation trigger a cross-document view-transition?
The term
style attribute
is
defined in
CSS Style Attributes
[CSSATTR]
The following terms are defined in the
CSS Cascading and Inheritance
[CSSCASCADE]
cascaded value
specified value
computed value
used value
cascade origin
Author Origin
User Origin
User Agent Origin
Animation Origin
Transition Origin
initial value
The
CanvasRenderingContext2D
object's use of fonts depends on the features
described in the CSS
Fonts
and
Font Loading
specifications, including
in particular
FontFace
objects and the
font source
concept.
[CSSFONTS]
[CSSFONTLOAD]
The following interfaces and terms are defined in
Geometry Interfaces
[GEOMETRY]
DOMMatrix
interface, and associated
m11 element
m12 element
m21 element
m22 element
m41 element
, and
m42 element
DOMMatrix2DInit
and
DOMMatrixInit
dictionaries
The
create a
DOMMatrix
from a dictionary
and
create a
DOMMatrix
from a 2D dictionary
algorithms for
DOMMatrix2DInit
or
DOMMatrixInit
The
DOMPointInit
dictionary, and associated
and
members
Matrix multiplication
The following terms are defined in the
CSS Scoping
[CSSSCOPING]
flat tree
The following terms and features are defined in
CSS Color Adjustment
[CSSCOLORADJUST]
'color-scheme'
page's supported color-schemes
The following terms are defined in
CSS Pseudo-Elements
[CSSPSEUDO]
'::details-content'
'::file-selector-button'
The following terms are defined in
CSS Containment
[CSSCONTAIN]
skips its contents
relevant to the user
proximity to the viewport
layout containment
'content-visibility'
property
'auto'
value for
'content-visibility'
The following terms are defined in
CSS Anchor Positioning
[CSSANCHOR]
implicit anchor element
Intersection Observer
The following term is defined in
Intersection Observer
[INTERSECTIONOBSERVER]
run the update intersection observations steps
IntersectionObserver
IntersectionObserverInit
observe
unobserve
isIntersecting
target
Resize Observer
The following terms are defined in
Resize Observer
[RESIZEOBSERVER]
gather active resize observations at depth
has active resize observations
has skipped resize observations
broadcast active resize observations
deliver resize loop error
WebGL
The following interfaces are defined in the WebGL specifications:
[WEBGL]
WebGLRenderingContext
interface
WebGL2RenderingContext
interface
WebGLContextAttributes
dictionary
WebGPU
The following interfaces are defined in
WebGPU
[WEBGPU]
GPUCanvasContext
interface
WebVTT
Implementations may support WebVTT as a text track format for subtitles, captions, metadata,
etc., for media resources.
[WEBVTT]
The following terms, used in this specification, are defined in
WebVTT
WebVTT file
WebVTT file using cue text
WebVTT file using only nested cues
WebVTT parser
The
rules for updating the display of WebVTT text tracks
The WebVTT
text track cue writing direction
VTTCue
interface
ARIA
The
role
attribute is defined in
Accessible Rich Internet Applications
ARIA
), as are the following
roles:
[ARIA]
button
presentation
In addition, the following
aria-*
content
attributes are defined in
ARIA
[ARIA]
aria-checked
aria-describedby
aria-disabled
aria-label
aria-level
Finally, the following terms are defined in
ARIA
[ARIA]
role
accessible name
The
ARIAMixin
interface, with its associated
ARIAMixin
getter steps
and
ARIAMixin
setter steps
hooks, and its
role
and
aria*
attributes
Content Security Policy
The following terms are defined in
Content Security Policy
[CSP]
Content Security Policy
disposition
directive set
Content Security Policy directive
CSP list
The
Content Security Policy syntax
enforce the policy
The
parse a serialized Content Security Policy
algorithm
The
Run CSP initialization for a Document
algorithm
The
Run CSP initialization for a global object
algorithm
The
Should element's inline behavior be blocked by Content Security Policy?
algorithm
The
Should navigation request of type be blocked by Content Security Policy?
algorithm
The
Should navigation response to navigation request of type in target be blocked by Content Security Policy?
algorithm
The
report-uri
directive
The
EnsureCSPDoesNotBlockStringCompilation
abstract operation
The
Is base allowed for Document?
algorithm
The
frame-ancestors
directive
The
sandbox
directive
The
contains a header-delivered Content Security Policy
property.
The
Parse a response's Content Security Policies
algorithm.
SecurityPolicyViolationEvent
interface
The
securitypolicyviolation
event
Service Workers
The following terms are defined in
Service Workers
[SW]
active worker
client message queue
control
handle fetch
match service worker registration
service worker
service worker client
service worker client
service worker registration
ServiceWorker
interface
ServiceWorkerContainer
interface
ServiceWorkerGlobalScope
interface
unregister
Secure Contexts
The following algorithms are defined in
Secure Contexts
[SECURE-CONTEXTS]
Is url potentially trustworthy?
Permissions Policy
The following terms are defined in
Permissions Policy
[PERMISSIONSPOLICY]
permissions policy
policy-controlled feature
container policy
serialized permissions policy
default allowlist
The
creating a permissions policy
algorithm
The
creating a permissions policy from a response
algorithm
The
is feature enabled by policy for origin
algorithm
The
process permissions policy attributes
algorithm
Payment Request API
The following feature is defined in
Payment Request API
[PAYMENTREQUEST]
PaymentRequest
interface
MathML
While support for MathML as a whole is not required by this specification (though it is
encouraged, at least for web browsers), certain features depend upon small parts of MathML being
implemented.
[MATHML]
The following features are defined in
Mathematical Markup Language
MathML
):
MathML
annotation-xml
element
MathML
math
element
MathML
merror
element
MathML
mi
element
MathML
mn
element
MathML
mo
element
MathML
ms
element
MathML
mtext
element
SVG
While support for SVG as a whole is not required by this specification (though it is
encouraged, at least for web browsers), certain features depend upon parts of SVG being
implemented.
User agents that implement SVG must implement the
SVG 2
specification, and not
any earlier revisions.
The following features are defined in the
SVG 2
specification:
[SVG]
SVGElement
interface
SVGImageElement
interface
SVGScriptElement
interface
SVGSVGElement
interface
SVG
element
SVG
desc
element
SVG
foreignObject
element
SVG
image
element
SVG
script
element
SVG
svg
element
SVG
title
element
SVG
use
element
SVG
text-rendering
property
Filter Effects
The following features are defined in
Filter Effects
[FILTERS]

Compositing
The following features are defined in
Compositing and Blending
[COMPOSITE]


source-over
copy
Cooperative Scheduling of Background Tasks
The following features are defined in
Cooperative Scheduling of Background
Tasks
[REQUESTIDLECALLBACK]
requestIdleCallback()
start an idle period algorithm
Screen Orientation
The following terms are defined in
Screen Orientation
[SCREENORIENTATION]
screen orientation change steps
Storage
The following terms are defined in
Storage
[STORAGE]
storage key
obtain a local storage bottle map
obtain a session storage bottle map
obtain a storage key for non-storage purposes
storage key equal
storage proxy map
legacy-clone a traversable storage shed
Web App Manifest
The following features are defined in
Web App Manifest
[MANIFEST]
application manifest
installed web application
process the manifest
WebAssembly JavaScript Interface: ESM Integration
The following terms are defined in
WebAssembly JavaScript Interface: ESM Integration
[WASMESM]
WebAssembly Module Record
parse a WebAssembly module
WebCodecs
The following features are defined in
WebCodecs
[WEBCODECS]
VideoFrame
interface.
[[display width]]
[[display height]]
WebDriver
The following terms are defined in
WebDriver
[WEBDRIVER]
extension command
remote end steps
WebDriver error
WebDriver error code
invalid argument
getting a property
success
WebDriver's security considerations
current browsing context
WebDriver BiDi
The following terms are defined in
WebDriver BiDi
[WEBDRIVERBIDI]
WebDriver BiDi navigation status
navigation status id
navigation status status
navigation status canceled
navigation status committed
navigation status pending
navigation status complete
navigation status url
navigation status suggested filename
download behavior allowed
download behavior destination folder
navigation status downloaded filepath
WebDriver BiDi navigation aborted
WebDriver BiDi navigation committed
WebDriver BiDi navigation failed
WebDriver BiDi navigation started
WebDriver BiDi download end
WebDriver BiDi download will begin
WebDriver BiDi fragment navigated
WebDriver BiDi DOM content loaded
WebDriver BiDi load complete
WebDriver BiDi history updated
WebDriver BiDi navigable created
WebDriver BiDi navigable destroyed
WebDriver BiDi user prompt closed
WebDriver BiDi user prompt opened
WebDriver BiDi file dialog opened
WebDriver BiDi emulated language
WebDriver BiDi scripting is enabled
Web Cryptography API
The following terms are defined in
Web Cryptography API
[WEBCRYPTO]
generating a random UUID
WebSockets
The following terms are defined in
WebSockets
[WEBSOCKETS]
WebSocket
make disappear
WebTransport
The following terms are defined in
WebTransport
[WEBTRANSPORT]
WebTransport
context cleanup steps
Web Authentication: An API for accessing Public Key Credentials
The following terms are defined in
Web Authentication: An API for accessing Public Key
Credentials
[WEBAUTHN]
public key credential
Credential Management
The following terms are defined in
Credential Management
[CREDMAN]
conditional mediation
credential
navigator.credentials.get()
Console
The following terms are defined in
Console
[CONSOLE]
report a warning to the console
Web Locks API
The following terms are defined in
Web Locks API
[WEBLOCKS]
locks
lock requests
Trusted Types
This specification uses the following features defined in
Trusted Types
[TRUSTED-TYPES]
TrustedHTML
data
TrustedScript
data
TrustedScriptURL
get trusted type compliant string
WebRTC API
The following terms are defined in
WebRTC API
[WEBRTC]
RTCDataChannel
RTCPeerConnection
Picture-in-Picture API
The following terms are defined in
Picture-in-Picture API
[PICTUREINPICTURE]
PictureInPictureWindow
Idle Detection API
The following terms are defined in
Idle Detection API
IdleDetector
Web Speech API
The following terms are defined in
Web Speech API
SpeechRecognition
WebOTP API
The following terms are defined in
WebOTP API
OTPCredential
Web Share API
The following terms are defined in
Web Share API
share()
Web Smart Card API
The following terms are defined in
Web Smart Card API
SmartCardConnection
Web Background Synchronization
The following terms are defined in
Web Background Synchronization
SyncManager
register()
Web Periodic Background Synchronization
The following terms are defined in
Web Periodic Background Synchronization
PeriodicSyncManager
register()
Web Background Fetch
The following terms are defined in
Background Fetch
BackgroundFetchManager
fetch()
Keyboard Lock
The following terms are defined in
Keyboard Lock
Keyboard
lock()
Web MIDI API
The following terms are defined in
Web MIDI API
requestMIDIAccess()
Generic Sensor API
The following terms are defined in
Generic Sensor API
request sensor access
WebHID API
The following terms are defined in
WebHID API
requestDevice
WebXR Device API
The following terms are defined in
WebXR Device API
XRSystem
This specification does not
require
support of any particular network protocol, style
sheet language, scripting language, or any of the DOM specifications beyond those required in the
list above. However, the language described by this specification is biased towards CSS as the
styling language, JavaScript as the scripting language, and HTTP as the network protocol, and
several features assume that those languages and protocols are in use.
A user agent that implements the HTTP protocol must implement
HTTP State Management
Mechanism
(Cookies) as well.
[HTTP]
[COOKIES]
This specification might have certain additional requirements on character
encodings, image formats, audio formats, and video formats in the respective sections.
2.1.10
Extensibility
Vendor-specific proprietary user agent extensions to this specification are strongly
discouraged. Documents must not use such extensions, as doing so reduces interoperability and
fragments the user base, allowing only users of specific user agents to access the content in
question.
All extensions must be defined so that the use of extensions neither contradicts nor causes the
non-conformance of functionality defined in the specification.
For example, while strongly discouraged from doing so, an implementation could add a new IDL
attribute "
typeTime
" to a control that returned the time it took the user
to select the current value of a control (say). On the other hand, defining a new control that
appears in a form's
elements
array would be in violation
of the above requirement, as it would violate the definition of
elements
given in this specification.
When vendor-neutral extensions to this specification are needed, either this specification can
be updated accordingly, or an extension specification can be written that overrides the
requirements in this specification. When someone applying this specification to their activities
decides that they will recognize the requirements of such an extension specification, it becomes
an
applicable specification
for the purposes
of conformance requirements in this specification.
Someone could write a specification that defines any arbitrary byte stream as
conforming, and then claim that their random junk is conforming. However, that does not mean that
their random junk actually is conforming for everyone's purposes: if someone else decides that
that specification does not apply to their work, then they can quite legitimately say that the
aforementioned random junk is just that, junk, and not conforming at all. As far as conformance
goes, what matters in a particular community is what that community
agrees
is
applicable.
User agents must treat elements and attributes that they do not understand as semantically
neutral; leaving them in the DOM (for DOM processors), and styling them according to CSS (for CSS
processors), but not inferring any meaning from them.
When support for a feature is disabled (e.g. as an emergency measure to mitigate a security
problem, or to aid in development, or for performance reasons), user agents must act as if they
had no support for the feature whatsoever, and as if the feature was not mentioned in this
specification. For example, if a particular feature is accessed via an attribute in a Web IDL
interface, the attribute itself would be omitted from the objects that implement that interface
— leaving the attribute on the object but making it return null or throw an exception is
insufficient.
2.1.11
Interactions with XPath and XSLT
Implementations of XPath 1.0 that operate on
HTML
documents
parsed or created in the manners described in this specification (e.g. as part of
the
document.evaluate()
API) must act as if the following edit was applied
to the XPath 1.0 specification.
First, remove this paragraph:
QName
in the node test is expanded
into an
expanded-name
using the namespace declarations from the expression context. This is the same way expansion is
done for element type names in start and end-tags except that the default namespace declared with
xmlns
is not used: if the
QName
does not have a prefix, then the
namespace URI is null (this is the same way attribute names are expanded). It is an error if the
QName
has a prefix for which there is
no namespace declaration in the expression context.
Then, insert in its place the following:
A QName in the node test is expanded into an expanded-name using the namespace declarations
from the expression context. If the QName has a prefix, then there must be a namespace declaration for this prefix in
the expression context, and the corresponding namespace URI is the one that is
associated with this prefix. It is an error if the QName has a prefix for which there is no
namespace declaration in the expression context.
If the QName has no prefix and the principal node type of the axis is element, then the
default element namespace is used. Otherwise, if the QName has no prefix, the namespace URI is
null. The default element namespace is a member of the context for the XPath expression. The
value of the default element namespace when executing an XPath expression through the DOM3 XPath
API is determined in the following way:
If the context node is from an HTML DOM, the default element namespace is
"http://www.w3.org/1999/xhtml".
Otherwise, the default element namespace URI is null.
This is equivalent to adding the default element namespace feature of XPath 2.0
to XPath 1.0, and using the HTML namespace as the default element namespace for HTML documents.
It is motivated by the desire to have implementations be compatible with legacy HTML content
while still supporting the changes that this specification introduces to HTML regarding the
namespace used for HTML elements, and by the desire to use XPath 1.0 rather than XPath 2.0.
This change is a
willful violation
of the XPath 1.0 specification,
motivated by desire to have implementations be compatible with legacy content while still
supporting the changes that this specification introduces to HTML regarding which namespace is
used for HTML elements.
[XPATH10]
XSLT 1.0 processors outputting to a DOM when the output
method is "html" (either explicitly or via the defaulting rule in XSLT 1.0) are affected as
follows:
If the transformation program outputs an element in no namespace, the processor must, prior to
constructing the corresponding DOM element node, change the namespace of the element to the
HTML namespace
ASCII-lowercase
the
element's local name, and
ASCII-lowercase
the
names of any non-namespaced attributes on the element.
This requirement is a
willful violation
of the XSLT 1.0
specification, required because this specification changes the namespaces and case-sensitivity
rules of HTML in a manner that would otherwise be incompatible with DOM-based XSLT
transformations. (Processors that serialize the output are unaffected.)
[XSLT10]
This specification does not specify precisely how XSLT processing interacts with the
HTML
parser
infrastructure (for example, whether an XSLT processor acts as if it puts any
elements into a
stack of open elements
). However, XSLT processors must
stop
parsing
if they successfully complete, and must
update the current document
readiness
first to "
interactive
" and then to "
complete
" if they are aborted.
This specification does not specify how XSLT interacts with the
algorithm, how it fits in with the
event loop
, nor
how error pages are to be handled (e.g. whether XSLT errors are to replace an incremental XSLT
output, or are rendered inline, etc.).
There are also additional non-normative comments regarding the interaction of XSLT
and HTML
in the
script
element section
, and of
XSLT, XPath, and HTML
in the
template
element
section
2.2
Policy-controlled features
Headers/Permissions-Policy/document-domain
Support in one engine only.
Firefox
🔰 74+
Safari
No
Chrome
🔰 88+
Opera
Edge
🔰 88+
Edge (Legacy)
Internet Explorer
No
Firefox Android
Safari iOS
Chrome Android
No
WebView Android
Samsung Internet
Opera Android
This document defines the following
policy-controlled features
Headers/Feature-Policy/autoplay
Firefox
🔰 74+
Safari
No
Chrome
64+
Opera
Edge
79+
Edge (Legacy)
Internet Explorer
No
Firefox Android
Safari iOS
Chrome Android
WebView Android
Samsung Internet
Opera Android
Headers/Permissions-Policy/autoplay
Support in one engine only.
Firefox
🔰 74+
Safari
No
Chrome
88+
Opera
Edge
88+
Edge (Legacy)
Internet Explorer
No
Firefox Android
Safari iOS
Chrome Android
WebView Android
Samsung Internet
Opera Android
autoplay
", which has a
default allowlist
of
'self'
cross-origin-isolated
", which has a
default allowlist
of
'self'
focus-without-user-activation
", which has a
default allowlist
of
'self'