You are granted a license to use, reproduce
and create derivative works of this document.
Abstract
This specification evolves HTML and its related APIs to ease the
authoring of Web-based applications. Additions include context
menus, a direct-mode graphics canvas, a full duplex client-server
communication channel, more semantics, audio and video, various
features for offline Web applications, sandboxed iframes, and
scoped styling. Heavy emphasis is placed on keeping the language
backwards compatible with existing legacy user agents and on
keeping user agents backwards compatible with existing legacy
documents.
Status of this document
This is a work in progress! This document is
changing on a daily if not hourly basis in response to comments and
as a general part of its development process. Comments are very
welcome, please send them to whatwg@whatwg.org . Thank you.
The current focus is in responding to the outstanding feedback . (There
is a chart
showing current progress.)
Implementors should be aware that this specification is not
stable. Implementors who are not taking part in the
discussions are likely to find the specification changing out from
under them in incompatible ways. Vendors interested in
implementing this specification before it eventually reaches the
call for implementations should join the WHATWG mailing list and take part in the
discussions.
This specification is also being produced by the W3C HTML WG . The two
specifications are identical from the table of contents
onwards.
This specification is intended to replace (be the new version
of) what was previously the HTML4, XHTML 1.x, and DOM2 HTML
specifications.
Stability
Different parts of this specification are at different levels of
maturity.
The World Wide Web's markup language has always been HTML. HTML
was primarily designed as a language for semantically describing
scientific documents, although its general design and adaptations
over the years has enabled it to be used to describe a number of
other types of documents.
The main area that has not been adequately addressed by HTML is
a vague subject referred to as Web Applications. This specification
attempts to rectify this, while at the same time updating the HTML
specifications to address issues raised in the past few years.
1.2 Audience
This section is non-normative.
This specification is intended for authors of documents and
scripts that use the features defined in this specification
, and implementors of tools that are intended to
conform to this specification, and individuals wishing to establish
the correctness of documents or implementations with respect to the
requirements of this specification .
This document is probably not suited to readers who do not
already have at least a passing familiarity with Web technologies,
as in places it sacrifices clarity for precision, and brevity for
completeness. More approachable tutorials and authoring guides can
provide a gentler introduction to the topic.
In particular, readers should be familiar with the basics of DOM
Core and DOM Events before reading this specification. An
understanding of Web IDL, HTTP, XML, Unicode, character encodings,
JavaScript, and CSS will be helpful in places but is not
essential.
1.3 Scope
This section is non-normative.
This specification is limited to providing a semantic-level
markup language and associated semantic-level scripting APIs for
authoring accessible pages on the Web ranging from static documents
to dynamic applications.
The scope of this specification does not include providing
mechanisms for media-specific customization of presentation
(although default rendering rules for Web browsers are included at
the end of this specification, and several mechanisms for hooking
into CSS are provided as part of the language).
The scope of this specification does not include documenting
every HTML or DOM feature supported by Web browsers. Browsers
support many features that are considered to be very bad for
accessibility or that are otherwise inappropriate. For example, the
blink element is clearly
presentational and authors wishing to cause text to blink should
instead use CSS.
The scope of this specification is not to describe an entire
operating system. In particular, hardware configuration software,
image manipulation tools, and applications that users would be
expected to use with high-end workstations on a daily basis are out
of scope. In terms of applications, this specification is targeted
specifically at applications that would be expected to be used by
users on an occasional basis, or regularly but from disparate
locations, with low CPU requirements. For instance online
purchasing systems, searching systems, games (especially
multiplayer online games), public telephone books or address books,
communications software (e-mail clients, instant messaging clients,
discussion software), document editing software, etc.
1.4 History
This section is non-normative.
Work on HTML 5 originally started in late 2003, as a proof
of concept to show that it was possible to extend HTML4's forms to
provide many of the features that XForms 1.0 introduced, without
requiring browsers to implement rendering engines that were
incompatible with existing HTML Web pages. At this early stage,
while the draft was already publicly available, and input was
already being solicited from all sources, the specification was
only under Opera Software's copyright.
In early 2004, some of the principles that underlie this effort,
as well as an early draft proposal covering just forms-related
features, were presented to the W3C jointly by Mozilla and Opera at
a workshop discussing the future of Web Applications on the Web.
The proposal was rejected on the grounds that the proposal
conflicted with the previously chosen direction for the Web's
evolution.
Shortly thereafter, Apple, Mozilla, and Opera jointly announced
their intent to continue working on the effort. A public mailing
list was created, and the drafts were moved to the WHATWG site. The
copyright was subsequently amended to be jointly owned by all three
vendors, and to allow reuse of the specifications.
In 2006, the W3C expressed interest in the specification, and
created a working group chartered to work with the WHATWG on the
development of the HTML 5 specifications. The working group
opened in 2007. Apple, Mozilla, and Opera allowed the W3C to
publish the specifications under the W3C copyright, while keeping
versions with the less restrictive license on the WHATWG site.
Since then, both groups have been working together.
1.5 Design
notes
This section is non-normative.
It must be admitted that many aspects of HTML appear at first
glance to be nonsensical and inconsistent.
HTML, its supporting DOM APIs, as well as many of its supporting
technologies, have been developed over a period of several decades
by a wide array of people with different priorities who, in many
cases, did not know of each other's existence.
Features have thus arisen from many sources, and have not always
been designed in especially consistent ways. Furthermore, because
of the unique characteristics of the Web, implementation bugs have
often become de-facto, and now de-jure, standards, as content is
often unintentionally written in ways that rely on them before they
can be fixed.
Despite all this, efforts have been made to adhere to certain
design goals. These are described in the next few subsections.
1.5.1 Serializability of script execution
This section is non-normative.
To avoid exposing Web authors to the complexities of
multithreading, the HTML and DOM APIs are designed such that no
script can ever detect the simultaneous execution of other scripts.
Even with workers , the intent is that
the behavior of implementations can be thought of as completely
serialising the execution of all scripts in all browsing contexts
.
The navigator.getStorageUpdates()
method, in this model, is equivalent to allowing other scripts to
run while the calling script is blocked.
1.5.2 Compliance with other specifications
This section is non-normative.
This specification interacts with and relies on a wide variety
of other specifications. In certain circumstances, unfortunately,
the desire to be compatible with legacy content has led to this
specification violating the requirements of these other
specifications. Whenever this has occurred, the transgressions have
been noted as " willful violations ".
1.6 Relationships to other specifications
1.6.1 Relationship to HTML 4.01 and DOM2 HTML
This section is non-normative.
This specification describes a new revision of the HTML language
and its associated DOM API.
The requirements in this specification for features that were
already in HTML4 and DOM2 HTML are based primarily on the
implementation and deployment experience collected over the past
ten years. Some features have been removed from the language, based
on best current practices; implementation requirements for some of
these, as well as for non-standard features that have nonetheless
garnered wide use, are still included in this specification to
allow implementations to continue supporting legacy content.
[HTML4][DOM2HTML]
A separate document has been published by the W3C HTML working
group to provide a more detailed reference of the differences
between this specification and the language described in the HTML 4
specification. [HTMLDIFF]
1.6.2
Relationship to XHTML 1.x
This section is non-normative.
This specification is intended to replace XHTML 1.0 as the
normative definition of the XML serialization of the HTML
vocabulary. [XHTML10]
While this specification updates the semantics and requirements
of the vocabulary defined by XHTML Modularization 1.1 and used by
XHTML 1.1, it does not attempt to provide a replacement for the
modularization scheme defined and used by those (and other)
specifications, and therefore cannot be considered a complete
replacement for them. [XHTMLMOD][XHTML11]
Thus, authors and implementors who do not need such a
modularization scheme can consider this specification a replacement
for XHTML 1.x, but those who do need such a mechanism are
encouraged to continue using the XHTML 1.1 line of
specifications.
1.6.3 Relationship to XHTML2 and XForms This
section is non-normative. XHTML2 defines a new vocabulary with
features for hyperlinks, multimedia content, annotating document
edits, rich metadata, declarative interactive forms, and describing
the semantics of human literary works such as poems and scientific
papers. [XHTML2] XForms similarly defines a new vocabulary with
features for complex data entry, such as tax forms or insurance
forms. However, XHTML2 and XForms lack features to express the
semantics of many of the non-document types of content often seen
on the Web. For instance, they are not well-suited for marking up
forum sites, auction sites, search engines, online shops, mapping
applications, e-mail applications, word processors, real-time
strategy games, and the like. This specification aims to extend
HTML so that it is also suitable in these contexts. XHTML2, XForms,
and this specification all use different namespaces and therefore
can all be implemented in the same XML processor.
1.7 HTML vs
XHTML
This section is non-normative.
This specification defines an abstract language for describing
documents and applications, and some APIs for interacting with
in-memory representations of resources that use this language.
The in-memory representation is known as "DOM5 HTML", or "the
DOM" for short.
There are various concrete syntaxes that can be used to transmit
resources that use this abstract language, two of which are defined
in this specification.
The first such concrete syntax is "HTML5". This is the format
recommended for most authors. It is compatible with all legacy Web
browsers. If a document is transmitted with the MIME type
text/html , then it will be processed as an
"HTML5" document by Web browsers.
The second concrete syntax uses XML, and is known as "XHTML5".
When a document is transmitted with an XML
MIME type , such as application/xhtml+xml
, then it is processed by an XML processor by Web browsers, and
treated as an "XHTML5" document. Authors are reminded that the
processing for XML and HTML differs; in particular, even minor
syntax errors will prevent an XML document from being rendered
fully, whereas they would be ignored in the "HTML5" syntax.
The "DOM5 HTML", "HTML5", and "XHTML5" representations cannot
all represent the same content. For example, namespaces cannot be
represented using "HTML5", but they are supported in "DOM5 HTML"
and "XHTML5". Similarly, documents that use the noscript feature can be
represented using "HTML5", but cannot be represented with "XHTML5"
and "DOM5 HTML". Comments that contain the string " --> " can be represented in "DOM5 HTML" but not in
"HTML5" and "XHTML5". And so forth.
1.8 Structure of this specification
This section is non-normative.
This specification is divided into the following major
sections:
Documents are built from elements. These elements form a tree
using the DOM. This section defines the features of this DOM, as
well as introducing the features common to all elements, and the
concepts used in defining elements.
Each element has a predefined meaning, which is explained in
this section. Rules for authors on how to use the element
, along with user agent requirements for how to
handle each element, are also given.
HTML documents do not exist in a vacuum — this section defines
many of the features that affect environments that deal with
multiple pages, links between pages, and running scripts.
Applications written in HTML often require mechanisms to
communicate with remote servers, as well as communicating with
other applications from different domains running on the same
client.
All of these features would be for naught if they couldn't be
represented in a serialized form and sent to other people, and so
this section defines the syntax of HTML, along with rules for how
to parse HTML.
This specification should be read like all other specifications.
First, it should be read cover-to-cover, multiple times. Then, it
should be read backwards at least once. Then it should be read by
picking random sections from the contents list and following all
the cross-references.
1.8.2
Typographic conventions
This is a definition, requirement, or explanation.
This is a note.
This is an example.
This is an open issue.
This is a warning.
interface Example {
// this is an IDL definition
};
This is a note to authors describing the usage of an
interface.
/*
this
is
a
CSS
fragment
*/
The defining instance of a term is marked up like this . Uses of that term are marked
up like this or like this .
The defining instance of an element, attribute, or API is marked
up like this .
References to that element, attribute, or API are marked up like
this .
Other code fragments are marked up like
this .
Variables are marked up like this .
This is an implementation requirement.
1.9 A quick introduction to HTML
This section is non-normative.
A basic HTML document looks like this:
<!DOCTYPE HTML>
<html>
<head>
<title>Sample page</title>
</head>
<body>
<h1>Sample page</h1>
<p>This is a <a href="demo.html">simple</a> sample.</p>
</body>
</html>
HTML documents consist of a tree of elements and text. Each
element is denoted by a start tag , such as " <body> ", and an end tag , such as " </body> ". (Certain start tags and end tags can in
certain cases be omitted and are implied by other
tags.)
Tags have to be nested correctly, so that elements do not
partially overlap each other:
<p>This
is
<em>very
<strong>wrong</em>!</strong></p>
<p>This
<em>is
<strong>correct</strong>.</em></p>
This specification defines a set of elements that can be used in
HTML, along with rules about the ways in which the elements can be
nested.
Elements can have attributes, which control how the elements
work. In the example above, there is a hyperlink , formed using the a element and its href attribute:
<a
href="demo.html">simple</a>
Attributes are placed inside the start tag,
and consist of a name and a value
, separated by an " = " character. The
attribute value can be left unquoted if it is a keyword, but
generally will be quoted. (The value can also be omitted altogether
if it is empty.)
The tree formed by an HTML document in this way is turned into a
DOM tree when parsed. This DOM tree can then be manipulated from
scripts. Since DOM trees are the "live" representation of an HTML
document, this specification is mostly phrased in terms of DOM
trees, instead of the serialisation described above.
Each element in the DOM tree is represented by an object, and
thus objects have APIs so that they can be manipulated. For
instance, a link can have its " href " attributed changed in
several ways:
var a = document.links[0]; // obtain the first link in the document
a.href = 'sample.html'; // change the destination URL of the link
a.
protocol
=
'https';
//
change
just
the
scheme
part
of
the
URL
HTML documents represent a media-independent description of
interactive content. HTML documents might be rendered to a screen,
or through a speech synthesizer, or on a braille display. To
influence exactly how such rendering takes place, authors can use a
styling language such as CSS.
In the following example, the page has been made yellow-on-blue
using CSS.
<!DOCTYPE HTML>
<html>
<head>
<title>Sample styled page</title>
<style>
body { background: navy; color: yellow; }
</style>
</head>
<body>
<h1>Sample styled page</h1>
<p>This page is just a demo.</p>
</body>
</html>
For more details on how to use HTML, authors are encouraged to
consult tutorials and guides. Some of the examples included in this
specification might also be of use, but the novice author is
cautioned that this specification, by necessity, defines the
language with a level of detail that may be difficult to understand
at first.
2 Common
infrastructure
2.1
Terminology
This specification refers to both HTML and XML attributes and
DOM 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
DOM attributes for those from the DOM.
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 XHTML 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 XHTML)".
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.
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.
When an algorithm B says to return to another algorithm A, it
implies that A called B. Upon returning to A, the implementation
must continue from where it left off in calling B.
2.1.1 XML
To ease migration from HTML to XHTML, UAs
conforming to this specification will place elements in HTML in the
http://www.w3.org/1999/xhtml namespace, at least for
the purposes of the DOM and CSS. The term " elements in the HTML
namespace ", or " HTML elements
" for short, when used in this specification, thus refers to both
HTML and XHTML elements.
Unless otherwise stated, all elements defined or mentioned in
this specification are in the
http://www.w3.org/1999/xhtml namespace, and all
attributes defined or mentioned in this specification have no
namespace (they are in the per-element partition).
When an XML name, such as an attribute or element name, is
referred to in the form prefix :
localName , as in xml:id or
svg:rect , it refers to a name with the local name
localName and the namespace given by the
prefix, as defined by the following table:
xml
http://www.w3.org/XML/1998/namespace
html
http://www.w3.org/1999/xhtml
svg
http://www.w3.org/2000/svg
Attribute names are said to be XML-compatible if they match the Name production defined in XML, they contain no
U+003A COLON (:) characters, and their first three characters are
not an ASCII case-insensitive
match for the string " xml ". [XML]
The term XML MIME type is used to
refer to the MIME types text/xml ,
application/xml , and any MIME type ending
with the four characters " +xml ". [RFC3023]
2.1.2 DOM trees
The term root element , when not
explicitly qualified as referring to the document's root element,
means the furthest ancestor element node of whatever node is being
discussed, or the node itself if it has no ancestors. When the node
is a part of the document, then that is indeed the document's root
element; however, if the node is not currently part of the document
tree, the root element will be an orphaned node.
A node's home subtree is the
subtree rooted at that node's root
element .
The Document of a Node (such as an
element) is the Document that the Node 's
ownerDocument DOM attribute returns.
When an element's root element is
the root element of a
Document , it is said to be in
a Document . An element is said to have been
inserted into a document
when its root element changes and is
now the document's root element .
Analogously, an element is said to have been removed from a document
when its root element changes from
being the document's root element to
being another element.
If a Node is in a
Document then that Document is always
the Node 's Document , and the
Node 's ownerDocument DOM
attribute thus always returns that Document .
The term tree order means a
pre-order, depth-first traversal of DOM nodes involved (through the
parentNode / childNodes
relationship).
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.
The term text node refers to any
Text node, including CDATASection nodes;
specifically, any Node with node type TEXT_NODE (3) or CDATA_SECTION_NODE
(4). [DOM3CORE]
A content attribute is said to change value
only if its value new value is different than its previous value;
setting an attribute to a value it already has does not change
it.
2.1.3
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 ".
A DOM 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
that means that any attributes returning that object must always return the same object (not a new object
each time), and the attributes and methods on that object
must operate on the actual underlying
data, not a snapshot of the data.
The terms fire and dispatch are used interchangeably in the context of
events, as in the DOM Events specifications. [DOM3EVENTS]
2.1.4 Plugins
The term plugin is used to mean any
content handler, typically a third-party content handler, for Web
content types that are not supported by the user agent natively, or
for content types that do not expose a DOM, that supports rendering
the content as part of the user agent's interface.
One example of a plugin would be a PDF viewer
that is instantiated in a browsing
context 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. [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.
2.1.5
Character encodings
An ASCII-compatible character
encoding is a single-byte or variable-length encoding in
which the bytes 0x09, 0x0A, 0x0C, 0x0D, 0x20 - 0x22, 0x26, 0x27,
0x2C - 0x3F, 0x41 - 0x5A, and 0x61 - 0x7A , ignoring bytes that are
the second and later bytes of multibyte sequences, all correspond
to single-byte sequences that map to the same Unicode characters as
those bytes in ANSI_X3.4-1968 (US-ASCII). [RFC1345]
This includes such encodings as Shift_JIS and
variants of ISO-2022, even though it is possible in this encodings
for bytes like 0x70 to be part of longer sequences that are
unrelated to their interpretation as ASCII. It excludes such
encodings as UTF-7, UTF-16, HZ-GB-2312, GSM03.38, and EBCDIC
variants.
2.1.6 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
actually also contained animation data.
A MPEG4 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.
2.2
Conformance requirements
All diagrams, examples, and notes in this specification are
non-normative, as are all sections explicitly marked non-normative.
Everything else in this specification is normative.
The key words "MUST", "MUST NOT", "REQUIRED", "SHOULD", "SHOULD
NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in the normative parts
of this document are to be interpreted as described in RFC2119. For
readability, these words do not appear in all uppercase letters in
this specification. [RFC2119]
Requirements phrased in the imperative as part of
algorithms (such as "strip any leading space characters" or "return
false and abort these steps") are to be interpreted with the
meaning of the key word ("must", "should", "may", etc) used in
introducing the algorithm.
This specification describes the conformance criteria for
user agents (relevant to implementors)
and documents (relevant to authors and
authoring tool implementors) .
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 XHTML
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 XHTML processor would, upon finding
an XHTML 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 as text/html 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 the Web IDL specification. [WEBIDL]
Non-interactive presentation user
agents
User agents that process HTML and XHTML 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.
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 flag 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 "HTML5 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 XHTML documents for
reasons other than to either render the documents or check them for
conformance should act in accordance to 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 each
section 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.
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 the author of the document or
section. However, since an authoring tool is likely unable to
determine the difference, an authoring tool is exempt from that
requirement.
In terms of conformance checking, an editor is
therefore required 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 ,
b , i , 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.
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.
Conformance requirements phrased as algorithms or specific steps
may be implemented in any manner, so long as the end result is
equivalent. (In particular, the algorithms defined in this
specification are intended to be easy to follow, and not intended
to be performant.)
User agents may impose
implementation-specific limits on otherwise unconstrained inputs,
e.g. to prevent denial of service attacks, to guard against running
out of memory, or to work around platform-specific limitations.
For compatibility with existing content and prior
specifications, this specification describes two authoring formats:
one based on XML (referred to as the
XHTML syntax ), and one using a custom
format inspired by SGML (referred to as the
HTML syntax ). Implementations may support
only one of these two formats, although supporting both is
encouraged.
XML documents that use elements or
attributes from the HTML namespace
and that are served over the wire (e.g. by HTTP) must be sent using
an XML MIME type such as
application/xml or application/xhtml+xml
and must not be served as text/html . [RFC3023]
Documents that use the
HTML syntax , if they are served over the wire (e.g. by HTTP)
must be labeled with the text/html MIME type.
The language in this
specification assumes that the user agent expands all entity
references, and therefore does not include entity reference nodes
in the DOM. If user agents do include entity reference nodes in the
DOM, then user agents must handle them as if they were fully
expanded when implementing this specification. For example, if a
requirement talks about an element's child text nodes, then any
text nodes that are children of an entity reference that is a child
of that element would be used as well. Entity references to unknown
entities must be treated as if they contained just an empty text
node for the purposes of the algorithms defined in this
specification.
2.2.1
Dependencies
This specification relies on several other underlying
specifications.
XML
Implementations that support the
XHTML syntax must support some version of XML, as well as its
corresponding namespaces specification, because that syntax uses an
XML serialization with namespaces. [XML][XMLNAMES]
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. [DOM3CORE]
Implementations must support some version of DOM Core and DOM
Events, because this specification is defined in terms of the DOM,
and some of the features are defined as extensions to the DOM Core
interfaces. [DOM3CORE][DOM3EVENTS]
Web IDL
The IDL fragments in this specification must be interpreted as
required for conforming IDL fragments, as described in the Web IDL
specification. [WEBIDL]
Unless otherwise specified, if a DOM attribute that is a
floating point number type ( float ) is
assigned an Infinity or Not-a-Number value, a NOT_SUPPORTED_ERR exception must be
raised.
Unless otherwise specified, if a method with an argument that is
a floating point number type ( float ) is
passed an Infinity or Not-a-Number value, a NOT_SUPPORTED_ERR exception must be
raised.
JavaScript
Some parts of the language described by this specification only
support JavaScript as the underlying scripting language. [ECMA262]
The term "JavaScript" is used to refer to ECMA262,
rather than the official term ECMAScript, since the term JavaScript
is more widely known. Similarly, the MIME type used to refer to
JavaScript in this specification is text/javascript , since that is the most commonly used
type, despite it being an officially obsoleted
type according to RFC 4329. [RFC4329]
Media Queries
Implementations must support some version of the Media Queries
language. [MQ]
This specification does not require support of any
particular network transport protocols, style sheet language,
scripting language, or any of the DOM and WebAPI specifications
beyond those described 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.
This specification might have certain additional
requirements on character encodings, image formats, audio formats,
and video formats in the respective sections.
2.2.2
Extensibility
Vendor-specific proprietary 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.
If markup extensions are needed, they should be done using XML,
with elements or attributes from custom namespaces. If DOM
extensions are needed, the members should be prefixed by
vendor-specific strings to prevent clashes with future versions of
this specification. Extensions must be defined so that the use of
extensions does not contradict nor cause the non-conformance of
functionality defined in the specification.
For example, while strongly discouraged to do so, an
implementation "Foo Browser" could add a new DOM attribute "
fooTypeTime " to a control's DOM interface
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.
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.
2.3 Case-sensitivity and string comparison
This specification defines several comparison operators for
strings.
Comparing two strings in a case-sensitive manner means comparing them
exactly, code point for code point.
Comparing two strings in an ASCII case-insensitive manner means
comparing them exactly, code point for code point, except that the
characters in the range U+0041 .. U+005A (i.e. LATIN CAPITAL LETTER
A to LATIN CAPITAL LETTER Z) and the corresponding characters in
the range U+0061 .. U+007A (i.e. LATIN SMALL LETTER A to LATIN
SMALL LETTER Z) are considered to also match.
Comparing two strings in a compatibility caseless manner means
using the Unicode compatibility caseless match operation to
compare the two strings. [UNICODECASE]
Converting a string to ASCII
uppercase means replacing all characters in the range U+0061
.. U+007A (i.e. LATIN SMALL LETTER A to LATIN SMALL LETTER Z) with
the corresponding characters in the range U+0041 .. U+005A (i.e.
LATIN CAPITAL LETTER A to LATIN CAPITAL LETTER Z).
Converting a string to ASCII
lowercase means replacing all characters in the range U+0041
.. U+005A (i.e. LATIN CAPITAL LETTER A to LATIN CAPITAL LETTER Z)
with the corresponding characters in the range U+0061 .. U+007A
(i.e. LATIN SMALL LETTER A to LATIN SMALL LETTER Z).
A string pattern is a prefix match for a string s when pattern is not longer than
s and truncating s to
pattern 's length leaves the two strings as
matches of each other.
2.4 Common
microsyntaxes
There are various places in HTML that accept particular data
types, such as dates or numbers. This section describes what the
conformance criteria for content in those formats is, and how to
parse them.
Implementors are strongly urged to carefully
examine any third-party libraries they might consider using to
implement the parsing of syntaxes described below. For example,
date libraries are likely to implement error handling behavior that
differs from what is required in this specification, since
error-handling behavior is often not defined in specifications that
describe date syntaxes similar to those used in this specification,
and thus implementations tend to vary greatly in how they handle
errors.
2.4.1
Common parser idioms
The space
characters , for the purposes of this specification, are
U+0020 SPACE, U+0009 CHARACTER TABULATION (tab), U+000A LINE FEED
(LF), U+000C FORM FEED (FF), and U+000D CARRIAGE RETURN (CR).
The White_Space
characters are those that have the Unicode property
"White_Space". [UNICODE]
The alphanumeric ASCII
characters are those in the ranges U+0030 DIGIT ZERO ..
U+0039 DIGIT NINE, U+0041 LATIN CAPITAL LETTER A .. U+005A LATIN
CAPITAL LETTER Z, U+0061 LATIN SMALL LETTER A .. U+007A LATIN SMALL
LETTER Z.
Some of the micro-parsers described below follow the pattern of
having an input variable that holds the string
being parsed, and having a position variable
pointing at the next character to parse in input .
For parsers based on this pattern, a step that requires the user
agent to collect a
sequence of characters means that the following algorithm
must be run, with characters being the set of
characters that can be collected:
Let input and position
be the same variables as those of the same name in the algorithm
that invoked these steps.
Let result be the empty string.
While position doesn't point past the end of
input and the character at position is one of the characters ,
append that character to the end of result and
advance position to the next character in
input .
When a user agent is to strip line
breaks from a string, the user agent must remove any U+000A
LINE FEED (LF) and U+000D CARRIAGE RETURN (CR) characters from that
string.
The code-point length of a
string is the number of Unicode code points in that string.
2.4.2
Boolean attributes
A number of attributes are boolean attributes . The presence of a
boolean attribute on an element represents the true value, and the
absence of the attribute represents the false value.
If the attribute is present, its value must either be the empty
string or a value that is an ASCII case-insensitive match for the
attribute's canonical name, with no leading or trailing
whitespace.
The values "true" and "false" are not allowed on
boolean attributes. To represent a false value, the attribute has
to be omitted altogether.
2.4.3 Keywords and enumerated attributes
Some attributes are defined as taking one of a finite set of
keywords. Such attributes are called enumerated attributes . The
keywords are each defined to map to a particular state
(several keywords might map to the same state, in which case some
of the keywords are synonyms of each other; additionally, some of
the keywords can be said to be non-conforming, and are only in the
specification for historical reasons). In addition, two default
states can be given. The first is the invalid value default
, the second is the missing value default .
If an enumerated attribute is specified, the attribute's value
must be an ASCII
case-insensitive match for one of the given keywords that are
not said to be non-conforming, with no leading or trailing
whitespace.
When the attribute is specified, if its value is an ASCII case-insensitive match for one
of the given keywords then that keyword's state is the state that
the attribute represents. If the attribute value matches none of
the given keywords, but the attribute has an invalid value
default , then the attribute represents that state. Otherwise,
if the attribute value matches none of the keywords but there is a
missing value default state defined, then that is
the state represented by the attribute. Otherwise, there is no
default, and invalid values must be ignored.
When the attribute is not specified, if there is a
missing value default state defined, then that is the state
represented by the (missing) attribute. Otherwise, the absence of
the attribute means that there is no state represented.
The empty string can be a valid keyword.
2.4.4 Numbers
2.4.4.1
Non-negative integers
A string is a valid
non-negative integer if it consists of one or more characters
in the range U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9).
A valid non-negative
integer represents the number that is represented in base ten
by that string of digits.
The rules for
parsing non-negative integers are as given in the following
algorithm. When invoked, the steps must be followed in the order
given, aborting at the first step that returns a value. This
algorithm will either return zero, a positive integer, or an error.
Leading spaces are ignored. Trailing spaces and any trailing
garbage characters are ignored.
Let input be the string being parsed.
Let position be a pointer into input , initially pointing at the start of the string.
If position is past the end of input , return an error.
If the next character is a U+002B PLUS SIGN character (+),
advance position to the next character.
If position is past the end of input , return an error.
If the next character is not one of U+0030 DIGIT ZERO (0) ..
U+0039 DIGIT NINE (9), then return an error.
Loop : If the next character is one of U+0030 DIGIT ZERO
(0) .. U+0039 DIGIT NINE (9):
Multiply value by ten.
Add the value of the current character (0..9) to value .
Advance position to the next
character.
If position is not past the end of
input , return to the top of the step labeled
loop in the overall algorithm (that's the step within which
these substeps find themselves).
Return value .
2.4.4.2 Signed
integers
A string is a valid integer if it
consists of one or more characters in the range U+0030 DIGIT ZERO
(0) to U+0039 DIGIT NINE (9), optionally prefixed with a U+002D
HYPHEN-MINUS ("-") character.
A valid integer without a U+002D
HYPHEN-MINUS ("-") prefix represents the number that is represented
in base ten by that string of digits. A valid integerwith a U+002D
HYPHEN-MINUS ("-") prefix represents the number represented in base
ten by the string of digits that follows the U+002D HYPHEN-MINUS,
subtracted from zero.
The rules for parsing
integers are similar to the rules for non-negative
integers , and are as given in the following algorithm. When
invoked, the steps must be followed in the order given, aborting at
the first step that returns a value. This algorithm will either
return an integer or an error. Leading spaces are ignored. Trailing
spaces and trailing garbage characters are ignored.
Let input be the string being parsed.
Let position be a pointer into input , initially pointing at the start of the string.
If position is past the end of input , return an error.
If the character indicated by position (the
first character) is a U+002D HYPHEN-MINUS ("-") character:
Let sign be "negative".
Advance position to the next
character.
If position is past the end of input , return an error.
If the next character is not one of U+0030 DIGIT ZERO (0) ..
U+0039 DIGIT NINE (9), then return an error.
If the next character is one of U+0030 DIGIT ZERO (0) .. U+0039
DIGIT NINE (9):
Multiply value by ten.
Add the value of the current character (0..9) to value .
Advance position to the next
character.
If position is not past the end of
input , return to the top of step 9 in the
overall algorithm (that's the step within which these substeps find
themselves).
If sign is "positive", return value , otherwise return 0- value
.
2.4.4.3 Real
numbers
A string is a valid
floating point number if it consists of:
Optionally, a U+002D HYPHEN-MINUS ("-") character.
A series of one or more characters in the range U+0030 DIGIT
ZERO (0) to U+0039 DIGIT NINE (9).
Optionally:
A single U+002E FULL STOP (".") character.
A series of one or more characters in the range U+0030 DIGIT
ZERO (0) to U+0039 DIGIT NINE (9).
Optionally:
Either a U+0065 LATIN SMALL LETTER E character or a U+0045
LATIN CAPITAL LETTER E character.
Optionally, a U+002D HYPHEN-MINUS ("-") character or U+002B
PLUS SIGN ("+") character.
A series of one or more characters in the range U+0030 DIGIT
ZERO (0) to U+0039 DIGIT NINE (9).
A valid floating point
number represents the number obtained by multiplying the
significand by ten raised to the power of the exponent, where the
significand is the first number, interpreted as base ten (including
the decimal point and the number after the decimal point, if any,
and interpreting the significand as a negative number if the whole
string starts with a U+002D HYPHEN-MINUS ("-") character and the
number is not zero), and where the exponent is the number after the
E, if any (interpreted as a negative number if there is a U+002D
HYPHEN-MINUS ("-") character between the E and the number and the
number is not zero, or else ignoring a U+002B PLUS SIGN ("+")
character between the E and the number if there is one). If there
is no E, then the exponent is treated as zero.
The best
representation of the floating point number n is the string obtained from applying the JavaScript
operator ToString to n .
The rules for parsing
floating point number values are as given in the following
algorithm. As with the previous algorithms, when this one is
invoked, the steps must be followed in the order given, aborting at
the first step that returns something. This algorithm will either
return a number or an error. Leading spaces are ignored. Trailing
spaces and garbage characters are ignored.
Let input be the string being parsed.
Let position be a pointer into input , initially pointing at the start of the string.
If position is past the end of input , return an error.
If the character indicated by position is a
U+002D HYPHEN-MINUS ("-") character:
Change value and divisor to −1.
Advance position to the next
character.
If position is past the end of input , return an error.
If the character indicated by position is
not one of U+0030 DIGIT ZERO (0) .. U+0039 DIGIT NINE (9), then
return an error.
Collect a sequence
of characters in the range U+0030 DIGIT ZERO (0) to U+0039
DIGIT NINE (9), and interpret the resulting sequence as a base-ten
integer. Multiply value by that integer.
If position is past the end of input , return value .
If the character indicated by position is a
U+002E FULL STOP ("."), run these substeps:
Advance position to the next character.
If position is past the end of input , or if the character indicated by position is not one of U+0030 DIGIT ZERO (0) .. U+0039
DIGIT NINE (9), then return value .
Fraction loop : Multiply divisor by
ten.
Add the value of the current character interpreted as a
base-ten digit (0..9) divided by divisor , to
value .
Advance position to the next character.
If position is past the end of input , then return value .
If the character indicated by position is
one of U+0030 DIGIT ZERO (0) .. U+0039 DIGIT NINE (9), return to
the step labeled fraction loop in these substeps.
If the character indicated by position is a
U+0065 LATIN SMALL LETTER E character or a U+0045 LATIN CAPITAL
LETTER E character, run these substeps:
Advance position to the next character.
If position is past the end of input , then return value .
If the character indicated by position is a
U+002D HYPHEN-MINUS ("-") character:
Change exponent to −1.
Advance position to the next
character.
If position is past the end of input , then return value .
Otherwise, if the character indicated by position is a U+002B PLUS SIGN ("+") character:
Advance position to the next
character.
If position is past the end of input , then return value .
If the character indicated by position is
not one of U+0030 DIGIT ZERO (0) .. U+0039 DIGIT NINE (9), then
return value .
Collect a sequence
of characters in the range U+0030 DIGIT ZERO (0) to U+0039
DIGIT NINE (9), and interpret the resulting sequence as a base-ten
integer. Multiply exponent by that integer.
Multiply value by ten raised to the
exponent th power.
Return value .
2.4.4.4 Ratios
The algorithms described in this section are used
by the progress
and meter
elements.
A valid
denominator punctuation character is one of the characters
from the table below. There is a value
associated with each denominator punctuation character , as
shown in the table below.
Denominator Punctuation Character
Value
U+0025 PERCENT SIGN
%
100
U+066A ARABIC PERCENT SIGN
٪
100
U+FE6A SMALL PERCENT SIGN
﹪
100
U+FF05 FULLWIDTH PERCENT SIGN
％
100
U+2030 PER MILLE SIGN
‰
1000
U+2031 PER TEN THOUSAND SIGN
‱
10000
The steps
for finding one or two numbers of a ratio in a string are as
follows:
If the string is empty, then return nothing and abort these
steps.
Find a number in the string
according to the algorithm below, starting at the start of the
string.
If the sub-algorithm in step 2 returned nothing or returned an
error condition, return nothing and abort these steps.
Set number1 to the number returned by the
sub-algorithm in step 2.
Starting with the character immediately after the last one
examined by the sub-algorithm in step 2, skip all White_Space characters in the string (this might
match zero characters).
If there are still further characters in the string, and the
next character in the string is a valid denominator
punctuation character , set denominator to
that character.
If the string contains any other characters in the range U+0030
DIGIT ZERO to U+0039 DIGIT NINE, but denominator was given a value in the step 6, return
nothing and abort these steps.
Otherwise, if denominator was given a value
in step 6, return number1 and denominator and abort these steps.
Find a number in the string again,
starting immediately after the last character that was examined by
the sub-algorithm in step 2.
If the sub-algorithm in step 9 returned nothing or an error
condition, return number1 and abort these
steps.
Set number2 to the number returned by the
sub-algorithm in step 9.
Starting with the character immediately after the last one
examined by the sub-algorithm in step 9, skip all White_Space characters in the string (this might
match zero characters).
If there are still further characters in the string, and the
next character in the string is a valid denominator
punctuation character , return nothing and abort these
steps.
If the string contains any other characters in the range U+0030
DIGIT ZERO to U+0039 DIGIT NINE, return nothing and abort these
steps.
Otherwise, return number1 and number2 .
The algorithm to find a number is
as follows. It is given a string and a starting position, and
returns either nothing, a number, or an error condition.
Starting at the given starting position, ignore all characters
in the given string until the first character that is either a
U+002E FULL STOP or one of the ten characters in the range U+0030
DIGIT ZERO to U+0039 DIGIT NINE.
If there are no such characters, return nothing and abort these
steps.
Starting with the character matched in step 1, collect all the
consecutive characters that are either a U+002E FULL STOP or one of
the ten characters in the range U+0030 DIGIT ZERO to U+0039 DIGIT
NINE, and assign this string of one or more characters to
string .
If string consists of just a single U+002E
FULL STOP character or if it contains more than one U+002E FULL
STOP character then return an error condition and abort these
steps.
The rules for
parsing dimension values are as given in the following
algorithm. When invoked, the steps must be followed in the order
given, aborting at the first step that returns a value. This
algorithm will either return a number greater than or equal to 1.0,
or an error; if a number is returned, then it is further
categorized as either a percentage or a length.
Let input be the string being parsed.
Let position be a pointer into input , initially pointing at the start of the string.
If position is past the end of input , return an error.
If the next character is not one of U+0031 DIGIT ONE (1) ..
U+0039 DIGIT NINE (9), then return an error.
Collect a sequence
of characters in the range U+0030 DIGIT ZERO (0) to U+0039
DIGIT NINE (9), and interpret the resulting sequence as a base-ten
integer. Let value be that number.
If position is past the end of input , return value as an
integer.
If the next character is a U+002E FULL STOP character (.):
Advance position to the next character.
If the next character is not one of U+0030 DIGIT ZERO (0) ..
U+0039 DIGIT NINE (9), then return value as an
integer.
Collect a sequence
of characters in the range U+0030 DIGIT ZERO (0) to U+0039
DIGIT NINE (9). Let length be the number of
characters collected. Let fraction be the
result of interpreting the collected characters as a base-ten
integer, and then dividing that number by 10
length .
Increment value by fraction .
If position is past the end of input , return value as a length.
If the next character is a U+0025 PERCENT SIGN character (%),
return value as a percentage.
Return value as a length.
2.4.4.6 Lists
of integers
A valid list of integers
is a number of valid
integers separated by U+002C COMMA characters, with no other
characters (e.g. no space characters ). In addition, there might
be restrictions on the number of integers that can be given, or on
the range of values allowed.
The rules for
parsing a list of integers are as follows:
Let input be the string being parsed.
Let position be a pointer into input , initially pointing at the start of the string.
Let numbers be an initially empty list of
integers. This list will be the result of this algorithm.
If there is a character in the string input
at position position , and it is either a
U+0020 SPACE, U+002C COMMA, or U+003B SEMICOLON character, then
advance position to the next character in
input , or to beyond the end of the string if
there are no more characters.
If position points to beyond the end of
input , return numbers and
abort.
If the character in the string input at
position position is a U+0020 SPACE, U+002C
COMMA, or U+003B SEMICOLON character, then return to step 4.
Let negated be false.
Let value be 0.
Let started be false. This variable is set
to true when the parser sees a number or a U+002D HYPHEN-MINUS
("-") character.
Let got number be false. This variable is
set to true when the parser sees a number.
Let finished be false. This variable is set
to true to switch parser into a mode where it ignores characters
until the next separator.
Let bogus be false.
Parser: If the character in the string input at position position is:
A U+002D HYPHEN-MINUS character
Follow these substeps:
If got number is true, let finished be true.
If finished is true, skip to the next step
in the overall set of steps.
If started is true, let negated be false.
Otherwise, if started is false and if
bogus is false, let negated
be true.
Let started be true.
A character in the range U+0030 DIGIT ZERO .. U+0039 DIGIT
NINE
Follow these substeps:
If finished is true, skip to the next step
in the overall set of steps.
Multiply value by ten.
Add the value of the digit, interpreted in base ten, to
value .
Let started be true.
Let got number be true.
A U+0020 SPACE character
A U+002C COMMA character
A U+003B SEMICOLON character
Follow these substeps:
If got number is false, return the
numbers list and abort. This happens if an
entry in the list has no digits, as in " 1,2,x,4 ".
If negated is true, then negate value .
Append value to the numbers list.
Jump to step 4 in the overall set of steps.
A character in the range U+0001 .. U+001F, U+0021 .. U+002B,
U+002D .. U+002F, U+003A, U+003C .. U+0040, U+005B .. U+0060,
U+007b .. U+007F (i.e. any other non-alphabetic ASCII
character)
Follow these substeps:
If got number is true, let finished be true.
If finished is true, skip to the next step
in the overall set of steps.
Let negated be false.
Any other character
Follow these substeps:
If finished is true, skip to the next step
in the overall set of steps.
Let negated be false.
Let bogus be true.
If started is true, then return the
numbers list, and abort. (The value in
value is not appended to the list first; it is
dropped.)
Advance position to the next character in
input , or to beyond the end of the string if
there are no more characters.
If position points to a character (and not
to beyond the end of input ), jump to the big
Parser step above.
If negated is true, then negate value .
If got number is true, then append
value to the numbers
list.
Return the numbers list and abort.
2.4.4.7
Lists of dimensions
The rules for
parsing a list of dimensions are as follows. These rules
return a list of zero or more pairs consisting of a number and a
unit, the unit being one of percentage , relative ,
and absolute .
Let raw input be the string being
parsed.
If the last character in raw input is a
U+002C COMMA character (","), then remove that character from
raw input .
For each token in raw tokens , run the
following substeps:
Let input be the token.
Let position be a pointer into input , initially pointing at the start of the string.
Let value be the number 0.
Let unit be absolute .
If position is past the end of input , set unit to relative
and jump to the last substep.
If the character at position is a character
in the range U+0030 DIGIT ZERO (0) to U+0039 DIGIT NINE (9),
collect a sequence of
characters in the range U+0030 DIGIT ZERO (0) to U+0039 DIGIT
NINE (9), interpret the resulting sequence as an integer in base
ten, and increment value by that integer.
If the character at position is a U+002E
FULL STOP character (.), run these substeps:
If the character at position is a U+0025
PERCENT SIGN (%) character, then set unit to
percentage .
Otherwise, if the character at position is a
U+002A ASTERISK character (*), then set unit to
relative .
Add an entry to result consisting of the
number given by value and the unit given by
unit .
Return the list result .
2.4.5 Dates and
times
In the algorithms below, the number of days in
month month of year year is: 31 if month is
1, 3, 5, 7, 8, 10, or 12; 30 if month
is 4, 6, 9, or 11; 29 if month is 2
and year is a number divisible by 400, or if
year is a number divisible by 4 but not by 100;
and 28 otherwise. This takes into account leap years in
the Gregorian calendar. [GREGORIAN]
The digits in the date and time syntaxes
defined in this section must be characters in the range U+0030
DIGIT ZERO to U+0039 DIGIT NINE, used to express numbers in base
ten.
2.4.5.1 Months
A month
consists of a specific proleptic Gregorian date with no time-zone
information and no date information beyond a year and a month.
[GREGORIAN]
A string is a valid month
string representing a year year and month
month if it consists of the following
components in the given order:
Four or more digits , representing year , where year
> 0
A U+002D HYPHEN-MINUS character (-)
Two digits , representing the month
month , in the range 1 ≤ month ≤ 12
The rules to parse a month
string are as follows. This will either return a year and
month, or nothing. If at any point the algorithm says that it
"fails", this means that it is aborted at that point and returns
nothing.
Let input be the string being parsed.
Let position be a pointer into input , initially pointing at the start of the string.
If position is not beyond the end
of input , then fail.
Return year and month
.
The rules to parse a month
component , given an input string and a
position , are as follows. This will either
return a year and a month, or nothing. If at any point the
algorithm says that it "fails", this means that it is aborted at
that point and returns nothing.
Collect a sequence
of characters in the range U+0030 DIGIT ZERO (0) to U+0039
DIGIT NINE (9). If the collected sequence is not at least four
characters long, then fail. Otherwise, interpret the resulting
sequence as a base-ten integer. Let that number be the year .
If year is not a number greater than zero,
then fail.
If position is beyond the end of input or if the character at position
is not a U+002D HYPHEN-MINUS character, then fail. Otherwise, move
position forwards one character.
Collect a sequence
of characters in the range U+0030 DIGIT ZERO (0) to U+0039
DIGIT NINE (9). If the collected sequence is not exactly two
characters long, then fail. Otherwise, interpret the resulting
sequence as a base-ten integer. Let that number be the month .
If month is not a number in the range
1 ≤ month ≤ 12, then
fail.
Return year and month
.
2.4.5.2 Dates
A date
consists of a specific proleptic Gregorian date with no time-zone
information, consisting of a year, a month, and a day. [GREGORIAN]
A string is a valid date
string representing a year year , month
month , and day day if it
consists of the following components in the given order:
The rules to parse a date
string are as follows. This will either return a date, or
nothing. If at any point the algorithm says that it "fails", this
means that it is aborted at that point and returns nothing.
Let input be the string being parsed.
Let position be a pointer into input , initially pointing at the start of the string.
Parse a date component to
obtain year , month , and
day . If this returns nothing, then fail.
If position is not beyond the end
of input , then fail.
Let date be the date with year year , month month , and day
day .
Return date .
The rules to parse a date
component , given an input string and a
position , are as follows. This will either
return a year, a month, and a day, or nothing. If at any point the
algorithm says that it "fails", this means that it is aborted at
that point and returns nothing.
If position is beyond the end of input or if the character at position
is not a U+002D HYPHEN-MINUS character, then fail. Otherwise, move
position forwards one character.
Collect a sequence
of characters in the range U+0030 DIGIT ZERO (0) to U+0039
DIGIT NINE (9). If the collected sequence is not exactly two
characters long, then fail. Otherwise, interpret the resulting
sequence as a base-ten integer. Let that number be the day .
If day is not a number in the range
1 ≤ month ≤ maxday , then fail.
Return year , month ,
and day .
2.4.5.3 Times
A time
consists of a specific time with no time-zone information,
consisting of an hour, a minute, a second, and a fraction of a
second.
A string is a valid time
string representing an hour hour , a
minute minute , and a second second if it consists of the following components in the
given order:
Two digits , representing hour , in the range 0 ≤ hour ≤ 23
A U+003A COLON character (:)
Two digits , representing minute , in the range 0 ≤ minute ≤ 59
Optionally (required if second is
non-zero):
A U+003A COLON character (:)
Two digits , representing the integer part
of second , in the range 0 ≤
s ≤ 59
Optionally (required if second is not an
integer):
A 002E FULL STOP character (.)
One or more digits , representing the fractional
part of second
The second component cannot be
60 or 61; leap seconds cannot be represented.
The rules to parse a time
string are as follows. This will either return a time, or
nothing. If at any point the algorithm says that it "fails", this
means that it is aborted at that point and returns nothing.
Let input be the string being parsed.
Let position be a pointer into input , initially pointing at the start of the string.
Parse a time component to
obtain hour , minute , and
second . If this returns nothing, then
fail.
If position is not beyond the end
of input , then fail.
Let time be the time with hour hour , minute minute , and second
second .
Return time .
The rules to parse a time
component , given an input string and a
position , are as follows. This will either
return an hour, a minute, and a second, or nothing. If at any point
the algorithm says that it "fails", this means that it is aborted
at that point and returns nothing.
Collect a sequence
of characters in the range U+0030 DIGIT ZERO (0) to U+0039
DIGIT NINE (9). If the collected sequence is not exactly two
characters long, then fail. Otherwise, interpret the resulting
sequence as a base-ten integer. Let that number be the hour .
If hour is not a number in the range
0 ≤ hour ≤ 23, then
fail.
If position is beyond the end of input or if the character at position
is not a U+003A COLON character, then fail. Otherwise, move
position forwards one character.
Collect a sequence
of characters in the range U+0030 DIGIT ZERO (0) to U+0039
DIGIT NINE (9). If the collected sequence is not exactly two
characters long, then fail. Otherwise, interpret the resulting
sequence as a base-ten integer. Let that number be the minute .
If minute is not a number in the range
0 ≤ minute ≤ 59, then
fail.
Let second be a string with the value
"0".
If position is not beyond the end of
input and the character at position is a U+003A COLON, then run these substeps:
Advance position to the next character in
input .
If position is beyond the end of input , or at the last character in input , or if the next two characters in
input starting at position
are not two characters both in the range U+0030 DIGIT ZERO (0) to
U+0039 DIGIT NINE (9), then fail.
Collect a sequence
of characters that are either characters in the range U+0030
DIGIT ZERO (0) to U+0039 DIGIT NINE (9) or U+002E FULL STOP
characters. If the collected sequence has more than one U+002E FULL
STOP characters, or if the last character in the sequence is a
U+002E FULL STOP character, then fail. Otherwise, let the collected
string be second instead of its previous
value.
Interpret second as a base-ten number
(possibly with a fractional part). Let second
be that number instead of the string version.
If second is not a number in the range
0 ≤ second < 60, then
fail.
Return hour , minute ,
and second .
2.4.5.4
Local dates and times
A local date and time consists of a
specific proleptic Gregorian date, consisting of a year, a month,
and a day, and a time, consisting of an hour, a minute, a second,
and a fraction of a second, but expressed without a time zone.
[GREGORIAN]
A string is a valid
local date and time string representing a date and time if it
consists of the following components in the given order:
The rules to parse
a local date and time string are as follows. This will either
return a date and time, or nothing. If at any point the algorithm
says that it "fails", this means that it is aborted at that point
and returns nothing.
Let input be the string being parsed.
Let position be a pointer into input , initially pointing at the start of the string.
Parse a date component to
obtain year , month , and
day . If this returns nothing, then fail.
If position is beyond the end of input or if the character at position
is not a U+0054 LATIN CAPITAL LETTER T character then fail.
Otherwise, move position forwards one
character.
Parse a time component to
obtain hour , minute , and
second . If this returns nothing, then
fail.
If position is not beyond the end
of input , then fail.
Let date be the date with year year , month month , and day
day .
Let time be the time with hour hour , minute minute , and second
second .
Return date and time
.
2.4.5.5
Global dates and times
A global
date and time consists of a specific proleptic Gregorian
date, consisting of a year, a month, and a day, and a time,
consisting of an hour, a minute, a second, and a fraction of a
second, expressed with a time zone, consisting of a number of hours
and minutes. [GREGORIAN]
A string is a valid
global date and time string representing a date, time, and a
time-zone offset if it consists of the following components in the
given order:
A U+005A LATIN CAPITAL LETTER Z character, allowed only if the
time zone is UTC
Or:
Either a U+002B PLUS SIGN character (+) or a U+002D
HYPHEN-MINUS (-) character, representing the sign of the time-zone
offset
Two digits , representing the hours
component hour of the time-zone offset, in the
range 0 ≤ hour ≤ 23
A U+003A COLON character (:)
Two digits , representing the minutes
component minute of the time-zone offset, in
the range 0 ≤ minute
≤ 59
This format allows for time zone offsets from
-23:59 to +23:59. In practice, however, the range of actual time
zones is -12:00 to +14:00, and the minutes component of actual time
zones is always either 00, 30, or 45.
Midnight UTC on the birthday of Nero (the Roman Emperor).
" 1979-10-14T12:00:00.001-04:00 "
One millisecond after noon on October 14th 1979, in the time
zone in use on the east coast of North America during daylight
saving time.
" 8592-01-01T02:09+02:09 "
Midnight UTC on the 1st of January, 8592. The time zone
associated with that time is two hours and nine minutes ahead of
UTC, which is not a real time zone currently, but is nonetheless
allowed.
Several things are notable about these dates:
Years with fewer than four digits have to be zero-padded. The
date "37-12-13" would not be a valid date.
To unambiguously identify a moment in time prior to the
introduction of the Gregorian calendar, the date has to be first
converted to the Gregorian calendar from the calendar in use at the
time (e.g. from the Julian calendar). The date of Nero's birth is
the 15th of December 37, in the Julian Calendar, which is the 13th
of December 37 in the proleptic Gregorian Calendar.
The time and time-zone components are not optional.
Dates before the year zero can't be represented as a datetime
in this version of HTML.
Time zones differ based on daylight savings time.
The rules to parse
a global date and time string are as follows. This will
either return a time in UTC, with associated time-zone information
for round tripping or display purposes, or nothing. If at any point
the algorithm says that it "fails", this means that it is aborted
at that point and returns nothing.
Let input be the string being parsed.
Let position be a pointer into input , initially pointing at the start of the string.
Parse a date component to
obtain year , month , and
day . If this returns nothing, then fail.
If position is beyond the end of input or if the character at position
is not a U+0054 LATIN CAPITAL LETTER T character then fail.
Otherwise, move position forwards one
character.
Parse a time component to
obtain hour , minute , and
second . If this returns nothing, then
fail.
If position is beyond the end of input , then fail.
Parse a time-zone
component to obtain timezone hours and timezone minutes . If this returns nothing, then fail.
If position is not beyond the end
of input , then fail.
Let time be the moment in time at year
year , month month , day
day , hours hour , minute
minute , second second ,
subtracting timezone hours
hours and timezone minutes
minutes. That moment in time is a moment in the UTC time zone.
Let timezone be timezone
hours hours and timezone
minutes minutes from UTC.
Return time and timezone
.
The rules to parse a
time-zone component , given an input
string and a position , are as follows. This
will either return time-zone hours and time-zone minutes, or
nothing. If at any point the algorithm says that it "fails", this
means that it is aborted at that point and returns nothing.
If the character at position is a U+005A
LATIN CAPITAL LETTER Z, then:
Let timezone hours be
0.
Let timezone minutes be
0.
Advance position to the next character in
input .
Otherwise, if the character at position is
either a U+002B PLUS SIGN ("+") or a U+002D HYPHEN-MINUS ("-"),
then:
If the character at position is a U+002B
PLUS SIGN ("+"), let sign be "positive".
Otherwise, it's a U+002D HYPHEN-MINUS ("-"); let sign be "negative".
Advance position to the next character in
input .
Collect a sequence
of characters in the range U+0030 DIGIT ZERO (0) to U+0039
DIGIT NINE (9). If the collected sequence is not exactly two
characters long, then fail. Otherwise, interpret the resulting
sequence as a base-ten integer. Let that number be the timezone hours .
If timezone hours is
not a number in the range 0 ≤ timezone
hours ≤ 23, then fail.
If sign is "negative", then negate
timezone hours .
If position is beyond the end of input or if the character at position
is not a U+003A COLON character, then fail. Otherwise, move
position forwards one character.
Collect a sequence
of characters in the range U+0030 DIGIT ZERO (0) to U+0039
DIGIT NINE (9). If the collected sequence is not exactly two
characters long, then fail. Otherwise, interpret the resulting
sequence as a base-ten integer. Let that number be the timezone minutes .
If timezone minutes is
not a number in the range 0 ≤ timezone
minutes ≤ 59, then fail.
If sign is "negative", then negate
timezone minutes .
Return timezone hours
and timezone minutes .
2.4.5.6 Weeks
A week
consists of a week-year number and a week number representing a
seven day period. Each week-year in this calendaring system has
either 52 weeks or 53 weeks, as defined below. A week is a
seven-day period. The week starting on the Gregorian date Monday
December 29th 1969 (1969-12-29) is defined as week number 1 in
week-year 1970. Consecutive weeks are numbered sequentially. The
week before the number 1 week in a week-year is the last week in
the previous week-year, and vice versa. [GREGORIAN]
A week-year with a number year has 53 weeks
if it corresponds to either a year year in the
proleptic Gregorian calendar that has a Thursday as its first day
(January 1st), or a year year in the proleptic
Gregorian calendar that has a Wednesday as its first day (January
1st) and where year is a number divisible by
400, or a number divisible by 4 but not by 100. All other
week-years have 52 weeks.
The week number of the
last day of a week-year with 53 weeks is 53; the week number
of the last day of a week-year with 52 weeks is 52.
The week-year number of a particular day can be
different than the number of the year that contains that day in the
proleptic Gregorian calendar. The first week in a week-year
y is the week that contains the first Thursday
of the Gregorian year y .
A string is a valid week
string representing a week-year year and
week week if it consists of the following
components in the given order:
Four or more digits , representing year , where year
> 0
A U+002D HYPHEN-MINUS character (-)
A U+0057 LATIN CAPITAL LETTER W character
Two digits , representing the week
week , in the range 1 ≤ week ≤ maxweek , where
maxweek is the week number of the last day of
week-year year
The rules to parse a week
string are as follows. This will either return a week-year
number and week number, or nothing. If at any point the algorithm
says that it "fails", this means that it is aborted at that point
and returns nothing.
Let input be the string being parsed.
Let position be a pointer into input , initially pointing at the start of the string.
Collect a sequence
of characters in the range U+0030 DIGIT ZERO (0) to U+0039
DIGIT NINE (9). If the collected sequence is not at least four
characters long, then fail. Otherwise, interpret the resulting
sequence as a base-ten integer. Let that number be the year .
If year is not a number greater than zero,
then fail.
If position is beyond the end of input or if the character at position
is not a U+002D HYPHEN-MINUS character, then fail. Otherwise, move
position forwards one character.
If position is beyond the end of input or if the character at position
is not a U+0057 LATIN CAPITAL LETTER W character, then fail.
Otherwise, move position forwards one
character.
Collect a sequence
of characters in the range U+0030 DIGIT ZERO (0) to U+0039
DIGIT NINE (9). If the collected sequence is not exactly two
characters long, then fail. Otherwise, interpret the resulting
sequence as a base-ten integer. Let that number be the week .
A string is a valid date or time string in
content if it consists of zero or more White_Space characters, followed by a valid date or time string ,
followed by zero or more further White_Space characters.
The rules to parse a date
or time string are as follows. The algorithm is invoked with
a flag indicating if the in attribute variant or the in
content variant is to be used. The algorithm will either return
a date , a
time , a global date and
time , or nothing. If at any point the algorithm says that it
"fails", this means that it is aborted at that point and returns
nothing.
Let input be the string being parsed.
Let position be a pointer into input , initially pointing at the start of the string.
Set start position to the same position as
position .
Set the date present and time
present flags to true.
Parse a date component to
obtain year , month , and
day . If this fails, then set the date present flag to false.
If date present is true, and position is not beyond the end of input , and the character at position
is a U+0054 LATIN CAPITAL LETTER T character, then advance
position to the next character in input .
Otherwise, if date present is true, and
either position is beyond the end of
input or the character at position is not a U+0054 LATIN CAPITAL LETTER T character,
then set time present to false.
Otherwise, if date present is false, set
position back to the same position as
start position .
If the time present flag is true, then
parse a time component to
obtain hour , minute , and
second . If this returns nothing, then set the
time present flag to false.
If both the date present and time present flags are false, then fail.
If the time present flag is true, but
position is beyond the end of input , then fail.
If the date present and time
present flags are both true, parse a time-zone component to
obtain timezone hours and
timezone minutes . If this
returns nothing, then fail.
If position is not beyond the end
of input , then fail.
If the date present flag is true and the
time present flag is false, then let
date be the date with year year , month month , and day
day , and return date .
Otherwise, if the time present flag is true
and the date present flag is false, then let
time be the time with hour hour , minute minute , and second
second , and return time
.
Otherwise, let time be the moment in time at
year year , month month ,
day day , hours hour ,
minute minute , second second , subtracting timezone hours hours and timezone minutes minutes, that moment in time being a moment
in the UTC time zone; let timezone be
timezone hours hours and
timezone minutes minutes
from UTC; and return time and timezone .
2.4.6 Colors
A simple color consists of three
8-bit numbers in the range 0..255, representing the red, green, and
blue components of the color respectively, in the sRGB color space.
[SRGB]
A string is a valid simple
color if it is exactly seven characters long, and the first
character is a U+0023 NUMBER SIGN (#) character, and the remaining
six characters are all in the range U+0030 DIGIT ZERO (0) .. U+0039
DIGIT NINE (9), U+0041 LATIN CAPITAL LETTER A .. U+0046 LATIN
CAPITAL LETTER F, U+0061 LATIN SMALL LETTER A .. U+0066 LATIN SMALL
LETTER F, with the first two digits representing the red component,
the middle two digits representing the green component, and the
last two digits representing the blue component, in
hexadecimal.
A string is a valid
lowercase simple color if it is a valid simple color and doesn't use any
characters in the range U+0041 LATIN CAPITAL LETTER A .. U+0046
LATIN CAPITAL LETTER F.
The rules for
parsing simple color values are as given in the following
algorithm. When invoked, the steps must be followed in the order
given, aborting at the first step that returns a value. This
algorithm will either return a simple
color or an error.
Let input be the string being parsed.
If input is not exactly seven characters
long, then return an error.
If the first character in input is not a
U+0023 NUMBER SIGN (#) character, then return an error.
If the last six characters of input are not
all in the range U+0030 DIGIT ZERO (0) .. U+0039 DIGIT NINE (9),
U+0041 LATIN CAPITAL LETTER A .. U+0046 LATIN CAPITAL LETTER F,
U+0061 LATIN SMALL LETTER A .. U+0066 LATIN SMALL LETTER F, then
return an error.
Interpret the second and third characters as a hexadecimal
number and let the result be the red component of result .
Interpret the fourth and fifth characters as a hexadecimal
number and let the result be the green component of result .
Interpret the sixth and seventh characters as a hexadecimal
number and let the result be the blue component of result .
Return result .
The rules
for serializing simple color values given a simple color are as given in the following
algorithm:
Let result be a string consisting of a
single U+0023 NUMBER SIGN (#) character.
Convert the red, green, and blue components in turn to two-digit
hexadecimal numbers using the digits U+0030 DIGIT ZERO (0) ..
U+0039 DIGIT NINE (9) and U+0061 LATIN SMALL LETTER A .. U+0066
LATIN SMALL LETTER F, zero-padding if necessary, and append these
numbers to result , in the order red, green,
blue.
Some obsolete legacy attributes parse colors in a more
complicated manner, using the rules for parsing a legacy
color value , which are given in the following algorithm.
When invoked, the steps must be followed in the order given,
aborting at the first step that returns a value. This algorithm
will either return a simple color or an
error.
Let input be the string being parsed.
If input is the empty string, then return an
error.
If input is an ASCII case-insensitive match for the
string " transparent ", then return an
error.
If input is four characters long, and the
first character in input is a U+0023 NUMBER
SIGN (#) character, and the last three characters of input are all in the range U+0030 DIGIT ZERO (0) .. U+0039
DIGIT NINE (9), U+0041 LATIN CAPITAL LETTER A .. U+0046 LATIN
CAPITAL LETTER F, and U+0061 LATIN SMALL LETTER A .. U+0066 LATIN
SMALL LETTER F, then run these substeps:
Interpret the second character of input as a
hexadecimal digit; let the red component of result be the resulting number multiplied by 17.
Interpret the third character of input as a
hexadecimal digit; let the green component of result be the resulting number multiplied by 17.
Interpret the fourth character of input as a
hexadecimal digit; let the blue component of result be the resulting number multiplied by 17.
Return result .
Replace any characters in input that have a
Unicode code point greater than U+FFFF (i.e. any characters that
are not in the basic multilingual plane) with the two-character
string " 00 ".
If input is longer than 128 characters,
truncate input , leaving only the first 128
characters.
If the first character in input is a U+0023
NUMBER SIGN character (#), remove it.
Replace any character in input that is not
in the range U+0030 DIGIT ZERO (0) .. U+0039 DIGIT NINE (9), U+0041
LATIN CAPITAL LETTER A .. U+0046 LATIN CAPITAL LETTER F, and U+0061
LATIN SMALL LETTER A .. U+0066 LATIN SMALL LETTER F with the
character U+0030 DIGIT ZERO (0).
While input 's length is zero or not a
multiple of three, append a U+0030 DIGIT ZERO (0) character to
input .
Split input into three strings of equal
length, to obtain three components. Let length
be the length of those components (one third the length of
input ).
If length is greater than 8, then remove the
leading length -8
characters in each component, and let length be
8.
While length is greater than two and the
first character in each component is a U+0030 DIGIT ZERO (0)
character, remove that character and reduce length by one.
If length is still greater than
two, truncate each component, leaving only the first two characters
in each.
Interpret the first component as a hexadecimal number; let the
red component of result be the resulting
number.
Interpret the second component as a hexadecimal number; let the
green component of result be the resulting
number.
Interpret the third component as a hexadecimal number; let the
blue component of result be the resulting
number.
Return result .
The 2D graphics context has a separate color
syntax that also handles opacity.
2.4.7
Space-separated tokens
A set of space-separated
tokens is a set of zero or more words separated by one or
more space
characters , where words consist of any string of one or more
characters, none of which are space characters .
An unordered set of
unique space-separated tokens is a set of space-separated tokens
where none of the words are duplicated.
An ordered set of
unique space-separated tokens is a set of space-separated tokens
where none of the words are duplicated but where the order of the
tokens is meaningful.
Sets of space-separated tokens
sometimes have a defined set of allowed values. When a set of
allowed values is defined, the tokens must all be from that list of
allowed values; other values are non-conforming. If no such set of
allowed values is provided, then all values are conforming.
When a user agent has to split a string on spaces , it must
use the following algorithm:
Let input be the string being parsed.
Let position be a pointer into input , initially pointing at the start of the string.
If position is not past the end of
input , and output is not
the empty string, append a single U+0020 SPACE character at the end
of output .
Otherwise, append s to the end of
output .
Return to step 6 in the overall set of steps.
This causes any occurrences of the token to be
removed from the string, and any spaces that were surrounding the
token to be collapsed to a single space, except at the start and
end of the string, where such spaces are removed.
2.4.8
Comma-separated tokens
A set of comma-separated
tokens is a set of zero or more tokens each separated from
the next by a single U+002C COMMA character ( , ), where tokens consist of any string of zero or more
characters, neither beginning nor ending with space characters ,
nor containing any U+002C COMMA characters ( , ), and optionally surrounded by space characters
.
For instance, the string " a ,b,,d d " consists of four
tokens: "a", "b", the empty string, and "d d". Leading and
trailing whitespace around each token doesn't count as part of the
token, and the empty string can be a token.
Sets of comma-separated tokens
sometimes have further restrictions on what consists a valid token.
When such restrictions are defined, the tokens must all fit within
those restrictions; other values are non-conforming. If no such
restrictions are specified, then all values are conforming.
When a user agent has to split a string on commas , it must
use the following algorithm:
Let input be the string being parsed.
Let position be a pointer into input , initially pointing at the start of the string.
Let tokens be a list of tokens, initially
empty.
Token : If position is past the end
of input , jump to the last step.
Collect a sequence
of characters that are not U+002C COMMA characters (
, ). Let s be the
resulting sequence (which might be the empty string).
Remove any leading or trailing sequence of space characters
from s .
Add s to tokens .
If position is not past the end of
input , then the character at position is a U+002C COMMA character ( , ); advance position past that
character.
Jump back to the step labeled token .
Return tokens .
2.4.9
Reversed DNS identifiers
A valid reversed DNS
identifier is a string that consists of a series of IDNA
labels in reverse order (i.e. starting with the top-level domain),
the prefix of which, when reversed and converted to ASCII,
corresponds to a registered domain.
For instance, the string " com.example.xn--74h " is a valid reversed DNS identifier
because the string " example.com " is a
registered domain.
Apply the IDNA ToASCII algorithm to the string, with both the
AllowUnassigned and UseSTD3ASCIIRules flags set, but between steps
2 and 3 of the general ToASCII/ToUnicode algorithm (i.e. after
splitting the domain name into individual labels), reverse the
order of the labels.
If ToASCII fails to convert one of the components of the string,
e.g. because it is too long or because it contains invalid
characters, then the string is not valid; abort these steps.
[RFC3490]
Check that the end of the resulting string matches a suffix in
the Public Suffix List, and that there is at least one domain label
before the matching substring. If it does not, or if there is not,
then the string is not valid; abort these steps. [PSL]
Check that the domain name up to the label before the prefix
that was matched in the previous string is a registered domain
name.
2.4.10
References
A valid hash-name
reference to an element of type type is a
string consisting of a U+0023 NUMBER SIGN ( #
) character followed by a string which exactly matches the value of
the name attribute of an element in the
document with type type .
The rules for
parsing a hash-name reference to an element of type
type are as follows:
If the string being parsed does not contain a U+0023 NUMBER SIGN
character, or if the first such character in the string is the last
character in the string, then return null and abort these
steps.
Let s be the string from the character
immediately after the first U+0023 NUMBER SIGN character in the
string being parsed up to the end of that string.
Return the first element of type type that
has an id attribute whose value is a
case-sensitive match for s or a name attribute whose value is
a compatibility caseless
match for s .
2.5 URLs
2.5.1
Terminology
A URL is a string used to identify a
resource.
A URL is a valid
URL if it is a valid Web address as defined by
the Web addresses specification. [WEBADDRESSES]
A URL is an absolute
URL if it is an absolute Web address as defined
by the Web addresses specification. [WEBADDRESSES]
To parse a URL url into its component parts, the user agent must use the
parse a Web address algorithm defined by the Web
addresses specification. [WEBADDRESSES]
Parsing a URL results in the following components, again as
defined by the Web addresses specification:
<scheme>
<host>
<port>
<hostport>
<path>
<query>
<fragment>
<host-specific>
To resolve a URL to an absolute URL relative to either another
absolute URL or an element, the user
agent must use the resolve a Web address algorithm
defined by the Web addresses specification. [WEBADDRESSES]
The document base URL of a
Document object is the document base Web
address as defined by the Web addresses specification.
[WEBADDRESSES]
The term "URL" in this specification is used in a
manner distinct from the precise technical meaning it is given in
RFC 3986. Readers familiar with that RFC will find it easier to
read this specification if they pretend the term "URL" as
used herein is really called something else altogether. This is a
willful violation of RFC 3986.
[RFC3986]
When an element is moved from one document to another, if the
two documents have different base URLs , then that element and all its
descendants are affected
by a base URL change .
When an element is affected by a base URL change
, it must act as described in the following list:
If the absolute URL identified by
the hyperlink is being shown to the user, or if any data derived
from that URL is affecting the display, then the href attribute should be re-resolved relative to
the element and the UI updated appropriately.
For example, the CSS :link /
:visited pseudo-classes might have
been affected.
If the hyperlink has a ping attribute and
its absolute
URL(s) are being shown to the user, then the ping attribute's
tokens should be re-resolved relative to the element and the UI
updated appropriately.
If the absolute URL identified by
the cite attribute is being shown to the
user, or if any data derived from that URL is affecting the
display, then the URL should be re-resolved relative to
the element and the UI updated appropriately.
Otherwise
The element is not directly affected.
Changing the base URL doesn't affect the image
displayed by img
elements, although subsequent accesses of the src DOM attribute
from script will return a new absolute
URL that might no longer correspond to the image being
shown.
2.5.3 Interfaces for URL manipulation
An interface that has a complement of URL decomposition attributes
will have seven attributes with the following definitions:
Returns the current fragment identifier in the underlying
URL.
Can be set, to change the underlying URL's fragment
identifier.
The attributes defined to be URL decomposition attributes must
act as described for the attributes with the same corresponding
names in this section.
In addition, an interface with a complement of URL decomposition
attributes will define an input , which is a URL
that the attributes act on, and a common setter action , which is a
set of steps invoked when any of the attributes' setters are
invoked.
The seven URL decomposition attributes have similar
requirements.
On getting, if the input is an absolute URL that fulfills the condition given
in the "getter condition" column corresponding to the attribute in
the table below, the user agent must return the part of the
input
URL given in the "component" column, with any prefixes specified in
the "prefix" column appropriately added to the start of the string
and any suffixes specified in the "suffix" column appropriately
added to the end of the string. Otherwise, the attribute must
return the empty string.
On setting, the new value must first be mutated as described by
the "setter preprocessor" column, then mutated by %-escaping any
characters in the new value that are not valid in the relevant
component as given by the "component" column. Then, if the input is an
absolute URL and the resulting new
value fulfills the condition given in the "setter condition"
column, the user agent must make a new string output by replacing the component of the URL given by the
"component" column in the input URL with the new value; otherwise,
the user agent must let output be equal to the
input .
Finally, the user agent must invoke the common setter
action with the value of output .
When replacing a component in the URL, if the component is part
of an optional group in the URL syntax consisting of a character
followed by the component, the component (including its prefix
character) must be included even if the new value is the empty
string.
The previous paragraph applies in particular to the
" : " before a <port> component, the "
? " before a <query> component, and the
" # " before a <fragment>
component.
For the purposes of the above definitions, URLs must be parsed
using the URL parsing
rules defined in this specification.
input is hierarchical, uses a server-based
naming authority, and contained a <port> component (possibly an empty one)
—
—
Remove any characters in the new value that are not in the
range U+0030 DIGIT ZERO .. U+0039 DIGIT NINE. If the resulting
string is empty, set it to a single U+0030 DIGIT ZERO character
('0').
input is hierarchical and uses a
server-based naming authority
The (empty) <fragment> component is not part of the
<query>
component.
2.6 Fetching
resources
When a user agent is to fetch a resource,
the following steps must be run:
If the resource is identified by the URLabout:blank , then return
the empty string and abort these steps.
Perform the remaining steps asynchronously.
If the resource is identified by an absolute URL , and the resource is to be
obtained using a idempotent action (such as an HTTP GET or equivalent ), and it is
already being downloaded for other reasons (e.g. another invocation
of this algorithm), and the user agent is configured such that it
is to reuse the data from the existing download instead of
initiating a new one, then use the results of the existing download
instead of starting a new one.
Otherwise, at a time convenient to the user and the user agent,
download (or otherwise obtain) the resource, applying the semantics
of the relevant specifications (e.g. performing an HTTP GET or POST
operation, or reading the file from disk, following redirects,
dereferencing
javascript:
URLs , etc).
For purposes of generating the address of the resource from
which Request-URIs are obtained as required by HTTP for the
Referer (sic) header, the user
agent must use the
document's current address of the appropriate
Document as given by this list. [HTTP]
Release the storage mutex so that
it is once again free.
When the resource is available, or if there is an error of some
description, queue a task that uses the
resource as appropriate. If the resource can be processed
incrementally, as, for instance, with a progressively interlaced
JPEG or an HTML file, additional tasks may be queued to process the
data as it is downloaded. The task
source for these tasks is the networking task source .
The navigation processing model handles redirects
itself, overriding the redirection handling that would be done by
the fetching algorithm.
Whether the type
sniffing rules apply to the fetched resource depends on the
algorithm that invokes the rules — they are not always
applicable.
2.6.1
Protocol concepts
User agents can implement a variety of transfer protocols, but
this specification mostly defines behavior in terms of HTTP.
[HTTP]
The HTTP GET method is equivalent
to the default retrieval action of the protocol. For example, RETR
in FTP. Such actions are idempotent and safe, in HTTP terms.
The HTTP response codes are
equivalent to statuses in other protocols that have the same basic
meanings. For example, a "file not found" error is equivalent to a
404 code, a server error is equivalent to a 5xx code, and so
on.
The HTTP headers are equivalent
to fields in other protocols that have the same basic meaning. For
example, the HTTP authentication headers are equivalent to the
authentication aspects of the FTP protocol.
2.6.2 Encrypted HTTP and related security
concerns
Anything in this specification that refers to HTTP also applies
to HTTP-over-TLS, as represented by URLs representing the https
scheme.
User agents should report certificate errors to
the user and must either refuse to download resources sent with
erroneous certificates or must act as if such resources were in
fact served with no encryption.
Not doing so can result in users not noticing man-in-the-middle
attacks.
If a user connects to a server with a self-signed certificate,
the user agent could allow the connection but just act as if there
had been no encryption. If the user agent instead allowed the user
to override the problem and then displayed the page as if it was
fully and safely encrypted, the user could be easily tricked into
accepting man-in-the-middle connections.
If a user connects to a server with full encryption, but the
page then refers to an external resource that has an expired
certificate, then the user agent will act as if the resource was
unavailable, possibly also reporting the problem to the user. If
the user agent instead allowed the resource to be used, then an
attacker could just look for "secure" sites that used resources
from a different host and only apply man-in-the-middle attacks to
that host, for example taking over scripts in the page.
2.6.3
Determining the type of a resource
The Content-Type
metadata of a resource must be obtained and interpreted in a
manner consistent with the requirements of the Content-Type
Processing Model specification. [MIMESNIFF]
The algorithm
for extracting an encoding from a Content-Type , given a
string s , is given in the Content-Type
Processing Model specification. It either returns an encoding or
nothing. [MIMESNIFF]
The sniffed type of a resource must be
found in a manner consistent with the requirements given in the
Content-Type Processing Model specification for finding that
sniffed type . [MIMESNIFF]
The rules for sniffing images
specifically are also defined in the Content-Type Processing
Model specification. [MIMESNIFF]
It is imperative that the rules in the
Content-Type Processing Model specification be followed exactly.
When a user agent uses different heuristics for content type
detection than the server expects, security problems can occur. For
more details, see the Content-Type Processing Model specification.
[MIMESNIFF]
2.7
Character encodings
User agents must at a minimum support the UTF-8 and Windows-1252
encodings, but may support more.
It is not unusual for Web browsers to support
dozens if not upwards of a hundred distinct character
encodings.
User agents must support the preferred MIME name of every
character encoding they support that has a preferred MIME name, and
should support all the IANA-registered aliases. [IANACHARSET]
When comparing a string specifying a character encoding with the
name or alias of a character encoding to determine if they are
equal, user agents must use the Charset Alias Matching rules
defined in Unicode Technical Standard #22. [UTS22]
For instance, "GB_2312-80" and "g.b.2312(80)"
are considered equivalent names.
When a user agent would otherwise use an encoding specified by a
label given in the first column of the following table to either
convert content to Unicode characters or convert Unicode characters
to bytes, it must instead use the encoding given in the cell in the
second column of the same row. When a byte or sequence of bytes is
treated differently due to this encoding aliasing, it is said to
have been misinterpreted
for compatibility .
The requirement to treat certain encodings as other
encodings according to the table above is a willful violation of the W3C Character
Model specification, motivated by a desire for compatibility with
legacy content. [CHARMOD]
Support for encodings based on EBCDIC is not recommended. This
encoding is rarely used for publicly-facing Web content.
Support for UTF-32 is not recommended. This encoding is rarely
used, and frequently implemented incorrectly.
This specification does not make any attempt to
support EBCDIC-based encodings and UTF-32 in its algorithms;
support and use of these encodings can thus lead to unexpected
behavior in implementations of this specification.
2.8
Common DOM interfaces
2.8.1 Reflecting content attributes in
DOM attributes
Some DOM attributes are
defined to reflect a particular
content attribute . This means that on getting, the
DOM attribute returns the current value of the content attribute,
and on setting, the DOM attribute changes the value of the content
attribute to the given value.
A list of reflecting DOM attributes and
their corresponding content attributes is given in the index.
In general, on getting, if the content attribute is not present,
the DOM attribute must act as if the content attribute's value is
the empty string; and on setting, if the content attribute is not
present, it must first be added.
If a reflecting DOM attribute is a DOMString
attribute whose content attribute is defined to contain a URL , then on getting, the DOM attribute must resolve the value of the
content attribute relative to the element and return the resulting
absolute URL if that was successful, or
the empty string otherwise; and on setting, must set the content
attribute to the specified literal value. If the content attribute
is absent, the DOM attribute must return the default value, if the
content attribute has one, or else the empty string.
If a reflecting DOM attribute is a DOMString
attribute whose content attribute is defined to contain one or more
URLs , then on getting, the DOM
attribute must split the content attribute on
spaces and return the concatenation of resolving each token URL to an absolute URL relative to the element, with a
single U+0020 SPACE character between each URL, ignoring any tokens
that did not resolve successfully. If the content attribute is
absent, the DOM attribute must return the default value, if the
content attribute has one, or else the empty string. On setting,
the DOM attribute must set the content attribute to the specified
literal value.
If a reflecting DOM attribute is a DOMString whose
content attribute is an enumerated
attribute , and the DOM attribute is limited to only known values ,
then, on getting, the DOM attribute must return the conforming
value associated with the state the attribute is in (in its
canonical case), or the empty string if the attribute is in a state
that has no associated keyword value; and on setting, if the new
value is an ASCII
case-insensitive match for one of the keywords given for that
attribute, then the content attribute must be set to the conforming
value associated with the state that the attribute would be in if
set to the given new value, otherwise, if the new value is the
empty string, then the content attribute must be removed,
otherwise, the setter must raise a SYNTAX_ERR exception.
If a reflecting DOM attribute is a DOMString but
doesn't fall into any of the above categories, then the getting and
setting must be done in a transparent, case-preserving manner.
If a reflecting DOM attribute is a boolean attribute, then on
getting the DOM attribute must return true if the attribute is set,
and false if it is absent. On setting, the content attribute must
be removed if the DOM attribute is set to false, and must be set to
have the same value as its name if the DOM attribute is set to
true. (This corresponds to the rules for boolean content
attributes .)
If a reflecting DOM attribute is a signed integer type (
long ) then, on getting, the content attribute must be
parsed according to the rules for parsing signed
integers , and if that is successful, and the value is in the
range of the DOM attribute's type, the resulting value must be
returned. If, on the other hand, it fails or returns an out of
range value, or if the attribute is absent, then the default value
must be returned instead, or 0 if there is no default value. On
setting, the given value must be converted to the shortest possible
string representing the number as a valid
integer in base ten and then that string must be used as the
new content attribute value.
If a reflecting DOM attribute is an unsigned integer
type ( unsigned long ) then, on getting, the content
attribute must be parsed according to the rules for parsing
non-negative integers , and if that is successful, and the
value is in the range of the DOM attribute's type, the resulting
value must be returned. If, on the other hand, it fails or returns
an out of range value, or if the attribute is absent, the default
value must be returned instead, or 0 if there is no default value.
On setting, the given value must be converted to the shortest
possible string representing the number as a valid non-negative integer in
base ten and then that string must be used as the new content
attribute value.
If a reflecting DOM attribute is an unsigned integer type (
unsigned long ) that is limited to only
positive non-zero numbers , then the behavior is similar to
the previous case, but zero is not allowed. On getting, the content
attribute must first be parsed according to the rules for parsing
non-negative integers , and if that is successful, and the
value is in the range of the DOM attribute's type, the resulting
value must be returned. If, on the other hand, it fails or returns
an out of range value, or if the attribute is absent, the default
value must be returned instead, or 1 if there is no default value.
On setting, if the value is zero, the user agent must fire an
INDEX_SIZE_ERR
exception. Otherwise, the given value must be converted to the
shortest possible string representing the number as a valid non-negative integer in
base ten and then that string must be used as the new content
attribute value.
If a reflecting DOM attribute is a floating point number type (
float ) and it doesn't fall into one of the earlier
categories, then, on getting, the content attribute must be parsed
according to the rules for parsing
floating point number values , and if that is successful, and
the value is in the range of the DOM attribute's type, the
resulting value must be returned. If, on the other hand, it fails
or returns an out of range value, or if the attribute is absent,
the default value must be returned instead, or 0.0 if there is no
default value. On setting, the given value must be converted to the
best
representation of the floating point number and then that
string must be used as the new content attribute value.
The values ±Infinity and NaN throw an exception on
setting, as defined by Web IDL. [WEBIDL]
If a reflecting DOM attribute is of the type DOMTokenList or DOMSettableTokenList , then on
getting it must return a DOMTokenList or DOMSettableTokenList object
(as appropriate) whose underlying string is the element's
corresponding content attribute. When the object mutates its
underlying string, the content attribute must itself be immediately
mutated. When the attribute is absent, then the string represented
by the object is the empty string; when the object mutates this
empty string, the user agent must first add the corresponding
content attribute, and then mutate that attribute instead. The same
DOMTokenList object must
be returned every time for each attribute.
If a reflecting DOM attribute has the type HTMLElement , or an interface that
descends from HTMLElement ,
then, on getting, it must run the following algorithm (stopping at
the first point where a value is returned):
If the corresponding content attribute is absent, then the DOM
attribute must return null.
Let candidate be the element that the
document.getElementById() method would find
if it was passed as its argument the current value of the
corresponding content attribute.
If candidate is null, or if it is not
type-compatible with the DOM attribute, then the DOM attribute must
return null.
Otherwise, it must return candidate .
On setting, if the given element has an id attribute, then
the content attribute must be set to the value of that id attribute.
Otherwise, the DOM attribute must be set to the empty string.
When a collection is created, a filter and a root are
associated with the collection.
For example, when the HTMLCollection object for the
document.images attribute is
created, it is associated with a filter that selects only
img elements, and
rooted at the root of the document.
The collection
then represents a live view of the subtree rooted at the collection's
root, containing only nodes that match the given filter. The view
is linear. In the absence of specific
requirements to the contrary, the nodes within the collection must
be sorted in tree order .
Returns the first item with ID or name name
from the collection.
Returns null if no element with that ID or name could be
found.
Only a ,
applet ,
area , embed , form , frame , frameset , iframe , img , and object elements can have a name
for the purpose of this method; their name is given by the value of
their name attribute.
Returns a collection that is a filtered view of the current
collection, containing only elements with the given tag name.
The object's indices of the supported indexed
properties are the numbers in the range zero to one less
than the number of nodes represented by the collection
. If there are no such elements, then there are no supported
indexed properties .
The item( index
) method must return the index th
node in the collection. If there is no index th
node in the collection, then the method must return null.
Returns the item with ID or namename from the
collection.
If there are multiple matching items, then a RadioNodeList object containing all
those elements is returned.
Returns null if no element with that ID or name could be
found.
radioNodeList . value [
= value ]
Returns the value of the first checked radio button represented
by the object.
Can be set, to check the first radio button with the given value
represented by the object.
The object's indices of the supported indexed
properties are the numbers in the range zero to one less
than the number of nodes represented by the collection
. If there are no such elements, then there are no supported
indexed properties .
The item( index ) method must return the index th node in the collection. If there is no
index th node in the collection, then the
method must return null.
The names of the supported named properties consist
of the values of all the id and name attributes
of all the elements represented by the collection
.
The namedItem(
name ) method must act according
to the following algorithm:
If, at the time the method is called, there is exactly one node
in the collection that has either an id attribute or a name attribute
equal to name , then return that node and stop
the algorithm.
Otherwise, if there are no nodes in the collection that have
either an id attribute or a name attribute
equal to name , then return null and stop the
algorithm.
If element is null, or if it is an element
with no value attribute, return the empty
string.
Otherwise, return the value of element 's
value attribute.
On setting, the value DOM attribute must run
the following steps:
Let element be the first element in tree order represented by the RadioNodeList object that is an
input element whose
type attribute is in the Radio
Button state and whose value content attribute is present
and equal to the new value, if any. Otherwise, let it be null.
If element is not null, then set its
checkedness to true.
2.8.2.3
HTMLOptionsCollection
The HTMLOptionsCollection
interface represents a list of option elements. It is always
rooted on a select
element and has attributes and methods that manipulate that
element's descendants.
The before argument can be a number, in
which case element is inserted before the item
with that number, or an element from the collection, in which case
element is inserted before that element.
If before is omitted, null, or a number out
of range, then element will be added at the end
of the list.
This method will throw a HIERARCHY_REQUEST_ERR exception
if element is an ancestor of the element into
which it is to be inserted. If element is not
an option or
optgroup element,
then the method does nothing.
The object's indices of the supported indexed
properties are the numbers in the range zero to one less
than the number of nodes represented by the collection
. If there are no such elements, then there are no supported
indexed properties .
On setting, the behavior depends on whether the new value is
equal to, greater than, or less than the number of nodes represented by the collection
at that time. If the number is the same, then setting the attribute
must do nothing. If the new value is greater, then n new option elements with no attributes
and no child nodes must be appended to the select element on which the
HTMLOptionsCollection is
rooted, where n is the difference between the
two numbers (new value minus old value). If the new value is lower,
then the last n nodes in the collection must be
removed from their parent nodes, where n is the
difference between the two numbers (old value minus new value).
Setting length never removes
or adds any optgroup elements, and never
adds new children to existing optgroup elements (though it can
remove children from them).
The item( index ) method must return the index th node in the collection. If there is no
index th node in the collection, then the
method must return null.
The names of the supported named properties consist
of the values of all the id and name attributes of all the elements
represented by the
collection .
The namedItem( name ) method must act according to the
following algorithm:
If, at the time the method is called, there is exactly one node
in the collection that has either an id attribute or a name attribute equal to name , then return that node and stop the algorithm.
Otherwise, if there are no nodes in the collection that have
either an id attribute or a name attribute equal to name , then return null and stop the algorithm.
Otherwise, create a NodeList object representing a
live view of the HTMLOptionsCollection object,
further filtered so that the only nodes in the
NodeList object are those that have either an
id
attribute or a name attribute
equal to name . The nodes in the
NodeList object must be sorted in tree order .
Return that NodeList object.
The add( element , before ) method
must act according to the following algorithm:
If element is not an option or optgroup element, then return
and abort these steps.
If before is an element, but that element
isn't a descendant of the select element on which the
HTMLOptionsCollection is
rooted, then throw a NOT_FOUND_ERR exception.
If element and before
are the same element, then return and abort these steps.
If before is a node, then let reference be that node. Otherwise, if before is an integer, and there is a before th node in the collection, let reference be that node. Otherwise, let reference be null.
If reference is not null, let parent be the parent node of reference
. Otherwise, let parent be the select element on which the
HTMLOptionsCollection is
rooted.
Act as if the DOM Core insertBefore() method was invoked on the
parent node, with element
as the first argument and reference as the
second argument.
The remove( index ) method must act according to the
following algorithm:
If index is not a number greater than or
equal to 0 and less than the number of nodes represented by the collection
, let element be the first element in the
collection. Otherwise, let element be the
index th element in the collection.
Returns a PropertyNodeList object containing
any elements that add a property named name
.
propertyNodeList . content
Returns an array of the various values that the relevant
elements have.
The object's indices of the supported indexed
properties are the numbers in the range zero to one less
than the number of nodes represented by the collection
. If there are no such elements, then there are no supported
indexed properties .
The item( index ) method must return the index th node in the collection. If there is no
index th node in the collection, then the
method must return null.
The names
attribute must return a live DOMStringList object
giving the property names of all the
elements represented by
the collection , listed in tree order
, but with duplicates removed, leaving only the first occurrence of
each name. The same object must be returned each time.
The namedItem( name ) method must return a PropertyNodeList object representing
a live view of the HTMLPropertyCollection
object, further filtered so that the only nodes in the
RadioNodeList object are
those that have a property name equal to name . The nodes in the PropertyNodeList object must be
sorted in tree order , and the same
object must be returned each time a particular name is queried.
A members of the PropertyNodeList interface inherited
from the NodeList interface must behave as they would
on a NodeList object.
The content DOM
attribute on the PropertyNodeList object, on getting,
must return a newly constructed DOMStringArray whose
values are the values obtained from the content DOM
property of each of the elements represented by the object, in
tree order .
While the order of the tokens in the underlying
string is not important, the DOMTokenList interfaces preserves the
underlying order for consistency between implementations.
The object's indices of the supported indexed
properties are the numbers in the range zero to length -1 , unless the
length is zero, in which case
there are no supported indexed properties .
The item( index
) method must split the underlying string on
spaces , preserving the order of the tokens as found in the
underlying string, remove instances of exact duplicates other than
the first instance in each case, and then return the index th item in this list. If index
is equal to or greater than the number of tokens, then the method
must return null.
For example, if the string is " a
b a c " then there are three tokens: the token with index 0
is " a ", the token with index 1 is "
b ", and the token with index 2 is "
c ".
The contains( token
) method must run the following algorithm:
If the given token is already one of the
tokens in the DOMTokenList object's underlying
string then stop the algorithm.
Otherwise, if the DOMTokenList object's underlying
string is not the empty string and the last character of that
string is not a space character ,
then append a U+0020 SPACE character to the end of that
string.
Append the value of token to the end of the
DOMTokenList object's
underlying string.
The remove( token
) method must run the following algorithm:
Otherwise, if the DOMTokenList object's underlying
string is not the empty string and the last character of that
string is not a space character ,
then append a U+0020 SPACE character to the end of that
string.
Append the value of token to the end of the
DOMTokenList object's
underlying string.
Return true.
Objects implementing the DOMTokenList interface must stringify to the object's underlying
string representation.
2.8.4
DOMSettableTokenList
The DOMSettableTokenList interface
is the same as the DOMTokenList interface, except that it
allows the underlying string to be directly changed.
An object implementing the DOMSettableTokenList interface
must act as defined for the DOMTokenList interface, except for the
value attribute
defined here.
The value attribute
must return the underlying string on getting, and must replace the
underlying string with the new value on setting.
2.8.5 Safe passing of structured data
When a user agent is required to obtain a structured clone of an object, it must run
the following algorithm, which either returns a separate object, or
throws an exception.
Let input be the object being cloned.
Let memory be a list of objects, initially
empty. (This is used to catch cycles.)
The internal
structured cloning algorithm is always called with two
arguments, input and memory
, and its behavior depends on the type of input
, as follows:
If input is the undefined value
Return the undefined value.
If input is the null value
Return the null value.
If input is the false value
Return the false value.
If input is the true value
Return the true value.
If input is a Number object
Return a newly constructed Number object with the same value as
input .
If input is a String object
Return a newly constructed String object with the same value as
input .
If input is a Date object
Return a newly constructed Date object with the
same value as input .
If input is a RegExp
object
Return a newly constructed RegExp object with the
same pattern and flags as input .
The value of the lastIndex
property is not copied.
Return a newly constructed ImageData object with the same width and height as input , and with a newly constructed CanvasPixelArray for its
data attribute, with the same
length and pixel values
as the input 's.
Otherwise, let new memory be a list
consisting of the items in memory with the
addition of input .
Create a new object, output , of the same
type as input : either an Array or an
Object.
For each enumerable property in input , add
a corresponding property to output having the
same name, and having a value created from invoking the internal structured
cloning algorithm recursively with the value of the property as
the " input " argument and new
memory as the " memory " argument. The
order of the properties in the input and
output objects must be the same.
This does not walk the prototype chain.
Return output .
If input is another native object type
(e.g. Error )
Return the null value.
2.8.6
DOMStringMap
The DOMStringMap
interface represents a set of name-value pairs. It exposes these
using the scripting language's native mechanisms for property
access.
When a DOMStringMap
object is instantiated, it is associated with three algorithms, one
for getting the list of name-value pairs, one for setting names to
certain values, and one for deleting names.
The names of the supported named properties on a
DOMStringMap object at
any instant are the names of each pair returned from the algorithm
for getting the list of name-value pairs at that instant.
When a DOMStringMap
object is indexed to retrieve a named property name , the value returned must be the value component of
the name-value pair whose name component is name in the list returned by the algorithm for getting the
list of name-value pairs.
When a DOMStringMap
object is indexed to create or modify a named property name with value value , the algorithm
for setting names to certain values must be run, passing
name as the name and the result of converting
value to a DOMString as the
value.
When a DOMStringMap
object is indexed to delete a named property named name , the algorithm for deleting names must be run,
passing name as the name.
The DOMStringMap interface definition here
is only intended for JavaScript environments. Other language
bindings will need to define how DOMStringMap is to be implemented for
those languages.
The dataset attribute on elements exposes the
data-*
attributes on the element.
Given the following fragment and elements with similar
constructions:
...one could imagine a function splashDamage() that takes some arguments, the first of
which is the element to process:
function splashDamage(node, x, y, damage) {
if (node.classList.contains('tower') && // checking the 'class' attribute
node.dataset.x == x && // reading the 'data-x' attribute
node.dataset.y == y) { // reading the 'data-y' attribute
var hp = parseInt(node.dataset.hp); // reading the 'data-hp' attribute
hp = hp - damage;
if (hp < 0) {
hp = 0;
node.dataset.ai = 'dead'; // setting the 'data-ai' attribute
delete node.dataset.ability; // removing the 'data-ability' attribute
}
node.dataset.hp = hp; // setting the 'data-hp' attribute
}
}
2.8.7 DOM
feature strings
DOM3 Core defines mechanisms for checking for interface support,
and for obtaining implementations of interfaces, using feature
strings . [DOM3CORE]
A DOM application can use the hasFeature( feature ,
version ) method of the
DOMImplementation interface with parameter values "
HTML " and " 5.0 "
(respectively) to determine whether or not this module is supported
by the implementation. In addition to the feature string "
HTML ", the feature string " XHTML " (with version string " 5.0 ") can be
used to check if the implementation supports XHTML. User agents should respond with a true value when the
hasFeature method is queried
with these values. Authors are cautioned, however, that UAs
returning true might not be perfectly compliant, and that UAs
returning false might well have support for features in this
specification; in general, therefore, use of this method is
discouraged.
The values " HTML " and "
XHTML " (both with version " 5.0
") should also be supported in the context of the
getFeature() and isSupported() methods,
as defined by DOM3 Core.
The interfaces defined in this specification are
not always supersets of the interfaces defined in DOM2 HTML; some
features that were formerly deprecated, poorly supported, rarely
used or considered unnecessary have been removed. Therefore it is
not guaranteed that an implementation that supports " HTML " " 5.0 " also supports " HTML " " 2.0 ".
2.8.8
Exceptions
The following DOMException codes are defined in DOM
Core. [DOMCORE]
INDEX_SIZE_ERR
DOMSTRING_SIZE_ERR
HIERARCHY_REQUEST_ERR
WRONG_DOCUMENT_ERR
INVALID_CHARACTER_ERR
NO_DATA_ALLOWED_ERR
NO_MODIFICATION_ALLOWED_ERR
NOT_FOUND_ERR
NOT_SUPPORTED_ERR
INUSE_ATTRIBUTE_ERR
INVALID_STATE_ERR
SYNTAX_ERR
INVALID_MODIFICATION_ERR
NAMESPACE_ERR
INVALID_ACCESS_ERR
VALIDATION_ERR
TYPE_MISMATCH_ERR
SECURITY_ERR
NETWORK_ERR
ABORT_ERR
URL_MISMATCH_ERR
QUOTA_EXCEEDED_ERR
DATAGRID_MODEL_ERR
PARSE_ERR
SERIALISE_ERR
2.8.9
Garbage collection
There is an implied strong
reference from any DOM attribute that returns a pre-existing
object to that object.
For example, the document.location attribute means
that there is a strong reference from a Document
object to its Location object.
Similarly, there is always a strong reference from a
Document to any descendant nodes, and from any node to
its owner Document .
3 Semantics, structure, and
APIs of HTML documents
3.1
Introduction
This section is non-normative.
An introduction to marking up a document.
3.2 Documents
Every XML and HTML document in an HTML UA is represented by a
Document object. [DOM3CORE]
Document objects are assumed to be XML documents unless they are flagged as
being HTML documents when they are
created. Whether a document is an HTML document or an XML document affects the behavior of
certain APIs, as well as a few CSS rendering rules. [CSS]
A Document object created by the
createDocument() API on the
DOMImplementation object is initially an XML document , but can
be made into an HTML document by calling document.open() on it.
3.2.1
Documents in the DOM
All Document objects (in user agents implementing
this specification) must also implement
the HTMLDocument
interface, available using binding-specific methods. (This is the
case whether or not the document in question is an HTML document or
indeed whether it contains any HTML
elements at all.) Document objects must also implement the document-level interface of
any other namespaces found in the document that the UA
supports.
For example, if an HTML implementation also
supports SVG, then the Document object implements both
HTMLDocument and
SVGDocument .
Because the HTMLDocument interface is now obtained
using binding-specific casting methods instead of simply being the
primary interface of the document object, it is no longer defined
as inheriting from Document .
Since the HTMLDocument
interface holds methods and attributes related to a number of
disparate features, the members of this interface are described in
various different sections.
Returns the address of the
Document from which the user navigated to this one,
unless it was blocked or there was no such document, in which case
it returns the empty string.
The noreferrer link
type can be used to block the referrer.
The referrer attribute must
return either the current address of the
active document of the source browsing contextat the
time the navigation was started (that is, the page which
navigated the browsing context to the current document),
or the empty string if there is no such originating page, or if the
UA has been configured not to report referrers in this case, or if
the navigation was initiated for a hyperlink with a noreferrer keyword.
In the case of HTTP, the referrer DOM attribute will
match the Referer (sic) header
that was sent when fetching the
current page.
Typically user agents are configured to not report
referrers in the case where the referrer uses an encrypted protocol
and the current page does not (e.g. when navigating from an
https: page to an http:
page).
Returns the HTTP cookies that apply to the Document
. If there are no cookies or cookies can't be applied to this
resource, the empty string will be returned.
Can be set, to add a new cookie to the element's set of HTTP
cookies.
On setting, if the document is not associated with a browsing context then the user agent must
raise an INVALID_STATE_ERR exception.
Otherwise, if the sandboxed origin browsing
context flag was set on the browsing context of the
Document when the Document was created,
the user agent must raise a SECURITY_ERR exception. Otherwise, if
the document's address does
not use a server-based naming authority, it must do nothing.
Otherwise, the user agent must obtain the storage mutex and then
act as it would when processing cookies if it had just attempted to
fetchthe
document's address over HTTP, and had received a response with
a Set-Cookie header whose value was the specified
value, as per RFC 2109 sections 4.3.1, 4.3.2, and 4.3.3 or later
specifications, but without overwriting the values of HTTP-only
cookies. [RFC2109][RFC2965]
This specification does not define what makes an
HTTP-only cookie, and at the time of publication the editor is not
aware of any reference for HTTP-only cookies. They are a feature
supported by some Web browsers wherein an " httponly " parameter added to the cookie string causes
the cookie to be hidden from script.
Since the cookie
attribute is accessible across frames, the path restrictions on
cookies are only a tool to help manage which cookies are sent to
which parts of the site, and are not in any way a security
feature.
Returns the date of the last modification to the document, as
reported by the server, in the form " MM/DD/YYYY hh:mm:ss ".
If the last modification date is not known, the current time is
returned instead.
The lastModified
attribute, on getting, must return the date and time of the
Document 's source file's last modification, in the
user's local time zone, in the following format:
The month component of the date.
A U+002F SOLIDUS character ('/').
The day component of the date.
A U+002F SOLIDUS character ('/').
The year component of the date.
A U+0020 SPACE character.
The hours component of the time.
A U+003A COLON character (':').
The minutes component of the time.
A U+003A COLON character (':').
The seconds component of the time.
All the numeric components above, other than the year, must be
given as two digits in the range U+0030 DIGIT ZERO to U+0039 DIGIT
NINE representing the number in base ten, zero-padded if necessary.
The year must be given as four or more digits in the range U+0030
DIGIT ZERO to U+0039 DIGIT NINE representing the number in base
ten, zero-padded if necessary.
The Document 's source file's last modification
date and time must be derived from relevant features of the
networking protocols used, e.g. from the value of the HTTP
Last-Modified header of the document, or from
metadata in the file system for local files. If the last
modification date and time are not known, the attribute must return
the current date and time in the above format.
In a conforming document, returns the string " CSS1Compat ". (In quirks mode
documents, returns the string " BackCompat ",
but a conforming document can never trigger quirks mode .)
A Document is always set to one of three modes:
no quirks mode , the default;
quirks mode , used typically for legacy
documents; and limited quirks
mode , also known as "almost standards" mode. The mode is
only ever changed from the default by the HTML parser , based on the presence, absence, or
value of the DOCTYPE string.
The compatMode DOM
attribute must return the literal string " CSS1Compat " unless the document has been set to quirks mode by the HTML
parser , in which case it must instead return the literal
string " BackCompat ".
Returns what might be the user agent's default character
encoding.
Documents have an associated character encoding . When a
Document object is created, the document's character encoding
must be initialized to UTF-16. Various algorithms during page
loading affect this value, as does the charset setter. [IANACHARSET]
The charset DOM attribute
must, on getting, return the preferred MIME name of the document's character encoding
. On setting, if the new value is an IANA-registered alias for a
character encoding supported by the user agent, the document's character encoding
must be set to that character encoding. (Otherwise, nothing
happens.)
The characterSet DOM
attribute must, on getting, return the preferred MIME name of the
document's character
encoding .
The defaultCharset DOM
attribute must, on getting, return the preferred MIME name of a
character encoding, possibly the user's default encoding, or an
encoding associated with the user's current geographical location,
or any arbitrary encoding name.
Returns "loading" while the Document is loading,
and "complete" once it has loaded.
The readystatechange
event fires on the Document object when this value
changes.
Each document has a current
document readiness . When a Document object is
created, it must have its current document readiness set to
the string "loading" if the document is associated with an HTML parser or an XML
parser , or to the string "complete" otherwise. Various
algorithms during page loading affect this value. When the value is
set, the user agent must fire a
simple event called readystatechange at the
Document object.
A Document is said to have an active parser if it is associated with an
HTML parser or an XML parser that has not yet been stopped or aborted.
Can be set, to update the document's title. If there is no
head element , the new value is
ignored.
In SVG documents, the SVGDocument interface's
title attribute takes
precedence.
The title
element of a document is the first title element in the document (in
tree order), if there is one, or null otherwise.
The title attribute must, on
getting, run the following algorithm:
If the root element is an
svg element in the " http://www.w3.org/2000/svg " namespace, and the user
agent supports SVG, then return the value that would have been
returned by the DOM attribute of the same name on the
SVGDocument interface. [SVG]
On setting, the following algorithm must be run. Mutation events
must be fired as appropriate.
If the root element is an
svg element in the " http://www.w3.org/2000/svg " namespace, and the user
agent supports SVG, then the setter must defer to the setter for
the DOM attribute of the same name on the SVGDocument
interface (if it is readonly, then this will raise an exception).
Stop the algorithm here. [SVG]
A single Text node whose data is the new value
being assigned must be appended to the title element .
The title attribute on the HTMLDocument interface should shadow the
attribute of the same name on the SVGDocument
interface when the user agent supports both HTML and SVG. [SVG]
The body element of a
document is the first child of the
html element that is either a body element or a frameset element. If there is no such
element, it is null. If the body element is
null, then when the specification requires that events be fired at
"the body element", they must instead be fired at the
Document object.
The body attribute, on getting,
must return the body element of
the document (either a body element, a frameset element, or null). On setting, the
following algorithm must be run:
Otherwise, if the new value is the same as the body element , do nothing. Abort
these steps.
Otherwise, if the body
element is not null, then replace that element with the new
value in the DOM, as if the root element's replaceChild() method had been called with the new value
and the
incumbent body element as its two arguments respectively, then
abort these steps.
Otherwise, the the body
element is null. Append the new value to the root element.
The images attribute must
return an HTMLCollection rooted at the
Document node, whose filter matches only
img elements.
The embeds attribute must
return an HTMLCollection rooted at the
Document node, whose filter matches only
embed elements.
The plugins attribute must
return the same object as that returned by the embeds attribute.
The links attribute must return
an HTMLCollection
rooted at the Document node, whose filter matches only
a elements with
href attributes and
area elements with
href attributes.
The forms attribute must return
an HTMLCollection
rooted at the Document node, whose filter matches only
form elements.
The scripts attribute must
return an HTMLCollection rooted at the
Document node, whose filter matches only
script elements.
Returns a NodeList of the elements in the object on
which the method was invoked (a Document or an
Element ) that have all the classes given by
classes .
The classes argument is interpreted as a
space-separated list of classes.
The getElementsByClassName(
classNames ) method takes a string
that contains an unordered set of
unique space-separated tokens representing classes. When
called, the method must return a live NodeList object
containing all the elements in the document, in tree order , that have all the classes specified
in that argument, having obtained the classes by splitting a string on spaces . If
there are no tokens specified in the argument, then the method must
return an empty NodeList . If the document is in
quirks mode , then the comparisons for
the classes must be done in an ASCII case-insensitive manner,
otherwise, the comparisons must be done in a case-sensitive manner.
The getElementsByClassName(
classNames ) method on the
HTMLElement interface must
return a live NodeList with the nodes that the
HTMLDocumentgetElementsByClassName()
method would return when passed the same argument(s), excluding any
elements that are not descendants of the HTMLElement object on which the method
was invoked.
HTML, SVG, and MathML elements define which classes they are in
by having an attribute in the per-element partition with the name
class containing a space-separated list of
classes to which the element belongs. Other specifications may also
allow elements in their namespaces to be labeled as being in
specific classes.
A call to
document.getElementById('example').getElementsByClassName('aaa')
would return a NodeList with the two paragraphs
p1 and p2 in it.
A call to getElementsByClassName('ccc bbb')
would only return one node, however, namely p3 . A
call to
document.getElementById('example').getElementsByClassName('bbb ccc ')
would return the same thing.
A call to getElementsByClassName('aaa,bbb') would
return no nodes; none of the elements above are in the "aaa,bbb"
class.
The HTMLDocument
interface supports named
properties . The names of the supported named
properties at any moment consist of the values of the
name content attributes of all the
applet ,
embed ,
form , iframe , img , and fallback-freeobject elements in the
Document that have name
content attributes, and the values of the id content
attributes of all the applet and fallback-freeobject elements in the
Document that have id content attributes, and the
values of the id content attributes of all the
img elements in the
Document that have both name content attributes and id content
attributes.
When the HTMLDocument object is
indexed for property retrieval using a name name , then the user agent must return the value obtained
using the following steps:
Let elements be the list of named elements with the name
name in the Document .
There will be at least one such element, by
definition.
If elements has only one element, and that
element is an iframe
element, then return the WindowProxy object of the nested browsing context represented
by that iframe
element, and abort these steps.
Otherwise, if elements has only one element,
return that element and abort these steps.
Otherwise return an HTMLCollection rooted at the
Document node, whose filter matches only named elements with the name
name .
Named elements with the name
name , for the purposes of the above algorithm,
are those that are either:
img elements that
have an id content attribute whose value is
name , and that have a name content attribute present also.
An object element
is said to be fallback-free if it has
no object or
embed
descendants.
The dir attribute on the HTMLDocument interface is defined along
with the dir content attribute.
3.3 Elements
3.3.1
Semantics
Elements, attributes, and attribute values in HTML are defined
(by this specification) to have certain meanings (semantics). For
example, the ol element
represents an ordered list, and the lang attribute
represents the language of the content.
Authors must not use elements, attributes, and attribute values
for purposes other than their appropriate intended semantic
purpose. Authors must not use elements, attributes, and attribute
values that are not permitted by this specification or other
applicable specifications.
For example, the following document is non-conforming, despite
being syntactically correct:
<!DOCTYPE html>
<html lang="en-GB">
<head> <title> Demonstration </title> </head>
<body>
<table>
<tr> <td> My favourite animal is the cat. </td> </tr>
<tr>
<td>
—<a href="http://example.org/~ernest/"><cite>Ernest</cite></a>,
in an essay from 1992
</td>
</tr>
</table>
</body>
</html>
...because the data placed in the cells is clearly not tabular
data (and the cite
element mis-used). A corrected version of this document might
be:
<!DOCTYPE html>
<html lang="en-GB">
<head> <title> Demonstration </title> </head>
<body>
<blockquote>
<p> My favourite animal is the cat. </p>
</blockquote>
<p>
—<a href="http://example.org/~ernest/">Ernest</a>,
in an essay from 1992
</p>
</body>
</html>
This next document fragment, intended to represent the heading
of a corporate site, is similarly non-conforming because the second
line is not intended to be a heading of a subsection, but merely a
subheading or subtitle (a subordinate heading for the same
section).
<body>
<h1>ABC Company</h1>
<h2>Leading the way in widget design since 1432</h2>
...
The hgroup
element should be used in these kinds of situations:
<body>
<hgroup>
<h1>ABC Company</h1>
<h2>Leading the way in widget design since 1432</h2>
</hgroup>
...
In the next example, there is a non-conforming attribute value
("carpet") and a non-conforming attribute ("texture"), which is not
permitted by this specification:
Through scripting and using other mechanisms, the values of
attributes, text, and indeed the entire structure of the document
may change dynamically while a user agent is processing it. The
semantics of a document at an instant in time are those represented
by the state of the document at that instant in time, and the
semantics of a document can therefore change over time. User agents
must update their presentation of the
document as this occurs.
HTML has a progress element that describes
a progress bar. If its "value" attribute is dynamically updated by
a script, the UA would update the rendering to show the progress
changing.
3.3.2
Elements in the DOM
The nodes representing HTML
elements in the DOM must implement,
and expose to scripts, the interfaces listed for them in the
relevant sections of this specification. This includes HTML elements in XML
documents , even when those documents are in another context
(e.g. inside an XSLT transform).
Elements in the DOM represent things; that is, they have intrinsic
meaning , also known as semantics.
For example, an ol element represents an ordered
list.
The basic interface, from which all the HTML elements ' interfaces inherit,
and which must be used by elements that have no
additional requirements, is the HTMLElement interface.
The HTMLElement
interface holds methods and attributes related to a number of
disparate features, and the members of this interface are therefore
described in various different sections of this specification.
3.3.3
Global attributes
The following attributes are common to and may be specified on
all HTML elements(even those not defined in this specification) :
The attributes marked with an asterisk cannot be
specified on body
elements as those elements expose event handler attributes of the
Window object with the same
names.
Also, custom data attributes (e.g.
data-foldername or data-msgid ) can be specified on any HTML element , to store
custom data specific to the page.
In HTML documents , elements in
the HTML namespace may have an
xmlns attribute specified, if, and only if,
it has the exact value " http://www.w3.org/1999/xhtml
". This does not apply to XML
documents .
In HTML, the xmlns attribute
has absolutely no effect. It is basically a talisman. It is allowed
merely to make migration to and from XHTML mildly easier. When
parsed by an HTML parser , the attribute
ends up in no namespace, not the "
http://www.w3.org/2000/xmlns/ " namespace like
namespace declaration attributes in XML do.
In XML, an xmlns attribute is
part of the namespace declaration mechanism, and an element cannot
actually have an xmlns attribute in no
namespace specified.
3.3.3.1 The
id attribute
The id attribute represents its element's unique identifier. The
value must be unique in the element's home
subtree and must contain at least one character. The value must
not contain any space characters .
If the value is not the empty string, user agents must associate
the element with the given value (exactly, including any space
characters) for the purposes of ID matching within the element's
home subtree (e.g. for selectors in CSS
or for the getElementById() method in the DOM).
Identifiers are opaque strings. Particular meanings should not
be derived from the value of the id attribute.
This specification doesn't preclude an element having multiple
IDs, if other mechanisms (e.g. DOM Core methods) can set an
element's ID in a way that doesn't conflict with the id attribute.
The id DOM
attribute must reflect the id content
attribute.
3.3.3.2 The
title attribute
The title attribute represents advisory information for the element,
such as would be appropriate for a tooltip. On a link, this could
be the title or a description of the target resource; on an image,
it could be the image credit or a description of the image; on a
paragraph, it could be a footnote or commentary on the text; on a
citation, it could be further information about the source; and so
forth. The value is text.
If this attribute is omitted from an element, then it implies
that the title attribute of the nearest
ancestor HTML
element with a title attribute set is also
relevant to this element. Setting the attribute overrides this,
explicitly stating that the advisory information of any ancestors
is not relevant to this element. Setting the attribute to the empty
string indicates that the element has no advisory information.
If the title attribute's value contains
U+000A LINE FEED (LF) characters, the content is split into
multiple lines. Each U+000A LINE FEED (LF) character represents a
line break.
Caution is advised with respect to the use of newlines in
title attributes.
For instance, the following snippet actually defines an
abbreviation's expansion with a line break in it :
<p>My logs show that there was some interest in <abbr title="Hypertext
Transport
Protocol">HTTP</abbr>
today.</p>
Some elements, such as link , abbr , and input , define additional semantics
for the title attribute beyond the
semantics described above.
The title DOM attribute must reflect the title content attribute.
The lang attribute (in no namespace)
specifies the primary language for the
element's contents and for any of the element's attributes that
contain text. Its value must be a valid RFC 3066 language code, or
the empty string. [RFC3066]
If these attributes are omitted from an element, then the
language of this element is the same as the language of its parent
element, if any. Setting the attribute to the empty string
indicates that the primary language is unknown.
The lang
attribute in no namespace may be used on any HTML element .
Authors must not use the lang attribute in the
XML namespace in HTML
documents . To ease migration to and from XHTML, authors may
specify an attribute in no namespace with no prefix and with the
literal localname " xml:lang " on HTML elements in HTML documents , but such attributes must
only be specified if a lang attribute in no namespace is also
specified, and both attributes must have the same value when
compared in an ASCII
case-insensitive manner.
To determine the language of a node, user agents must look at
the nearest ancestor element (including the element itself if the
node is an element) that has a lang attribute in the
XML namespace set or is an HTML element and has a
lang in no
namespace attribute set. That attribute specifies the language of
the node.
If there is no document-wide default
language , then language information from a higher-level
protocol (such as HTTP), if any, must be used as the final fallback
language. In the absence of any language information, the default
value is unknown (the empty string).
If the resulting value is not a recognized language code, then
it must be treated as an unknown language (as if the value was the
empty string).
User agents may use the element's language to determine proper
processing or rendering (e.g. in the selection of appropriate fonts
or pronunciations, or for dictionary selection).
The lang
DOM attribute must reflect the lang content attribute
in no namespace.
The dir attribute specifies the
element's text directionality. The attribute is an enumerated attribute with the keyword
ltr mapping to the state ltr , and the
keyword rtl mapping to the state rtl .
The attribute has no defaults.
The processing of this attribute is primarily performed by the
presentation layer. For example, the rendering section in this
specification defines a mapping from this attribute to the CSS
'direction' and 'unicode-bidi' properties, and CSS defines
rendering in terms of those properties.
The directionality of an
element, which is used in particular by the canvas element's text rendering
API, is either 'ltr' or 'rtl'. If the user agent supports CSS and
the 'direction' property on this element has a computed value of
either 'ltr' or 'rtl', then that is the directionality of the element.
Otherwise, if the element is being rendered, then the directionality of the element is the
directionality used by the presentation layer, potentially
determined from the value of the dir attribute on the element.
Otherwise, if the element's dir attribute has the state
ltr , the element's directionality is 'ltr' (left-to-right);
if the attribute has the state rtl , the element's
directionality is 'rtl' (right-to-left); and otherwise, the
element's directionality is the same as its parent element, or
'ltr' if there is no parent element.
Authors are strongly encouraged to use the
dir
attribute to indicate text direction rather than using CSS, since
that way their documents will continue to render correctly even in
the absence of CSS (e.g. as interpreted by search engines).
The classes that an HTML element has assigned to it consists of all
the classes returned when the value of the class attribute is
split on spaces .
Assigning classes to an element affects class
matching in selectors in CSS, the getElementsByClassName()
method in the DOM, and other such features.
Authors may use any value in the class attribute, but are
encouraged to use the values that describe the nature of the
content, rather than values that describe the desired presentation
of the content.
The className and classList
DOM attributes must both reflect the
class
content attribute.
3.3.3.7 The
style attribute
All elements may have the style content attribute set. If
specified, the attribute must contain only a list of zero or more
semicolon-separated (;) CSS declarations. [CSS]
In user agents that support CSS, the attribute's value must be
parsed when the attribute is added or has its value changed, with
its value treated as the body (the part inside the curly brackets)
of a declaration block in a rule whose selector matches just the
element on which the attribute is set. All URLs in the value must be resolved relative to the element when the
attribute is parsed. For the purposes of the CSS cascade, the
attribute must be considered to be a 'style' attribute at the
author level.
Documents that use style attributes on any of their
elements must still be comprehensible and usable if those
attributes were removed.
In particular, using the style
attribute to hide and show content, or to convey meaning that is
otherwise not included in the document, is non-conforming. (To hide
and show content, use the hidden attribute.)
Returns a CSSStyleDeclaration object for the
element's style attribute.
The style DOM attribute must return a
CSSStyleDeclaration whose value represents the
declarations specified in the attribute, if present. Mutating the
CSSStyleDeclaration object must create a style attribute on the element (if there
isn't one already) and then change its value to be a value
representing the serialized form of the
CSSStyleDeclaration object. [CSSOM]
In the following example, the words that refer to colors are
marked up using the span element and the style
attribute to make those words show up in the relevant colors in
visual media.
<p>My sweat suit is <span style="color: green; background:
transparent">green</span> and my eyes are <span style="color: blue;
background:
transparent">blue</span>.</p>
3.3.3.8 Embedding custom non-visible
data
A custom data attribute is
an attribute in no namespace whose name starts with the string "
data-
", has at least one character after the hyphen, is XML-compatible , and contains no characters
in the range U+0041 .. U+005A (LATIN CAPITAL LETTER A .. LATIN
CAPITAL LETTER Z).
All attributes in HTML
documents get lowercased automatically, so the restriction on
uppercase letters doesn't affect such documents.
Custom data attributes are intended to
store custom data private to the page or application, for which
there are no more appropriate attributes or elements.
These attributes are not intended for use by software that is
independent of the site that uses the attributes.
For instance, a site about music could annotate list items
representing tracks in an album with custom data attributes
containing the length of each track. This information could then be
used by the site itself to allow the user to sort the list by track
length, or to filter the list for tracks of certain lengths.
<ol>
<li data-length="2m11s">Beyond The Sea</li>
...
</ol>
It would be inappropriate, however, for the user to use generic
software not associated with that music site to search for tracks
of a certain length by looking at this data.
This is because these attributes are intended for use by the
site's own scripts, and are not a generic extension mechanism for
publicly-usable metadata.
The dataset DOM attribute provides
convenient accessors for all the data-* attributes on an element. On
getting, the dataset DOM attribute must return a
DOMStringMap object,
associated with the following algorithms, which expose these
attributes on their element:
The algorithm for getting the list of name-value pairs
Let list be an empty list of name-value
pairs.
For each content attribute on the element whose first five
characters are the string " data- ", add a
name-value pair to list whose name is the
attribute's name with the first five character removed and whose
value is the attribute's value.
Return list .
The algorithm for setting names to certain values
Let name be the concatenation of the string
data- and the name passed to the
algorithm.
Let value be the value passed to the
algorithm.
Set the value of the attribute with the name name , to the value value , replacing
any previous value if the attribute already existed. If
setAttribute() would have raised an exception
when setting an attribute with the name name ,
then this must raise the same exception.
The algorithm for deleting names
Let name be the concatenation of the string
data- and the name passed to the
algorithm.
Remove the attribute with the name name ,
if such an attribute exists. Do nothing otherwise.
If a Web page wanted an element to represent a space ship, e.g.
as part of a game, it would have to use the class attribute along with data-*
attributes:
Authors should carefully design such extensions so that when the
attributes are ignored and any associated CSS dropped, the page is
still usable.
User agents must not derive any implementation behavior from
these attributes or values. Specifications intended for user agents
must not define these attributes to have any meaningful values.
3.4 Content
models
All the elements in this specification have a defined content
model, which describes what nodes are allowed inside the elements,
and thus what the structure of an HTML document or fragment must
look like.
The space
characters are always allowed between elements. User agents
represent these characters between elements in the source markup as
text nodes in the DOM. Empty text nodes and text nodes consisting of just sequences of those
characters are considered inter-element whitespace .
Inter-element whitespace
, comment nodes, and processing instruction nodes must be ignored
when establishing whether an element matches its content model or
not, and must be ignored when following algorithms that define
document and element semantics.
An element A is said to be preceded or followed by a second
element B if A and
B have the same parent node and there are no
other element nodes or text nodes (other than inter-element whitespace ) between
them.
Authors must not use elements in the HTML
namespace anywhere except where they are explicitly allowed, as
defined for each element, or as explicitly required by other
specifications. For XML compound documents, these contexts could be
inside elements from other namespaces, if those elements are
defined as providing the relevant contexts.
The Atom specification defines the Atom content element, when its type
attribute has the value xhtml , as requiring
that it contains a single HTML div element. Thus, a div element is allowed in that
context, even though this is not explicitly normatively stated by
this specification. [ATOM]
For example, creating a td element and storing it in a global
variable in a script is conforming, even though td elements are otherwise only
supposed to be used inside tr elements.
var data = {
name: "Banana",
cell: document.createElement('td'),
};
3.4.1 Kinds of
content
Each element in HTML falls into zero or more categories that
group elements with similar characteristics together. The following
broad categories are used in this specification:
In addition, certain elements are categorized as form-associated elements and further
subcategorized to define their role in various form-related
processing models.
Some elements have unique requirements and do not fit into any
particular category.
3.4.1.1
Metadata content
Metadata content is content
that sets up the presentation or behavior of the rest of the
content, or that sets up the relationship of the document with
other documents, or that conveys other "out of band"
information.
Elements from other namespaces whose semantics are primarily
metadata-related (e.g. RDF) are also metadata content .
Thus, in the XML serialization, one can use RDF, like this:
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:r="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<head>
<title>Hedral's Home Page</title>
<r:RDF>
<Person xmlns="http://www.w3.org/2000/10/swap/pim/contact#"
r:about="http://hedral.example.com/#">
<fullName>Cat Hedral</fullName>
<mailbox r:resource="mailto:hedral@damowmow.com"/>
<personalTitle>Sir</personalTitle>
</Person>
</r:RDF>
</head>
<body>
<h1>My home page</h1>
<p>I like playing with string, I guess. Sister says squirrels are fun
too so sometimes I follow her to play with them.</p>
</body>
</html>
This isn't possible in the HTML serialization, however.
3.4.1.2 Flow
content
Most elements that are used in the body of documents and
applications are categorized as flow
content .
As a general rule, elements whose content model allows any
flow content should have either at
least one descendant text node that is not
inter-element whitespace ,
or at least one descendant element node that is embedded content . For the purposes of
this requirement, del
elements and their descendants must not be counted as contributing
to the ancestors of the del element.
This requirement is not a hard requirement, however, as there
are many cases where an element can be empty legitimately, for
example when it is used as a placeholder which will later be filled
in by a script, or when the element is part of a template and would
on most pages be filled in but on some pages is not relevant.
3.4.1.3
Sectioning content
Sectioning content is
content that defines the scope of headings and footers .
Heading content defines the
header of a section (whether explicitly marked up using sectioning content elements, or implied
by the heading content itself).
Phrasing content is the text
of the document, as well as elements that mark up that text at the
intra-paragraph level. Runs of phrasing content form paragraphs .
As a general rule, elements whose content model allows any
phrasing content should have
either at least one descendant text node
that is not inter-element
whitespace , or at least one descendant element node that is
embedded content . For the
purposes of this requirement, nodes that are descendants of
del elements must not
be counted as contributing to the ancestors of the del element.
Most elements that are categorized as phrasing
content can only contain elements that are themselves categorized
as phrasing content, not any flow content.
Elements that are from namespaces other than the HTML namespace and that convey content but
not metadata, are embedded
content for the purposes of the content models defined in this
specification. (For example, MathML, or SVG.)
Some embedded content elements can have fallback content : content that is to be
used when the external resource cannot be used (e.g. because it is
of an unsupported format). The element definitions state what the
fallback is, if any.
3.4.1.7
Interactive content
Interactive content is
content that is specifically intended for user interaction.
Certain elements in HTML have an activation behavior , which means that
the user can activate them. This triggers a sequence of events
dependent on the activation mechanism, and normally culminating in
a click event followed by a
DOMActivate event
, as described below .
The user agent should allow the user to manually trigger
elements that have an activation
behavior , for instance using keyboard or voice input, or
through mouse clicks. When the user triggers an element with a
defined activation behavior in a
manner other than clicking it, the default action of the
interaction event must be to run synthetic click
activation steps on the element.
If there is an element e , then the default
action of the click event must be
to run post-click
activation steps on element e .
If there is an element e but the event is
canceled, the user agent must run canceled activation steps
on element e .
The above doesn't happen for arbitrary synthetic
events dispatched by author script. However, the click() method can be
used to make it happen programmatically.
When a user agent is to run pre-click activation
steps on an element, it must run the pre-click activation steps
defined for that element, if any.
When a user agent is to run post-click activation
steps on an element, the user agent must fire a simple event called DOMActivate that is cancelable at that
element. The default action of this event must be to run final activation steps on
that element. If the event is canceled, the user agent must
run canceled activation
steps on the element instead.
When a user agent is to run canceled activation steps
on an element, it must run the canceled activation steps defined
for that element, if any.
When a user agent is to run
final activation steps on an element, it must run the
activation behavior defined for
that element. Activation behaviors can refer to the click and DOMActivate events that were fired by
the steps above leading up to this point.
3.4.2 Transparent content models
Some elements are described as transparent ; they have "transparent" in the
description of their content model.
When a content model includes a part that is "transparent",
those parts must not contain content that would not be conformant
if all transparent elements in the tree were replaced, in their
parent element, by the children in the "transparent" part of their
content model, retaining order.
When a transparent element has no parent, then the part of its
content model that is "transparent" must instead be treated as
accepting any flow content .
3.5 Paragraphs
The term paragraph as
defined in this section is distinct from (though related to) the
p element defined later.
The paragraph concept defined here is used
to describe how to interpret documents.
A paragraph is typically a run of
phrasing content that forms a
block of text with one or more sentences that discuss a particular
topic, as in typography, but can also be used for more general
thematic grouping. For instance, an address is also a paragraph, as
is a part of a form, a byline, or a stanza in a poem.
In the following example, there are two paragraphs in a section.
There is also a heading, which contains phrasing content that is
not a paragraph. Note how the comments and inter-element whitespace do not
form paragraphs.
<section>
<h1>Example of paragraphs</h1>
This is the <em>first</em> paragraph in this example.
<p>This is the second.</p>
<!-- This is not a paragraph. -->
</section>
Paragraphs in flow content are
defined relative to what the document looks like without the
a , ins , del , and map elements complicating matters,
since those elements, with their hybrid content models, can
straddle paragraph boundaries, as shown in the first two examples
below.
Generally, having elements straddle paragraph
boundaries is best avoided. Maintaining such markup can be
difficult.
The following example takes the markup from the earlier example
and puts ins and
del elements around
some of the markup to show that the text was changed (though in
this case, the changes admittedly don't make much sense). Notice
how this example has exactly the same paragraphs as the previous
one, despite the ins
and del elements — the
ins element straddles
the heading and the first paragraph, and the del element straddles the boundary
between the two paragraphs.
<section>
<ins><h1>Example of paragraphs</h1>
This is the <em>first</em> paragraph in</ins> this example<del>.
<p>This is the second.</p></del>
<!-- This is not a paragraph. -->
</section>
Let view be a view of the DOM that replaces
all a , ins , del , and map elements in the document with
their contents. Then, in view , for each run of
sibling phrasing content nodes
uninterrupted by other types of content, in an element that accepts
content other than phrasing
content , let first be the first node of
the run, and let last be the last node of the
run. For each such run that consists of at least one node that is
neither embedded content nor
inter-element whitespace ,
a paragraph exists in the original DOM from immediately before
first to immediately after last . (Paragraphs can thus span across a , ins , del , and map elements.)
Conformance checkers may warn authors of cases where they have
paragraphs that overlap each other (this can happen with
object ,
video , audio , and canvas elements).
A paragraph is also formed explicitly
by p elements.
The p
element can be used to wrap individual paragraphs when there would
otherwise not be any content other than phrasing content to
separate the paragraphs from each other.
In the following example, the link spans half of the first
paragraph, all of the heading separating the two paragraphs, and
half of the second paragraph. It straddles the paragraphs and the
heading.
<aside>
Welcome!
<a href="about.html">
This is home of...
<h1>The Falcons!</h1>
The Lockheed Martin multirole jet fighter aircraft!
</a>
This page discusses the F-16 Fighting Falcon's innermost secrets.
</aside>
Here is another way of marking this up, this time showing the
paragraphs explicitly, and splitting the one link element into
three:
<aside>
<p>Welcome! <a href="about.html">This is home of...</a></p>
<h1><a href="about.html">The Falcons!</a></h1>
<p><a href="about.html">The Lockheed Martin multirole jet
fighter aircraft!</a> This page discusses the F-16 Fighting
Falcon's innermost secrets.</p>
</aside>
It is possible for paragraphs to overlap when using certain
elements that define fallback content. For example, in the
following section:
<section>
<h1>My Cats</h1>
You can play with my cat simulator.
<object data="cats.sim">
To see the cat simulator, use one of the following links:
<ul>
<li><a href="cats.sim">Download simulator file</a>
<li><a href="http://sims.example.com/watch?v=LYds5xY4INU">Use online simulator</a>
</ul>
Alternatively, upgrade to the Mellblom Browser.
</object>
I'm quite proud of it.
</section>
There are five paragraphs:
The paragraph that says "You can play with my cat simulator.
object I'm quite proud of it.", where object is the object element.
The paragraph that says "To see the cat simulator, use one of
the following links:".
The paragraph that says "Download simulator file".
The paragraph that says "Use online simulator".
The paragraph that says "Alternatively, upgrade to the Mellblom
Browser.".
The first paragraph is overlapped by the other four. A user
agent that supports the "cats.sim" resource will only show the
first one, but a user agent that shows the fallback will
confusingly show the first sentence of the first paragraph as if it
was in the same paragraph as the second one, and will show the last
paragraph as if it was at the start of the second sentence of the
first paragraph.
To avoid this confusion, explicit p elements can be used.
3.6 APIs
in HTML documents
For HTML documents , and for
HTML elements in HTML documents , certain APIs defined in DOM3
Core become case-insensitive or case-changing, as sometimes defined
in DOM3 Core, and as summarized or
required below. [DOM3CORE] .
These attributes must return element
names converted to ASCII
uppercase , regardless of the case with which they were
created.
Document.createElement()
The canonical form of HTML markup is all-lowercase; thus, this
method will lowercase the argument before
creating the requisite element. Also, the
element created must be in the HTML
namespace .
This doesn't apply to Document.createElementNS() . Thus, it is possible, by
passing this last method a tag name in the wrong case, to create an
element that claims to have the tag name of an element defined in
this specification, but doesn't support its interfaces, because it
really has another tag name not accessible from the DOM APIs.
Specifically: when an attribute is set on an HTML element using
Element.setAttribute() , the name argument
must be converted to ASCII
lowercase before the element is affected; and when an
Attr node is set on an HTML element using Element.setAttributeNode() , it must have its name
converted to ASCII
lowercase before the element is affected.
This doesn't apply to Document.setAttributeNS() and Document.setAttributeNodeNS() .
Specifically: When the Element.getAttribute() method or the Element.getAttributeNode() method is invoked on an
HTML element ,
the name argument must be converted to ASCII lowercase
before the element's attributes are examined.
This doesn't apply to Document.getAttributeNS() and Document.getAttributeNodeNS() .
Document.getElementsByTagName()
Element.getElementsByTagName()
HTML elements match by lower-casing the argument before
comparison, elements from other namespaces are treated as in XML
(case-sensitively).
Specifically, these methods (but not their namespaced
counterparts) must compare the given argument in a case-sensitive manner, but when looking at
HTML elements ,
the argument must first be converted to ASCII lowercase
.
Thus, in an HTML document with nodes in multiple
namespaces, these methods will effectively be both case-sensitive
and case-insensitive at the same time.
3.7 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) are affected as follows:
In addition to the cases where a name expression would match a
node per XPath 1.0, a name expression must evaluate to matching a
node when all the following conditions are also met:
The name expression has no namespace.
The name expression has local name that is a match for
local .
The expression is being tested against an element node.
These requirements are 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]
3.8
Dynamic markup insertion
APIs for dynamically inserting markup into the
document interact with the parser, and thus their behavior, varies
depending on whether they are used with HTML documents (and the HTML parser ) or XHTML in XML documents (and the XML parser ).
3.8.1 Controlling the input stream
The open() method comes in
several variants with different numbers of arguments.
document = document .
open ( [ type
[, replace ] ] )
Causes the Document to be replaced in-place, as if
it was a new Document object, but reusing the previous
object, which is then returned.
If the type argument is omitted or has the
value " text/html ", then the resulting
Document has an HTML parser associated with it, which
can be given data to parse using document.write() . Otherwise, all
content passed to document.write() will be parsed as
plain text.
If the replace argument is absent or false,
a new entry is added to the session history to represent this
entry, and the previous entries for this Document are
all collapsed into one entry with a new Document
object.
The method has no effect if the Document is still
being parsed.
window = document .
open ( url ,
name , features [,
replace ] )
Closes the input stream that was opened by the document.open() method.
When called with two or fewer arguments, the method must act as
follows:
Let type be the value of the first argument,
if there is one, or " text/html " otherwise.
Let replace be true if there is a second
argument and it is an ASCII
case-insensitive match for the value "replace", and false
otherwise.
If the document has an active
parser that isn't a script-created parser , and the
insertion point associated with that
parser's input stream is not
undefined (that is, it does point to somewhere in the
input stream), then the method does nothing. Abort these steps and
return the Document object on which the method was
invoked.
This basically causes document.open() to be ignored when
it's called in an inline script found during the parsing of data
sent over the network, while still letting it have an effect when
called asynchronously or on a document that is itself being
spoon-fed using these APIs.
If the document has an active
parser , then abort that parser, and throw away any pending
content in the input stream .
Unregister all event listeners registered on the
Document node and its descendants.
Remove any tasks associated with the Document
in any task source .
Remove all child nodes of the document, without firing any
mutation events.
Replace the Document 's singleton objects with new
instances of those objects. (This includes in particular the
Window , Location , History , ApplicationCache , UndoManager , Navigator , and Selection objects, the various
BarProp objects, the two
Storage objects, and the various HTMLCollection objects. It also
includes all the Web IDL prototypes in the JavaScript binding,
including the Document object's prototype.)
Create a new HTML parser and
associate it with the document. This is a script-created parser (meaning that
it can be closed by the document.open() and document.close() methods, and that
the tokenizer will wait for an explicit call to document.close() before emitting
an end-of-file token). The encoding confidence is irrelevant
.
Mark the document as being an HTML document (it might already be
so-marked).
If the type string contains a U+003B
SEMICOLON (;) character, remove the first such character and all
characters from it up to the end of the string.
Remove any earlier entries that share the same
Document
Add a new entry just before the last entry that is associated
with the text that was parsed by the previous parser associated
with the Document object, as well as the state of the
document at the start of these steps. (This allows the user to step
backwards in the session history to see the page before it was
blown away by the document.open() call.)
Finally, set the insertion point
to point at just before the end of the input stream (which at this point will be
empty).
Return the Document on which the method was
invoked.
When called with three or more arguments, the open()
method on the HTMLDocument
object must call the open() method on the Window object of the HTMLDocument object, with the same
arguments as the original call to the open()
method, and return whatever that method returned. If the
HTMLDocument object has no
Window object, then the method
must raise an INVALID_ACCESS_ERR exception.
The close() method must do
nothing if there is no script-created parser associated with
the document. If there is such a parser, then, when the method is
called, the user agent must insert an explicit "EOF" character at the end
of the parser's input stream .
Otherwise, the tokenizer must process the characters that were
inserted, one at a time, processing resulting tokens as they are
emitted, and stopping when the tokenizer reaches the insertion
point or when the processing of the tokenizer is aborted by the
tree construction stage (this can happen if a script end tag token is emitted by the
tokenizer).
The document.writeln(...)
method, when invoked, must act as if the document.write() method had been
invoked with the same argument(s), plus an extra argument
consisting of a string containing a single line feed character
(U+000A).
Returns a fragment of HTML or XML that represents the element's
contents.
Can be set, to replace the contents of the element with nodes
parsed from the given string.
In the case of XML documents , will
throw a SYNTAX_ERR if the
element cannot be serialized to XML, or if the given string is not
well-formed.
On getting, if the node's document is an HTML document , then
the attribute must return the result of running the HTML fragment
serialization algorithm on the node; otherwise, the node's
document is an XML
document , and the attribute must return the result of running
the XML fragment
serialization algorithm on the node instead (this might raise
an exception instead of returning a string).
In either case, the algorithm must be invoked with the string
being assigned into the innerHTML attribute as the input . If the node is an Element node, then,
in addition, that element must be passed as the context element.
If this raises an exception, then abort these steps.
Otherwise, let new children be the nodes
returned.
If the attribute is being set on a Document node,
and that document has an active parser
, then abort that parser.
Remove the child nodes of the node whose innerHTML
attribute is being set, firing appropriate mutation events.
If the attribute is being set on a Document node,
let target document be that
Document node. Otherwise, the attribute is being set
on an Element node; let target
document be the ownerDocument of that
Element .
Set the ownerDocument of all the nodes in
new children to the target
document .
Append all the new children nodes to the
node whose innerHTML attribute is being set,
preserving their order, and firing mutation events as
appropriate.
Returns a fragment of HTML or XML that represents the element
and its contents.
Can be set, to replace the element with nodes parsed from the
given string.
In the case of XML documents , will
throw a SYNTAX_ERR if the
element cannot be serialized to XML, or if the given string is not
well-formed.
On getting, if the node's document is an HTML document , then
the attribute must return the result of running the HTML fragment
serialization algorithm on a fictional node whose only child is
the node on which the attribute was invoked; otherwise, the node's
document is an XML
document , and the attribute must return the result of running
the XML fragment
serialization algorithm on that fictional node instead (this
might raise an exception instead of returning a string).
On setting, the following steps must be run:
Let target be the element whose outerHTML
attribute is being set.
If target has no parent node, then abort
these steps. There would be no way to obtain a reference to the
nodes created even if the remaining steps were run.
If target 's parent node is a
Document object, throw a NO_MODIFICATION_ALLOWED_ERR
exception and abort these steps.
Let parent be target 's
parent node, unless that is a DocumentFragment node,
in which case let parent be an arbitrary
body element.
In either case, the algorithm must be invoked with the string
being assigned into the outerHTML attribute as the input , and parent as the context element.
If this raises an exception, then abort these steps.
Otherwise, let new children be target s returned.
Set the ownerDocument of all the nodes in
new children to target 's
document.
Remove target from its parent node, firing
mutation events as appropriate, and then insert in its place all
the new children nodes, preserving their order,
and again firing mutation events as appropriate.
The html element
represents the root of an HTML
document.
The manifest attribute gives
the address of the document's application cachemanifest , if there is one. If the
attribute is present, the attribute's value must be a valid URL .
The manifest attribute only has an
effect during the early stages of document load. Changing the
attribute dynamically thus has no effect (and thus, no DOM API is
provided for this attribute).
The title element
represents the document's title or name.
Authors should use titles that identify their documents even when
they are used out of context, for example in a user's history or
bookmarks, or in search results. The document's title is often
different from its first heading, since the first heading does not
have to stand alone when taken out of context.
There must be no more than one title element per document.
The text DOM attribute must return
the same value as the textContent DOM attribute on the
element.
Here are some examples of appropriate titles, contrasted with
the top-level headings that might be used on those same pages.
<title>Introduction to The Mating Rituals of Bees</title>
...
<h1>Introduction</h1>
<p>This companion guide to the highly successful
<cite>Introduction to Medieval Bee-Keeping</cite> book is...
The next page might be a part of the same site. Note how the
title describes the subject matter unambiguously, while the first
heading assumes the reader knows what the context is and therefore
won't wonder if the dances are Salsa or Waltz:
<title>Dances used during bee mating rituals</title>
...
<h1>The
Dances</h1>
The string to use as the document's title is given by the
document.title DOM attribute.
User agents should use the document's title when
referring to the document in their user interface.
There must be no more than one base element per document.
A base element must
have either an href attribute, a target
attribute, or both.
The href content attribute, if
specified, must contain a valid URL .
A base element, if
it has an href attribute, must come before any
other elements in the tree that have attributes defined as taking
URLs , except the html element (its
