Publication as a Editor's Draft does not imply endorsement by the W3C Membership. この文書は草案であり、いつでも更新、他の文書による置き換えや廃止扱いにされうる。進行中の作業以外のものとしてこの文書を引用することは不適切である。
この仕様は、この仕様で定義された機能を使用する文書およびスクリプトの著者を対象としている, implementors of tools that operate on pages that use the features defined in this specification, and individuals wishing to establish the correctness of documents or implementations with respect to the requirements of this specification。
長年にわたり、両グループは、Ian Hicksonの下で一緒に働いてきた。2011年、グループは、異なる目標を持っているという結論に達した。WHATWGは継続的に仕様を維持し、新機能を追加し、HTML Living Standardの作業を続行したいとする一方で、W3CはHTML5勧告の機能に対して、一区切りつけたいというものである。2012年中旬、新しいエディタチームはHTML5勧告の作成を引き受け、次のHTMLバージョンへのワーキングドラフトを準備することをW3Cで始めた。
著者は、リンクタイプの定義済みセットの拡張を登録することにより、特定の意味を持つリンクに注釈を付けるrel=""メカニズムを使用できる。これは、マイクロフォーマットでも使用される。さらに、非ASCII文字を一切含まず、U+0041（LATIN CAPITAL LETTER A）からU+005A（LATIN CAPITAL LETTER Z）までの範囲の文字もまた含まない絶対URLは、リンクタイプとして使用してもよい。
各要素は、この章で説明される事前に定義された意味を持つ。Rules for authors on how to use the element, along with user agent requirements for how to handle each element, are also given. これは、ビデオの再生や字幕、フォーム制御やフォーム送信、HTMLキャンバスとして知られる2次元のグラフィックAPIのようなHTMLの大きな署名機能を含む。
<!DOCTYPE html>
<html lang="en">
<head>
<title>Sample page</title>
</head>
<body>
<h1>Sample page</h1>
<p>This is a <a href="demo.html">simple</a> sample.</p>
<!-- this is a comment -->
</body>
</html>
<script>
var img = new Image();
img.src = 'games.png';
img.alt = 'Games';
img.onload = gamesLogoHasLoaded;
// img.addEventListener('load', gamesLogoHasLoaded, false); // would work also
</script>
<!-- Do not use this style, it has a race condition!-->
<img id="games" src="games.png" alt="Games">
<!-- the 'load' event might fire here while the parser is taking a
break, in which case you will not see it!-->
<script>
var img = document.getElementById('games');
img.onload = gamesLogoHasLoaded; // might never fire!
</script>
This specification provides guidelines for designing Web content
authoring tools that are more accessible for people with disabilities. An authoring tool that
conforms to these guidelines will promote accessibility by providing an accessible user interface
to authors with disabilities as well as by enabling, supporting, and promoting the production of
accessible Web content by all authors.
User Agent Accessibility Guidelines (UAAG) 2.0 [UAAG]
This document provides guidelines for designing user agents that
lower barriers to Web accessibility for people with disabilities. User agents include browsers
and other types of software that retrieve and render Web content. A user agent that conforms to
these guidelines will promote accessibility through its own user interface and through other
internal facilities, including its ability to communicate with other technologies (especially
assistive technologies). Furthermore, all users, not just users with disabilities, should find
conforming user agents to be more usable.
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.
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.
If a DOM object is said to be live, then the attributes and methods on that object
must operate on the actual underlying data, not a snapshot of the
data.
Browsers should take extreme care when interacting with external content
intended for plugins. When third-party software is run with the same
privileges as the user agent itself, vulnerabilities in the third-party software become as
dangerous as those in the user agent.
Since different users having differents sets of plugins provides a
fingerprinting vector that increases the chances of users being uniquely identified, user agents
are encouraged to support the exact same set of plugins for each
user.
ASCII互換文字エンコーディングは、バイト0x09、0x0A、0x0C、0x0D、0x20-0x22、0x26、0x27、0x2C-0x3F、0x41-0x5Aおよび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 Windows-1252 [ENCODING]
The key words "MUST", "MUST NOT", "SHOULD", "SHOULD
NOT", "MAY", and "OPTIONAL" in the normative parts of this document are to be interpreted as described in RFC2119. この文書の規範部分でのキーワード"OPTIONALLY"は、"MAY"または"OPTIONAL"としての意味と同一に解釈される。読みやすさのために、これらの単語は本仕様において大文字のみで出現しない。[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.
For example, were the spec to say:
To eat an orange, the user must:
1. Peel the orange.
2. Separate each slice of the orange.
3. Eat the orange slices.
...it would be equivalent to the following:
To eat an orange:
1. The user must peel the orange.
2. The user must separate each slice of the orange.
3. The user must eat the orange slices.
Here the key word is "must".
The former (imperative) style is generally preferred in this specification for stylistic
reasons.
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.)
2.2.1 Conformance classes
This specification describes the conformance criteria for user agents
(relevant to implementors) and documents (relevant to authors and
authoring tool implementors).
Conforming documents are those that comply with all the conformance criteria for
documents. For readability, some of these conformance requirements are phrased as conformance
requirements on authors; such requirements are implicitly requirements on documents: by
definition, all documents are assumed to have had an author. (In some cases, that author may
itself be a user agent — such user agents are subject to additional rules, as explained
below.)
For example, if a requirement states that "authors must not use the foobar element", it would imply that documents are not allowed to contain elements
named foobar.
There is no implied relationship between document conformance requirements
and implementation conformance requirements. User agents are not free to handle non-conformant
documents as they please; the processing model described in this specification applies to
implementations regardless of the conformity of the input documents.
User agents fall into several (overlapping) categories with different conformance
requirements.
Web browsers and other interactive user agents
Web browsers that support the 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 with an
HTML MIME type as described in this specification, so that users can interact with
them.
User agents that support scripting must also be conforming implementations of the IDL
fragments in this specification, as described in the Web IDL specification. [WEBIDL]
Unless explicitly stated, specifications that override the semantics of HTML
elements do not override the requirements on DOM objects representing those elements. For
example, the script element in the example above would still implement the
HTMLScriptElement interface.
Non-interactive presentation user agents
User agents that process HTML and 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.
Visual user agents that support the suggested default rendering
User agents, whether interactive or not, may be designated (possibly as a user option) as
supporting the suggested default rendering defined by this specification.
This is not required. In particular, even user agents that do implement the suggested default
rendering are encouraged to offer settings that override this default to improve the experience
for the user, e.g. changing the color contrast, using different focus styles, or otherwise
making the experience more accessible and usable to the user.
User agents that are designated as supporting the suggested default rendering must, while so
designated, implement the rules in the rendering section that that
section defines as the behavior that user agents are expected to implement.
User agents with no scripting support
Implementations that do not support scripting (or which have their scripting features
disabled entirely) are exempt from supporting the events and DOM interfaces mentioned in this
specification. For the parts of this specification that are defined in terms of an events model
or in terms of the DOM, such user agents must still act as if events and the DOM were
supported.
Scripting can form an integral part of an application. Web browsers that do not
support scripting, or that have scripting disabled, might be unable to fully convey the author's
intent.
Conformance checkers
Conformance checkers must verify that a document conforms to the applicable conformance
criteria described in this specification. Automated conformance checkers are exempt from
detecting errors that require interpretation of the author's intent (for example, while a
document is non-conforming if the content of a blockquote element is not a quote,
conformance checkers running without the input of human judgement do not have to check that
blockquote elements only contain quoted material).
Conformance checkers must check that the input document conforms when parsed without a
browsing context (meaning that no scripts are run, and that the parser's
scripting 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 "HTML validator" can be used to refer to a conformance checker that itself conforms
to the applicable requirements of this specification.
XML DTDs cannot express all the conformance requirements of this specification. Therefore, a
validating XML processor and a DTD cannot constitute a conformance checker. Also, since neither
of the two authoring formats defined in this specification are applications of SGML, a
validating SGML system cannot constitute a conformance checker either.
To put it another way, there are three types of conformance criteria:
Criteria that can be expressed in a DTD.
Criteria that cannot be expressed by a DTD, but can still be checked by a machine.
Criteria that can only be checked by a human.
A conformance checker must check for the first two. A simple DTD-based validator only checks
for the first class of errors and is therefore not a conforming conformance checker according
to this specification.
Data mining tools
Applications and tools that process HTML and XHTML documents for reasons other than to either
render the documents or check them for conformance should act in accordance with the semantics
of the documents that they process.
A tool that generates document outlines but
increases the nesting level for each paragraph and does not increase the nesting level for 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. However, authoring tools must not automatically misuse elements or encourage
their users to do so.
For example, it is not conforming to use an address element for
arbitrary contact information; that element can only be used for marking up contact information
for 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. This does not mean,
though, that authoring tools can use address elements for any block of italics text
(for instance); it just means that the authoring tool doesn't have to verify that when the user
uses a tool for inserting contact information for a section, that the user really is doing that
and not inserting something else instead.
In terms of conformance checking, an editor has to output documents that conform
to the same extent that a conformance checker will verify.
When an authoring tool is used to edit a non-conforming document, it may preserve the
conformance errors in sections of the document that were not edited during the editing session
(i.e. an editing tool is allowed to round-trip erroneous content). However, an authoring tool
must not claim that the output is conformant if errors have been so preserved.
Authoring tools are expected to come in two broad varieties: tools that work from structure
or semantic data, and tools that work on a What-You-See-Is-What-You-Get media-specific editing
basis (WYSIWYG).
The former is the preferred mechanism for tools that author HTML, since the structure in the
source information can be used to make informed choices regarding which HTML elements and
attributes are most appropriate.
However, WYSIWYG tools are legitimate. WYSIWYG tools should use elements they know are
appropriate, and should not use elements that they do not know to be appropriate. This might in
certain extreme cases mean limiting the use of flow elements to just a few elements, like
div, 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.
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 must support at least one of these two formats, although
supporting both is encouraged.
Some conformance requirements are phrased as requirements on elements, attributes, methods or
objects. Such requirements fall into two categories: those describing content model restrictions,
and those describing implementation behavior. Those in the former category are requirements on
documents and authoring tools. Those in the second category are requirements on user agents.
Similarly, some conformance requirements are phrased as requirements on authors; such requirements
are to be interpreted as conformance requirements on the documents that authors produce. (In other
words, this specification does not distinguish between conformance criteria on authors and
conformance criteria on documents.)
2.2.2 Dependencies
This specification relies on several other underlying specifications.
Unicode and Encoding
The Unicode character set is used to represent textual data, and the Encoding standard
defines requirements around character encodings. [UNICODE]
This specification introduces terminology
based on the terms defined in those specifications, as described earlier.
The following terms are used as defined in the Encoding standard: [ENCODING]
Getting an encoding
The encoder and decoder algorithms for various encodings, including
the UTF-8 encoder and UTF-8 decoder
The generic decode algorithm which takes a byte stream and an encoding and
returns a character stream
The UTF-8 decode algorithm which takes a byte stream and returns a character
stream, additionally stripping one leading UTF-8 Byte Order Mark (BOM), if any
The UTF-8 decoder is distinct from the UTF-8 decode
algorithm. The latter first strips a Byte Order Mark (BOM), if any, and then invokes the
former.
For readability, character encodings are sometimes referenced in this specification with a
case that differs from the canonical case given in the Encoding standard. (For example,
"UTF-16LE" instead of "utf-16le".)
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][XMLNS]
URLs
The following terms are defined in the WHATWG URL standard: [URL]
The following terms are defined in the Cookie specification: [COOKIES]
cookie-string
receives a set-cookie-string
Fetch
The following terms are defined in the WHATWG Fetch specification: [FETCH]
cross-origin request
cross-origin request status
custom request headers
simple cross-origin request
redirect steps
omit credentials flag
resource sharing check
This specification does not yet use the "fetch" algorithm from the WHATWG Fetch
specification. It will be updated to do so in due course.
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]
The terms supported property indices, determine the value of an indexed
property, support named properties, supported property names,
unenumerable, determine the value of a named property, platform array
objects, and read only (when applied to arrays)
are used as defined in the Web IDL specification. The algorithm to convert a DOMString to a
sequence of Unicode characters is similarly that defined in the Web IDL specification.
When this specification requires a user agent to create a Date object
representing a particular time (which could be the special value Not-a-Number), the milliseconds
component of that time, if any, must be truncated to an integer, and the time value of the newly
created Date object must represent the resulting truncated time.
For instance, given the time 23045 millionths of a second after 01:00 UTC on
January 1st 2000, i.e. the time 2000-01-01T00:00:00.023045Z, then the Date object
created representing that time would represent the same time as that created representing the
time 2000-01-01T00:00:00.023Z, 45 millionths earlier. If the given time is NaN, then the result
is a Date object that represents a time value NaN (indicating that the object does
not represent a specific instant of time).
JavaScript
Some parts of the language described by this specification only support JavaScript as the
underlying scripting language. [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]
The term JavaScript global environment refers to the global
environment concept defined in the ECMAScript specification.
The ECMAScript SyntaxError exception is also
defined in the ECMAScript specification. [ECMA262]
The ArrayBuffer and related object types and underlying concepts from the
ECMAScript Specification are used for several features in this specification. [ECMA262]
The following helper IDL is used for referring to ArrayBuffer-related types:
typedef (Int8Array or Uint8Array or Uint8ClampedArray or
Int16Array or Uint16Array or
Int32Array or Uint32Array or
Float32Array or Float64Array or
DataView) ArrayBufferView;
In particular, the Uint8ClampedArray type is used by some 2D canvas APIs, and the WebSocket API
uses ArrayBuffer objects for handling binary frames.
DOM
The Document Object Model (DOM) is a representation — a model — of a document and
its content. The DOM is not just an API; the conformance criteria of HTML implementations are
defined, in this specification, in terms of operations on the DOM. [DOM]
Implementations must support DOM and the events defined in DOM Events, because this
specification is defined in terms of the DOM, and some of the features are defined as extensions
to the DOM interfaces. [DOM][DOMEVENTS]
In particular, the following features are defined in the DOM specification: [DOM]
Attr interface
Comment interface
DOMImplementation interface
Document interface
XMLDocument interface
DocumentFragment interface
DocumentType interface
DOMException interface
ChildNode interface
Element interface
Node interface
NodeList interface
ProcessingInstruction interface
Text interface
HTMLCollection interface
item() method
The terms collections and represented by the collection
DOMTokenList interface
DOMSettableTokenList interface
createDocument() method
createHTMLDocument() method
createElement() method
createElementNS() method
getElementById() method
insertBefore() method
ownerDocument attribute
childNodes attribute
localName attribute
parentNode attribute
namespaceURI attribute
tagName attribute
id attribute
textContent attribute
The insert, append, remove, replace, and adopt algorithms for nodes
The nodes are inserted and nodes are removed concepts
The concept of a regular event parent and a cross-boundary event parent
The encoding (herein the character encoding) and content type of a Document
The distinction between XML documents and HTML documents
The terms quirks mode, limited-quirks mode, and no-quirks mode
The algorithm to clone a Node, and the concept of cloning steps used by that algorithm
The concept of base URL change steps and the definition of what happens when an element is affected by a base URL change
The concept of an element's unique identifier (ID)
The concept of a DOM range, and the terms start, end, and boundary point as applied to ranges.
MutationObserver interface
The invoke MutationObserver objects algorithm
Promise interface
The resolver concept
The fulfill and reject algorithms
The term throw in this specification is used as defined in the DOM specification.
The following DOMException types are defined in the DOM specification: [DOM]
IndexSizeError
HierarchyRequestError
WrongDocumentError
InvalidCharacterError
NoModificationAllowedError
NotFoundError
NotSupportedError
InvalidStateError
SyntaxError
InvalidModificationError
NamespaceError
InvalidAccessError
SecurityError
NetworkError
AbortError
URLMismatchError
QuotaExceededError
TimeoutError
InvalidNodeTypeError
DataCloneError
For example, to throw a TimeoutError exception, a user
agent would construct a DOMException object whose type was the string "TimeoutError" (and whose code was the number 23, for legacy reasons) and
actually throw that object as an exception.
The following features are defined in the DOM Events specification: [DOMEVENTS]
MouseEvent interface
MouseEventInit dictionary type
The FocusEvent interface and its relatedTarget attribute
The UIEvent interface's detail attribute
click event
dblclick event
mousedown event
mouseenter event
mouseleave event
mousemove event
mouseout event
mouseover event
mouseup event
mousewheel event
keydown event
keyup event
keypress event
The following features are defined in the Touch Events specification: [TOUCH]
Touch interface
Touch point concept
This specification sometimes uses the term name to refer to the event's
type; as in, "an event named click"
or "if the event name is keypress". The terms "name" and "type" for
events are synonymous.
The following features are defined in the DOM Parsing and Serialization specification: [DOMPARSING]
innerHTML
outerHTML
User agents are also encouraged to implement the features described in the
HTML Editing APIs and UndoManager and DOM Transaction
specifications.
[EDITING][UNDO]
The following parts of the Fullscreen specification are referenced from this specification,
in part to define the rendering of dialog elements, and also to define how the
Fullscreen API interacts with the sandboxing features in HTML: [FULLSCREEN]
The top layer concept
requestFullscreen()
The fullscreen enabled flag
The fully exit fullscreen algorithm
File API
This specification uses the following features defined in the File API specification: [FILEAPI]
Blob
File
FileList
Blob.close()
Blob.type
The concept of read errors
XMLHttpRequest
This specification references the XMLHttpRequest specification to describe how the two
specifications interact and to use its ProgressEvent features. The following
features and terms are defined in the XMLHttpRequest specification: [XHR]
XMLHttpRequest
ProgressEvent
Fire a progress event named e
Server-Sent Events
This specification references EventSource which is specified
in the Server-Sent Events specification [EVENTSOURCE]
Media Queries
Implementations must support the Media Queries language. [MQ]
CSS modules
While support for CSS as a whole is not required of implementations of this specification
(though it is encouraged, at least for Web browsers), some features are defined in terms of
specific CSS requirements.
In particular, some features require that a string be parsed as a CSS <color>
value. When parsing a CSS value, user agents are required by the CSS specifications to
apply some error handling rules. These apply to this specification also. [CSSCOLOR][CSS]
For example, user agents are required to close all open constructs upon
finding the end of a style sheet unexpectedly. Thus, when parsing the string "rgb(0,0,0" (with a missing close-parenthesis) for a color value, the close
parenthesis is implied by this error handling rule, and a value is obtained (the color 'black').
However, the similar construct "rgb(0,0," (with both a missing parenthesis
and a missing "blue" value) cannot be parsed, as closing the open construct does not result in a
viable value.
The term CSS element reference identifier is used as defined in the CSS
Image Values and Replaced Content specification to define the API that declares
identifiers for use with the CSS 'element()' function. [CSSIMAGES]
Similarly, the term provides a paint source is used as defined in the CSS
Image Values and Replaced Content specification to define the interaction of certain HTML
elements with the CSS 'element()' function. [CSSIMAGES]
The term default object size is also defined in the CSS Image Values and
Replaced Content specification. [CSSIMAGES]
Implementations that support scripting must support the CSS Object Model. The following
features and terms are defined in the CSSOM specifications: [CSSOM][CSSOMVIEW]
The terms create a CSS style sheet, remove a CSS style sheet, and associated CSS style sheet
CSS style sheets and their properties:
type,
location,
parent CSS style sheet,
owner node,
owner CSS rule,
media,
title,
alternate flag,
disabled flag,
CSS rules,
origin-clean flag
Alternative style sheet sets and the preferred style sheet set
Serializing a CSS value
Scroll an element into view
Scroll to the beginning of the document
The resize event
The scroll event
The term environment encoding is defined in the CSS Syntax
specifications. [CSSSYNTAX]
The term CSS styling attribute is defined in the CSS Style Attributes
specification. [CSSATTR]
The CanvasRenderingContext2D object's use of fonts depends on the features
described in the CSS Fonts and Font Load Events specifications, including in particular
FontLoader. [CSSFONTS][CSSFONTLOAD]
SVG
The following interface is defined in the SVG specification: [SVG]
SVGMatrix
WebGL
The following interface is defined in the WebGL specification: [WEBGL]
WebGLRenderingContext
WebVTT
Implementations may support WebVTT as a text track format for subtitles, captions,
chapter titles, metadata, etc, for media resources. [WEBVTT]
The following terms, used in this specification, are defined in the WebVTT specification:
WebVTT file
WebVTT file using cue text
WebVTT file using chapter title text
WebVTT file using only nested cues
WebVTT parser
The rules for updating the display of WebVTT text tracks
The rules for interpreting WebVTT cue text
The WebVTT text track cue writing direction
The WebSocket protocol
The following terms are defined in the WebSocket protocol specification: [WSP]
establish a WebSocket connection
the WebSocket connection is established
validate the server's response
extensions in use
subprotocol in use
headers to send appropriate cookies
cookies set during the server's opening handshake
a WebSocket message has been received
send a WebSocket Message
fail the WebSocket connection
close the WebSocket connection
start the WebSocket closing handshake
the WebSocket closing handshake is started
the WebSocket connection is closed (possibly cleanly)
the WebSocket connection close code
the WebSocket connection close reason
ARIA
The terms strong native semantics is used as defined in the ARIA specification.
The term default implicit ARIA semantics has the same meaning as the term implicit
WAI-ARIA semantics as used in the ARIA specification. [ARIA]
The role and aria-*
attributes are defined in the ARIA specification. [ARIA]
This specification does not require support of any particular network protocol, style
sheet language, scripting language, or any of the DOM specifications beyond those required in the
list above. However, the language described by this specification is biased towards CSS as the
styling language, JavaScript as the scripting language, and HTTP as the network protocol, and
several features assume that those languages and protocols are in use.
A user agent that implements the HTTP protocol must implement the Web Origin Concept
specification and the HTTP State Management Mechanism specification (Cookies) as well. [HTTP][ORIGIN][COOKIES]
This specification might have certain additional requirements on character
encodings, image formats, audio formats, and video formats in the respective sections.
If such extensions are nonetheless needed, e.g. for experimental purposes, then vendors are
strongly urged to use one of the following extension mechanisms:
For markup-level features that can be limited to the XML serialization and need not be
supported in the HTML serialization, vendors should use the namespace mechanism to define custom
namespaces in which the non-standard elements and attributes are supported.
For markup-level features that are intended for use with the HTML syntax,
extensions should be limited to new attributes of the form "x-vendor-feature", where vendor is a
short string that identifies the vendor responsible for the extension, and feature is the name of the feature. New element names should not be created.
Using attributes for such extensions exclusively allows extensions from multiple vendors to
co-exist on the same element, which would not be possible with elements. Using the "x-vendor-feature" form allows extensions
to be made without risk of conflicting with future additions to the specification.
For instance, a browser named "FerretBrowser" could use "ferret" as a vendor prefix, while a
browser named "Mellblom Browser" could use "mb". If both of these browsers invented extensions
that turned elements into scratch-and-sniff areas, an author experimenting with these features
could write:
<p>This smells of lemons!
<span x-ferret-smellovision x-ferret-smellcode="LEM01"
x-mb-outputsmell x-mb-smell="lemon juice"></span></p>
Attribute names beginning with the two characters "x-" are reserved for
user agent use and are guaranteed to never be formally added to the HTML language. For
flexibility, attributes names containing underscores (the U+005F LOW LINE character) are also
reserved for experimental purposes and are guaranteed to never be formally added to the HTML
language.
Pages that use such attributes are by definition non-conforming.
For DOM extensions, e.g. new methods and IDL attributes, the new members should be prefixed by
vendor-specific strings to prevent clashes with future versions of this specification.
For events, experimental event types should be prefixed with vendor-specific strings.
For example, if a user agent called "Pleasold" were to add an event to indicate when
the user is going up in an elevator, it could use the prefix "pleasold" and
thus name the event "pleasoldgoingup", possibly with an event handler
attribute named "onpleasoldgoingup".
All extensions must be defined so that the use of extensions neither contradicts nor causes the
non-conformance of functionality defined in the specification.
For example, while strongly discouraged from doing so, an implementation "Foo Browser" could
add a new IDL 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.
When adding new reflecting IDL attributes corresponding to content
attributes of the form "x-vendor-feature", the IDL attribute should be named "vendorFeature" (i.e. the "x" is
dropped from the IDL attribute's name).
この仕様にベンダー中立の拡張が必要になった場合、この仕様が状況に応じて更新されうる、または拡張仕様がこの仕様の要求を上書きされうるかのいずれかである。When someone applying this specification to their activities decides that they will recognise the requirements of such an extension specification, it becomes
applicable
specification.
As a suggested but not required convention, such
specifications might define conformance terminology such as:
"Conforming HTML5+XXX document", where XXX is a short name for the applicable specification. （例："適合HTML5+自動拡張文書"）。
User agents must treat elements and attributes that they do not understand as semantically
neutral; leaving them in the DOM (for DOM processors), and styling them according to CSS (for CSS
processors), but not inferring any meaning from them.
When support for a feature is disabled (e.g. as an emergency measure to mitigate a security
problem, or to aid in development, or for performance reasons), user agents must act as if they
had no support for the feature whatsoever, and as if the feature was not mentioned in this
specification. For example, if a particular feature is accessed via an attribute in a Web IDL
interface, the attribute itself would be omitted from the objects that implement that interface
— leaving the attribute on the object but making it return null or throw an exception is
insufficient.
2.2.4 Interactions with XPath and XSLT
Implementations of XPath 1.0 that operate on HTML
documents parsed or created in the manners described in this specification (e.g. as part of
the document.evaluate() API) must act as if the following edit was applied
to the XPath 1.0 specification.
First, remove this paragraph:
A QName in the node test is expanded
into an expanded-name
using the namespace declarations from the expression context. This is the same way expansion is
done for element type names in start and end-tags except that the default namespace declared with
xmlns is not used: if the QName does not have a prefix, then the
namespace URI is null (this is the same way attribute names are expanded). It is an error if the
QName has a prefix for which there is
no namespace declaration in the expression context.
Then, insert in its place the following:
A QName in the node test is expanded into an expanded-name using the namespace declarations
from the expression context. If the QName has a prefix, then there must be a namespace declaration for this prefix in
the expression context, and the corresponding namespace URI is the one that is
associated with this prefix. It is an error if the QName has a prefix for which there is no
namespace declaration in the expression context.
If the QName has no prefix and the principal node type of the axis is element, then the
default element namespace is used. Otherwise if the QName has no prefix, the namespace URI is
null. The default element namespace is a member of the context for the XPath expression. The
value of the default element namespace when executing an XPath expression through the DOM3 XPath
API is determined in the following way:
If the context node is from an HTML DOM, the default element namespace is
"http://www.w3.org/1999/xhtml".
Otherwise, the default element namespace URI is null.
This is equivalent to adding the default element namespace feature of XPath 2.0
to XPath 1.0, and using the HTML namespace as the default element namespace for HTML documents.
It is motivated by the desire to have implementations be compatible with legacy HTML content
while still supporting the changes that this specification introduces to HTML regarding the
namespace used for HTML elements, and by the desire to use XPath 1.0 rather than XPath 2.0.
This change is a willful violation of the XPath 1.0 specification,
motivated by desire to have implementations be compatible with legacy content while still
supporting the changes that this specification introduces to HTML regarding which namespace is
used for HTML elements. [XPATH10]
XSLT 1.0 processors outputting to a DOM when the output
method is "html" (either explicitly or via the defaulting rule in XSLT 1.0) are affected as
follows:
If the transformation program outputs an element in no namespace, the processor must, prior to
constructing the corresponding DOM element node, change the namespace of the element to the
HTML namespace, ASCII-lowercase the
element's local name, and ASCII-lowercase the
names of any non-namespaced attributes on the element.
This requirement is a willful violation of the XSLT 1.0
specification, required because this specification changes the namespaces and case-sensitivity
rules of HTML in a manner that would otherwise be incompatible with DOM-based XSLT
transformations. (Processors that serialise the output are unaffected.) [XSLT10]
This specification does not specify precisely how XSLT processing interacts with the HTML
parser infrastructure (for example, whether an XSLT processor acts as if it puts any
elements into a stack of open elements). However, XSLT processors must stop
parsing if they successfully complete, and must set the current document
readiness first to "interactive" and then to "complete" if they are aborted.
This specification does not specify how XSLT interacts with the navigation algorithm, how it fits in with the event loop, nor
how error pages are to be handled (e.g. whether XSLT errors are to replace an incremental XSLT
output, or are rendered inline, etc).
ASCII大文字・小文字区別において2つの文字列を比較する方法は、コードポイントごとに正確に比較することを意味し、U+0041からU+005Aまでの範囲（すなわちLATIN CAPITAL LETTER AからLATIN CAPITAL LETTER Zまで）を除いて、U+0061からU+007Aまでの範囲（すなわちLATIN SMALL LETTER AからLATIN SMALL LETTER Zまで）において一致する文字も一致するとみなされる。
Converting a string to ASCII uppercase means
replacing all characters in the range U+0061 to U+007A (i.e. LATIN SMALL LETTER A to LATIN SMALL
LETTER Z) with the corresponding characters in the range U+0041 to 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 to U+005A (i.e. LATIN CAPITAL LETTER A to LATIN
CAPITAL LETTER Z) with the corresponding characters in the range U+0061 to U+007A (i.e. LATIN
SMALL LETTER A to LATIN SMALL LETTER Z).
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.
ASCII16進数字は、ASCII 数字、U+0041 LATIN CAPITAL LETTER AからU+0046 LATIN CAPITAL LETTERまで、およびU+0061 LATIN SMALL LETTER AからU+0066 LATIN SMALL LETTER Fまでの範囲の文字である。
大文字のASCII16進数字は、範囲ASCII数字およびU+0041 LATIN CAPITAL LETTER AからU+0046 LATIN CAPITAL LETTER Fまでのみの文字である。
小文字のASCII16進数字は、範囲ASCII数字およびU+0061 LATIN SMALL LETTER AからU+0066 LATIN SMALL LETTER Fまでのみの文字である。
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 "LF" (U+000A) and "CR" (U+000D) characters from that string.
When a user agent is to strip leading and trailing whitespace from a string, the
user agent must remove all space characters that are at the
start or end of the string.
When a user agent is to strip and collapse whitespace in a string, it must replace
any sequence of one or more consecutive space characters in
that string with a single U+0020 SPACE character, and then strip leading and trailing
whitespace from that string.
When a user agent has to strictly split a string on a particular delimiter character
delimiter, 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 an ordered list of tokens, initially empty.
Append the string collected in the previous step to tokens.
Advance position to the next character in input.
Return tokens.
For the special cases of splitting a string on spaces and on commas, this
algorithm does not apply (those algorithms also perform whitespace trimming).
The rules for parsing 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 return either an integer or an error.
Let input be the string being parsed.
Let position be a pointer into input, initially
pointing at the start of the string.
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 return either zero, a positive integer, or an error.
The best
representation of the number n as a floating-point number is the string
obtained from applying the JavaScript operator ToString to n. The JavaScript
operator ToString is not uniquely determined. When there are multiple possible strings that could
be obtained from the JavaScript operator ToString for a particular value, the user agent must
always return the same string for that value (though it may differ from the value used by other
user agents).
The rules for parsing floating-point number values are as given in the following
algorithm. This algorithm must be aborted at the first step that returns something. This algorithm
will return either a number or an error.
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.
Otherwise, if the character indicated by position (the first character)
is a "+" (U+002B) character:
Advance position to the next character. (The "+"
is ignored, but it is not conforming.)
If position is past the end of input, return an
error.
If the character indicated by position is a "." (U+002E), and
that is not the last character in input, and the character after the
character indicated by position is an ASCII
digit, then set value to zero and jump to the step labeled
fraction.
If the character indicated by position is not an ASCII digit, then return an error.
If position is past the end of input, jump to the
step labeled conversion.
Fraction: If the character indicated by position is a "." (U+002E), 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 an ASCII
digit, "e" (U+0065), or "E" (U+0045), then jump
to the step labeled conversion.
If the character indicated by position is a "e" (U+0065) character or a "E" (U+0045) character, skip the remainder of
these substeps.
Fraction loop: Multiply divisor by ten.
Add the value of the character indicated by position, interpreted as a
base-ten digit (0..9) and divided by divisor, to value.
Advance position to the next character.
If position is past the end of input, then jump
to the step labeled conversion.
If the character indicated by position is an ASCII digit, jump back to the step labeled fraction loop in these
substeps.
If the character indicated by position is a "e" (U+0065) character or a "E" (U+0045) character, run these substeps:
Advance position to the next character.
If position is past the end of input, then jump
to the step labeled conversion.
If the character indicated by position is a "-" (U+002D) character:
Change exponent to −1.
Advance position to the next character.
If position is past the end of input, then
jump to the step labeled conversion.
Otherwise, if the character indicated by position is a "+" (U+002B) character:
Advance position to the next character.
If position is past the end of input, then
jump to the step labeled conversion.
If the character indicated by position is not an ASCII digit, then jump to the step labeled conversion.
Multiply value by ten raised to the exponentth
power.
Conversion: Let S be the set of finite IEEE 754
double-precision floating-point values except −0, but with two special values added: 21024 and −21024.
Let rounded-value be the number in S that is
closest to value, selecting the number with an even significand if there are
two equally close values. (The two special values 21024 and −21024 are considered to have even significands for this purpose.)
If rounded-value is 21024 or −21024, return an error.
Return rounded-value.
2.4.4.4 Percentages and lengths
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 return either a number greater than or equal to 1.0, or an error; if a
number is returned, then it is further categorised 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.
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) 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.
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 to U+001F, U+0021 to U+002B, U+002D to U+002F, U+003A, U+003C to U+0040, U+005B to U+0060, U+007b to 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.6 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) character,
then remove that character from raw input.
While the formats described here are intended to be subsets of the corresponding
ISO8601 formats, this specification defines parsing rules in much more detail than ISO8601.
Implementors are therefore encouraged to carefully examine any date parsing libraries before using
them to implement the parsing rules described below; ISO8601 libraries might not parse dates and
times in exactly the same manner. [ISO8601]
The rules to parse a month string are as follows. This will return either 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 return either 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 that are ASCII digits. 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 that are ASCII digits. 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.
The rules to parse a date string are as follows. This will return either 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 return either 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 that are ASCII digits. 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 ≤ day ≤ maxday, then fail.
The rules to parse a yearless date string are as follows. This will return either 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.
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 month and day.
The rules to parse a yearless date component, given an input
string and a position, are as follows. This will return either 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.
Collect a sequence of characters that are "-" (U+002D) characters.
If the collected sequence is not exactly zero or two characters long, then fail.
Collect a sequence of characters that are ASCII digits. 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.
Let maxday be the number of days in month month of any arbitrary leap year (e.g. 4
or 2000).
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 that are ASCII digits. 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 ≤ day ≤ maxday, then fail.
The rules to parse a time string are as follows. This will return either 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 return either 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 that are ASCII digits. 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 that are ASCII digits. 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 both ASCII
digits, then fail.
Collect a sequence of characters that are either ASCII digits
or U+002E FULL STOP characters. If the collected sequence is three characters long, or if it is
longer than three characters long and the third character is not a U+002E FULL STOP character,
or if it has more than one 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.
The rules to parse a floating date and time string are as follows. This will return
either 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 neither a U+0054 LATIN CAPITAL LETTER T character
(T) nor a U+0020 SPACE 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.
The rules to parse a time-zone offset string are as follows. This will return either
a time-zone offset, 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 the time-zone offset that is timezonehours
hours and timezoneminutes minutes from UTC.
The rules to parse a time-zone offset component, given an input
string and a position, are as follows. This will return either 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 character
(Z), then:
Let timezonehours be 0.
Let timezoneminutes be 0.
Advance position to the next character in input.
Otherwise, if the character at position is either a "+" (U+002B)
or a "-" (U+002D), then:
If the character at position is a "+" (U+002B), let sign be "positive". Otherwise, it's a "-" (U+002D); let sign be "negative".
If s is exactly two characters long, then run these substeps:
Interpret s as a base-ten integer. Let that number be the timezonehours.
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 that are ASCII digits. 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 timezoneminutes.
If s is exactly four characters long, then run these substeps:
Interpret the first two characters of s as a base-ten integer. Let
that number be the timezonehours.
Interpret the last two characters of s as a base-ten integer. Let
that number be the timezoneminutes.
Otherwise, fail.
If timezonehours is not a number in the range
0 ≤ timezonehours ≤ 23, then
fail.
If sign is "negative", then negate timezonehours.
If timezoneminutes is not a number in the range
0 ≤ timezoneminutes ≤ 59,
then fail.
If sign is "negative", then negate timezoneminutes.
The rules to parse a global date and time string are as follows. This will return
either a time in UTC, with associated time-zone offset 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 neither a U+0054 LATIN CAPITAL LETTER T character
(T) nor a U+0020 SPACE 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.
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 timezonehours hours and timezoneminutes minutes. That moment in time is a moment in the UTC time
zone.
Let timezone be timezonehours
hours and timezoneminutes minutes from UTC.
The rules to parse a week string are as follows. This will return either 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 that are ASCII digits. 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 "W" (U+0057) character,
then fail. Otherwise, move position forwards one character.
Collect a sequence of characters that are ASCII digits. 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.
The rules to parse a duration string are as follows. This will return either a duration 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.
Let months, seconds, and component
count all be zero.
Let M-disambiguator be minutes.
This flag's other value is months. It is used to disambiguate the "M"
unit in ISO8601 durations, which use the same unit for months and minutes. Months are not
allowed, but are parsed for future compatibility and to avoid misinterpreting ISO8601 durations
that would be valid in other contexts.
If the character in input pointed to by position
is a U+0050 LATIN CAPITAL LETTER P character, then advance position to the
next character, set M-disambiguator to months, and skip
whitespace.
Run the following substeps in a loop, until a step requiring the loop to be broken or the
entire algorithm to fail is reached:
Let units be undefined. It will be assigned one of the following
values: years, months, weeks, days, hours, minutes,
and seconds.
Let next character be undefined. It is used to process characters
from the input.
If position is past the end of input, then break
the loop.
If the character in input pointed to by position
is a U+0054 LATIN CAPITAL LETTER T character, then advance position to the
next character, set M-disambiguator to minutes, skip
whitespace, and return to the top of the loop.
Set next character to the character in input
pointed to by position.
If next character is a "." (U+002E) character, then let N equal zero. (Do not advance position. That is taken care
of below.)
Otherwise next character is not part of a number; fail.
If position is past the end of input, then
fail.
Set next character to the character in input
pointed to by position, and this time advance position
to the next character. (If next character was a U+002E FULL STOP character
(.) before, it will still be that character this time.)
If next character is a "." (U+002E) character, then run these
substeps:
Set next character to the character in input
pointed to by position, and advance position to the
next character.
If next character is neither a U+0053 LATIN CAPITAL LETTER S
character nor a U+0073 LATIN SMALL LETTER S character, then fail.
Set units to seconds.
Otherwise, run these substeps:
If next character is a space character, then
skip whitespace, set next character to the character in input pointed to by position, and advance position to the next character.
If next character is a U+0059 LATIN CAPITAL LETTER Y character, or a
U+0079 LATIN SMALL LETTER Y character, set units to years and set
M-disambiguator to months.
If next character is a U+004D LATIN CAPITAL LETTER M character or a
U+006D LATIN SMALL LETTER M character, and M-disambiguator is
months, then set units to months.
If next character is a U+0057 LATIN CAPITAL LETTER W character or a
U+0077 LATIN SMALL LETTER W character, set units to weeks and set
M-disambiguator to minutes.
If next character is a U+0044 LATIN CAPITAL LETTER D character or a
U+0064 LATIN SMALL LETTER D character, set units to days and set
M-disambiguator to minutes.
If next character is a U+0048 LATIN CAPITAL LETTER H character or a
U+0068 LATIN SMALL LETTER H character, set units to hours and set
M-disambiguator to minutes.
If next character is a U+004D LATIN CAPITAL LETTER M character or a
U+006D LATIN SMALL LETTER M character, and M-disambiguator is
minutes, then set units to minutes.
If next character is a U+0053 LATIN CAPITAL LETTER S character or a
U+0073 LATIN SMALL LETTER S character, set units to seconds and
set M-disambiguator to minutes.
Otherwise if next character is none of the above characters, then
fail.
Increment component count.
Let multiplier be 1.
If units is years, multiply multiplier by
12 and set units to months.
If units is months, add the product of N and
multiplier to months.
Otherwise, run these substeps:
If units is weeks, multiply multiplier
by 7 and set units to days.
If units is days, multiply multiplier
by 24 and set units to hours.
If units is hours, multiply multiplier
by 60 and set units to minutes.
If units is minutes, multiply multiplier by 60 and set units to seconds.
Forcibly, units is now seconds. Add the product of N and multiplier to seconds.
The rules to parse a date or time string are as follows. The algorithm will return
either 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
either a "T" (U+0054) character or a U+0020 SPACE 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 neither a "T" (U+0054) character nor a U+0020
SPACE 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 fail.
If the date present and time present flags are
both 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 offset component to obtain timezonehours and timezoneminutes. 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 timezonehours hours and timezoneminutes minutes, that moment in time being a moment
in the UTC time zone; let timezone be timezonehours hours and timezoneminutes
minutes from UTC; and return time and timezone.
妥当な単純色でかつ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 return either 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 ASCII hex
digits, 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) character.
Convert the red, green, and blue components in turn to two-digit hexadecimal numbers using
lowercase ASCII hex digits, 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 return either 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 four characters long, and the first character in input is a "#" (U+0023) character, and the last three characters of
input are all ASCII hex digits, 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) character,
remove it.
Replace any character in input that is not an ASCII hex digit with the character "0" (U+0030).
While input's length is zero or not a multiple of three, append a
"0" (U+0030) 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 "0" (U+0030) 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.
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.
Resolving a URL is the process of taking a relative URL and obtaining the
absolute URL that it implies.
To resolve a URL to an absolute URL relative to either another
absolute URL or an element, the user agent must use the following steps. Resolving a
URL can result in an error, in which case the URL is not resolvable.
Let serialised URL be the result of apply the URL
serializer to parsed URL.
Return serialised URL as the resulting absolute URL and
parsed URL as the resulting parsed URL.
Given an element, the element's base URL is the base URI of the element, as
defined by the XML Base specification, with the base URI of the document entity being
defined as the document base URL of the Document that owns the element.
[XMLBASE]
For the purposes of the XML Base specification, user agents must act as if all
Document objects represented XML documents.
It is possible for xml:base attributes to be
present even in HTML fragments, as such attributes can be added dynamically using script. (Such
scripts would not be conforming, however, as xml:base
attributes are not allowed in HTML documents.)
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 element is a q, blockquote, ins, or
del element with a cite attribute
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.
そうでなければ
The element is not directly affected.
For instance, changing the base URL doesn't affect the image displayed by
img elements, although subsequent accesses of the src IDL attribute from script will return a new absolute
URL that might no longer correspond to the image being shown.
2.6 Fetching resources
2.6.1 Terminology
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.
When a user agent is to fetch a resource or URL, optionally
from an origin origin, optionally using a
specific referrer source as an override referrer source, and optionally with
any of a synchronous flag, a manual redirect flag, a force same-origin flag,
and a block cookies flag, the following steps must be run. (When a URL is to be
fetched, the URL identifies a resource to be obtained.)
If there is a specific override referrer source, and it is a URL, then
let referrer be the override referrer source, and jump to the step
labeled clean referrer.
Let document be the appropriate Document as given by the
following list:
Let referrer be the result of applying the URL serializer to parsed referrer,
with the exclude fragment flag set.
If referrer is not the empty string, is not a data: URL, and is not the URL
"about:blank", then generate the address of the resource from which Request-URIs
are obtained as required by HTTP for the Referer (sic)
header from referrer. [HTTP]
Otherwise, the Referer (sic) header must be omitted,
regardless of its value.
If the algorithm was not invoked with the synchronous flag, perform the remaining
steps asynchronously.
If the Document with which any tasksqueued by this algorithm would be associated doesn't have an
associated browsing context, then abort these steps.
This is the main step.
If the resource is to be obtained from an application cache, then use the data
from that application cache, as if it had been obtained in the manner appropriate
given its URL.
If the resource is identified by an absolute URL, and the resource is to be
obtained using an 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 this request would be
identical to the previous one (e.g. same Accept and Origin headers), 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, if the resource is identified by an absolute URL with a scheme that
does not define a mechanism to obtain the resource (e.g. it is a mailto:
URL) or that the user agent does not support, then act as if the resource was an HTTP 204 No
Content response with no other metadata.
Otherwise, if the resource is identified by the URLabout:blank, then the resource is immediately available and consists of
the empty string, with no metadata.
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, or expanding data: URLs, etc).
For the purposes of the Referer (sic) header, use the
address of the resource from which Request-URIs are obtained generated in the earlier
step.
For the purposes of the Origin header, if the fetching algorithm was explicitly initiated from an origin, then the origin that initiated the HTTP request is origin. Otherwise, this is a request from a "privacy-sensitive"
context. [ORIGIN]
If the algorithm was not invoked with the block cookies flag, and there are cookies to
be set, then the user agent must run the following substeps:
Wait until ownership of the storage mutex can be taken by this instance of
the fetching algorithm.
Release the storage mutex so that it is once again free.
If the fetched resource is an HTTP redirect or
equivalent, then:
If the force same-origin flag is set and the URL of the target of the
redirect does not have the same origin as the URL for which the
fetch algorithm was invoked
Abort these steps and return failure from this algorithm, as if the remote host could not
be contacted.
If the manual redirect flag is set
Continue, using the fetched resource (the redirect) as the result of the algorithm. If the
calling algorithm subsequently requires the user agent to transparently follow the
redirect, then the user agent must resume this algorithm from the main step, but
using the target of the redirect as the resource to fetch, rather than the original
resource.
そうでなければ
First, apply any relevant requirements for redirects (such as showing any appropriate
prompts). Then, redo main step, but using the target of the redirect as the resource to
fetch, rather than the original resource. For HTTP requests, the new request must include the
same headers as the original request, except for headers for which other requirements are
specified (such as the Host header). [HTTP]
The HTTP specification requires that 301, 302, and 307 redirects, when applied
to methods other than the safe methods, not be followed without user confirmation. That would
be an appropriate prompt for the purposes of the requirement in the paragraph above. [HTTP]
If the algorithm was not invoked with the synchronous flag: 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.
Otherwise, return the resource or error information to the calling algorithm.
If the user agent can determine the actual length of the resource being fetched for an instance of this algorithm, and if that length is finite, then
that length is the file's size. Otherwise, the subject of
the algorithm (that is, the resource being fetched) has no known size. (For example, the HTTP Content-Length header might provide this information.)
The user agent must also keep track of the number of bytes
downloaded for each instance of this algorithm. This number must exclude any out-of-band
metadata, such as HTTP headers.
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.3 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.
[HTTP]
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.
User agents should warn the user that there is a potential problem whenever the user visits a
page that the user has previously visited, if the page uses less secure encryption on the second
visit.
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.
If a user bookmarks a site that uses a CA-signed certificate, and then later revisits that
site directly but the site has started using a self-signed certificate, the user agent could warn
the user that a man-in-the-middle attack is likely underway, instead of simply acting as if the
page was not encrypted.
2.6.4 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 MIME Sniffing specification. [MIMESNIFF]
The sniffed type of a resource must be found in a
manner consistent with the requirements given in the MIME Sniffing specification for finding the
sniffed media type of the relevant sequence of octets. [MIMESNIFF]
The rules for sniffing images specifically and
the rules for distinguishing if a resource is
text or binary are also defined in the MIME Sniffing specification. Both sets of rules
return a MIME type as their result. [MIMESNIFF]
It is imperative that the rules in the MIME Sniffing 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 MIME Sniffing specification. [MIMESNIFF]
2.6.5 Extracting character encodings from meta elements
The algorithm for extracting a character encoding from a meta element,
given a string s, is as follows. It either returns a character encoding or
nothing.
Let position be a pointer into s, initially
pointing at the start of the string.
Loop: Find the first seven characters in s after position that are an ASCII case-insensitive match for the word "charset". If no such match is found, return nothing and abort these
steps.
Skip any space characters that immediately follow the
word "charset" (there might not be any).
If the next character is not a "=" (U+003D), then move position to point just before that next character, and jump back to the step
labeled loop.
Skip any space characters that immediately follow the
equals sign (there might not be any).
Process the next character as follows:
If it is a """ (U+0022) character and there is a later """ (U+0022) character in s
If it is a "'" (U+0027) character and there is a later "'" (U+0027) character in s
Return the result of getting an encoding from the substring that is between
this character and the next earliest occurrence of this character.
If it is an unmatched """ (U+0022) character
If it is an unmatched "'" (U+0027) character
If there is no next character
Return nothing.
そうでなければ
Return the result of getting an encoding from the substring that consists of
this character up to but not including the first space character or ";" (U+003B) character, or the end of s, whichever comes first.
This algorithm is distinct from those in the HTTP specification (for example, HTTP
doesn't allow the use of single quotes and requires supporting a backslash-escape mechanism that
is not supported by this algorithm While the algorithm is used in contexts that, historically, were related to HTTP, the syntax as supported by implementations diverged some time ago. [HTTP]
When the user agent is required to perform a potentially CORS-enabled fetch of an
absolute URLURL with a mode mode that is
either "No CORS", "Anonymous", or "Use Credentials", optionally using a
referrer sourcereferrer source, with an originorigin, and with a default origin behaviour default
which is either "taint" or "fail", it must run the first applicable set of steps
from the following list. The default origin behaviour is only used if mode is
"No CORS". This algorithm wraps the fetch
algorithm above, and labels the obtained resource as either CORS-same-origin or
CORS-cross-origin, or blocks the resource entirely.
FetchURL, using referrer
source if one was specified, with the manual redirect flag set.
Loop: Wait for the fetch algorithm to know if the result is a
redirect or not.
Follow the first appropriate steps from the following list:
If the result of the fetch is a redirect, and the origin of the
target URL of the redirect is not the same origin as origin
Set URL to the target URL of the redirect and return to the top of
the potentially CORS-enabled fetch algorithm (this time, one of the other
branches below might be taken, based on the value of mode
FetchURL, using referrer
source if one was specified.
The tasks from the fetch algorithm are queued normally, but for the purposes of the calling algorithm, the
obtained resource is CORS-cross-origin. The user agent may report a cross-origin
resource access failure to the user (e.g. in a debugging console).
The URL does not have the same origin as origin, and default is fail.
Discard any data fetched as part of this algorithm, and prevent any tasks from such invocations of the fetch algorithm
from being queued.
For the purposes of the calling algorithm, the user agent must act as if there was a fatal
network error and no resource was obtained. The user agent may report a cross-origin resource
access failure to the user (e.g. in a debugging console).
Perform a cross-origin request with the request URL set
to URL, with the CORS referrer source set to referrer source if one was specified, the source origin set to origin, and with the omit credentials flag set if mode is "Anonymous" and not
set otherwise. [FETCH]
Discard all fetched data and prevent any tasks from
the fetch algorithm from being queued. For
the purposes of the calling algorithm, the user agent must act as if there was a fatal
network error and no resource was obtained. If a CORS resource sharing check
failed, the user agent may report a cross-origin resource access failure to the user (e.g.
in a debugging console).
In general, on getting, if the content attribute is not present, the IDL 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 IDL attribute is a DOMString attribute whose content attribute is
defined to contain a URL, then on getting, the IDL 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 IDL attribute must return the default value, if the content
attribute has one, or else the empty string.
If a reflecting IDL attribute is a DOMString attribute whose content attribute is
defined to contain one or more URLs, then on getting, the IDL 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 IDL attribute must return the default value, if the content attribute has one, or else
the empty string. On setting, the IDL attribute must set the content attribute to the specified
literal value.
If a reflecting IDL attribute is a DOMString attribute whose content attribute is
an enumerated attribute, and the IDL attribute is limited to only known
values, then, on getting, the IDL attribute must return the conforming value associated with
the state the attribute is in (in its canonical case), if any, or the empty string if the
attribute is in a state that has no associated keyword value or if the attribute is not in a defined state
(e.g. the attribute is missing and there is no missing value default); and on setting, the
content attribute must be set to the specified new value.
If a reflecting IDL attribute is a DOMString attribute 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 IDL attribute is a boolean attribute, then on getting the
IDL attribute must return true if the content attribute is set, and false if it is absent. On
setting, the content attribute must be removed if the IDL attribute is set to false, and must be
set to the empty string if the IDL attribute is set to true. (This corresponds to the rules for
boolean content attributes.)
If a reflecting IDL attribute has 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 IDL 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 and then that string must be used as the new content attribute value.
If a reflecting IDL attribute has a signed integer type (long) that is
limited to only non-negative numbers 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 IDL 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 negative, the user agent must throw an IndexSizeError
exception. Otherwise, the given value must be converted to the shortest possible string
representing the number as a valid non-negative integer and then that string must be
used as the new content attribute value.
If a reflecting IDL attribute has 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
0 to 2147483647 inclusive, 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, first, if the new value is in the
range 0 to 2147483647, then let n be the new value, otherwise let n be the default value, or 0 if there is no default value; then, n must be converted to the shortest possible string representing the number as a
valid non-negative integer and that string must be used as the new content attribute
value.
If a reflecting IDL attribute has an unsigned integer type (unsigned long) that is
limited to only non-negative numbers greater than zero, 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 1 to 2147483647 inclusive, 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 throw an IndexSizeError exception. Otherwise,
first, if the new value is in the range 1 to 2147483647, then let n be the new
value, otherwise let n be the default value, or 1 if there is no default
value; then, n must be converted to the shortest possible string representing
the number as a valid non-negative integer and that string must be used as the new
content attribute value.
If a reflecting IDL attribute has a floating-point number type (double or
unrestricted double), then, on getting, the content attribute must be parsed
according to the rules for parsing floating-point number values, and if that is
successful, the resulting value must be returned. If, on the other hand, it fails, 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
number as a floating-point number and then that string must be used as the new content
attribute value.
If a reflecting IDL attribute has a floating-point number type (double or
unrestricted double) that is limited to numbers greater than zero, then
the behavior is similar to the previous case, but zero and negative values are not allowed. 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 greater than 0.0,
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, if the value is less than or equal to zero, then the value must
be ignored. Otherwise, the given value must be converted to the best representation of the
number as a floating-point number and then that string must be used as the new content
attribute value.
The values Infinity and Not-a-Number (NaN) values throw an exception on setting,
as defined in the Web IDL specification. [WEBIDL]
If a reflecting IDL attribute has the type DOMTokenList or
DOMSettableTokenList, then on getting it must return a DOMTokenList or
DOMSettableTokenList object (as appropriate) whose associated element is the element
in question and whose associated attribute's local name is the name of the attribute in question.
The same DOMTokenList or DOMSettableTokenList object must be returned
every time for each attribute.
If a reflecting IDL 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 IDL attribute must return
null.
Let candidate be the element that the document.getElementById() method would find when
called on the content attribute's document if it were 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 IDL
attribute, then the IDL attribute must return null.
Otherwise, it must return candidate.
On setting, if the given element has an id attribute, and has the
same home subtree as the element of the attribute being set, and the given element is
the first element in that home subtree whose ID is
the value of that id attribute, then the content attribute must be
set to the value of that id attribute. Otherwise, the content
attribute must be set to the empty string.
The properties exposed in this way must be unenumerable.
The item(name) and namedItem(name)
methods must act according to the following algorithm:
If name is the empty string, return null and stop the algorithm.
Let collection be an HTMLCollection object rooted at the
same Document as the HTMLAllCollection object on which the method was
invoked, whose filter matches only elements that are either:
The supported property names consist of the non-empty values of all the id and name attributes of all the
elements represented by the collection, in tree order, ignoring later
duplicates, with the id of an element preceding its name if it contributes both, they differ from each other, and neither is the
duplicate of an earlier entry.
The properties exposed in this way must be unenumerable.
The namedItem(name) method must act according to the following algorithm:
If name is the empty string, return null and stop the 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 IDL 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.
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). Mutation events must be fired as if a DocumentFragment containing the new
option elements had been inserted. 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 supported property names consist of the non-empty values of all the id and name attributes of all the
elements represented by the collection, in tree order, ignoring later
duplicates, with the id of an element preceding its name if it contributes both, they differ from each other, and neither is
the duplicate of an earlier entry.
The properties exposed in this way must be unenumerable.
When the user agent is to set the value of a new
indexed property or set the value of an existing indexed property for a given property index
index to a new value value, it must run the following
algorithm:
If value is null, invoke the steps for the remove method with index as
the argument, 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 NotFoundError exception and abort these steps.
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 beforeth 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 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:
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 supported property names 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, in the order returned.
To determine the value of a named property name in a DOMStringMap, the user agent must return 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.
To set the value of a new or existing named property name to 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.
To delete an existing named property 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.
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
}
}
When a DOMElementMap object is instantiated, it is associated with three
algorithms, one for getting the list of name-element mappings, one for mapping a name to a certain
element, and one for deleting mappings by name.
The supported property names on a DOMElementMap object at any instant
are the names for each mapping returned from the algorithm for getting the list of name-element
mappings at that instant, in the order returned.
To determine the value of a named property name in a DOMElementMap, the user agent must return the element
component of the name-element mapping whose name component is name in the list
returned by the algorithm for getting the list of name-element mappings.
To set the value of a new or existing named property name to value
value, the algorithm for mapping a name to a certain element must be run,
passing name as the name value as the element.
To delete an existing named property name, the algorithm for deleting mappings must be run, passing name as the name component of the mapping to be deleted.
The DOMElementMap interface definition here is only intended for
JavaScript environments. Other language bindings will need to define how
DOMElementMap is to be implemented for those languages.
To transfer a Transferable object to a new owner, the user agent must
run the steps defined for the type of object in question. The steps will return a new object of
the same type, and will permanently neuter the
original object. (This is an irreversible and non-idempotent operation; once an object has been
transferred, it cannot be transferred, or indeed used, again.)
To transfer an
ArrayBuffer object old to a new owner owner, a user agent must create a new ArrayBuffer object pointing at
the same underlying data as old, thus obtaining new,
must neuter the old
object, and must finally return new. [ECMA262]
When a user agent is required to obtain a structured clone of a value, optionally
with a transfer map, it must run the following algorithm, which either returns a separate
value, or throws an exception. If a transfer map is provided, it consists of an association
list of Transferable objects to placeholder objects.
Let input be the value being cloned.
Let transfer map be the transfer map passed to the algorithm,
if any, or the empty list otherwise.
Let memory be an association list of pairs of objects, initially
empty. This is used to handle duplicate references. In each pair of objects, one is called the
source object and the other the destination object.
For each mapping in transfer map, add a mapping from the
Transferable object (the source object) to the placeholder object (the destination
object) to memory.
Let output be the value resulting from calling the internal
structured cloning algorithm with input as the "input" argument, and memory as the "memory" argument.
Return output.
The internal structured cloning algorithm is always called with two arguments, input and memory, and its behavior is as follows:
If input is the source object of a pair of objects in memory, then return the destination object in that pair of objects and abort these
steps.
If input is a primitive value, then return that value and abort these
steps.
Let deep clone be none.
The input value is an object. Jump to the appropriate step below:
If input is a Boolean object
Let output be a newly constructed Boolean object with the same value
as input.
If input is a Number object
Let output be a newly constructed Number object with the same value
as input.
If input is a String object
Let output be a newly constructed String object with the same value
as input.
If input is a Date object
Let output be a newly constructed Date object with the
same value as input.
If input is a RegExp object
Let output be a newly constructed RegExp object with the
same pattern and flags as input.
The value of the lastIndex property is not copied.
If input has been disabled through the close() method, throw a DataCloneError exception
and abort the overall structured clone algorithm. Otherwise, let output be a newly constructed object of the same class as input, corresponding to the same underlying data.
Let output be a newly constructed FileList object
containing a list of newly constructed File objects corresponding to the same
underlying data as those in input, maintaining their relative
order.
If input is an ImageData object
Let output be a newly constructed ImageData object
whose width and height have values equal to the corresponding attributes
on input, and whose data
attribute has the value obtained from invoking the internal structured cloning
algorithm recursively with the value of the data attribute on input as the new
"input" argument and memory as the new "memory" argument.
If input has been neutered, throw a DataCloneError
exception and abort the overall structured clone algorithm. Otherwise, let output be a newly constructed ArrayBuffer object whose contents
are a copy of input's contents, with the same length.
If input is an object with a [[DataView]] internal slot
Let output be a newly constructed object of the same class as input, with its [[DataView]] internal property present, its
[[ViewedArrayBuffer]] internal property set to the value obtained from invoking the
internal structured cloning algorithm recursively with the value of the internal
property on input as the new "input" argument and
memory as the new "memory" argument, and with the
[[ByteLength]] and [[ByteOffset]] internal properties set to the same value as their
counterparts on input.
If input is an Array object
Let output be a newly constructed empty Array object
whose length is equal to the length of input, and set deep clone to own.
This means that the length of sparse arrays is preserved.
If input is an Object object
Let output be a newly constructed empty Object object, and set deep clone to own.
If input is a Map object
Let output be a newly constructed empty Map
object, and set deep clone to map.
If input is a Set object
Let output be a newly constructed empty Set
object, and set deep clone to set.
If input is an object that another specification defines how to clone
Let output be a clone of the object as defined by the other
specification.
If input is another native object type (e.g. Error,
Function)
For the purposes of the algorithm above, an object is a particular type of object class if its [[Class]] internal property is equal to class.
For example, "input is an Object
object" if input's [[Class]] internal property is equal to the string
"Object".
Add a mapping from input (the source object) to output (the destination object) to memory.
If deep clone is set to map, then run these substeps. These
substeps use the terminology and typographic conventions used in the JavaScript specification's
definition of Maps. [ECMA262]
Let source be the List that is the value of input's [[MapData]] internal slot, if any. If there is no such slot, then
instead throw a DataCloneError exception and abort the overall structured
clone algorithm. [ECMA262]
Let target be the List that is the value of output's [[MapData]] internal slot.
For each Record {[[key]], [[value]]} entry that is an element of
source, run the following substeps:
Let key have the value obtained from invoking the
internal structured cloning algorithm recursively with entry.[[key]] as the new "input" argument and memory as the new "memory" argument.
Let value have the value obtained from invoking the
internal structured cloning algorithm recursively with entry.[[value]] as the new "input" argument and memory as the new "memory" argument.
Let new entry be the Record {[[key]]: key,
[[value]]: value}.
Append new entry as the last element of target.
Set deep clone to own.
If deep clone is set to set, then run these substeps. These
substeps use the terminology and typographic conventions used in the JavaScript specification's
definition of Sets. [ECMA262]
Let source be the List that is the value of input's [[SetData]] internal slot, if any. If there is no such slot, then
instead throw a DataCloneError exception and abort the overall structured
clone algorithm. [ECMA262]
Let target be the List that is the value of output's [[SetData]] internal slot.
For each entry that is an element of source that
is not empty, run the following substeps:
Let new entry have the value obtained from invoking the
internal structured cloning algorithm recursively with entry as the new "input" argument and memory as the new "memory" argument.
Append new entry as the last element of target.
Set deep clone to own.
If deep clone is set to own, then, for each enumerable own
property in input, run the following steps:
Let name be the name of the property.
Let source value be the result of calling the [[Get]] internal
method of input with the argument name. If the
[[Get]] internal method of a property involved executing script, and that script threw an
uncaught exception, then abort the overall structured clone algorithm, with that
exception being passed through to the caller.
Let cloned value be the result of invoking the internal
structured cloning algorithm recursively with source value as the
"input" argument and memory as the "memory" argument. If this results in an exception, then abort the overall
structured clone algorithm, with that exception being passed through to the
caller.
Add a new property to output having the name name, and having the value cloned value.
The order of the properties in the input and output
objects must be the same, and any properties whose [[Get]] internal method involves running
script must be processed in that same order.
This does not walk the prototype chain.
Property descriptors, setters, getters, and analogous features are not copied in
this process. For example, the property in the input could be marked as read-only, but in the
output it would just have the default state (typically read-write, though that could depend on
the scripting environment).
Properties of Array objects are not treated any differently than those of other
Objects. In particular, this means that non-index properties of arrays are copied as well.
Return output.
This algorithm preserves cycles and preserves the identity of duplicate objects in
graphs.
There is an implied strong reference from any IDL 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.
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.
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) character.
The day component of the date.
A "/" (U+002F) character.
The year component of the date.
A U+0020 SPACE character.
The hours component of the time.
A ":" (U+003A) character.
The minutes component of the time.
A ":" (U+003A) character.
The seconds component of the time.
All the numeric components above, other than the year, must be given as two ASCII
digits representing the number in base ten, zero-padded if necessary. The year must be
given as the shortest possible string of four or more ASCII digits 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.
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, an
XML parser, or an XSLT processor, and 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 named readystatechange at the Document object.
Let element be the first title element in
the SVG namespace that is a child of the root element, if any. If
there isn't one, create a title element in the SVG
namespace, append it to the root element, and let element be that element. [SVG]
Act as if the textContent IDL attribute of element was
set to the new value being assigned.
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, if there is no root element, throw a HierarchyRequestError exception
and abort these steps.
Otherwise, the body element is null, but there's a root element. 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.
The getElementsByName(name) method takes a string name, and must
return a liveNodeList containing all the HTML elements in
that document that have a name attribute whose value is equal to the name argument (in a case-sensitive manner), in tree
order. When the method is invoked on a Document object again with the same
argument, the user agent may return the same as the object returned by the earlier call. In other
cases, a new NodeList object must be returned.
When a Document is created, it must be associated with an initially-empty CSS
ID overrides list, which consists of a list of mappings each of which consists of a string
name mapped to an Element node.
On getting, the cssElementMap IDL attribute
must return a DOMElementMap object, associated with the following algorithms, which
expose the current mappings:
The algorithm for getting the list of name-element mappings
Return the Document's CSS ID overrides list, maintaining the order
in which the entries were originally added to the list.
The algorithm for mapping a name to a certain element
Let name be the name passed to the algorithm and element be the Element passed to the algorithm.
If element is null, run the algorithm for deleting mappings by name,
passing it name.
Otherwise, if there is an entry in the Document's CSS ID overrides
list whose name is name, replace its current value with element.
The currentScript attribute, on
getting, must return the value to which it was most recently initialized. When the
Document is created, the currentScript must be initialised to null.
The Document interface supports named properties. The supported property names at
any moment consist of the values of the name content attributes of
all the
applet,
exposedembed,
form,
iframe,
img, and
exposedobject
elements in the Document that have non-empty name content
attributes, and the values of the id content attributes of all the
applet and
exposedobject
elements in the Document that have non-empty id content
attributes, and the values of the id content attributes of all the
img
elements in the Document that have both non-empty name content attributes and non-empty id
content attributes. The supported property names must be in tree order,
ignoring later duplicates, with values from id attributes coming
before values from name attributes when the same element contributes
both.
To determine the value of a named propertyname when the Document object is indexed for property
retrieval, the user agent must return the value obtained using the following steps:
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.
Replace all the children of document by the children of result (even if it has no children), firing mutation events as if a
DocumentFragment containing the new children had been inserted.
<!DOCTYPE HTML>
<html lang="en">
<head>
<title>My Page</title>
</head>
<body>
<h1>Welcome to my page</h1>
<p>I like cars and lorries and have a big Jeep!</p>
<h2>Where I live</h2>
<p>I live in a small hut on a mountain!</p>
</body>
</html>
ユーザーエージェントが文書を処理している間に、スクリプトやその他のメカニズムの使用を介して、属性値、テキスト、文書の全体構造は実際に動的に変更するかもしれない。ある瞬間において文書のセマンティックは、その瞬間における文書の状態によって表されるものであり、したがって、文書のセマンティックは、時間の経過とともに変化する。User agents must update their presentation of the document as this occurs.
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).
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.
This is then followed by a description of what the element represents, along with any additional normative conformance criteria that may apply to authors and implementations. 時に例も含まれる。
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:r="http://www.w3.org/1999/02/22-rdf-syntax-ns#" lang="en">
<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>
<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>
<section>
<ins><h2>Example of paragraphs</h2>
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 as well as 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, and indirectly through elements in other namespaces that allow HTML
to be further embedded therein, like svg or math).
<header>
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.
</header>
<section>
<h2>My Cats</h2>
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>
5つの段落が存在する：
"You can play with my cat simulator. object I'm quite proud of it."とある段落。ここでobjectはobject要素である。
"To see the cat simulator, use one of the following links:"とある段落。
"Download simulator file"とある段落。
"Use online simulator"とある段落。
"Alternatively, upgrade to the Mellblom Browser."とある段落。
<section>
<h2>My Cats</h2>
<p>You can play with my cat simulator.</p>
<object data="cats.sim">
<p>To see the cat simulator, use one of the following links:</p>
<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>
<p>Alternatively, upgrade to the Mellblom Browser.</p>
</object>
<p>I'm quite proud of it.</p>
</section>
3.2.5 グローバル属性
The following attributes are common to and may be specified on all HTML
elements (even those not defined in this specification):
These attributes are only defined by this specification as attributes for HTML
elements. When this specification refers to elements having these attributes, elements from
namespaces that are not defined as having these attributes must not be considered as being
elements with these attributes.
For example, in the following XML fragment, the "bogus" element does not
have a dir attribute as defined in this specification, despite
having an attribute with the literal name "dir". Thus, the
directionality of the inner-most span element is 'rtl', inherited from the div element indirectly through
the "bogus" element.
The advisory information of an element is the value that the following algorithm
returns, with the algorithm being aborted once a value is returned. When the algorithm returns the
empty string, then there is no advisory information.
If the element is a link, style, dfn,
abbr, or menuitem element, then: if the element has a title attribute, return the value of that attribute,
otherwise, return the empty string.
Otherwise, if the element has a title attribute, then
return its value.
Otherwise, if the element has a parent element, then return the parent element's
advisory information.
Otherwise, return the empty string.
User agents should inform the user when elements have advisory information,
otherwise the information would not be discoverable.
The title IDL attribute must reflect the
title content attribute.
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 (regardless of its value).
If neither the node nor any of the node's ancestors, including the root element,
have either attribute set, but there is a pragma-set default language set, then that
is the language of the node. If there is no pragma-set default language set, then
language information from a higher-level protocol (such as HTTP), if any, must be used as the
final fallback language instead. In the absence of any such language information, and in cases
where the higher-level protocol reports multiple languages, the language of the node is unknown,
and the corresponding language tag is the empty string.
If the resulting value is not a recognised language tag, then it must be treated as an unknown
language having the given language tag, distinct from all other languages. For the purposes of
round-tripping or communicating with other services that expect language tags, user agents should
pass unknown language tags through unmodified, and tagged as being BCP 47 language tags, so that
subsequent services do not interpret the data as another type of language description. [BCP47]
Thus, for instance, an element with lang="xyzzy" would be
matched by the selector :lang(xyzzy) (e.g. in CSS), but it would not be
matched by :lang(abcde), even though both are equally invalid. Similarly, if
a Web browser and screen reader working in unison communicated about the language of the element,
the browser would tell the screen reader that the language was "xyzzy", even if it knew it was
invalid, just in case the screen reader actually supported a language with that tag after all.
Even if the screen reader supported both BCP 47 and another syntax for encoding language names,
and in that other syntax the string "xyzzy" was a way to denote the Belarusian language, it would
be incorrect for the screen reader to then start treating text as Belarusian, because
"xyzzy" is not how Belarusian is described in BCP 47 codes (BCP 47 uses the code "be" for
Belarusian).
If the resulting value is the empty string, then it must be interpreted as meaning that the
language of the node is explicitly unknown.
User agents may use the element's language to determine proper processing or rendering (e.g. in
the selection of appropriate fonts or pronunciations, for dictionary selection, or for the user
interfaces of form controls such as date pickers).
The lang IDL attribute must reflect the
lang content attribute in no namespace.
The translate IDL attribute must, on getting,
return true if the element's translation mode is translate-enabled, and
false otherwise. On setting, it must set the content attribute's value to "yes" if the new value is true, and set the content attribute's value to "no" otherwise.
<!DOCTYPE HTML>
<html> <!-- default on the root element is translate=yes -->
<head>
<title>The Bee Game</title> <!-- implied translate=yes inherited from ancestors -->
</head>
<body>
<p>The Bee Game is a text adventure game in English.</p>
<p>When the game launches, the first thing you should do is type
<kbd translate=no>eat honey</kbd>. The game will respond with:</p>
<pre><samp translate=no>Yum yum! That was some good honey!</samp></pre>
</body>
</html>
<p dir=auto class="u1"><b><bdi>Student</bdi>:</b> How do you write "What's your name?" in Arabic?</p>
<p dir=auto class="u2"><b><bdi>Teacher</bdi>:</b> ما اسمك؟</p>
<p dir=auto class="u1"><b><bdi>Student</bdi>:</b> Thanks.</p>
<p dir=auto class="u2"><b><bdi>Teacher</bdi>:</b> That's written "شكرًا".</p>
<p dir=auto class="u2"><b><bdi>Teacher</bdi>:</b> Do you know how to write "Please"?</p>
<p dir=auto class="u1"><b><bdi>Student</bdi>:</b> "من فضلك", right?</p>
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. (Duplicates are ignored.)
In user agents that support CSS, the attribute's value must be parsed when the attribute is
added or has its value changed,
according to the rules given for CSS styling
attributes. [CSSATTR]
<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>
The dataset IDL attribute provides convenient
accessors for all the data-* attributes on an element. On
getting, the dataset IDL 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-" and whose remaining characters (if any) do not include any
uppercase ASCII letters, in the order that those attributes are listed in the
element's attribute list, add a name-value pair to list whose
name is the attribute's name with the first five characters removed and whose value is the
attribute's value.
For each name in list, for each "-" (U+002D) character in the
name that is followed by a lowercase ASCII letter,
remove the "-" (U+002D) character and replace the character that followed it by the
same character converted to ASCII uppercase.
Return list.
The algorithm for setting names to certain values
Let name be the name passed to the algorithm.
Let value be the value passed to the algorithm.
If name contains a "-" (U+002D) character followed by a
lowercase ASCII letter, throw a
SyntaxError exception and abort these steps.
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 thrown an exception when setting an attribute with
the name name, then this must throw the same exception.
Remove the attribute with the name name, if such an attribute exists.
Do nothing otherwise.
This algorithm will only get invoked by the Web IDL specification for names that
are given by the earlier algorithm for getting the list of name-value pairs. [WEBIDL]
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.
HTML要素のコンテンツでTextノードをもつHTML要素におけるテキストコンテンツ、および自由形式のテキストを許可するHTML要素の属性のテキストは、U+202AからU+202Eまでの範囲（双方向アルゴリズムの書式設定文字）の文字を含んでもよい。ただし、これらの文字の使用は、これらの文字によって生成される任意の埋め込みまたは上書きが、異なる親要素で開始または終了できないよう、かつすべてのそのような埋めこみと上書きが明示的にU+202C POP DIRECTIONAL FORMATTING文字で終わるように制限される。これは、双方向アルゴリズム上の予期しない効果を持つ方法で再利用されるテキストの発生を減少させるのに役立つ。[BIDI]
User agents must implement the Unicode bidirectional algorithm to determine the proper ordering
of characters when rendering documents and parts of documents. [BIDI]
The mapping of HTML to the Unicode bidirectional algorithm must be done in one of three ways.
Either the user agent must implement CSS, including in particular the CSS 'unicode-bidi',
'direction', and 'content' properties, and must have, in its user agent style sheet, the rules
using those properties given in this specification's rendering section,
or, alternatively, the user agent must act as if it implemented just the aforementioned properties
and had a user agent style sheet that included all the aforementioned rules, but without letting
style sheets specified in documents override them, or, alternatively, the user agent must
implement another styling language with equivalent semantics. [CSSWM][CSSGC]
The following elements and attributes have requirements defined by the rendering section that, due to the requirements in this section, are
requirements on all user agents (not just those that support the suggested
default rendering):
Using WAI-ARIA in HTML - アクセシブル・リッチ・インターネット・アプリケーション仕様[ARIA]を使用してHTML要素にアクセシビリティー情報を追加する方法についての開発者のための実用的なガイド。特に推奨表は、どのARIAロール（role）、ステート（state）およびプロパティーが各HTML要素に使用に適切かについて、著者に対して完全なリファレンスを提供する。
User agents must implement ARIA semantics on all HTML elements, as defined in the
ARIA specifications. The default implicit ARIA semantics defined below must be
recognised by implementations for the purposes of ARIA processing. [ARIAIMPL]
The ARIA attributes defined in the ARIA specifications, and the strong
native semantics and default implicit ARIA semantics defined below, do not
have any effect on CSS pseudo-class matching, user interface modalities that don't use assistive
technologies, or the default actions of user interaction events as described in this
specification.
The WAI-ARIA role that an HTML element has assigned to it is the
first non-abstract role found in the list of values generated when the
role attribute is split on
spaces.
次の表は、強いネイティヴセマンティックかつHTML要素に適用する対応するデフォルトの暗黙のARIAセマンティックを定義する。1列目のセルでそれぞれの言語機能（要素または属性）は同じ行の2列目のセルで与えられるARIAセマンティック（ロール、ステート、およびプロパティー）を意味する。When multiple rows apply to an element, the role from the last row to define a role must be applied, and the states and properties from all the rows must be combined.
The WAI-ARIA specification neither requires or forbids user
agents from enhancing native presentation and interaction behaviors
on the basis of WAI- ARIA markup. Even mainstream user agents might
choose to expose metadata or navigational features directly or via
user-installed extensions; for example, exposing required form
fields or landmark navigation. User agents are encouraged to
maximize their usefulness to users, including users without
disabilities.
Conformance checkers are encouraged to phrase errors such that authors are encouraged to use
more appropriate elements rather than remove accessibility annotations. For example, if an
a element is marked as having the button
role, a conformance checker could say "Use a more appropriate element to represent a button, for
example a button element or an input element" rather than "The button role cannot be used with a elements".
<!DOCTYPE html>
<html lang="en">
<head>
<title>Swapping Songs</title>
</head>
<body>
<h1>Swapping Songs</h1>
<p>Tonight I swapped some of the songs I wrote with some friends, who
gave me some of the songs they wrote. I love sharing my music.</p>
</body>
</html>
The IDL attribute text must return a
concatenation of the contents of all the Text nodes that are children of the
title element (ignoring any other nodes such as comments or elements), in tree order.
On setting, it must act the same way as the textContent IDL attribute.
<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...
User agents should use the document's title when referring to the document in their user
interface. When the contents of a title element are used in this way, the
directionality of that title element should be used to set the directionality
of the document's title in the user interface.
If there are multiple base elements with target attributes, all but the first are ignored.
A base element that is the first base element with an href content attribute in a particular Document has a
frozen base URL. The frozen base URL must be set, synchronously, whenever any of the following situations occur:
<!DOCTYPE html>
<html lang="en">
<head>
<title>This is an example for the <base> element</title>
<base href="http://www.example.com/news/index.html">
</head>
<body>
<p>Visit the <a href="archives.html">archives</a>.</p>
</body>
</html>
（関係を）示されるリンクの種類はrel属性値によって与えられ、存在する場合、スペースで区切られたトークンの集合である値を持たなければならない。許可されたキーワードとその意味は、後の節で定義される。If the rel attribute is absent, has no keywords, or if none of the keywords used are allowed according to the definitions in this specification, then the element does not create any links.
For external resources that are represented in the DOM (for example, style sheets), the DOM
representation must be made available (modulo cross-origin restrictions) even if the resource is
not applied. To obtain the resource, the user agent must
run the following steps:
If the href attribute's value is the empty string,
then abort these steps.
Resolve the URL given by the href attribute, relative to the element.
If the previous step fails, then abort these steps.
User agents may opt to only try to obtain such resources when they are needed, instead of
pro-actively fetching all the external resources that are not
applied.
The semantics of the protocol used (e.g. HTTP) must be followed when fetching external
resources. (For example, redirects will be followed and 404 responses will cause the external
resource to not be applied.)
Once the attempts to obtain the resource and its critical subresources are
complete, the user agent must, if the loads were successful, queue a task to
fire a simple event named load at the
link element, or, if the resource or one of its critical subresources
failed to completely load for any reason (e.g. DNS error, HTTP 404 response, a connection being
prematurely closed, unsupported Content-Type), queue a task to fire a simple
event named error at the link element.
Non-network errors in processing the resource or its subresources (e.g. CSS parse errors, PNG
decoding errors) are not failures for the purposes of this paragraph.
The element must delay the load event of the element's document until all the
attempts to obtain the resource and its critical subresources are complete.
(Resources that the user agent has not yet attempted to obtain, e.g. because it is waiting for the
resource to be needed, do not delay the load event.)
Interactive user agents may provide users with a means to follow the hyperlinks created using the link element, somewhere
within their user interface. The exact interface is not defined by this specification, but it
could include the following information (obtained from the element's attributes, again as defined
below), in some form or another (possibly simplified), for each hyperlink created with each
link element in the document:
The relationship between this document and the resource (given by the rel attribute)
The title of the resource (given by the title
attribute).
The address of the resource (given by the href
attribute).
The language of the resource (given by the hreflang
attribute).
The optimum media for the resource (given by the media
attribute).
User agents could also include other information, such as the type of the resource (as given by
the type attribute).
If the link is a hyperlink then the media
attribute is purely advisory, and describes for which media the document in question was
designed.
However, if the link is an external resource link, then the media attribute is prescriptive. The user agent must apply the
external resource when the media attribute's value
matches the environment and the other relevant conditions apply, and must not apply
it otherwise.
The external resource might have further restrictions defined within that limit
its applicability. For example, a CSS style sheet might have some @media
blocks. This specification does not override such further restrictions or requirements.
外部リソースへのリンクについて、それらがサポートしないリソースの再取得を回避できるように、type属性はユーザーエージェントへのヒントとして使用される。If the attribute is present, then the user agent must assume that the resource is of the given type (even if that is not a valid MIME type, e.g. the empty string). If the attribute is omitted, but the external resource link type has a default type defined, then the user agent must assume that the resource is of that type. If the UA does not support the given MIME type for the given link relationship, then the UA should not obtain the resource; if the UA does support the given MIME type for the given link relationship, then the UA should obtain the resource at the appropriate time as specified for the external resource link's particular type. If the attribute is omitted, and the external resource link type does not have a default type defined, but the user agent would obtain the resource if the type was known and supported, then the user agent should obtain the resource under the assumption that it will be supported.
User agents must not consider the type attribute
authoritative — upon fetching the resource, user agents must not use the type attribute to determine its actual type. Only the actual type
(as defined in the next paragraph) is used to determine whether to apply the resource,
not the aforementioned assumed type.
If the external resource link type defines rules for processing
the resource's Content-Type metadata, then those rules apply.
Otherwise, if the resource is expected to be an image, user agents may apply the image sniffing rules, with the official
type being the type determined from the resource's Content-Type
metadata, and use the resulting sniffed type of the resource as if it was the actual type.
Otherwise, if neither of these conditions apply or if the user agent opts not to apply the image
sniffing rules, then the user agent must use the resource's Content-Type metadata to determine the type of the resource. If there
is no type metadata, but the external resource link type has a default type defined, then the user
agent must assume that the resource is of that type.
Once the user agent has established the type of the resource, the user agent must apply the
resource if it is of a supported type and the other relevant conditions apply, and must ignore the
resource otherwise.
If a document contains style sheet links labeled as follows:
...then a compliant UA that supported only CSS style sheets would fetch the B and C files, and
skip the A file (since text/plain is not the MIME type for CSS style
sheets).
For files B and C, it would then check the actual types returned by the server. For those that
are sent as text/css, it would apply the styles, but for those labeled as
text/plain, or any other type, it would not.
If one of the two files was returned without a Content-Type metadata, or with a
syntactically incorrect type like Content-Type: "null", then the
default type for stylesheet links would kick in. Since that
default type is text/css, the style sheet would nonetheless be
applied.
HTTP Link: headers, if supported, must be assumed to come before
any links in the document, in the order that they were given in the HTTP message. These headers
are to be processed according to the rules given in the relevant specifications. [HTTP][WEBLINK]
Registration of relation types in HTTP Link: headers is distinct from HTML link types, and thus their semantics can be different from same-named
HTML types.
The IDL attributes href, rel, rev, media,
hreflang, type, and sizes each must reflect the respective
content attributes of the same name.
The name and content IDL attributes must reflect the
respective content attributes of the same name. The IDL attribute httpEquiv must reflect the content
attribute http-equiv.
User agents may use the application name in UI in preference to the page's
title, since the title might include status messages and the like relevant to the
status of the page at a particular moment in time instead of just being the name of the
application.
To find the application name to use given an ordered list of languages (e.g. British English,
American English, and English), user agents must run the following steps:
Let languages be the list of languages.
Let default language be the language of the
Document's root element,
if any, and if that language is not unknown.
If there is a default language, and if it is not the same language
as any of the languages in languages, append it to languages.
Let winning language be the first language in languages for which there is a meta element in the
Document that has its name attribute set to
the value application-name and whose
language is the language in question.
If none of the languages have such a meta element, then abort these steps;
there's no given application name.
This algorithm would be used by a browser when it needs a name for the page, for
instance, to label a bookmark. The languages it would provide to the algorithm would be the
user's preferred languages.
Return keywords. This is the list of keywords that the author has
specified as applicable to the page.
User agents should not use this information when there is insufficient confidence in the
reliability of the value.
For instance, it would be reasonable for a content management system to use
the keyword information of pages within the system to populate the index of a site-specific
search engine, but a large-scale content aggregator that used this information would likely find
that certain users would try to game its ranking mechanism through the use of inappropriate
keywords.
Conformance checkers may use the information given on the WHATWG
Wiki MetaExtensions page to establish if a value is allowed or not:
values defined in this specification or marked as "proposed" or
"ratified" must be accepted, whereas values marked as "discontinued"
or not listed in either this specification or on the aforementioned
page must be reported as invalid. Conformance checkers may cache
this information (e.g. for performance reasons or to avoid the use
of unreliable network connectivity).
When an author uses a new metadata name not defined by either this specification or the Wiki
page, conformance checkers should offer to add the value to the Wiki, with the details described
above, with the "proposed" status.
http-equiv属性は、列挙属性である。以下の表は、この属性に対して定義されたキーワードを列挙する。キーワードとともにその行の最初のセルに与えられた状態は、これらキーワードが対応する状態を与える。Some of the keywords are non-conforming, as noted in the last column.
When a meta element is inserted
into the document, if its http-equiv attribute is
present and represents one of the above states, then the user agent must run the algorithm
appropriate for that state, as described in the following list:
Content language state
(http-equiv="content-language")
This feature is non-conforming. Authors are encouraged to use the lang attribute instead.
This pragma sets the pragma-set default language. Until such a pragma is
successfully processed, there is no pragma-set default language.
If the meta element has no content
attribute, then abort these steps.
If the element's content attribute contains a
"," (U+002C) character then abort these steps.
Let input be the value of the element's content attribute.
Let position point at the first character of input.
If the value consists of multiple space-separated tokens, tokens after the
first are ignored.
This pragma is almost, but not quite, entirely unlike the HTTP
Content-Language header of the same name. [HTTP]
エンコーディング宣言状態（http-equiv="content-type"）
エンコーディング宣言状態は、charset属性の設定の単なる代替形式である。これは文字エンコーディング宣言である。This state's user agent requirements are all handled by the parsing section of the specification.
If another meta element with an http-equiv attribute in the Refresh state has already been successfully
processed (i.e. when it was inserted the user agent processed it and reached the last step of
this list of steps), then abort these steps.
If the meta element has no content
attribute, or if that attribute's value is the empty string, then abort these steps.
Let input be the value of the element's content attribute.
Let position point at the first character of input.
If the character in input pointed to by position
is a ";" (U+003B) character or a "," (U+002C) character, then advance position to the next character. Otherwise, jump to the last step.
If the character in input pointed to by position
is a "U" (U+0055) character or a U+0075 LATIN SMALL LETTER U character
(u), then advance position to the next character. Otherwise, jump to the
last step.
If the character in input pointed to by position
is a "R" (U+0052) character or a U+0072 LATIN SMALL LETTER R character
(r), then advance position to the next character. Otherwise, jump to the
last step.
If the character in input pointed to by position
is s "L" (U+004C) character or a U+006C LATIN SMALL LETTER L character
(l), then advance position to the next character. Otherwise, jump to the
last step.
If the character in input pointed to by position
is either a "'" (U+0027) character or """ (U+0022) character, then let
quote be that character, and advance position to the
next character. Otherwise, let quote be the empty string.
Let url be equal to the substring of input from
the character at position to the end of the string.
If quote is not the empty string, and there is a character in url equal to quote, then truncate url at
that character, so that it and all subsequent characters are removed.
For the purposes of the previous paragraph, a refresh is said to have come due as soon as
the later of the following two conditions occurs:
At least time seconds have elapsed since the document has
completely loaded, adjusted to take into account user or user agent
preferences.
At least time seconds have elapsed since the meta
element was inserted into the
Document, adjusted to take into account user or user agent
preferences.
In addition, the user agent may, as with anything, inform the user of any and all aspects
of its operation, including the state of any timers, the destinations of any timed redirects,
and so forth.
a valid non-negative integer, followed by a U+003B SEMICOLON character
(;), followed by one or more space characters, followed
by a substring that is an ASCII case-insensitive match for the string "URL", followed by a "=" (U+003D) character, followed by a valid
URL that does not start with a literal "'" (U+0027) or """ (U+0022) character.
Conformance checkers must use the information given on the WHATWG Wiki PragmaExtensions page to
establish if a value is allowed or not: values defined in this specification or listed on the
aforementioned page must be accepted, whereas values not listed in either this specification or on
the aforementioned page must be rejected as invalid. Conformance checkers may cache this
information (e.g. for performance reasons or to avoid the use of unreliable network
connectivity).
Authoring tools should default to using UTF-8 for newly-created documents. [ENCODING]
0x20から0x7Eまでの範囲で一連のバイトがU+0020からU+007Eまでの範囲の文字を比較する以外の文字にデコードできるエンコーディングは、潜在的なセキュリティー脆弱性を表す。エンコーディングをサポートしない（またはエンコーディングを宣言するために使用されるラベルをサポートしない、または他のユーザーエージェントのようにラベル付けされないコンテンツのエンコーディングを宣言する同じメカニズムを使用しない）ユーザーエージェントは、結局はHTMLタグおよびJavaScriptとして技術的に温和なプレーンテキストの文脈で解釈することになるかもしれない。したがって、著者はこれらのエンコーディングを使用すべきではない。たとえば、ASCIIで"<script>"に対応するバイトのエンコーディングに適用すると、異なる文字列をデコードする可能性がある。Authors should not use such encodings, which are known to include JIS_C6226-1983, JIS_X0212-1990,
HZ-GB-2312, JOHAB (Windows code page 1361), encodings based on
ISO-2022, and encodings based on EBCDIC. さらに、著者は、CESU-8、UTF-7、BOCU-1およびSCSUエンコーディングを使用してはならない。これらのエンコーディングはウェブコンテンツへの使用に対して全く意図されていないため、このカテゴリに分類される。[RFC1345][RFC1842][RFC1468][RFC2237][RFC1554][CP50220][RFC1922][RFC1557][CESU8][UTF7][BOCU1][SCSU]
When examining types
to determine if they support the language, user agents must not ignore unknown MIME parameters
— types with unknown parameters must be assumed to be unsupported. The charset parameter must be treated as an unknown parameter for the purpose of
comparing MIME types here.
media属性は、スタイルが適用されるメディアを言う。値は妥当なメディアクエリでなければならない。The user agent must apply the styles when the media attribute's value matches the environment and the other relevant conditions apply, and must not apply them otherwise.
The styles might be further limited in scope, e.g. in CSS with the use of @media blocks. This specification does not override such further restrictions or
requirements.
...the user agent must queue a task to invoke the update a style
block algorithm that applies for the style sheet language specified by the element's type attribute, passing it the element's style
data.
For styling languages that consist of pure text (as opposed to XML), a style
element's style data is the concatenation of the contents of all the
Text nodes that are children of the style element (not any other nodes
such as comments or elements), in tree order. For XML-based styling languages, the
style data consists of all the child nodes of the style element.
This is a reference to the (possibly absent at this time) attribute, rather
than a copy of the attribute's current value. The CSSOM specification defines what happens
when the attribute is dynamically set, changed, or removed.
This specification does not define any other styling language's update a style
block algorithm.
Once the attempts to obtain the style sheet's critical subresources, if any, are
complete, or, if the style sheet has no critical subresources, once the style sheet
has been parsed and processed, the user agent must, if the loads were successful or there were
none, queue a task to fire a simple event named load at the style element, or, if one of the style sheet's
critical subresources failed to completely load for any reason (e.g. DNS error, HTTP
404 response, a connection being prematurely closed, unsupported Content-Type), queue a
task to fire a simple event named error at
the style element. Non-network errors in processing the style sheet or its
subresources (e.g. CSS parse errors, PNG decoding errors) are not failures for the purposes of
this paragraph.
<!DOCTYPE html>
<html lang="en-US">
<head>
<title>My favorite book</title>
<style>
body { color: black; background: white; }
em { font-style: normal; color: red; }
</style>
</head>
<body>
<p>My <em>favorite</em> book of all time has <em>got</em> to be
<cite>A Cat's Life</cite>. It is a book by P. Rahmel that talks
about the <i lang="la">Felis Catus</i> in modern human society.</p>
</body>
</html>
4.2.7 Interactions of styling and scripting
Style sheets, whether added by a link element, a style element, an
PI, an HTTP Link: header, or some
other mechanism, have a style sheet ready flag, which is initially unset.
When a style sheet is ready to be applied, its style sheet ready flag must be set.
If the style sheet referenced no other resources (e.g. it was an internal style sheet given by a
style element with no @import rules), then the style rules must
be synchronously made available to script; otherwise, the style rules must only be made available
to script once the event loop reaches its update the rendering step.
A style sheet in the context of the Document of an HTML parser or
XML parser is said to be a style sheet that is blocking scripts if the
element was created by that Document's parser, and the element is either a
style element or a link element that was an external resource link that contributes to the styling processing
model when the element was created by the parser, and the element's style sheet was enabled
when the element was created by the parser, and the element's style sheet ready flag
is not yet set, and, the last time the event loop reached step 1, the element was
in that Document, and the user agent hasn't given
up on that particular style sheet yet. A user agent may give up on a style sheet at any time.
Giving up on a style sheet before the style sheet loads, if the style sheet
eventually does still load, means that the script might end up operating with incorrect
information. For example, if a style sheet sets the color of an element to green, but a script
that inspects the resulting style is executed before the sheet is loaded, the script will find
that the element is black (or whatever the default color is), and might thus make poor choices
(e.g. deciding to use black as the color elsewhere on the page, instead of green). Implementors
have to balance the likelihood of a script using incorrect information with the performance impact
of doing nothing while waiting for a slow network request to finish.
<article itemscope itemtype="http://schema.org/BlogPosting">
<header>
<h2 itemprop="headline">The Very First Rule of Life</h2>
<p><time itemprop="datePublished" datetime="2009-10-09">3 days ago</time></p>
<link itemprop="url" href="?comments=0">
</header>
<p>If there's a microphone anywhere near you, assume it's hot and
sending whatever you're saying to the world. Seriously.</p>
<p>...</p>
<footer>
<a itemprop="discussionUrl" href="?comments=1">Show comments...</a>
</footer>
</article>
これは同じブログの記事であるが、コメントの一部を示す：
<article itemscope itemtype="http://schema.org/BlogPosting">
<header>
<h2 itemprop="headline">The Very First Rule of Life</h2>
<p><time itemprop="datePublished" datetime="2009-10-09">3 days ago</time></p>
<link itemprop="url" href="?comments=0">
</header>
<p>If there's a microphone anywhere near you, assume it's hot and
sending whatever you're saying to the world. Seriously.</p>
<p>...</p>
<section>
<h2>Comments</h2>
<article itemprop="comment" itemscope itemtype="http://schema.org/UserComments" id="c1">
<link itemprop="url" href="#c1">
<footer>
<p>Posted by: <span itemprop="creator" itemscope itemtype="http://schema.org/Person">
<span itemprop="name">George Washington</span>
</span></p>
<p><time itemprop="commentTime" datetime="2009-10-10">15 minutes ago</time></p>
</footer>
<p>Yeah! Especially when talking about your lobbyist friends!</p>
</article>
<article itemprop="comment" itemscope itemtype="http://schema.org/UserComments" id="c2">
<link itemprop="url" href="#c2">
<footer>
<p>Posted by: <span itemprop="creator" itemscope itemtype="http://schema.org/Person">
<span itemprop="name">George Hammond</span>
</span></p>
<p><time itemprop="commentTime" datetime="2009-10-10">5 minutes ago</time></p>
</footer>
<p>Hey, you have the same first name as me.</p>
</article>
</section>
</article>
<article>
<header>
<h2>Apples</h2>
<p>Tasty, delicious fruit!</p>
</header>
<p>The apple is the pomaceous fruit of the apple tree.</p>
<section>
<h3>Red Delicious</h3>
<p>These bright red apples are the most common found in many
supermarkets.</p>
</section>
<section>
<h3>Granny Smith</h3>
<p>These juicy, green apples make a great filling for
apple pies.</p>
</section>
</article>
<article class="book">
<style>
section { border: double medium; margin: 2em; }
section.chapter h1 { font: 2em Roboto, Helvetica Neue, sans-serif; }
section.appendix h1 { font: small-caps 2em Roboto, Helvetica Neue, sans-serif; }
</style>
<header>
<h2>My Book</h2>
<p>A sample with not much content</p>
<p><small>Published by Dummy Publicorp Ltd.</small></p>
</header>
<section class="chapter">
<h3>My First Chapter</h3>
<p>This is the first of my chapters. It doesn't say much.</p>
<p>But it has two paragraphs!</p>
</section>
<section class="chapter">
<h3>It Continutes: The Second Chapter</h3>
<p>Bla dee bla, dee bla dee bla. Boom.</p>
</section>
<section class="chapter">
<h3>Chapter Three: A Further Example</h3>
<p>It's not like a battle between brightness and earthtones would go
unnoticed.</p>
<p>But it might ruin my story.</p>
</section>
<section class="appendix">
<h3>Appendix A: Overview of Examples</h3>
<p>These are demonstrations.</p>
</section>
<section class="appendix">
<h3>Appendix B: Some Closing Remarks</h3>
<p>Hopefully this long example shows that you <em>can</em> style
sections, so long as they are used to indicate actual sections.</p>
</section>
</article>
<nav>
<h2>Navigation</h2>
<p>You are on my home page. To the north lies <a href="/blog">my
blog</a>, from whence the sounds of battle can be heard. To the east
you can see a large mountain, upon which many <a
href="/school">school papers</a> are littered. Far up thus mountain
you can spy a little figure who appears to be me, desperately
scribbling a <a href="/school/thesis">thesis</a>.</p>
<p>To the west are several exits. One fun-looking exit is labeled <a
href="http://games.example.com/">"games"</a>. Another more
boring-looking exit is labeled <a
href="http://isp.example.net/">ISP™</a>.</p>
<p>To the south lies a dark and dank <a href="/about">contacts
page</a>. Cobwebs cover its disused entrance, and at one point you
see a rat run quickly out of the page.</p>
</nav>
<aside>
<h2>Switzerland</h2>
<p>Switzerland, a land-locked country in the middle of geographic
Europe, has not joined the geopolitical European Union, though it is
a signatory to a number of European treaties.</p>
</aside>
次の例は、asideが長い記事でリード文のマークアップに対して使用される様子を示す。
...
<p>He later joined a large company, continuing on the same work.
<q>I love my job. People ask me what I do for fun when I'm not at
work. But I'm paid to do my hobby, so I never know what to
answer. Some people wonder what they would do if they didn't have to
work... but I know what I would do, because I was unemployed for a
year, and I filled that time doing exactly what I do now.</q></p>
<aside>
<q> People ask me what I do for fun when I'm not at work. But I'm
paid to do my hobby, so I never know what to answer. </q>
</aside>
<p>Of course his work — or should that be hobby? —
isn't his only passion. He also enjoys other pleasures.</p>
...
<body>
<header>
<h1>My wonderful blog</h1>
<p>My tagline</p>
</header>
<aside>
<!-- this aside contains two sections that are tangentially related
to the page, namely, links to other blogs, and links to blog posts
from this blog -->
<nav>
<h2>My blogroll</h2>
<ul>
<li><a href="http://blog.example.com/">Example Blog</a>
</ul>
</nav>
<nav>
<h2>Archives</h2>
<ol reversed>
<li><a href="/last-post">My last post</a>
<li><a href="/first-post">My first post</a>
</ol>
</nav>
</aside>
<aside>
<!-- this aside is tangentially related to the page also, it
contains twitter messages from the blog author -->
<h2>Twitter Feed</h2>
<blockquote cite="http://twitter.example.net/t31351234">
I'm on vacation, writing my blog.
</blockquote>
<blockquote cite="http://twitter.example.net/t31219752">
I'm going to go on vacation soon.
</blockquote>
</aside>
<article>
<!-- this is a blog post -->
<h2>My last post</h2>
<p>This is my last post.</p>
<footer>
<p><a href="/last-post" rel=bookmark>Permalink</a>
</footer>
</article>
<article>
<!-- this is also a blog post -->
<h2>My first post</h2>
<p>This is my first post.</p>
<aside>
<!-- this aside is about the blog post, since it's inside the
<article> element; it would be wrong, for instance, to put the
blogroll here, since the blogroll isn't really related to this post
specifically, only to the page as a whole -->
<h1>Posting</h1>
<p>While I'm thinking about it, I wanted to say something about
posting. Posting is fun!</p>
</aside>
<footer>
<p><a href="/first-post" rel=bookmark>Permalink</a>
</footer>
</article>
<footer>
<nav>
<a href="/archives">Archives</a> —
<a href="/about">About me</a> —
<a href="/copyright">Copyright</a>
</nav>
</footer>
</body>
<body>
<header>
<h1>Little Green Guys With Guns</h1>
<nav>
<ul>
<li><a href="/games">Games</a>
<li><a href="/forum">Forum</a>
<li><a href="/download">Download</a>
</ul>
</nav>
<h2>Important News</h2> <!-- this starts a second subsection -->
<!-- this is part of the subsection entitled "Important News" -->
<p>To play today's games you will need to update your client.</p>
<h2>Games</h2> <!-- this starts a third subsection -->
</header>
<p>You have three active games:</p>
<!-- this is still part of the subsection entitled "Games" -->
...
<body>
<footer><a href="../">Back to index...</a></footer>
<div>
<h1>Lorem ipsum</h1>
<p>The ipsum of all lorems</p>
</div>
<p>A dolor sit amet, consectetur adipisicing elit, sed do eiusmod
tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim
veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex
ea commodo consequat. Duis aute irure dolor in reprehenderit in
voluptate velit esse cillum dolore eu fugiat nulla
pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
culpa qui officia deserunt mollit anim id est laborum.</p>
<footer><a href="../">Back to index...</a></footer>
</body>
<ADDRESS>
<A href="../People/Raggett/">Dave Raggett</A>,
<A href="../People/Arnaud/">Arnaud Le Hors</A>,
contact persons for the <A href="Activity">W3C HTML Activity</A>
</ADDRESS>
The contact information consists of all the
address elements that have node
as an ancestor and do not have another body or
article element ancestor that is a descendant of node.
If node has an ancestor element that is an article element
If node has an ancestor element that is a body element
The contact information of node is the same
as the contact information of the nearest article or
body element ancestor, whichever is nearest.
The contact information of node is the same
as the contact information of the body element of the
Document.
そうでなければ
There is no contact information for node.
User agents may expose the contact information of a node to the
user, or use it for other purposes, such as indexing sections based
on the sections' contact information.
<body>
<h4>Apples</h4>
<p>Apples are fruit.</p>
<section>
<h2>Taste</h2>
<p>They taste lovely.</p>
<h6>Sweet</h6>
<p>Red apples are sweeter than green ones.</p>
<h1>Color</h1>
<p>Apples come in various colors.</p>
</section>
</body>
ただし、同じ文書をより明確に表現できるだろう。
<body>
<h1>Apples</h1>
<p>Apples are fruit.</p>
<section>
<h2>Taste</h2>
<p>They taste lovely.</p>
<section>
<h3>Sweet</h3>
<p>Red apples are sweeter than green ones.</p>
</section>
</section>
<section>
<h2>Color</h2>
<p>Apples come in various colors.</p>
</section>
</body>
<body>
<h1>Apples</h1>
<p>Apples are fruit.</p>
<section>
<h1>Taste</h1>
<p>They taste lovely.</p>
<section>
<h1>Sweet</h1>
<p>Red apples are sweeter than green ones.</p>
</section>
</section>
<section>
<h1>Color</h1>
<p>Apples come in various colors.</p>
</section>
</body>
This section defines an algorithm for creating an outline for a sectioning content
element or a sectioning root element. It is defined in terms of a walk over the nodes
of a DOM tree, in tree order, with each node being visited when it is entered and when it
is exited during the walk.
セクションは、元のDOMツリーで一部のノードに対応するコンテナである。各セクションは、セクションに関連付けられた1つの見出しを持つことができ、さらにネストされた任意の数のセクションを含むことができる。The algorithm for the outline also associates each node in the DOM tree with a particular section and potentially a heading. (The sections in the outline aren't section elements, though some may correspond to such elements — they are merely conceptual sections.)
The algorithm that must be followed during a walk of a DOM subtree rooted at a sectioning
content element or a sectioning root element to determine that element's
outline is as follows:
Let current outline target be null. (It holds the element whose
outline is being created.)
Let current section be null. (It holds a pointer to a section, so that elements in the DOM can all be associated with a
section.)
Create a stack to hold elements, which is used to handle nesting. Initialise this stack to
empty.
Walk over the DOM in tree order, starting with the sectioning
content element or sectioning root element at the root of the subtree for
which an outline is to be created, and trigger the first relevant step below for each element as
the walk enters and exits it.
When exiting an element, if that element is the element at the top of the stack
The element being exited is a heading content element or an
element with a hidden attribute.
Pop that element from the stack.
If the top of the stack is a heading content element or an element with a
hidden attribute
If the current section has no heading, create an implied heading
and let that be the heading for the current section.
Pop the top element from the stack, and let the current outline
target be that element.
Let current section be the last section in the
outline of the current outline target element.
Append the outline of the sectioning content element being
exited to the current section. (This does not change which section is
the last section in the outline.)
The current outline target is the element being exited,
and it is the sectioning content element or a sectioning root
element at the root of the subtree for which an outline is being generated.
If the current section has no heading, create an implied heading and
let that be the heading for the current section.
Skip to the next step in the overall set of steps. (The walk is over.)
If the current section has no heading, let the element being entered be
the heading for the current section.
Otherwise, if the element being entered has a rank equal to or higher than the
heading of the last section of the outline of the current outline
target, or if the heading of the last section of the outline of the current outline target is an implied heading, then create a new section and append it to the outline of the current outline target element, so that this new section is the new last
section of that outline. Let current section be that new section. Let the
element being entered be the new heading for the current section.
Otherwise, run these substeps:
Let candidate section be current
section.
Heading loop: If the element being entered has a rank lower than
the rank of the heading of the candidate section, then create a new
section, and append it to candidate
section. (This does not change which section is the last section in the outline.) Let
current section be this new section. Let the element being entered be the
new heading for the current section. Abort these substeps.
Let new candidate section be the section that contains candidate section in
the outline of current outline target.
Let candidate section be new candidate
section.
Return to the step labeled heading loop.
Push the element being entered onto the stack. (This causes the algorithm to skip any
descendants of the element.)
Recall that h1 has the highest rank, and h6
has the lowest rank.
そうでなければ
何もしない。
In addition, whenever the walk exits a node, after doing the steps
above, if the node is not associated with a section yet,
associate the node with the sectioncurrent
section.
Associate all non-element nodes that are in the subtree for which an outline is being
created with the section with which their parent element is
associated.
Associate all nodes in the subtree with the heading of the section with which they are associated, if any.
The tree of sections created by the algorithm above, or a proper subset thereof, must be used
when generating document outlines, for example when generating tables of contents.
When creating an interactive table of contents, entries should jump the user to the relevant
sectioning content element, if the section was
created for a real element in the original document, or to the relevant heading
content element, if the section in the tree was
generated for a heading in the above process.
Selecting the first section of the document
therefore always takes the user to the top of the document, regardless of where the first heading
in the body is to be found.
Although it contains no headings, this snippet has three sections: a document (the
body) with two subsections (a nav and an aside). A user
agent could present the outline as follows:
Untitled document
Navigation
Sidebar
These default headings ("Untitled document", "Navigation", "Sidebar") are not specified by
this specification, and might vary with the user's language, the page's language, the user's
preferences, the user agent implementor's preferences, etc.
The following JavaScript function shows how the tree walk could be implemented. The root argument is the root of the tree to walk (either a sectioning
content element or a sectioning root element), and the enter and exit arguments are callbacks that are called with
the nodes as they are entered and exited. [ECMA262]
function (root, enter, exit) {
var node = root;
start: while (node) {
enter(node);
if (node.firstChild) {
node = node.firstChild;
continue start;
}
while (node) {
exit(node);
if (node == root) {
node = null;
} else if (node.nextSibling) {
node = node.nextSibling;
continue start;
} else {
node = node.parentNode;
}
}
}
}
<!DOCTYPE HTML>
<title>The Tax Book (all in one page)</title>
<h1>The Tax Book</h1>
<h2>Earning money</h2>
<p>Earning money is good.</p>
<h3>Getting a job</h3>
<p>To earn money you typically need a job.</p>
<h2>Spending money</h2>
<p>Spending is what money is mainly used for.</p>
<h3>Cheap things</h3>
<p>Buying cheap things often not cost-effective.</p>
<h3>Expensive things</h3>
<p>The most expensive thing is often not the most cost-effective either.</p>
<h2>Investing money</h2>
<p>You can lend your money to other people.</p>
<h2>Losing money</h2>
<p>If you spend money or invest money, sooner or later you will lose money.
<h3>Poor judgement</h3>
<p>Usually if you lose money it's because you made a mistake.</p>
<!DOCTYPE HTML>
<title>The Tax Book (all in one page)</title>
<h1>The Tax Book</h1>
<section>
<h1>Earning money</h1>
<p>Earning money is good.</p>
<section>
<h1>Getting a job</h1>
<p>To earn money you typically need a job.</p>
</section>
</section>
<section>
<h1>Spending money</h1>
<p>Spending is what money is mainly used for.</p>
<section>
<h1>Cheap things</h1>
<p>Buying cheap things often not cost-effective.</p>
</section>
<section>
<h1>Expensive things</h1>
<p>The most expensive thing is often not the most cost-effective either.</p>
</section>
</section>
<section>
<h1>Investing money</h1>
<p>You can lend your money to other people.</p>
</section>
<section>
<h1>Losing money</h1>
<p>If you spend money or invest money, sooner or later you will lose money.
<section>
<h1>Poor judgement</h1>
<p>Usually if you lose money it's because you made a mistake.</p>
</section>
</section>
<!DOCTYPE HTML>
<title>Feathers on The Site of Encyclopedic Knowledge</title>
<section>
<h1>A plea from our caretakers</h1>
<p>Please, we beg of you, send help! We're stuck in the server room!</p>
</section>
<h1>Feathers</h1>
<p>Epidermal growths.</p>
<!DOCTYPE HTML>
<title>We're adopting a child! — Ray's blog</title>
...
<h1>Ray's blog</h1>
<main>
<article>
<header>
<nav>
<a href="?t=-1d">Yesterday</a>;
<a href="?t=-7d">Last week</a>;
<a href="?t=-1m">Last month</a>
</nav>
</header>
<h2>We're adopting a child!</h2>
<p>As of today, Janine and I have signed the papers to become
the proud parents of baby Diane! We've been looking forward to
this day for weeks.</p>
</article>
</main>
...
<h1>Music</h1>
<p>As any burner can tell you, the event has a lot of trance.</p>
<aside>You can buy the music we played at our <a href="buy.html">playlist page</a>.</aside>
<p>This year we played a kind of trance that originated in Belgium, Germany, and the Netherlands in the mid 90s.</p>
<h1>The Guide To Music On The Playa</h1><h2>The Main Stage</h2>
<p>If you want to play on a stage, you should bring one.</p>
<h2>Amplified Music</h2>
<p>Amplifiers up to 300W or 90dB are welcome.</p>
<article>
<header>
<h1>Hard Trance is My Life</h1>
<p>By DJ Steve Hill and Technikal</p>
</header>
<p>The album with the amusing punctuation has red artwork.</p>
</article>
<article>
<h1>Hard Trance is My Life</h1>
<p>The album with the amusing punctuation has red artwork.</p>
<footer>
<p>Artists: DJ Steve Hill and Technikal</p>
</footer>
</article>
<p>The little kitten gently seated himself on a piece of
carpet. Later in his life, this would be referred to as the time the
cat sat on the mat.</p>
<fieldset>
<legend>Personal information</legend>
<p>
<label>Name: <input name="n"></label>
<label><input name="anon" type="checkbox"> Hide from other users</label>
</p>
<p><label>Address: <textarea name="a"></textarea></label></p>
</fieldset>
<p>There was once an example from Femley,<br>
Whose markup was of dubious quality.<br>
The validator complained,<br>
So the author was pained,<br>
To move the error from the markup to the rhyming.</p>
<p>For instance, this fantastic sentence has bullets relating to</p>
<ul>
<li>wizards,
<li>faster-than-light travel, and
<li>telepathy,
</ul>
<p>and is further discussed below.</p>
<div>For instance, this fantastic sentence has bullets relating to
<ul>
<li>wizards,
<li>faster-than-light travel, and
<li>telepathy,
</ul>
and is further discussed below.</div>
<section>
<h1>Communication</h1>
<p>There are various methods of communication. This section
covers a few of the important ones used by the project.</p>
<hr>
<p>Communication stones seem to come in pairs and have mysterious
properties:</p>
<ul>
<li>They can transfer thoughts in two directions once activated
if used alone.</li>
<li>If used with another device, they can transfer one's
consciousness to another body.</li>
<li>If both stones are used with another device, the
consciousnesses switch bodies.</li>
</ul>
<hr>
<p>Radios use the electromagnetic spectrum in the meter range and
longer.</p>
<hr>
<p>Signal flares use the electromagnetic spectrum in the
nanometer range.</p>
</section>
<section>
<h1>Food</h1>
<p>All food at the project is rationed:</p>
<dl>
<dt>Potatoes</dt>
<dd>Two per day</dd>
<dt>Soup</dt>
<dd>One bowl per day</dd>
</dl>
<hr>
<p>Cooking is done by the chefs on a set rotation.</p>
</section>
<p>Dudley was ninety-two, in his second life, and fast approaching
time for another rejuvenation. Despite his body having the physical
age of a standard fifty-year-old, the prospect of a long degrading
campaign within academia was one he regarded with dread. For a
supposedly advanced civilization, the Intersolar Commonwealth could be
appallingly backward at times, not to mention cruel.</p>
<p><i>Maybe it won't be that bad</i>, he told himself. The lie was
comforting enough to get him through the rest of the night's
shift.</p>
<hr>
<p>The Carlton AllLander drove Dudley home just after dawn. Like the
astronomer, the vehicle was old and worn, but perfectly capable of
doing its job. It had a cheap diesel engine, common enough on a
semi-frontier world like Gralmond, although its drive array was a
thoroughly modern photoneural processor. With its high suspension and
deep-tread tyres it could plough along the dirt track to the
observatory in all weather and seasons, including the metre-deep snow
of Gralmond's winters.</p>
<pre><samp>You are in an open field west of a big white house with a boarded
front door.
There is a small mailbox here.
></samp> <kbd>open mailbox</kbd>
<samp>Opening the mailbox reveals:
A leaflet.
></samp></pre>
cite属性が存在する場合、潜在的にスペースで囲まれた妥当なURLでなければならない。To obtain the corresponding citation link, the value of the attribute must be resolved relative to the element. User agents may allow users to follow such citation links, but they are primarily intended for private use (e.g. by server-side scripts collecting statistics about a site's use of quotations), not for readers.
The cite IDL
attribute must reflect the element's cite content attribute.
<figure>
<blockquote>
"That monster custom, who all sense doth eat
Of habit's devil," <abbr title="et cetera">&c.</abbr> not in Folio
"What a falling off was there !
From me, whose love was of that dignity
That it went hand in hand even with the vow
I made to her in marriage, and to decline
Upon a wretch."
</blockquote>
<footer>
— <cite class="title">Shakespeare manual</cite> by <cite class="author">Frederick Gard Fleay</cite>,
p19 (in Google Books)
</footer>
</figure>
<blockquote>
<p>I contend that we are both atheists. I just believe in one fewer
god than you do. When you understand why you dismiss all the other
possible gods, you will understand why I dismiss yours.</p>
<footer>— <cite>Stephen Roberts</cite></footer>
</blockquote>
<blockquote>
The people recognize themselves in their commodities; they find their
soul in their automobile, hi-fi set, split-level home, kitchen equipment.
— <cite><a href="http://en.wikipedia.org/wiki/Herbert_Marcuse">Herbert Marcuse</a></cite>
</blockquote>
<blockquote>
<p>... she said she would not sign any deposition containing the word "amorous"
instead of "advances". For her the difference was of crucial significance,
and one of the reasons she had separated from her husband was that he had never been
amorous but had consistently made advances.</p>
<footer itemscope itemtype="http://schema.org/Book">
<span itemprop="author">Heinrich Böll</span>,
<span itemprop="name">The Lost Honor of Katharina Blum</span>,
<span itemprop="datePublished">January 1, 1974</span>
</footer>
</blockquote>
<figure>
<blockquote>
<p>The truth may be puzzling. It may take some work to grapple with.
It may be counterintuitive. It may contradict deeply held
prejudices. It may not be consonant with what we desperately want to
be true. But our preferences do not determine what's true. We have a
method, and that method helps us to reach not absolute truth, only
asymptotic approaches to the truth — never there, just closer
and closer, always finding vast new oceans of undiscovered
possibilities. Cleverly designed experiments are the key.</p>
</blockquote>
<figcaption><cite>Carl Sagan</cite>, in "<cite>Wonder and Skepticism</cite>", from
the <cite>Skeptical Enquirer</cite> Volume 19, Issue 1 (January-February
1995)</figcaption>
</figure>
<p>His next piece was the aptly named <cite>Sonnet 130</cite>:</p>
<blockquote cite="http://quotes.example.org/s/sonnet130.html">
<p>My mistress' eyes are nothing like the sun,<br>
Coral is far more red, than her lips red,<br>
...
<article>
<h1><a href="http://bacon.example.com/?blog=109431">Bacon on a crowbar</a></h1>
<article>
<header><strong>t3yw</strong> 12 points 1 hour ago</header>
<p>I bet a narwhal would love that.</p>
<footer><a href="?pid=29578">permalink</a></footer>
<article>
<header><strong>greg</strong> 8 points 1 hour ago</header>
<blockquote><p>I bet a narwhal would love that.</p></blockquote>
<p>Dude narwhals don't eat bacon.</p>
<footer><a href="?pid=29579">permalink</a></footer>
<article>
<header><strong>t3yw</strong> 15 points 1 hour ago</header>
<blockquote>
<blockquote><p>I bet a narwhal would love that.</p></blockquote>
<p>Dude narwhals don't eat bacon.</p>
</blockquote>
<p>Next thing you'll be saying they don't get capes and wizard
hats either!</p>
<footer><a href="?pid=29580">permalink</a></footer>
<article>
<article>
<header><strong>boing</strong> -5 points 1 hour ago</header>
<p>narwhals are worse than ceiling cat</p>
<footer><a href="?pid=29581">permalink</a></footer>
</article>
</article>
</article>
</article>
<article>
<header><strong>fred</strong> 1 points 23 minutes ago</header>
<blockquote><p>I bet a narwhal would love that.</p></blockquote>
<p>I bet they'd love to peel a banana too.</p>
<footer><a href="?pid=29582">permalink</a></footer>
</article>
</article>
</article>
<p>He began his list of "lessons" with the following:</p>
<blockquote>One should never assume that his side of
the issue will be recognized, let alone that it will
be conceded to have merits.</blockquote>
<p>He continued with a number of similar points, ending with:</p>
<blockquote>Finally, one should be prepared for the threat
of breakdown in negotiations at any given moment and not
be cowed by the possibility.</blockquote>
<p>We shall now discuss these points...
If the start attribute is
present, user agents must parse it as an integer, in order to determine the
attribute's value. The default value, used if the attribute is
missing or if the value cannot be converted to a number according to
the referenced algorithm, is 1 if the element has no reversed attribute, and is the
number of child li elements otherwise.
The first item in the list has the ordinal value
given by the ol element's start attribute, unless that
li element has a value attribute with a value that can
be successfully parsed, in which case it has the ordinal
value given by that value
attribute.
Each subsequent item in the list has the ordinal
value given by its value
attribute, if it has one, or, if it doesn't, the ordinal
value of the previous item, plus one if the reversed is absent, or minus one if
it is present.
type属性は、重要な場合（たとえば、項目が数字または文字によって参照されることがあるためなど）、リストで使用するマーカーの種類を指定するために使用できる。属性を指定する場合、属性は、次表のいずれかの行にある最初のセルに与えられた文字のいずれかに大文字・小文字区別で一致する値を持たなければならない。The type attribute represents the state given in the cell in the second column of the row whose first cell matches the attribute's value; if none of the cells match, or if the attribute is omitted, then the attribute represents the decimal state.
User agents should render the items of the list in a manner
consistent with the state of the type attribute of the ol
element. Numbers less than or equal to zero should always use the
decimal system regardless of the type attribute.
For CSS user agents, a mapping for this attribute to
the 'list-style-type' CSS property is given in
the rendering section (the mapping is straightforward: the
states above have the same names as their corresponding CSS
values).
The reversed,
start, and type IDL attributes must
reflect the respective content attributes of the same
name. The start IDL attribute has
the same default as its content attribute.
<p>I have lived in the following countries (given in the order of when
I first lived there):</p>
<ol>
<li>Switzerland
<li>United Kingdom
<li>United States
<li>Norway
</ol>
<p>I have lived in the following countries (given in the order of when
I first lived there):</p>
<ol>
<li>United Kingdom
<li>Switzerland
<li>United States
<li>Norway
</ol>
If the value attribute is
present, user agents must parse it as an integer, in order to determine the
attribute's value. If the attribute's value cannot be converted to a
number, the attribute must be treated as if it was absent. The
attribute has no default value.
The value attribute is
processed relative to the element's parent ol element
(q.v.), if there is one. If there is not, the attribute has no
effect.
The value IDL attribute must reflect
the value of the value content attribute.
If a dl element has one or more non-whitespaceText
node children, or has child elements that are neither
dt nor dd elements, all such
Text nodes and elements, as well as their descendants
(including any dt or dd elements), do not
form part of any groups in that dl.
If a dl element has one or more dt
element children but no dd element children, then it
consists of one group with names but no values.
If a dl element has one or more dd
element children but no dt element children, then it
consists of one group with values but no names.
If a dl element's first dt or
dd element child is a dd element, then the
first group has no associated name.
If a dl element's last dt or
dd element child is a dt element, then the
last group has no associated value.
When a dl element doesn't match its
content model, it is often due to accidentally using dd
elements in the place of dt elements and vice
versa. Conformance checkers can spot such mistakes and might be able
to advise authors how to correctly use the markup.
<dl>
<dt> Authors
<dd> John
<dd> Luke
<dt> Editor
<dd> Frank
</dl>
次の例は、1つの定義が2つの用語にリンクされる。
<dl>
<dt lang="en-US"> <dfn>color</dfn> </dt>
<dt lang="en-GB"> <dfn>colour</dfn> </dt>
<dd> A sensation which (in humans) derives from the ability of
the fine structure of the eye to distinguish three differently
filtered analyses of a view. </dd>
</dl>
<p>Determine the victory points as follows (use the
first matching case):</p>
<dl>
<dt> If you have exactly five gold coins </dt>
<dd> You get five victory points </dd>
<dt> If you have one or more gold coins, and you have one or more silver coins </dt>
<dd> You get two victory points </dd>
<dt> If you have one or more silver coins </dt>
<dd> You get one victory point </dd>
<dt> Otherwise </dt>
<dd> You get no victory points </dd>
</dl>
<dl>
<dt><dfn>Apartment</dfn>, n.</dt>
<dd>An execution context grouping one or more threads with one or
more COM objects.</dd>
<dt><dfn>Flat</dfn>, n.</dt>
<dd>A deflated tire.</dd>
<dt><dfn>Home</dfn>, n.</dt>
<dd>The user's login directory.</dd>
</dl>
<article>
<h1>FAQ</h1>
<dl>
<dt>What do we want?</dt>
<dd>Our data.</dd>
<dt>When do we want it?</dt>
<dd>Now.</dd>
<dt>Where is it?</dt>
<dd>We are not sure.</dd>
</dl>
</article>
<dl>
<dt><dfn>happiness</dfn></dt>
<dd class="pronunciation">/'hæ p. nes/</dd>
<dd class="part-of-speech"><i><abbr>n.</abbr></i></dd>
<dd>The state of being happy.</dd>
<dd>Good fortune; success. <q>Oh <b>happiness</b>! It worked!</q></dd>
<dt><dfn>rejoice</dfn></dt>
<dd class="pronunciation">/ri jois'/</dd>
<dd><i class="part-of-speech"><abbr>v.intr.</abbr></i> To be delighted oneself.</dd>
<dd><i class="part-of-speech"><abbr>v.tr.</abbr></i> To cause one to be delighted.</dd>
</dl>
The firstfigcaption element child of the element, if
any, represents the caption of the figure element's contents. If there is no child
figcaption element, then there is no caption.
<p>In <a href="#l4">listing 4</a> we see the primary core interface
API declaration.</p>
<figure id="l4">
<figcaption>Listing 4. The primary core interface API declaration.</figcaption>
<pre><code>interface PrimaryCore {
boolean verifyDataLine();
void sendData(in sequence<byte> data);
void initSelfDestruct();
}</code></pre>
</figure>
<p>The API is designed to use UTF-8.</p>
<!DOCTYPE HTML>
<title>Bubbles at work — My Gallery™</title>
<figure>
<img src="bubbles-work.jpeg"
alt="Bubbles, sitting in his office chair, works on his
latest project intently.">
<figcaption>Bubbles at work</figcaption>
</figure>
<nav><a href="19414.html">Prev</a> — <a href="19416.html">Next</a></nav>
<h2>Malinko's comics</h2>
<p>This case centered on some sort of "intellectual property"
infringement related to a comic (see Exhibit A). The suit started
after a trailer ending with these words:
<blockquote>
<img src="promblem-packed-action.png" alt="ROUGH COPY! Promblem-Packed Action!">
</blockquote>
<p>...was aired. A lawyer, armed with a Bigger Notebook, launched a
preemptive strike using snowballs. A complete copy of the trailer is
included with Exhibit B.
<figure>
<img src="ex-a.png" alt="Two squiggles on a dirty piece of paper.">
<figcaption>Exhibit A. The alleged <cite>rough copy</cite> comic.</figcaption>
</figure>
<figure>
<video src="ex-b.mov"></video>
<figcaption>Exhibit B. The <cite>Rough Copy</cite> trailer.</figcaption>
</figure>
<p>The case was resolved out of court.
<figure>
<p>'Twas brillig, and the slithy toves<br>
Did gyre and gimble in the wabe;<br>
All mimsy were the borogoves,<br>
And the mome raths outgrabe.</p>
<figcaption><cite>Jabberwocky</cite> (first verse). Lewis Carroll, 1832-98</figcaption>
</figure>
<figure>
<figcaption>The castle through the ages: 1423, 1858, and 1999 respectively.</figcaption>
<figure>
<figcaption>Etching. Anonymous, ca. 1423.</figcaption>
<img src="castle1423.jpeg" alt="The castle has one tower, and a tall wall around it.">
</figure>
<figure>
<figcaption>Oil-based paint on canvas. Maria Towle, 1858.</figcaption>
<img src="castle1858.jpeg" alt="The castle now has two towers and two walls.">
</figure>
<figure>
<figcaption>Film photograph. Peter Jankle, 1999.</figcaption>
<img src="castle1999.jpeg" alt="The castle lies in ruins, the original tower all that remains in one piece.">
</figure>
</figure>
図は、時にはコンテンツからのみ、暗黙的に参照される：
<article>
<h1>Fiscal negotiations stumble in Congress as deadline nears</h1>
<figure>
<img src="obama-reid.jpeg" alt="Obama and Reid sit together smiling in the Oval Office.">
<figcaption>Barrak Obama and Harry Reid. White House press photograph.</figcaption>
</figure>
<p>Negotiations in Congress to end the fiscal impasse sputtered on Tuesday, leaving both chambers
grasping for a way to reopen the government and raise the country's borrowing authority with a
Thursday deadline drawing near.</p>
...
</article>
<!-- other content -->
<main>
<h1>Skateboards</h1>
<p>The skateboard is the way cool kids get around</p>
<article>
<h2>Longboards</h2>
<p>Longboards are a type of skateboard with a longer
wheelbase and larger, softer wheels.</p>
<p>... </p>
<p>... </p>
</article>
<article>
<h2>Electric Skateboards</h2>
<p>These no longer require the propelling of the skateboard
by means of the feet; rather an electric motor propels the board,
fed by an electric battery.</p>
<p>... </p>
<p>... </p>
</article>
</main>
<!-- other content -->
<article lang="en-US">
<h1>My use of language and my cats</h1>
<p>My cat's behavior hasn't changed much since her absence, except
that she plays her new physique to the neighbors regularly, in an
attempt to get pets.</p>
<div lang="en-GB">
<p>My other cat, coloured black and white, is a sweetie. He followed
us to the pool today, walking down the pavement with us. Yesterday
he apparently visited our neighbours. I wonder if he recognises that
their flat is a mirror image of ours.</p>
<p>Hm, I just noticed that in the last paragraph I used British
English. But I'm supposed to write in American English. So I
shouldn't say "pavement" or "flat" or "colour"...</p>
</div>
<p>I should say "sidewalk" and "apartment" and "color"!</p>
</article>
The href, target, download, and
attributes affect what happens when users follow
hyperlinks or download hyperlinks created using
the a element. The rel, hreflang, and type
attributes may be used to indicate to the user the likely nature of the target resource before the
user follows the link.
Abort these steps without following the hyperlink.
If the target of the click event is an img
element with an ismap attribute specified, then server-side
image map processing must be performed, as follows:
If the click event was a real pointing-device-triggered
click event on the img element, then let x be the distance in CSS pixels from the left edge of the image's left border,
if it has one, or the left edge of the image otherwise, to the location of the click, and let
y be the distance in CSS pixels from the top edge of the image's top
border, if it has one, or the top edge of the image otherwise, to the location of the click.
Otherwise, let x and y be zero.
Let the hyperlink suffix be a U+003F QUESTION MARK character, the
value of x expressed as a base-ten integer using ASCII digits,
a "," (U+002C) character, and the value of y expressed as a base-ten
integer using ASCII digits.
Finally, the user agent must follow the
hyperlink or download the hyperlink created by
the a element, as determined by the download attribute and any expressed user preference. If
the steps above defined a hyperlink suffix, then take that into account when following
or downloading the hyperlink.
The IDL attributes download,
target,
rel, rev, hreflang, and type, must reflect the respective content
attributes of the same name.
The IDL attribute relList must
reflect the rel content attribute.
The text IDL attribute, on getting, must return the
same value as the textContent IDL attribute on the element, and on setting, must act
as if the textContent IDL attribute on the element had been set to the new value.
The a element also supports the URLUtils interface. [URL]
When the element is created, and whenever the element's href content attribute is set, changed, or removed, the user
agent must invoke the element's URLUtils interface's set the input algorithm with the value of the href content attribute, if any, or the empty string otherwise,
as the given value.
When the element's URLUtils interface invokes its update steps with a string value, the user
agent must set the element's href content attribute to
the string value.
<aside class="advertising">
<h1>Advertising</h1>
<a href="http://ad.example.com/?adid=1929&pubid=1422">
<section>
<h1>Mellblomatic 9000!</h1>
<p>Turn all your widgets into mellbloms!</p>
<p>Only $9.99 plus shipping and handling.</p>
</section>
</a>
<a href="http://ad.example.com/?adid=375&pubid=1422">
<section>
<h1>The Mellblom Browser</h1>
<p>Web browsing at the speed of light.</p>
<p>No other browser goes faster!</p>
</section>
</a>
</aside>
<figcaption>Figure 1. <strong>Ant colony dynamics</strong>. The ants in this colony are
affected by the heat source (upper left) and the food source (lower right).</figcaption>
次の例において、実際の見出しは"Flowers, Bees, and Honey"であるが、著者は見出しに陽気な付け足しを追加している。したがって、strong要素は、後半から見出しを区別しようとして前半をマークアップするために使用される。
<h1><strong>Flowers, Bees, and Honey</strong> and other things I don't understand</h1>
<p><strong>Warning.</strong> This dungeon is dangerous.
<strong>Avoid the ducks.</strong> Take any gold you find.
<strong><strong>Do not take any of the diamonds</strong>,
they are explosive and <strong>will destroy anything within
ten meters.</strong></strong> You have been warned.</p>
<p>Welcome to Remy, the reminder system.</p>
<p>Your tasks for today:</p>
<ul>
<li><p><strong>Turn off the oven.</strong></p></li>
<li><p>Put out the trash.</p></li>
<li><p>Do the laundry.</p></li>
</ul>
<p>Example Corp today announced record profits for the
second quarter <small>(Full Disclosure: Foo News is a subsidiary of
Example Corp)</small>, leading to speculation about a third quarter
merger with Demo Group.</p>
<aside>
<h1>Example Corp</h1>
<p>This company mostly creates small software and Web
sites.</p>
<p>The Example Corp company mission is "To provide entertainment
and news on a sample basis".</p>
<p><small>Information obtained from <a
href="http://example.com/about.html">example.com</a> home
page.</small></p>
</aside>
<p>Buy our Iced Tea and Lemonade!</p>
<p><s>Recommended retail price: $3.99 per bottle</s></p>
<p><strong>Now selling for just $2.99 a bottle!</strong></p>
Creative works include a book, a paper, an essay, a poem, a score, a song, a script, a film,
a TV show, a game, a sculpture, a painting, a theatre production, a play, an opera, a musical, an exhibition,
a legal case report, a computer program, , a web site, a web page, a blog post
or comment, a forum post or comment, a tweet, a written or oral statement, etc.
<p>In the words of <cite>Charles Bukowski</cite> -
<q>An intellectual says a simple thing in a hard way. An artist says a hard thing in a simple way.</q></p>
<article id="comment-1">
Comment by <cite><a href="http://oli.jp">Oli Studholme</a></cite>
<time datetime="2013-08-19T16:01">August 19th, 2013 at 4:01 pm</time>
<p>Unfortunately I don't think adding names back into the definition of <code>cite</code>
solves the problem: of the 12 blockquote examples in
<a href="http://oli.jp/example/blockquote-metadata/">Examples of block quote metadata</a>,
there's not even one that's <em>just</em> a person’s name.</p>
<p>A subset of the problem, maybe…</p>
</article>
<div id="resultStats">About 416,000,000 results 0.33 seconds) </div>
...
<p><a href="http://www.w3.org/html/wg/">W3C <i>HTML Working Group</i></a></p>
<p><cite>www.w3.org/<b>html</b>/wg/</cite></p>
<p>15 Apr 2013 - The <i>HTML Working Group</i> is currently chartered to continue its
work through 31 December 2014. A Plan 2014 document published by the...</p>
...
<article>
<h2>Book notes</h2>
...
...
<blockquote>"Money is the real cause of poverty,"
<footer>
<cite id="baseref">The Ragged-Trousered Philanthropists, page 89.</cite>
</footer>
</blockquote>
...
...
<blockquote>"Money is the cause of poverty because it is the device by which those who
are too lazy to work are enabled to rob the workers of the fruits of their labour."
<a href="#baseref"><cite>Ibid.</cite></a>
</blockquote>
...
</article>
cite属性が存在する場合、潜在的にスペースで囲まれた妥当なURLでなければならない。To obtain the corresponding citation link, the value of the attribute must be resolved relative to the element. User agents may allow users to follow such citation links, but they are primarily intended for private use (e.g. by server-side scripts collecting statistics about a site's use of quotations), not for readers.
<p>The W3C page <cite>About W3C</cite> says the W3C's
mission is <q cite="http://www.w3.org/Consortium/">To lead the
World Wide Web to its full potential by developing protocols and
guidelines that ensure long-term growth for the Web</q>. I
disagree with this mission.</p>
次の例は、引用文自身が引用文を含む：
<p>In <cite>Example One</cite>, he writes <q>The man
said <q>Things that are impossible just take longer</q>. I
disagreed with him</q>. Well, I disagree even more!</p>
次の断片において、用語"Garage Door Opener"が第1段落で最初に定義され、第2段落で使用される。どちらの場合も、その略語は、実際に表示されるものである。
<p>The <dfn><abbr title="Garage Door Opener">GDO</abbr></dfn>
is a device that allows off-world teams to open the iris.</p>
<!-- ... later in the document: -->
<p>Teal'c activated his <abbr title="Garage Door Opener">GDO</abbr>
and so Hammond ordered the iris to be opened.</p>
<p>The <dfn id=gdo><abbr title="Garage Door Opener">GDO</abbr></dfn>
is a device that allows off-world teams to open the iris.</p>
<!-- ... later in the document: -->
<p>Teal'c activated his <a href=#gdo><abbr title="Garage Door Opener">GDO</abbr></a>
and so Hammond ordered the iris to be opened.</p>
下記の段落はabbr要素でマークアップされた略語を含む。この段落は、"Web Hypertext Application Technology Working Group"という用語を定義する。
<p>The <dfn id=whatwg><abbr
title="Web Hypertext Application Technology Working Group">WHATWG</abbr></dfn>
is a loose unofficial collaboration of Web browser manufacturers and
interested parties who wish to develop new technologies designed to
allow authors to write and deploy Applications over the World Wide
Web.</p>
これを記述する別の方法は、次のようになる：
<p>The <dfn id=whatwg>Web Hypertext Application Technology
Working Group</dfn> (<abbr
title="Web Hypertext Application Technology Working Group">WHATWG</abbr>)
is a loose unofficial collaboration of Web browser manufacturers and
interested parties who wish to develop new technologies designed to
allow authors to write and deploy Applications over the World Wide
Web.</p>
<p>The
<abbr title="Web Hypertext Application Technology Working Group">WHATWG</abbr>
started working on HTML5 in 2004.</p>
この段落は、その定義に略語をリンクする。
<p>The <a href="#whatwg"><abbr
title="Web Hypertext Application Technology Working Group">WHATWG</abbr></a>
community does not have much representation from Asia.</p>
<p>Philip` and Dashiva both denied that they were going to
get the issue counts from past revisions of the specification to
backfill the <abbr>WHATWG</abbr> issue graph.</p>
Within a ruby element, content is parcelled into a series of ruby segments. Each ruby
segment is described by:
Zero or more ruby bases, each of which is a DOM range that
may contain phrasing content or an rb element.
A base range, that is a DOM range including all the bases. This is the
ruby base container.
Zero or more ruby text containers which may
correspond to explicit rtc elements, or to sequences of rt
elements implicitly recognised as contained in an anonymous ruby text
container.
Each ruby text container is described by zero or more ruby text annotations each of which is a DOM range that may contain
phrasing content or an rt element, and an annotations range that is a range
including all the annotations for that container. A ruby text container is also
known (primarily in a CSS context) as a ruby annotation container.
Furthermore, a ruby element contains ignored ruby content. Ignored ruby content
does not form part of the document's semantics. It consists of some inter-element
whitespace and rp elements, the latter of which are used for legacy user
agents that do not support ruby at all.
Informally, the segmentation and categorisation algorithm below performs a simple set of
tasks. First it processes adjacent rb elements, text nodes, and non-ruby
elements into a list of bases. Then it processes any number of rtc elements or
sequences of rt elements that are considered to automatically map to an
anonymous ruby text container. Put together these data items form a ruby
segment as detailed in the data model above. It will continue to produce such segments
until it reaches the end of the content of a given ruby element. The complexity
of the algorithm below compared to this informal description stems from the need to support
an author-friendly syntax and being mindful of inter-element white space.
At any particular time, the segmentation and categorisation of content of a ruby element
is the result that would be obtained from running the following algorithm:
Let current annotations be an empty list of DOM ranges.
Let current annotations range be null.
Let current annotations range start be null.
Let current annotation containers be an empty list.
Let current automatic base nodes be an empty list of DOM Nodes.
Let current automatic base range start be null.
Process a ruby child: If index is equal to or greater than the number of
child nodes in root, then run the steps to commit a ruby segment,
return ruby segments, and abort these steps.
Let current child be the indexth node in root.
If current child is not a Text node and is not an
Element node, then increment index by one and jump to the step
labelled process a ruby child.
If current child is an rp element, then increment
index by one and jump to the step labelled process a ruby child. (Note
that this has the effect of including this element in any range that we are currently
processing. This is done intentionally so that misplaced rp can be
processed correctly; semantically they are ignored all the same.)
If current child is an rt element, then run these substeps:
If current annotations is empty, set current annotations range
start to the value of index.
Create a new DOM range whose start is the
boundary point (root,
index) and whose end is the boundary point (root, index plus
one), and append it at the end of current annotations.
Increment index by one and jump to the step labelled process a ruby
child.
If current child is an rtc element, then run these
substeps:
If peek child is an rt element, an
rtc element, or an rp element, then set
index to the value of lookahead index and jump to the step
labelled process a ruby child.
If current annotations is not empty or if current annotation
containers is not empty, then run the steps to commit a ruby segment.
If current child is an rb element, then run these substeps:
If current bases is empty, then set current bases range start to
the value of index.
Create a new DOM range whose start is the
boundary point (root,
index) and whose end is the boundary point (root, index plus
one), and append it at the end of current bases.
Increment index by one and jump to the step labelled process a ruby
child.
If current automatic base nodes is empty, set current automatic base range
start to the value of index.
Append current child at the end of current automatic base nodes.
Increment index by one and jump to the step labelled process a ruby
child.
When the steps above say to commit a ruby segment, it means to run the
following steps at that point in the algorithm:
Create a new ruby segment. It is described by a list of bases set to
current bases, a base DOM range set to current bases range, and a
list of ruby annotation containers
that are the current annotation containers list. Append this new
ruby segment at the end of ruby segments.
Let current bases be an empty list.
Let current bases range be null.
Let current bases range start be null.
Let current annotation containers be an empty list.
When the steps above say to commit the base range, it means to run the following
steps at that point in the algorithm:
If current bases is empty, abort these steps.
If current bases range is not null, abort these steps.
Let current bases range be a DOM range whose start is the boundary
point (root, current bases range start) and whose end is the boundary
point (root, index).
When the steps above say to commit current annotations, it means to run the
following steps at that point in the algorithm:
If current annotations is not empty and current annotations range is
null let current annotations range be a DOM range whose start is the boundary
point (root, current annotations range start) and whose end is the boundary
point (root, index).
If current annotations is not empty, create a new ruby annotation
container. It is described by an annotations list set to current
annotations and a range set to current annotations range. Append this new
ruby annotation container at the end of current annotation
containers.
Let current annotations be an empty list of DOM ranges.
Let current annotations range be null.
Let current annotations range start be null.
When the steps above say to commit an automatic base, it means to run the
following steps at that point in the algorithm:
If current automatic base nodes is empty, abort these steps.
If current automatic base nodes contains nodes that are not Text
nodes, or Text nodes that are not inter-element whitespace, then
run these substeps:
It current bases is empty, set current bases range start to the
value of current automatic base range start.
Create a new DOM range whose start is the
boundary point (root, current
automatic base range start) and whose end
is the boundary point (root,
index), and append it at the end of current bases.
Let current automatic base nodes be an empty list of DOM Nodes.
An rt element that is not a child of a ruby element or of an
rtc element that is itself the child of a ruby element
represents the same thing as its children.
An rtc element that is not a child of a ruby element
represents the same thing as its children.
When an rtc element is processed as part of the segmentation and
categorisation of content for a ruby element, the following algorithm
defines how to process an rtc element:
Let root be the rtc element for which the algorithm is
being run.
indexを0にする。
Let annotations be an empty list of DOM ranges.
Let current automatic annotation nodes be an empty list of DOM nodes.
Let current automatic annotation range start be null.
Process an rtc child: If index is equal to or greater than the number of
child nodes in root, then run the steps to commit an automatic
annotation, return annotations, and abort these steps.
Let current child be the indexth node in root.
If current child is an rt element, then run these substeps:
Create a new DOM range whose start is the
boundary point (root,
index) and whose end is the boundary point (root, index plus
one), and append it at the end of annotations.
Increment index by one and jump to the step labelled process an rtc
child.
If current automatic annotation nodes is empty, set current automatic
annotation range start to the value of index.
Append current child at the end of current automatic annotation
nodes.
Increment index by one and jump to the step labelled process an rtc
child.
When the steps above say to commit an automatic annotation, it means to run the
following steps at that point in the algorithm:
If current automatic annotation nodes is empty, abort these steps.
If current automatic annotation nodes contains nodes that are not
Text nodes, or Text nodes that are not inter-element
whitespace, then create a new DOM range whose start is the boundary
point (root, current automatic annotation range start) and
whose end is the boundary point (root, index), and
append it at the end of annotations.
Let current automatic annotation nodes be an empty list of DOM nodes.
Let current automatic annotation range start be null.
When combined with microformats or
microdata,
the element serves to provide both a machine-readable value for the purposes of data processors, and a human-readable value for the purposes of rendering in a Web browser. この場合、value属性で使用されるフォーマットは、使用中のマイクロフォーマットまたはマイクロ語彙によって決定される。
If parsing a local date and time
string from the element's datetime value returns a local date and time, that is the machine-readable
equivalent; abort these steps.
If the element's datetime value consists of only ASCII digits,
at least one of which is not "0" (U+0030), then the machine-readable equivalent is the
base-ten interpretation of those digits, representing a year; abort these steps.
The algorithms referenced above are intended to be designed such that for any
arbitrary string s, only one of the algorithms returns a value. A more
efficient approach might be to create a single algorithm that parses all these data types in one
pass; developing such an algorithm is left as an exercise to the reader.
The dateTime IDL attribute must
reflect the element's datetime content
attribute.
<article itemscope itemtype="http://n.example.org/rfc4287">
<h1 itemprop="title">Big tasks</h1>
<footer>Published <time itemprop="published" datetime="2009-08-29">two days ago</time>.</footer>
<p itemprop="content">Today, I went out and bought a bike for my kid.</p>
</article>
<article itemscope itemtype="http://schema.org/BlogPosting">
<h1 itemprop="headline">Small tasks</h1>
<footer>Published <time itemprop="datePublished" datetime="2009-08-30">yesterday</time>.</footer>
<p itemprop="articleBody">I put a bike bell on his bike.</p>
</article>
<p>The <code>code</code> element represents a fragment of computer
code.</p>
<p>When you call the <code>activate()</code> method on the
<code>robotSnowman</code> object, the eyes glow.</p>
<p>The example below uses the <code>begin</code> keyword to indicate
the start of a statement block. It is paired with an <code>end</code>
keyword, which is followed by the <code>.</code> punctuation character
(full stop) to indicate the end of the program.</p>
<p>If there are <var>n</var> pipes leading to the ice
cream factory then I expect at <em>least</em> <var>n</var>
flavors of ice cream to be available for purchase!</p>
<figure>
<math>
<mi>a</mi>
<mo>=</mo>
<msqrt>
<msup><mi>b</mi><mn>2</mn></msup>
<mi>+</mi>
<msup><mi>c</mi><mn>2</mn></msup>
</msqrt>
</math>
<figcaption>
Using Pythagoras' theorem to solve for the hypotenuse <var>a</var> of
a triangle with sides <var>b</var> and <var>c</var>
</figcaption>
</figure>
<p>Then he turned to the blackboard and picked up the chalk. After a few moment's
thought, he wrote <var>E</var> = <var>m</var> <var>c</var><sup>2</sup>. The teacher
looked pleased.</p>
<p>The most beautiful women are
<span lang="fr"><abbr>M<sup>lle</sup></abbr> Gwendoline</span> and
<span lang="fr"><abbr>M<sup>me</sup></abbr> Denise</span>.</p>
<p>The coordinate of the <var>i</var>th point is
(<var>x<sub><var>i</var></sub></var>, <var>y<sub><var>i</var></sub></var>).
For example, the 10th point has coordinate
(<var>x<sub>10</sub></var>, <var>y<sub>10</sub></var>).</p>
<p>The <i class="taxonomy">Felis silvestris catus</i> is cute.</p>
<p>The term <i>prose content</i> is defined above.</p>
<p>There is a certain <i lang="fr">je ne sais quoi</i> in the air.</p>
<p>Raymond tried to sleep.</p>
<p><i>The ship sailed away on Thursday</i>, he
dreamt. <i>The ship had many people aboard, including a beautiful
princess called Carey. He watched her, day-in, day-out, hoping she
would notice him, but she never did.</i></p>
<p><i>Finally one night he picked up the courage to speak with
her—</i></p>
<p>Raymond woke with a start as the fire alarm rang out.</p>
<article>
<h2>Kittens 'adopted' by pet rabbit</h2>
<p><b class="lede">Six abandoned kittens have found an
unexpected new mother figure — a pet rabbit.</b></p>
<p>Veterinary nurse Melanie Humble took the three-week-old
kittens to her Aberdeen home.</p>
[...]
In most cases, another element is likely to be more appropriate: for marking stress emphasis,
the em element should be used; for marking key words or phrases either the
b element or the mark element should be used, depending on the context;
for marking book titles, the cite element should be used; for labeling text with explicit textual annotations, the
ruby element should be used; for labeling ship names in Western texts, the
i element should be used.
<p lang="en-US">Consider the following quote:</p>
<blockquote lang="en-GB">
<p>Look around and you will find, no-one's really
<mark>colour</mark> blind.</p>
</blockquote>
<p lang="en-US">As we can tell from the <em>spelling</em> of the word,
the person writing this quote is clearly not American.</p>
<p>I also have some <mark>kitten</mark>s who are visiting me
these days. They're really cute. I think they like my garden! Maybe I
should adopt a <mark>kitten</mark>.</p>
次の断片において、テキストの段落はコード断片の特定部分に言及する。
<p>The highlighted part below is where the error lies:</p>
<pre><code>var i: Integer;
begin
i := <mark>1.1</mark>;
end.</code></pre>
<article>
<style scoped>
blockquote mark, q mark {
font: inherit; font-style: italic;
text-decoration: none;
background: transparent; color: inherit;
}
.bubble em {
font: inherit; font-size: larger;
text-decoration: underline;
}
</style>
<h1>She knew</h1>
<p>Did you notice the subtle joke in the joke on panel 4?</p>
<blockquote>
<p class="bubble">I didn't <em>want</em> to believe. <mark>Of course
on some level I realised it was a known-plaintext attack.</mark> But I
couldn't admit it until I saw for myself.</p>
</blockquote>
<p>(Emphasis mine.) I thought that was great. It's so pedantic, yet it
explains everything neatly.</p>
</article>
<h3>Wormhole Physics Introduction</h3>
<p><mark>A wormhole in normal conditions can be held open for a
maximum of just under 39 minutes.</mark> Conditions that can increase
the time include a powerful energy source coupled to one or both of
the gates connecting the wormhole, and a large gravity well (such as a
black hole).</p>
<p><mark>Momentum is preserved across the wormhole. Electromagnetic
radiation can travel in both directions through a wormhole,
but matter cannot.</mark></p>
<p>When a wormhole is created, a vortex normally forms.
<strong>Warning: The vortex caused by the wormhole opening will
annihilate anything in its path.</strong> Vortexes can be avoided when
using sufficiently advanced dialing technology.</p>
<p><mark>An obstruction in a gate will prevent it from accepting a
wormhole connection.</mark></p>
<aside>
<!-- don't do this -->
<ins datetime="2005-03-16 00:00Z">
<p> I like fruit. </p>
Apples are <em>tasty</em>.
</ins>
<ins datetime="2007-12-19 00:00Z">
So are pears.
</ins>
</aside>
<aside>
<ins datetime="2005-03-16 00:00Z">
<p> I like fruit. </p>
</ins>
<ins datetime="2005-03-16 00:00Z">
Apples are <em>tasty</em>.
</ins>
<ins datetime="2007-12-19 00:00Z">
So are pears.
</ins>
</aside>
<h1>To Do</h1>
<ul>
<li>Empty the dishwasher</li>
<li><del datetime="2009-10-11T01:25-07:00">Watch Walter Lewin's lectures</del></li>
<li><del datetime="2009-10-10T23:38-07:00">Download more tracks</del></li>
<li>Buy a printer</li>
</ul>
cite属性が存在する場合、変更を説明する潜在的にスペースで囲まれた妥当なURLでなければならない。To obtain the corresponding citation link, the value of the attribute must be resolved relative to the element. User agents may allow users to follow such citation links, but they are primarily intended for private use (e.g. by server-side scripts collecting statistics about a site's edits), not for readers.
User agents must parse the datetime attribute according
to the parse a date or time string algorithm. If that doesn't return a date or a global date and time,
then the modification has no associated timestamp (the value is non-conforming; it is not a
valid date string with optional time). Otherwise, the modification is marked as
having been made at the given date or global date and time. If the given value is a global date and time then user agents should use the associated
time-zone offset information to determine which time zone to present the given datetime in.
This value may be shown to the user, but it is primarily intended for
private use.
The cite IDL attribute must reflect
the element's cite content attribute. The dateTime IDL attribute must reflect the
element's datetime content attribute.
<section>
<ins>
<p>
This is a paragraph that was inserted.
</p>
This is another paragraph whose first sentence was inserted
at the same time as the paragraph above.
</ins>
This is a second sentence, which was there all along.
</section>
<section>
This is the first paragraph. <ins>This sentence was
inserted.
<p>This second paragraph was inserted.</p>
This sentence was inserted too.</ins> This is the
third paragraph in this example.
<!-- (don't do this) -->
</section>
<section>
<p>This is the first paragraph. <del>This sentence was
deleted.</del></p>
<p><del>This sentence was deleted too.</del> That
sentence needed a separate <del> element.</p>
</section>
The user agent hasn't obtained any image data,
or has obtained some or all of the image data but
hasn't yet decoded enough of the image to get the image dimensions.
Partially available
The user agent has obtained some of the image data and at least the image dimensions are
available.
Completely available
The user agent has obtained all of the image data and at least the image dimensions are
available.
Broken
The user agent has obtained all of the image data that it can, but it cannot even decode the
image enough to get the image dimensions (e.g. the image is corrupted, or the format is not
supported, or no data could be obtained).
When an img element is available, it
provides a paint source whose width is the image's intrinsic width, whose height is
the image's intrinsic height, and whose appearance is the intrinsic appearance of the image.
A user agent that obtains images immediately must synchronously
update the image data of an img element,
with the restart animation flag set if so stated,
whenever that element is created,
or has experienced relevant mutations,
and whenever that element's adopting steps are run.
A user agent that obtains images on demand must update the image data of an
img element whenever it needs the image data (i.e. on demand),
but only if the img element is in the
unavailable state. When an img element
has experienced relevant mutations,
and whenever that element's adopting steps are run, if the user
agent only obtains images on demand, the img element must return to the unavailable state.
The relevant mutations for an img element are as follows:
The element's src,
srcset
or sizes attributes are set, changed, or removed.
The element's src attribute is set to the same value as the previous value.
This must set the restart animation flag for the update the image data algorithm.
The element's crossorigin attribute's state is changed.
The element is inserted into or removed from a picture parent element.
The element's parent is a picture element and a
source element is inserted as a previous sibling.
The element's parent is a picture element and a
source element that was a previous sibling is removed.
The element's parent is a picture element and a
source element that is a previous sibling has its
srcset,
sizes,
media
or type attributes set, changed, or removed.
Each img element has a last selected source, which must initially be
null.
Each image request has a current pixel density, which must initially be undefined.
When an img element has a current pixel density that is not 1.0, the
element's image data must be treated as if its resolution, in device pixels per CSS pixels, was
the current pixel density.
For example, if the current pixel density is 3.125, that means
that there are 300 device pixels per CSS inch, and thus if the image data is 300x600, it has an
intrinsic dimension of 96 CSS pixels by 192 CSS pixels.
Each Document object must have a list of available images. Each image
in this list is identified by a tuple consisting of an absolute URL, a CORS
settings attribute mode, and, if the mode is not No
CORS, an origin.
Each image furthermore has an ignore higher-layer caching flag.
User agents may copy entries from one Document
object's list of available images to another at any time (e.g. when the
Document is created, user agents can add to it all the images that are loaded in
other Documents), but must not change the keys of entries copied in this way when
doing so, and must unset the ignore higher-layer caching flag for the copied entry.
User agents may also remove images from such lists at any time (e.g. to save
memory).
User agents must remove entries in the list of available images as appropriate
given higher-layer caching semantics for the resource (e.g. the HTTP Cache-Control
response header) when the ignore higher-layer caching is unset.
For example, if a resource has the HTTP response header Cache-Control: must-revalidate,
the user agent would remove it from the list of available images but could keep the image data separately,
and use that if the server responds with a 204 No Content status.
When the user agent is to update the image data of an img element,
optionally with the restart animations flag set,
it must run the following steps:
If the element does not have a srcset attribute specified and
it does not have a parent or it has a parent but it is not a picture element,
and it has a src attribute specified and
its value is not the empty string, let selected source be the value of the
element's src attribute, and selected pixel
density be 1.0. Otherwise, let selected source be null and selected pixel density be undefined.
⌛ If another instance of this algorithm for this img element was started
after this instance (even if it aborted and is no longer running), then abort these steps.
Only the last instance takes effect, to avoid multiple requests when, for
example, the src, srcset,
and crossorigin attributes are all set in
succession.
⌛ Let selected source and selected pixel density be the
URL and pixel density that results from selecting an image source,
respectively.
⌛ Do a potentially CORS-enabled fetch of absolute URL,
with the mode being the current state of
the element's crossorigin content attribute, the origin being the origin of the img element's
Document, and the default origin behaviour set to taint.
Let this instance of the fetching algorithm be associated with image request.
This, unfortunately, can be used to perform a rudimentary port scan of the
user's local network (especially in conjunction with scripting, though scripting isn't actually
necessary to carry out such an attack). User agents may implement cross-origin access control policies that are stricter than those
described above to mitigate this attack, but unfortunately such policies are typically not
compatible with existing Web content.
Otherwise, if image request is the current request,
it is in the unavailable state,
and the user agent is able to determine that image request's image
is corrupted in some fatal way such that the image dimensions cannot be obtained,
set the current request's state to broken.
Otherwise, if the user agent is able to determine image request's image's width and height,
and image request is current request,
update the img element's presentation appropriately
and set image request's state to partially available.
That task, and each subsequent task, that is queued by the
networking task source while the image is being fetched,
if image request is the current request,
must update the presentation of the image appropriately (e.g. if
the image is a progressive JPEG, each packet can improve the resolution of the image).
To restart the animation for an img element means that,
if the image is an animated image,
all animated images with the same absolute URL and the same image data in the img element's Document
are expected to restart their animation.
While a user agent is running the above algorithm for an element x, there
must be a strong reference from the element's Document to the element x, even if that element is not in its
Document.
When an img element is in the completely available
state and the user agent can decode the media data without errors, then the
img element is said to be fully decodable.
Whether the image is fetched successfully or not (e.g. whether the response code was a 2xx code
or equivalent) must be ignored when determining
the image's type and whether it is a valid image.
This allows servers to return images with error responses, and have them
displayed.
User agents must not support non-image resources with the img element (e.g. XML
files whose root element is an HTML element). User agents must not run executable code (e.g.
scripts) embedded in the image resource. User agents must only display the first page of a
multipage resource (e.g. a PDF file). User agents must not allow the resource to act in an
interactive fashion, but should honor any animation in the resource.
This specification does not specify which image types are to be supported.
An image source is a URL,
and optionally either a density descriptor, or a width descriptor.
A source size is a <source-size-value>.
When a source size has a unit relative to the viewport,
it must be interpreted relative to the img element's document's viewport.
Other units must be interpreted the same as in Media Queries. [MQ]
When asked to select an image source for a given img element el,
user agents must do the following:
If el has a parent node and that is a picture element,
let elements be an array containing el's parent node's child elements, retaining relative order.
Otherwise, let elements be array containing only el.
Iterate through elements,
doing the following for each item child:
If child has a src attribute
whose value is not the empty string
and source set does not contain an
image source with a density descriptor value of 1,
and no image source with a width descriptor,
append child's src attribute value to source set.
Each img element independently considers
its previous sibling source elements
plus the img element itself
for selecting an image source, ignoring any other (invalid) elements,
including other img elements in the same picture element,
or source elements that are following siblings
of the relevant img element.
When asked to parse a srcset attribute from an element,
parse the value of the element's srcset attribute as follows:
Let input be the value passed to this algorithm.
Let position be a pointer into input,
initially pointing at the start of the string.
Let raw candidates be an initially empty
ordered list of URLs with associated unparsed descriptor list.
The order of entries in the lists is the order in which entries are added to the lists.
If url ends with a "," (U+002C) character,
follow these substeps:
Remove all trailing U+002C COMMA characters from url.
If url is empty,
then jump to the step labeled splitting loop.
Otherwise, follow these substeps:
Let current token be the empty string.
Let state be start.
Let c be the character at position.
Do the following depending on the value of state.
For the purpose of this step, "EOF" is a special character representing
that position is past the end of input.
If current token is not empty,
append current token to descriptors
and let current token be the empty string.
Set state to after token.
"," (U+002C)
Advance position to the next character in input.
If current token is not empty,
append current token to descriptors.
Jump to the step labeled add candidate.
"(" (U+0028)
Append c to current token.
Set state to in parens.
EOF
If current token is not empty,
append current token to descriptors.
Jump to the step labeled add candidate.
Anything else
Append c to current token.
In parens
Do the following, depending on the value of c:
")" (U+0029)
Append c to current token.
Set state to start.
EOF
Append current token to descriptors.
Jump to the step labeled add candidate.
Set state to start.
Set position to the previous character in input.
Advance position to the next character in input.
Repeat this step.
Add candidate: Add url to raw candidates,
associated with descriptors.
Return to the step labeled splitting loop.
Descriptor parser:
Let candidates be an initially empty source set.
The order of entries in the list is the order in which entries are added to the list.
For each entry in raw candidates with URL url
associated with the unparsed descriptor list descriptor list,
run these substeps:
Let error be no.
Let width be absent.
Let density be absent.
Let future-compat-h be absent.
For each token in descriptor list,
run the appropriate set of steps from the following list:
If the token consists of a valid non-negative integer
followed by a U+0077 LATIN SMALL LETTER W character
If width and density
are not both absent,
then let error be yes.
If density is zero,
the intrinsic dimensions will be infinite.
User agents are expected to have limits in how big images can be rendered,
which is allowed by the hardware limitations clause.
If the token consists of a valid non-negative integer
followed by a U+0068 LATIN SMALL LETTER H character
If future-compat-h and density
are not both absent,
then let error be yes.
If error is still no,
then add a new image source to candidates
whose URL is url,
associated with a width width if not absent
and a pixel density density if not absent.
Return candidates.
When asked to parse a sizes attribute from an element,
parse a comma-separated list of component values
from the value of the element's sizes attribute
(or the empty string, if the attribute is absent),
and let unparsed sizes list be the result. [CSSSYNTAX]
For each unparsed size in unparsed sizes list:
Remove all consecutive <whitespace-token>s
from the end of unparsed size.
If unparsed size is now empty,
continue to the next iteration of this algorithm.
If the last component value in unparsed size
is a valid non-negative <source-size-value>,
let size be its value
and remove the component value from unparsed size.
Otherwise, continue to the next iteration of this algorithm.
Remove all consecutive <whitespace-token>s
from the end of unparsed size.
If unparsed size is now empty,
return size and exit this algorithm.
Parse the remaining component values in unparsed size
as a <media-condition>.
If it does not parse correctly,
or it does parse correctly but the <media-condition> evaluates to false,
continue to the next iteration of this algorithm. [MQ]
Return size and exit this algorithm.
If the above algorithm exhausts unparsed sizes list without returning a size value,
return 100vw.
While a valid source size list only contains a bare <source-size-value>
(without an accompanying <media-condition>)
as the last entry in the <source-size-list>,
the parsing algorithm technically allows such at any point in the list,
and will accept it immediately as the size
if the preceding entries in the list weren't used.
This is to enable future extensions,
and protect against simple author errors such as a final trailing comma.
An image source can have a density descriptor,
a width descriptor,
or no descriptor at all accompanying its URL.
Normalizing a source set gives every image source a density descriptor.
When asked to normalize the source densities of a source setsource set,
the user agent must do the following:
Otherwise, if the image source has a width descriptor,
replace the width descriptor with a density descriptor
with a value of the width descriptor divided by the source size
and a unit of x.
If the source size is zero,
the density would be infinity,
which results in the intrinsic dimensions being zero by zero.
Otherwise, give the image source a density descriptor of 1x.
The user agent may at any time run the following algorithm to update an img
element's image in order to react to changes in the environment. (User agents are not
required to ever run this algorithm; for example, if the user is not looking at the page any
more, the user agent might want to wait until the user has returned to the page before determining
which image to use, in case the environment changes again in the meantime.)
If this download fails in any way (other than the response code not being a 2xx code, as
mentioned earlier), or if the image format is unsupported (as determined by applying the image sniffing rules, again as mentioned earlier),
or if the resource type is multipart/x-mixed-replace, then abort these steps.
Otherwise, wait for the fetch algorithm to queue its last task, and then
continue with these steps. The data obtained in this way is used in the steps below.
Replace the img element's image data with the resource obtained by the
earlier step of this algorithm. It can be either CORS-same-origin or
CORS-cross-origin; this affects the origin of the image itself (e.g.
when used on a canvas).
What an img element represents depends on the src attribute and the alt
attribute.
If the src attribute is set and the alt attribute is set to the empty string
The image is either decorative or supplemental to the rest of the content, redundant with
some other information in the document.
If the image is available and the user agent is configured
to display that image, then the element represents the element's image data.
Otherwise, the element represents nothing, and may be omitted completely from
the rendering. User agents may provide the user with a notification that an image is present but
has been omitted from the rendering.
If the src attribute is set and the alt attribute is set to a value that isn't empty
The image is a key part of the content; the alt attribute
gives a textual equivalent or replacement for the image.
If the image is available and the user agent is configured
to display that image, then the element represents the element's image data.
Otherwise, the element represents the text given by the alt attribute. User agents may provide the user with a notification
that an image is present but has been omitted from the rendering.
If the src attribute is set and the alt attribute is not
There is no textual equivalent of the image available.
If the image is available and the user agent is configured
to display that image, then the element represents the element's image data.
Otherwise, the user agent should display some sort of indicator that there is an image that
is not being rendered, and may, if requested by the user, or if so configured, or when required
to provide contextual information in response to navigation, provide caption information for the
image, derived as follows:
If the image is a descendant of a figure element that has a child
figcaption element, and, ignoring the figcaption element and its
descendants, the figure element has no Text node descendants other
than inter-element whitespace, and no embedded content descendant
other than the img element, then the contents of the first such
figcaption element are the caption information; abort these steps.
There is no caption information.
If the src attribute is not set and either the alt attribute is set to the empty string or the alt attribute is not set at all
The element represents the text given by the alt attribute.
The alt attribute does not represent advisory information.
User agents must not present the contents of the alt attribute
in the same way as content of the title attribute.
The IDL attributes width and height must return the rendered width and height of the
image, in CSS pixels, if the image is being rendered, and is being rendered to a
visual medium; or else the intrinsic width and height of the image, in CSS pixels, if the image is
available but not being rendered to a visual medium; or else 0, if
the image is not available. [CSS]
On setting, they must act as if they reflected the respective
content attributes of the same name.
The IDL attributes naturalWidth and naturalHeight must return the intrinsic width and
height of the image, in CSS pixels, if the image is available, or
else 0. [CSS]
The IDL attribute complete must return true if
any of the following conditions is true:
Both the src attribute and the srcset attribute are omitted.
The srcset attribute is omitted and the src attribute's value is the empty string.
A constructor is provided for creating HTMLImageElement objects (in addition to
the factory methods from DOM such as createElement()): Image(width, height).
When invoked as a constructor, this must return a new HTMLImageElement object (a new
img element). If the width argument is present, the new object's
width content attribute must be set to width. If the height argument is also present, the new object's
height content attribute must be set to height. The element's document must be the active document of the
browsing context of the Window object on which the interface object of
the invoked constructor is found.
画像のalt属性は非常に重要なアクセシビリティー属性である。有用なalt属性コンテンツを作成することは、画像が出現するコンテキストおよびそのコンテキストにおいて画像が持ってもよい機能を著者に注意深く考慮することを要求する。ここを含むガイダンスは、著者が画像を使用するもっとも一般的な方法を扱う。追加のガイダンスおよびテクニックはResources on Alternative Text for Imagesで利用可能である。
この例において、PIP社の会社のロゴは2つの画像に分割されており、1枚目は単語PIPを含み、2枚目は略語COをもつ。画像は、PIPCOのホームページへのリンクに属する唯一のコンテンツである。この場合、リンク先の簡単な説明が提供される。単一の実体として画像はユーザーに提供されるので、最初の画像のalt属性におけるテキストによる代替はPIP CO homeである。
<a href="pipco-home.html">
<img src="pip.gif" alt="PIP CO home"><img src="co.gif" alt="">
</a>
<img src="piechart.gif" alt="Pie chart: Browser Share - Internet Explorer 25%, Firefox 40%, Chrome 25%, Safari 6% and Opera 4%.">
この場合、グラフィカルな形式で画像が前の段落を繰り返す。alt属性コンテンツは画像を分類する。
<p>According to a recent study Firefox has a 40% browser share, Internet Explorer has 25%, Chrome has 25%, Safari has 6% and Opera has 4%.</p>
<p><img src="piechart.gif" alt="Pie chart representing the data in the previous paragraph."></p>
<a href="#desc"><img src="flowchart.gif" alt="Flowchart: Dealing with a broken lamp."></a>
...
...
<div id="desc">
<h2>Dealing with a broken lamp</h2>
<ol><li>Check if it's plugged in, if not, plug it in.</li><li>If it still doesn't work; check if the bulb is burned out. If it is, replace the bulb.</li><li>If it still doesn't work; buy a new lamp.</li></ol>
</div>
<figure>
<img src="flowchart.gif" alt="Flowchart: Dealing with a broken lamp.">
<details><summary>Dealing with a broken lamp</summary>
<ol>
lt;li>Check if it's plugged in, if not, plug it in.</li>
<li>If it still doesn't work; check if the bulb is burned out. If it is, replace the bulb.</li>
<li>If it still doesn't work; buy a new lamp.</li>
</ol>
</details>
</figure>
この例では、テキストからなる広告画像であり、フレーズ"The BIG sale"が3回繰り返され、回を重ねるごとにテキストはより小さくかつより暗くなり、最後の行は"...ends Friday"と読む。広告として、コンテキストにおける使用は、画像のテキストによる代替は一度だけテキスト"The BIG sale"を含むことが推奨される。視覚効果とテキストの繰り返しは、画像が表示できないユーザーにとって不要であり、混乱を招くかもしれない。
<p><img src="sale.gif" alt="The BIG sale ...ends Friday."></p>
<figure>
<img src="figure1.gif" alt="Figure 1">
<figcaption><strong>Figure 1.</strong> Distribution of Articles by Journal Category.
Pie chart: Language=68%, Education=14% and Science=18%.</figcaption>
</figure>
これはページ内容の主題に密接に関連するが、直接説明されない画像の一例である。その詩の暗唱ページで、詩に触発された絵の画像である。次の断片は例を示す。画像は、"Lady of Shallot"（シャロットの貴婦人）と題した絵画であり、絵は詩に触発され、絵の主題は詩から派生している。したがって、テキストによる代替が提供されることを強く推奨する。alt属性に画像の内容の短い説明があり、文の下に長い説明へのリンクがある。長い説明の最後に絵についての詳しい情報へのリンクもある。
<header>
<h1>The Lady of Shalott</h1>
<p>A poem by Alfred Lord Tennyson</p>
</header>
<img src="shalott.jpeg" alt="Painting of a young woman with long hair, sitting in a wooden boat. ">
<p><a href="#des">Description of the painting</a>.</p>
<!-- Full Recitation of Alfred, Lord Tennyson's Poem. -->
...
...
...
<p id="des">The woman in the painting is wearing a flowing white dress. A large piece of intricately
patterned fabric is draped over the side. In her right hand she holds the chain mooring the boat. Her expression
is mournful. She stares at a crucifix lying in front of her. Beside it are three candles. Two have blown out.<a href="http://bit.ly/5HJvVZ">Further information about the painting</a>.</p>
この例は、ページの主題の写真として画像を識別するテキストによる代替の提供を説明する。
<img src="orateur_robin_berjon.png" alt="Portrait photo(black and white) of Robin.">
<h1>Robin Berjon</h1>
<p>What more needs to be said?</p>
<header><h1>The Lady of Shalott</h1>
<p>A poem by Alfred Lord Tennyson</p></header>
<figure>
<img src="shalott.jpeg" alt="Painting of a woman in a white flowing dress, sitting in a small boat.">
<p><a href="http://bit.ly/5HJvVZ">About this painting.</a></p>
</figure>
<!-- Full Recitation of Alfred, Lord Tennyson's Poem. -->
<p>View houses for sale in North Katoomba or South Katoomba:</p>
<p><img src="imagemap.png" width="209" alt="Map of Katoomba" height="249" usemap="#Map">
<map name="Map">
<area shape="poly" coords="78,124,124,10,189,29,173,93,168,132,136,151,110,130"
href="north.html" alt="Houses in North Katoomba">
<area shape="poly" coords="66,63,80,135,106,138,137,154,167,137,175,133,144,240,49,223,17,137,17,61"
alt="Houses in South Katoomba" href="south.html">
</map>
<h1>The crocoduck</h1>
<p>You encounter a strange creature called a "crocoduck".
The creature seems angry!Perhaps some friendly stroking will help to calm
it, but be careful not to stroke any crocodile parts. This would just enrage
the beast further.</p>
<a href="?stroke=head"><img src="crocoduck1.png" alt="Stroke crocodile's angry, chomping head"></a>
<a href="?stroke=body"><img src="crocoduck2.png" alt="Stroke duck's soft, feathery body"></a>
<figure>
<img src="664aef.jpg" alt="Lola the cat sitting under an umbrella in the bath tub.">
<figcaption>Lola prefers a bath to a shower.</figcaption>
</figure>
<figure>
<img src="Rorschach1.jpg" alt="An abstract, freeform, vertically symmetrical, black inkblot on a light background.">
<figcaption>The first of the ten cards in the Rorschach test.</figcaption>
</figure>
<figure>
<img src="webcam1.jpg" alt="Sopwith house weather cam. Taken on the 21/04/10 at 11:51 and 34 seconds.
In the foreground are the safety rails on the flat part of the roof. Nearby there are low rise industrial buildings,
beyond are blocks of flats. In the distance there's a church steeple.">
<figcaption>View from Sopwith house, looking towards north Kingston. This image is updated every hour.</figcaption>
</figure>
<p>View the <a href="http://news.bbc.co.uk/weather/forecast/4296?area=Kingston">latest weather details</a> for Kingston upon Thames.</p>
HTML5 is a language for structuring and presenting content for the World
Wide Web, a core technology of the Internet. It is the latest revision of the HTML standard
(originally created in 1990 and most recently standardized as HTML4 in 1997) and currently remains
under development. Its core aims have been to improve the language with support for the latest
multimedia while keeping it easily readable by humans and consistently understood by computers and
devices (web browsers, parsers etc.).
<p><img src="HTML5_Logo.png" alt="HTML5 logo: Shaped like a shield with the
text 'HTML' above and the numeral '5' prominent on the face of the shield."></p>
Information about HTML5
4.7.5.1.20 CAPTCHA画像
CAPTCHA（キャプチャ）は、"Completely Automated Public Turing test to tell Computers and Humans Apart"（コンピュータと人間を区別する完全に自動化された公開チューリングテスト）の略である。CAPTCHA 画像は、コンテンツがコンピュータではなく人間によってアクセスされていることを確認する、セキュリティー目的のために使用される。この認証は、画像の視覚的な検証を介して行われる。CAPTCHAは一般的に、文字や単語をもつ画像を提示し、ユーザーがそれを入力する。画像は通常、歪められており、文字を読解困難にするために適用されるノイズを持つ。
<img src="captcha.png" alt="If you cannot view this image an audio challenge is provided.">
<!-- audio CAPTCHA option that allows the user to listen and type the word -->
<!-- form that asks a question -->
<h2>Is it a ghost?</h2>
<picture>
<source media="(min-width: 32em)" srcset="large.jpg">
<img src="small.jpg" alt="Reflection of a girls face in a train window.">
</picture>
Markup generators (such as WYSIWYG authoring tools) should,
wherever possible, obtain a text alternative from their
users. However, it is recognized that in many cases, this will not
be possible.
For images that are the sole contents of links, markup generators
should examine the link target to determine the title of the target,
or the URL of the target, and use information obtained in this
manner as the text alternative.
For images that have captions, markup generators should use the
figure and figcaption elements to provide the
image's caption.
As a last resort, implementors should either set the alt attribute to the empty string, under
the assumption that the image is a purely decorative image that
doesn't add any information but is still specific to the surrounding
content, or omit the alt attribute
altogether, under the assumption that the image is a key part of the
content.
Markup generators may specify a generator-unable-to-provide-required-alt
attribute on img elements for which they have been
unable to obtain a text alternative and for which they have therefore
omitted the alt attribute. The
value of this attribute must be the empty string. Documents
containing such attributes are not conforming, but conformance
checkers will silently
ignore this error.
This is intended to avoid markup generators from
being pressured into replacing the error of omitting the alt attribute with the even more
egregious error of providing phony text alternatives, because
state-of-the-art automated conformance checkers cannot distinguish
phony text alternatives from correct text alternatives.
Markup generators should generally avoid using the image's own
file name as the text alternative. Similarly, markup generators
should avoid generating text alternatives from any content that will
be equally available to presentation user agents (e.g. Web
browsers).
This is because once a page is generated, it will
typically not be updated, whereas the browsers that later read the
page can be updated by the user, therefore the browser is likely to
have more up-to-date and finely-tuned heuristics than the markup
generator did when generating the page.
4.7.5.1.23 Guidance for conformance checkers
A conformance checker must report the lack of an alt attribute as an error unless one of
the conditions listed below applies:
The img element has a (non-conforming) generator-unable-to-provide-required-alt
attribute whose value is the empty string. A conformance checker
that is not reporting the lack of an alt attribute as an error must also not
report the presence of the empty generator-unable-to-provide-required-alt
attribute as an error. (This case does not represent a case where
the document is conforming, only that the generator could not
determine appropriate alternative text — validators are not
required to show an error in this case, because such an error might
encourage markup generators to include bogus alternative text
purely in an attempt to silence validators. Naturally, conformance
checkers may report the lack of an alt attribute as an error even in the
presence of the generator-unable-to-provide-required-alt
attribute; for example, there could be a user option to report
all conformance errors even those that might be the more
or less inevitable result of using a markup generator.)
<article>
<h1>I got my own magazine!</h1>
<p>After much effort, I've finally found a publisher, and so now I
have my own magazine!Isn't that awesome?!The first issue will come
out in September, and we have articles about getting food, and about
getting in boxes, it's going to be great!</p>
<footer>
<p>Written by <a href="/users/cap">cap</a>, 1 hour ago.
</footer>
<article>
<footer> Thirteen minutes ago, <a href="/users/ch">ch</a> wrote: </footer>
<iframe seamless sandbox srcdoc="<p>did you get a cover picture yet?"></iframe>
</article>
<article>
<footer> Nine minutes ago, <a href="/users/cap">cap</a> wrote: </footer>
<iframe seamless sandbox srcdoc="<p>Yeah, you can see it <a href="/gallery?mode=cover&amp;page=1">in my gallery</a>."></iframe>
</article>
<article>
<footer> Five minutes ago, <a href="/users/ch">ch</a> wrote: </footer>
<iframe seamless sandbox srcdoc="<p>hey that's earl's table.
<p>you should get earl&amp;me on the next cover."></iframe>
</article>
A load event is also fired at the
iframe element when it is created if no other data is loaded in it.
Each Document has an iframe load in progress flag and a mute
iframe load flag. When a Document is created, these flags must be unset for
that Document.
This, in conjunction with scripting, can be used to probe the URL space of the
local network's HTTP servers. User agents may implement cross-origin
access control policies that are stricter than those described above to mitigate this attack, but
unfortunately such policies are typically not compatible with existing Web content.
Whenever the name attribute is set, the nested
browsing context's name must be changed to
the new value. If the attribute is removed, the browsing context name must be set to
the empty string.
<p>We're not scared of you! Here is your content, unedited:</p>
<iframe sandbox src="http://usercontent.example.net/getusercontent.cgi?id=12193"></iframe>
Suppose now that a script in A removes all the sandbox attributes in A and B. This would change nothing immediately. ユーザーがCのリンクをクリックした場合、BでのiframeにページDを読み込み、リンクはページBが読み込まれた際にAの<c11><a12>iframe</a12></c11>内のネストされたブラウジングコンテキストの状態だったため、あたかもBでのiframeがallow-same-originと<c8><a9>allow-forms</a9></c8>キーワードが設定されていたかのように、ページDは振る舞うだろう。
In a CSS-supporting user agent: the user agent must add all the style sheets that apply to
the iframe element to the cascade of the active document of the
iframe element's nested browsing context, at the appropriate cascade
levels, before any style sheets specified by the document itself.
In a CSS-supporting user agent: the user agent must, for the purpose of CSS property
inheritance only, treat the root element of the active document of the
iframe element's nested browsing context as being a child of the
iframe element. (Thus inherited properties on the root element of the document in
the iframe will inherit the computed values of those properties on the
iframe element instead of taking their initial values.)
In visual media, in a CSS-supporting user agent: the user agent should set the intrinsic
width of the iframe to the width that the element would have if it was a
non-replaced block-level element with 'width: auto', unless that width would be zero (e.g. if the
element is floating or absolutely positioned), in which case the user agent should set the
intrinsic width of the iframe to the shrink-to-fit width of the root element (if
any) of the content rendered in the iframe.
In visual media, in a CSS-supporting user agent: the user agent should set the intrinsic
height of the iframe to the shortest height that would make the content rendered in
the iframe at its current width (as given in the previous bullet point) have no
scrollable overflow at its bottom edge Scrollable overflow is any overflow that would increase the range to which a scrollbar or other scrolling mechanism can scroll.
In visual media, in a CSS-supporting user agent: the user agent must force the height of the
initial containing block of the active document of the nested browsing
context of the iframe to zero.
This is intended to get around the otherwise circular dependency of percentage
dimensions that depend on the height of the containing block, thus affecting the height of the
document's bounding box, thus affecting the height of the viewport, thus affecting the size of
the initial containing block.
In speech media, the user agent should render the nested browsing context
without announcing that it is a separate document.
For example if the user agent supports listing all the links in a document,
links in "seamlessly" nested documents would be included in that list without being
significantly distinguished from links in the document itself.
While any of the following conditions are occurring, any plugin instantiated for
the element must be removed, and the embed element represents
nothing:
The element has neither a src attribute nor a type attribute.
Determine the type of the content being embedded, as
follows (stopping at the first substep that determines the type):
If the element has a type attribute, and that
attribute's value is a type that a plugin supports, then the value of the
type attribute is the content's type.
Otherwise, if applying the URL parser algorithm to the URL of
the specified resource (after any redirects) results in a parsed URL whose
path component matches a pattern that a
plugin supports, then the content's
type is the type that that plugin can handle.
For example, a plugin might say that it can handle resources with path components that end with the four character string
".swf".
Otherwise, find and instantiate an appropriate plugin based on the content's type, and hand that plugin the
content of the resource, replacing any previously instantiated plugin for the element. The
embed element now represents this plugin instance.
Whether the resource is fetched successfully or not (e.g. whether the response code was a
2xx code or equivalent) must be ignored
when determining the content's type and when handing
the resource to the plugin.
This allows servers to return data for plugins even with error responses (e.g.
HTTP 500 Internal Server Error codes can still contain plugin data).
The user agent should find and instantiate an appropriate plugin based on the
value of the type attribute. The embed
element now represents this plugin instance.
The embed element has no fallback content. If the user agent can't
find a suitable plugin when attempting to find and instantiate one for the algorithm above, then
the user agent must use a default plugin. This default could be as simple as saying "Unsupported
Format".
When a plugin is to be instantiated but it cannot be secured and the sandboxed plugins browsing context
flag is set on the embed element's Document's active
sandboxing flag set, then the user agent must not instantiate the plugin, and
must instead render the embed element in a manner that conveys that the
plugin was disabled. The user agent may offer the user the option to override the
sandbox and instantiate the plugin anyway; if the user invokes such an option, the
user agent must act as if the conditions above did not apply for the purposes of this element.
Plugins that cannot be secured are
disabled in sandboxed browsing contexts because they might not honor the restrictions imposed by
the sandbox (e.g. they might allow scripting even when scripting in the sandbox is disabled). User
agents should convey the danger of overriding the sandbox to the user if an option to do so is
provided.
The user agent should pass the names and values of all the attributes of the embed
element that have no namespace to the plugin used, when one is instantiated.
The HTMLEmbedElement object representing the element must expose the scriptable
interface of the plugin instantiated for the embed element, if any. At a
minimum, this interface must implement the legacy caller
operation. (It is suggested that the default behavior of this legacy caller operation, e.g.
the behavior of the default plugin's legacy caller operation, be to throw a
NotSupportedError exception.)
one of the element's ancestor object elements changes to or from showing its
fallback content,
the element's classid attribute is set, changed, or
removed,
the element's classid attribute is not present, and
its data attribute is set, changed, or removed,
neither the element's classid attribute nor its
data attribute are present, and its type attribute is set, changed, or removed,
the element changes from being rendered to not being rendered, or vice versa,
...the user agent must queue a task to run the following steps to (re)determine
what the object element represents. This task
being queued or actively running must delay the load
event of the element's document.
If the user has indicated a preference that this object element's fallback
content be shown instead of the element's usual behavior, then jump to the step below
labeled fallback.
For example, a user could ask for the element's fallback content to
be shown because that content uses a format that the user finds more accessible.
If the classid attribute is present, and has a
value that isn't the empty string, then: if the user agent can find a plugin
suitable according to the value of the classid
attribute, and either plugins aren't being sandboxed or that
plugin can be secured, then that
pluginshould be used, and the value of the data attribute, if any, should be passed to the
plugin. If no suitable plugin can be found, or if the
plugin reports an error, jump to the step below labeled fallback.
If the data attribute is present and its value is
not the empty string, then:
If the type attribute is present and its value is
not a type that the user agent supports, and is not a type that the user agent can find a
plugin for, then the user agent may jump to the step below labeled fallback
without fetching the content to examine its real type.
Resolve the URL specified by the data attribute, relative to the element.
If that failed, fire a simple event named error at the element, then jump to the step below labeled
fallback.
For the purposes of the application cache networking model, this
fetch operation is not for a child browsing context (though it might
end up being used for one after all, as defined below).
If the resource is not yet available (e.g. because the resource was not available in the
cache, so that loading the resource required making a request over the network), then jump to
the step below labeled fallback. The task that is
queued by the networking task source once the
resource is available must restart this algorithm from this step. Resources can load
incrementally; user agents may opt to consider a resource "available" whenever enough data has
been obtained to begin processing the resource.
If the load failed (e.g. there was an HTTP 404 error, there was a DNS error), fire
a simple event named error at the element, then jump to
the step below labeled fallback.
If the object element has a typemustmatch attribute, jump to the step below
labeled handler.
If the user agent is configured to strictly obey Content-Type headers for this resource,
and the resource has associated Content-Type metadata,
then let the resource type be the type specified in the resource's Content-Type metadata, and jump to the step below
labeled handler.
This can introduce a vulnerability, wherein a site is trying to embed a
resource that uses a particular plugin, but the remote site overrides that and instead
furnishes the user agent with a resource that triggers a different plugin with different
security characteristics.
If there is a type attribute present on the
object element, and that attribute's value is not a type that the user agent
supports, but it is a type that a plugin supports, then let the resource type be the type specified in that type attribute, and jump to the step below labeled
handler.
Run the appropriate set of steps from the following
list:
If binary is false, then let the resource
type be the type specified in the resource's
Content-Type metadata, and jump to the step below labeled handler.
If there is a type attribute present on the
object element, and its value is not application/octet-stream,
then run the following steps:
If the attribute's value is a type that a plugin supports, or the
attribute's value is a type that starts with "image/" that is not also an
XML MIME type, then let the resource type be the type
specified in that type attribute.
If tentative type is notapplication/octet-stream, then let resource type be
tentative type and jump to the step below labeled
handler.
If applying the URL parser algorithm to the URL of the
specified resource (after any redirects) results in a parsed URL whose path component matches a pattern that a plugin
supports, then let resource type be the type that that plugin can
handle.
For example, a plugin might say that it can handle resources with path components that end with the four character string
".swf".
It is possible for this step to finish, or for one of the substeps above to
jump straight to the next step, with resource type still being unknown. In
both cases, the next step will trigger fallback.
Handler: Handle the content as given by the first of the following cases that
matches:
If the resource type is not a type that the user agent supports, but
it is a type that a plugin supports
If the data attribute is absent but the type attribute is present, and the user agent can find a
plugin suitable according to the value of the type attribute, and either plugins aren't being sandboxed or the plugin can be
secured, then that pluginshould be used. If these conditions cannot be met, or if the
plugin reports an error, jump to the step below labeled fallback. Otherwise
abort these steps; once the plugin is completely loaded, queue a task to fire
a simple event named load at the element.
Fallback: The object element represents the element's
children, ignoring any leading param element children. This is the element's
fallback content. If the element has an instantiated plugin, then
unload it.
When the algorithm above instantiates a plugin, the user agent
should pass to the plugin used the names and values of all the attributes on the
element, in the order they were added to the element, with the attributes added by the parser
being ordered in source order, followed by a parameter named "PARAM" whose value is null, followed
by all the names and values of parameters given by
param elements that are children of the object element, in tree
order. If the plugin supports a scriptable interface, the
HTMLObjectElement object representing the element should expose that interface. The
object element represents the plugin. The
plugin is not a nested browsing context.
Due to the algorithm above, the contents of object elements act as fallback
content, used only when referenced resources can't be shown (e.g. because it returned a 404
error). This allows multiple object elements to be nested inside each other,
targeting multiple user agents with different capabilities, with the user agent picking the first
one it supports.
The IDL attributes data, type and name each must reflect the respective
content attributes of the same name. The typeMustMatch IDL attribute must
reflect the typemustmatch content
attribute. The useMap IDL attribute must
reflect the usemap content attribute.
The contentWindow IDL attribute must
return the WindowProxy object of the object element's nested
browsing context, if it has one; otherwise, it must return null.
All object elements have a legacy caller
operation. If the object element has an instantiated plugin that
supports a scriptable interface that defines a legacy caller operation, then that must be the
behavior of the object's legacy caller operation. Otherwise, the object's legacy caller operation
must be to throw a NotSupportedError exception.
<figure>
<object type="application/x-java-applet">
<param name="code" value="MyJavaClass">
<p>You do not have Java available, or it is disabled.</p>
</object>
<figcaption>My Java Clock</figcaption>
</figure>
If both attributes are present, and if the parent element of the param is an
object element, then the element defines a parameter with the given name-value pair.
If either the name or value of a parameter defined
by a param element that is the child of an object element that
represents an instantiated plugin changes, and if that
plugin is communicating with the user agent using an API that features the ability to
update the plugin when the name or value of a parameter so changes, then the user agent must
appropriately exercise that ability to notify the plugin of the change.
The IDL attributes name and value must both reflect the respective
content attributes of the same name.
<!DOCTYPE HTML>
<html lang="en">
<head>
<title>O3D Utah Teapot</title>
</head>
<body>
<p>
<object type="application/vnd.o3d.auto">
<param name="o3d_features" value="FloatingPointTextures">
<img src="o3d-teapot.png"
title="3D Utah Teapot illustration rendered using O3D."
alt="When O3D renders the Utah Teapot, it appears as a squat
teapot with a shiny metallic finish on which the
surroundings are reflected, with a faint shadow caused by
the lighting.">
<p>To see the teapot actually rendered by O3D on your
computer, please download and install the <a
href="http://code.google.com/apis/o3d/docs/gettingstarted.html#install">O3D plugin</a>.</p>
</object>
<script src="o3d-teapot.js"></script>
</p>
</body>
</html>
Content may be provided inside the video element. User agents
should not show this content to the user; it is intended for older Web browsers which do
not support video, so that legacy video plugins can be tried, or to show text to the
users of these older browsers informing them of how to access the video contents.
If the specified resource is to be used, then, when the element is created or when the poster attribute is set, changed, or removed, the user agent must
run the following steps to determine the element's poster frame (regardless of the
value of the element's show poster flag):
If there is an existing instance of this algorithm running for this video
element, abort that instance of this algorithm without changing the poster
frame.
If the poster attribute's value is the empty string
or if the attribute is absent, then there is no poster frame; abort these
steps.
Resolve the poster attribute's value relative to the element. If this fails,
then there is no poster frame; abort these steps.
A video element represents what is given for the first matching condition in the
list below:
When no video data is available (the element's readyState attribute is either HAVE_NOTHING, or HAVE_METADATA but no video data has yet been obtained at
all, or the element's readyState attribute is any
subsequent value but the media resource does not have a video channel)
The video element represents its poster frame, if any,
or else transparent black with no intrinsic dimensions.
When the video element is paused, and the
frame of video corresponding to the current playback
position is not available (e.g. because the video is seeking or buffering)
In addition to the above, the user agent may provide messages to the user (such as "buffering",
"no video loaded", "error", or more detailed information) by overlaying text or icons on the video
or other areas of the element's playback area, or in another appropriate manner.
User agents that cannot render the video may instead make the element represent a link to an external video playback utility or to the video
data itself.
The intrinsic width and intrinsic height of the media resource
are the dimensions of the resource in CSS pixels after taking into account the resource's
dimensions, aspect ratio, clean aperture, resolution, and so forth, as defined for the format used
by the resource. If an anamorphic format does not define how to apply the aspect ratio to the
video data's dimensions to obtain the "correct" dimensions, then the user agent must apply the
ratio by increasing one dimension and leaving the other unchanged.
The videoWidth IDL attribute must return
the intrinsic width of the video in CSS pixels.
The videoHeight IDL attribute must return
the intrinsic height of the video in CSS
pixels. If the element's readyState attribute is HAVE_NOTHING, then the attributes must return 0.
In the absence of style rules to the contrary, video content should be rendered inside the
element's playback area such that the video content is shown centered in the playback area at the
largest possible size that fits completely within it, with the video content's aspect ratio being
preserved. Thus, if the aspect ratio of the playback area does not match the aspect ratio of the
video, the video will be shown letterboxed or pillarboxed. Areas of the element's playback area
that do not contain the video represent nothing.
The intrinsic width of a video element's playback area is the intrinsic width of
the poster frame, if that is available and the element currently
represents its poster frame; otherwise, it is the intrinsic width of the video resource, if that is
available; otherwise the intrinsic width is missing.
The intrinsic height of a video element's playback area is the intrinsic height of
the poster frame, if that is available and the element currently
represents its poster frame; otherwise it is the intrinsic height of the video resource, if that is
available; otherwise the intrinsic height is missing.
User agents should provide controls to enable or disable the display of closed captions, audio
description tracks, and other additional data associated with the video stream, though such
features should, again, not interfere with the page's normal rendering.
User agents may allow users to view the video content in manners more suitable to the user
(e.g. full-screen or in an independent resizable window). As for the other user interface
features, controls to enable this should not interfere with the page's normal rendering unless the
user agent is exposing a user interface.
In such an independent context, however, user agents may make full user interfaces visible, with,
e.g., play, pause, seeking, and volume controls, even if the controls attribute is absent.
User agents may allow video playback to affect system features that could interfere with the
user's experience; for example, user agents could disable screensavers while video playback is in
progress.
The poster IDL attribute must
reflect the poster content attribute.
この例は、ビデオを正常に再生するために障害が発生したことを検出する様子を示す：
<script>
function failed(e) {
// video playback failed - show a message saying why
switch (e.target.error.code) {
case e.target.error.MEDIA_ERR_ABORTED:
alert('You aborted the video playback.');
break;
case e.target.error.MEDIA_ERR_NETWORK:
alert('A network error caused the video download to fail part-way.');
break;
case e.target.error.MEDIA_ERR_DECODE:
alert('The video playback was aborted due to a corruption problem or because the video used features your browser did not support.');
break;
case e.target.error.MEDIA_ERR_SRC_NOT_SUPPORTED:
alert('The video could not be loaded, either because the server or network failed or because the format is not supported.');
break;
default:
alert('An unknown error occurred.');
break;
}
}
</script>
<p><video src="tgif.vid" autoplay controls onerror="failed(event)"></video></p>
<p><a href="tgif.vid">Download the video file</a>.</p>
Content may be provided inside the audio element. User agents
should not show this content to the user; it is intended for older Web browsers which do
not support audio, so that legacy audio plugins can be tried, or to show text to the
users of these older browsers informing them of how to access the audio contents.
A constructor is provided for creating HTMLAudioElement objects (in addition to
the factory methods from DOM such as createElement()): Audio(src). When invoked as a
constructor, it must return a new HTMLAudioElement object (a new audio
element). The element must be created with its preload
attribute set to the literal value "auto". If the
src argument is present, the object created must be created with its src content attribute set to the provided value (this will cause the user agent to invoke the object's
resource selection algorithm before returning).
The element's document must be the active document of the browsing
context of the Window object on which the interface object of the invoked
constructor is found.
If the element has a src attribute whose value is not the
empty string and whose value, when the attribute was set, could be successfully resolved relative to the element, then the element's track
URL is the resulting absolute URL. Otherwise, the element's track
URL is the empty string.
If the element has a srclang attribute whose value is
not the empty string, then the element's track language is the value of the attribute.
Otherwise, the element has no track language.
If the element has a label attribute whose value is not
the empty string, then the element's track label is the value of the attribute.
Otherwise, the element's track label is an empty string.
The readyState attribute must return the
numeric value corresponding to the text track readiness state of the
track element's text track, as defined by the following list:
The track IDL attribute must, on getting,
return the track element's text track's corresponding
TextTrack object.
The src, srclang, label, and default IDL attributes must reflect the
respective content attributes of the same name. The kind IDL attribute must reflect the content
attribute of the same name, limited to only known values.
このビデオは、複数言語の字幕を持つ：
<video src="brave.webm">
<track kind=subtitles src=brave.en.vtt srclang=en label="English">
<track kind=captions src=brave.en.hoh.vtt srclang=en label="English for the Hard of Hearing">
<track kind=subtitles src=brave.fr.vtt srclang=fr lang=fr label="Français">
<track kind=subtitles src=brave.de.vtt srclang=de lang=de label="Deutsch">
</video>
Except where otherwise explicitly specified, the task source for all the tasks
queued in this section and its subsections is the media
element event task source of the media element in question.
All media elements have an associated error status, which
records the last error the element encountered since its resource selection algorithm was last invoked. The
error attribute, on getting, must return the
MediaError object created for this last error, or null if there has not been an
error.
ここでパラメータなしのMIMEタイプ "application/octet-stream"は特殊な場合である。任意のパラメータが型に出現する場合、その型は他のMIMEタイプと同じように扱われるだろう。This is a deviation from the rule that unknown MIME type parameters should be ignored.
The canPlayType(type) method must return the
empty string if type is a type that the user agent knows it cannot
render or is the type "application/octet-stream"; it must return "probably" if the user agent is confident
that the type represents a media resource that it can render if used in with this
audio or video element; and it must return "maybe" otherwise. Implementors are encouraged
to return "maybe" unless the type can be
confidently established as being supported or not. Generally, a user agent should never return
"probably" for a type that allows the codecs parameter if that parameter is not present.
<section id="video">
<p><a href="playing-cats.nfv">Download video</a></p>
</section>
<script>
var videoSection = document.getElementById('video');
var videoElement = document.createElement('video');
var support = videoElement.canPlayType('video/x-new-fictional-format;codecs="kittens,bunnies"');
if (support != "probably" && "New Fictional Video Plugin" in navigator.plugins) {
// not confident of browser support
// but we have a plugin
// so use plugin instead
videoElement = document.createElement("embed");
} else if (support == "") {
// no support from browser and no plugin
// do nothing
videoElement = null;
}
if (videoElement) {
while (videoSection.hasChildNodes())
videoSection.removeChild(videoSection.firstChild);
videoElement.setAttribute("src", "playing-cats.nfv");
videoSection.appendChild(videoElement);
}
</script>
As media elements interact with the network, their current
network activity is represented by the networkState attribute. On getting, it must
return the current network state of the element, which must be one of the following values:
The resource selection algorithm defined
below describes exactly when the networkState
attribute changes value and what events fire to indicate changes in this state.
All media elements have an autoplaying flag,
which must begin in the true state, and a delaying-the-load-event flag, which must
begin in the false state. While the delaying-the-load-event flag is true, the element
must delay the load event of its document.
Playback of any previously playing media resource for this element
stops.
The resource selection algorithm for a
media element is as follows. This algorithm is always invoked synchronously, but one
of the first steps in the algorithm is to return and continue running the remaining steps
asynchronously, meaning that it runs in the background with scripts and other tasks running in parallel. In addition, this algorithm interacts
closely with the event loop mechanism; in particular, it has synchronous sections (which are triggered as part of the event loop
algorithm). Steps in such sections are marked with ⌛.
⌛ If the media element has a src
attribute, then let mode be attribute.
⌛ Otherwise, if the media element does not have a src attribute but has a source element child, then
let mode be children and let candidate
be the first such source element child in tree order.
⌛ If the src
attribute's value is the empty string, then end the synchronous section, and jump
down to the failed with attribute step below.
⌛ Let absolute URL be the absolute URL that
would have resulted from resolving the URL
specified by the src attribute's value relative to the
media element when the src attribute was last
changed.
⌛ If absolute URL was obtained successfully, set the currentSrc attribute to absolute
URL.
If absolute URL was obtained successfully, run the resource fetch algorithm with absolute
URL. If that algorithm returns without aborting this one, then the load
failed.
Failed with attribute: Reaching this step indicates that the media resource
failed to load or that the given URL could not be resolved. Queue a task to run the following steps:
Wait for the task queued by the previous step to have
executed.
Abort these steps. Until the load() method is
invoked or the src attribute is changed, the element won't
attempt to load another resource.
Otherwise, the source elements will be used; run these substeps:
⌛ Let pointer be a position defined by two adjacent nodes in the
media element's child list, treating the start of the list (before the first
child in the list, if any) and end of the list (after the last child in the list, if any) as
nodes in their own right. One node is the node before pointer, and the
other node is the node after pointer. Initially, let pointer be the position between the candidate node and the
next node, if there are any, or the end of the list, if it is the last node.
As nodes are inserted and removed into the media element, pointer must be updated as follows:
If a new node is inserted between the two nodes that define pointer
Let pointer be the point between the node before pointer and the new node. In other words, insertions at pointer go after pointer.
If the node before pointer is removed
Let pointer be the point between the node after pointer and the node before the node after pointer. In
other words, pointer doesn't move relative to the remaining nodes.
If the node after pointer is removed
Let pointer be the point between the node before pointer and the node after the node before pointer. Just
as with the previous case, pointer doesn't move relative to the remaining
nodes.
Other changes don't affect pointer.
⌛ Process candidate: If candidate does not have a
src attribute, or if its src attribute's value is the empty string, then end the
synchronous section, and jump down to the failed with elements step
below.
⌛ Let absolute URL be the absolute URL that
would have resulted from resolving the URL
specified by candidate's src
attribute's value relative to the candidate when the src attribute was last changed.
⌛ If absolute URL was not obtained successfully, then end the
synchronous section, and jump down to the failed with elements step
below.
⌛ Search loop: If the node after pointer is
the end of the list, then jump to the waiting step below.
⌛ If the node after pointer is a source element,
let candidate be that element.
⌛ Advance pointer so that the node before pointer is now the node that was after pointer, and the node
after pointer is the node after the node that used to be after pointer, if any.
⌛ If candidate is null, jump back to the search
loop step. Otherwise, jump back to the process candidate step.
Optionally, run the following substeps. This is the expected behavior if the user agent
intends to not attempt to fetch the resource until the user requests it explicitly (e.g. as a way
to implement the preload attribute's none keyword).
The resource obtained in this fashion, if any, contains the media data. It can
be CORS-same-origin or CORS-cross-origin; this affects whether
subtitles referenced in the media data are exposed in the API and, for
video elements, whether a canvas gets tainted when the video is drawn
on it.
While the load is not suspended (see below), every 350ms (±200ms) or for every byte
received, whichever is least frequent, queue a task to fire a simple
event named progress at the element.
The stall timeout is a user-agent defined length of time, which should be about
three seconds. When a media element that is actively attempting to obtain
media data has failed to receive any data for a duration equal to the stall
timeout, the user agent must queue a task to fire a simple
event named stalled at the element.
User agents may allow users to selectively block or slow media data downloads.
When a media element's download has been blocked altogether, the user agent must
act as if it was stalled (as opposed to acting as if the connection was closed). The rate of the
download may also be throttled automatically by the user agent, e.g. to balance the download
with other connections sharing the same bandwidth.
User agents may decide to not download more content at any time, e.g.
after buffering five minutes of a one hour media resource, while waiting for the user to decide
whether to play the resource or not, while waiting for user input in an interactive resource, or
when the user navigates away from the page. When a media element's download has
been suspended, the user agent must queue a task, to set the networkState to NETWORK_IDLE and fire a simple event named
suspend at the element. If and when downloading of the
resource resumes, the user agent must queue a task to set the networkState to NETWORK_LOADING. Between the queuing of these tasks,
the load is suspended (so progress events don't fire,
as described above).
The preload attribute provides a hint
regarding how much buffering the author thinks is advisable, even in the absence of the autoplay attribute.
When a user agent decides to completely stall a download, e.g. if it is waiting until the
user starts playback before downloading any further content, the user agent must queue a
task to set the element's delaying-the-load-event flag to false. This stops
delaying the load event.
The user agent may use whatever means necessary to fetch the resource (within the constraints
put forward by this and other specifications); for example, reconnecting to the server in the
face of network errors, using HTTP range retrieval requests, or switching to a streaming
protocol. The user agent must consider a resource erroneous only if it has given up trying to
fetch it.
This specification does not currently say whether or how to check the MIME
types of the media resources, or whether or how to perform file type sniffing using the actual
file data. Implementors differ in their intentions on this matter and it is therefore unclear
what the right solution is. In the absence of any requirement here, the HTTP specification's
strict requirement to follow the Content-Type header prevails ("Content-Type specifies the media
type of the underlying data." ... "If and only if the media type is not given by a Content-Type
field, the recipient MAY attempt to guess the media type via inspection of its content
and./or the name extension(s) of the URI used to identify the resource.").
If the media data cannot be fetched at all, due to network errors, causing the
user agent to give up trying to fetch the resource
If the media data can be fetched but is found by inspection to be in an
unsupported format, or can otherwise not be rendered at all
DNS errors, HTTP 4xx and 5xx errors (and equivalents in other protocols), and other fatal
network errors that occur before the user agent has established whether the current media resource is usable, as well as the file using an unsupported
container format, or using unsupported codecs for all the data, must cause the user agent to
execute the following steps:
The user agent should cancel the fetching process.
If either the media resource or the address of the current
media resource indicate a particular set of audio tracks to enable, or if the user
agent has information that would facilitate the selection of specific audio tracks to
improve the user's experience, then: if this audio track is one of the ones to enable, then
set enable to true, otherwise, set enable
to false.
This could be triggered by Media Fragments URI fragment
identifier syntax, but it could also be triggered e.g. by the user agent selecting a 5.1
surround sound audio track over a stereo audio track. [MEDIAFRAG]
If enable is still unknown, then, if the media
element does not yet have an enabled audio track, then set enable
to true, otherwise, set enable to false.
If enable is true, then enable this audio track,
otherwise, do not enable this audio track.
If either the media resource or the address of the current
media resource indicate a particular set of video tracks to enable, or if the user
agent has information that would facilitate the selection of specific video tracks to
improve the user's experience, then: if this video track is the first such video track, then
set enable to true, otherwise, set enable
to false.
This could again be triggered by Media Fragments URI
fragment identifier syntax.
If enable is still unknown, then, if the media
element does not yet have a selected video track, then set enable
to true, otherwise, set enable to false.
If enable is true, then select this track and unselect any
previously selected video tracks, otherwise, do not select this video track. If other tracks
are unselected, then a change event will be fired.
Update the timeline offset to the date and time that corresponds to the zero
time in the media timeline established in the previous step, if any. If no
explicit time and date is given by the media resource, the timeline
offset must be set to Not-a-Number (NaN).
Update the duration attribute with the time of
the last frame of the resource, if known, on the media timeline established
above. If it is not known (e.g. a stream that is in principle infinite), update the duration attribute to the value positive Infinity.
If either the media resource or the address of the current
media resource indicate a particular start time, then set the initial playback
position to that time and, if jumped is still false, seek to that time and let jumped be
true.
For example, with media formats that support the Media Fragments
URI fragment identifier syntax, the fragment identifier can be used to indicate a
start position. [MEDIAFRAG]
A user agent that is attempting to reduce network usage while still fetching
the metadata for each media resource would also stop buffering at this point,
following the rules described previously, which involve the
networkState attribute switching to the NETWORK_IDLE value and a suspend event firing.
The user agent is required to determine the duration of the
media resource and go through this step before playing.
Once the entire media resource has been fetched
(but potentially before any of it has been decoded)
If the user agent can keep the media resource loaded, then the
algorithm will continue to its final step below, which aborts the algorithm.
If the connection is interrupted after some media data has been received,
causing the user agent to give up trying to fetch the resource
Fatal network errors that occur after the user agent has established whether the current media resource is usable (i.e. once the media element's
readyState attribute is no longer HAVE_NOTHING) must cause the user agent to execute the
following steps:
The user agent should cancel the fetching process.
Fatal errors in decoding the media data that occur after the user agent has
established whether the current media resource is usable must cause the
user agent to execute the following steps:
The user agent should cancel the fetching process.
If the media data fetching process is aborted by the user
The fetching process is aborted by the user, e.g. because the user
pressed a "stop" button, the user agent must execute the following steps. These steps are not
followed if the load() method itself is invoked while
these steps are running, as the steps above handle that particular kind of abort.
The user agent should cancel the fetching process.
If the media data can be fetched but has non-fatal
errors or uses, in part, codecs that are unsupported, preventing the user agent from rendering
the content completely correctly but not preventing playback altogether
The server returning data that is partially usable but cannot be optimally rendered must
cause the user agent to render just the bits it can handle, and ignore the rest.
Cross-origin videos do not expose their subtitles, since that would allow
attacks such as hostile sites reading subtitles from confidential videos on a user's
intranet.
When the networking task source has queued the
last task as part of fetching the
media resource (i.e. once the download has completed), if the fetching process
completes without errors, including decoding the media data, and if all of the data is available
to the user agent without network access, then, the user agent must move on to the next step.
This might never happen, e.g. when streaming an infinite resource such as Web radio, or if the
resource is longer than the user agent's ability to cache data.
While the user agent might still need network access to obtain parts of the media
resource, the user agent must remain on this step.
For example, if the user agent has discarded the first half of a video, the
user agent will remain at this step even once the playback has
ended, because there is always the chance the user will seek back to the start. In fact,
in this situation, once playback has ended, the user agent
will end up firing a suspend event, as described
earlier.
If the user agent ever reaches this step (which can only happen if the entire resource
gets loaded and kept available): abort the overall resource selection algorithm.
The preload attribute is intended to provide a hint to
the user agent about what the author thinks will lead to the best user experience. The attribute
may be ignored altogether, for example based on explicit user preferences or based on the
available connectivity.
The buffered attribute must return a new
static normalised TimeRanges object that represents the ranges of the
media resource, if any, that the user agent has buffered, at the time the attribute
is evaluated. Users agents must accurately determine the ranges available, even for media streams
where this can only be determined by tedious inspection.
Typically this will be a single range anchored at the zero point, but if, e.g. the
user agent uses HTTP range requests in response to seeking, then there could be multiple
ranges.
User agents may discard previously buffered data.
Thus, a time position included within a range of the objects return by the buffered attribute at one time can end up being not included in
the range(s) of objects returned by the same attribute at later times.
A media resource has a media timeline that maps times (in seconds) to
positions in the media resource. The origin of a timeline is its earliest defined
position. The duration of a timeline is its last defined position.
Establishing the media
timeline: If the media resource somehow specifies an explicit timeline whose
origin is not negative (i.e. gives each frame a specific time offset and gives the first frame a
zero or positive offset), then the media timeline should be that timeline. (Whether
the media resource can specify a timeline or not depends on the media resource's format.) If the media resource specifies an
explicit start time and date, then that time and date should be considered the zero point
in the media timeline; the timeline offset will be the time and date,
exposed using the getStartDate() method.
If the media resource has a discontinuous timeline, the user agent must extend the
timeline used at the start of the resource across the entire resource, so that the media
timeline of the media resource increases linearly starting from the
earliest possible position (as defined below), even if the underlying media
data has out-of-order or even overlapping time codes.
For example, if two clips have been concatenated into one video file, but the
video format exposes the original times for the two clips, the video data might expose a timeline
that goes, say, 00:15..00:29 and then 00:05..00:38. However, the user agent would not expose those
times; it would instead expose the times as 00:15..00:29 and 00:29..01:02, as a single video.
In the rare case of a media resource that does not have an explicit timeline, the
zero time on the media timeline should correspond to the first frame of the
media resource. In the even rarer case of a media resource with no
explicit timings of any kind, not even frame durations, the user agent must itself determine the
time for each frame in a user-agent-defined manner.
An example of a file format with no explicit timeline but with explicit frame
durations is the Animated GIF format. An example of a file format with no explicit timings at all
is the JPEG-push format (multipart/x-mixed-replace with JPEG frames, often
used as the format for MJPEG streams).
If, in the case of a resource with no timing information, the user agent will nonetheless be
able to seek to an earlier point than the first frame originally provided by the server, then the
zero time should correspond to the earliest seekable time of the media resource;
otherwise, it should correspond to the first frame received from the server (the point in the
media resource at which the user agent began receiving the stream).
At the time of writing, there is no known format that lacks explicit frame time
offsets yet still supports seeking to a frame before the first frame sent by the server.
Consider a stream from a TV broadcaster, which begins streaming on a sunny Friday afternoon in
October, and always sends connecting user agents the media data on the same media timeline, with
its zero time set to the start of this stream. Months later, user agents connecting to this
stream will find that the first frame they receive has a time with millions of seconds. The getStartDate() method would always return the date that the
broadcast started; this would allow controllers to display real times in their scrubber (e.g.
"2:30pm") rather than a time relative to when the broadcast began ("8 months, 4 hours, 12
minutes, and 23 seconds").
Consider a stream that carries a video with several concatenated fragments, broadcast by a
server that does not allow user agents to request specific times but instead just streams the
video data in a predetermined order, with the first frame delivered always being identified as
the frame with time zero. If a user agent connects to this stream and receives fragments defined
as covering timestamps 2010-03-20 23:15:00 UTC to 2010-03-21 00:05:00 UTC and 2010-02-12 14:25:00
UTC to 2010-02-12 14:35:00 UTC, it would expose this with a media timeline starting
at 0s and extending to 3,600s (one hour). Assuming the streaming server disconnected at the end
of the second clip, the duration attribute would then
return 3,600. The getStartDate() method would return a
Date object with a time corresponding to 2010-03-20 23:15:00 UTC. However, if a
different user agent connected five minutes later, it would (presumably) receive
fragments covering timestamps 2010-03-20 23:20:00 UTC to 2010-03-21 00:05:00 UTC and 2010-02-12
14:25:00 UTC to 2010-02-12 14:35:00 UTC, and would expose this with a media timeline
starting at 0s and extending to 3,300s (fifty five minutes). In this case, the getStartDate() method would return a Date object
with a time corresponding to 2010-03-20 23:20:00 UTC.
In both of these examples, the seekable attribute
would give the ranges that the controller would want to actually display in its UI; typically, if
the servers don't support seeking to arbitrary times, this would be the range of time from the
moment the user agent connected to the stream up to the latest frame that the user agent has
obtained; however, if the user agent starts discarding earlier information, the actual range
might be shorter.
In any case, the user agent must ensure that the earliest possible position (as
defined below) using the established media timeline, is greater than or equal to
zero.
The media timeline also has an associated clock. Which clock is used is user-agent
defined, and may be media resource-dependent, but it should approximate the user's
wall clock.
Media elements also have a default playback start
position, which must initially be set to zero seconds. This time is used to allow the
element to be seeked even before the media is loaded.
Each media element has a show poster flag. When a media
element is created, this flag must be set to true. This flag is used to control when the
user agent is to show a poster frame for a video element instead of showing the video
contents.
If the media resource is a streaming resource, then the user agent might be unable
to obtain certain parts of the resource after it has expired from its buffer. Similarly, some
media resources might have a media timeline that
doesn't start at zero. The earliest possible position is the earliest position in the
stream or resource that the user agent can ever obtain again. It is also a time on the media
timeline.
The duration attribute must return the time
of the end of the media resource, in seconds, on the media timeline. If
no media data is available, then the attributes must return the Not-a-Number (NaN)
value. If the media resource is not known to be bounded (e.g. streaming radio, or a
live event with no announced end time), then the attribute must return the positive Infinity
value.
The user agent must determine the duration of the media resource before playing
any part of the media data and before setting readyState to a value equal to or greater than HAVE_METADATA, even if doing so requires fetching multiple
parts of the resource.
When the length of the media resource changes to a known value
(e.g. from being unknown to known, or from a previously established length to a new length) the
user agent must queue a task to fire a simple event named durationchange at the media element. (The
event is not fired when the duration is reset as part of loading a new media resource.) If the
duration is changed such that the current playback position ends up being greater
than the time of the end of the media resource, then the user agent must also seek to the time of the end of the media resource.
If an "infinite" stream ends for some reason, then the duration would change
from positive Infinity to the time of the last frame or sample in the stream, and the durationchange event would be fired. Similarly, if the
user agent initially estimated the media resource's duration instead of determining
it precisely, and later revises the estimate based on new information, then the duration would
change and the durationchange event would be
fired.
Some video files also have an explicit date and time corresponding to the zero time in the
media timeline, known as the timeline offset. Initially, the
timeline offset must be set to Not-a-Number (NaN).
Media elements have a ready state, which describes to
what degree they are ready to be rendered at the current playback position. The
possible values are as follows; the ready state of a media element at any particular time is the
greatest value describing the state of the element:
User agents do not need to support autoplay, and it is suggested that user
agents honor user preferences on the matter. Authors are urged to use the autoplay attribute rather than using script to force the
video to play, so as to allow the user to override the behavior if so desired.
The readyState IDL attribute must, on
getting, return the value described above that describes the current ready state of the
media element.
autoplay属性は真偽属性である。When present, the user agent (as described in the algorithm described herein) will automatically begin playback of the media resource as soon as it can do so without stopping.
The word "reaches" here does not imply that the current playback
position needs to have changed during normal playback; it could be via seeking, for instance.
The defaultPlaybackRate attribute
gives the desired speed at which the media resource is to play, as a multiple of its
intrinsic speed. The attribute is mutable: on getting it must return the last value it was set to,
or 1.0 if it hasn't yet been set; on setting the attribute must be set to the new value.
The playbackRate attribute gives the
effective playback rate (assuming there is no current media controller
overriding it), which is the speed at which the media resource plays, as a multiple
of its intrinsic speed. If it is not equal to the defaultPlaybackRate, then the implication is that the
user is using a feature such as fast forward or slow motion playback. The attribute is mutable: on
getting it must return the last value it was set to, or 1.0 if it hasn't yet been set; on setting
the attribute must be set to the new value, and the playback will change speed (if the element is
potentially playing and there is no current media controller).
This specification doesn't define how the user agent achieves the appropriate
playback rate — depending on the protocol and media available, it is plausible that the user
agent could negotiate with the server to have the server provide the media data at the appropriate
rate, so that (except for the period between when the rate is changed and when the server updates
the stream's playback rate) the client doesn't actually have to drop or interpolate any
frames.
While the direction of playback is backwards, any corresponding audio must be
muted. While the effective playback rate is
so low or so high that the user agent cannot play audio usefully, the corresponding audio must
also be muted. If the effective playback
rate is not 1.0, the user agent may apply pitch adjustments to the audio as necessary to
render it faithfully.
Media elements that are potentially playing
while not in a Document must not play any video, but should play any
audio component. Media elements must not stop playing just because all references to them have
been removed; only once a media element is in a state where no further audio could ever be played
by that element may the element be garbage collected.
It is possible for an element to which no explicit references exist to play audio,
even if such an element is not still actively playing: for instance, it could have a current
media controller that still has references and can still be unpaused, or it could be
unpaused but stalled waiting for content to buffer.
When the current playback position of a media element changes (e.g.
due to playback or seeking), the user agent must run the time marches on steps. If the
current playback position changes while the steps are running, then the user agent
must wait for the steps to complete, and then must immediately rerun the steps. (These steps are
thus run as often as possible or needed — if one iteration takes a long time, this can cause
certain cues to be skipped over as the user agent rushes ahead
to "catch up".)
Let last time be the current playback position at the
time this algorithm was last run for this media element, if this is not the first
time it has run.
If the current playback position has, since the last time this algorithm was
run, only changed through its usual monotonic increase during normal playback, then let missed cues be the list of cues in other cues whose start times are
greater than or equal to last time and whose end times are less than or equal to the current playback position.
Otherwise, let missed cues be an empty list.
If the time was reached through the usual monotonic increase of the current playback
position during normal playback, and if the user agent has not fired a timeupdate event at the element in the past 15 to 250ms and
is not still running event handlers for such an event, then the user agent must queue a
task to fire a simple event named timeupdate at the element. (In the other cases, such as
explicit seeks, relevant events get fired as part of the overall process of changing the
current playback position.)
The event thus is not to be fired faster than about 66Hz or slower than 4Hz
(assuming the event handlers don't take longer than 250ms to run). User agents are encouraged to
vary the frequency of the event based on the system load and the average cost of processing the
event each time, so that the UI updates are not any more frequent than the user agent can
comfortably handle while decoding the video.
In the other cases, such as explicit seeks, playback is not paused by going past
the end time of a cue, even if that cue has its text track cue pause-on-exit flag set.
Let events be a list of tasks,
initially empty. Each task in this list will be associated
with a text track, a text track cue, and a time, which are used to
sort the list before the tasks are queued.
Let affected tracks be a list of text
tracks, initially empty.
When the steps below say to prepare an event named event for a
text track cuetarget with a time time, the
user agent must run these substeps:
Finally, sort tasks in events that have
the same time and same text track cue order by placing tasks that fire enter events before
those that fire exit events.
The seeking attribute must initially have the
value false.
The fastSeek() method must seek to the time given by the method's argument, with the
approximate-for-speed flag set.
When the user agent is required to seek to a particular new playback position in the media resource, optionally with the
approximate-for-speed flag set, it means that the user agent must run the following steps.
This algorithm interacts closely with the event loop mechanism; in particular, it has
a synchronous section (which is triggered as part of the event loop
algorithm). Steps in that section are marked with ⌛.
If the element's seeking IDL attribute is true,
then another instance of this algorithm is already running. Abort that other instance of the
algorithm without waiting for the step that it is running to complete.
If the seek was in response to a DOM method call or setting of an IDL attribute, then
continue the script. The remainder of these steps must be run asynchronously. With the exception
of the steps marked with ⌛, they could be aborted at any time by another instance of this
algorithm being invoked.
If the new playback position is later than the end of the media
resource, then let it be the end of the media resource instead.
If the new playback position is less than the earliest possible
position, let it be that position instead.
If the (possibly now changed) new playback position is not in one of
the ranges given in the seekable attribute, then let it
be the position in one of the ranges given in the seekable attribute that is the nearest to the new
playback position. If two positions both satisfy that constraint (i.e. the new playback position is exactly in the middle between two ranges in the seekable attribute) then use the position that is closest to
the current playback position. If there are no ranges given in the seekable attribute then set the seeking IDL attribute to false and abort these steps.
If the approximate-for-speed flag is set, adjust the new playback
position to a value that will allow for playback to resume promptly. If new
playback position before this step is before current playback position, then
the adjusted new playback position must also be before the current
playback position. Similarly, if the new playback position before
this step is after current playback position, then the adjusted new
playback position must also be after the current playback position.
For example, the user agent could snap to the nearest key frame, so that it
doesn't have to spend time decoding then discarding intermediate frames before resuming
playback.
This step sets the current playback position, and thus can
immediately trigger other conditions, such as the rules regarding when playback "reaches the end of the media resource" (part of the logic that
handles looping), even before the user agent is actually able to render the media data for that
position (as determined in the next step).
Wait until the user agent has established whether or not the media data for
the new playback position is available, and, if it is, until it has decoded
enough data to play back that position.
The seekable attribute must return a new
static normalised TimeRanges object that represents the ranges of the
media resource, if any, that the user agent is able to seek to, at the time the
attribute is evaluated.
If the user agent can seek to anywhere in the media resource, e.g.
because it is a simple movie file and the user agent and the server support HTTP Range requests,
then the attribute would return an object with one range, whose start is the time of the first
frame (the earliest possible position, typically zero), and whose end is the same as
the time of the first frame plus the duration attribute's
value (which would equal the time of the last frame, and might be positive Infinity).
The range might be continuously changing, e.g. if the user agent is buffering a
sliding window on an infinite stream. This is the behavior seen with DVRs viewing live TV, for
instance.
An AudioTrackList object represents a dynamic list of zero or more audio tracks,
of which zero or more can be enabled at a time. Each audio track is represented by an
AudioTrack object.
A VideoTrackList object represents a dynamic list of zero or more video tracks, of
which zero or one can be selected at a time. Each video track is represented by a
VideoTrack object.
Tracks in AudioTrackList and VideoTrackList objects must be
consistently ordered. If the media resource is in a format that defines an order,
then that order must be used; otherwise, the order must be the relative order in which the tracks
are declared in the media resource. The order used is called the natural order
of the list.
Each track in a TrackList thus has an index; the first has the index
0, and each subsequent track is numbered one higher than the previous one. If a media
resource dynamically adds or removes audio or video tracks, then the indices of the tracks
will change dynamically. If the media resource changes entirely, then all the
previous tracks will be removed and replaced with new tracks.
The AudioTrackList.length and VideoTrackList.length attributes must return
the number of tracks represented by their objects at the time of getting.
The AudioTrackList.getTrackById(id) and VideoTrackList.getTrackById(id) methods must return the first AudioTrack or
VideoTrack object (respectively) in the AudioTrackList or
VideoTrackList object (respectively) whose identifier is equal to the value of the
id argument (in the natural order of the list, as defined above). When no
tracks match the given argument, the methods must return null.
The AudioTrack and VideoTrack objects represent specific tracks of a
media resource. Each track can have an identifier, category, label, and language.
These aspects of a track are permanent for the lifetime of the track; even if a track is removed
from a media resource's AudioTrackList or VideoTrackList
objects, those aspects do not change.
In addition, AudioTrack objects can each be enabled or disabled; this is the audio
track's enabled state. When an AudioTrack is created, its enabled state
must be set to false (disabled). The resource fetch
algorithm can override this.
Similarly, a single VideoTrack object per VideoTrackList object can
be selected, this is the video track's selection state. When a VideoTrack is
created, its selection state must be set to false (not selected). The resource fetch algorithm can override this.
The AudioTrack.id and VideoTrack.id attributes must return the identifier
of the track, if it has one, or the empty string otherwise. If the media resource is
in a format that supports the Media Fragments URI fragment identifier syntax, the
identifier returned for a particular track must be the same identifier that would enable the track
if used as the name of a track in the track dimension of such a fragment identifier. [MEDIAFRAG]
For example, in Ogg files, this would be the Name header field of the track. [OGGSKELETONHEADERS]
The AudioTrack.kind and VideoTrack.kind attributes must return the category
of the track, if it has one, or the empty string otherwise.
The category of a track is the string given in the first column of the table below that is the
most appropriate for the track based on the definitions in the table's second and third columns,
as determined by the metadata included in the track in the media resource. The cell
in the third column of a row says what the category given in the cell in the first column of that
row applies to; a category is only appropriate for an audio track if it applies to audio tracks,
and a category is only appropriate for video tracks if it applies to video tracks. Categories must
only be returned for AudioTrack objects if they are appropriate for audio, and must
only be returned for VideoTrack objects if they are appropriate for video.
The AudioTrack.label and VideoTrack.label attributes must return the label
of the track, if it has one, or the empty string otherwise.
The AudioTrack.language and VideoTrack.language attributes must return the
BCP 47 language tag of the language of the track, if it has one, or the empty string otherwise. If
the user agent is not able to express that language as a BCP 47 language tag (for example because
the language information in the media resource's format is a free-form string without
a defined interpretation), then the method must return the empty string, as if the track had no
language.
Source attribute values for id, kind, label and language of multitrack audio and video tracks as
described for the relevant media resource format. [INBANDTRACKS]
The AudioTrack.enabled attribute, on
getting, must return true if the track is currently enabled, and false otherwise. On setting, it
must enable the track if the new value is true, and disable it otherwise. (If the track is no
longer in an AudioTrackList object, then the track being enabled or disabled has no
effect beyond changing the value of the attribute on the AudioTrack object.)
The VideoTrackList.selectedIndex attribute
must return the index of the currently selected track, if any. If the VideoTrackList
object does not currently represent any tracks, or if none of the tracks are selected, it must
instead return −1.
The VideoTrack.selected attribute, on
getting, must return true if the track is currently selected, and false otherwise. On setting, it
must select the track if the new value is true, and unselect it otherwise. If the track is in a
VideoTrackList, then all the other VideoTrack objects in that list must
be unselected. (If the track is no longer in a VideoTrackList object, then the track
being selected or unselected has no effect beyond changing the value of the attribute on the
VideoTrack object.)
The controller attribute on a media
element, on getting, must return the element's current media controller, if
any, or null otherwise. On setting, the user agent must run the following steps:
The MediaController() constructor, when
invoked, must return a newly created MediaController object.
The readyState attribute must
return the value to which it was most recently set. When the MediaController object
is created, the attribute must be set to the value 0 (HAVE_NOTHING). The value is updated by the report the
controller state algorithm below.
The buffered attribute must return
a new static normalised TimeRanges object that represents the
intersection of the ranges of the media resources of the
slaved media elements that the user agent has buffered, at the time the attribute is
evaluated. Users agents must accurately determine the ranges available, even for media streams
where this can only be determined by tedious inspection.
When a MediaController is created it is a playing media controller. It
can be changed into a paused media controller and back either via the user agent's user
interface (when the element is exposing a user
interface to the user) or by script using the APIs defined in this section (see below).
The playbackState attribute
must return the value to which it was most recently set. When the MediaController
object is created, the attribute must be set to the value "waiting". The value is updated by the report the
controller state algorithm below.
A MediaController has a media controller default playback rate and a
media controller playback rate, which must both be set to 1.0 when the
MediaController object is created.
A MediaController has a media controller volume multiplier, which must
be set to 1.0 when the MediaController object is created, and a media controller
mute override, much must initially be false.
In some situations, e.g. when playing back a live stream without buffering
anything, the media controller position would increase monotonically as described
above at the same rate as the ΔT described in the previous paragraph
decreases it, with the end result that for all intents and purposes, the media controller
position would appear to remain constant (probably with the value 0).
A MediaController has a most recently reported readiness state, which
is a number from 0 to 4 derived from the numbers used for the media elementreadyState attribute, and a most recently reported
playback state, which is either playing, waiting, or ended.
Set the MediaController's playbackState attribute to the value given in
the second column of the row of the following table whose first column contains the new playback state.
Fire a simple event at the MediaController object, whose name
is the value given in the third column of the row of the following table whose first column
contains the new playback state.
Rules for processing and rendering such data are defined by the relevant specifications, e.g.
the specification of the video format if the media resource is a video.
When a media resource contains data that the user agent recognises and supports as
being equivalent to a text track, the user agent runs the steps to expose a
media-resource-specific text track with the relevant data, as follows.
Set the new text track's kind, label, and language
based on the semantics of the relevant data, as defined for the relevant format [INBANDTRACKS]. If there is no label in that data, then the label must be set to the empty string.
Let stream type be the value of the "stream_type" field describing the
text track's type in the file's program map section, interpreted as an 8-bit unsigned integer.
Let length be the value of the "ES_info_length" field for the track in the
same part of the program map section, interpreted as an integer as defined by the MPEG-2
specification. Let descriptor bytes be the length bytes
following the "ES_info_length" field. The text track in-band metadata track dispatch
type must be set to the concatenation of the stream type byte and
the zero or more descriptor bytes bytes, expressed in hexadecimal using
uppercase ASCII hex digits. [MPEG2]
Let the
first stsd box of the
first stbl box of the
first minf box of the
first mdia box of the
text track's trak box in the
first moov box
of the file be the stsd box, if any.
If the file has no stsd box, or if the stsd box has neither a mett box nor a metx box, then the text track
in-band metadata track dispatch type must be set to the empty string.
Otherwise, if the stsd box has a mett box then the text
track in-band metadata track dispatch type must be set to the concatenation of the
string "mett", a U+0020 SPACE character, and the value of the first mime_format field of the first mett box of the stsd
box, or the empty string if that field is absent in that box.
Otherwise, if the stsd box has no mett box but has a metx box then the text track in-band metadata track dispatch type
must be set to the concatenation of the string "metx", a U+0020 SPACE
character, and the value of the first namespace field of the first metx box of the stsd box, or the empty string if that field is absent in
that box.
[MPEG4]
Set the new text track's mode to the
mode consistent with the user's preferences and the requirements of the relevant specification
for the data.
For instance, if there are no other active subtitles, and this is a forced
subtitle track (a subtitle track giving subtitles in the audio track's primary language, but
only for audio that is actually in another language), then those subtitles might be activated
here.
When a track element is created, it must be associated with a new text
track (with its value set as defined below) and its corresponding new
TextTrack object.
The text track kind is determined from the state of the element's kind attribute according to the following table; for a state given
in a cell of the first column, the kind is the string given
in the second column:
When the user agent is required to honor user preferences for automatic text track
selection for a media element, the user agent must run the following steps:
For example, the user could have set a browser preference to the effect of "I
want French captions whenever possible", or "If there is a subtitle track with 'Commentary' in
the title, enable it", or "If there are audio description tracks available, enable one, ideally
in Swiss German, but failing that in Standard Swiss German or Standard German".
The track element's parent element changes and the new parent is a media
element.
When a user agent is to start the track processing model for a
text track and its track element, it must run the following algorithm.
This algorithm interacts closely with the event loop mechanism; in particular, it has
a synchronous section (which is triggered as part of the event loop
algorithm). The steps in that section are marked with ⌛.
If another occurrence of this algorithm is already running for this text
track and its track element, abort these steps, letting that other algorithm
take care of this element.
If URL is not the empty string, perform a potentially CORS-enabled
fetch of URL, with the mode being CORS mode, the origin being the origin of the
track element's Document, and the default origin behaviour set
to fail.
The resource obtained in this fashion, if any, contains the text track data. If any data is
obtained, it is by definition CORS-same-origin (cross-origin resources that are not
suitably CORS-enabled do not get this far).
The tasksqueued by the
fetching algorithm on the networking task source to
process the data as it is being fetched must determine the type of the resource If the
type of the resource is not a supported text track format, the load will fail, as
described below. Otherwise, the resource's data must be passed to the appropriate parser (e.g.
the WebVTT parser) as it is received, with the text track list of cues being used for
that parser's output. [WEBVTT]
The appropriate parser will synchronously (during these networking task
sourcetasks) and incrementally (as each such task is
run with whatever data has been received from the network) update the text track list of
cues.
This specification does not currently say whether or how to check the MIME
types of text tracks, or whether or how to perform file type sniffing using the actual file
data. Implementors differ in their intentions on this matter and it is therefore unclear what
the right solution is. In the absence of any requirement here, the HTTP specification's strict
requirement to follow the Content-Type header prevails ("Content-Type specifies the media type
of the underlying data." ... "If and only if the media type is not given by a Content-Type
field, the recipient MAY attempt to guess the media type via inspection of its content
and./or the name extension(s) of the URI used to identify the resource.").
If the fetching algorithm does not fail, but the
type of the resource is not a supported text track format, or the file was not successfully
processed (e.g. the format in question is an XML format and the file contained a well-formedness
error that the XML specification requires be detected and reported to the application), then the
task that is queued by the
networking task source in which the aforementioned problem is found must change the
text track readiness state to failed to
load and fire a simple event named error
at the track element.
Whenever a track element has its src attribute
set, changed, or removed, the user agent must synchronously empty the element's text
track's text track list of cues. (This also causes the algorithm above to stop
adding cues from the resource being obtained using the previously given URL, if any.)
4.7.14.12.4 Guidelines for exposing cues in various formats as text track cues
How a specific format's text track cues are to be interpreted for the purposes of processing by
an HTML user agent is defined by that format [INBANDTRACKS]. In the
absence of such a specification, this section provides some constraints within which implementations can
attempt to consistently expose such formats.
To support the text track model of HTML, each unit of timed data is converted to a
text track cue. Where the mapping of the format's features to the aspects of a
text track cue as defined in this specification are not defined, implementations must
ensure that the mapping is consistent with the definitions of the aspects of a text track
cue as defined above, as well as with the following constraints:
The getTrackById(id) method must return the first TextTrack in the
TextTrackList object whose id IDL attribute
would return a value equal to the value of the id argument. When no tracks
match the given argument, the method must return null.
The id attribute returns the track's
identifier, if it has one, or the empty string otherwise. For tracks that correspond to
track elements, the track's identifier is the value of the element's id attribute, if any. For in-band tracks, the track's identifier is
specified by the media resource. If the media resource is in a format
that supports the Media Fragments URI fragment identifier syntax, the identifier
returned for a particular track must be the same identifier that would enable the track if used as
the name of a track in the track dimension of such a fragment identifier. [MEDIAFRAG]
The mode attribute, on getting, must return
the string corresponding to the text track mode of the text track that
the TextTrack object represents, as defined by the following list:
var sfx = new Audio('sfx.wav');
var sounds = sfx.addTextTrack('metadata');
// add sounds we care about
function addFX(start, end, name) {
var cue = new VTTCue(start, end, '');
cue.id = name;
cue.pauseOnExit = true;
sounds.addCue(cue);
}
addFX(12.783, 13.612, 'dog bark');
addFX(13.612, 15.091, 'kitten mew'))
function playSound(id) {
sfx.currentTime = sounds.getCueById(id).startTime;
sfx.play();
}
// play a bark as soon as we can
sfx.oncanplaythrough = function () {
playSound('dog bark');
}
// meow when the user tries to leave
window.onbeforeunload = function () {
playSound('kitten mew');
return 'Are you sure you want to leave this awesome page?';
}
The getCueById(id) method, when called with an argument other than the empty string,
must return the first text track cue in the list represented by the
TextTrackCueList object whose text track cue identifier is id, if any, or null otherwise. If the argument is the empty string, then the method
must return null.
The data attribute, on getting, must
return the raw text track cue data of the text track cue that the
TextTrackCue object represents. On setting, the text track cue data must
be set to the new value.
The rules for constructing the chapter tree from a text track are as follows. They
produce a potentially nested list of chapters, each of which have a start time, end time, title,
and a list of nested chapters. This algorithm discards cues that do not correctly nest within each
other, or that are out of order.
Let output be an empty list of chapters, where a chapter is a record
consisting of a start time, an end time, a title, and a (potentially empty) list of nested
chapters. For the purpose of this algorithm, each chapter also has a parent chapter.
Let current chapter be a stand-in chapter whose start time is negative
infinity, whose end time is positive infinity, and whose list of nested chapters is output. (This is just used to make the algorithm easier to describe.)
Loop: If list is empty, jump to the step labeled
end.
Let current cue be the first cue in list, and then
remove it from list.
If current cue's text track cue start time is less than
the start time of current chapter, then return to the step labeled
loop.
While current cue's text track cue start time is greater
than or equal to current chapter's end time, let current
chapter be current chapter's parent chapter.
If current cue's text track cue end time is greater than
the end time of current chapter, then return to the step labeled
loop.
If the attribute is present, or if scripting is
disabled for the media element, then the user agent should expose a user
interface to the user. This user interface should include features to begin playback, pause
playback, seek to an arbitrary position in the content (if the content supports arbitrary
seeking), change the volume, change the display of closed captions or embedded sign-language
tracks, select different audio tracks or turn on audio descriptions, and show the media content in
manners more suitable to the user (e.g. full-screen video or in an independent resizable window).
Other controls may also be made available.
If the media element has a current media controller, then the user
agent should expose audio tracks from all the slaved media elements (although
avoiding duplicates if the same media resource is being used several times). If a
media resource's audio track exposed in this way has no known name, and it is the
only audio track for a particular media element, the user agent should use the
element's title attribute, if any, as the name (or as part of the
name) of that track.
Even when the attribute is absent, however, user agents may provide controls to affect playback
of the media resource (e.g. play, pause, seeking, and volume controls), but such features should
not interfere with the page's normal rendering. For example, such features could be exposed in the
media element's context menu. The user agent may implement this simply by exposing a user interface to the user as
described above (as if the controls attribute was
present).
If the user agent exposes a user interface to
the user by displaying controls over the media element, then the user agent
should suppress any user interaction events while the user agent is interacting with this
interface. (For example, if the user clicks on a video's playback control, mousedown events and so forth would not simultaneously be fired at
elements on the page.)
Where possible (specifically, for starting, stopping, pausing, and unpausing playback, for
seeking, for changing the rate of playback, for fast-forwarding or rewinding, for listing,
enabling, and disabling text tracks, and for muting or changing the volume of the audio), user
interface features exposed by the user agent must be implemented in terms of the DOM API described
above, so that, e.g., all the same events fire.
The "play" function in the user agent's interface must set the playbackRate attribute to the value of the defaultPlaybackRate attribute before invoking the play()
method. When a media element has a current media controller, the
attributes and method with those names on that MediaController object must be used.
Otherwise, the attributes and method with those names on the media element itself
must be used.
Features such as fast-forward or rewind must be implemented by only changing the playbackRate attribute (and not the defaultPlaybackRate
attribute). Again, when a media element has a current media controller,
the attributes with those names on that MediaController object must be used;
otherwise, the attributes with those names on the media element itself must be used.
When a media element has a current media controller, seeking must be
implemented in terms of the currentTime
attribute on that MediaController object. Otherwise, the user agent must directly
seek to the requested position in the media
element's media timeline. For media resources where seeking to an arbitrary
position would be slow, user agents are encouraged to use the approximate-for-speed flag
when seeking in response to the user manipulating an approximate position interface such as a seek
bar.
When a media element has a current media controller, user agents may
additionally provide the user with controls that directly manipulate an individual media
element without affecting the MediaController, but such features are
considered relatively advanced and unlikely to be useful to most users.
A media element has a playback volume, which is a fraction in the range 0.0 (silent) to 1.0 (loudest).
Initially, the volume should be 1.0, but user agents may remember the last set value across
sessions, on a per-site basis or otherwise, so the volume may start at other values.
The volume IDL attribute must return the
playback volume of any audio portions of the
media element. On setting, if the new value is in the range 0.0 to 1.0 inclusive, the
media element's playback volume must be
set to the new value. If the new value is outside the range 0.0 to 1.0 inclusive, then, on
setting, an IndexSizeError exception must be thrown instead.
A media element can also be muted. If
anything is muting the element, then it is muted. (For example, when the direction of
playback is backwards, the element is muted.)
The muted IDL attribute must return the value
to which it was last set. When a media element is created, if the element has a muted content attribute specified, then the muted IDL attribute should be set to true; otherwise, the user
agents may set the value to the user's preferred value (e.g. remembering the last set value across
sessions, on a per-site basis or otherwise). While the muted
IDL attribute is set to true, the media element must be muted.
An element's effective media volume is determined as follows:
If the user has indicated that the user agent is to override the volume of the element,
then the element's effective media volume is the volume desired by the user. Abort
these steps.
The element's effective media volume is volume,
interpreted relative to the range 0.0 to 1.0, with 0.0 being silent, and 1.0 being the loudest
setting, values in between increasing in loudness. The range need not be linear. The loudest
setting may be lower than the system's loudest possible setting; for example the user could have
set a maximum volume.
The length IDL attribute must return the
number of ranges represented by the object.
The start(index)
method must return the position of the start of the indexth range represented
by the object, in seconds measured from the start of the timeline that the object covers.
The end(index) method
must return the position of the end of the indexth range represented by the
object, in seconds measured from the start of the timeline that the object covers.
These methods must throw IndexSizeError exceptions if called with an index argument greater than or equal to the number of ranges represented by the
object.
When a TimeRanges object is said to be a normalised TimeRanges
object, the ranges it represents must obey the following criteria:
The start of a range must be greater than the end of all earlier ranges.
The start of a range must be less than the end of that same range.
In other words, the ranges in such an object are ordered, don't overlap, aren't empty, and
don't touch (adjacent ranges are folded into one bigger range).
Thus, the end of a range would be equal to the start of a following adjacent
(touching but not overlapping) range. Similarly, a range covering a whole timeline anchored at
zero would have a start equal to zero and an end equal to the duration of the timeline.
The track attribute must return the value it was initialised to. オブジェクトが作成される際、この属性はnullに初期化しなければならない。It represents the context information for the event.
The main security and privacy implications of the video and audio
elements come from the ability to embed media cross-origin. There are two directions that threats
can flow: from hostile content to a victim page, and from a hostile page to victim content.
If a victim page embeds hostile content, the threat is that the content might contain scripted
code that attempts to interact with the Document that embeds the content. To avoid
this, user agents must ensure that there is no access from the content to the embedding page. In
the case of media content that uses DOM concepts, the embedded content must be treated as if it
was in its own unrelated top-level browsing context.
For instance, if an SVG animation was embedded in a video element,
the user agent would not give it access to the DOM of the outer page. From the perspective of
scripts in the SVG resource, the SVG file would appear to be in a lone top-level browsing context
with no parent.
If a hostile page embeds victim content, the threat is that the embedding page could obtain
information from the content that it would not otherwise have access to. The API does expose some
information: the existence of the media, its type, its duration, its size, and the performance
characteristics of its host. Such information is already potentially problematic, but in practice
the same information can more or less be obtained using the img element, and so it
has been deemed acceptable.
However, significantly more sensitive information could be obtained if the user agent further
exposes metadata within the content such as subtitles or chapter titles. Such information is
therefore only exposed if the video resource passes a CORS resource sharing check.
The crossorigin attribute allows authors to control
how this check is performed. [FETCH]
Without this restriction, an attacker could trick a user running within a
corporate network into visiting a site that attempts to load a video from a previously leaked
location on the corporation's intranet. If such a video included confidential plans for a new
product, then being able to read the subtitles would present a serious confidentiality breach.
4.7.14.18 Best practices for authors using media elements
4.7.14.19 Best practices for implementors of media elements
この節は非規範的である。
How accurately various aspects of the media element API are implemented is
considered a quality-of-implementation issue.
For example, when implementing the buffered attribute,
how precise an implementation reports the ranges that have been buffered depends on how carefully
the user agent inspects the data. Since the API reports ranges as times, but the data is obtained
in byte streams, a user agent receiving a variable-bit-rate stream might only be able to determine
precise times by actually decoding all of the data. User agents aren't required to do this,
however; they can instead return estimates (e.g. based on the average bit rate seen so far) which
get revised as more information becomes available.
As a general rule, user agents are urged to be conservative rather than optimistic. For
example, it would be bad to report that everything had been buffered when it had not.
Another quality-of-implementation issue would be playing a video backwards when the codec is
designed only for forward playback (e.g. there aren't many key frames, and they are far apart, and
the intervening frames only have deltas from the previous frame). User agents could do a poor job,
e.g. only showing key frames; however, better implementations would do more work and thus do a
better job, e.g. actually decoding parts of the video forwards, storing the complete frames, and
then playing the frames backwards.
Similarly, while implementations are allowed to drop buffered data at any time (there is no
requirement that a user agent keep all the media data obtained for the lifetime of the media
element), it is again a quality of implementation issue: user agents with sufficient resources to
keep all the data around are encouraged to do so, as this allows for a better user experience. For
example, if the user is watching a live stream, a user agent could allow the user only to view the
live video; however, a better user agent would buffer everything and allow the user to seek
through the earlier material, pause it, play it forwards and backwards, etc.
When multiple tracks are synchronised with a MediaController, it is possible for
scripts to add and remove media elements from the MediaController's list of
slaved media elements, even while these tracks are playing. How smoothly the media
plays back in such situations is another quality-of-implementation issue.
When a media element that is paused is removed from a document and not reinserted before the next time the event
loop reaches step 1, implementations that are resource constrained are encouraged to take
that opportunity to release all hardware resources (like video planes, networking resources, and
data buffers) used by the media element. (User agents still have to keep track of the
playback position and so forth, though, in case playback is later restarted.)
The areas attribute must return an
HTMLCollection rooted at the map element, whose filter matches only
area elements.
The images attribute must return an
HTMLCollection rooted at the Document node, whose filter matches only
img and object elements that are associated with this map
element according to the image map processing model.
The IDL attribute name must reflect
the content attribute of the same name.
shape属性は、列挙属性である。以下の表は、この属性に対して定義されたキーワードを列挙する。キーワードとともにその行の最初のセルに与えられた状態は、これらキーワードが対応する状態を与える。Some of the keywords are non-conforming, as noted in the last column.
coords属性が指定される場合、整数の妥当なリストを含まなければならない。この属性は、shape属性によって記述された図形の座標を与える。The processing for this attribute is described as part of the image map processing model.
circle stateにおいて、area要素は、最後の整数は非負でなければならない、3つの整数とともに、存在するcoords属性を持たなければならない。最初の整数は画像の左端から円の中心までのCSSピクセル単位距離でなければならず、2番目の整数は画像の上端から円の中心までのCSSピクセル単位距離でなければならず、3番目の整数はCSSピクセル単位距離で円の半径でなければならない。
When user agents allow users to follow hyperlinks or
download hyperlinks created using the
area element, as described in the next section, the href, target,
download, and
attributes decide how the link is followed. The rel, hreflang, and type
attributes may be used to indicate to the user the likely nature of the target resource before the
user follows the link.
When the element is created, and whenever the element's href content attribute is set, changed, or removed, the user
agent must invoke the element's URLUtils interface's set the input algorithm with the value of the href content attribute, if any, or the empty string otherwise,
as the given value.
When the element's URLUtils interface invokes its update steps with a string value, the user
agent must set the element's href content attribute to
the string value.
<p>
Please select a shape:
<img src="shapes.png" usemap="#shapes"
alt="Four shapes are available: a red hollow box, a green circle, a blue triangle, and a yellow four-pointed star.">
<map name="shapes">
<area shape=rect coords="50,50,100,100"> <!-- the hole in the red box -->
<area shape=rect coords="25,25,125,125" href="red.html" alt="Red box.">
<area shape=circle coords="200,75,50" href="green.html" alt="Green circle.">
<area shape=poly coords="325,25,262,125,388,125" href="blue.html" alt="Blue triangle.">
<area shape=poly coords="450,25,435,60,400,75,435,90,450,125,465,90,500,75,465,60"
href="yellow.html" alt="Yellow star.">
</map>
</p>
4.7.17.2 Processing model
If an img element or an object element representing an image has a
usemap attribute specified, user agents must process it
as follows:
If that returned null, then abort these steps. The image is not associated with an image
map after all.
Otherwise, the user agent must collect all the area elements that are
descendants of the map. Let those be the areas.
Having obtained the list of area elements that form the image map (the areas), interactive user agents must process the list in one of two ways.
If the user agent intends to show the text that the img element represents, then
it must use the following steps.
In user agents that do not support images, or that have images disabled,
object elements cannot represent images, and thus this section never applies (the
fallback content is shown instead). The following steps therefore only apply to
img elements.
Remove all the area elements in areas that have no href attribute.
Remove all the area elements in areas that have no alt attribute, or whose alt
attribute's value is the empty string, if there is another area element in
areas with the same value in the href attribute and with a non-empty alt attribute.
Each remaining area element in areas represents a
hyperlink. Those hyperlinks should all be made available to the user in a manner
associated with the text of the img.
In this context, user agents may represent area and img elements
with no specified alt attributes, or whose alt
attributes are the empty string or some other non-visible text, in a user-agent-defined fashion
intended to indicate the lack of suitable author-provided text.
If the user agent intends to show the image and allow interaction with the image to select
hyperlinks, then the image must be associated with a set of layered shapes, taken from the
area elements in areas, in reverse tree order (so the last
specified area element in the map is the bottom-most shape, and
the first element in the map, in tree order, is the top-most shape).
Each area element in areas must be processed as follows to
obtain a shape to layer onto the image:
Find the state that the element's shape attribute
represents.
Use the rules for parsing a list of integers to parse the element's coords attribute, if it is present, and let the result be the
coords list. If the attribute is absent, let the coords
list be the empty list.
If the number of items in the coords list is less than the minimum number
given for the area element's current state, as per the following table, then the
shape is empty; abort these steps.
If the shape attribute represents the rectangle state, and the first number in the list is
numerically less than the third number in the list, then swap those two numbers around.
If the shape attribute represents the rectangle state, and the second number in the list is
numerically less than the fourth number in the list, then swap those two numbers around.
If the shape attribute represents the circle state, and the third number in the list is less than
or equal to zero, then the shape is empty; abort these steps.
Now, the shape represented by the element is the one described for the entry in the list
below corresponding to the state of the shape attribute:
Let x be the first number in coords, y be the second number, and r be the third number.
The shape is a circle whose center is x CSS pixels from the left edge
of the image and y CSS pixels from the top edge of the image, and whose
radius is r pixels.
Let xi be the (2i)th entry in coords, and yi be the (2i+1)th entry in coords (the first entry in coords being the one with index 0).
Let the coordinates be (xi, yi),
interpreted in CSS pixels measured from the top left of the image, for all integer values of
i from 0 to (N/2)-1, where N is the number of items in coords.
The shape is a polygon whose vertices are given by the coordinates, and
whose interior is established using the even-odd rule. [GRAPHICS]
Let x1 be the first number in coords, y1 be the second number, x2 be the third number, and y2 be the fourth number.
The shape is a rectangle whose top-left corner is given by the coordinate (x1, y1) and whose
bottom right corner is given by the coordinate (x2,
y2), those coordinates being interpreted as CSS pixels
from the top left corner of the image.
For historical reasons, the coordinates must be interpreted relative to the
displayed image after any stretching caused by the CSS 'width' and 'height' properties
(or, for non-CSS browsers, the image element's width and height attributes — CSS browsers map those attributes to the
aforementioned CSS properties).
Browser zoom features and transforms applied using CSS or SVG do not affect the
coordinates.
Pointing device interaction with an image associated with a set of layered shapes per the above
algorithm must result in the relevant user interaction events being first fired to the top-most
shape covering the point that the pointing device indicated, if any, or to the image element
itself, if there is no shape covering that point. User agents may also allow individual
area elements representing hyperlinks to be selected
and activated (e.g. using a keyboard).
Because a map element (and its area elements) can be
associated with multiple img and object elements, it is possible for an
area element to correspond to multiple focusable areas of the document.
Image maps are live; if the DOM is mutated, then the user agent must act as if it
had rerun the algorithms for image maps.
User agents must handle text other than inter-element whitespace found in MathML
elements whose content models do not allow straight text by pretending for the purposes of MathML
content models, layout, and rendering that that text is actually wrapped in an mtext element in the MathML namespace. (Such text is not, however,
conforming.)
User agents must act as if any MathML element whose contents does not match the element's
content model was replaced, for the purposes of MathML layout and rendering, by an merror element in the MathML namespace containing some appropriate
error message.
To enable authors to use MathML tools that only accept MathML in its XML form, interactive HTML
user agents are encouraged to provide a way to export any MathML fragment as an XML
namespace-well-formed XML fragment.
To enable authors to use SVG tools that only accept SVG in its XML form, interactive HTML user
agents are encouraged to provide a way to export any SVG fragment as an XML namespace-well-formed
XML fragment.
Author requirements: The width and height attributes on img,
iframe, embed, object, video, and, when their
type attribute is in the Image Button state, input elements may be
specified to give the dimensions of the visual content of the element (the width and height
respectively, relative to the nominal direction of the output medium), in CSS pixels. The
attributes, if specified, must have values that are valid
non-negative integers.
The width and height IDL attributes on the iframe,
embed, object, and video elements must reflect
the respective content attributes of the same name.
For iframe, embed, and object the IDL
attributes are DOMString; for video the IDL attributes are
unsigned long.
The corresponding IDL attributes for img and
input elements are defined in those respective elements'
sections, as they are slightly more specific to those elements' other behaviors.
ハイパーリンクを作成するa要素、area要素に、hreflang属性が指定されている場合、この属性はリンク先リソースの言語を表す。これは単なる助言である。値は、妥当なBCP 47言語タグでなければならない。[BCP47]User agents must not consider this attribute authoritative — upon fetching the resource, user agents must use only language information associated with the resource to determine its language, not metadata included in the link to the resource.
type属性が存在する場合、この属性はリンク先のリソースのMIMEタイプを表す。これは単なる助言である。値は妥当なMIMEタイプでなければならない。User agents must not consider the type attribute authoritative — upon fetching the resource, user agents must not use metadata included in the link to the resource to determine its type.
4.8.2 Following hyperlinks
When a user follows a hyperlink created by an element
subject, the user agent must run the following steps:
Let replace be false.
Let source be the browsing context that contains the
Document object with which subject in question is
associated.
If the user indicated a specific browsing context when following the hyperlink,
or if the user agent is configured to follow hyperlinks by navigating a particular browsing
context, then let target be that browsing context.
Otherwise, if resolving the URL failed, the
user agent may report the error to the user in a user-agent-specific manner, may queue a
task to navigate the targetbrowsing context to an error page to report the error, or may ignore the error and
do nothing. In any case, the user agent must then abort these steps.
In the case of server-side image maps, append the hyperlink suffix to URL.
When a user downloads a hyperlink created by an
element, the user agent must run the following steps:
Resolve the URL given by the href attribute of that element, relative to that
element.
If resolving the URL fails, the user agent
may report the error to the user in a user-agent-specific manner, may
navigate to an error page to report the error, or may
ignore the error and do nothing. In either case, the user agent must abort these steps.
When a user agent is to handle a resource obtained from a fetch algorithm as
a download, it should provide the user with a way to save the resource for later use, if a
resource is successfully obtained; or otherwise should report any problems downloading the file to
the user.
If the user agent needs a file name for a resource being handled as a download, it
should select one using the following algorithm.
This algorithm is intended to mitigate security dangers involved in downloading
files from untrusted sites, and user agents are strongly urged to follow it.
Let filename be the void value.
If the resource has a Content-Disposition
header, that header specifies the attachment disposition type, and the
header includes file name information, then let filename have the value
specified by the header, and jump to the step labeled sanitize below. [RFC6266]
Let interface origin be the origin of the
Document in which the download or
navigate action resulting in the download was initiated, if any.
Let resource origin be the origin of the URL of the
resource being downloaded, unless that URL's scheme
component is data, in which case let resource origin be
the same as the interface origin, if any.
If there is no interface origin, then let trusted
operation be true. Otherwise, let trusted operation be true if resource origin is the same origin as interface
origin, and false otherwise.
If trusted operation is true and the resource has a Content-Disposition header and that header includes file
name information, then let filename have the value specified by the header,
and jump to the step labeled sanitize below. [RFC6266]
If the download was not initiated from a hyperlink created by an
a or area element, or if the element of the hyperlink from
which it was initiated did not have a download
attribute when the download was initiated, or if there was such an attribute but its value when
the download was initiated was the empty string, then jump to the step labeled no proposed
file name.
Let proposed filename have the value of the download attribute of the element of the
hyperlink that initiated the download at the time the download was
initiated.
If trusted operation is true, let filename have
the value of proposed filename, and jump to the step labeled sanitize
below.
If the resource has a Content-Disposition
header and that header specifies the attachment disposition type, let filename have the value of proposed filename, and jump to the
step labeled sanitize below. [RFC6266]
No proposed file name: If trusted operation is true, or if the
user indicated a preference for having the resource in question downloaded, let filename have a value derived from the URL of the resource in a
user-agent-defined manner, and jump to the step labeled sanitize below.
Act in a user-agent-defined manner to safeguard the user from a potentially hostile
cross-origin download. If the download is not to be aborted, then let filename be set to the user's preferred file name or to a file name selected by
the user agent, and jump to the step labeled sanitize below.
If the algorithm reaches this step, then a download was begun from a different origin than
the resource being downloaded, and the origin did not mark the file as suitable for
downloading, and the download was not initiated by the user. This could be because a download attribute was used to trigger the download, or
because the resource in question is not of a type that the user agent supports.
This could be dangerous, because, for instance, a hostile server could be trying to get a
user to unknowingly download private information and then re-upload it to the hostile server,
by tricking the user into thinking the data is from the hostile server.
Thus, it is in the user's interests that the user be somehow notified that the resource in
question comes from quite a different source, and to prevent confusion, any suggested file name
from the potentially hostile interface origin should be ignored.
Sanitize: Optionally, allow the user to influence filename. For
example, a user agent could prompt the user for a file name, potentially providing the value of
filename as determined above as a default value.
Adjust filename to be suitable for the local file system.
For example, this could involve removing characters that are not legal in
file names, or trimming leading and trailing whitespace.
If the platform conventions do not in any way use extensions to determine the types of file on the file system,
then return filename as the file name and abort these steps.
Let claimed type be the type given by the resource's Content-Type metadata, if any is known. Let named
type be the type given by filename's extension, if any is known. For the purposes of this step, a
type is a mapping of a MIME type to an extension.
If named type is consistent with the user's preferences (e.g. because
the value of filename was determined by prompting the user), then return filename as the file name and abort these steps.
If claimed type and named type are the same type
(i.e. the type given by the resource's Content-Type metadata is
consistent with the type given by filename's extension), then return filename as the file
name and abort these steps.
If the claimed type is known, then alter filename to
add an extension corresponding to claimed
type.
Otherwise, if named type is known to be potentially dangerous (e.g. it
will be treated by the platform conventions as a native executable, shell script, HTML
application, or executable-macro-capable document) then optionally alter filename to add a known-safe extension
(e.g. ".txt").
This last step would make it impossible to download executables, which might not
be desirable. As always, implementors are forced to balance security and usability in this
matter.
Return filename as the file name.
For the purposes of this algorithm, a file extension
consists of any part of the file name that platform conventions dictate will be used for
identifying the type of the file. For example, many operating systems use the part of the file
name following the last dot (".") in the file name to determine the type of
the file, and from that the manner in which the file is to be opened or executed.
User agents should ignore any directory or path information provided by the resource itself,
its URL, and any download attribute, in
deciding where to store the resulting file in the user's file system.
To determine which link types apply to a link, a, or
area element, the element's rel attribute must be split on spaces. The resulting tokens are the link types
that apply to that element.
Some of the types described below list synonyms for these values. These are to be handled as specified by user agents, but must not be used
in documents.
The first link, a, or area element in the document (in
tree order) with the alternate keyword used with the type attribute set to the value application/rss+xml or the value application/atom+xml must
be treated as the default syndication feed for the purposes of feed autodiscovery.
The following link element gives the syndication
feed for the current page:
Synonyms: For historical reasons, user agents must also treat
link, a, and area elements that have a rev attribute with the value "made" as having the author keyword specified as a link relationship.
...
<body>
<h1>Example of permalinks</h1>
<div id="a">
<h2>First example</h2>
<p><a href="a.html" rel="bookmark">This permalink applies to
only the content from the first H2 to the second H2</a>. The DIV isn't
exactly that section, but it roughly corresponds to it.</p>
</div>
<h2>Second example</h2>
<article id="b">
<p><a href="b.html" rel="bookmark">This permalink applies to
the outer ARTICLE element</a> (which could be, e.g., a blog post).</p>
<article id="c">
<p><a href="c.html" rel="bookmark">This permalink applies to
the inner ARTICLE element</a> (which could be, e.g., a blog comment).</p>
</article>
</article>
</body>
...
The specified resource is an icon representing the page or site, and should be used by the user
agent when representing the page in the user interface.
アイコンは、聴覚アイコン、視覚アイコン、または他の種類のアイコンかもしれない。If multiple icons are provided, the user agent must select the most appropriate icon according to the type, media, and sizes attributes. If there are multiple equally appropriate icons, user agents must use the last one declared in tree order at the time that the user agent collected the list of icons. If the user agent tries to use an icon but that icon is determined, upon closer examination, to in fact be inappropriate (e.g. because it uses an unsupported format), then the user agent must try the next-most-appropriate icon as determined by the attributes.
User agents are not required to update icons when the list of icons changes, but
are encouraged to do so.
There is no default type for resources given by the icon keyword.
However, for the purposes of determining the type of the
resource, user agents must expect the resource to be an image.
存在する場合、この属性は、ASCII大文字・小文字不区別である一意なスペース区切りトークンの順不同の組である値を持たなければならない。値はそれぞれ、"any"に一致するASCII大文字・小文字不区別である文字列か、2つの妥当な非負整数からなる値のいずれかでなければならない。この数値は、先行する"0"（U+0030）文字を持たず、かつ1つのU+0078 LATIN SMALL LETTER XまたはU+0058 LATIN CAPITAL LETTER X文字により分離される。
To parse and process the attribute's value, the user agent must first split the attribute's value on spaces, and must then parse each resulting
keyword to determine what it represents.
Other keywords must be further parsed as follows to determine what they represent:
If the keyword doesn't contain exactly one U+0078 LATIN SMALL LETTER X or U+0058 LATIN
CAPITAL LETTER X character, then this keyword doesn't represent anything. Abort these steps for
that keyword.
Let width string be the string before the "x" or
"X".
Let height string be the string after the "x" or
"X".
If either width string or height string start with
a "0" (U+0030) character or contain any characters other than ASCII digits,
then this keyword doesn't represent anything. Abort these steps for that keyword.
In the absence of a link with the icon keyword, for
Documents obtained over HTTP or HTTPS, user agents may instead attempt to
fetch and use an icon with the absolute URL obtained by
resolving the URL "/favicon.ico" against the document's
address, as if the page had declared that icon using the icon
keyword.
If a user agent follows a link defined by an a or area element that
has the noreferrer keyword, the user agent must not include a
Referer (sic) HTTP header (or equivalent for other protocols) in the
request.
When the type attribute of the link
element of an external resource link that is already in a
Document but was previously not obtained due to the type attribute specifying an unsupported type is set, removed, or
changed.
Quirk: If the document has been set to quirks mode, has the
same origin as the URL of the external resource,
and the Content-Type metadata of the external resource is not a
supported style sheet type, the user agent must instead assume it to be text/css.
If element no longer creates an external resource link
that contributes to the styling processing model, or if, since the resource in question was obtained, it has become appropriate to obtain it again (meaning this algorithm is about to be
invoked again for a newly obtained resource), then abort these steps.
This is a reference to the (possibly absent at this time) attribute, rather
than a copy of the attribute's current value. The CSSOM specification defines what happens
when the attribute is dynamically set, changed, or removed.
If the element has a charset attribute, get an encoding from that attribute's value. If that
succeeds, return the resulting encoding and abort these steps. [ENCODING]
<!DOCTYPE HTML>
<html>
<head>
<title>My Precious</title>
</head>
<body>
<header><h1>My precious</h1> <p>Summer 2012</p></header>
<p>Recently I managed to dispose of a red gem that had been
bothering me. I now have a much nicer blue sapphire.</p>
<p>The red gem had been found in a bauxite stone while I was digging
out the office level, but nobody was willing to haul it away.
same red gem stayed there for literally years.</p>
<footer>
Tags: <a rel=tag href="http://en.wikipedia.org/wiki/Gemstone">Gemstone</a>
</footer>
</body>
</html>
<!DOCTYPE HTML>
<html>
<head>
<title>Gem 4/4</title>
</head>
<body>
<article>
<h1>801: Steinbock</h1>
<p>The number 801 Gem 4/4 electro-diesel has an ibex and was rebuilt in 2002.</p>
</article>
<article>
<h1>802: Murmeltier</h1>
<figure>
<img src="http://upload.wikimedia.org/wikipedia/commons/b/b0/Trains_de_la_Bernina_en_hiver_2.jpg"
alt="The 802 was red with pantographs and tall vents on the side.">
<figcaption>The 802 in the 1980s, above Lago Bianco.</figcaption>
</figure>
<p>The number 802 Gem 4/4 electro-diesel has a marmot and was rebuilt in 2003.</p>
</article>
<p class="topic"><a rel=tag href="http://en.wikipedia.org/wiki/Rhaetian_Railway_Gem_4/4">Gem 4/4</a></p>
</body>
</html>
Conformance checkers may use the information given on the microformats wiki existing-rel-values page to
establish if a value is allowed or not: values defined in this
specification or marked as "proposed" or "ratified" must be accepted
when used on the elements for which they apply as described in the
"Effect on..." field, whereas values marked as "discontinued" or
values not containing a U+003A COLON character but not listed in
either this specification or on the aforementioned page must be
reported as invalid. The remaining values must be accepted as valid
if they are absolute URLs containing US-ASCII characters only and
rejected otherwise. Conformance checkers may cache this
information (e.g. for performance reasons or to avoid the use of
unreliable network connectivity).
Note: Even URL-valued link types are compared
ASCII-case-insensitively. Validators might choose to warn about
characters U+0041 (LATIN CAPITAL LETTER A) through
U+005A (LATIN CAPITAL LETTER Z) (inclusive) in the pre-case-folded
form of link types that contain a colon.
When an author uses a new type not defined by either this specification or the Wiki page,
conformance checkers should offer to add the value to the Wiki, with the details described above,
with the "proposed" status.
The table element takes part in the table model. Tables have rows, columns, and cells given by their descendants. 行と列はグリッドを形成する。テーブルのセルは完全に重複することなく、グリッドをカバーしなければならない。
Precise rules for determining whether this conformance requirement is met are
described in the description of the table model.
Tables can be complicated to understand and navigate. To help
users with this, user agents should clearly delineate cells in a
table from each other, unless the user agent has classified the
table as a
layout table.
Authors and implementors
are encouraged to consider using some of the table design techniques
described below to make tables easier to navigate for users.
User agents, especially those that do table analysis on arbitrary
content, are encouraged to find heuristics to determine which tables
actually contain data and which are merely being used for layout.
This specification does not define a precise heuristic, but the
following are suggested as possible indicators:
Feature
Indication
The use of the role attribute with the value presentation
Probably a layout table
The use of the border attribute with the non-conforming value 0
Not a good indicator (both layout and non-layout tables have historically been given this attribute)
It is quite possible that the above suggestions are
wrong. Implementors are urged to provide feedback elaborating on
their experiences with trying to create a layout table detection
heuristic.
The caption IDL attribute must return, on
getting, the first caption element child of the table element, if any,
or null otherwise. On setting, the first caption element child of the
table element, if any, must be removed, and the new value, if not null, must be
inserted as the first node of the table element.
The createCaption() method must return
the first caption element child of the table element, if any; otherwise
a new caption element must be created, inserted as the first node of the
table element, and then returned.
The deleteCaption() method must remove
the first caption element child of the table element, if any.
The tHead IDL attribute must return, on
getting, the first thead element child of the table element, if any, or
null otherwise. On setting, if the new value is null or a thead element, the first
thead element child of the table element, if any, must be removed, and
the new value, if not null, must be inserted immediately before the first element in the
table element that is neither a caption element nor a
colgroup element, if any, or at the end of the table if there are no such elements.
If the new value is neither null nor a thead element, then a
HierarchyRequestError DOM exception must be thrown instead.
The createTHead() method must return the
first thead element child of the table element, if any; otherwise a new
thead element must be created and inserted immediately before the first element in
the table element that is neither a caption element nor a
colgroup element, if any, or at the end of the table if there are no such elements,
and then that new element must be returned.
The deleteTHead() method must remove the
first thead element child of the table element, if any.
The tFoot IDL attribute must return, on
getting, the first tfoot element child of the table element, if any, or
null otherwise. On setting, if the new value is null or a tfoot element, the first
tfoot element child of the table element, if any, must be removed, and
the new value, if not null, must be inserted immediately before the first element in the
table element that is neither a caption element, a colgroup
element, nor a thead element, if any, or at the end of the table if there are no such
elements. If the new value is neither null nor a tfoot element, then a
HierarchyRequestError DOM exception must be thrown instead.
The createTFoot() method must return the
first tfoot element child of the table element, if any; otherwise a new
tfoot element must be created and inserted immediately before the first element in
the table element that is neither a caption element, a
colgroup element, nor a thead element, if any, or at the end of the
table if there are no such elements, and then that new element must be returned.
The deleteTFoot() method must remove the
first tfoot element child of the table element, if any.
The tBodies attribute must return an
HTMLCollection rooted at the table node, whose filter matches only
tbody elements that are children of the table element.
The createTBody() method must create a
new tbody element, insert it immediately after the last tbody element
child in the table element, if any, or at the end of the table element
if the table element has no tbody element children, and then must return
the new tbody element.
The rows attribute must return an
HTMLCollection rooted at the table node, whose filter matches only
tr elements that are either children of the table element, or children
of thead, tbody, or tfoot elements that are themselves
children of the table element. The elements in the collection must be ordered such
that those elements whose parent is a thead are included first, in tree order,
followed by those elements whose parent is either a table or tbody
element, again in tree order, followed finally by those elements whose parent is a
tfoot element, still in tree order.
The behavior of the insertRow(index) method depends on the state of the table. When it is called,
the method must act as required by the first item in the following list of conditions that
describes the state of the table and the index argument:
If index is less than −1 or greater than the number of elements
in rows collection:
If the rows collection has zero elements in it, and the
table has no tbody elements in it:
The method must create a tbody element, then create a tr element,
then append the tr element to the tbody element, then append the
tbody element to the table element, and finally return the
tr element.
The method must create a tr element, append it to the last tbody
element in the table, and return the tr element.
If index is −1 or equal to the number of items in rows collection:
The method must create a tr element, and append it to the parent of the last
tr element in the rows collection. Then, the
newly created tr element must be returned.
Otherwise:
The method must create a tr element, insert it immediately before the indexth tr element in the rows
collection, in the same parent, and finally must return the newly created tr
element.
When the deleteRow(index) method is called, the user agent must run the following
steps:
If index is equal to −1, then index must be
set to the number of items in the rows collection, minus
one.
Now, if index is less than zero, or greater than or equal to the
number of elements in the rows collection, the method must
instead throw an IndexSizeError exception, and these steps must be aborted.
Otherwise, the method must remove the indexth element in the rows collection from its parent.
The border IDL
attribute must reflect the content attribute of the
same name.
<p id="summary">In the following table, characteristics are
given in the second column, with the negative side in the left column and the positive
side in the right column.</p>
<table aria-describedby="summary">
<caption>Characteristics with positive and negative sides</caption>
<thead>
<tr>
<th id="n"> Negative
<th> Characteristic
<th> Positive
<tbody>
<tr>
<td headers="n r1"> Sad
<th id="r1"> Mood
<td> Happy
<tr>
<td headers="n r2"> Failing
<th id="r2"> Grade
<td> Passing
</table>
<table>
<caption>
<strong>Characteristics with positive and negative sides.</strong>
<p>Characteristics are given in the second column, with the
negative side in the left column and the positive side in the right
column.</p>
</caption>
<thead>
<tr>
<th id="n"> Negative
<th> Characteristic
<th> Positive
<tbody>
<tr>
<td headers="n r1"> Sad
<th id="r1"> Mood
<td> Happy
<tr>
<td headers="n r2"> Failing
<th id="r2"> Grade
<td> Passing
</table>
<table>
<caption>
<strong>Characteristics with positive and negative sides.</strong>
<details>
<summary>Help</summary>
<p>Characteristics are given in the second column, with the
negative side in the left column and the positive side in the right
column.</p>
</details>
</caption>
<thead>
<tr>
<th id="n"> Negative
<th> Characteristic
<th> Positive
<tbody>
<tr>
<td headers="n r1"> Sad
<th id="r1"> Mood
<td> Happy
<tr>
<td headers="n r2"> Failing
<th id="r2"> Grade
<td> Passing
</table>
<figure>
<figcaption>Characteristics with positive and negative sides</figcaption>
<p>Characteristics are given in the second column, with the
negative side in the left column and the positive side in the right
column.</p>
<table>
<thead>
<tr>
<th id="n"> Negative
<th> Characteristic
<th> Positive
<tbody>
<tr>
<td headers="n r1"> Sad
<th id="r1"> Mood
<td> Happy
<tr>
<td headers="n r2"> Failing
<th id="r2"> Grade
<td> Passing
</table>
</figure>
<figure>
<figcaption>
<strong>Characteristics with positive and negative sides</strong>
<p>Characteristics are given in the second column, with the
negative side in the left column and the positive side in the right
column.</p>
</figcaption>
<table>
<thead>
<tr>
<th id="n"> Negative
<th> Characteristic
<th> Positive
<tbody>
<tr>
<td headers="n r1"> Sad
<th id="r1"> Mood
<td> Happy
<tr>
<td headers="n r2"> Failing
<th id="r2"> Grade
<td> Passing
</table>
</figure>
User agents are encouraged to render tables using these techniques whenever the page does not
use CSS and the table is not classified as a layout table.
<caption>
<p>Table 1.
<p>This table shows the total score obtained from rolling two
six-sided dice. The first row represents the value of the first die,
the first column the value of the second die. The total is given in
the cell that corresponds to the values of the two dice.
</caption>
以下は、より多くのコンテキストをユーザーに提供する：
Table 1.
This table shows the total score obtained from rolling two
six-sided dice. The first row represents the value of the first
die, the first column the value of the second die. The total is
given in the cell that corresponds to the values of the two dice.
The rows attribute must return an
HTMLCollection rooted at the element, whose filter matches only tr
elements that are children of the element.
The insertRow(index)
method must, when invoked on an element table section, act as follows:
If index is less than −1 or greater than the number of elements in
the rows collection, the method must throw an
IndexSizeError exception.
If index is −1 or equal to the number of items in the rows collection, the method must create a tr element,
append it to the element table section, and return the newly created
tr element.
Otherwise, the method must create a tr element, insert it as a child of the table section element, immediately before the indexth
tr element in the rows collection, and finally
must return the newly created tr element.
The deleteRow(index)
method must remove the indexth element in the rows collection from its parent. If index is
less than zero or greater than or equal to the number of elements in the rows collection, the method must instead throw an
IndexSizeError exception.
The rowIndex attribute must, if the element has
a parent table element, or a parent tbody, thead, or
tfoot element and a grandparenttable element, return the index
of the tr element in that table element's rows collection. If there is no such table element,
then the attribute must return −1.
The sectionRowIndex attribute must, if
the element has a parent table, tbody, thead, or
tfoot element, return the index of the tr element in the parent
element's rows collection (for tables, that's the HTMLTableElement.rows collection; for table sections, that's the
HTMLTableRowElement.rows collection). If there is no such
parent element, then the attribute must return −1.
The cells attribute must return an
HTMLCollection rooted at the tr element, whose filter matches only
td and th elements that are children of the tr element.
The insertCell(index)
method must act as follows:
If index is less than −1 or greater than the number of elements in
the cells collection, the method must throw an
IndexSizeError exception.
If index is equal to −1 or equal to the number of items in cells collection, the method must create a td element,
append it to the tr element, and return the newly created td
element.
Otherwise, the method must create a td element, insert it as a child of the
tr element, immediately before the indexth td or
th element in the cells collection, and finally
must return the newly created td element.
The deleteCell(index)
method must remove the indexth element in the cells collection from its parent. If index is less
than zero or greater than or equal to the number of elements in the cells collection, the method must instead throw an
IndexSizeError exception.
User agents, especially in non-visual environments or where displaying the table as a 2D grid
is impractical, may give the user context for the cell when rendering the contents of a cell; for
instance, giving its position in the table model, or listing the cell's header cells
(as determined by the algorithm for assigning header cells). When a cell's header
cells are being listed, user agents may use the value of abbr
attributes on those header cells, if any, instead of the contents of the header cells
themselves.
The colSpan IDL attribute must
reflect the colspan content attribute. Its
default value is 1.
The rowSpan IDL attribute must
reflect the rowspan content attribute. Its
default value is 1.
The headers IDL attribute must
reflect the content attribute of the same name.
The cellIndex IDL attribute must, if the
element has a parent tr element, return the index of the cell's element in the parent
element's cells collection. If there is no such parent element,
then the attribute must return −1.
4.9.12 Processing model
The various table elements and their content attributes together define the table
model.
A table consists of cells aligned on a two-dimensional grid of
slots with coordinates (x, y). The grid is finite, and is either empty or has one or more slots. If the grid
has one or more slots, then the x coordinates are always in the range 0 ≤ x < xwidth, and the y coordinates are always in the
range 0 ≤ y < yheight. If one or both of xwidth and yheight are zero, then the
table is empty (has no slots). Tables correspond to table elements.
A cell is a set of slots anchored at a slot (cellx, celly), and with
a particular width and height such that the cell covers
all the slots with coordinates (x, y) where cellx ≤ x < cellx+width and celly ≤ y < celly+height. Cells can either be data cells
or header cells. Data cells correspond to td elements, and header cells
correspond to th elements. Cells of both types can have zero or more associated
header cells.
It is possible, in certain error cases, for two cells to occupy the same slot.
A row is a complete set of slots from x=0 to x=xwidth-1, for a particular value of y. Rows usually
correspond to tr elements, though a row group
can have some implied rows at the end in some cases involving
cells spanning multiple rows.
A column is a complete set of slots from y=0 to y=yheight-1, for a particular value of x. Columns can
correspond to col elements. In the absence of col elements, columns are
implied.
A row group is a set of rows anchored at a slot (0, groupy) with a particular height such that the row group
covers all the slots with coordinates (x, y) where 0 ≤ x < xwidth and groupy ≤ y < groupy+height. Row groups correspond to
tbody, thead, and tfoot elements. Not every row is
necessarily in a row group.
A column group is a set of columns anchored at a slot (groupx, 0) with a particular width such that the column group
covers all the slots with coordinates (x, y) where groupx ≤ x < groupx+width and 0 ≤ y < yheight. Column
groups correspond to colgroup elements. Not every column is necessarily in a column
group.
A cell cannot cover slots that are from two or more row groups. It is, however, possible for a cell to be in multiple
column groups. All the slots that form part of one cell
are part of zero or one row groups and zero or more column groups.
A table model error is an error with the data represented by table
elements and their descendants. Documents must not have table model errors.
4.9.12.1 Forming a table
To determine which elements correspond to which slots in a table associated with a table element, to determine the
dimensions of the table (xwidth and yheight), and to determine if there are any table model errors, user agents must use the following algorithm:
Let xwidth be zero.
Let yheight be zero.
Let pending tfoot elements be a list of tfoot
elements, initially empty.
Let the table be the table represented
by the table element. The xwidth and yheight variables give the table's
dimensions. The table is initially empty.
If the table element has no children elements, then return the
table (which will be empty), and abort these steps.
Associate the first caption element child of the table element with
the table. If there are no such children, then it has no associated
caption element.
Let the current element be the first element child of the
table element.
If a step in this algorithm ever requires the current element to be advanced to the next child of the table when
there is no such next child, then the user agent must jump to the step labeled end, near
the end of this algorithm.
While the current element is not one of the following elements, advance the current element to the next
child of the table:
If the result of parsing the value is not an error or zero, then let span be that value.
Otherwise, if the col element has no span attribute, or if trying to parse the attribute's value
resulted in an error or zero, then let span be 1.
Increase xwidth by span.
Let the last spancolumns in
the table correspond to the current columncol element.
If current column is not the last col element child of
the colgroup element, then let the current column be the
next col element child of the colgroup element, and return to
the step labeled columns.
Let all the last columns in the
table from x=xstart to
x=xwidth-1 form a new column group, anchored at the slot (xstart, 0), with width xwidth-xstart, corresponding to the colgroup element.
If the current element has no col element children
If the result of parsing the value is not an error or zero, then let span be that value.
Otherwise, if the colgroup element has no span attribute, or if trying to parse the attribute's
value resulted in an error or zero, then let span be 1.
Increase xwidth by span.
Let the last spancolumns in
the table form a new column
group, anchored at the slot (xwidth-span, 0), with width span, corresponding to the colgroup element.
Advance the current element
to the next child of the table.
While the current element is not one of the following elements, advance the current element to the
next child of the table:
If the current element is a tr, then run the algorithm
for processing rows, advance the current element to the next child of the table, and return to the
step labeled rows.
If the current element is a tfoot, then add that element to
the list of pending tfoot elements, advance the current element to the next
child of the table, and return to the step labeled rows.
If yheight > ystart, then let all the last rows in the table from y=ystart to y=yheight-1 form a new row
group, anchored at the slot with coordinate (0, ystart), with height yheight-ystart, corresponding
to the element being processed.
If the tr element being processed has no td or th
element children, then increase ycurrent by 1, abort
this set of steps, and return to the algorithm above.
Let current cell be the first td or th element child
in the tr element being processed.
Cells: While xcurrent is less than xwidth and the slot with coordinate (xcurrent, ycurrent) already has a
cell assigned to it, increase xcurrent by 1.
If xcurrent is equal to xwidth, increase xwidth by 1. (xcurrent is never greater than xwidth.)
If parsing that value failed or if the attribute is absent, then let rowspan be 1, instead.
If rowspan is zero and the table element's
Document is not set to quirks mode, then let cell grows
downward be true, and set rowspan to 1. Otherwise, let cell grows downward be false.
If xwidth < xcurrent+colspan, then let xwidth be xcurrent+colspan.
If yheight < ycurrent+rowspan, then let yheight be ycurrent+rowspan.
Let the slots with coordinates (x, y) such that xcurrent ≤ x < xcurrent+colspan and ycurrent ≤ y < ycurrent+rowspan be covered by a
new cellc, anchored at (xcurrent, ycurrent),
which has width colspan and height rowspan,
corresponding to the current cell element.
If the current cell element is a th element, let this new
cell c be a header cell; otherwise, let it be a data cell.
If any of the slots involved already had a cell covering
them, then this is a table model error. Those slots now have two cells
overlapping.
If cell grows downward is true, then add the tuple {c, xcurrent, colspan}
to the list of downward-growing cells.
Increase xcurrent by colspan.
If current cell is the last td or th element child in
the tr element being processed, then increase ycurrent by 1, abort this set of steps, and return to the algorithm
above.
Let current cell be the next td or th element child
in the tr element being processed.
Return to the step labeled cells.
When the algorithms above require the user agent to run the algorithm for growing
downward-growing cells, the user agent must, for each {cell, cellx, width} tuple in the list of downward-growing cells, if any, extend the cellcell so that it also covers the slots with
coordinates (x, ycurrent), where cellx ≤ x < cellx+width.
4.9.12.2 Forming relationships between data cells and header cells
Each cell can be assigned zero or more header cells. The algorithm for assigning header
cells to a cell principal cell is as follows.
Let header list be an empty list of cells.
Let (principalx, principaly) be the coordinate of the slot to which the principal
cell is anchored.
If the principal cell has a headers attribute specified
Take the value of the principal cell's headers attribute and split it on spaces, letting id list be the list of tokens
obtained.
For each token in the id list, if the
first element in the Document with an ID equal to
the token is a cell in the same table, and that cell is not the
principal cell, then add that cell to header list.
If principal cell does not have a headers attribute specified
Let principalwidth be the width of the principal cell.
Let principalheight be the height of the principal cell.
For each value of y from principaly to principaly+principalheight-1, run
the internal algorithm for scanning and assigning header cells, with the principal cell, the header list, the initial coordinate
(principalx,y), and the
increments Δx=−1 and Δy=0.
For each value of x from principalx to principalx+principalwidth-1, run
the internal algorithm for scanning and assigning header cells, with the principal cell, the header list, the initial coordinate
(x,principaly), and the
increments Δx=0 and Δy=−1.
If the principal cell is anchored in a row group, then add all header cells that are row group headers and are anchored in the same row group
with an x-coordinate less than or equal to principalx+principalwidth-1 and a y-coordinate less than or
equal to principaly+principalheight-1 to header
list.
If the principal cell is anchored in a column group, then add all header cells that are column group headers and are anchored in the same column
group with an x-coordinate less than or equal to principalx+principalwidth-1 and a y-coordinate less than or
equal to principaly+principalheight-1 to header
list.
Remove principal cell from the header list if it is
there.
Assign the headers in the header list to the principal
cell.
The internal algorithm for scanning and assigning header cells, given a principal cell, a header list, an initial coordinate (initialx, initialy),
and Δx and Δy increments, is as follows:
Let x equal initialx.
Let y equal initialy.
Let opaque headers be an empty list of cells.
If principal cell is a header cell
Let in header block be true, and let headers from
current header block be a list of cells containing just the principal
cell.
そうでなければ
Let in header block be false and let headers from
current header block be an empty list of cells.
Loop: Increment x by Δx; increment y by Δy.
For each invocation of this algorithm, one of Δx and
Δy will be −1, and the other will be 0.
If either x or y is less than 0, then abort this
internal algorithm.
If there is no cell covering slot (x, y), or if there
is more than one cell covering slot (x, y), return to
the substep labeled loop.
Let current cell be the cell covering slot (x, y).
If current cell is a header cell
Set in header block to true.
Add current cell to headers from current header
block.
Let blocked be false.
If Δx is 0
If there are any cells in the opaque headers list anchored with the
same x-coordinate as the current cell, and with
the same width as current cell, then let blocked
be true.
If the current cell is not a column header, then let
blocked be true.
If Δy is 0
If there are any cells in the opaque headers list anchored with the
same y-coordinate as the current cell, and with
the same height as current cell, then let blocked
be true.
If the current cell is not a row header, then let blocked be true.
If blocked is false, then add the current cell
to the headers list.
If current cell is a data cell and in header block is true
Set in header block to false. Add all the cells in headers from current header block to the opaque headers
list, and empty the headers from current header block list.
Return to the step labeled loop.
A header cell anchored at the slot with coordinate (x, y) with width width and height height is
said to be a column header if any of the following conditions are true:
The cell's scope attribute is in the column state, or
The cell's scope attribute is in the auto state, and there are no data cells in any of the cells
covering slots with y-coordinates y .. y+height-1.
A header cell anchored at the slot with coordinate (x, y) with width width and height height is
said to be a row header if any of the following conditions are true:
The cell's scope attribute is in the row state, or
The cell's scope attribute is in the auto state, the cell is not a column header, and
there are no data cells in any of the cells covering slots with x-coordinates
x .. x+width-1.
A header cell is said to be a column group header if its scope attribute is in the column
group state.
A header cell is said to be a row group header if its scope attribute is in the row
group state.
A cell is said to be an empty cell if it contains no elements and its text content,
if any, consists only of White_Space characters.
Let direction be reversed and have explicit
direction be true.
If have explicit ordinality is false
Parse token as an
integer. If this resulted in an error or the value zero, then ignore the token.
Otherwise, set ordinality to the parsed value, and set have
explicit ordinality to true.
Even if table was a sorting-enabled table
element when the algorithm was invoked, the DOM might have been entirely changed by the
event handlers for the sort event, so this has to be verified at
this stage, not earlier.
Let row collection cursor be a pointer to an element, initially pointing
at the first child of table that is after table's first
thead, if any, and that is either a tbody or a tr
element, assuming there is one. If there is no such child, then jump to the step labeled
end below.
If table has no row group
corresponding to a thead element, then set ignore first group to
true. Otherwise, set it to false.
Row loop: Let rows be an empty list of tr
elements.
Run the appropriate steps from the following list:
Collect: Append the element pointed to by row collection
cursor to rows.
If there are no tr or tbody children of table that are later siblings of the element pointed to by row
collection cursor, or if the next such child is a tbody element, then jump
to the step labeled group below.
Let row collection cursor point to the next tr child
of table that is a later sibling of the element pointed to by row collection cursor.
Return to the step labeled collect above.
If row collection cursor points to a tbody element
Place all the tr element children of the element pointed to by row collection cursor into rows, in tree
order.
If rows is empty, jump to the step labeled increment loop
below.
Group: Let groups be an empty list of groups of tr
elements.
Let group cursor be a pointer to an element, initially pointing at the
first tr element in rows.
Start group: Let pending rows in group be 1.
Group loop: Append the tr element pointed to by group
cursor to group.
If there are any cells whose highest row's element is the one pointed to by group
cursor, then let tallest height be the number of rows covered by the
tallest such cell.
If tallest height is greater than pending rows in
group then set pending rows in group to tallest
height.
Decrement pending rows in group by one.
Let group cursor point to the next tr element in rows, if any; otherwise, let it be null.
If group cursor is not null and pending rows in
group is not zero, return to the step labeled group loop.
Append a new group to groups consisting of the tr
elements in group.
Empty group.
If group cursor is not null, then return to the step labeled start
group.
If ignore first group is true, then drop the first group in groups and set ignore first group to false.
Drop leading header groups: If groups is now empty, jump to the
step labeled increment loop below.
If the first group of groups consists of tr elements
whose element children are all th elements, then drop the first group in groups and return to the previous step (labeled drop leading header
groups).
Let insertion point be a placeholder in a DOM tree, which can be used
to reinsert nodes at a specific point in the DOM. Insert insertion point into
the parent of the first tr element of the first group in groups,
immediately before that tr element.
Sort the groups in groups, using the following algorithm to decide the
relative order of any two groups a and b (the algorithm
either returns that a comes before b, or that b comes before a):
Let key index be an index into key heading
cells, initially denoting the first element in the list.
Let direction be a sort direction, initially ascending. Its
other possible value is descending. When direction is
toggled, that means that if its value is ascending, it must be changed to
descending, and when its value is descending, it must be changed to
ascending.
Column loop: Let th be the key indexth
th in key heading cells.
If tentative order is not "equal", then jump to the step labeled
return below.
Increment key index.
If key index still denotes a th element in key heading cells, then jump back to the step above labeled column
loop.
If a's tr elements precede b's in
tree order, then let tentative order be "a before b".
Otherwise, let tentative order be "b before a".
Return: Return the relative order given by the matching option from the following
list:
If direction is ascending and tentative
order is "a before b"
Return that a comes before b.
If direction is ascending and tentative
order is "b before a"
Return that b comes before a.
If direction is descending and tentative
order is "a before b"
Return that b comes before a.
If direction is descending and tentative
order is "b before a"
Return that a comes before b.
When the user agent is required to compare two row groups using the th element th,
with a and b being the two row groups respectively, the
user agent must run the following steps:
Let x be the x-coordinate of the slots that
th covers in its table.
Let cella be the element corresponding to the cell in the first row of group
a that covers the slot in that row whose
x-coordinate is x.
Let cellb be the element corresponding to the cell in the first row of group
b that covers the slot in that row whose
x-coordinate is x.
In either case, if there's no cell that actually covers
the slot, then use the value null instead.
The type and value of the cell cell are computed as follows.
If cell is null, then the type is "string" and the value is
the empty string; abort these steps.
If, ignoring inter-element whitespace and nodes other than
Element and Text nodes, cell has only one child
and that child is a data element, then the value is the value of that
data element's value attribute, if there is
one, or the empty string otherwise; the type is "string".
If, ignoring inter-element whitespace and nodes other than
Element and Text nodes, cell has only one child
and that child is a progress element, then the value is the value of that
progress element's value attribute, if
there is one, or the empty string otherwise; the type is "string".
If, ignoring inter-element whitespace and nodes other than
Element and Text nodes, cell has only one child
and that child is a meter element, then the value is the value of that
meter element's value attribute, if there is
one, or the empty string otherwise; the type is "string".
If there is no machine-readable equivalent, then the type is "string" and the value is
the empty string.
If the type is
a month,
a date,
a week, or
a year,
then change the value to be the instant in time (with no time zone) that describes the
earliest moment that the value represents, and change the type to be
a floating date and time.
For example, if the cell was
<td><time>2011-11</time> then for sorting purposes the value is
interpreted as "2011-11-01T00:00:00.000" and the type is treated as a floating date and time rather than a month.
Similarly, if the cell was <td><time
datetime="2014">MMXIV</time> then for sorting purposes the value is interpreted as
"2014-01-01T00:00:00.000" and the type is treated as a floating date and time rather than a year.
The value is the element's textContent. The type is "string".
If typea and typeb are not
equal, then: return "a before b" if typea is earlier in the
following list than typeb, otherwise, return "b before a";
then, abort these steps.
If valuea and valueb are
equal, then return "equal" and abort these steps.
If typea and typeb are not
"string", then: if valuea is earlier than valueb then return "a before b" and abort these steps, otherwise,
return "b before a" and abort these steps.
Values sort in their natural order, with the following additional constraints:
For time values, 00:00:00.000 is the earliest value and
23:59:59.999 is the latest value.
For yearless date values, 01-01 is the earliest
value and 12-31 is the latest value; 02-28 is earlier than 02-29 which is earlier than
03-01.
As described below, componentsa and componentsb are tuples consisting of a list of nnumbers, a list of nnumber strings, a list of n+1 non-numeric strings, and a list of 2n+1 raw
strings, for any non-negative integer value of n (zero or more).
Let order be the result of a locale-specific string
comparison of componentsa's first non-numeric
string and componentsb's first non-numeric string,
in the context of th.
If order is not "equal" then return order and abort
these steps.
If componentsa and componentsb both have exactly one number, then run these
substeps:
If componentsa's number is less than componentsb's number, return "a before b".
If componentsb's number is less than componentsa's number, return "b before a".
Let order be the result of a locale-specific string
comparison of componentsa's second non-numeric
string and componentsb's second non-numeric
string, in the context of th.
If order is not "equal" then return order and
abort these steps.
Let order be the result of a locale-specific string
comparison of componentsa's number string and
componentsb's number string, in the context of th.
If order is not "equal" then return order and
abort these steps.
Otherwise, run these substeps:
If componentsa has zero numbers but componentsb has more than zero numbers, return "a before
b".
If componentsb has zero numbers but componentsa has more than zero numbers, return "b before
a".
If componentsa has one number, return "a before
b".
If componentsb has one number, return "b before
a".
If componentsa and componentsb have more than one number, run these substeps:
Let count be the smaller of the number of numbers in componentsa and the number of numbers in componentsb.
For each number in componentsa and componentsb from the first to the countth, in
order: if componentsa's number is less than componentsb's number, then return "a before b" and abort
these steps; otherwise, if componentsb's number is
less than componentsa's number, return "b before a"
and abort these steps.
If componentsa has fewer numbers than componentsb, return "a before b" and abort these steps.
If componentsb has fewer numbers than componentsa, return "b before a" and abort these steps.
Let index be zero.
String loop: Let order be the result of a locale-specific
string comparison of componentsa's indexth number string and componentsb's indexth number string,
in the context of th.
If order is not "equal" then return order and
abort these steps.
Increment index.
Let order be the result of a locale-specific string
comparison of componentsa's indexth separator string and componentsb's indexth separator
string, in the context of th.
If order is not "equal" then return order and
abort these steps.
If index is less than the number of numbers in componentsa and componentsb, return
to the step labeled string loop.
Let index be zero.
Final loop: Let order be the result of a raw string
comparison of componentsa's nth
raw string and componentsb's nth
raw string.
If order is not "equal" then return order and abort
these steps.
Increment index.
If index is less than the number of raw strings in componentsa and componentsb, return
to the step labeled final loop.
Return "equal".
Let new order be a list of tr elements consisting of the
tr elements of all the groups in the newly ordered groups, with
the tr elements being in the same order as the groups to which they belong are in
groups, and the tr elements within each such group themselves
being ordered in tree order.
Remove all the tr elements in new order from their parents, in tree order.
Insert all the tr elements in new order into the DOM at the location of insertion point, in
the order these elements are found in new order.
Remove insertion point from the DOM.
Increment loop: If there are no tr or tbody children of
table that are later siblings of the element pointed to by row
collection cursor, then jump to the step labeled end below.
Let row collection cursor point to the next tr or
tbody child of table that is a later sibling of the element
pointed to by row collection cursor.
When a user agent is to parse the sort key value, it must run the following steps. These return a tuple consisting of a list
of nnumbers, a list of nnumber strings, a
list of n+1 non-numeric strings, and a list of 2n+1
raw strings, respectively, for any non-negative integer value of n (zero or
more).
Let raw strings be a list of strings initially containing just one entry, an empty string.
If index is greater than the number of characters in value, stop repeating these substeps and continue along the overall steps.
Otherwise, return to the step labeled top of loop.
Let numbers be an empty list.
Let number strings be an empty list.
Let non-numeric strings be an empty list.
For each even-numbered entry in raw strings, in order, starting from the
first entry (numbered 0), append an entry to non-numeric strings that
consists of the result of trimming and collapsing the value of the entry.
If raw strings has more than one entry, then, for each odd-numbered entry
in raw strings, in order, starting from the second entry (numbered 1),
append an entry to number strings that consists of the value of the entry,
and append an entry to number strings that consists of the result of parsing
the value of the entry using the rules for parsing floating-point number
values.
Return numbers, number strings, non-numeric strings, and raw strings respectively.
When the user agent is required by the step above to perform a locale-specific string
comparison of two strings a and b in the context of
an element e, the user agent must apply the Unicode Collation Algorithm, using
the Default Unicode Collation Element Table as customised for the language of the
element e in the Common Locale Data Repository, to the strings a and b, ignoring case. If the result of this algorithm places
a first, then return "a before b"; if it places b first,
then return "b before a"; otherwise, if they compare as equal, then return "equal". [UCA][CLDR]
When the user agent is required by the step above to perform a raw string comparison
of two strings a and b, the user agent must apply the
Unicode Collation Algorithm, using the Default Unicode Collation Element Table without
customizations, to the strings a and b. If the result of
this algorithm places a first, then return "a before b"; if it places b first, then return "b before a"; otherwise, if they compare as equal, then return
"equal". [UCA]
Where the steps above refer to trimming and collapsing a string value, it means running the following algorithm:
For each th element th in current
headers, in order, run the following substeps:
If th's sorted attribute's
column sort direction is normal, then set th's sorted attribute to a valid integer whose value is
level. Otherwise, set it to the concatenation of the string "reversed", a U+0020 SPACE character, and a valid integer whose
value is level.
Increment level by 1.
Set target's sorted attribute to
the empty string.
The length IDL attribute must return the number
of nodes represented by the elements collection.
The supported property indices at any instant are the indices supported by the
object returned by the elements attribute at that
instant.
When a form element is indexed for indexed property
retrieval, the user agent must return the value returned by the item method on the elements collection, when invoked with the given index as its
argument.
Each form element has a mapping of names to elements called the past names
map. It is used to persist names of controls even when they change names.
The supported property names consist of the names obtained from the following
algorithm, in the order obtained from this algorithm:
Let sourced names be an initially empty ordered list of tuples
consisting of a string, an element, a source, where the source is either id, name,
or past, and, if the source is past, an age.
If candidate has an id attribute, add
an entry to sourced names with that id
attribute's value as the string, candidate as the element, and id as
the source.
If candidate has a name attribute,
add an entry to sourced names with that name attribute's value as the string, candidate
as the element, and name as the source.
For each img element candidate whose form owner
is the form element, run these substeps:
If candidate has an id attribute, add
an entry to sourced names with that id
attribute's value as the string, candidate as the element, and id as
the source.
If candidate has a name attribute,
add an entry to sourced names with that name attribute's value as the string, candidate
as the element, and name as the source.
For each entry past entry in the past names map add an entry
to sourced names with the past entry's name as the
string, past entry's element as the element, past as the source, and
the length of time past entry has been in the past names map as
the age.
Sort sourced names by tree order of the element entry of
each tuple, sorting entries with the same element by putting entries whose source is id
first, then entries whose source is name, and finally entries whose source is past,
and sorting entries with the same element and source by their age, oldest first.
Remove any entries in sourced names that have the empty string as
their name.
Remove any entries in sourced names that have the same name as an
earlier entry in the map.
Return the list of names from sourced names, maintaining their
relative order.
The properties exposed in this way must be unenumerable.
When a form element is indexed for named property
retrieval, the user agent must run the following steps:
If candidates is empty, let candidates be a
liveRadioNodeList object containing all the img elements
that are descendants of the form element and that have either an id attribute or a name attribute equal
to name, in tree order.
If candidates is empty, name is the name of one of
the entries in the form element's past names map: return the object
associated with name in that map.
If candidates contains more than one node, return candidates and abort these steps.
Otherwise, candidates contains exactly one node. Add a mapping from
name to the node in candidates in the form
element's past names map, replacing the previous entry with the same name, if
any.
Return the node in candidates.
If an element listed in a form element's past names map changes
form owner, then its entries must be removed from that map.
The submit() method, when invoked, must submit the form element from the form
element itself, with the submitted from submit() method flag set.
The reset() method, when invoked, must run the
following steps:
If the checkValidity() method is
invoked, the user agent must statically validate the constraints of the
form element, and return true if the constraint validation return a positive
result, and false if it returned a negative result.
If the reportValidity() method is
invoked, the user agent must interactively validate the constraints of the
form element, and return true if the constraint validation return a positive
result, and false if it returned a negative result.
labelは、ユーザーインターフェースでのキャプションを表す。The caption can be associated with a specific form control, known as the label element's labeled control, either using the for attribute, or by putting the form control inside the label element itself.
Except where otherwise specified by the following rules, a label element has no
labeled control.
for属性は、キャプションが関連付けされることになっているフォームコントロールを示すために指定されてもよい。この属性が指定される場合、属性値は、label要素と同じDocumentでラベル付け可能要素のIDでなければならない。If the attribute is specified and there is an element in the Document whose ID is equal to the value of the for attribute, and the first such element is a labelable element, then that element is the label element's labeled control.
The label element's exact default presentation and behavior, in particular what
its activation behavior might be, if anything, should match the platform's label
behavior. The activation behavior of a label element for events targeted
at interactive content descendants of a label element, and any
descendants of those interactive content descendants, must be to do nothing.
For example, on platforms where clicking or pressing a checkbox label checks the checkbox, clicking or pressing the
label in the following snippet could trigger the user agent to run synthetic
click activation steps on the input element, as if the element itself had
been triggered by the user:
<!-- bad example - link inside label reduces checkbox activation area -->
<label><input type=checkbox name=tac>I agree to <a href="tandc.html">the terms and conditions</a></label>
<!-- bad example - all label text inside the link reduces activation area to checkbox only -->
<label><input type=checkbox name=tac><a href="tandc.html">I agree to the terms and conditions</a></label>
<!-- good example - link outside label means checkbox activation area includes the checkbox and all the label text -->
<label><input type=checkbox name=tac>I agree to the terms and conditions</label>
(read <a href="tandc.html">Terms and Conditions</a>)
Some states of the type attribute define a value
sanitization algorithm.
Each input element has a value, which is
exposed by the value IDL attribute. Some states define an
algorithm to convert a string to a number,
an algorithm to convert a number to a
string, an algorithm to convert a string to a
Date object, and an algorithm to
convert a Date object to a string, which are used by max, min, step, valueAsDate,
valueAsNumber, valueLow, valueHigh,
stepDown(), and stepUp().
Each input element has a boolean dirty
value flag. The dirty value flag must be
initially set to false when the element is created, and must be set to true whenever the user
interacts with the control in a way that changes the value.
(It is also set to true when the value is programmatically changed, as described in the definition
of the value IDL attribute.)
valueコンテンツ属性はinput要素のデフォルトの値を示す。When the value content attribute is added, set, or removed, if the control's dirty value flag is false, the user agent must set the value of the element to the value of the value content attribute, if there is one, or the empty string otherwise, and then run the current value sanitization algorithm, if one is defined.
Each input element has a boolean dirty checkedness flag. When it is true, the
element is said to have a dirty checkedness.
The dirty checkedness flag must be initially
set to false when the element is created, and must be set to true whenever the user interacts with
the control in a way that changes the checkedness.
checkedコンテンツ属性は、input要素のデフォルトのcheckednessを与える真偽属性である。When the checked content attribute is added, if the control does not have dirty checkedness, the user agent must set the checkedness of the element to true; when the checked content attribute is removed, if the control does not have dirty checkedness, the user agent must set the checkedness of the element to false.
Each input element can be mutable. Except where
otherwise specified, an input element is always mutable. Similarly, except where otherwise specified, the user
agent should not allow the user to modify the element's value or checkedness.
When an input element is first created, the element's rendering and behavior must
be set to the rendering and behavior defined for the type
attribute's state, and the value sanitization algorithm, if one is defined for the
type attribute's state, must be invoked.
When an input element's type attribute
changes state, the user agent must run the following steps:
If the previous state of the element's type attribute
put the value IDL attribute in the value mode, and the element's value is not the empty string, and the new state of the element's
type attribute puts the value IDL attribute in either the default mode or the default/on mode, then set the element's value content attribute to the element's value.
Otherwise, if the previous state of the element's type attribute put the value
IDL attribute in any mode other than the value mode, and the
new state of the element's type attribute puts the value IDL attribute in the value mode, then set the value of the element to the value of the value content attribute, if there is one, or the empty string
otherwise, and then set the control's dirty value
flag to false.
Update the element's rendering and behavior to the new state's.
The indeterminate IDL attribute must
initially be set to false. On getting, it must return the last value it was set to. On setting, it
must be set to the new value. It has no effect except for changing the appearance of checkbox controls.
The accept, alt, max,
min, multiple, pattern, placeholder, required, size, src,
and step IDL attributes must reflect
the respective content attributes of the same name. The dirName IDL attribute must reflect the
dirname content attribute. The readOnly IDL attribute must reflect the
readonly content attribute. The defaultChecked IDL attribute must
reflect the checked content attribute. The
defaultValue IDL attribute must
reflect the value content attribute.
The IDL attributes width and height must return the rendered width and height of
the image, in CSS pixels, if an image is being rendered, and is being rendered to a
visual medium; or else the intrinsic width and height of the image, in CSS pixels, if an image is
available but not being rendered to a visual medium; or else 0,
if no image is available. When the input element's
type attribute is not in the Image Button state, then no image is available. [CSS]
On setting, they must act as if they reflected the respective
content attributes of the same name.
If the element is mutable, its value should be editable by the user. User agents must not allow
users to insert "LF" (U+000A) or "CR" (U+000D) characters into the element's
value.
If the element is mutable, the user agent should allow the
user to change the writing direction of the element, setting it either to a left-to-right writing
direction or a right-to-left writing direction. If the user does so, the user agent must then run
the following steps:
Set the element's dir attribute to "ltr" if the user selected a left-to-right writing direction, and
"rtl" if the user selected a right-to-left writing
direction.
If the element is mutable, its value should be editable by the user. User agents may change the
spacing and, with care, the punctuation of values that the
user enters. User agents must not allow users to insert "LF" (U+000A) or "CR" (U+000D) characters into the element's value.
If the element is mutable, the user agent should allow the
user to change the URL represented by its value. User agents
may allow the user to set the value to a string that is not
a validabsolute URL, but may also or instead
automatically escape characters entered by the user so that the value is always a validabsolute URL (even if that isn't the actual value seen and edited by the user in the
interface). User agents should allow the user to set the value to the empty string. User agents must not allow users to
insert "LF" (U+000A) or "CR" (U+000D) characters into the value.
If the element is mutable, the user agent should allow the
user to change the e-mail address represented by its value. User agents may allow the user to set the value to a string that is not a valid e-mail
address. The user agent should act in a manner consistent with expecting the user to
provide a single e-mail address. User agents should allow the user to set the value to the empty string. User agents must not allow users to
insert "LF" (U+000A) or "CR" (U+000D) characters into the value. User agents may transform the value for display and editing; in particular, user agents should
convert punycode in the value to IDN in the display and
vice versa.
Constraint validation: While the user interface is representing input that
the user agent cannot convert to punycode, the control is suffering from bad
input.
If the element is mutable, the user agent should allow the
user to add, remove, and edit the e-mail addresses represented by its values. User agents may allow the user to set any
individual value in the list of values to a
string that is not a valid e-mail address, but must not allow users to set any
individual value to a string containing "," (U+002C), "LF" (U+000A), or "CR" (U+000D) characters. User agents should allow the user to remove all the addresses
in the element's values. User agents may
transform the values for display and editing; in
particular, user agents should convert punycode in the value to IDN in the display and vice versa.
Constraint validation: While the user interface describes a situation where
an individual value contains a "," (U+002C) or is representing input that the user agent
cannot convert to punycode, the control is suffering from bad input.
Whenever the user changes the element's values, the user agent must run the following
steps:
Let latest values be a copy of the element's values.
Let the element's value be the result of
concatenating all the values in latest values, separating each value from
the next by a single "," (U+002C) character, maintaining the list's order.
Let the element's value be the result of
concatenating the element's values, separating
each value from the next by a single "," (U+002C) character, maintaining the list's
order.
If the element is mutable, its value should be editable by the user. User agents must not allow
users to insert "LF" (U+000A) or "CR" (U+000D) characters into the value.
See the introduction section for a discussion of
the difference between the input format and submission format for date, time, and number form
controls, and the implementation notes
regarding localization of form controls.
The value sanitization algorithm is as follows: If the value of the element is a valid global date and time
string, then adjust the time so that the value
represents the same point in time but expressed in the UTC time zone as a valid normalized
forced-UTC global date and time string, otherwise, set it to the empty string instead.
step属性は秒単位で表される。The step scale factor is 1000 (which converts the seconds to milliseconds, as used in the other algorithms). The default step is 60 seconds.
The algorithm to convert a string to a
number, given a string input, is as follows: If parsing a global date and time from input results in an error, then return an error; otherwise, return the number of
milliseconds elapsed from midnight UTC on the morning of 1970-01-01 (the time represented by the
value "1970-01-01T00:00:00.0Z") to the parsed global date and time, ignoring leap seconds.
Date and Time状態（および、後続の節で説明される他の日付と時間に関連する状態）は、現代の暦を基準に正確な日付および時刻が確証されないような値を入力するためのものではない。たとえば、"ビッグバン後の1ミリ秒"、"ジュラ紀初期"、または"西暦紀元前250年頃の冬"のような年代のエントリには不適切だろう。
グレゴリオ暦の導入以前の日付の入力のために、著者は、Date and Time状態（および、以降の節で説明される他の日付と時間に関連する状態）を使用しないように推奨される。これは、ユーザーエージェントが、グレゴリオ暦以前の時代から日付および時刻の変換をサポートする必要がないように、ユーザーに変換を求め、ユーザーに過度の負担を手動でかけるためである。（これは16世紀から20世紀初頭にわたって、異なる国で異なる時期に発生した、グレゴリオ暦が段階的に導入されたために複雑である。）代わりに、きめ細かい入力コントロールは、Number状態をもつselect要素とinput要素を使って提供することが著者に推奨される。
If the element is mutable, the user agent should allow the
user to change the date represented by its value, as obtained by parsing a
date from it. User agents must not allow the user to set the value to a non-empty string that is not a valid date
string. If the user agent provides a user interface for selecting a date, then the value must be set
to a valid date string representing the user's selection. User agents should allow
the user to set the value to the empty string.
See the introduction section for a discussion of
the difference between the input format and submission format for date, time, and number form
controls, and the implementation notes
regarding localization of form controls.
step属性は日単位で表される。The step scale factor is 86,400,000 (which converts the days to milliseconds, as used in the other algorithms). The default step is 1 day.
The algorithm to convert a string to a
number, given a string input, is as follows: If parsing a date from input results in an
error, then return an error; otherwise, return the number of milliseconds elapsed from midnight
UTC on the morning of 1970-01-01 (the time represented by the value "1970-01-01T00:00:00.0Z") to midnight UTC on the morning of the parsed date, ignoring leap seconds.
The algorithm to convert a number to a
string, given a number input, is as follows: Return a
valid date string that represents the date that, in
UTC, is current input milliseconds after midnight UTC on the morning of
1970-01-01 (the time represented by the value "1970-01-01T00:00:00.0Z").
If the element is mutable, the user agent should allow the
user to change the month represented by its value, as obtained by parsing a
month from it. User agents must not allow the user to set the value to a non-empty string that is not a valid month
string. If the user agent provides a user interface for selecting a month, then the value must be
set to a valid month string representing the user's selection. User agents should
allow the user to set the value to the empty string.
See the introduction section for a discussion of
the difference between the input format and submission format for date, time, and number form
controls, and the implementation notes
regarding localization of form controls.
If the element is mutable, the user agent should allow the
user to change the week represented by its value, as obtained by parsing a
week from it. User agents must not allow the user to set the value to a non-empty string that is not a valid week
string. If the user agent provides a user interface for selecting a week, then the value must be set
to a valid week string representing the user's selection. User agents should allow
the user to set the value to the empty string.
See the introduction section for a discussion of
the difference between the input format and submission format for date, time, and number form
controls, and the implementation notes
regarding localization of form controls.
step属性は週単位で表される。The step scale factor is 604,800,000 (which converts the weeks to milliseconds, as used in the other algorithms). The default step is 1 week. The default step base is −259,200,000 (the start of week 1970-W01).
The algorithm to convert a string to a
number, given a string input, is as follows: If parsing a week string from input results in
an error, then return an error; otherwise, return the number of milliseconds elapsed from midnight
UTC on the morning of 1970-01-01 (the time represented by the value "1970-01-01T00:00:00.0Z") to midnight UTC on the morning of the Monday of the
parsed week, ignoring leap seconds.
The algorithm to convert a number to a
string, given a number input, is as follows: Return a
valid week string that represents the week that, in
UTC, is current input milliseconds after midnight UTC on the morning of
1970-01-01 (the time represented by the value "1970-01-01T00:00:00.0Z").
If the element is mutable, the user agent should allow the
user to change the time represented by its value, as obtained by parsing a
time from it. User agents must not allow the user to set the value to a non-empty string that is not a valid time
string. If the user agent provides a user interface for selecting a time, then the value must be set
to a valid time string representing the user's selection. User agents should allow
the user to set the value to the empty string.
See the introduction section for a discussion of
the difference between the input format and submission format for date, time, and number form
controls, and the implementation notes
regarding localization of form controls.
step属性は秒単位で表される。The step scale factor is 1000 (which converts the seconds to milliseconds, as used in the other algorithms). The default step is 60 seconds.
The algorithm to convert a string to a
number, given a string input, is as follows: If parsing a time from input results in an
error, then return an error; otherwise, return the number of milliseconds elapsed from midnight to
the parsed time on a day with no time changes.
When the element is suffering from a step mismatch, the user agent may round the
element's value to the nearest number for which the element
would not suffer from a step mismatch. If
there are two such numbers, user agents are encouraged to pick the one nearest positive
infinity.
When the element is suffering from a step mismatch, the user agent must round
the element's value to the nearest number for which the
element would not suffer from a step
mismatch, and which is greater than or equal to the minimum, and, if the maximum is not less than the minimum, which is less than or equal to the maximum, if there is a number that matches these constraints.
If two numbers match these constraints, then user agents must use the one nearest to positive
infinity.
For example, the markup
<input type="range" min=0 max=100 step=20 value=50>
results in a range control whose initial value is 60.
Othwerwise, let the element's values be the two
values, with the smaller value first.
Let the element's value be the result of
concatenating the element's values, separating them by
a single "," (U+002C) character, with the lower value coming first.
Whenever the user changes the element's values, the
user agent must set the element's value to the result of
concatenating the element's values, separating them by a
single "," (U+002C) character, with the lower value coming first.
When the element is suffering from a step mismatch, the user agent must round
the values represented by the element's values to, in
each case, the nearest number for which the element would not suffer from a step mismatch, and which is greater than or equal to the
minimum, and, if the maximum is not less than the minimum, which is less than or equal to the maximum, if there is a number that matches these constraints.
If two numbers match these constraints, then user agents must use the one nearest to positive
infinity.
Whenever the user agent changes the element's values
according to the three previous paragraphs, the user agent must set the element's value to the result of concatenating the element's values, separating them by a single U+002C COMMA character
(,), with the lower value coming first.
In this state, there is always a color picked, and there is no way to set the
value to the empty string.
If the element is mutable, the user agent should allow the
user to change the color represented by its value, as
obtained from applying the rules for parsing simple color values to it. User agents
must not allow the user to set the value to a string that is
not a valid lowercase simple color. If the user agent provides a user interface for
selecting a color, then the value must be set to the result
of using the rules for serializing simple color values to the user's selection. User
agents must not allow the user to set the value to the empty
string.
When any of the following phenomena occur, if the element's checkedness state is true after the occurrence, the checkedness state of all the other elements in the same radio
button group must be set to false:
The element's checkedness state is set to true (for
whatever reason).
The element's name attribute is set, changed, or
removed.
File names must not contain path components, even
in the case that a user has selected an entire directory hierarchy or multiple files with the same
name from different directories. Path components, for
the purposes of the File Upload state, are those parts
of file names that are separated by "\" (U+005C) character characters.
Unless the multiple attribute is set, there must be
no more than one file in the list of selected
files.
If the algorithm is not allowed to show a popup, then abort these steps
without doing anything else.
Return, but continue running these steps asynchronously.
Optionally, wait until any prior execution of this algorithm has terminated.
Display a prompt to the user requesting that the user specify some files. If the multiple attribute is not set, there must be no more than one
file selected; otherwise, any number may be selected. Files can be from the filesystem or created
on the fly, e.g. a picture taken from a camera connected to the user's device.
If the element is mutable, the user agent should allow the
user to change the files on the list in other ways also, e.g. adding or removing files by
drag-and-drop. When the user does so, the user agent must queue a task to first
update the element's selected files so that
it represents the user's new selection, then fire a simple event that bubbles named
input at the input element, and finally
fire a simple event that bubbles named change at the input element.
If the element is not mutable, it has no activation
behavior and the user agent must not allow the user to change the element's selection.
function extractFilename(path) {
if (path.substr(0, 12) == "C:\\fakepath\\")
return path.substr(12); // modern browser
var x;
x = path.lastIndexOf('/');
if (x >= 0) // Unix-based path
return path.substr(x+1);
x = path.lastIndexOf('\\');
if (x >= 0) // Windows-based path
return path.substr(x+1);
return path; // just the file name
}
これは次のように使用できる：
<p><input type=file name=image onchange="updateFilename(this.value)"></p>
<p>The name of the file you picked is: <span id="filename">(none)</span></p>
<script>
function updateFilename(path) {
var name = extractFilename(path);
document.getElementById('filename').textContent = name;
}
</script>
When an input element's type attribute is in
the Submit Button state, the rules in this section
apply.
input要素は、アクティブになった際、フォームを送信するボタンを表す。If the element has a value attribute, the button's label must be the value of that attribute; otherwise, it must be an implementation-defined string that means "Submit" or some such. The element is a button, specifically a submit button.
When any of the following events occur, unless the user agent cannot support images, or its
support for images has been disabled, or the user agent only fetches elements on demand, or the
src attribute's value is the empty string, the user agent must
resolve the value of the src attribute, relative to the element, and if that is successful,
must fetch the resulting absolute URL:
The input element's type attribute is first
set to the Image Button state (possibly when the
element is first created), and the src attribute is
present.
The input element's type attribute is
changed back to the Image Button state, and the src attribute is present, and its value has changed since the last
time the type attribute was in the Image Button state.
The input element's type attribute is in
the Image Button state, and the src attribute is set or changed.
If the image was successfully obtained, with no network errors, and the image's type is a
supported image type, and the image is a valid image of that type, then the image is said to be
available. If this is true before the image is
completely downloaded, each task that is queued by the networking task source while the image is being fetched must update the presentation of the image appropriately.
User agents must not support non-image resources with the input element. User
agents must not run executable code embedded in the image resource. User agents must only display
the first page of a multipage resource. User agents must not allow the resource to act in an
interactive fashion, but should honor any animation in the resource.
If the src attribute is set, and the image is available and the user agent is configured to display that image,
then: The element represents a control for selecting a coordinate from the image specified by the
src attribute; if the element is mutable, the user agent should allow the user to select this coordinate, and the element's activation
behavior is as follows: if the element has a form owner, and the element's
Document is fully active, take the user's selected coordinate, and submit the input element's form owner
from the input element. If the user activates the control without explicitly
selecting a coordinate, then the coordinate (0,0) must be assumed.
The selected coordinate must consist of
an x-component and a y-component. The coordinates
represent the position relative to the edge of the image, with the coordinate space having the
positive x direction to the right, and the positive y
direction downwards.
The x-component must be a valid integer representing a number
x in the range −(borderleft+paddingleft) ≤ x ≤ width+borderright+paddingright, where width is the rendered width of the image, borderleft is the width of the border on the left of the image, paddingleft is the width of the padding on the left of the
image, borderright is the width of the border on the right
of the image, and paddingright is the width of the padding
on the right of the image, with all dimensions given in CSS pixels.
The y-component must be a valid integer representing a number
y in the range −(bordertop+paddingtop) ≤ y ≤ height+borderbottom+paddingbottom, where
height is the rendered height of the image, bordertop is the width of the border above the image, paddingtop is the width of the padding above the image, borderbottom is the width of the border below the image, and paddingbottom is the width of the padding below the image, with
all dimensions given in CSS pixels.
Where a border or padding is missing, its width is zero CSS pixels.
When an input element's type attribute is in
the Reset Button state, the rules in this section
apply.
アクティブの際、input要素は、フォームをリセットするボタンを表す。If the element has a value attribute, the button's label must be the value of that attribute; otherwise, it must be an implementation-defined string that means "Reset" or some such. The element is a button.
When an input element's type attribute is in
the Button state, the rules in this section apply.
input要素は、デフォルトの動作をもたないボタンを表す。要素が空文字列であるかもしれないが、ボタンのラベルは、value属性で指定されなければならない。If the element has a value attribute, the button's label must be the value of that attribute; otherwise, it must be the empty string. The element is a button.
4.10.5.2 Implemention notes regarding localization of form controls
この節は非規範的である。
The formats shown to the user in date, time, and number controls is independent of the format
used for form submission.
Browsers are encouraged to use user interfaces that present dates, times, and numbers according
to the conventions of either the locale implied by the input element's
language or the user's preferred locale. Using the page's locale will ensure
consistency with page-provided data.
For example, it would be confusing to users if an American English page claimed
that a Cirque De Soleil show was going to be showing on 02/03, but their
browser, configured to use the British English locale, only showed the date 03/02 in the ticket purchase date picker. Using the page's locale would at least ensure that the
date was presented in the same format everywhere. (There's still a risk that the user would end up
arriving a month late, of course, but there's only so much that can be done about such cultural
differences...)
These attributes only apply to an input
element if its type attribute is in a state whose definition
declares that the attribute applies. When an attribute
doesn't apply to an input element, user agents must
ignore the attribute, regardless of the requirements and definitions below.
If the attribute is present, then its value must be parsed using the rules for parsing
non-negative integers, and if the result is a number greater than zero, then the user agent
should ensure that at least that many characters are visible.
<fieldset>
<legend>Did the movie pass the Bechdel test?</legend>
<p><label><input type="radio" name="bechdel" value="no-characters"> No, there are not even two female characters in the movie. </label>
<p><label><input type="radio" name="bechdel" value="no-names"> No, the female characters never talk to each other. </label>
<p><label><input type="radio" name="bechdel" value="no-topic"> No, when female characters talk to each other it's always about a male character. </label>
<p><label><input type="radio" name="bechdel" value="yes" required> Yes. </label>
<p><label><input type="radio" name="bechdel" value="unknown"> I don't know. </label>
</fieldset>
If an input element has a pattern
attribute specified, and the attribute's value, when compiled as a JavaScript regular expression
with the global, ignoreCase, and multiline flags disabled (see ECMA262 Edition 5, sections 15.10.7.2
through 15.10.7.4), compiles successfully, then the resulting regular expression is the element's
compiled pattern regular expression. If the element has no such attribute, or if the
value doesn't compile successfully, then the element has no compiled pattern regular
expression. [ECMA262]
The compiled pattern regular expression, when matched against a string, must have
its start anchored to the start of the string and its end anchored to the end of the string.
This implies that the regular expression language used for this attribute is the
same as that used in JavaScript, except that the pattern
attribute is matched against the entire value, not just any subset (somewhat as if it implied a
^(?: at the start of the pattern and a )$ at the
end).
<label> Part number:
<input pattern="[0-9][A-Z]{3}" name="part"
data-x="A part number is a digit followed by three uppercase letters."/>
</label>
<p>A part number is a digit followed by three uppercase letters.</p>
<label> Part number:
<input pattern="[0-9][A-Z]{3}" name="part" aria-describedby="description">
</label>
<p id="description">A part number is a digit followed by three uppercase letters.</p>
Their syntax is defined by the section that defines the type attribute's current state.
If the element has a min attribute, and the result of
applying the algorithm to convert a string to a
number to the value of the min attribute is a number,
then that number is the element's minimum; otherwise, if the
type attribute's current state defines a default minimum, then that is the minimum; otherwise, the element has no minimum.
If the element has a max attribute, and the result of
applying the algorithm to convert a string to a
number to the value of the max attribute is a number,
then that number is the element's maximum; otherwise, if the
type attribute's current state defines a default maximum, then that is the maximum; otherwise, the element has no maximum.
step属性は、許可される値を制限することによって、値または複数の値の期待される（そして必須の）粒度を示す。The section that defines the type attribute's current state also defines the default step, the step scale factor, and in some cases the default step base, which are used in processing the attribute as described below.
The step base is the value returned by the following
algorithm:
If the element has a min content attribute, and the
result of applying the algorithm to convert a
string to a number to the value of the min content
attribute is not an error, then return that result and abort these steps.
If the element does not have a multiple attribute
specified or if the multiple attribute does not apply, then: if the element has a value content attribute, and the result of applying the algorithm to convert a string to a number to
the value of the value content attribute is not an error,
then return that result and abort these steps.
Otherwise, the element's type attribute is in the Range state and the element has a multiple attribute specified: run these substeps:
If the element does not have a value content
attribute, skip these substeps.
If the result of the previous step was not exactly two values, or if either gets an
error when you apply the algorithm to convert
a string to a number, then skip these substeps.
Return the lower of the two numbers obtained in the previous step, and abort these
steps.
If a default step base is defined for
this element given its type attribute's state, then return
it and abort these steps.
Return zero.
How these range limitations apply depends on whether the element has a multiple attribute.
The suggestions source element is the first element in
the document in tree order to have an ID equal to the
value of the list attribute, if that element is a
datalist element. If there is no list attribute,
or if there is no element with that ID, or if the first element
with that ID is not a datalist element, then there is
no suggestions source element.
If there is a suggestions source element, then, when
the user agent is allowing the user to edit the input element's value, the user agent should offer the suggestions represented by
the suggestions source element to the user in a manner
suitable for the type of control used. The user agent may use the suggestion's label to identify the suggestion if appropriate.
How user selections of suggestions are handled depends on whether the element is a control
accepting a single value only, or whether it accepts multiple values:
When the user selects a suggestion, the input element's value must be set to the selected suggestion's value, as if the user had written that value himself.
If the element's type attribute is in the Range state and the element has a multiple attribute specified
When the user selects a suggestion, the user agent must identify which value in the element's
values the user intended to update, and must then update
the element's values so that the relevant value is
changed to the value given by the selected suggestion's value, as if the user had himself set it to that value.
If the element's type attribute is in the Email state and the element has a multiple attribute specified
When the user selects a suggestion, the user agent must either add a new entry to the
input element's values, whose value
is the selected suggestion's value, or change an
existing entry in the input element's values to have the value given by the selected
suggestion's value, as if the user had himself added
an entry with that value, or edited an existing entry to be that value. Which behavior is to be
applied depends on the user interface in a user-agent-defined manner.
User agents should present this hint to the user, after having stripped line breaks from it, when the element's value is the empty string or the control is not focused (or both),
e.g. by displaying it inside a blank unfocused control and hiding it otherwise.
The value IDL attribute allows scripts to
manipulate the value of an input element. The
attribute is in one of the following modes, which define its behavior:
value
On getting, it must return the current value of the
element. On setting, it must set the element's value to
the new value, set the element's dirty value
flag to true, invoke the value sanitization algorithm, if the element's
type attribute's current state defines one, and then, if
the element has a text entry cursor position, should move the text entry cursor position to the
end of the text field, unselecting any selected text and resetting the selection direction to
none.
default
On getting, if the element has a value attribute, it
must return that attribute's value; otherwise, it must return the empty string. On setting, it
must set the element's value attribute to the new
value.
default/on
On getting, if the element has a value attribute, it
must return that attribute's value; otherwise, it must return the string "on". On setting, it must set the element's value attribute to the new value.
filename
On getting, it must return the string "C:\fakepath\" followed by the
name of the first file in the list of selected
files, if any, or the empty string if the list is empty. On setting, if the new value is
the empty string, it must empty the list of selected files; otherwise, it must throw an
InvalidStateError exception.
Since path components are not
permitted in file names in the list of selected
files, the "\fakepath\" cannot be mistaken for a path component.
The checked IDL attribute allows scripts to
manipulate the checkedness of an input
element. On getting, it must return the current checkedness of the element; and on setting, it must set the
element's checkedness to the new value and set the
element's dirty checkedness flag to
true.
The files IDL attribute allows scripts to
access the element's selected files. On
getting, if the IDL attribute applies, it must return a
FileList object that represents the current selected files. The same object must be returned
until the list of selected files changes. If
the IDL attribute does not apply, then it must instead return
null. [FILEAPI]
The valueAsDate IDL attribute represents
the value of the element, interpreted as a date.
On setting, if the valueAsDate attribute does not apply, as defined for the input element's type attribute's current state, then throw an
InvalidStateError exception; otherwise, if the new value is null or a
Date object representing the NaN time value, then set the value of the element to the empty string; otherwise, run the
algorithm to convert a Date object to
a string, as defined for that state, on the new value, and set the value of the element to the resulting string.
The valueAsNumber IDL attribute
represents the value of the element, interpreted as a
number.
On getting, if the valueAsNumber attribute does not apply, as defined for the input element's type attribute's current state, then return a Not-a-Number (NaN)
value. Otherwise, if the valueAsDate
attribute applies, run the algorithm to convert a string to a Date
object defined for that state to the element's value; if the algorithm returned a Date object, then
return the time value of the object (the number of milliseconds from midnight UTC the
morning of 1970-01-01 to the time represented by the Date object), otherwise, return
a Not-a-Number (NaN) value. Otherwise, run the algorithm to convert a string to a number
defined for that state to the element's value; if the
algorithm returned a number, then return it, otherwise, return a Not-a-Number (NaN) value.
On setting, if the new value is infinite, then throw a TypeError exception.
Otherwise, if the valueAsNumber attribute does not apply, as defined for the input element's type attribute's current state, then throw an
InvalidStateError exception. Otherwise, if the new value is a Not-a-Number (NaN)
value, then set the value of the element to the empty
string. Otherwise, if the valueAsDate
attribute applies, run the algorithm to convert a Date object to a
string defined for that state, passing it a Date object whose time
value is the new value, and set the value of the
element to the resulting string. Otherwise, run the algorithm to convert a number to a string, as
defined for that state, on the new value, and set the value
of the element to the resulting string.
The valueLow and valueHigh IDL attributes represent the value of the element, interpreted as a comma-separated pair of
numbers.
On getting, if the attributes do not apply, as defined for the input
element's type attribute's current state, then return zero;
otherwise, run the following steps:
If the attribute in question is valueLow, return
the lowest of the values in values; otherwise, return the highest of the
values in values.
On setting, if the attributes do not apply, as defined for the input
element's type attribute's current state, then throw an
InvalidStateError exception. Otherwise, run the following steps:
If the attribute in question is valueLow, replace
the lower value in values with new value; otherwise,
replace the higher value in values with new
value.
If the element has a minimum and a maximum and there is no value greater than or equal to the
element's minimum and less than or equal to the element's
maximum that, when subtracted from the step base, is an integral multiple of the allowed value step, then abort these steps.
If applying the algorithm to convert a
string to a number to the string given by the element's value does not result in an error, then let value be the result of that algorithm. Otherwise, let value
be zero.
If value subtracted from the step
base is not an integral multiple of the allowed value
step, then set value to the nearest value that, when subtracted from
the step base, is an integral multiple of the allowed value step, and that is less than value if the method invoked was the stepDown() and more than value
otherwise.
Otherwise (value subtracted from the step base is an integral multiple of the allowed value step), run the following substeps:
If the method invoked was the stepDown() method,
negate delta.
Let value be the result of adding delta to value.
If the element has a minimum, and value is less than that minimum, then set
value to the smallest value that, when subtracted from the step base, is an integral multiple of the allowed value step, and that is more than or equal to minimum.
If the element has a maximum, and value is greater than that maximum, then
set value to the largest value that, when subtracted from the step base, is an integral multiple of the allowed value step, and that is less than or equal to maximum.
When the input and change events apply
(which is the case for all input controls other than buttons and those with the type attribute in the Hidden state), the events are fired to indicate that the
user has interacted with the control. The input
event fires whenever the user has modified the data of the control. The change event fires when the value is committed, if
that makes sense for the control, or else when the control loses focus. In all cases, the input event comes before the corresponding change event (if any).
When an input element has a defined activation behavior, the rules
for dispatching these events, if they apply, are given
in the section above that defines the type attribute's
state. (This is the case for all input controls with the type attribute in the Checkbox state, the Radio Button state, or the File Upload state.)
For input elements without a defined activation behavior, but to
which these events apply, and for which the user
interface involves both interactive manipulation and an explicit commit action, then when the user
changes the element's value, the user agent must
queue a task to fire a simple event that bubbles named input at the input element, and any time the user
commits the change, the user agent must queue a task to fire a simple
event that bubbles named change at the
input element.
An example of a user interface involving both interactive manipulation and a
commit action would be a Range controls that use a
slider, when manipulated using a pointing device. While the user is dragging the control's knob,
input events would fire whenever the position changed,
whereas the change event would only fire when the user
let go of the knob, committing to a specific value.
For input elements without a defined activation behavior, but to
which these events apply, and for which the user
interface involves an explicit commit action but no intermediate manipulation, then any time the
user commits a change to the element's value, the user
agent must queue a task to first fire a simple event that bubbles named
input at the input element, and then
fire a simple event that bubbles named change at the input element.
An example of a user interface with a commit action would be a Color control that consists of a single button that brings
up a color wheel: if the value only changes when the dialog
is closed, then that would be the explicit commit action. On the other hand, if the control can be
focused and manipulating the control changes the color interactively, then there might be no
commit action.
Another example of a user interface with a commit action would be a Date control that allows both text-based user input and user
selection from a drop-down calendar: while text input might not have an explicit commit step,
selecting a date from the drop down calendar and then dismissing the drop down would be a commit
action.
Examples of a user changing the element's value would include the user typing into a text field, pasting a
new value into the field, or undoing an edit in that field. Some user interactions do not cause
changes to the value, e.g. hitting the "delete" key in an empty text field, or replacing some text
in the field with text from the clipboard that happens to be exactly the same text.
A Range control in the form of a
slider that the user has focused and is interacting with using a keyboard would be
another example of the user changing the element's value
without a commit step.
In the case of tasks that just fire an input event, user agents may wait for a suitable break in the
user's interaction before queuing the tasks; for example, a
user agent could wait for the user to have not hit a key for 100ms, so as to only fire the event
when the user pauses, instead of continuously for each keystroke.
These events are not fired in response to changes made to the values of form
controls by scripts. (This is to make it easier to update the values of form controls in response
to the user manipulating the controls, without having to then filter out the script's own changes
to avoid an infinite loop.)
When a button element is not disabled,
its activation behavior element is to run the steps defined in the following list for
the current state of the element's type attribute:
A button element's designated pop-up menu is the first element in the
button's home subtree whose ID is that given by the button
element's menu attribute, if there is such an element and
its type attribute is in the popup menu state; otherwise, the element has no designated pop-up
menu.
The value and menu IDL attributes must reflect the
content attributes of the same name.
The display size of a select element is the
result of applying the rules for parsing non-negative integers to the value of
element's size attribute, if it has one and parsing it is
successful. If applying those rules to the attribute's value is not successful, or if the size attribute is absent, then the element's display size is 4 if the element's multiple content attribute is present, and 1 otherwise.
If the multiple attribute is absent, and the element
is not disabled, then the user agent should allow the
user to pick an option element in its list
of options that is itself not disabled. Upon
this option element being picked (either
through a click, or through unfocusing the element after changing its value, or through a menu command, or through any other mechanism), and before the
relevant user interaction event is queued (e.g. before the
click event), the user agent must set the selectedness of the picked option element
to true, set its dirtiness to true, and then
send select update notifications.
If the multiple attribute is absent and the
element's display size is greater than 1, then the user
agent should also allow the user to request that the option whose selectedness is true, if any, be unselected. Upon this
request being conveyed to the user agent, and before the relevant user interaction event is queued (e.g. before the click event), the user agent must set the selectedness of that option element to
false, set its dirtiness to true, and then
send select update notifications.
If the multiple attribute is present, and the
element is not disabled, then the user agent should
allow the user to toggle the selectedness of the option elements in
its list of options that are themselves not disabled. Upon such an element being toggled (either through a click, or through a menu command, or any other mechanism), and before the relevant user
interaction event is queued (e.g. before a related click event), the selectedness of the option element must
be changed (from true to false or false to true), the dirtiness of the element must be set to true, and the
user agent must send select update notifications.
The type IDL attribute, on getting, must
return the string "select-one" if the multiple attribute is absent, and the string "select-multiple" if the multiple
attribute is present.
The length IDL attribute must return the
number of nodes represented by the options collection. On setting, it must act like the attribute
of the same name on the options collection.
The item(index) method
must return the value returned by the method of the same
name on the options collection, when invoked with
the same argument.
The namedItem(name)
method must return the value returned by the
method of the same name on the options collection,
when invoked with the same argument.
When the user agent is to set the value of a new
indexed property for a given property index index to a new value value, it must instead set the
value of a new indexed property with the given property index index to
the new value value on the options
collection.
Similarly, the add() method must act like its
namesake method on that same options collection.
The remove() method must act like its
namesake method on that same options collection when it
has arguments, and like its namesake method on the ChildNode interface implemented by
the HTMLSelectElement ancestor interface Element when it has no
arguments.
The selectedOptions IDL attribute
must return an HTMLCollection rooted at the select node, whose filter
matches the elements in the list of options that
have their selectedness set to true.
The selectedIndex IDL attribute, on
getting, must return the index of the first
option element in the list of
options in tree order that has its selectedness set to true, if any. If there isn't one,
then it must return −1.
This can result in no element having a selectedness set to true even in the case of the
select element having no multiple
attribute and a display size of 1.
The value IDL attribute, on getting, must
return the value of the first option
element in the list of options in tree
order that has its selectedness set to
true, if any. If there isn't one, then it must return the empty string.
This can result in no element having a selectedness set to true even in the case of the
select element having no multiple
attribute and a display size of 1.
The multiple, required, and size IDL attributes must reflect the
respective content attributes of the same name. The size IDL
attribute has a default value of zero.
For historical reasons, the default value of the size IDL attribute does not return the actual size used, which, in
the absence of the size content attribute, is either 1 or 4
depending on the presence of the multiple
attribute.
<p>
<label for="allowedunits">Select unit types to enable on this map:</label>
<select id="allowedunits" name="allowedunits" multiple>
<option value="1" selected> Miner </option>
<option value="2" selected> Puffer </option>
<option value="3" selected> Snipey </option>
<option value="4" selected> Max </option>
<option value="5" selected> Firebot </option>
</select>
</p>
ときには、ユーザーは1つ以上の項目を選択する必要がある。次の例はそのようなインターフェースを示す。
<p>Select the songs from that you would like on your Act II Mix Tape:</p>
<select multiple required name="act2">
<option value="s1">It Sucks to Be Me (Reprise)
<option value="s2">There is Life Outside Your Apartment
<option value="s3">The More You Ruv Someone
<option value="s4">Schadenfreude
<option value="s5">I Wish I Could Go Back to College
<option value="s6">The Money Song
<option value="s7">School for Monsters
<option value="s8">The Money Song (Reprise)
<option value="s9">There's a Fine, Fine Line (Reprise)
<option value="s10">What Do You Do With a B.A. in English? (Reprise)
<option value="s11">For Now
</select>
datalist要素は、他のコントロール用にあらかじめ定義されたオプションを表すoption要素のセットを表す。In the rendering, the datalist element represents nothing and it, along with its children, should be hidden.
An optgroup element's end tag may be omitted
if the optgroup element is
immediately followed by another optgroup element, or if there is no more content in
the parent element.
When showing option elements in select elements, user agents should
show the option elements of such groups as being related to each other and separate
from other option elements.
label属性を指定しなければならない。その値は、ユーザーインターフェースの目的に対して、グループの名前を与える。User agents should use this attribute's value when labeling the group of option elements in a select element.
The disabled and label attributes must reflect the
respective content attributes of the same name.
The dirtiness of an option element is
a boolean state, initially false. It controls whether adding or removing the selected content attribute has any effect.
The selectedness of an option
element is a boolean state, initially false. Except where otherwise specified, when the element is
created, its selectedness must be set to true if
the element has a selected attribute. Whenever an
option element's selected attribute is
added, if its dirtiness is false, its selectedness must be set to true. Whenever an
option element's selected attribute is
removed, if its dirtiness is false, its
selectedness must be set to false.
The Option() constructor, when called with three
or fewer arguments, overrides the initial state of the selectedness state to always be false even if the third
argument is true (implying that a selected attribute is
to be set). The fourth argument can be used to explicitly set the initial selectedness state when using the constructor.
The disabled IDL attribute must
reflect the content attribute of the same name. The defaultSelected IDL attribute must
reflect the selected content attribute.
The label IDL attribute, on getting, must
return the element's label. On setting, the element's
label content attribute must be set to the new value.
The value IDL attribute, on getting, must
return the element's value. On setting, the element's
value content attribute must be set to the new value.
The selected IDL attribute, on getting,
must return true if the element's selectedness
is true, and false otherwise. On setting, it must set the element's selectedness to the new value, set its dirtiness to true, and then cause the element to
ask for a reset.
The index IDL attribute must return the
element's index.
On setting, the text attribute must act as if the
textContent IDL attribute on the element had been set to the new value.
The form IDL attribute's behavior depends on
whether the option element is in a select element or not. If the
option has a select element as its parent, or has an
optgroup element as its parent and that optgroup element has a
select element as its parent, then the form IDL
attribute must return the same value as the form IDL attribute
on that select element. Otherwise, it must return null.
A constructor is provided for creating HTMLOptionElement objects (in addition to
the factory methods from DOM such as createElement()): Option(text, value, defaultSelected, selected). When invoked as a
constructor, it must return a new HTMLOptionElement object (a new option
element). If the first argument is not the empty string, the new object must have as its only
child a Text node whose data is the value of that argument. Otherwise, it must have
no children. If the value argument is present, the new object must have a
value attribute set with the value of the argument as its
value. If the defaultSelected argument is true, the new object must have a
selected attribute set with no value. If the selected argument is true, the new object must have its selectedness set to true; otherwise the selectedness must be set to false, even if the defaultSelected argument is true. The element's document must be the active
document of the browsing context of the Window object on which
the interface object of the invoked constructor is found.
Filename: <code>/etc/bash.bashrc</code>
<textarea name="buffer" readonly>
# System-wide .bashrc file for interactive bash(1) shells.
# To enable the settings / commands in this file for login shells as well,
# this file has to be sourced in /etc/profile.
# If not running interactively, don't do anything
[ -z "$PS1" ] && return
...</textarea>
When a textarea is mutable, its raw value should be editable by the user: the user agent
should allow the user to edit, insert, and remove text, and to insert and remove line breaks in
the form of "LF" (U+000A) characters. Any time the user causes the element's raw value to change, the user agent must queue a
task to fire a simple event that bubbles named input at the textarea element. User agents may wait for a
suitable break in the user's interaction before queuing the task; for example, a user agent could
wait for the user to have not hit a key for 100ms, so as to only fire the event when the user
pauses, instead of continuously for each keystroke.
A textarea element has a dirty value
flag, which must be initially set to false, and must be set to true whenever the user
interacts with the control in a way that changes the raw
value.
If the element is mutable, the user agent should allow
the user to change the writing direction of the element, setting it either to a left-to-right
writing direction or a right-to-left writing direction. If the user does so, the user agent must
then run the following steps:
Set the element's dir attribute to "ltr" if the user selected a left-to-right writing direction, and
"rtl" if the user selected a right-to-left writing
direction.
cols属性は行あたりの予想最大文字数を指定する。cols属性が指定される場合、その値は0より大きい妥当な非負整数でなければならない。If applying the rules for parsing non-negative integers to the attribute's value results in a number greater than zero, then the element's character width is that value; otherwise, it is 20.
The user agent may use the textarea element's character width as a hint to the user as to how many
characters the server prefers per line (e.g. for visual user agents by making the width of the
control be that many characters). In visual renderings, the user agent should wrap the user's
input in the rendering so that each line is no wider than this number of characters.
rows属性は、表示する行数を指定する。rows属性が指定される場合、その値は0より大きい妥当な非負整数でなければならない。If applying the rules for parsing non-negative integers to the attribute's value results in a number greater than zero, then the element's character height is that value; otherwise, it is 2.
Visual user agents should set the height of the control to the number of lines given by character height.
For historical reasons, the element's value is normalised in three different ways for three
different purposes. The raw value is the value as
it was originally set. It is not normalized. The API
value is the value used in the value IDL
attribute. It is normalised so that line breaks use "LF" (U+000A) characters. Finally,
there is the value, as used in form submission and other
processing models in this specification. It is normalised so that line breaks use U+000D CARRIAGE
RETURN "CRLF" (U+000A) character pairs, and in addition, if necessary given the element's
wrap attribute, additional line breaks are inserted to
wrap the text at the given width.
The element's API value is defined to be the
element's raw value with the following
transformation applied:
Replace every U+000D CARRIAGE RETURN "CRLF" (U+000A) character pair from the raw value with a single "LF" (U+000A)
character.
Replace every remaining U+000D CARRIAGE RETURN character from the raw value with a single "LF" (U+000A)
character.
The element's value is defined to be the element's raw value with the textarea wrapping
transformation applied. The textarea wrapping transformation is the following
algorithm, as applied to a string:
Replace every occurrence of a "CR" (U+000D) character not followed by a
"LF" (U+000A) character, and every occurrence of a "LF" (U+000A) character not
preceded by a "CR" (U+000D) character, by a two-character string consisting of a
U+000D CARRIAGE RETURN "CRLF" (U+000A) character pair.
If the element's wrap attribute is in the Hard state, insert U+000D CARRIAGE RETURN "CRLF" (U+000A) character pairs into the string using a UA-defined algorithm so that each line
has no more than character width characters. For
the purposes of this requirement, lines are delimited by the start of the string, the end of the
string, and U+000D CARRIAGE RETURN "CRLF" (U+000A) character pairs.
Constraint validation: If the element has its required attribute specified, and the element is mutable, and the element's value is the empty string, then the element is suffering
from being missing.
User agents should present this hint to the user when the element's value is the empty string and the control is not
focused (e.g. by displaying it inside a blank unfocused control). All U+000D CARRIAGE
RETURN U+000A LINE FEED character pairs (CRLF) in the hint, as well as all other "CR" (U+000D) and "LF" (U+000A) characters in the hint, must be treated as line breaks when
rendering the hint.
The type IDL attribute must return the value
"textarea".
The defaultValue IDL attribute must
act like the element's textContent IDL attribute.
The value attribute must, on getting, return
the element's API value; on setting, it must set
the element's raw value to the new value, set the
element's dirty value flag to true, and should then
move the text entry cursor position to the end of the text field, unselecting any selected text
and resetting the selection direction to none.
<textarea placeholder="Dear Francine,
They closed the parks this week, so we won't be able to
meet your there. Should we just have dinner?
Love,
Daddy"></textarea>
<p>If you have any comments, please let us know (you may use either English or Hebrew for your comments):
<textarea cols=80 name=comments dirname=comments.dir></textarea></p>
The user agent may expose a user interface for each keygen element to allow the
user to configure settings of the element's key pair generator, e.g. the key length.
The reset algorithm for keygen
elements is to set these various configuration settings back to their defaults.
The element's value is the string returned from the
following algorithm:
Generate an RSA key pair using the settings given by the user, if appropriate, using the
md5WithRSAEncryption RSA signature algorithm (the signature algorithm
with MD5 and the RSA encryption algorithm) referenced in section 2.2.1 ("RSA Signature
Algorithm") of RFC 3279, and defined in RFC 2313. [RFC3279][RFC2313]
Otherwise, the keytype attribute is in the unknown state
The given key type is not supported. Return the empty string and abort this algorithm.
Let private key be the generated private key.
Let public key be the generated public key.
Let signature algorithm be the selected signature algorithm.
If the element has a challenge attribute, then let
challenge be that attribute's value. Otherwise, let challenge be the empty string.
Let algorithm be an ASN.1 AlgorithmIdentifier
structure as defined by RFC 5280, with the algorithm field giving the
ASN.1 OID used to identify signature algorithm, using the OIDs defined in
section 2.2 ("Signature Algorithms") of RFC 3279, and the parameters field
set up as required by RFC 3279 for AlgorithmIdentifier structures for that
algorithm. [X690][RFC5280][RFC3279]
Let spki be an ASN.1 SubjectPublicKeyInfo structure
as defined by RFC 5280, with the algorithm field set to the algorithm structure from the previous step, and the subjectPublicKey field set to the BIT STRING value resulting from ASN.1 DER
encoding the public key. [X690][RFC5280]
Let publicKeyAndChallenge be an ASN.1 PublicKeyAndChallenge
structure as defined below, with the spki field set to the spki structure from the previous step, and the challenge
field set to the string challenge obtained earlier. [X690]
Let signature be the BIT STRING value resulting from ASN.1 DER encoding
the signature generated by applying the signature algorithm to the byte
string obtained by ASN.1 DER encoding the publicKeyAndChallenge structure,
using private key as the signing key. [X690]
Let signedPublicKeyAndChallenge be an ASN.1
SignedPublicKeyAndChallenge structure as defined below, with the publicKeyAndChallenge field set to the publicKeyAndChallenge
structure, the signatureAlgorithm field set to the algorithm structure, and the signature field set to the BIT
STRING signature from the previous step. [X690]
Return the result of base64 encoding the result of ASN.1 DER encoding the signedPublicKeyAndChallenge structure. [RFC4648][X690]
The data objects used by the above algorithm are defined as follows. These definitions use the
same "ASN.1-like" syntax defined by RFC 5280. [RFC5280]
The element has a value mode flag which is either value or default.
Initially, the value mode flag must be set to default.
The element also has a default value. Initially,
the default value must be the empty string.
When the value mode flag is in mode default, the contents of the element represent both the
value of the element and its default value. When
the value mode flag is in mode value, the contents of the element represent the value of
the element only, and the default value is only
accessible using the defaultValue IDL attribute.
Whenever the element's descendants are changed in any way, if the value mode flag is in mode default, the element's default value must be set to the value of the element's
textContent IDL attribute.
The value IDL attribute must act like the
element's textContent IDL attribute, except that on setting, in addition, before the
child nodes are changed, the element's value mode flag
must be set to value.
The defaultValue IDL attribute, on
getting, must return the element's default value.
On setting, the attribute must set the element's default
value, and, if the element's value mode flag is in
the mode default, set the element's
textContent IDL attribute as well.
The type attribute must return the string
"output".
The htmlFor IDL attribute must
reflect the for content attribute.
User agent requirements: If the value
attribute is omitted, then the progress bar is an indeterminate progress bar. Otherwise, it is a
determinate progress bar.
If the progress bar is a determinate progress bar and the element has a max attribute, the user agent must parse the max attribute's value according to the rules for parsing
floating-point number values. If this does not result in an error, and if the parsed value
is greater than zero, then the maximum value of the
progress bar is that value. Otherwise, if the element has no max attribute, or if it has one but parsing it resulted in an
error, or if the parsed value was less than or equal to zero, then the maximum value of the progress bar is 1.0.
If the progress bar is a determinate progress bar, user agents must parse the value attribute's value according to the rules for
parsing floating-point number values. If this does not result in an error, and if the
parsed value is less than the maximum value and
greater than zero, then the current value of the
progress bar is that parsed value. Otherwise, if the parsed value was greater than or equal to the
maximum value, then the current value of the progress bar is the maximum value of the progress bar. Otherwise, if parsing
the value attribute's value resulted in an error, or a
number less than or equal to zero, then the current
value of the progress bar is zero.
UA requirements for showing the progress bar: When representing a
progress element to the user, the UA should indicate whether it is a determinate or
indeterminate progress bar, and in the former case, should indicate the relative position of the
current value relative to the maximum value.
If the progress bar is an indeterminate progress bar, then the position IDL attribute must return −1.
Otherwise, it must return the result of dividing the current
value by the maximum value.
If the progress bar is an indeterminate progress bar, then the value IDL attribute, on getting, must return 0.
Otherwise, it must return the current value. On
setting, the given value must be converted to the best representation of the number as a
floating-point number and then the value content
attribute must be set to that string.
Setting the value IDL attribute to itself
when the corresponding content attribute is absent would change the progress bar from an
indeterminate progress bar to a determinate progress bar with no progress.
<p>The grapefruit pie had a radius of 12cm and a height of
2cm.</p>
<dl>
<dt>Radius: <dd> <meter min=0 max=20 value=12>12cm</meter>
<dt>Height: <dd> <meter min=0 max=10 value=2>2cm</meter>
</dl>
User agents must then use all these numbers to obtain values for six points on the gauge, as
follows. (The order in which these are evaluated is important, as some of the values refer to
earlier ones.)
The minimum value
If the min attribute is specified and a value could be
parsed out of it, then the minimum value is that value. Otherwise, the minimum value is
zero.
The maximum value
If the max attribute is specified and a value could be
parsed out of it, then the candidate maximum value is that value. Otherwise, the candidate
maximum value is 1.0.
If the candidate maximum value is greater than or equal to the minimum value, then the
maximum value is the candidate maximum value. Otherwise, the maximum value is the same as the
minimum value.
The actual value
If the value attribute is specified and a value could
be parsed out of it, then that value is the candidate actual value. Otherwise, the candidate
actual value is zero.
If the candidate actual value is less than the minimum value, then the actual value is the
minimum value.
Otherwise, if the candidate actual value is greater than the maximum value, then the actual
value is the maximum value.
Otherwise, the actual value is the candidate actual value.
The low boundary
If the low attribute is specified and a value could be
parsed out of it, then the candidate low boundary is that value. Otherwise, the candidate low
boundary is the same as the minimum value.
If the candidate low boundary is less than the minimum value, then the low boundary is the
minimum value.
Otherwise, if the candidate low boundary is greater than the maximum value, then the low
boundary is the maximum value.
Otherwise, the low boundary is the candidate low boundary.
The high boundary
If the high attribute is specified and a value could be
parsed out of it, then the candidate high boundary is that value. Otherwise, the candidate high
boundary is the same as the maximum value.
If the candidate high boundary is less than the low boundary, then the high boundary is the
low boundary.
Otherwise, if the candidate high boundary is greater than the maximum value, then the high
boundary is the maximum value.
Otherwise, the high boundary is the candidate high boundary.
The optimum point
If the optimum attribute is specified and a value
could be parsed out of it, then the candidate optimum point is that value. Otherwise, the
candidate optimum point is the midpoint between the minimum value and the maximum value.
If the candidate optimum point is less than the minimum value, then the optimum point is the
minimum value.
Otherwise, if the candidate optimum point is greater than the maximum value, then the optimum
point is the maximum value.
Otherwise, the optimum point is the candidate optimum point.
All of which will result in the following inequalities all being true:
minimum value ≤ actual value ≤ maximum value
minimum value ≤ low boundary ≤ high boundary ≤ maximum value
minimum value ≤ optimum point ≤ maximum value
UA requirements for regions of the gauge: If the optimum point is equal to the
low boundary or the high boundary, or anywhere in between them, then the region between the low
and high boundaries of the gauge must be treated as the optimum region, and the low and high
parts, if any, must be treated as suboptimal. Otherwise, if the optimum point is less than the low
boundary, then the region between the minimum value and the low boundary must be treated as the
optimum region, the region from the low boundary up to the high boundary must be treated as a
suboptimal region, and the remaining region must be treated as an even less good region. Finally,
if the optimum point is higher than the high boundary, then the situation is reversed; the region
between the high boundary and the maximum value must be treated as the optimum region, the region
from the high boundary down to the low boundary must be treated as a suboptimal region, and the
remaining region must be treated as an even less good region.
UA requirements for showing the gauge: When representing a meter
element to the user, the UA should indicate the relative position of the actual value to the
minimum and maximum values, and the relationship between the actual value and the three regions of
the gauge.
User agents may combine the value of the title attribute and the other attributes to provide context-sensitive
help or inline text detailing the actual values.
<fieldset name="clubfields" disabled>
<legend> <label>
<input type=checkbox name=club onchange="form.clubfields.disabled = !checked">
Use Club Card
</label> </legend>
<p><label>Name on card: <input name=clubname required></label></p>
<fieldset name="numfields">
<legend> <label>
<input type=radio checked name=clubtype onchange="form.numfields.disabled = !checked">
My card has numbers on it
</label> </legend>
<p><label>Card number: <input name=clubnum required pattern="[-0-9]+"></label></p>
</fieldset>
<fieldset name="letfields" disabled>
<legend> <label>
<input type=radio name=clubtype onchange="form.letfields.disabled = !checked">
My card has letters on it
</label> </legend>
<p><label>Card code: <input name=clublet required pattern="[A-Za-z]+"></label></p>
</fieldset>
</fieldset>
この例において、外側の"Use Club Card"チェックボックスがチェックされない場合、2つのネストされたfieldsetのlegendで2つのラジオボタンを含む、外側のfieldset内部のすべては無効になる。しかし、チェックボックスがチェックされる場合、ラジオボタンが両方とも有効に設定され、有効にするよう2つの内部fieldsetのどちらが選択できるようになる。
The form IDL attribute's behavior depends on
whether the legend element is in a fieldset element or not. If the
legend has a fieldset element as its parent, then the form IDL attribute must return the same value as the form IDL attribute on that fieldset element. Otherwise,
it must return null.
A form-associated element is, by default, associated with its nearest ancestor form element (as described
below), but, if it is reassociateable, may have a
form attribute specified to override this.
The rules in this section are complicated by the fact that although conforming
documents will never contain nested form elements, it is quite possible (e.g. using a
script that performs DOM manipulation) to generate documents that have such nested elements. They
are also complicated by rules in the HTML parser that, for historical reasons, can result in a
form-associated element being associated with a form element that is not
its ancestor.
When the user agent is to reset the form owner of a form-associated
element, it must run the following steps:
If the element's form owner is not null, and either the element is not reassociateable or its form content attribute is not present, and the element's form
owner is its nearest form element ancestor after the change to the ancestor
chain, then do nothing, and abort these steps.
The form owner of "d" would be the inner nested form "c", while the form
owner of "e" would be the outer form "a".
This happens as follows: First, the "e" node gets associated with "c" in the HTML
parser. Then, the innerHTML algorithm moves the nodes
from the temporary document to the "b" element. At this point, the nodes see their ancestor chain
change, and thus all the "magic" associations done by the parser are reset to normal ancestor
associations.
This example is a non-conforming document, though, as it is a violation of the content models
to nest form elements.
<form action="/events/menu.cgi" method="post">
<p><label>Name of Event: <input required minlength=5 maxlength=50 name=event></label></p>
<p><label>Describe what you would like for breakfast, if anything:
<textarea name="breakfast" minlength="10"></textarea></label></p>
<p><label>Describe what you would like for lunch, if anything:
<textarea name="lunch" minlength="10"></textarea></label></p>
<p><label>Describe what you would like for dinner, if anything:
<textarea name="dinner" minlength="10"></textarea></label></p>
<p><input type=submit value="Submit Request"></p>
</form>
The action IDL attribute must
reflect the content attribute of the same name, except that on getting, when the
content attribute is missing or its value is the empty string, the document's address
must be returned instead. The target IDL attribute
must reflect the content attribute of the same name. The method and enctype IDL attributes must reflect the
respective content attributes of the same name, limited to only known values. The
encoding IDL attribute must reflect
the enctype content attribute, limited to only known
values. The noValidate IDL attribute must
reflect the novalidate content attribute. The
formAction IDL attribute must
reflect the formaction content attribute,
except that on getting, when the content attribute is missing or its value is the empty string,
the document's address must be returned instead. The formEnctype IDL attribute must reflect
the formenctype content attribute, limited to only
known values. The formMethod IDL
attribute must reflect the formmethod content
attribute, limited to only known values. The formNoValidate IDL attribute must
reflect the formnovalidate content
attribute. The formTarget IDL attribute must
reflect the formtarget content attribute.
If the user has indicated (for example, by starting to type in a form control) that he
does not wish focus to be changed, then optionally abort these steps.
Queue a task that checks to see if the element is focusable, and
if so, runs the focusing steps for that element. User agents may also change the
scrolling position of the document, or perform some other action that brings the element to the
user's attention. The task source for this task is the user interaction task
source.
This handles the automatic focusing during document load. The show() and showModal()
methods of dialog elements also processes the autofocus attribute.
Focusing the control does not imply that the user agent must focus the browser
window if it has lost focus.
The autofocus IDL attribute must
reflect the content attribute of the same name.
User agents must recognise all the keywords and corresponding states given below, but need not
support all of the corresponding states. If a keyword's state is not supported, the user agent
must act as if the keyword instead mapped to the given state's fallback state, as defined below.
This fallback behaviour is transitive.
For example, if a user agent with a QWERTY keyboard layout does not support text
prediction and automatic capitalization, then it could treat the latin-prose keyword in the same way as the
verbatim keyword, following the chain
Latin Prose → Latin Text → Latin Verbatim.
User agents must all support the Default input mode state, which corresponds to the
user agent's default input modality. This specification does not define how the
user agent's default modality is to operate. The missing value default is the default input mode state.
User agents should use the input modality corresponding to the state of the inputmode attribute when exposing a user interface for editing
the value of a form control to which the attribute applies. An input modality corresponding to a state is one
designed to fit the description of the state in the table above. This value can change
dynamically; user agents should update their interface as the attribute changes state, unless that
would go against the user's wishes.
The autofill scope identifies the group of fields that are to be filled with the
information from the same source, and consists of the autofill hint set with, if
applicable, the "section-*" prefix, e.g. "billing", "section-parent shipping", or "section-child
shipping home".
These values are defined as the result of running the following algorithm:
If the element has no autocomplete attribute,
then jump to the step labeled default.
If tokens is empty, then jump to the step labeled
default.
Let index be the index of the last token in tokens.
If the indexth token in tokens is not an ASCII
case-insensitive match for one of the tokens given in the first column of the following
table, or if the number of tokens in tokens is greater than the maximum
number given in the cell in the second column of that token's row, then jump to the step labeled
default. Otherwise, let field be the string given in the cell of the
first column of the matching row, and let category be the value of the cell
in the third column of that same row.
If the indexth token in tokens is the first entry,
then skip to the step labeled done.
Decrement index by one.
If category is Contact and the indexth token in tokens is an ASCII case-insensitive match for one of the strings in
the following list, then run the substeps that follow:
Let contact be the matching string from the list above.
Insert contact at the start of scope
tokens.
Add contact to hint tokens.
Let IDL value be the concatenation of contact, a
U+0020 SPACE character, and the previous value of IDL value (which at this
point will always be field).
If the indexth entry in tokens is the first
entry, then skip to the step labeled done.
Decrement index by one.
If the indexth token in tokens is an ASCII
case-insensitive match for one of the strings in the following list, then run the
substeps that follow:
Let mode be the matching string from the list above.
Insert mode at the start of scope
tokens.
Add mode to hint tokens.
Let IDL value be the concatenation of mode, a
U+0020 SPACE character, and the previous value of IDL value (which at this
point will either be field or the concatenation of contact, a space, and field).
If the indexth entry in tokens is the first
entry, then skip to the step labeled done.
Decrement index by one.
If the indexth entry in tokens is not the first
entry, then jump to the step labeled default.
If the first eight characters of the indexth token in tokens are not an ASCII case-insensitive match for the string "section-", then jump to the step labeled
default.
Suppose that on the first visit to this page, the user selects "Zambia". On the second visit,
the user agent could duplicate the entry for Zambia at the top of the list, so that the interface
instead looks like this:
When the autofill field name is "on", the user agent should attempt to use heuristics to
determine the most appropriate values to offer the user, e.g. based on the element's name value, the position of the element in the document's DOM, what
other fields exist in the form, and so forth.
When the user agent autofills form controls, elements
with the same form owner and the same autofill scope must use data
relating to the same person, address, payment instrument, and contact details. When a user agent autofills "country" and "country-name" fields with the same form
owner and autofill scope, and the user agent has a value for the country" field(s), then the "country-name" field(s) must be filled using a
human-readable name for the same country. When a user agent fills in multiple fields at
once, all fields with the same autofill field name, form owner and
autofill scope must be filled with the same value.
The "section-*" tokens in the autofill scope are opaque;
user agents must not attempt to derive meaning from the precise values of these tokens.
For example, it would not be conforming if the user agent decided that it
should offer the address it knows to be the user's daughter's address for "section-child" and the addresses it knows to be the user's spouses' addresses for
"section-spouse".
The autocompletion mechanism must be implemented by the user agent acting as if the user had modified the control's data, and must be done at a time where the element is mutable (e.g. just after the element has been inserted into the document, or when the user agent stops parsing). ユーザーエージェントは、は、ユーザーが入力したかもしれない値を使用するコントロールのみを事前入力しなければならない。
the user has disabled this feature for this form's
Document's origin
the user agent does not support this form's fields (e.g. the form
has different fields whose autofill scope use different "section-*" tokens)
the form was obtained via unencrypted channels and the user agent
does not support autofill in such situations
another instance of this algorithm is already being run for form
User agents are encouraged to log the precise cause in a developer console, to
aid debugging.
Let pending autofills be an initially empty list of submittable elements, each annotated with a string known as the
original autocomplete value.
For each element that matches the following criteria, add the element to pending autofills, with the original autocomplete value annotation being
the value of the element's autocomplete
attribute:
the element is an input element to which the autocomplete attribute currently applies, or, the element is a textarea
element, or, the element is a select element
When the user agent is required to fail the autofill request on a form
element target with a reason reason, the user agent must
dispatch an event that uses the AutocompleteErrorEvent interface, with the event type
autocompleteerror, which bubbles, is not cancelable, has no default action,
has its reason attribute set to reason, and which is trusted, at target.
The reason attribute must
return the value it was initialised to. When the object is created, this attribute must be
initialised to the empty string. It
represents the context information for the event.
For input elements, calling these methods while they don't apply, and getting or setting these attributes while they don't apply, must throw an InvalidStateError exception. Otherwise, they
must act as described below.
For input elements, these methods and attributes must operate on the element's
value. For textarea elements, these methods and
attributes must operate on the element's raw
value.
Where possible, user interface features for changing the text selection in input
and textarea elements must be implemented in terms of the DOM API described in this
section, so that, e.g., all the same events fire.
The selections of input and textarea elements have a
direction, which is either forward, backward, or none. This direction
is set when the user manipulates the selection. The exact meaning of the selection direction
depends on the platform.
On Windows, the direction indicates the position of the caret relative to the
selection: a forward selection has the caret at the end of the selection and a
backward selection has the caret at the start of the selection. Windows has no none
direction. On Mac, the direction indicates which end of the selection is affected when the user
adjusts the size of the selection using the arrow keys with the Shift modifier: the forward
direction means the end of the selection is modified, and the backwards direction means the start
of the selection is modified. The none direction is the default on Mac, it indicates that no
particular direction has yet been selected. The user sets the direction implicitly when first
adjusting the selection, based on which directional arrow key was used.
The select() method must cause the
contents of the text field to be fully selected, with the selection direction being none, if the
platform support selections with the direction none, or otherwise forward. The user
agent must then queue a task to fire a simple event that bubbles named
select at the element, using the user interaction task
source as the task source.
The selectionStart attribute
must, on getting, return the offset (in logical order) to the character that immediately follows
the start of the selection. If there is no selection, then it must return the offset (in logical
order) to the character that immediately follows the text entry cursor.
On setting, it must act as if the setSelectionRange() method had been called,
with the new value as the first argument; the current value of the selectionEnd attribute as the second argument,
unless the current value of the selectionEnd
is less than the new value, in which case the second argument must also be the new value; and the
current value of the selectionDirection
as the third argument.
The selectionEnd attribute
must, on getting, return the offset (in logical order) to the character that immediately follows
the end of the selection. If there is no selection, then it must return the offset (in logical
order) to the character that immediately follows the text entry cursor.
On setting, it must act as if the setSelectionRange() method had been called,
with the current value of the selectionStart attribute as the first argument,
the new value as the second argument, and the current value of the selectionDirection as the third argument.
The selectionDirection
attribute must, on getting, return the string corresponding to the current selection direction: if
the direction is forward, "forward"; if the direction is
backward, "backward"; and otherwise, "none".
On setting, it must act as if the setSelectionRange() method had been called,
with the current value of the selectionStart attribute as the first argument,
the current value of the selectionEnd
attribute as the second argument, and the new value as the third argument.
The setSelectionRange(start, end, direction) method
must set the selection of the text field to the sequence of characters starting with the character
at the startth position (in logical order) and ending with the character at
the (end-1)th position. Arguments greater than the
length of the value of the text field must be treated as pointing at the end of the text field. If
end is less than or equal to start then the start of the
selection and the end of the selection must both be placed immediately before the character with
offset end. In UAs where there is no concept of an empty selection, this must
set the cursor to be just before the character with offset end. The direction
of the selection must be set to backward if direction is a
case-sensitive match for the string "backward", forward
if direction is a case-sensitive match for the string "forward" or if the platform does not support selections with the direction
none, and none otherwise (including if the argument is omitted). The user agent must
then queue a task to fire a simple event that bubbles named select at the element, using the user interaction task
source as the task source.
The setRangeText(replacement, start, end, selectMode) method must run the following steps:
If the method has only one argument, then let start and end have the values of the selectionStart attribute and the selectionEnd attribute respectively.
Otherwise, let start, end have the values of the
second and third arguments respectively.
If start is greater than end, then throw an
IndexSizeError exception and abort these steps.
If start is greater than the length of the value of the text field,
then set it to the length of the value of the text field.
If end is greater than the length of the value of the text field,
then set it to the length of the value of the text field.
Let selection start be the current value of the selectionStart attribute.
Let selection end be the current value of the selectionEnd attribute.
If start is less than end, delete the sequence of
characters starting with the character at the startth position (in logical
order) and ending with the character at the (end-1)th
position.
Insert the value of the first argument into the text of the value of the text field,
immediately before the startth character.
Let new length be the length of the value of the first argument.
Let new end be the sum of start and new length.
Run the appropriate set of substeps from the following list:
If the fourth argument's value is "select"
Let selection start be start.
Let selection end be new end.
If the fourth argument's value is "start"
Let selection start and selection end be start.
If the fourth argument's value is "end"
Let selection start and selection end be new end.
If the fourth argument's value is "preserve" (the default)
Let old length be end minus start.
Let delta be new length minus old length.
If selection start is greater than end, then
increment it by delta. (If delta is negative, i.e.
the new text is shorter than the old text, then this will decrease the value of
selection start.)
Otherwise: if selection start is greater than start, then set it to start. (This snaps the start of the
selection to the start of the new text if it was in the middle of the text that it
replaced.)
If selection end is greater than end, then
increment it by delta in the same way.
Otherwise: if selection end is greater than start, then set it to new end. (This snaps the end of the
selection to the end of the new text if it was in the middle of the text that it
replaced.)
Set the selection of the text field to the sequence of characters starting with the character
at the selection startth position (in logical order) and ending with the
character at the (selection end-1)th position. In UAs
where there is no concept of an empty selection, this must set the cursor to be just before the
character with offset end. The direction of the selection must be set to
forward if the platform does not support selections with the direction none, and
none otherwise.
All elements to which this API applies have either a
selection or a text entry cursor position at all times (even for elements that are not being
rendered). User agents should follow platform conventions to determine their initial
state.
U+200D ZERO WIDTH JOINERのような、不可視のレンダリングをともなう文字は、依然として文字としてカウントされる。したがって、たとえば選択は単に不可視の文字を含めることができ、テキスト挿入カーソルは片側またはそのような文字の別のものに配置できる。
現在選択されているテキストを取得するためには、次のJavaScriptで十分である：
var selectionText = control.value.substring(control.selectionStart, control.selectionEnd);
An element can be constrained in various ways. The following is the list of validity
states that a form control can be in, making the control invalid for the purposes of
constraint validation. (The definitions below are non-normative; other parts of this specification
define more precisely when each state applies or does not.)
An element can still suffer from these states even when the element is disabled; thus these states can be represented in the DOM even
if validating the form during submission wouldn't indicate a problem to the user.
An element satisfies its constraints if it is not suffering
from any of the above validity states.
4.10.21.2 Constraint validation
When the user agent is required to statically validate the constraints of
form element form, it must run the following steps, which return
either a positive result (all the controls in the form are valid) or a negative
result (there are invalid controls) along with a (possibly empty) list of elements that are
invalid and for which no script has claimed responsibility:
If the event was not canceled, then add field to unhandled invalid controls.
Return a negative result with the list of elements in the unhandled
invalid controls list.
If a user agent is to interactively validate the constraints of form
element form, then the user agent must run the following steps:
Statically validate the constraints of form, and let unhandled invalid controls be the list of elements returned if the result was
negative.
If the result was positive, then return that result and abort these steps.
Report the problems with the constraints of at least one of the elements given in unhandled invalid controls to the user. User agents may focus one of those
elements in the process, by running the focusing steps for that element, and may
change the scrolling position of the document, or perform some other action that brings the
element to the user's attention. User agents may report more than one constraint violation. User
agents may coalesce related constraint violation reports if appropriate (e.g. if multiple radio
buttons in a group are marked as required, only one error
need be reported). If one of the controls is not being rendered (e.g. it has the
hidden attribute set) then user agents may report a script
error.
<label>Feeling: <input name=f type="text" oninput="check(this)"></label>
<script>
function check(input) {
if (input.value == "good" ||
input.value == "fine" ||
input.value == "tired") {
input.setCustomValidity('"' + input.value + '" is not a feeling.');
} else {
// input is fine -- reset the error message
input.setCustomValidity('');
}
}
</script>
The validity attribute must return a
ValidityState object that represents the validity states of the element.
This object is live, and the same object must be returned each time the element's
validity attribute is retrieved.
A ValidityState object has the following attributes. On getting, they must return
true if the corresponding condition given in the following list is true, and false otherwise.
When the checkValidity() method is
invoked, if the element is a candidate for constraint validation and does not satisfy its constraints, the user agent must fire a simple
event named invalid that is cancelable (but in this case
has no default action) at the element and return false. Otherwise, it must only return true
without doing anything else.
When the reportValidity() method is
invoked, if the element is a candidate for constraint validation and does not satisfy its constraints, the user agent must: fire a simple
event named invalid that is cancelable at the element,
and if that event is not canceled, report the problems with the constraints of that element to the
user; then, return false. Otherwise, it must only return true without doing anything else. When
reporting the problem with the constraints to the user, the user agent may run the focusing
steps for that element, and may change the scrolling position of the document, or perform
some other action that brings the element to the user's attention. User agents may report more
than one constraint violation, if the element suffers from multiple problems at once. If the
element is not being rendered, then the user agent may, instead of notifying the
user, report a script error.
The validationMessage attribute must
return the empty string if the element is not a candidate for constraint validation
or if it is one but it satisfies its constraints; otherwise,
it must return a suitably localised message that the user agent would show the user if this were
the only form control with a validity constraint problem. If the user agent would not actually
show a textual message in such a situation (e.g. it would show a graphical cue instead), then the
attribute must return a suitably localised message that expresses (one or more of) the validity
constraint(s) that the control does not satisfy. If the element is a candidate for
constraint validation and is suffering from a custom error, then the
custom validity error message should be present in the return value.
If the user agent supports letting the user submit a form implicitly (for example, on some
platforms hitting the "enter" key while a text field is focused implicitly submits the form), then
doing so for a form whose default button has a defined activation
behavior must cause the user agent to run synthetic click activation steps on
that default button.
Consequently, if the default button is disabled, the form is not submitted when such an implicit
submission mechanism is used. (A button has no activation behavior when
disabled.)
There are pages on the Web that are only usable if there is a way to implicitly
submit forms, so user agents are strongly encouraged to support this.
If the form has
no submit button, then the implicit submission
mechanism must do nothing if the form has more than one field that blocks implicit
submission, and must submit the form
element from the form element itself otherwise.
When a form element form is submitted from an element submitter
(typically a button), optionally with a submitted from submit() method flag set, the user agent must run the
following steps:
Let form browsing context be the browsing context of form document.
If the submitted from submit()
method flag is not set, and the submitter element's no-validate state is false, then interactively
validate the constraints of form and examine the result: if the result
is negative (the constraint validation concluded that there were invalid fields and probably
informed the user of this) then fire a simple event named invalid at the form element and then abort these
steps.
If the submitted from submit()
method flag is not set, then fire a simple event that bubbles and is
cancelable named submit, at form. If the
event's default action is prevented (i.e. if the event is canceled) then abort these steps.
Otherwise, continue (effectively the default action is to perform the submission).
If target browsing context was created in the previous step, or,
alternatively, if the form document has not yet completely
loaded and the submitted from submit()
method flag is set, then let replace be true. Otherwise, let it be
false.
Otherwise, select the appropriate row in the table below based on the value of scheme as given by the first cell of each row. Then, select the appropriate cell
on that row based on the value of method as given in the first cell of each
column. Then, jump to the steps named in that cell and defined below the table.
If scheme is not one of those listed in this table, then the behavior is
not defined by this specification. User agents should, in the absence of another specification
defining this, act in a manner analogous to that defined in this specification for similar
schemes.
Each form element has a planned navigation, which is either null or a
task; when the form is first created, its
planned navigation must be set to null. In the behaviours described below, when the
user agent is required to plan to navigate to a particular resource destination, it must run the following steps:
Navigatetarget browsing context to
the particular resource destination. If replace is
true, then target browsing context must be navigated with
replacement enabled.
For the purposes of this task, target browsing context and replace are the variables that were set up when the overall form submission
algorithm was run, with their values as they stood when this planned navigation
was queued.
If action contains the string "%%%%" (four U+0025
PERCENT SIGN characters), then percent encode all bytes in data that, if interpreted as US-ASCII, are not characters in the URL
default encode set, and then, treating the result as a US-ASCII string,
UTF-8 percent encode all the U+0025 PERCENT SIGN characters in the resulting
string and replace the first occurrence of "%%%%" in action with the resulting doubly-escaped string. [URL]
Otherwise, if action contains the string "%%"
(two U+0025 PERCENT SIGN characters in a row, but not four), then UTF-8 percent
encode all characters in data that, if interpreted as US-ASCII, are
not characters in the URL default encode set, and then, treating the result as a
US-ASCII string, replace the first occurrence of "%%" in action with the resulting escaped string. [URL]
Replace occurrences of "+" (U+002B) characters in headers with
the string "%20".
Let destination consist of all the characters from the first character
in action to the character immediately before the first "?" (U+003F) character, if any, or the end of the string if there are none.
Append a single "?" (U+003F) character to destination.
If destination does not contain a "?" (U+003F) character,
append a single "?" (U+003F) character to destination.
Otherwise, append a single U+0026 AMPERSAND character (&).
Append the string "body=" to destination.
Append body, interpreted as a US-ASCII string, to destination.
Let subject be the nearest ancestor dialog element of form, if any.
If there isn't one, or if it does not have an open
attribute, do nothing. Otherwise, proceed as follows:
If submitter is an input element whose type attribute is in the Image Button state, then let result
be the string formed by concatenating the selected coordinate's x-component, expressed as a base-ten number using ASCII digits, a
"," (U+002C) character, and the selected
coordinate's y-component, expressed in the same way as the x-component.
Otherwise, if submitter has a value, then let result be that value.
Otherwise, there is no result.
Then, close the dialogsubject. If there is a result, let that be the return value.
The appropriate form encoding algorithm is
determined as follows:
The algorithm to construct the form data set
for a form form optionally in the context of a submitter submitter is as follows. If not specified otherwise, submitter
is null.
The field element is not an input element whose type attribute is in the Image Button state, and either the field element does not have a name attribute
specified, or its name attribute's value is the empty
string.
The field element is an object element that is not using
a plugin.
Otherwise, process field as follows:
Let type be the value of the type IDL
attribute of field.
If the field element is an input element whose type attribute is in the Image Button state, then run these further nested
substeps:
If the field element has a name
attribute specified and its value is not the empty string, let name be
that value followed by a single "." (U+002E) character. Otherwise, let name be the empty string.
Let namex be the string consisting of the
concatenation of name and a single U+0078 LATIN SMALL LETTER X character
(x).
Let namey be the string consisting of the
concatenation of name and a single U+0079 LATIN SMALL LETTER Y character
(y).
The field element is submitter, and before
this algorithm was invoked the user indicated a coordinate. Let x be the x-component of the coordinate selected by the
user, and let y be the y-component of the coordinate
selected by the user.
Append an entry to the form data set with the name namex, the value x, and the type type.
Append an entry to the form data set with the name namey and the value y, and the type
type.
Skip the remaining substeps for this element: if there are any more elements in controls, return to the top of the loop step, otherwise, jump to the
end step below.
Let name be the value of the field element's
name attribute.
If the field element is a select element, then for each
option element in the select element's list of options whose selectedness is true and that is not disabled, append an entry to the form data
set with the name as the name, the value of the option element as the value, and
type as the type.
Otherwise, if the field element is an input element whose
type attribute is in the Checkbox state or the Radio Button state, then run these further nested
substeps:
If the field element has a value attribute specified, then let value
be the value of that attribute; otherwise, let value be the string "on".
Append an entry to the form data set with name
as the name, value as the value, and type as the
type.
Otherwise, if the field element is an input element
whose type attribute is in the File Upload state, then for each file selected in the input element,
append an entry to the form data set with the name as
the name, the file (consisting of the name, the type, and the body) as the value, and type as the type. If there are no selected files, then append an entry to the
form data set with the name as the name, the empty
string as the value, and application/octet-stream as the type.
Otherwise, if the field element is an object element:
try to obtain a form submission value from the plugin, and if that is successful,
append an entry to the form data set with name as the
name, the returned form submission value as the value, and the string "object" as the type.
Otherwise, append an entry to the form data set with name as the name, the value of the field element as the value, and type as the type.
If the element has a dirname attribute, and that
attribute's value is not the empty string, then run these substeps:
Let dirname be the value of the element's dirname attribute.
Append an entry to the form data set with dirname as the name, dir as the value, and the string
"direction" as the type.
An element can only have a dirname
attribute if it is a textarea element or an input element whose
type attribute is in either the Text state or the Search state.
End: For the name of each entry in the form data set, and for the
value of each entry in the form data set whose type is not "file" or "textarea", replace every occurrence of a "CR" (U+000D) character not followed by a "LF" (U+000A) character, and every
occurrence of a "LF" (U+000A) character not preceded by a "CR" (U+000D)
character, by a two-character string consisting of a U+000D CARRIAGE RETURN "CRLF" (U+000A) character pair.
In the case of the value of
textarea elements, this newline normalization is already performed during the
conversion of the control's raw value into the
control's value (which also performs any necessary line
wrapping). In the case of input elements type
attributes in the File Upload state, the value is not
normalized.
Return the form data set.
4.10.22.5 Selecting a form submission encoding
If the user agent is to pick an encoding for a
form, optionally with an allow non-ASCII-compatible encodings flag set, it must run
the following substeps:
For each token in candidate encoding labels in turn (in the order in
which they were found in input), get an
encoding for the token and, if this does not result in failure, append the
encoding to candidate encodings.
If the allow non-ASCII-compatible encodings flag is not set, remove any encodings
that are not ASCII-compatible character
encodings from candidate encodings.
If candidate encodings is empty, return UTF-8 and abort these
steps.
Each character encoding in candidate encodings can represent a finite
number of characters. (For example, UTF-8 can represent all 1.1 million or so Unicode code
points, while Windows-1252 can only represent 256.)
For each encoding in candidate encodings, determine how many of the
characters in the names and values of the entries in the form data set the
encoding can represent (without ignoring duplicates). Let max be the
highest such count. (For UTF-8, max would equal the number of characters
in the names and values of the entries in the form data set.)
Return the first encoding in candidate encodings that can encode max characters in the names and values of the entries in the form
data set.
For each entry in the form data set, perform these substeps:
If the entry's name is "_charset_" and its
type is "hidden", replace its value with charset.
If the entry's type is "file", replace its value with the file's
name only.
For each character in the entry's name and value that cannot be expressed using the
selected character encoding, replace the character by a string consisting of a U+0026 AMPERSAND
character (&), a "#" (U+0023) character, one or more ASCII digits
representing the Unicode code point of the character in base ten, and finally a ";" (U+003B) character.
Encode the entry's name and value using the encoder for the selected character
encoding. The entry's name and value are now byte strings.
For each byte in the entry's name and value, apply the appropriate subsubsteps from the
following list:
If the byte is 0x20 (U+0020 SPACE if interpreted as ASCII)
Replace the byte with a single 0x2B byte ("+" (U+002B) character if interpreted
as ASCII).
If the byte is in the range 0x2A, 0x2D, 0x2E, 0x30 to 0x39, 0x41 to 0x5A, 0x5F, 0x61 to
0x7A
Leave the byte as is.
そうでなければ
Let s be a string consisting of a U+0025 PERCENT SIGN character
(%) followed by uppercase ASCII hex digits representing the hexadecimal value
of the byte in question (zero-padded if necessary).
Encode the string s as US-ASCII, so that it is now a byte
string.
Replace the byte in question in the name or value being processed by the bytes in
s, preserving their relative order.
Interpret the entry's name and value as Unicode strings encoded in US-ASCII. (All of the
bytes in the string will be in the range 0x00 to 0x7F; the high bit will be zero throughout.)
The entry's name and value are now Unicode strings again.
If the entry's name is "isindex", its type is
"text", and this is the first entry in the form data
set, then append the value to result and skip the rest of the
substeps for this entry, moving on to the next entry, if any, or the next step in the overall
algorithm otherwise.
If this is not the first entry, append a single U+0026 AMPERSAND character (&) to
result.
Append the entry's name to result.
Append a single "=" (U+003D) character to result.
Append the entry's value to result.
Encode result as US-ASCII and return the resulting byte
stream.
The multipart/form-data encoding algorithm is as follows:
Let result be the empty string.
If the algorithm was invoked with an explicit character encoding, let the selected character
encoding be that encoding. (This algorithm is used by other specifications, which provide an
explicit character encoding to avoid the dependency on the form element described
in the next paragraph.)
For each entry in the form data set, perform these substeps:
If the entry's name is "_charset_" and its
type is "hidden", replace its value with charset.
For each character in the entry's name and value that cannot be expressed using the
selected character encoding, replace the character by a string consisting of a U+0026 AMPERSAND
character (&), a "#" (U+0023) character, one or more ASCII digits
representing the Unicode code point of the character in base ten, and finally a ";" (U+003B) character.
Encode the (now mutated) form data set using the rules described by RFC
2388, Returning Values from Forms: multipart/form-data, and
return the resulting byte stream. [RFC2388]
Each entry in the form data set is a field, the name of the entry
is the field name and the value of the entry is the field value.
The order of parts must be the same as the order of fields in the form data
set. Multiple entries with the same name must be treated as distinct fields.
In particular, this means that multiple files submitted as part of a single
<input type=file multiple> element will result in each file
having its own field; the "sets of files" feature ("multipart/mixed") of
RFC 2388 is not used.
The parts of the generated multipart/form-data resource that correspond
to non-file fields must not have a Content-Type header specified. Their names and
values must be encoded using the character encoding selected above (field names in particular do
not get converted to a 7-bit safe encoding as suggested in RFC 2388).
File names included in the generated multipart/form-data resource (as
part of file fields) must use the character encoding selected above, though the precise name may
be approximated if necessary (e.g. newlines could be removed from file names, quotes could be
changed to "%22", and characters not expressible in the selected character encoding could be
replaced by other characters). User agents must not use the RFC 2231 encoding suggested by RFC
2388.
The boundary used by the user agent in generating the return value of this algorithm is the
multipart/form-data boundary string. (This value is used to
generate the MIME type of the form submission payload generated by this algorithm.)
Each resettable element defines its own reset algorithm. Changes made to form controls as part of
these algorithms do not count as changes caused by the user (and thus, e.g., do not cause input events to fire).
The firstsummary element child of the element, if any,
represents the summary or legend of the details. If there is no
child summary element, the user agent should provide its own legend (e.g.
"Details").
When the element is created, if the attribute is absent, the additional information should be
hidden; if the attribute is present, that information should be shown. Subsequently, if the
attribute is removed, then the information should be hidden; if the attribute is added, the
information should be shown.
The user agent should allow the user to request that the additional information be shown or
hidden. To honor a request for the details to be shown, the user agent must set the open attribute on the element to the value open. To honor a request for the information to be hidden, the user agent must
remove the open attribute from the element.
Whenever the open attribute is added to or removed from
a details element, the user agent must queue a task that runs the
following steps, which are known as the details notification task steps, for this
details element:
Other menus, which allows the list to be nested (menu)
To construct and show a menu for a particular menu element and with a
particular element as a subject, the user agent must run the following steps:
Let the menu be an empty list of the type described above.
Run the menu builder steps for the menu element using the menu
prepared in the previous list as the output.
The menu builder steps for a menu element using a specific menu as
output are as follows: For each child node of the menu in tree order,
run the appropriate steps from the following list:
If the child is a menu element with no label attribute
Append a separator to the menu, then run the menu builder steps using this
child menu element for the same menu, then append another separator to the
menu.
If the child is a menu element with a label attribute
Create a new submenu as an empty list of the type described above, and construct it by
running the menu builder steps for the child menu element using the
new submenu as the output. Then, append the submenu to the menu, using the value of the child
menu element's label attribute as the label
of the submenu.
Remove any submenu with no label, or whose label is the empty string, in the menu or any
submenus.
Remove any menu item with no label, or whose label is the empty string, in the menu or any
submenus.
Collapse all sequences of two or more adjacent separators in the menu or any submenus to a
single separator.
Remove all separators at the start or end of the menu and any submenus.
Display the menu to the user, and let the algorithm that invoked this one continue.
If the user selects a menu item that corresponds to an element that still represents a command when the user selects it, then the UA must invoke that
command's Action. If the command's Action is defined as firing
a click event, either directly or via the run
synthetic click activation steps algorithm, then the relatedTarget attribute of that click event must be initialised to the subject passed to this
construct and show a menu algorithm.
Pop-up menus must not, while being shown, reflect changes in the DOM. The menu is constructed
from the DOM before being shown, and is then immutable.
icon属性は、コマンドを表す画像を提供する。属性が指定される場合、属性値は潜在的にスペースで囲まれた妥当な空でないURLを含めなければならない。To obtain the absolute URL of the icon when the attribute's value is not the empty string, the attribute's value must be resolved relative to the element. When the attribute is absent, or its value is the empty string, or resolving its value fails, there is no icon.
If the element has a checked attribute, the UA
must remove that attribute. Otherwise, the UA must add a checked attribute, with the literal value checked.
If the element has a parent, then the UA must walk the list of child nodes of that parent
element, and for each node that is a menuitem element, if that element has a radiogroup attribute whose value exactly matches the
current element's (treating missing radiogroup
attributes as if they were the empty string), and has a checked attribute, must remove that attribute.
Then, the element's checked attribute must be set
to the literal value checked.
When an element's context menu is requested (e.g. by the user right-clicking the element, or
pressing a context menu key), the user agent must apply the appropriate rules from the following
list:
If the user requested a context menu using a pointing device
The user agent must fire a trusted event with the name contextmenu, that bubbles and is cancelable, and that uses the
MouseEvent interface, at the element for which the menu was requested. The context
information of the event must be initialised to the same values as the last
MouseEvent user interaction event that was fired as part of the gesture that was
interpreted as a request for the context menu.
Typically, therefore, the firing of the contextmenu event will be the default action of a mouseup or keyup event. The exact sequence
of events is UA-dependent, as it will vary based on platform conventions.
The default action of the contextmenu event depends on
whether or not the element for which the menu was requested has a non-null assigned context
menu when the event dispatch has completed, as follows.
If the assigned context menu of the element for which the menu was requested is
null, the default action must be for the user agent to show its default context menu, if it has
one.
Otherwise, let subject be the element for which the menu was requested, and
let menu be the assigned context menu of target immediately after the contextmenu
event's dispatch has completed. The user agent must fire a
trusted event with the name show at menu, using the RelatedEvent
interface, with the relatedTarget attribute
initialised to subject. The event must be cancelable.
If this event (the show event) is not canceled, then
the user agent must construct and show the menu for
menu with subject as the subject.
The user agent may also provide access to its default context menu, if any, with the context
menu shown. For example, it could merge the menu items from the two menus together, or provide the
page's context menu as a submenu of the default menu. In general, user agents are encouraged to
de-emphasise their own contextual menu items, so as to give the author's context menu the
appearance of legitimacy — to allow documents to feel like "applications" rather than "mere
Web pages".
User agents may provide means for bypassing the context menu processing model, ensuring that
the user can always access the UA's default context menus. For example, the user agent could
handle right-clicks that have the Shift key depressed in such a way that it does not fire the
contextmenu event and instead always shows the default
context menu.
The contextMenu IDL attribute must
reflect the contextmenu content attribute.
この例において、猫の画像は4つの可能なコマンドでコンテキストメニューを与えられる：
<img src="cats.jpeg" alt="Cats" contextmenu=catsmenu>
<menu type="popup" id="catsmenu">
<menuitem label="Pet the kittens" onclick="kittens.pet()">
<menuitem label="Cuddle with the kittens" onclick="kittens.cuddle()">
<menu label="Feed the kittens">
<menuitem label="Fish" onclick="kittens.feed(fish)">
<menuitem label="Chicken" onclick="kittens.feed(chicken)">
</menu>
</menu>
The relatedTarget attribute must return the value it was initialised to. オブジェクトが作成される際、この属性はnullに初期化しなければならない。It represents the other event target that is related to the event.
The commandType attribute must
return a string whose value is either "command", "radio", or "checkbox", depending on whether the Type of the command defined by the element is "command",
"radio", or "checkbox" respectively. If the element does not define a command, it must return
null.
The commandLabel attribute must
return the command's Label, or null if the element does
not define a command or does not specify a Label.
The commandIcon attribute must
return the absolute URL of the command's Icon. If the element does not specify an icon, or if the element
does not define a command, then the attribute must return null.
The commandHidden attribute must
return true if the command's Hidden State is that
the command is hidden, and false if the command is not hidden. If the element does not define a
command, the attribute must return null.
The commandDisabled attribute
must return true if the command's Disabled State
is that the command is disabled, and false if the command is not disabled. This attribute is not
affected by the command's Hidden State. If the
element does not define a command, the attribute must return null.
The commandChecked attribute must
return true if the command's Checked State is that
the command is checked, and false if it is that the command is not checked. If the element does
not define a command, the attribute must return null.
The ID facet is exposed by the id IDL attribute, the Hint
facet is exposed by the title IDL attribute, and the AccessKey facet is exposed by the accessKeyLabel IDL attribute.
The ID of the command is the value of the id attribute of the element, if the attribute is present and not empty.
Otherwise the command is an anonymous command.
The Label of the command is the string given by the
element's textContent IDL attribute.
The Hint of the command is the value of the title attribute of the element. If the attribute is not present, the
Hint is the empty string.
The Icon of the command is the absolute
URL obtained from resolving the value of the src attribute of the first img element descendant of the
element in tree order, relative to that element, if there is such an element and
resolving its attribute is successful. Otherwise, there is no Icon for the command.
The Disabled State of the command is true if
the element or one of its ancestors is inert, or if the element's disabled state is set, and false otherwise.
4.11.6.4 Using the input element to define a command
The Type of the command is "radio" if the type attribute is in the Radio
Button state, "checkbox" if the type attribute is in
the Checkbox state, and "command" otherwise.
The ID of the command is the value of the id attribute of the element, if the attribute is present and not empty.
Otherwise the command is an anonymous command.
The Label of the command depends on the Type of the
command:
If the Type is "command", then it is the string given
by the value attribute, if any, and a UA-dependent,
locale-dependent value that the UA uses to label the button itself if the attribute is absent.
Otherwise, the Type is "radio" or "checkbox". If the
element is a labeled control, the textContent of the first
label element in tree order whose labeled control is the
element in question is the Label (in DOM terms, this is
the string given by element.labels[0].textContent). Otherwise,
the value of the value attribute, if present, is the Label. Otherwise, the Label is the empty string.
The Hint of the command is the value of the title attribute of the input element. If the attribute is
not present, the Hint is the empty string.
If the element's type attribute is in the Image Button state, and the element has a src attribute, and that attribute's value can be successfully resolved relative to the element, then the Icon of the command is the absolute URL obtained
from resolving that attribute that way. Otherwise, there is no Icon for the command.
The Hidden State of the command is true (hidden)
if the element has a hidden attribute, and false otherwise.
The Disabled State of the command is true if
the element or one of its ancestors is inert, or if the element's disabled state is set, and false otherwise.
The Checked State of the command is true if the
command is of Type "radio" or "checkbox" and the element
is checked attribute, and false otherwise.
The Type of the command is "radio" if the
option's nearest ancestor select element has no multiple attribute, and "checkbox" if it does.
The ID of the command is the value of the id attribute of the element, if the attribute is present and not empty.
Otherwise the command is an anonymous command.
The Hidden State of the command is true (hidden)
if the element has a hidden attribute, and false otherwise.
The Disabled State of the command is true if
the element is disabled, or if its nearest ancestor
select element is disabled, or if it or one
of its ancestors is inert, and false otherwise.
The Checked State of the command is true
(checked) if the element's selectedness is true,
and false otherwise.
The Action of the command depends on its Type. If the command is of Type "radio" then it must pick the option element. Otherwise, it must toggle the option element.
4.11.6.6 Using the menuitem element to define a
command
The Type of the command is "radio" if the
menuitem's type attribute is
"radio", "checkbox" if the attribute's value is "checkbox", and
"command" otherwise.
The ID of the command is the value of the id attribute of the element, if the attribute is present and not empty.
Otherwise the command is an anonymous command.
The Label of the command is the value of the element's
label attribute, if there is one, or the empty string if
it doesn't.
The Hint of the command is the string given by the
element's title attribute, if any, and the empty string
if the attribute is absent.
The Icon for the command is the absolute
URL obtained from resolving the value of the element's
icon attribute, relative to the element, if it has such an
attribute and resolving it is successful. Otherwise, there is no Icon for the command.
The Hidden State of the command is true (hidden)
if the element has a hidden attribute, and false otherwise.
The Disabled State of the command is true if
the element or one of its ancestors is inert, or if the element has a disabled attribute, and false otherwise.
The Checked State of the command is true
(checked) if the element has a checked attribute, and
false otherwise.
The ID of the command is the value of the id attribute of the element, if the attribute is present and not empty.
Otherwise the command is an anonymous command.
If the element has a title attribute, then the Hint of the command is the value of that title attribute. Otherwise, the Hint of the command is the Hint of the master command.
The ID of the command is the value of the id attribute of the element, if the attribute is present and not empty.
Otherwise the command is an anonymous command.
The Label of the command is the string given by the
element's textContent IDL attribute.
The Hint of the command is the value of the title attribute of the element.
The ID of the command is the value of the id attribute of the element, if the attribute is present and not empty.
Otherwise the command is an anonymous command.
The Label of the command is the string given by the
element's textContent IDL attribute.
The Hint of the command is the value of the title attribute of the element.
If one of the earlier sections that define elements that define
commands define that this element defines a command,
then that section applies to this element, and this section does not. Otherwise, this section
applies to that element.
The ID of the command is the value of the id attribute of the element, if the attribute is present and not empty.
Otherwise the command is an anonymous command.
The Label of the command depends on the element. If
the element is a labeled control, the textContent of the first
label element in tree order whose labeled control is the
element in question is the Label (in DOM terms, this is
the string given by element.labels[0].textContent). Otherwise,
the Label is the textContent of the element
itself.
The Hint of the command is the value of the title attribute of the element. If the attribute is not present, the
Hint is the empty string.
A dialog element without an open attribute
specified should not be shown to the user. This requirement may be implemented indirectly through
the style layer. For example, user agents that support the suggested
default rendering implement this requirement using the CSS rules described in the rendering section.
Run the dialog focusing steps for the dialog element.
Each Document has a stack of dialog elements known as the
pending dialog stack. When a Document is created, this stack must be
initialised to be empty.
Let control be the first element in tree order that has an autofocus attribute specified and whose nearest ancestor
dialog element is subject, if any.
If there isn't one, then let control be the first element in tree order
that is focusable and whose nearest ancestor dialog element is subject, if any.
If there isn't one of those either but subject itself is
focusable, then let control be subject. (This is unusual.)
When the close() method is invoked, the user
agent must close the dialog that the method was invoked on. If the method was invoked
with an argument, that argument must be used as the return value; otherwise, there is no return
value.
When a dialog element subject is to be closed, optionally with a return value result, the user agent
must run the following steps:
If subject does not have an open
attribute, then abort these steps.
The returnValue IDL attribute, on
getting, must return the last value to which it was set. On setting, it must be set to the new
value. When the element is created, it must be set to the empty string.
An example of such a UI mechanism would be the user pressing the "Escape" key.
All dialog elements are always in one of three modes: normal alignment,
centered alignment, and magic alignment. When a dialog element
is created, it must be placed in the normal alignment mode. In this mode, normal CSS
requirements apply to the element. The centered alignment mode is only used for
dialog elements that are in the top layer. [FULLSCREEN][CSS]
When an element subject is placed in centered alignment mode,
and when it is in that mode and has new rendering boxes created, the user agent must set up the
element such that its top static position, for the purposes of calculating the used value of the
'top' property, is the value that would place the element's top margin edge as far from the top of
the viewport as the element's bottom margin edge from the bottom of the viewport, if the element's
height is less than the height of the viewport, and otherwise is the value that would place the
element's top margin edge at the top of the viewport.
If there is a dialog element with centered alignment and that is
being rendered when its browsing context changes viewport width (as
measured in CSS pixels), then the user agent must recreate the element's boxes, recalculating its
top static position as in the previous paragraph.
This top static position of a dialog element with centered alignment
must remain the element's top static position until its boxes are recreated. (The element's static
position is only used in calculating the used value of the 'top' property in certain situations;
it's not used, for instance, to position the element if its 'position' property is set to
'static'.)
When a user agent is to set up the position of an element subject using an anchor anchor, it must run the following
steps:
If anchor is a MouseEvent object, then run these
substeps:
If anchor's target element does not have a rendered box, or is in a
different document than subject, then let subject be
in the centered alignment mode, and abort the set up the position
steps.
Let anchor element be an anonymous element rendered as a box with
zero height and width (so its margin and border boxes both just form a point), positioned so
that its top and left are at the coordinate identified by the event, and whose properties all
compute to their initial values.
Otherwise, let anchor element be anchor.
Put subject in the magic alignment mode, aligned to anchor element.
While an element A has magic alignment, aligned to an element
B, the following requirements apply:
If at any time either A or B cease having rendered
boxes, A and B cease being in the same
Document, or B ceases being earlier than A in tree order, then, if subject is in the
pending dialog stack, let subject's mode become centered
alignment, otherwise, let subject's mode become normal
alignment.
A's 'position' property must compute to the keyword 'absolute-anchored' rather than whatever it would
otherwise compute to (i.e. the 'position' property's specified value is ignored).
The anchor points for A and B are defined as per the
appropriate entry in the following list:
If the computed value of 'anchor-point' is 'none' on both A and B
The anchor points of A and B are the center points
of their respective first boxes' border boxes.
If the computed value of 'anchor-point' is 'none' on A and a specific
point on B
The anchor point of B is the point given by its 'anchor-point'
property.
If the anchor point of B is the center point of B's
first box's border box, then A's anchor point is the center point of its
first box's margin box.
Otherwise, A's anchor point is on one of its margin edges. Consider
four hypothetical half-infinite lines L1, L2, L3, and L4 that each start in the center of B's first box's border box, and that extend respectively through the top left
corner, top right corner, bottom right corner, and bottom left corner of B's first box's border box. A's anchor point is determined
by the location of B's anchor point relative to these four hypothetical
lines, as follows:
If the anchor point of B lies on L1 or L2, or inside the area bounded
by L1 and L2 that also contains the points above B's first box's border
box, then let A's anchor point be the horizontal center of A's bottom margin edge.
Otherwise, if the anchor point of B lies on L3 or L4, or inside the
area bounded by L4 and L4 that also contains the points below B's first
box's border box, then let A's anchor point be the horizontal center of
A's top margin edge.
Otherwise, if the anchor point of B lies inside the area bounded by L4
and L1 that also contains the points to the left of B's first box's border
box, then let A's anchor point be the vertical center of A's right margin edge.
Otherwise, the anchor point of B lies inside the area bounded by L2 and
L3 that also contains the points to the right of B's first box's border
box; let A's anchor point be the vertical center of A's left margin edge.
If the computed value of 'anchor-point' is a specific point on A and
'none' on B
The anchor point of A is the point given by its 'anchor-point'
property.
If the anchor point of A is the center point of A's
first box's margin box, then B's anchor point is the center point of its
first box's border box.
Otherwise, B's anchor point is on one of its border edges. Consider
four hypothetical half-infinite lines L1, L2, L3, and L4 that each start in the center of A's first box's margin box, and that extend respectively through the top left
corner, top right corner, bottom right corner, and bottom left corner of A's first box's margin box. B's anchor point is determined
by the location of A's anchor point relative to these four hypothetical
lines, as follows:
If the anchor point of A lies on L1 or L2, or inside the area bounded
by L1 and L2 that also contains the points above A's first box's margin
box, then let B's anchor point be the horizontal center of B's bottom border edge.
Otherwise, if the anchor point of A lies on L3 or L4, or inside the
area bounded by L4 and L4 that also contains the points below A's first
box's margin box, then let B's anchor point be the horizontal center of
B's top border edge.
Otherwise, if the anchor point of A lies inside the area bounded by L4
and L1 that also contains the points to the left of A's first box's margin
box, then let B's anchor point be the vertical center of B's right border edge.
Otherwise, the anchor point of A lies inside the area bounded by L2 and
L3 that also contains the points to the right of A's first box's margin
box; let B's anchor point be the vertical center of B's left border edge.
If the computed value of 'anchor-point' is a specific point on both A
and B
The anchor points of A and B are the points given
by their respective 'anchor-point' properties.
The rules above generally use A's margin box, but
B's border box. This is because while A always
has a margin box, and using the margin box allows for the dialog to be positioned offset from
the box it is annotating, B sometimes does not have a margin box (e.g. if it
is a table-cell), or has a margin box whose position may be not entirely clear (e.g. in the face
of margin collapsing and 'clear' handling of in-flow blocks).
In cases where B does not have a border box but its border box is used by
the algorithm above, user agents must use its first box's content area instead. (This is in
particular an issue with boxes in tables that have 'border-collapse' set to 'collapse'.)
When an element's 'position' property computes to 'absolute-anchored', the 'float' property does not
apply and must compute to 'none', the 'display' property must compute to a value as described by
the table in the section of CSS
2.1 describing the relationships between 'display', 'position', and 'float',
and the element's box must be positioned using the rules for absolute positioning but with its
static position set such that if the box is positioned in its static position, its anchor point
is exactly aligned over the anchor point of the element to which it is magically aligned. Elements aligned in this way are absolutely
positioned. For the purposes of determining the containing block of other elements, the
'absolute-anchored' keyword must be treated
like the 'absolute' keyword.
The trivial example of an element that does not have a rendered box is one whose
'display' property computes to 'none'. However, there are many other cases; e.g. table columns do
not have boxes (their properties merely affect other boxes).
If an element to which another element is anchored changes rendering, the anchored
element will be be repositioned accordingly. (In other words, the requirements above are live,
they are not just calculated once per anchored element.)
The 'absolute-anchored'
keyword is not a keyword that can be specified in CSS; the 'position' property can only compute to
this value if the dialog element is positioned via the APIs described above.
User agents in visual interactive media should allow the user to pan the viewport to access all
parts of a dialog element's border box, even if the element is larger than the
viewport and the viewport would otherwise not have a scroll mechanism (e.g. because the viewport's
'overflow' property is set to 'hidden').
The open IDL attribute must
reflect the open content attribute.
A script element has several associated pieces of state.
The first is a flag indicating whether or not the script block has been "already
started". Initially, script elements must have this flag unset (script blocks,
when created, are not "already started"). The cloning
steps for script elements must set the "already started" flag on the copy if
it is set on the element being cloned.
The second is a flag indicating whether the element was "parser-inserted".
Initially, script elements must have this flag unset. It is set by the HTML
parser and the XML parser on script elements they insert and
affects the processing of those elements.
The third is a flag indicating whether the element will "force-async". Initially,
script elements must have this flag set. It is unset by the HTML parser
and the XML parser on script elements they insert. In addition, whenever
a script element whose "force-async" flag is set has a async content attribute added, the element's
"force-async" flag must be unset.
The fourth is a flag indicating whether or not the script block is "ready to be
parser-executed". Initially, script elements must have this flag unset (script
blocks, when created, are not "ready to be parser-executed"). This flag is used only for elements
that are also "parser-inserted", to let the parser know when to execute the
script.
The last few pieces of state are the script block's type, the
script block's character encoding, and the script block's fallback character
encoding. They are determined when the script is prepared, based on the attributes on
the element at that time, and the Document of the script element.
When a script element that is not marked as being "parser-inserted"
experiences one of the events listed in the following list, the user agent must synchronously
prepare the script element:
The script element is in a Document and has a src attribute set where previously the element had no such
attribute.
To prepare a script, the user agent must act as
follows:
If the script element is marked as having "already started", then
the user agent must abort these steps at this point. The script is not executed.
If the element has its "parser-inserted" flag set, then set was-parser-inserted to true and unset the element's
"parser-inserted" flag. Otherwise, set was-parser-inserted to
false.
This is done so that if parser-inserted script elements fail to run
when the parser tries to run them, e.g. because they are empty or specify an unsupported
scripting language, another script can later mutate them and cause them to run again.
If was-parser-inserted is true and the element does not have an async attribute, then set the element's
"force-async" flag to true.
This is done so that if a parser-inserted script element fails to
run when the parser tries to run it, but it is later executed after a script dynamically updates
it, it will execute asynchronously even if the async
attribute isn't set.
If the element has no src attribute, and its child
nodes, if any, consist only of comment nodes and empty Text nodes, then the user
agent must abort these steps at this point. The script is not executed.
If the element is not in a Document, then the user agent must abort
these steps at this point. The script is not executed.
If either:
the script element has a type attribute
and its value is the empty string, or
the script element has no type attribute
but it has a language attribute and that
attribute's value is the empty string, or
the script element has neither a type
attribute nor a language attribute, then
Otherwise, the element has a non-empty language
attribute; let the script block's type for this script element be the
concatenation of the string "text/" followed by the value of the language attribute.
The language attribute is never
conforming, and is always ignored if there is a type
attribute present.
The state of the element at this moment is later used to determine the script source.
If the element is flagged as "parser-inserted", but the element's
Document is not the Document of the parser that created the element,
then abort these steps.
If scripting is disabled for the script
element, then the user agent must abort these steps at this point. The script is not
executed.
The definition of scripting is disabled
means that, amongst others, the following scripts will not execute: scripts in
XMLHttpRequest's responseXML
documents, scripts in DOMParser-created documents, scripts in documents created by
XSLTProcessor's transformToDocument feature, and scripts
that are first inserted by a script into a Document that was created using the
createDocument() API. [XHR][DOMPARSING][DOM]
If the script element has an event
attribute and a for attribute, then run these substeps:
If for is not an ASCII case-insensitive match for the
string "window", then the user agent must abort these steps at this
point. The script is not executed.
If event is not an ASCII case-insensitive match for
either the string "onload" or the string "onload()", then the user agent must abort these steps at this point. The script
is not executed.
The resource obtained in this fashion can be either CORS-same-origin or
CORS-cross-origin. This only affects how error reporting happens.
For performance reasons, user agents may start fetching the script (as defined above) as
soon as the src attribute is set, instead, in the hope
that the element will be inserted into the document (and that the crossorigin attribute won't change value in the
meantime). Either way, once the element is inserted into the document, the load must have started as described in this
step. If the UA performs such prefetching, but the element is never inserted in the document,
or the src attribute is dynamically changed, or the crossorigin attribute is dynamically changed, then the
user agent will not execute the script so obtained, and the fetching process will have been
effectively wasted.
Then, the first of the following options that describes the situation must be followed:
If the element has a src
attribute, and the element has a defer attribute, and
the element has been flagged as "parser-inserted", and the element does not have
an async attribute
The element must be added to the end of the list of scripts that will execute when the
document has finished parsing associated with the Document of the parser
that created the element.
If the element has a src attribute, does not have an async attribute, and does not have the
"force-async" flag set
The element must be added to the end of the list of scripts that will execute in order
as soon as possible associated with the Document of the script
element at the time the prepare a script algorithm started.
The element must be added to the set of scripts that will execute as soon as
possible of the Document of the script element at the time the
prepare a script algorithm started.
The pending parsing-blocking script of a Document is used by the
Document's parser(s).
If a script element that blocks a parser gets moved to another
Document before it would normally have stopped blocking that parser, it nonetheless
continues blocking that parser until the condition that causes it to be blocking the parser no
longer applies (e.g. if the script is a pending parsing-blocking script because there
was a style sheet that is blocking scripts when it was parsed, but then the script is
moved to another Document before the style sheet loads, the script still blocks the
parser until the style sheets are all loaded, at which time the script executes and the parser is
unblocked).
When the user agent is required to execute a script
block, it must run the following steps:
If the element is flagged as "parser-inserted", but the element's
Document is not the Document of the parser that created the element,
then abort these steps.
Jump to the appropriate set of steps from the list below:
If the load resulted in an error (for example a DNS error, or an HTTP 404 error)
Executing the script block must consist of running the following steps. For the purposes of
these steps, the script is considered to be from an external file if, while the
prepare a script algorithm above was running for this script, the
script element had a src attribute
specified.
The contents of that file, interpreted as a Unicode string, are the script source.
To obtain the Unicode string, the user agent run the following steps:
If the resource's Content Type metadata, if any,
specifies a character encoding, and the user agent supports that encoding, then let character encoding be that encoding, and jump to the bottom step in this
series of steps.
If the algorithm above set the script block's character encoding, then
let character encoding be that encoding, and jump to the bottom step
in this series of steps.
If the specification for the script block's type gives specific rules for
decoding files in that format to Unicode, follow them, using character
encoding as the character encoding specified by higher-level protocols, if
necessary.
Otherwise, decode the file to Unicode, using character
encoding as the fallback encoding.
The decode algorithm overrides character
encoding if the file contains a BOM.
The external file is the script source. When it is later executed, it must be
interpreted in a manner consistent with the specification defining the language given by
the script block's type.
If the script came from a resource that was fetched in the
steps above, and the resource was CORS-cross-origin, then pass the muted errors flag to the create a script algorithm as well.
This is where the script is compiled and actually executed.
The async IDL attribute controls whether the
element will execute asynchronously or not. If the element's "force-async" flag is
set, then, on getting, the async IDL attribute must return
true, and on setting, the "force-async" flag must first be unset, and then the
content attribute must be removed if the IDL attribute's new value is false, and must be set to
the empty string if the IDL attribute's new value is true. If the element's
"force-async" flag is not set, the IDL attribute must reflect
the async content attribute.
The IDL attribute text must return a
concatenation of the contents of all the Text nodes that are children of the
script element (ignoring any other nodes such as comments or elements), in tree
order. On setting, it must act the same way as the textContent IDL attribute.
<script>
function calculate(form) {
var price = 52000;
if (form.elements.brakes.checked)
price += 1000;
if (form.elements.radio.checked)
price += 2500;
if (form.elements.turbo.checked)
price += 5000;
if (form.elements.sticker.checked)
price += 250;
form.elements.result.value = price;
}
</script>
<form name="pricecalc" onsubmit="return false" onchange="calculate(this)">
<fieldset>
<legend>Work out the price of your car</legend>
<p>Base cost: £52000.</p>
<p>Select additional options:</p>
<ul>
<li><label><input type=checkbox name=brakes> Ceramic brakes (£1000)</label></li>
<li><label><input type=checkbox name=radio> Satellite radio (£2500)</label></li>
<li><label><input type=checkbox name=turbo> Turbo charger (£5000)</label></li>
<li><label><input type=checkbox name=sticker> "XZ" sticker (£250)</label></li>
</ul>
<p>Total: £<output name=result></output></p>
</fieldset>
<script>
calculate(document.forms.pricecalc);
</script>
</form>
4.12.1.1 スクリプト言語
A user agent is said to support the scripting language if each component of the
script block's type is an ASCII case-insensitive match for the corresponding
component in the MIME type string of a scripting language that the user agent
implements.
User agents may support other MIME types for other languages,
but must not support other MIME types for the languages in the list
above. User agents are not required to support the languages listed above.
The following MIME types (with or without parameters) must not
be interpreted as scripting languages:
"text/plain"
"text/xml"
"application/octet-stream"
"application/xml"
These types are explicitly listed here because they are poorly-defined types that
are nonetheless likely to be used as formats for data blocks, and it would be problematic if they
were suddenly to be interpreted as script by a user agent.
When examining types to determine if they represent supported languages, user agents must not
ignore MIME parameters. Types are to be compared including all parameters.
For example, types that include the charset parameter will
not be recognised as referencing any of the scripting languages listed above.
script = outer *( comment-open inner comment-close outer )
outer = < any string that doesn't contain a substring that matches not-in-outer >
not-in-outer = comment-open
inner = < any string that doesn't contain a substring that matches not-in-inner >
not-in-inner = comment-close / script-open
comment-open = "<!--"
comment-close = "-->"
script-open = "<" s c r i p t tag-end
s = %x0053 ; U+0053 LATIN CAPITAL LETTER S
s =/ %x0073 ; U+0073 LATIN SMALL LETTER S
c = %x0043 ; U+0043 LATIN CAPITAL LETTER C
c =/ %x0063 ; U+0063 LATIN SMALL LETTER C
r = %x0052 ; U+0052 LATIN CAPITAL LETTER R
r =/ %x0072 ; U+0072 LATIN SMALL LETTER R
i = %x0049 ; U+0049 LATIN CAPITAL LETTER I
i =/ %x0069 ; U+0069 LATIN SMALL LETTER I
p = %x0050 ; U+0050 LATIN CAPITAL LETTER P
p =/ %x0070 ; U+0070 LATIN SMALL LETTER P
t = %x0054 ; U+0054 LATIN CAPITAL LETTER T
t =/ %x0074 ; U+0074 LATIN SMALL LETTER T
tag-end = %x0009 ; "tab" (U+0009)
tag-end =/ %x000A ; "LF" (U+000A)
tag-end =/ %x000C ; "FF" (U+000C)
tag-end =/ %x0020 ; U+0020 SPACE
tag-end =/ %x002F ; "/" (U+002F)
tag-end =/ %x003E ; ">" (U+003E)
<script>
var example = 'Consider this string: <!-- <script>';
console.log(example);
</script>
<!-- despite appearances, this is actually part of the script still! -->
<script>
... // this is the same script block still...
</script>
<script>
var example = 'Consider this string: <\!-- <\script>';
console.log(example);
</script>
<!-- this is just a comment between script blocks -->
<script>
... // this is a new script block
</script>
<script src="cool-effects.js">
// create new instances using:
// var e = new Effect();
// start the effect using .play, stop using .stop:
// e.play();
// e.stop();
</script>
This specification does not define how XSLT interacts with the script element.
However, in the absence of another specification actually defining this, here are some guidelines
for implementors, based on existing implementations:
When an XSLT transformation program is triggered by an processing instruction and the browser implements a
direct-to-DOM transformation, script elements created by the XSLT processor need to
be marked "parser-inserted" and run in document order (modulo scripts marked defer or async),
asynchronously while the transformation is occurring.
The XSLTProcessor.transformToFragment() method
needs to create a fragment that is equivalent to one built manually by creating the elements
using document.createElementNS(). For instance,
it needs to create script elements that aren't "parser-inserted" and
that don't have their "already started" flag set, so that they will execute when the
fragment is inserted into a document.
The main distinction between the first two cases and the last case is that the first two
operate on Documents and the last operates on a fragment.
noscript要素がテキストのみを含まなければならない。ただしHTML断片解析アルゴリズムを発動する場合を除く with
the noscript element as the context
element and the text contents as the input must result in a list of nodes
that consists only of link, style, and meta elements that
would be conforming if they were children of the noscript element, and no parse errors.
The noscript element has no other requirements. In particular, children of the
noscript element are not exempt from form submission, scripting, and so
forth, even when scripting is enabled for the element.
<form action="calcSquare.php">
<p>
<label for=x>Number</label>:
<input id="x" name="x" type="number">
</p>
<script>
var x = document.getElementById('x');
var output = document.createElement('p');
output.textContent = 'Type a number; it will be squared right then!';
x.form.appendChild(output);
x.form.onsubmit = function () { return false; }
x.oninput = function () {
var v = x.valueAsNumber;
output.textContent = v + ' squared is ' + v * v;
};
</script>
<noscript>
<input type=submit value="Calculate Square">
</noscript>
</form>
<form action="calcSquare.php">
<p>
<label for=x>Number</label>:
<input id="x" name="x" type="number">
</p>
<input id="submit" type=submit value="Calculate Square">
<script>
var x = document.getElementById('x');
var output = document.createElement('p');
output.textContent = 'Type a number; it will be squared right then!';
x.form.appendChild(output);
x.form.onsubmit = function () { return false; }
x.oninput = function () {
var v = x.valueAsNumber;
output.textContent = v + ' squared is ' + v * v;
};
var submit = document.getElementById('submit');
submit.parentNode.removeChild(submit);
</script>
</form>
Each template element has an associated DocumentFragment object that
is its template contents. When a template element is created, the user
agent must run the following steps to establish the template contents:
A Documentdoc's appropriate template contents owner
document is the Document returned by the following algorithm:
If doc is not a Document created by this algorithm, run
these substeps:
If doc does not yet have an associated inert template
document then run these substeps:
Let new doc be a new Document (that does not have a
browsing context). This is "a Document created by this algorithm"
for the purposes of the step above.
Each Document not created by this algorithm thus gets a single
Document to act as its proxy for owning the template contents of all
its template elements, so that they aren't in a browsing context and
thus remain inert (e.g. scripts do not run). Meanwhile, template elements inside
Document objects that are created by this algorithm just reuse the same
Document owner for their contents.
Return doc.
When a template element changes ownerDocument, the user agent must run the following
steps:
<!DOCTYPE html>
<title>Cat data</title>
<script>
// Data is hard-coded here, but could come from the server
var data = [
{ name: 'Pillar', color: 'Ticked Tabby', sex: 'Female (neutered)', legs: 3 },
{ name: 'Hedral', color: 'Tuxedo', sex: 'Male (neutered)', legs: 4 },
];
</script>
<table>
<thead>
<tr>
<th>Name <th>Color <th>Sex <th>Legs
<tbody>
<template id="row">
<tr><td><td><td><td>
</template>
</table>
<script>
var template = document.querySelector('#row');
for (var i = 0; i < data.length; i += 1) {
var cat = data[i];
var clone = template.content.cloneNode(true);
var cells = clone.querySelectorAll('td');
cells[0].textContent = cat.name;
cells[1].textContent = cat.color;
cells[2].textContent = cat.sex;
cells[3].textContent = cat.legs;
template.parentNode.appendChild(clone);
}
</script>
4.12.3.1 Interaction of template elements with XSLT and XPath
この節は非規範的である。
This specification does not define how XSLT and XPath interact with the template
element. However, in the absence of another specification actually defining this, here are some
guidelines for implementors, which are intended to be consistent with other processing described
in this specification:
An XSLT processor that outputs a DOM needs to ensure that nodes that would go into a
template element are instead placed into the element's template
contents.
canvas要素は、要素ビットマップの大きさを制御するwidthとheightの2つの属性を持つ。指定される場合、これらの属性は妥当な非負の整数である値を持たなければならない。The rules for parsing non-negative integers must be used to obtain their numeric values. If an attribute is missing, or if parsing its value returns an error, then the default value must be used instead. The width attribute defaults to 300, and the height attribute defaults to 150.
The bitmaps of canvas elements, as well as some of the bitmaps of rendering
contexts, such as those described in the HTML Canvas 2D Context specification
[CANVAS2D],
have an origin-clean flag, which can
be set to true or false. Initially, when the canvas element is created, its bitmap's
origin-clean flag must be set to true.
A canvas bitmap can also have a hit region list, as described in the
CanvasRenderingContext2D section below.
A canvas element can have a rendering context bound to it. Initially, it does not
have a bound rendering context. To keep track of whether it has a rendering context or not, and
what kind of rendering context it is, a canvas also has a canvas context mode, which is initially none but can be changed to either direct-2d, direct-webgl, indirect, or proxied by algorithms defined in this specification.
When its canvas context mode is none, a canvas element has no rendering context,
and its bitmap must be fully transparent black with an intrinsic width equal to the numeric value
of the element's width attribute and an intrinsic height
equal to the numeric value of the element's height
attribute, those values being interpreted in CSS pixels, and being updated as the attributes are
set, changed, or removed.
When a canvas element represents embedded content, it provides
a paint source whose width is the element's intrinsic width, whose height is the element's
intrinsic height, and whose appearance is the element's bitmap.
Whenever the width and height content attributes are set, removed, changed, or
redundantly set to the value they already have, if the canvas context mode is direct-2d, the user agent must set bitmap dimensions to the numeric values of
the width and height content attributes.
The width and height IDL attributes must reflect the
respective content attributes of the same name, with the same defaults.
There are two ways for a canvas element to acquire a rendering context: the
canvas element can provide one via the getContext() method, and one can be assigned to it via the
setContext() method. In addition, the whole issue of a
rendering context can be taken out of the canvas element's hands and passed to a
CanvasProxy object, which itself can then be assigned a rendering context using its
setContext() method.
These three methods are mutually exclusive; calling any of the three makes the other two start
throwing InvalidStateError exceptions when called.
Each rendering context has a context bitmap
mode, which is one of fixed, unbound, or bound.
Initially, rendering contexts must be in the unbound
mode.
The getContext(contextId, arguments...) method of the canvas element, when invoked,
must run the steps in the cell of the following table whose column header describes the
canvas element's canvas context mode
and whose row header describes the method's first argument.
Set the canvas element's context
mode to direct-2d, obtain a
CanvasRenderingContext2D object as defined in the HTML Canvas 2D Context
specification [CANVAS2D], set the obtained
CanvasRenderingContext2D object's
context bitmap mode to
fixed, and return the
CanvasRenderingContext2D object
Return the same object as was return the last time the method was invoked with this same
argument.
* Vendors may define experimental contexts using the syntax vendorname-context, for example,
moz-3d.
† For example, the "webgl" value in the case of a user agent having exhausted the
graphics hardware's abilities and having no software fallback implementation.
‡ The second (and subsequent) argument(s) to the method, if
any, are ignored in all cases except this one. See the WebGL specification for
details.
The probablySupportsContext(contextId,
arguments...) method of the canvas element, when
invoked, must return false if calling getContext() on
the same object and with the same arguments would definitely return null at this time, and true
otherwise.
The setContext(context) method of the canvas element, when invoked, must
run the following steps:
If the canvas element's bitmap has no pixels (i.e. either its horizontal
dimension or its vertical dimension is zero) then return the string "data:," and abort these steps. (This is the shortest data: URL; it represents the empty string in a text/plain resource.)
Return, but continue running these steps asynchronously.
If callback is null, abort these steps.
Queue a task to invoke the FileCallbackcallback with result as its argument. The task
source for this task is the canvas blob serialization task source.
<!DOCTYPE HTML>
<title>Clock</title>
<canvas></canvas>
<script>
var canvas = document.getElementsByTagName('canvas')[0];
var proxy = canvas.transferControlToProxy();
var worker = new Worker('clock.js');
worker.postMessage(proxy, [proxy]);
</script>
次に、ワーカー：
onmessage = function (event) {
var context = new CanvasRenderingContext2D();
event.data.setContext(context); // event.data is the CanvasProxy object
setInterval(function () {
context.clearRect(0, 0, context.width, context.height);
context.fillText(new Date(), 0, 100);
context.commit();
}, 1000);
};
4.12.4.2 Color spaces and color correction
The canvas APIs must perform color correction at only two points: when rendering
images with their own gamma correction and color space information onto a bitmap, to convert the
image to the color space used by the bitmaps (e.g. using the 2D Context's drawImage() method with an HTMLImageElement
object), and when rendering the actual canvas bitmap to the output device.
Thus, in the 2D context, colors used to draw shapes onto the canvas will exactly
match colors obtained through the getImageData() method.
The toDataURL() method must not include color space
information in the resources they return. Where the output format allows it, the color of pixels
in resources created by toDataURL() must match those
returned by the getImageData() method.
In user agents that support CSS, the color space used by a canvas element must
match the color space used for processing any colors for that element in CSS.
The gamma correction and color space information of images must be handled in such a way that
an image rendered directly using an img element would use the same colors as one
painted on a canvas element that is then itself rendered. Furthermore, the rendering
of images that have no color correction information (such as those returned by the toDataURL() method) must be rendered with no color
correction.
Thus, in the 2D context, calling the drawImage() method to render the output of the toDataURL() method to the canvas, given the appropriate
dimensions, has no visible effect.
4.12.4.3 ビットマップをファイルにシリアライズする
When a user agent is to create a serialization of the bitmap as a file, optionally
with some given arguments, and optionally with a native
flag set, it must create an image file in the format given by the first value of arguments, or, if there are no arguments, in the PNG format. [PNG]
If the native flag is set, or if the bitmap has one pixel per coordinate
space unit, then the image file must have the same pixel data (before compression, if applicable)
as the bitmap, and if the file format used supports encoding resolution metadata, the resolution
of that bitmap (device pixels per coordinate space units being interpreted as image pixels per CSS
pixel) must be given as well.
Otherwise, the image file's pixel data must be the bitmap's pixel data scaled to one image
pixel per coordinate space unit, and if the file format used supports encoding resolution
metadata, the resolution must be given as 96dpi (one image pixel per CSS pixel).
If arguments is not empty, the first value must be interpreted as a MIME type giving the format to use. If the type has any parameters, it
must be treated as not supported.
For example, the value "image/png" would mean to generate a PNG
image, the value "image/jpeg" would mean to generate a JPEG image, and the value
"image/svg+xml" would mean to generate an SVG image (which would require that the
user agent track how the bitmap was generated, an unlikely, though potentially awesome,
feature).
User agents must support PNG ("image/png"). User agents may support other types.
If the user agent does not support the requested type, it must create the file using the PNG
format. [PNG]
For image types that do not support an alpha channel, the serialised image must be the bitmap
image composited onto a solid black background using the source-over operator.
If the first argument in arguments gives a type corresponding to one of the
types given in the first column of the following table, and the user agent supports that type,
then the subsequent arguments, if any, must be treated as described in the second cell of that
row.
シリアル化メソッドの引数
型
他の引数
参照
image/jpeg
The second argument, if it is a number in the range 0.0 to 1.0
inclusive, must be treated as the desired quality level. If it is not a number or is outside that range, the user agent must use its
default value, as if the argument had been omitted.
For the purposes of these rules, an argument is considered to be a number if it is converted to
an IDL double value by the rules for handling arguments of type any in the
Web IDL specification. [WEBIDL]
Other arguments must be ignored and must not cause the user agent to throw an exception. A
future version of this specification will probably define other parameters to be passed to these
methods to allow authors to more carefully control compression settings, image metadata, etc.
Information leakage can occur if scripts from one origin can
access information (e.g. read pixels) from images from another origin (one that isn't the same).
To mitigate this, bitmaps used with canvas elements are defined to have a flag
indicating whether they are origin-clean. All
bitmaps start with their origin-clean set to
true. The flag is set to false when cross-origin images or fonts are used.
The toDataURL(), toBlob(), and getImageData() methods check the flag and will
throw a SecurityError exception rather than leak cross-origin data.
The flag can be reset in certain situations; for example, when a
CanvasRenderingContext2D is bound to a new canvas, the bitmap is cleared
and its flag reset.
<header>
<h2>3D films set for popularity slide </h2>
<p>First drop in 3D box office projected for this year despite hotly tipped summer blockbusters,
according to Fitch Ratings report</p>
</header>
この例は、AbbotとCostelloの有名なスケッチ、Who's on firstからの抽出物を用いてこれを示す：
<p> Costello: Look, you gotta first baseman?
<p> Abbott: Certainly.
<p> Costello: Who's playing first?
<p> Abbott: That's right.
<p> Costello becomes exasperated.
<p> Costello: When you pay off the first baseman every month, who gets the money?
<p> Abbott: Every dollar of it.
<p> <data value="1319898155">14:22</data> <b>egof</b> I'm not that nerdy, I've only seen 30% of the star trek episodes
<p> <data value="1319898192">14:23</data> <b>kaj</b> if you know what percentage of the star trek episodes you have seen, you are inarguably nerdy
<p> <data value="1319898200">14:23</data> <b>egof</b> it's unarguably
<p> <data value="1319898228">14:23</data> <i>* kaj blinks</i>
<p> <data value="1319898260">14:24</data> <b>kaj</b> you are not helping your case
<p> Next, you meet a fisherman. You can say one of several greetings:
<dl>
<dt> "Hello there!"
<dd>
<p> He responds with "Hello, how may I help you?"; you can respond with:
<dl>
<dt> "I would like to buy a fish."
<dd> <p> He sells you a fish and the conversation finishes.
<dt> "Can I borrow your boat?"
<dd>
<p> He is surprised and asks "What are you offering in return?".
<dl>
<dt> "Five gold." (if you have enough)
<dt> "Ten gold." (if you have enough)
<dt> "Fifteen gold." (if you have enough)
<dd> <p> He lends you his boat. The conversation ends.
<dt> "A fish." (if you have one)
<dt> "A newspaper." (if you have one)
<dt> "A pebble." (if you have one)
<dd> <p> "No thanks", he replies. Your conversation options
at this point are the same as they were after asking to borrow
his boat, minus any options you've suggested before.
</dl>
</dd>
</dl>
</dd>
<dt> "Vote for me in the next election!"
<dd> <p> He turns away. The conversation finishes.
<dt> "Sir, are you aware that your fish are running away?"
<dd>
<p> He looks at you skeptically and says "Fish cannot run, sir".
<dl>
<dt> "You got me!"
<dd> <p> The fisherman sighs and the conversation ends.
<dt> "Only kidding."
<dd> <p> "Good one!" he retorts. Your conversation options at this
point are the same as those following "Hello there!" above.
<dt> "Oh, then what are they doing?"
<dd> <p> He looks at his fish, giving you an opportunity to steal
his boat, which you do. The conversation ends.
</dl>
</dd>
</dl>
<section>
<h1>Dialogue</h1>
<p><small>Some characters repeat their lines in order each time you interact
with them, others randomly pick from amongst their lines. Those who respond in
order have numbered entries in the lists below.</small>
<h2>The Shopkeeper</h2>
<ul>
<li>How may I help you?
<li>Fresh apples!
<li>A loaf of bread for madam?
</ul>
<h2>The pilot</h2>
<p>Before the accident:
<ul>
</li>I'm about to fly out, sorry!
</li>Sorry, I'm just waiting for flight clearance and then I'll be off!
</ul>
<p>After the accident:
<ol>
<li>I'm about to fly out, sorry!
<li>Ok, I'm not leaving right now, my plane is being cleaned.
<li>Ok, it's not being cleaned, it needs a minor repair first.
<li>Ok, ok, stop bothering me!Truth is, I had a crash.
</ol>
<h2>Clan Leader</h2>
<p>During the first clan meeting:
<ul>
<li>Hey, have you seen my daughter?I bet she's up to something nefarious again...
<li>Nice weather we're having today, eh?
<li>The name is Bailey, Jeff Bailey. How can I help you today?
<li>A glass of water?Fresh from the well!
</ul>
<p>After the earthquake:
<ol>
<li>Everyone is safe in the shelter, we just have to put out the fire!
<li>I'll go and tell the fire brigade, you keep hosing it down!
</ol>
</section>
<p> Announcer: Number 16: The <i>hand</i>.
<p> Interviewer: Good evening. I have with me in the studio tonight
Mr Norman St John Polevaulter, who for the past few years has been
contradicting people. Mr Polevaulter, why <em>do</em> you
contradict people?
<p> Norman: I don't. <sup><a href="#fn1" id="r1">[1]</a></sup>
<p> Interviewer: You told me you did!
...
<section>
<p id="fn1"><a href="#r1">[1]</a> This is, naturally, a lie,
but paradoxically if it were true he could not say so without
contradicting the interviewer and thus making it false.</p>
</section>
<p> <span class="speaker">Customer</span>: I will not buy this record, it is scratched.
<p> <span class="speaker">Shopkeeper</span>: I'm sorry?
<p> <span class="speaker">Customer</span>: I will not buy this record, it is scratched.
<p> <span class="speaker">Shopkeeper</span>: No no no, this's'a tobacconist's.
<aside role="note">
<p>In 1970, the British Empire lay in ruins, and foreign
nationalists frequented the streets — many of them Hungarians
(not the streets — the foreign nationals). Sadly, Alexander
Yalt has been publishing incompetently-written phrase books.
</aside>
The Selectors specification leaves the case-sensitivity of element names, attribute names, and
attribute values to be defined by the host language. [SELECTORS]
The Selectors specification defines that ID and class selectors, when matched
against elements in documents that are in quirks mode, will be work in an ASCII
case-insensitive.
When comparing a CSS element type selector to the names of HTML elements in
HTML documents, the CSS element type selector must first be converted to ASCII
lowercase. The same selector when compared to other elements must be compared according to
its original case. In both cases, the comparison is case-sensitive.
When comparing the name part of a CSS attribute selector to the names of namespace-less
attributes on HTML elements in HTML documents, the name part of the CSS
attribute selector must first be converted to ASCII lowercase. The same selector when
compared to other attributes must be compared according to its original case. In both cases, the
comparison is case-sensitive.
There are a number of dynamic selectors that can be used with HTML. This section defines when
these selectors match HTML elements. [SELECTORS][CSSUI]
:link
:visited
All a elements that have an href
attribute, all area elements that have an href attribute, and all link elements that have
an href attribute, must match one of :link and :visited.
Other specifications might apply more specific rules regarding how these elements are to
match these pseudo-classes, to mitigate some privacy concerns that apply with straightforward
implementations of this requirement.
:active
The :active pseudo-class is defined to match an element
while an
element is being activated by the user. For the purposes of defining the :active pseudo-class only, an HTML user agent must consider an
element as being activated if it is:
An element falling into one of the following categories between the time the user begins to
indicate an intent to trigger the element's activation behavior and either the
time the user stops indicating an intent to trigger the element's activation
behavior, or the time the element's activation behavior has finished
running, which ever comes first:
For example, if the user is using a keyboard to push a button
element by pressing the space bar, the element would match this pseudo-class in between the
time that the element received the keydown event and the
time the element received the keyup event.
An element that the user indicates using a pointing device while that pointing device is in
the "down" state (e.g. for a mouse, between the time the mouse button is pressed and the time
it is depressed).
An element that has a descendant that is currently matching the :active pseudo-class.
:hover
The :hover pseudo-class is defined to match an element while the
user designates an element with a pointing device. For the purposes of defining the
:hover pseudo-class only, an HTML user agent must consider
an element as being one that the user designates if it is:
An element that the user indicates using a pointing device.
An element that has a descendant that the user indicates using a pointing device.
If the user designates the element with ID "a" with their pointing
device, then the p element (and all its ancestors not shown in the snippet above),
the label element, the element with ID "a", and the element
with ID "c" will match the :hover
pseudo-class. The element with ID "a" matches it from condition 1, the
label and p elements match it because of condition 2 (one of their
descendants is designated), and the element with ID "c" matches it
through condition 3 (its label element matches :hover). However, the element with ID "b"
does not match :hover: its descendant is not
designated, even though it matches :hover.
:enabled
The :enabled pseudo-class must match any element
falling into one of the following categories:
The :read-write pseudo-class must match any element
falling into one of the following categories, which for the purposes of Selectors are thus
considered user-alterable: [SELECTORS]
input elements to which the readonly
attribute applies, and that are mutable (i.e. that do not
have the readonly attribute specified and that are not
disabled)
Another section of this specification defines the target element used with
the :target pseudo-class.
This specification does not define when an element matches the :focus or :lang() dynamic
pseudo-classes, as those are all defined in sufficient detail in a language-agnostic fashion in
the Selectors specification. [SELECTORS]
5 ユーザーとの対話処理
5.1hidden属性
すべてのHTML要素はhiddenコンテンツ属性設定を持ってもよい。hidden属性は真偽属性である。要素で指定される場合、それは、要素がまだないこと、またはもはやページの現在の状態には直接関係がない、または、ユーザーが直接アクセスするのとは対照的に、ページの他の部分で再利用するコンテンツを宣言するために使用されていることを示す。User agents should not render elements that have the hidden attribute specified. This requirement may be implemented indirectly through the style layer. For example, an HTML+CSS user agent could implement these requirements using the rules suggested in the Rendering section.
HTMLの特定の要素は、ユーザーがアクティブにすることができることを意味する、アクティベーション動作を持つ。This triggers a sequence of events dependent on the activation mechanism, and normally culminating in a click 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.
Each element has a click in progress flag, initially set to false.
When a user agent is to run synthetic click activation steps on an element, the user
agent must run the following steps:
If the element's click in progress flag is set to true, then abort
these steps.
Set the click in progress flag on the element to true.
Set the click in progress flag on the element to false.
When a pointing device is clicked, the user agent must run authentic click activation
steps instead of firing the click event When a user agent is to run authentic click activation steps for a given event event, it must follow these steps:
Let target be the element designated by the user (the target of event).
If target is a canvas element, run the canvas
MouseEvent rerouting steps. If this changes event's
target, then let target be the new target.
Set the click in progress flag on target to
false.
The algorithms above don't run for arbitrary synthetic events dispatched by author
script. The click() method can be used to make the run
synthetic click activation steps algorithm happen programmatically.
Click-focusing behavior (e.g. the focusing of a text field when user clicks in
one) typically happens before the click, when the mouse button is first depressed, and is
therefore not discussed here.
Given an element target, the nearest activatable element is the
element returned by the following algorithm:
If target has a defined activation behavior, then return
target and abort these steps.
If target has a parent element, then set target to
that parent element and return to the first step.
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 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 post-click activation steps on an element, it must run
the activation behavior defined for that element, if any. Activation behaviors can
refer to the click event that was fired by the steps above
leading up to this point.
<map id=wallmap><area alt="Enter Door" coords="10,10,100,200" href="door.html"></map>
...
<img src="images/innerwall.jpeg" alt="There is a white wall here, with a door." usemap="#wallmap">
...
<img src="images/outerwall.jpeg" alt="There is a red wall here, with a door." usemap="#wallmap">
If current object is an area element's shape, append
that area element to output.
Otherwise, if current object is a focusable area whose DOM
anchor is an element that is not current object itself, append that
DOM anchor element to output.
Each element can have a tabindex focus flag set, as defined
below. This flag is a factor that contributes towards determining whether an element is a
focusable area, as described in the previous section.
If the tabindex attribute is specified on an element, it
must be parsed using the rules for parsing integers. The attribute's values, or lack
thereof, must be interpreted as follows:
If the attribute is omitted or parsing the value returns an error
Elements with a draggable attribute set, if that would
enable the user agent to allow the user to begin a drag operations for those elements without
the use of a pointing device
One valid reason to ignore the platform conventions and always allow an element
to be focused (by setting its tabindex focus flag) would be if the user's only
mechanism for activating an element is through a keyboard action that triggers the focused
element.
One valid reason to ignore the requirement that sequential focus navigation not
allow the author to lead to the element would be if the user's only mechanism for moving the
focus is sequential focus navigation. For instance, a keyboard-only user would be unable to
click on a text field with a negative tabindex, so that
user's user agent would be well justified in allowing the user to tab to the control
regardless.
after any focusable area whose DOM anchor is an element whose tabindex attribute has a value greater than zero but less than
the value of the tabindex attribute on candidate,
after any focusable area whose DOM anchor is an element whose tabindex attribute has a value equal to the value of the tabindex attribute on candidate but that is
earlier in the document in tree order than candidate,
before any focusable area whose DOM anchor is an element whose tabindex attribute has a value equal to the value of the tabindex attribute on candidate but that is
later in the document in tree order than candidate, and
This means that an element that is only focusable because of its tabindex attribute will fire a click event in response to a non-mouse activation (e.g. hitting the
"enter" key while the element is focused).
The tabIndex IDL attribute must
reflect the value of the tabindex content
attribute. Its default value is 0 for elements that are focusable and −1 for elements that
are not focusable.
For example, this might happen because an element is removed from its
Document, or has a hidden attribute added. It might
also happen to an input element when the element gets disabled.
Let old focus target be whatever the currently focused area of the top-level browsing
context was immediately before this algorithm became applicable (e.g. before the element
was disabled, or the dialog was closed, or whatever caused this algorithm to run).
If old focus target and new focus target are the
same, abort these steps.
Let new chain be the focus chain of new
focus target.
Run the focus update steps with old chain, new chain, and new focus target respectively.
The focus update steps, given an old chain, a new chain, and a new focus target respectively, are as
follows:
If the last entry in old chain and the last entry in new chain are the same, pop the last entry from old chain
and the last entry from new chain and redo this step.
For each entry entry in old chain, in order, run
these substeps:
If entry is an input
element, and the change event applies to the element, and the element does not have a
defined activation behavior, and the user has changed the element's value or its list of selected files while the control was focused
without committing that change, then fire a simple event that bubbles named change at the element.
If entry is an element, let blur event target be
entry.
If entry is a Document object, let blur
event target be that Document object's Window object.
Otherwise, let blur event target be null.
If entry is the last entry in old chain, and
entry is an Element, and the last entry in new
chain is also an Element, then let related blur target
be the last entry in new chain. Otherwise, let related blur
target be null.
If blur event target is not null, fire a focus event
named blur at blur event target, with
related blur target as the related target.
In some cases, e.g. if entry is an area
element's shape, a scrollable region, or a viewport, no event is fired.
Apply any relevant platform-specific conventions for focusing new focus
target. (For example, some platforms select the contents of a text field when that field is
focused.)
For each entry entry in new chain, in reverse
order, run these substeps:
If entry is an element, let focus event target be
entry.
If entry is a Document object, let focus
event target be that Document object's Window object.
Otherwise, let focus event target be null.
If entry is the last entry in new chain, and
entry is an Element, and the last entry in old
chain is also an Element, then let related focus target
be the last entry in old chain. Otherwise, let related
focus target be null.
If focus event target is not null, fire a focus event
named focus at focus event target, with
related focus target as the related target.
In some cases, e.g. if entry is an area
element's shape, a scrollable region, or a viewport, no event is fired.
When a user agent is required to fire a focus event named e at
an element t and with a given related target r, the user
agent must create a trustedFocusEvent
object, initialise it to have the given name e, to not bubble, to not be
cancelable, and to have the relatedTarget
attribute initialised to r, and must then dispatch the newly created FocusEvent object
at the specified target element t.
When a key event is to be routed in a top-level browsing context, the user agent
must run the following steps:
When the user requests that focus move from the currently focused area of a top-level
browsing context to the next or previous focusable area (e.g. as the default action
of pressing the tab key), or when the user requests that focus sequentially move to a
top-level browsing context in the first place (e.g. from the browser's location bar),
the user agent must use the following algorithm:
Let candidate be the result of running the sequential
navigation search algorithm with starting point, direction, and selection mechanism as the
arguments.
If candidate is not null, then run the focusing steps
for candidate and abort these steps.
For example, if direction is backward, then the
last focusable control before the browser's rendering area would be the control to focus.
If the user agent has no focusable controls — a kiosk-mode browser, for instance
— then the user agent may instead restart these steps with the starting point being the top-level browsing context itself.
The sequential navigation search algorithm consists of the following steps. This
algorithm takes three arguments: starting point, direction,
and selection mechanism.
Pick the appropriate cell from the following table, and follow the instructions in that
cell.
The appropriate cell is the one that is from the column whose header describes direction and from the first row whose header describes starting point and selection mechanism.
The blur() method on the Window
object, when invoked, provides a hint to the user agent that the script believes the user probably
is not currently interested in the contents of the browsing context of the
Window object on which the method was invoked, but that the contents might become
interesting again in the future.
User agents are encouraged to ignore calls to this blur()
method entirely.
Historically, the focus() and blur() methods actually affected the system-level focus of the
system widget (e.g. tab or window) that contained the browsing context, but hostile
sites widely abuse this behavior to the user's detriment.
The focus() method on elements, when invoked, must
run the following algorithm:
If the element is marked as locked for focus, then abort these steps.
The blur() method, when invoked, should run the
unfocusing steps for the element on which the method was called. User agents may
selectively or uniformly ignore calls to this method for usability reasons.
For example, if the blur() method is unwisely
being used to remove the focus ring for aesthetics reasons, the page would become unusable by
keyboard users. Ignoring calls to this method would thus allow keyboard users to interact with the
page.
An element's assigned access key is a key combination derived from the element's
accesskey content attribute. Initially, an element must not
have an assigned access key.
Whenever an element's accesskey attribute is set, changed,
or removed, the user agent must update the element's assigned access key by running
the following steps:
If the element has no accesskey attribute, then skip
to the fallback step below.
For each value in keys in turn, in the order the tokens appeared in the
attribute's value, run the following substeps:
If the value is not a string exactly one Unicode code point in length, then skip the
remainder of these steps for this value.
If the value does not correspond to a key on the system's keyboard, then skip the
remainder of these steps for this value.
If the user agent can find a mix of zero or more modifier keys that, combined with the
key that corresponds to the value given in the attribute, can be used as the access key, then
the user agent may assign that combination of keys as the element's assigned access
key and abort these steps.
Fallback: Optionally, the user agent may assign a key combination of its choosing
as the element's assigned access key and then abort these steps.
Once a user agent has selected and assigned an access key for an element, the user agent should
not change the element's assigned access key unless the accesskey content attribute is changed or the element is moved to
another Document.
When the user presses the key combination corresponding to the assigned access key
for an element, if the element defines a command, the
command's Hidden State facet is false (visible),
the command's Disabled State facet is also false
(enabled), the element is in a Document that has an associated
browsing context, and neither the element nor any of its ancestors has a hidden attribute specified, then the user agent must trigger the Action of the command.
User agents might expose elements that have
an accesskey attribute in other ways as well, e.g. in a menu
displayed in response to a specific key combination.
The accessKey IDL attribute must
reflect the accesskey content attribute.
The accessKeyLabel IDL attribute must return
a string that represents the element's assigned access key, if any. If the element
does not have one, then the IDL attribute must return the empty string.
The contentEditable IDL attribute, on
getting, must return the string "true" if the content attribute is set to
the true state, "false" if the content attribute is set to the false state,
and "inherit" otherwise. On setting, if the new value is an ASCII
case-insensitive match for the string "inherit" then the content
attribute must be removed, if the new value is an ASCII case-insensitive match for
the string "true" then the content attribute must be set to the string
"true", if the new value is an ASCII case-insensitive match for
the string "false" then the content attribute must be set to the string
"false", and otherwise the attribute setter must throw a
SyntaxError exception.
The isContentEditable IDL attribute, on
getting, must return true if the element is either an editing host or
editable, and false otherwise.
The designMode IDL attribute on the
Document object takes two values, "on" and "off". On setting, the new value must be compared in an ASCII
case-insensitive manner to these two values; if it matches the "on"
value, then designMode must be enabled, and if it
matches the "off" value, then designMode must be disabled. Other values must be
ignored.
On getting, if designMode is enabled, the IDL
attribute must return the value "on"; otherwise it is disabled, and the
attribute must return the value "off".
The last state set must persist until the document is destroyed or the state is changed.
Initially, documents must have their designMode
disabled.
When the designMode changes from being disabled to
being enabled, the user agent must synchronously reset the document's active range's
start and end boundary points to be at the start of the Document and then run the
focusing steps for the root element of the Document, if any.
User agents can support the checking of spelling and grammar of editable text, either in form
controls (such as the value of textarea elements), or in elements in an editing
host (e.g. using contenteditable).
For each element, user agents must establish a default
behavior, either through defaults or through preferences expressed by the user. There are
three possible default behaviors for each element:
true-by-default
The element will be checked for spelling and grammar if its contents are editable.
false-by-default
The element will never be checked for spelling and grammar.
inherit-by-default
The element's default behavior is the same as its parent element's. Elements that have no
parent element cannot have this as their default behavior.
The spellcheck IDL attribute, on getting, must
return true if the element's spellcheck content attribute is
in the true state, or if the element's spellcheck
content attribute is in the default state and the element's default behavior is true-by-default, or if the element's spellcheck content attribute is in the default state and the
element's default behavior is inherit-by-default and the element's parent
element's spellcheck IDL attribute would return true;
otherwise, if none of those conditions applies, then the attribute must instead return false.
The spellcheck IDL attribute is not affected
by user preferences that override the spellcheck content
attribute, and therefore might not reflect the actual spellchecking state.
On setting, if the new value is true, then the element's spellcheck content attribute must be set to the literal string
"true", otherwise it must be set to the literal string "false".
User agents must only consider the following pieces of text as checkable for the purposes of
this feature:
For text that is part of a Text node, the element with which the text is
associated is the element that is the immediate parent of the first character of the word,
sentence, or other piece of text. For text in attributes, it is the attribute's element. For the
values of input and textarea elements, it is the element itself.
To determine if a word, sentence, or other piece of text in an applicable element (as defined
above) is to have spelling- and grammar-checking enabled, the UA must use the following
algorithm:
If the user has disabled the checking for this text, then the checking is disabled.
Otherwise, if the user has forced the checking for this text to always be enabled, then the
checking is enabled.
Otherwise, if the element with which the text is associated has a spellcheck content attribute, then: if that attribute is in the
true state, then checking is enabled; otherwise, if that attribute is in the false
state, then checking is disabled.
Otherwise, if there is an ancestor element with a spellcheck content attribute that is not in the default
state, then: if the nearest such ancestor's spellcheck
content attribute is in the true state, then checking is enabled; otherwise, checking is
disabled.
Otherwise, if the element's parent element has its checking enabled, then checking
is enabled.
Otherwise, checking is disabled.
If the checking is enabled for a word/sentence/text, the user agent should indicate spelling
and grammar errors in that text. User agents should take into account the other semantics given in
the document when suggesting spelling and grammar corrections. User agents may use the language of
the element to determine what spelling and grammar rules to use, or may use the user's preferred
language settings. UAs should use input element attributes such as pattern to ensure that the resulting value is valid, where
possible.
If checking is disabled, the user agent should not indicate spelling or grammar errors for that
text.
Even when checking is enabled, user agents may opt to not report spelling or grammar errors in
text that the user agent deems the user has no interest in having checked (e.g. text that was
already present when the page was loaded, or that the user did not type, or text in controls that
the user has not focused, or in parts of e-mail addresses that the user agent is not confident
were misspelt). The forceSpellCheck() method,
when invoked on an element, must override this behavior, forcing the user agent to consider all
spelling and grammar errors in text in that element for which checking is enabled to be of
interest to the user.
The element with ID "a" in the following example would be the one used to determine if the
word "Hello" is checked for spelling errors. In this example, it would not be.
The element with ID "b" in the following example would have checking enabled (the leading
space character in the attribute's value on the input element causes the attribute
to be ignored, so the ancestor's value is used instead, regardless of the default).
However it is implemented, drag-and-drop operations must have a starting point (e.g. where the
mouse was clicked, or the start of the selection or element that was selected for the drag), may
have any number of intermediate steps (elements that the mouse moves over during a drag, or
elements that the user picks as possible drop points as he cycles through possibilities), and must
either have an end point (the element above which the mouse button was released, or the element
that was finally selected), or be canceled. The end point must be the last element selected as a
possible drop point before the drop occurs (so if the operation is not canceled, there must be at
least one element in the middle step).
<p>What fruits do you like?</p>
<ol ondragstart="dragStartHandler(event)">
<li draggable="true" data-value="fruit-apple">Apples</li>
<li draggable="true" data-value="fruit-orange">Oranges</li>
<li draggable="true" data-value="fruit-pear">Pears</li>
</ol>
<script>
var internalDNDType = 'text/x-example'; // set this to something specific to your site
function dragStartHandler(event) {
if (event.target instanceof HTMLLIElement) {
// use the element's data-value="" attribute as the value to be moving:
event.dataTransfer.setData(internalDNDType, event.target.dataset.value);
event.dataTransfer.effectAllowed = 'move'; // only allow moves
} else {
event.preventDefault(); // don't allow selection to be dragged
}
}
</script>
<p>Drop your favorite fruits below:</p>
<ol dropzone="move string:text/x-example" ondrop="dropHandler(event)">
<!-- don't forget to change the "text/x-example" type to something
specific to your site -->
</ol>
<script>
var internalDNDType = 'text/x-example'; // set this to something specific to your site
function dropHandler(event) {
var li = document.createElement('li');
var data = event.dataTransfer.getData(internalDNDType);
if (data == 'fruit-apple') {
li.textContent = 'Apples';
} else if (data == 'fruit-orange') {
li.textContent = 'Oranges';
} else if (data == 'fruit-pear') {
li.textContent = 'Pears';
} else {
li.textContent = 'Unknown Fruit';
}
event.target.appendChild(li);
}
</script>
The dropEffect attribute controls
the drag-and-drop feedback that the user is given during a drag-and-drop operation. When the
DataTransfer object is created, the dropEffect attribute is set to a string value. On
getting, it must return its current value. On setting, if the new value is one of "none", "copy", "link", or "move", then the attribute's current value must be set to the new value. Other
values must be ignored.
The effectAllowed attribute is
used in the drag-and-drop processing model to initialise the dropEffect attribute during the dragenter and dragover events.
When the DataTransfer object is created, the effectAllowed attribute is set to a string value. On
getting, it must return its current value. On setting, if drag data store's mode is the read/write
mode and the new value is one of "none", "copy", "copyLink", "copyMove", "link", "linkMove", "move", "all", or "uninitialized", then the attribute's current value
must be set to the new value. Otherwise it must be left unchanged.
The items attribute must return a
DataTransferItemList object associated with the DataTransfer object. The
same object must be returned each time.
The setDragImage(element,
x, y) method must run the following
steps:
If the DataTransfer object is no longer associated with a drag data
store, abort these steps. Nothing happens.
If the element argument is an img element, then set the
drag data store bitmap to the element's image (at its intrinsic size); otherwise,
set the drag data store bitmap to an image generated from the given element (the
exact mechanism for doing so is not currently specified).
The types attribute must return a
liveread only array giving the strings that
the following steps would produce. The same object must be returned each time.
Start with an empty list L.
If the DataTransfer object is no longer associated with a drag data
store, the array is empty. Abort these steps; return the empty list L.
If there are any items in the drag data store item list whose kind is File, then add an entry to the list L consisting of the string "Files". (This value can be
distinguished from the other values because it is not lowercase.)
The strings produced by these steps are those in the list L.
The getData(format) method must run the following steps:
If the DataTransfer object is no longer associated with a drag data
store, return the empty string and abort these steps.
If format equals "text", change it to "text/plain".
If format equals "url", change it to "text/uri-list" and set convert-to-URL to true.
If there is no item in the drag data store item list whose kind is Plain Unicode string and whose type string is equal to format, return the
empty string and abort these steps.
If convert-to-URL is true, then parse result as
appropriate for text/uri-list data, and then set result
to the first URL from the list, if any, or the empty string otherwise. [RFC2483]
Return result.
The setData(format, data) method must run the following steps:
If the DataTransfer object is no longer associated with a drag data
store, abort these steps. Nothing happens.
Add an item to the drag data store item list whose kind is Plain Unicode string, whose type string is equal to format, and whose data is the string
given by the method's second argument.
The clearData() method must run the
following steps:
If the DataTransfer object is no longer associated with a drag data
store, abort these steps. Nothing happens.
If the method was called with no arguments, remove each item in the drag data store
item list whose kind is Plain Unicode
string, and abort these steps.
The clearData() method does not
affect whether any files were included in the drag, so the types attribute's list might still not be empty after
calling clearData() (it would still contain the
"Files" string if any files were included in the drag).
The files attribute must return a
liveFileList sequence consisting of File objects
representing the files found by the following steps. The same object must be returned each time.
Furthermore, for a given FileList object and a given underlying file, the same
File object must be used each time.
Start with an empty list L.
If the DataTransfer object is no longer associated with a drag data
store, the FileList is empty. Abort these steps; return the empty list L.
For each item in the drag data store item list
whose kind is File , add the item's data (the file, in particular its name and contents, as well as
its type) to the list L.
The files found by these steps are those in the list L.
This version of the API does not expose the types of the files during the
drag.
The length attribute must
return zero if the object is in the disabled mode; otherwise it must return the number of
items in the drag data store item list.
The kind attribute must return the
empty string if the DataTransferItem object is in the disabled mode; otherwise
it must return the string given in the cell from the second column of the following table from the
row whose cell in the first column contains the drag data item kind of the item
represented by the DataTransferItem object:
The dataTransfer attribute of the DragEvent interface must return the value it was initialised to. オブジェクトが作成される際、この属性はnullに初期化しなければならない。It represents the context information for the event.
When a user agent is required to fire a DND event named e at an
element, using a particular drag data store, and optionally with a specific related target, the user agent must run the following steps:
If no specific related target was provided, set related target to null.
Where the table above provides possibly
appropriate alternatives, user agents may instead use the listed alternative values if
platform conventions dictate that the user has requested those alternate effects.
For example, Windows platform conventions are such that dragging while
holding the "alt" key indicates a preference for linking the data, rather than moving or copying
it. Therefore, on a Windows system, if "link" is an option according to
the table above while the "alt" key is depressed, the user agent could select that instead of
"copy" or "move".
Create a trustedDragEvent object
and initialise it to have the given name e, to bubble, to be cancelable
unless e is dragexit, dragleave, or dragend, and to have the detail attribute initialised to zero, the mouse and key
attributes initialised according to the state of the input devices as they would be for user
interaction events, the relatedTarget
attribute initialised to related target, and the dataTransfer attribute initialised to dataTransfer, the DataTransfer object created above.
If there is no relevant pointing device, the object must have its screenX, screenY, clientX, clientY, and button attributes set to 0.
Dispatch the newly created
DragEvent object at the specified target element.
Break the association between dataTransfer and the drag data
store.
5.7.5 Drag-and-drop processing model
When the user attempts to begin a drag operation, the user agent must run the following steps.
User agents must act as if these steps were run even if the drag actually started in another
document or application and the user agent was not aware that the drag was occurring until it
intersected with a document under the user agent's purview.
Determine what is being dragged, as follows:
If the drag operation was invoked on a selection, then it is the selection that is being
dragged.
Otherwise, if the drag operation was invoked on a Document, it is the first
element, going up the ancestor chain, starting at the node that the user tried to drag, that has
the IDL attribute draggable set to true. If there is no such
element, then nothing is being dragged; abort these steps, the drag-and-drop operation is never
started.
Otherwise, the drag operation was invoked outside the user agent's purview. What is being
dragged is defined by the document or application where the drag was started.
img elements and a elements with an href attribute have their draggable attribute set to true by default.
Establish which DOM node is the source node, as follows:
If it is a selection that is being dragged, then the source node is the
Text node that the user started the drag on (typically the Text node
that the user originally clicked). If the user did not specify a particular node, for example if
the user just told the user agent to begin a drag of "the selection", then the source
node is the first Text node containing a part of the selection.
Otherwise, if it is an element that is being dragged, then the source node is
the element that is being dragged.
Otherwise, the source node is part of another document or application. When this
specification requires that an event be dispatched at the source node in this case,
the user agent must instead follow the platform-specific conventions relevant to that
situation.
Multiple events are fired on the source node during the course of
the drag-and-drop operation.
Determine the list of dragged nodes, as follows:
If it is a selection that is being dragged, then the list of dragged nodes
contains, in tree order, every node that is partially or completely included in the
selection (including all their ancestors).
Dragging files can currently only happen from outside a browsing
context, for example from a file system manager application.
If the drag initiated outside of the application, the user agent must add items to the
drag data store item list as appropriate for the data being dragged, honoring
platform conventions where appropriate; however, if the platform conventions do not use MIME types to label dragged data, the user agent must make a
best-effort attempt to map the types to MIME types, and, in any case, all the drag data item type strings must be converted to ASCII
lowercase.
User agents may also add one or more items representing the selection or dragged element(s)
in other forms, e.g. as HTML.
If the list of dragged nodes is not empty, then extract the microdata from those nodes into a JSON form, and add one item to the
drag data store item list, with its properties set as follows:
If the node is an a element with an href attribute
Add to urls the result of resolving the element's href content
attribute relative to the element.
If the node is an img element with a src
attribute
Add to urls the result of resolving the element's src content attribute
relative to the element.
If urls is still empty, abort these substeps.
Let url string be the result of concatenating the strings in urls, in the order they were added, separated by a U+000D CARRIAGE RETURN U+000A
LINE FEED character pair (CRLF).
Update the drag data store default feedback as appropriate for the user agent
(if the user is dragging the selection, then the selection would likely be the basis for this
feedback; if the user is dragging an element, then that element's rendering would be used; if
the drag began outside the user agent, then the platform conventions for determining the drag
feedback should be used).
If the event is canceled, then the drag-and-drop operation should not occur; abort these
steps.
Since events with no event listeners registered are, almost by definition, never
canceled, drag-and-drop is always available to the user if the author does not specifically
prevent it.
The drag-and-drop feedback must be generated from the first of the
following sources that is available:
The drag data store bitmap, if any. In this case, the drag data store
hot spot coordinate should be used as hints for where to put the cursor relative to the
resulting image. The values are expressed as distances in CSS pixels from the left side and
from the top side of the image respectively. [CSS]
From the moment that the user agent is to initiate the drag-and-drop operation,
until the end of the drag-and-drop operation, device input events (e.g. mouse and keyboard events)
must be suppressed.
During the drag operation, the element directly indicated by the user as the drop target is
called the immediate user selection. (Only elements can be selected by the user; other
nodes must not be made available as drop targets.) However, the immediate user
selection is not necessarily the current target element, which is the element
currently selected for the drop part of the drag-and-drop operation.
The immediate user selection changes as the user selects different elements
(either by pointing at them with a pointing device, or by selecting them in some other way). The
current target element changes when the immediate user selection
changes, based on the results of event listeners in the document, as described below.
Both the current target element and the immediate user selection can
be null, which means no target element is selected. They can also both be elements in other
(DOM-based) documents, or other (non-Web) programs altogether. (For example, a user could drag
text to a word-processor.) The current target element is initially null.
In addition, there is also a current drag operation, which can take on the values
"none", "copy", "link", and
"move". Initially, it has the value "none". It is
updated by the user agent as described in the steps below.
User agents must, as soon as the drag operation is initiated and every 350ms (±200ms) thereafter for as long as the drag
operation is ongoing, queue a task to perform the following steps in sequence:
If the user agent is still performing the previous iteration of the sequence (if any) when
the next iteration becomes due, abort these steps for this iteration (effectively "skipping
missed frames" of the drag-and-drop operation).
If the previous step caused the current target element to change, and if the
previous target element was not null or a part of a non-DOM document, then fire a DND
event named dragleave at the previous target
element, with the new current target element as the specific related target.
"uninitialized", "copy", "copyLink", "copyMove", or "all"
"copy"
"copy"
"uninitialized", "link", "copyLink", "linkMove", or "all"
"link"
"link"
"uninitialized", "move", "copyMove", "linkMove", or "all"
"move"
"move"
Any other case
"none"
Otherwise, if the current target element is not a DOM element, use
platform-specific mechanisms to determine what drag operation is being performed (none, copy,
link, or move), and set the current drag operation accordingly.
Update the drag feedback (e.g. the mouse cursor) to match the current drag
operation, as follows:
Drag operation
Feedback
"copy"
Data will be copied if dropped here.
"link"
Data will be linked if dropped here.
"move"
Data will be moved if dropped here.
"none"
No operation allowed, dropping here will cancel the drag-and-drop operation.
Otherwise, if the user ended the drag-and-drop operation (e.g. by releasing the mouse button
in a mouse-driven drag-and-drop interface), or if the drag event
was canceled, then this will be the last iteration. Run the following steps, then stop the
drag-and-drop operation:
If the current drag operation is "none" (no drag
operation), or, if the user ended the drag-and-drop operation by canceling it (e.g. by hitting
the Escape key), or if the current target element is null, then the
drag operation failed. Run these substeps:
Insert the actual data of the first item in the drag data store item
list to have a drag data item type
string of "text/plain" and a drag
data item kind that is Plain Unicode string into the text field or
editing host or editable element in a manner consistent with
platform-specific conventions (e.g. inserting it at the current mouse cursor position, or
inserting it at the end of the field).
Run the appropriate steps from the following list as the default action of the dragend event:
If dropped is true, the current target element is a
text field (see below), the current drag operation is "move", and the source of the drag-and-drop operation is a selection in the
DOM that is entirely contained within an editing host
If dropped is true, the current target element is a
text field (see below), the current drag operation is "move", and the source of the drag-and-drop operation is a selection in a text
field
The user agent should delete the dragged selection from the relevant text
field.
The drag was canceled. If the platform conventions dictate that this be represented to
the user (e.g. by animating the dragged selection going back to the source of the
drag-and-drop operation), then do so.
User agents are encouraged to consider how to react to drags near the edge of
scrollable regions. For example, if a user drags a link to the bottom of the viewport on a long
page, it might make sense to scroll the page so that the user can drop the link lower on the
page.
This model is independent of which Document object the nodes involved
are from; the events are fired as described above and the rest of the processing model runs as
described above, irrespective of how many documents are involved in the operation.
The draggable IDL attribute, whose value depends
on the content attribute's in the way described below, controls whether or not the element is
draggable. Generally, only text selections are draggable, but elements whose draggable IDL attribute is true become draggable as well.
If an element's draggable content attribute has the state
true, the draggable IDL attribute must return true.
Otherwise, if the element's draggable content attribute has
the state false, the draggable IDL attribute must return
false.
Otherwise, the element's draggable content attribute has
the state auto. If the element is an img element, an object
element that represents an image, or an a element with an href content attribute, the draggable IDL attribute must return true; otherwise, the draggable IDL attribute must return false.
If the draggable IDL attribute is set to the value false,
the draggable content attribute must be set to the literal
value false. If the draggable IDL
attribute is set to the value true, the draggable content
attribute must be set to the literal value true.
A dropzone attribute specifies an operation if the dropzone processing steps result in a specified operation. The
specified operation is as given by those steps.
The dropzone processing steps are as follows.
They either result in a match or not, and separate from this result either in a specified
operation or not, as defined below.
For each value in keywords, if any, in the order that they were found in
value, run the following steps.
Let keyword be the keyword.
If keyword is one of "copy",
"move", or "link", then: run the following substeps:
If operation is still unspecified, then let operation be the string given by keyword.
Skip to the step labeled end of keyword below.
If keyword does not contain a ":" (U+003A) character, or if the
first such character in keyword is either the first character or the last
character in the string, then skip to the step labeled end of keyword below.
Let kind code be the substring of keyword from
the first character in the string to the last character in the string that is before the first
":" (U+003A) character in the string, converted to ASCII lowercase.
Jump to the appropriate step from the list below, based on the value of kind
code:
Let type be the substring of keyword from the
first character after the first ":" (U+003A) character in the string, to the last character
in the string, converted to ASCII lowercase.
End of keyword: Go on to the next keyword, if any, or the next step in the
overall algorithm, if there are no more.
The algorithm results in a match if matched is true, and does not
otherwise.
The algorithm results in a specified operation if operation is not
unspecified. The specified operation, if one is specified, is the one given by operation.
The dropzone IDL attribute must
reflect the content attribute of the same name.
<div dropzone="copy file:image/png file:image/gif file:image/jpeg" ondrop="receive(event, this)">
<p>Drop an image here to have it displayed.</p>
</div>
<script>
function receive(event, element) {
var data = event.dataTransfer.items;
for (var i = 0; i < data.length; i += 1) {
if ((data[i].kind == 'file') && (data[i].type.match('^image/'))) {
var img = new Image();
img.src = window.createObjectURL(data[i].getAsFile());
element.appendChild(img);
}
}
}
</script>
5.7.9 Security risks in the drag-and-drop model
User agents must not make the data added to the DataTransfer object during the
dragstart event available to scripts until the drop event, because otherwise, if a user were to drag sensitive
information from one document to a second document, crossing a hostile third document in the
process, the hostile document could intercept the data.
For the same reason, user agents must consider a drop to be successful only if the user
specifically ended the drag operation — if any scripts end the drag operation, it must be
considered unsuccessful (canceled) and the drop event must not be
fired.
User agents should take care to not start drag-and-drop operations in response to script
actions. For example, in a mouse-and-window environment, if a script moves a window while the user
has his mouse button depressed, the UA would not consider that to start a drag. This is important
because otherwise UAs could cause data to be dragged from sensitive sources and dropped into
hostile documents without the user's consent.
User agents should filter potentially active (scripted) content (e.g. HTML) when it is dragged
and when it is dropped, using a whitelist of known-safe features. Similarly, relative URLs should be turned into absolute URLs to avoid references changing in
unexpected ways. This specification does not specify how this is performed.
Consider a hostile page providing some content and getting the user to select and drag and
drop (or indeed, copy and paste) that content to a victim page's contenteditable region. If the browser does not ensure that
only safe content is dragged, potentially unsafe content such as scripts and event handlers in
the selection, once dropped (or pasted) into the victim site, get the privileges of the victim
site. This would thus enable a cross-site scripting attack.
6 ウェブページの読み込み
This section describes features that apply most directly to Web browsers. Having said that,
except where specified otherwise, the requirements defined in this section do apply to
all user agents, whether they are Web browsers or not.
存在し、利用可能であり、かつ現在のブラウジングコンテキストが、そのオープナーを解消するのでない場合、取得時に、WindowオブジェクトのopenerIDL属性は、現在のブラウジングコンテキストが（そのオープナーブラウジングコンテキスト）を作成されたブラウジングコンテキストのWindowProxyオブジェクトを返さなければならない。そうでなければ、nullを返さなければならない。On setting, if the new value is null then the current browsing context must disown its opener; if the new value is anything else then the user agent must
call the [[DefineOwnProperty]] internal method of the Window object, passing the
property name "opener" as the property key, and the Property Descriptor {
[[Value]]: value, [[Writable]]: true, [[Enumerable]]: true,
[[Configurable]]: true } as the property descriptor,
where value is the new value.
Each unit of related browsing contexts is then further divided into the smallest
number of groups such that every member of each group has an active document with an
effective script origin that, through appropriate manipulation of the document.domain attribute, could be made to be the same as
other members of the group, but could not be made the same as members of any other group. Each
such group is a unit of related similar-origin browsing contexts.
The task in which the algorithm is running was queued by an algorithm that was allowed to show a popup,
and the chain of such algorithms started within a user-agent defined timeframe.
For example, if a user clicked a button, it might be acceptable for a popup
to result from that after 4 seconds, but it would likely not be acceptable for a popup to result
from that after 4 hours.
The rules for choosing a browsing context given a browsing context name are as
follows. The rules assume that they are being applied in the context of a browsing
context, as part of the execution of a task.
If the given browsing context name is the empty string or _self, then
the chosen browsing context must be the current one.
If the given browsing context name is _parent, then the chosen
browsing context must be the parent browsing context of the current one,
unless there isn't one, in which case the chosen browsing context must be the current browsing
context.
If the given browsing context name is _top, then the chosen browsing
context must be the top-level browsing context of the current one, if there is one,
or else the current browsing context.
If the given browsing context name is not _blank and there exists a
browsing context whose name is the same as the given
browsing context name, and the current browsing context is familiar with that
browsing context, and the user agent determines that the two browsing contexts are related
enough that it is ok if they reach each other, then that browsing context must be the chosen
one. If there are multiple matching browsing contexts, the user agent should select one in some
arbitrary consistent manner, such as the most recently opened, most recently focused, or more
closely related.
If the browsing context is chosen by this step to be the current browsing context, then this
is also an explicit self-navigation override.
Otherwise, a new browsing context is being requested, and what happens depends on the user
agent's configuration and abilities — it is determined by the rules given for the first
applicable option from the following list:
If the algorithm is not allowed to show a popup and the
user agent has been configured to not show popups (i.e. the user agent has a "popup blocker"
enabled)
There is no chosen browsing context. The user agent may inform the user that a popup has
been blocked.
The user agent may offer to create a new top-level browsing context or reuse
an existing top-level browsing context. If the user picks one of those options,
then the designated browsing context must be the chosen one (the browsing context's name isn't
set to the given browsing context name). The default behaviour (if the user agent doesn't
offer the option to the user, or if the user declines to allow a browsing context to be used)
must be that there must not be a chosen browsing context.
If this case occurs, it means that an author has explicitly sandboxed the
document that is trying to open a link.
If the user agent has been configured such that in this instance it will
create a new browsing context, and the browsing context is being requested as part of following a hyperlink whose link
types include the noreferrer keyword
A new top-level browsing context must be created. If the given browsing
context name is not _blank, then the new top-level browsing context's
name must be the given browsing context name (otherwise, it has no name). The chosen browsing
context must be this new browsing context. The creation of such a browsing context
is a new start for session storage.
If the user agent has been configured such that in this instance it will create a new
browsing context, and the noreferrer keyword doesn't
apply
A new auxiliary browsing context must be created, with the opener
browsing context being the current one. If the given browsing context name is not _blank, then the new auxiliary browsing context's name must be the given
browsing context name (otherwise, it has no name). The chosen browsing context must be this new
browsing context.
For historical reasons, Window objects must also have a writable, configurable,
non-enumerable property named HTMLDocument whose value is the
Document interface object.
6.2.1 Security
This section describes a security model that is underdefined, imperfect, and
does not match implementations. Work is ongoing to attempt to resolve this, but in the meantime,
please do not rely on this section for precision. Implementors are urged to send their feedback on
how cross-origin cross-global access to Window and Location objects
should work. See bug 20701.
For members that return objects (including function objects), each distinct effective
script origin that is not the same as the Window object's
Document's effective script origin must be provided with a separate set
of objects. These objects must have the prototype chain appropriate for the script for which the
objects are created (not those that would be appropriate for scripts whose global
object, as specified by their settings object, is the Window
object in question).
For instance, if two frames containing Documents from different origins access the same Window object's postMessage() method, they will get distinct objects that
are not equal.
The method has four arguments, though they are all optional.
The first argument, url, must be a valid non-empty URL for a
page to load in the browsing context. If the first argument is the empty string, then the url argument must be interpreted as "about:blank". Otherwise, the
argument must be resolved to an absolute URL (or
an error), relative to the API base URL specified by the entry settings
object when the method was invoked.
The third argument, features, has no defined effect and is mentioned for
historical reasons only. User agents may interpret this argument as instructions to set the size
and position of the browsing context, but are encouraged to instead ignore the argument
entirely.
The fourth argument, replace, specifies whether or not the new page will
replace the page currently loaded in the browsing
context, when target identifies an existing browsing context (as opposed to
leaving the current page in the browsing context's session history).
When the method is invoked, the user agent must first select a browsing context to
navigate by applying the rules for choosing a browsing context given a browsing context
name using the target argument as the name and the browsing
context of the script as the context in which the algorithm is executed, unless the user
has indicated a preference, in which case the browsing context to navigate may instead be the one
indicated by the user.
For example, suppose there is a user agent that supports control-clicking a
link to open it in a new tab. If a user clicks in that user agent on an element whose onclick handler uses the window.open() API to open a page in an iframe, but, while doing so, holds
the control key down, the user agent could override the selection of the target browsing context
to instead target a new tab.
The method must return the WindowProxy object of the browsing context
that was navigated, or null if no browsing context was navigated.
The name attribute of the Window object
must, on getting, return the current name of the
browsing context, if one is set, or the empty string otherwise; and, on setting, set
the name of the browsing context to the
new value.
The name gets reset when the browsing context is
navigated to another domain.
The close() method on Window
objects should, if all the following conditions are met, close the browsing contextA:
To determine the value of a named propertyname when the Window object is indexed for property
retrieval, the user agent must return the value obtained using the following steps:
Otherwise, if objects 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 objects with
the name name. (By definition, these will all be elements.)
Named objects with the name name, for the purposes of the above algorithm, are those that are either:
Whenever a Document object is discarded, it is also removed from the list of the worker's
Documents of each worker whose list contains that Document.
When a browsing context is discarded, the strong reference
from the user agent itself to the browsing context must be severed, and all the
Document objects for all the entries in the browsing context's session
history must be discarded as well.
The visible attribute, on getting, must return either
true or a value determined by the user agent to most accurately represent the visibility state of
the user interface element that the object represents, as described below. On setting, the new
value must be discarded.
The following BarProp objects exist for each Document object in a
browsing context. Some of the user interface elements represented by these objects
might have no equivalent in some user agents; for those user agents, except when otherwise
specified, the object must act as if it was present and visible (i.e. its visible attribute must return true).
The location bar BarProp object
Represents the user interface element that contains a control that displays the
URL of the active document, or some similar interface concept.
The menu bar BarProp object
Represents the user interface element that contains a list of commands in menu form, or some
similar interface concept.
The personal bar BarProp object
Represents the user interface element that contains links to the user's favorite pages, or
some similar interface concept.
The scrollbar BarProp object
Represents the user interface element that contains a scrolling mechanism, or some similar
interface concept.
The status bar BarProp object
Represents a user interface element found immediately below or after the document, as
appropriate for the user's media, which typically provides information about ongoing network
activity or information about elements that the user's pointing device is current indicating. If
the user agent has no such user interface element, then the object may act as if the
corresponding user interface element was absent (i.e. its visible attribute may return false).
The toolbar BarProp object
Represents the user interface element found immediately above or before the document, as
appropriate for the user's media, which typically provides session history traversal
controls (back and forward buttons, reload buttons, etc). If the user agent has no such user
interface element, then the object may act as if the corresponding user interface element was
absent (i.e. its visible attribute may return
false).
For historical reasons, the status attribute
on the Window object must, on getting, return the last string it was set to, and on
setting, must set itself to the new value. When the Window object is created, the
attribute must be set to the empty string. It does not do anything else.
As mentioned earlier, each browsing context has a
WindowProxy object. This object is unusual in that all operations that
would be performed on it must be performed on the Window object of the browsing
context's active document instead. It is thus indistinguishable from that
Window object in every way until the browsing context is navigated.
In the following example, the variable x is set to the
WindowProxy object returned by the window accessor
on the global object. All of the expressions following the assignment return true, because in
every respect, the WindowProxy object acts like the underlying Window
object.
var x = window;
x instanceof Window; // true
x === this; // true
If a Document was obtained in some other manner (e.g. a data: URL typed in by the user or that was returned as
the location of an HTTP redirect (or
equivalent in other protocols), a Document created using the createDocument() API, etc)
The default behavior as defined in the DOM standard applies. [DOM].
Other specifications can override the above definitions by themselves specifying the origin of
a particular URL, Document, image, media element, or
font.
The Unicode serialization of an origin is the string obtained by applying the
following algorithm to the given origin:
If the origin in question is not a scheme/host/port tuple, then return the
literal string "null" and abort these steps.
Otherwise, let result be the scheme part of the origin
tuple.
Append the string "://" to result.
Apply the domain label to Unicode algorithm to each component of the host
part of the origin tuple, and append the results — each component, in the same
order, separated by "." (U+002E) characters — to result. [URL]
If the port part of the origin tuple gives a port that is different from the
default port for the protocol given by the scheme part of the origin tuple, then
append a ":" (U+003A) character and the given port, in base ten, to result.
Return result.
The ASCII serialization of an origin is the string obtained by applying the
following algorithm to the given origin:
If the origin in question is not a scheme/host/port tuple, then return the
literal string "null" and abort these steps.
Otherwise, let result be the scheme part of the origin
tuple.
Append the string "://" to result.
Apply the domain label to ASCII algorithm to each component of the host part of
the origin tuple, and append the results — each component, in the same order,
separated by "." (U+002E) characters — to result. [URL]
If the ToASCII algorithm used by the domain label to ASCII algorithm fails to
convert one of the components of the string, e.g. because it is too long or because it contains
invalid characters, then throw a SecurityError exception and abort these steps. [RFC3490]
If the port part of the origin tuple gives a port that is different from the
default port for the protocol given by the scheme part of the origin tuple, then
append a ":" (U+003A) character and the given port, in base ten, to result.
Return result.
Two origins are said to be the same origin if the
following algorithm returns true:
Let A be the first origin being compared, and B be the second origin being compared.
If A and B are both opaque identifiers, and their
value is equal, then return true.
Otherwise, if either A or B or both are opaque
identifiers, return false.
If A and B have scheme components that are not
identical, return false.
If A and B have host components that are not
identical, return false.
If A and B have port components that are not
identical, return false.
If either A or B have additional data, but that
data is not identical for both, return false.
The domain attribute on
Document objects must be initialised to the document's domain, if it has
one, and the empty string otherwise. If the document's domain starts with a "[" (U+005B) character and ends with a "]" (U+005D) character, it is
an IPv6 address; these square brackets must be omitted when initializing the attribute's
value.
On getting, the attribute must return its current value, unless the Document has
no browsing context, in which case it must return the empty string.
On setting, the user agent must run the following algorithm:
If the new value is an IPv4 or IPv6 address, let new value be the new
value.
Otherwise, strictly split the new value on
"." (U+002E) characters, apply the domain label to ASCII algorithm to each
returned token, and let new value be the result of concatenating the
results of applying that algorithm to each token, in the same order, separated by "." (U+002E) characters. [URL]
If the ToASCII algorithm used by the domain label to ASCII algorithm fails to
convert one of the components of the string, e.g. because it is too long or because it contains
invalid characters, then throw a SecurityError exception and abort these steps. [RFC3490]
If new value is not exactly equal to the current value of the document.domain attribute, then run these substeps:
If the current value is an IPv4 or IPv6 address, throw a SecurityError
exception and abort these steps.
If new value, prefixed by a "." (U+002E), does not exactly
match the end of the current value, throw a SecurityError exception and abort
these steps.
If the new value is an IPv4 or IPv6 address, it cannot
match the new value in this way and thus an exception will be thrown
here.
If new value matches a suffix in the Public Suffix List, or, if new value, prefixed by a "." (U+002E), matches the end of a suffix in
the Public Suffix List, then throw a SecurityError exception and abort these
steps. [PSL]
Set the port part of the effective script origin tuple of the
Document to "manual override" (a value that, for the purposes of comparing origins, is identical to "manual override" but not
identical to any other value).
The domain of a Document is the host part
of the document's origin, if the value of that origin is a
scheme/host/port tuple. If it isn't, then the document does not have a domain.
User agents may discard the Document
objects of entries other than the current entry that are not referenced from any
script, reloading the pages afresh when the user or script navigates back to such pages. This
specification does not specify when user agents should discard Document objects and
when they should cache them.
Entries that have had their Document objects discarded must, for the purposes of
the algorithms given below, act as if they had not. When the user or script navigates back or
forwards to a page which has no in-memory DOM objects, any other entries that shared the same
Document object with it must share the new object as well.
All the getters and setters for attributes, and all the methods, defined on the
History interface, when invoked on a History object associated with a
Document that is not fully active, must throw a
SecurityError exception instead of operating as described below.
The actual entries are not accessible from script.
The state attribute of the
History interface must return the last value it was set to by the user agent.
Initially, its value must be null.
When the go(delta) method is
invoked, if the argument to the method was omitted or has the value zero, the user agent must act
as if the location.reload() method was called instead.
Otherwise, the user agent must traverse the history by a delta whose value is the
value of the method's argument.
If there is an ongoing attempt to navigate specified browsing context
that has not yet matured (i.e. it has not passed the
point of making its Document the active document), then cancel that
attempt to navigate the browsing context.
If the specified browsing context's active document is not
the same Document as the Document of the specified
entry, then run these substeps:
When the user navigates through a browsing context, e.g. using a browser's back
and forward buttons, the user agent must traverse the history by a delta equivalent
to the action specified by the user.
The pushState(data, title, url) method adds a state object entry to
the history.
The replaceState(data, title, url) method updates the state object,
title, and optionally the URL of the current entry in the history.
When either of these methods is invoked, the user agent must run the following steps:
Let cloned data be a structured clone of the specified
data. If this throws an exception, then rethrow that exception and abort
these steps.
If the third argument is not null, run these substeps:
For the purposes of the comparisons in the above substeps, the path and query components
can only be the same if the scheme component of both
parsed URLs are relative schemes.
If the third argument is null, then let new URL be the URL
of the current entry.
Add a state object entry to the session history, after the current
entry, with cloned data as the state object, the given
title as the title, and new URL as the URL
of the entry.
Update the current entry to be this newly added entry.
Otherwise, if the method invoked was the replaceState() method:
Update the current entry in the session history so that cloned data is the entry's new state object, the given title
is the new title, and new URL is the entry's new URL.
If the current entry in the session history represents a non-GET request
(e.g. it was the result of a POST submission) then update it to instead represent a GET request
(or equivalent).
The title is purely advisory. User agents might use the title
in the user interface.
User agents may limit the number of state objects added to the session history per page. If a
page hits the UA-defined limit, user agents must remove the entry immediately after the first
entry for that Document object in the session history after having added the new
entry. (Thus the state history acts as a FIFO buffer for eviction, but as a LIFO buffer for
navigation.)
<!DOCTYPE HTML>
<!-- this is http://example.com/line?x=5 -->
<title>Line Game - 5</title>
<p>You are at coordinate 5 on the line.</p>
<p>
<a href="?x=6">Advance to 6</a> or
<a href="?x=4">retreat to 4</a>?
</p>
When a user requests that the active document of a browsing context
be reloaded through a user interface element, the user agent should navigate the browsing context to the same resource as that
Document, with replacement enabled. In the case of non-idempotent
methods (e.g. HTTP POST), the user agent should prompt the user to confirm the operation first,
since otherwise transactions (e.g. purchases or database modifications) could be repeated. User
agents may allow the user to explicitly override any caches when reloading. If browsing
context's active document's reload override flag is set, then the
user agent may instead perform an overridden reload rather than the navigation
described in this paragraph (with the browsing context being reloaded as the
source browsing context).
When the object is created, and whenever the the
address of the relevant Document changes, the user agent must invoke
the object's URLUtils interface's set the
input algorithm with the address of the
relevant Document as the given value.
In the task in which the algorithm is running, the event
listener for a trustedclick event is being handled.
If mode is normal navigation, then act as if the assign() method had been called with value as its argument. Otherwise, act as if the replace() method had been called with value as its argument.
6.5.3.1 Security
This section describes a security model that is underdefined, imperfect, and
does not match implementations. Work is ongoing to attempt to resolve this, but in the meantime,
please do not rely on this section for precision. Implementors are urged to send their feedback on
how cross-origin cross-global access to Window and Location objects
should work. See bug 20701.
For members that return objects (including function objects), each distinct effective
script origin that is not the same origin as the Location
object's Document's effective script origin must be provided with a
separate set of objects. These objects must have the prototype chain appropriate for the script
for which the objects are created (not those that would be appropriate for scripts whose
settings object specifies a global object that is the
Location object's Document's Window object).
6.5.4 Implementation notes for session history
この節は非規範的である。
The History interface is not meant to place restrictions on how implementations
represent the session history to the user.
For example, session history could be implemented in a tree-like manner, with each page having
multiple "forward" pages. This specification doesn't define how the linear list of pages in the
history object are derived from the actual session history as
seen from the user's perspective.
Similarly, a page containing two iframes has a history object distinct from the iframes' history objects, despite the fact that typical Web browsers present the
user with just one "Back" button, with a session history that interleaves the navigation of the
two inner frames and the outer page.
Security: It is suggested that to avoid letting a page "hijack" the history
navigation facilities of a UA by abusing pushState(),
the UA provide the user with a way to jump back to the previous page (rather than just going back
to the previous state). For example, the back button could have a drop down showing just the pages
in the session history, and not showing any of the states. Similarly, an aural browser could have
two "back" commands, one that goes back to the previous state, and one that jumps straight back to
the previous page.
In addition, a user agent could ignore calls to pushState() that are invoked on a timer, or from event
listeners that are not triggered in response to a clear user action, or that are invoked in rapid
succession.
6.6 ウェブを閲覧する
6.6.1 Navigating across documents
Certain actions cause the browsing context to navigate to a new resource.
A user agent may provide various ways for the user to explicitly cause a browsing context to
navigate, in addition to those defined in this specification.
A resource has a URL, but that might not be the only information necessary
to identify it. For example, a form submission that uses HTTP POST would also have the HTTP method
and payload. Similarly, an iframesrcdoc document needs to know the data it is to use.
Navigation always involves source browsing context, which is the browsing context which
was responsible for starting the navigation.
When a browsing context is navigated to a new resource, the user
agent must run the following steps:
Doing so, however, can be dangerous, as it means that the user is overriding the
author's explicit request to sandbox the content.
If the navigate algorithm was invoked with exceptions enabled, and it
is aborted on this step, then in addition to aborting this algorithm, the user agent must also
throw a SecurityError exception.
If there is a preexisting attempt to navigate the browsing context, and the
source browsing context is the same as the browsing context being
navigated, and that attempt is currently running the unload a document algorithm,
and the origin of the URL of the resource being loaded in that
navigation is not the same origin as the origin of the URL
of the resource being loaded in this navigation, then abort these steps without
affecting the preexisting attempt to navigate the browsing context.
The handle redirects step later in
this algorithm can in certain cases jump back to the step labeled fragment identifiers. Since, between those two steps,
this algorithm goes from operating synchronously in the context of the calling task to operating asynchronously independent of the event
loop, some of the intervening steps need to be able to handle both being synchronous and
being asynchronous. The gone async flag is thus used to make these steps
aware of which mode they are operating in.
If the new resource is to be handled using a mechanism that does not affect the browsing
context, e.g. ignoring the navigation request altogether because the specified scheme is not one
of the supported protocols, then abort these steps and proceed with that mechanism instead.
If this instance of the navigation algorithm gets canceled
while this step is running, the prompt to unload a document algorithm must
nonetheless be run to completion.
If the new resource is to be handled by displaying some sort of inline content, e.g. an error
message because the specified scheme is not one of the supported protocols, or an inline prompt
to allow the user to select a registered
handler for the given scheme, then display the inline
content and abort these steps.
In the case of a registered handler being used, the algorithm will be reinvoked
with a new URL to handle the request.
The user agent must take this nested browsing context out of the delaying
load events mode when this navigation algorithm later matures, or when it terminates (whether due to having
run all the steps, or being canceled, or being aborted), whichever happens first.
This is the step that attempts to obtain the resource, if necessary. Jump to the first
appropriate substep:
If the resource has already been obtained (e.g. because it is being used to populate an
object element's new child browsing context)
Append parsed URL's scheme
data component to script source.
If parsed URL's query
component is not null, then first append a "?" (U+003F) character to script source, and then append parsed URL's query component to script
source.
If parsed URL's fragment component is not null, then first append a
"#" (U+0023) character to script source, and then append parsed URL's fragment component to
script source.
Replace script source with the result of applying the
percent decode algorithm to script source.
Replace script source with the result of applying the UTF-8
decode algorithm to script source.
Let result be the return value of the code entry-point
of this script. If an exception was thrown, let result be void instead. (The result will be void also if scripting is disabled.)
Process results: If the result of executing the script is void (there is no return
value), then the result of obtaining the resource for the URL is equivalent to an HTTP resource with an HTTP
204 No Content response.
Otherwise, the result of obtaining the resource for the URL is equivalent to an HTTP resource with a 200 OK
response whose Content-Type metadata is
text/html and whose response body is the return value converted to a string
value.
So for example a javascript:
URL in an href attribute of an
a element would only be evaluated when the link was followed, while such a URL in the src attribute of an iframe element would be
evaluated in the context of the iframe's own nested browsing
context when the iframe is being set up; once evaluated, its return value
(if it was not void) would replace that browsing context's document, thus also
changing the Window object of that browsing context.
If the new resource is to be fetched using HTTP GET or equivalent, and there are relevant application caches that are identified by a URL with the
same origin as the URL in question, and that have this URL as one of their
entries, excluding entries marked as foreign,
and whose mode is fast, and the user agent is not in a mode where it
will avoid using application caches
For example, imagine an HTML page with an associated application cache
displaying an image and a form, where the image is also used by several other application
caches. If the user right-clicks on the image and chooses "View Image", then the user agent
could decide to show the image from any of those caches, but it is likely that the most useful
cache for the user would be the one that was used for the aforementioned HTML page. On the
other hand, if the user submits the form, and the form does a POST submission, then the user
agent will not use an application cache at all; the submission will be made to the
network.
そうでなければ
Fetch the new resource, with the manual redirect flag
set.
If the steps above invoked the fetch algorithm, the following requirements also
apply:
If gone async is false, return to whatever algorithm invoked the
navigation steps and continue running these steps asynchronously.
Let gone async be true.
Wait for one or more bytes to be available or for the user agent to establish that the
resource in question is empty. During this time, the user agent may allow the user to cancel this
navigation attempt or start other navigation attempts.
Handle redirects: If fetching the resource results in a redirect, and either the
URL of the target of the redirect has the same origin as the original
resource, or the resource is being obtained using the POST method or a safe method (in HTTP
terms), return to the step labeled fragment
identifiers with the new resource, except that if the URL of the target of
the redirect does not have a fragment identifier and the URL of the resource that
led to the redirect does, then the fragment identifier of the resource that led to the redirect
must be propagated to the URL of the target of the redirect.
So for instance, if the original URL was "http://example.com/#!sample" and "http://example.com/" is
found to redirect to "https://example.com/", the URL of the new resource
will be "https://example.com/#!sample".
Otherwise, if fetching the resource results in a redirect but the URL of the
target of the redirect does not have the same origin as the original resource and
the resource is being obtained using a method that is neither the POST method nor a safe method
(in HTTP terms), then abort these steps. The user agent may indicate to the user that the
navigation has been aborted for security reasons.
Fallback in prefer-online mode: If the resource was not fetched from an
application cache, and was to be fetched using HTTP GET or equivalent, and there are relevant application caches that are identified by a URL with the
same origin as the URL in question, and that have this URL as one of their entries,
excluding entries marked as foreign, and whose
mode is prefer-online, and the user didn't cancel the
navigation attempt during the earlier step, and the navigation attempt failed (e.g. the server
returned a 4xx or 5xx status code or
equivalent, or there was a DNS error), then:
If candidate is not marked as foreign, then the user agent must discard the failed
load and instead continue along these steps using candidate as the resource.
The user agent may indicate to the user that the original page load failed, and that the page
used was a previously cached resource.
This does not affect the address of the resource from which Request-URIs are
obtained, as used to set the document's referrer in the initialise the
Document object steps below; they still use the value as computed by the
original fetch algorithm.
If candidate is not marked as foreign, then the user agent must discard the failed
load and instead continue along these steps using candidate as the resource.
The document's address, if appropriate, will still be the originally requested URL,
not the fallback URL, but the user agent may indicate to the user that the original page load
failed, that the page used was a fallback resource, and what the URL of the fallback resource
actually is.
This does not affect the address of the resource from which Request-URIs are
obtained, as used to set the document's referrer in the initialise the
Document object steps below; they still use the value as computed by the
original fetch algorithm.
Resource handling: If the resource's out-of-band metadata (e.g. HTTP headers), not
counting any type information (such as the Content-Type HTTP
header), requires some sort of processing that will not affect the browsing context, then
perform that processing and abort these steps.
Such processing might be triggered by, amongst other things, the following:
HTTP status codes (e.g. 204 No Content or 205 Reset Content)
Network errors (e.g. the network interface being unavailable)
Cryptographic protocol failures (e.g. an incorrect TLS certificate)
Responses with HTTP Content-Disposition headers
specifying the attachment disposition type must be handled as a
download.
HTTP 401 responses that do not include a challenge recognised by the user agent must be
processed as if they had no challenge, e.g. rendering the entity body as if the response had
been 200 OK.
User agents may show the entity body of an HTTP 401 response even when the response does
include a recognised challenge, with the option to login being included in a non-modal fashion,
to enable the information provided by the server to be used by the user before authenticating.
Similarly, user agents should allow the user to authenticate (in a non-modal fashion) against
authentication challenges included in other responses such as HTTP 200 OK responses, effectively
allowing resources to present HTTP login forms without requiring their use.
If the user agent has been configured to process resources of the given type using some mechanism other than rendering the content in a browsing
context, then skip this step. Otherwise, if the type is one of the
following types, jump to the appropriate entry in the following list, and process the resource as
described there:
Follow the steps given in the XML document section. If
that section determines that the content is not to be displayed as a generic XML
document, then proceed to the next step in this overall set of steps. Otherwise, once the steps
given in the XML document section have completed, abort this
navigate algorithm.
"text/plain"
Follow the steps given in the plain text file section,
and then, once they have completed, abort this navigate algorithm.
Follow the steps given in the media section, and then,
once they have completed, abort this navigate algorithm.
A type that will use an external application to render the content in the browsing
context
Follow the steps given in the plugin section, and then,
once they have completed, abort this navigate algorithm.
An explicitly supported XML type is one for which the user agent is configured to
use an external application to render the content (either a plugin rendering
directly in the browsing context, or a separate application), or one for which the
user agent has dedicated processing rules (e.g. a Web browser with a built-in Atom feed viewer
would be said to explicitly support the application/atom+xml MIME type), or one for
which the user agent has a dedicated handler (e.g. one registered using registerContentHandler()).
Setting the document's address: If there is no
override URL, then any Document created by these steps must have its
address set to the URL that was
originally to be fetched, ignoring any other data that was used to
obtain the resource (e.g. the entity body in the case of a POST submission is not part of
the document's address, nor is the URL of the fallback resource in the case of the
original load having failed and that URL having been found to match a fallback namespace). However, if there is
an override URL, then any Document created by these steps must have
its address set to that URL
instead.
Initializing a new Document
object: when a Document is created as part of the above steps, the user agent
will be required to additionally run the following algorithm after creating the new object:
Set the document's referrer to the address of the resource from which
Request-URIs are obtained as determined when the fetch algorithm obtained the
resource, if that algorithm was used and determined such a value; otherwise, set it to the
empty string.
Non-document content: If, given type, the new resource is to be
handled by displaying some sort of inline content, e.g. a native rendering of the content, an
error message because the specified type is not supported, or an inline prompt to allow the user
to select a registered handler for
the given type, then display the inline content, and
then abort these steps.
In the case of a registered handler being used, the algorithm will be reinvoked
with a new URL to handle the request.
Otherwise, the document's type is such that the resource will not
affect the browsing context, e.g. because the resource is to be handed to an external application
or because it is an unknown type that will be processed as a download. Process the resource appropriately.
When a resource is handled by passing its URL or
data to an external software package separate from the user agent (e.g. handing a mailto: URL to a mail client, or a Word document to a word processor), user
agents should attempt to mitigate the risk that this is an attempt to exploit the target software,
e.g. by prompting the user to confirm that the source browsing context's active
document's origin is to be allowed to invoke the specified software. In
particular, if the navigate algorithm, when it was invoked, was not allowed to
show a popup, the user agent should not invoke the external software package without prior
user confirmation.
For example, there could be a vulnerability in the target software's URL
handler which a hostile page would attempt to exploit by tricking a user into clicking a link.
Some of the sections below, to which the above algorithm defers in certain cases, require the
user agent to update the session history with the new page. When a user agent is
required to do this, it must queue a task (associated with the Document
object of the current entry, not the new one) to run the following steps:
If this instance of the navigation algorithm is canceled while
this step is running the unload a document algorithm, then the unload a
document algorithm must be allowed to run to completion, but this instance of the navigation algorithm must not run beyond this step. (In particular, for
instance, the cancelation of this algorithm does not abort any event dispatch or script
execution occurring as part of unloading the document or its descendants.)
If the navigation was initiated for entry update of an entry
Replace the Document of the entry being updated, and any other entries
that referenced the same document as that entry, with the new Document.
This can only happen if the entry being updated is not the current
entry, and can never happen with replacement enabled. (It happens when the
user tried to traverse to a session history entry that no longer had a Document
object.)
Fragment identifier loop: Spin the event loop for a user-agent-defined
amount of time, as desired by the user agent implementor. (This is intended to allow the user
agent to optimise the user experience in the face of performance concerns.)
If the Document object has no parser, or its parser has stopped parsing, or the user agent has reason to believe the user is no longer
interested in scrolling to the fragment identifier, then abort these steps.
The input byte stream converts bytes into characters for use in the
tokenizer. This process relies, in part, on character encoding
information found in the real Content-Type metadata of the
resource; the "sniffed type" is not used for this purpose.
When no more bytes are available, the user agent must queue a task for the parser
to process the implied EOF character, which eventually causes a load event to be fired.
When faced with displaying an XML file inline, user agents must follow the requirements defined
in the XML and Namespaces in XML recommendations, RFC 7303, DOM, and other relevant specifications
to create a Document object and a corresponding XML parser. [XML][XMLNS][RFC7303][DOM]
At the time of writing, the XML specification community had not actually yet
specified how XML and the DOM interact.
The actual HTTP headers and other metadata, not the headers as mutated or implied by the
algorithms given in this specification, are the ones that must be used when determining the
character encoding according to the rules given in the above specifications. Once the character
encoding is established, the document's character encoding must be set to that
character encoding.
If the root element, as parsed according to the XML specifications cited above, is found to be
an html element with an attribute manifest
whose value is not the empty string, then, as soon as the element is inserted into the document, the user agent must resolve the value of that attribute relative to that element, and if
that is successful, must apply the URL serializer
algorithm to the resulting parsed URL with the exclude fragment flag set to
obtain manifest URL, and then run the application cache selection algorithm with manifest URL as the manifest URL, passing in the newly-created
Document. Otherwise, if the attribute is absent, its value is the empty string, or
resolving its value fails, then as soon as the root element is inserted into the document, the user agent must run the application cache selection algorithm with no manifest, and
passing in the Document.
Because the processing of the manifest
attribute happens only once the root element is parsed, any URLs referenced by processing
instructions before the root element (such as PIs)
will be fetched from the network and cannot be cached.
User agents may examine the namespace of the root Element node of this
Document object to perform namespace-based dispatch to alternative processing tools,
e.g. determining that the content is actually a syndication feed and passing it to a feed handler.
If such processing is to take place, abort the steps in this section, and jump to the next step (labeled non-document content) in the
navigate steps above.
Otherwise, then, with the newly created Document, the user agent must update
the session history with the new page. User agents may do this before the complete document
has been parsed (thus achieving incremental rendering), and must do this before any scripts
are to be executed.
Error messages from the parse process (e.g. XML namespace well-formedness errors) may be
reported inline by mutating the Document.
The rules for how to convert the bytes of the plain text document into actual characters, and
the rules for actually rendering the text to the user, are defined in RFC 2046, RFC 3676, and
subsequent versions thereof. [RFC2046][RFC3676]
When no more bytes are available, the user agent must queue a task for the parser
to process the implied EOF character, which eventually causes a load event to be fired.
User agents may add content to the head element of the Document, e.g.
linking to a style sheet or a binding, providing script, giving the document a
title, etc.
In particular, if the user agent supports the Format=Flowed
feature of RFC 3676 then the user agent would need to apply extra styling to cause the text to
wrap correctly and to handle the quoting feature. This could be performed using, e.g., a
binding or a CSS extension.
For each body part obtained from the resource, the user agent must run a new instance of the
navigate algorithm, starting from the resource handling step, using the new
body part as the resource being navigated, with replacement enabled if a previous
body part from the same resource resulted in a Document object being created and
initialized, and otherwise using the same
setup as the navigate attempt that caused this section to be invoked in the first
place.
For the purposes of algorithms processing these body parts as if they were complete stand-alone
resources, the user agent must act as if there were no more bytes for those resources whenever the
boundary following the body part is reached.
Thus, load events (and for that matter unload events) do fire for each body part loaded.
6.6.6 Page load processing model for media
When an image, video, or audio resource is to be loaded in a browsing context, the
user agent should create a Document object, mark it as being an HTML document, set its content
type to the sniffed MIME type of the resource (type in the
navigate algorithm), initialise the Document object, append
an html element to the Document, append a head element and
a body element to the html element, append an element host element for the media, as described below, to the body element,
and set the appropriate attribute of the element host element, as described
below, to the address of the image, video, or audio resource.
The element host element to create for the media is the element given in
the table below in the second cell of the row whose first cell describes the media. The
appropriate attribute to set is the one given by the third cell in that same row.
User agents may add content to the head element of the Document, or
attributes to the element host element, e.g. to link to a style sheet or a
binding, to provide a script, to give the document a title, to make the media
autoplay, etc.
6.6.7 Page load processing model for content that uses plugins
When a resource that requires an external resource to be rendered is to be loaded in a
browsing context, the user agent should create a Document object, mark
it as being an HTML document and mark it as being a
plugin document, set its content
type to the sniffed MIME type of the resource (type in the
navigate algorithm), initialise the Document object, append
an html element to the Document, append a head element and
a body element to the html element, append an embed to the
body element, and set the src attribute of the
embed element to the address of the resource.
The term plugin document is used by the Content Security Policy
specification as part of the mechanism that ensures iframes can't be used to evade
plugin-types directives. [CSP]
User agents may add content to the head element of the Document, or
attributes to the embed element, e.g. to link to a style sheet or a binding, or
to give the document a title.
6.6.8 Page load processing model for inline
content that doesn't have a DOM
When the user agent is to display a user agent page inline in a browsing context,
the user agent should create a Document object, mark it as being an HTML document, set its content type to "text/html",
initialise the Document object, and then either associate that
Document with a custom rendering that is not rendered using the normal
Document rendering rules, or mutate that Document until it represents
the content the user agent wants to render.
Once the page has been set up, the user agent must act as if it had stopped parsing.
Append a new entry at the end of the History object representing the new
resource and its Document object and related state. Its URL must be set
to the address to which the user agent was navigating. The title
must be left unset.
If the scrolling fails because the relevant ID has
not yet been parsed, then the original navigation algorithm will
take care of the scrolling instead, as the last few steps of its update the session history
with the new page algorithm.
When the user agent is required to scroll to the fragment identifier and the
indicated part of the document, if any, is being rendered, the user agent must
either change the scrolling position of the document using the following algorithm, or perform
some other action such that the indicated part of the document is brought to the
user's attention. If there is no indicated part, or if the indicated part is not being
rendered, then the user agent must do nothing. The aforementioned algorithm is as
follows:
If target is a focusable element, run the focusing
steps for that element.
The indicated part of the document is the one that the fragment identifier, if any,
identifies. The semantics of the fragment identifier in terms of mapping it to a specific DOM Node
is defined by the specification that defines the MIME type used by the
Document (for example, the processing of fragment identifiers for XML MIME types is the responsibility of RFC7303).
[RFC7303]
Let decoded fragid be the result of applying the UTF-8
decoder algorithm to fragid bytes. If the UTF-8 decoder
emits a decoder error, abort the decoder and instead jump to the step labeled no
decoded fragid.
If there is an element in the DOM that has an ID exactly
equal to decoded fragid, then the first such element in tree order is
the indicated part of the document; stop the algorithm here.
No decoded fragid: If there is an a element in the DOM that has a name attribute whose value is exactly equal to fragid (notdecoded fragid), then the first such
element in tree order is the indicated part of the document; stop the algorithm
here.
When a user agent is required to traverse the history to a specified
entry, optionally with replacement enabled, and optionally with the
asynchronous events flag set, the user agent must act as follows.
If there is no longer a Document object for the entry in question,
navigate the browsing
context to the resource for that entry to perform an entry update of that
entry, and abort these steps. The "navigate" algorithm reinvokes this "traverse"
algorithm to complete the traversal, at which point there is a Document
object and so this step gets skipped. The navigation must be done using the same source
browsing context as was used the first time this entry was created. (This can never
happen with replacement enabled.)
If the resource was obtained usign a non-idempotent action, for example a POST
form submission, or if the resource is no longer available, for example because the computer is
now offline and the page wasn't cached, navigating to it again might not be possible. In this
case, the navigation will result in a different page than previously; for example, it might be
an error message explaining the problem or offering to resubmit the form.
This is specifically intended for use by the Page Visibility specification. [PAGEVIS]
Fire a trusted event with the name pageshow at the Window object of that
Document, but with its target set to the
Document object (and the currentTarget set to the Window object),
using the PageTransitionEvent interface, with the persisted attribute initialised to true.
This event must not bubble, must not be cancelable, and has no default action.
If the specified entry has a URL whose fragment identifier differs
from that of the current entry's when compared in a case-sensitive
manner, and the two share the same Document object, then let hash
changed be true, and let old URL be the URL of the current
entry and new URL be the URL of the specified
entry. Otherwise, let hash changed be false.
If the traversal was initiated with replacement enabled, remove the entry
immediately before the specified entry in the session history.
If the entry is an entry with persisted user state, the user agent may update
aspects of the document and its rendering, for instance the scroll position or values of form
fields, that it had previously recorded.
This can even include updating the dir attribute
of textarea elements or input elements whose type attribute is in either the Text state or the Search state, if the persisted state includes the
directionality of user input in such controls.
If the entry is a state object entry, let state be a
structured clone of that state object. Otherwise, let state be
null.
Let state changed be true if the Document of the specified entry has a latest entry, and that entry is not the specified entry; otherwise let it be false.
Let the latest entry of the Document of the specified entry be the specified entry.
If the asynchronous events flag is not set, then run the following steps
synchronously. Otherwise, the asynchronous events flag is set; queue a task
to run the following substeps.
If state changed is true, fire a trusted
event with the name popstate at the Window
object of the Document, using the PopStateEvent interface, with the
state attribute initialised to the value of state. This event must bubble but not be cancelable and has no default
action.
If hash changed is true, then fire a trusted
event with the name hashchange at the browsing
context's Window object, using the HashChangeEvent interface,
with the oldURL attribute initialised to old URL and the newURL attribute
initialised to new URL. This event must bubble but not be cancelable and
has no default action.
The state attribute must return the value it was initialised to. オブジェクトが作成される際、この属性はnullに初期化しなければならない。It represents the context information for the event, or null, if the state represented is the initial state of the Document.
The oldURL attribute must return the value it was initialised to. オブジェクトが作成される際、この属性はnullに初期化しなければならない。It represents context information for the event, specifically the URL of the session history entry that was traversed from.
The newURL attribute must return the value it was initialised to. オブジェクトが作成される際、この属性はnullに初期化しなければならない。It represents context information for the event, specifically the URL of the session history entry that was traversed to.
The persisted attribute must
return the value it was initialised to. When the object is created, this attribute must be
initialised to false. It represents the context information for the event.
6.6.11 文書の解放
A Document has a salvageable state, which must initially be
true, a fired unload flag, which must initially be false, and a page showing
flag, which must initially be false. The page showing flag is used to ensure that
scripts receive pageshow and pagehide events in a consistent manner (e.g. that they never
receive two pagehide events in a row without an intervening
pageshow, or vice versa).
Event loops have a termination nesting level
counter, which must initially be zero.
When a user agent is to prompt to unload a document, it must run the following
steps.
If any event listeners were triggered by the earlier dispatch step, then set the
Document's salvageable state to
false.
If the returnValue attribute of the
event object is not the empty string, or if the event was canceled, then the
user agent should ask the user to confirm that they wish to unload the document.
The prompt shown by the user agent may include the string of the returnValue attribute, or some leading subset
thereof. (A user agent may want to truncate the string to 1024 characters for display, for
instance.)
The user agent must pause while waiting for the user's response.
If the user did not confirm the page navigation, then the user agent refused to allow
the document to be unloaded.
If this algorithm was invoked by another instance of the "prompt to unload a document"
algorithm (i.e. through the steps below that invoke this algorithm for all descendant browsing
contexts), then jump to the step labeled end.
When a user agent is to unload a document, it must run the following steps. These
steps are passed an argument, recycle, which is either true or false,
indicating whether the Document object is going to be re-used. (This is set by the
document.open() method.)
Fire a trusted event with the name pagehide at the Window object of the
Document, but with its target set to the
Document object (and the currentTarget
set to the Window object), using the PageTransitionEvent interface,
with the persisted attribute initialized
to true if the Document object's salvageable state is true, and false otherwise. This
event must not bubble, must not be cancelable, and has no default action.
If any event listeners were triggered by the earlier unload event step, then set
the Document object's salvageable state
to false and set the Document's fired unload flag to true.
If this algorithm was invoked by another instance of the "unload a document" algorithm
(i.e. by the steps below that invoke this algorithm for all descendant browsing contexts), then
jump to the step labeled end.
The returnValue attribute
represents the message to show the user. When the event is created, the attribute must be set to
the empty string. On getting, it must return the last value it was set to. On setting, the
attribute must be set to the new value.
6.6.12 Aborting a document load
If a Document is aborted, the user agent must
run the following steps:
Cancel any instances of the fetch algorithm in the context of
this Document, discarding any tasksqueued for them, and discarding any further data received from the
network for them. If this resulted in any instances of the fetch
algorithm being canceled or any queuedtasks or any network data getting discarded, then set the
Document's salvageable state to
false.
An application cache is a set of cached resources consisting of:
One or more resources (including their out-of-band metadata, such as HTTP headers, if any),
identified by URLs, each falling into one (or more) of the following categories:
Master entries
These are documents that were added to the cache because a browsing
context was navigated to that document and the document
indicated that this was its cache, using the manifest
attribute.
A URL in the list can be flagged with multiple different types, and thus an
entry can end up being categorised as multiple entries. For example, an entry can be a manifest
entry and an explicit entry at the same time, if the manifest is listed within the manifest.
Zero or more fallback namespaces, each of
which is mapped to a fallback entry.
Zero or more URLs that form the online
whitelist namespaces.
These are used as prefix match patterns, and declare URLs for which the user
agent will ignore the application cache, instead fetching them normally (i.e. from the network
or local HTTP cache as appropriate).
An online whitelist wildcard
flag, which is either open or blocking.
The open state indicates that any URL not listed as cached is to
be implicitly treated as being in the online
whitelist namespaces; the blocking state indicates that URLs not listed
explicitly in the manifest are to be treated as unavailable.
A cache mode flag, which is either in the fast state or the prefer-online state.
Each application cache has a completeness flag, which is either complete or
incomplete.
An application cache group is a group of application
caches, identified by the absolute URL of a resource manifest which is used to populate the caches in the
group.
Multiple application caches in different application cache groups can contain the same resource,
e.g. if the manifests all reference that resource. If the user agent is to select an application cache from a list of relevant application caches that contain a resource, the
user agent must use the application cache that the user most likely wants to see the resource
from, taking into account the following:
which application cache was most recently updated,
which application cache was being used to display the resource from which the user decided to
look at the new resource, and
which application cache the user prefers.
A URL matches a fallback namespace if
there exists a relevant application cache whose manifest's URL has the same origin as the
URL in question, and that has a fallback
namespace that is a prefix match for the URL being examined. If multiple
fallback namespaces match the same URL, the longest one is the one that matches. A URL looking for
a fallback namespace can match more than one application cache at a time, but only matches one
namespace in each cache.
If a manifest http://example.com/app1/manifest declares that http://example.com/resources/images is a fallback namespace, and the user
navigates to HTTP://EXAMPLE.COM:80/resources/images/cat.png, then the user
agent will decide that the application cache identified by http://example.com/app1/manifest contains a namespace with a match for that
URL.
CACHE MANIFEST
# the above line is required
# this is a comment
# there can be as many of these anywhere in the file
# they are all ignored
# comments can have spaces before them
# but must be alone on the line
# blank lines are ignored too
# these are files that need to be cached they can either be listed
# first, or a "CACHE:" header could be put before them, as is done
# lower down.
images/sound-icon.png
images/background.png
# note that each file has to be put on its own line
# here is a file for the online whitelist -- it isn't cached, and
# references to this file will bypass the cache, always hitting the
# network (or trying to, if the user is offline).
NETWORK:
comm.cgi
# here is another set of files to cache, this time just the CSS file.
CACHE:
style/default.css
When the current section is the online
whitelist section, data lines must consist of zero or more U+0020 SPACE and "tab" (U+0009) characters, either a single "*" (U+002A) character or a valid URL identifying a resource
other than the manifest itself, and then zero or more U+0020 SPACE and "tab" (U+0009) characters.
Let input be the decoded text of the manifest's byte stream.
Let position be a pointer into input, initially
pointing at the first character.
If the characters starting from position are "CACHE", followed by a
U+0020 SPACE character, followed by "MANIFEST", then advance position to the
next character after those. Otherwise, this isn't a cache manifest; abort this algorithm with a
failure while checking for the magic signature.
If the character at position is neither a U+0020 SPACE character, a
"tab" (U+0009) character, "LF" (U+000A) character, nor a "CR" (U+000D) character, then this isn't a cache manifest; abort this algorithm with a
failure while checking for the magic signature.
This is a cache manifest. The algorithm cannot fail beyond
this point (though bogus lines can get ignored).
Collect a sequence of characters that are not "LF" (U+000A)
or "CR" (U+000D) characters, and ignore those characters. (Extra text on the first
line, after the signature, is ignored.)
Let mode be "explicit".
Start of line: If position is past the end of input, then jump to the last step. Otherwise, collect a sequence of
characters that are "LF" (U+000A), "CR" (U+000D), U+0020 SPACE, or
"tab" (U+0009) characters.
Drop any trailing U+0020 SPACE and "tab" (U+0009) characters at the end
of line.
If line is the empty string, then jump back to the step labeled start
of line.
If the first character in line is a "#" (U+0023) character,
then jump back to the step labeled start of line.
If line equals "CACHE:" (the word "CACHE" followed by a ":)" (U+003A) character, then set mode to "explicit" and jump back to the step labeled
start of line.
If line equals "FALLBACK:" (the word "FALLBACK" followed by a ":)" (U+003A) character, then set mode to "fallback" and jump back to the step
labeled start of line.
If line equals "NETWORK:" (the word "NETWORK" followed by a ":)" (U+003A) character, then set mode to "online whitelist" and jump back to
the step labeled start of line.
If line equals "SETTINGS:" (the word "SETTINGS" followed by a ":)" (U+003A) character, then set mode to "settings" and jump back to the step
labeled start of line.
If line ends with a ":" (U+003A) character, then set mode to "unknown" and jump back to the step labeled start of line.
This is either a data line or it is syntactically incorrect.
Let position be a pointer into line, initially
pointing at the start of the string.
Let tokens be a list of strings, initially empty.
While position doesn't point past the end of line:
Let current token be an empty string.
While position doesn't point past the end of line and the character at position is neither a U+0020 SPACE
nor a "tab" (U+0009) character, add the character at position to current token and advance position to the next character in input.
Add current token to the tokens list.
While position doesn't point past the end of line and the character at position is either a U+0020 SPACE
or a "tab" (U+0009) character, advance position to the
next character in input.
Process tokens as follows:
If mode is "explicit"
Resolve the first item in tokens,
relative to base URL, with the URL character encoding set to UTF-8;
ignore the rest.
If this fails, then jump back to the step labeled start of line.
If the resulting parsed URL has a different scheme component than base URL (the
manifest's URL), then jump back to the step labeled start of line.
Let new URL be the result of applying the URL serializer algorithm to the resulting parsed
URL, with the exclude fragment flag set.
Add new URL to the explicit URLs.
If mode is "fallback"
Let part one be the first token in tokens, and let
part two be the second token in tokens.
Resolvepart one and part two, relative to base URL, with the URL character
encoding set to UTF-8.
If either fails, then jump back to the step labeled start of line.
If the absolute URL corresponding to either part one or
part two does not have the same origin as the manifest's URL,
then jump back to the step labeled start of line.
Let part one be the result of applying the URL serializer algorithm to the first resulting
parsed URL, with the exclude fragment flag set.
Let part two be the result of applying the URL serializer algorithm to the second resulting
parsed URL, with the exclude fragment flag set.
If part one is already in the fallback URLs mapping
as a fallback namespace, then jump back to
the step labeled start of line.
If the first item in tokens is a "*" (U+002A) character, then
set online whitelist wildcard flag to open and jump back
to the step labeled start of line.
Otherwise, resolve the first item in tokens, relative to base URL, with the URL character
encoding set to UTF-8; ignore the rest.
If this fails, then jump back to the step labeled start of line.
If the resulting parsed URL has a different scheme component than base URL (the
manifest's URL), then jump back to the step labeled start of line.
Let new URL be the result of applying the URL serializer algorithm to the resulting parsed
URL, with the exclude fragment flag set.
Add new URL to the online whitelist namespaces.
If mode is "settings"
If tokens contains a single token, and that token is a
case-sensitive match for the string "prefer-online", then
set cache mode flag to prefer-online and jump back to the
step labeled start of line.
Otherwise, the line is an unsupported setting: do nothing; the line is ignored.
If mode is "unknown"
何もしない。The line is ignored.
Jump back to the step labeled start of line. (That step jumps to the next, and last,
step when the end of the file is reached.)
Return the explicit URLs list, the fallback URLs
mapping, the online whitelist namespaces, the online whitelist
wildcard flag, and the cache mode flag.
The resource that declares the manifest (with the manifest attribute) will always get taken from the cache,
whether it is listed in the cache or not, even if it is listed in an online whitelist namespace.
6.7.4 Downloading or updating an application cache
When the user agent is required (by other parts of this specification) to start the
application cache download process for an absolute URL purported to
identify a manifest, or for an application
cache group, potentially given a particular cache host, and potentially given
a master resource, the user agent must run the steps
below. These steps are always run asynchronously, in parallel with the event looptasks.
Some of these steps have requirements that only apply if the user agent shows caching
progress. Support for this is optional. Caching progress UI could consist of a progress bar
or message panel in the user agent's interface, or an overlay, or something else. Certain events
fired during the application cache download process allow the script to override the
display of such an interface. (Such events are delayed until after the load event has fired.)
The goal of this is to allow Web applications to provide more
seamless update mechanisms, hiding from the user the mechanics of the application cache mechanism.
User agents may display user interfaces independent of this, but are encouraged to not show
prominent update progress notifications for applications that cancel the relevant events.
Optionally, wait until the permission to start the application cache download
process has been obtained from the user and until the user agent is confident that the
network is available. This could include doing nothing until the user explicitly opts-in to
caching the site, or could involve prompting the user for permission. The algorithm might never
get past this point. (This step is particularly intended to be used by user agents running on
severely space-constrained devices or in highly privacy-sensitive environments).
Atomically, so as to avoid race conditions, perform the following substeps:
Pick the appropriate substeps:
If these steps were invoked with an absolute URL purported to identify a
manifest
If that application cache group is obsolete, then abort this instance of the
application cache download process. This can happen if another instance of this
algorithm found the manifest to be 404 or 410 while this algorithm was waiting in the first
step above.
If these steps were invoked with a cache host, and the status of cache group is
checking or downloading, then queue a post-load task to fire a
simple event named checking that is
cancelable at the ApplicationCache singleton of that cache host. The
default action of this event must be, if the user agent shows caching progress,
the display of some sort of user interface indicating to the user that the user agent is
checking to see if it can download the application.
If the status of the cache
group is either checking or downloading, then abort this instance of the
application cache download process, as an update is already in progress.
Fetching the manifest: Fetch the resource from manifest URL with the synchronous flag set, and let manifest be that resource. HTTP caching semantics should be honored for this
request.
The MIME type of the resource is ignored — it is assumed to
be text/cache-manifest. In the future, if new manifest formats are supported, the
different types will probably be distinguished on the basis of the file signatures (for the
current format, that is the "CACHE MANIFEST" string at the top of the
file).
If fetching the manifest fails due to a 404 or 410 response or equivalent, then run these substeps:
Mark cache group as obsolete. This cache group no
longer exists for any purpose other than the processing of Document objects
already associated with an application cache in the cache
group.
For each cache host associated with an application cache in
cache group, create a task to fire
a simple event named obsolete that is
cancelable at the ApplicationCache singleton of the cache host, and
append it to task list. The default action of these events must be, if the
user agent shows caching progress, the display of some sort of user interface
indicating to the user that the application is no longer available for offline use.
For each entry in cache group's list of pending master entries, create a task to fire a simple event that is cancelable named
error (not obsolete!) at the ApplicationCache
singleton of the Document for this entry, if there still is one, and append it to
task list. The default action of this event must be, if the user agent
shows caching progress, the display of some sort of user interface indicating to
the user that the user agent failed to save the application for offline use.
Otherwise, if fetching the manifest fails in some other way (e.g. the server returns
another 4xx or 5xx response or equivalent, or
there is a DNS error, or the connection times out, or the user cancels the download, or the
parser for manifests fails when checking the magic signature), or if the server returned a
redirect, then run the cache failure steps. [HTTP]
If this is an upgrade attempt and the newly
downloaded manifest is byte-for-byte identical to the manifest found in the
newestapplication cache in cache group, or the server reported it as "304 Not Modified" or equivalent, then run these substeps:
For each entry in cache group's list of pending master entries, wait for the
resource for this entry to have either completely downloaded or failed.
If the download failed (e.g. the server returns a 4xx or 5xx response or equivalent, or there is a DNS error, the
connection times out, or the user cancels the download), or if the resource is labeled with
the "no-store" cache directive, then create a task to
fire a simple event that is cancelable named error at the ApplicationCache singleton of
the Document for this entry, if there still is one, and append it to task list. The default action of this event must be, if the user agent
shows caching progress, the display of some sort of user interface indicating to
the user that the user agent failed to save the application for offline use.
Otherwise, associate the Document for this entry with cache; store the resource for this entry in cache, if it
isn't already there, and categorise its entry as a master entry. If applying the URL parser
algorithm to the resource's URL results in a parsed URL that has a
non-null fragment component, the URL
used for the entry in cache must instead be the absolute URL
obtained from applying the URL serializer
algorithm to the parsed URL with the exclude fragment flag set
(application caches never include fragment identifiers).
If any URL is in file list more than once, then merge the entries into
one entry for that URL, that entry having all the flags that the original entries had.
If the resource URL being processed was flagged as neither an "explicit entry" nor or a
"fallback entry", then the user agent may skip this URL.
This is intended to allow user agents to expire resources not listed in the
manifest from the cache. Generally, implementors are urged to use an approach that expires
lesser-used resources first.
For each cache host associated with an application cache in
cache group, queue a post-load task to fire a trusted
event with the name progress, which does not
bubble, which is cancelable, and which uses the ProgressEvent interface, at the
ApplicationCache singleton of the cache host. The lengthComputable attribute must be set to
true, the total attribute must be set to the
number of files in file list, and the loaded attribute must be set to the number of files in
file list that have been either downloaded or skipped so far. The default
action of these events must be, if the user agent shows caching progress, the
display of some sort of user interface indicating to the user that a file is being downloaded
in preparation for updating the application. [XHR]
Fetch the resource, from the origin of the
URLmanifest URL, with the synchronous flag set and
the manual redirect flag set. If this is an upgrade attempt, then use the newestapplication cache in cache group as an HTTP cache, and honor HTTP caching semantics (such as
expiration, ETags, and so forth) with respect to that cache. User agents may also have other
caches in place that are also honored.
If the resource in question is already being downloaded for other reasons then
the existing download process can sometimes be used for the purposes of this step, as defined
by the fetching algorithm.
An example of a resource that might already be being downloaded is a large
image on a Web page that is being seen for the first time. The image would get downloaded to
satisfy the img element on the page, as well as being listed in the cache
manifest. According to the rules for fetching that image only need
be downloaded once, and it can be used both for the cache and for the rendered Web page.
If the previous step fails (e.g. the server returns a 4xx or 5xx response or equivalent, or there is a DNS error, or the
connection times out, or the user cancels the download), or if the server returned a redirect,
or if the resource is labeled with the "no-store" cache directive, then run the first
appropriate step from the following list: [HTTP]
If the URL being processed was flagged as an "explicit entry" or a "fallback entry"
If these steps are being run in parallel for any other URLs in file
list, then abort these steps for those other URLs. Run the cache failure
steps.
Redirects are fatal because they are either indicative of a network problem
(e.g. a captive portal); or would allow resources to be added to the cache under URLs that
differ from any URL that the networking model will allow access to, leaving orphan entries;
or would allow resources to be stored under URLs different than their true URLs. All of
these situations are bad.
If the error was a 404 or 410 HTTP response or equivalent
If the resource was labeled with the "no-store" cache directive
Skip this resource. It is dropped from the cache.
そうでなければ
Copy the resource and its metadata from the newestapplication cache in cache group whose completeness
flag is complete, and act as if that was the fetched resource, ignoring the
resource obtained from the network.
User agents may warn the user of these errors as an aid to development.
These rules make errors for resources listed in the manifest fatal, while
making it possible for other resources to be removed from caches when they are removed from
the server, without errors, and making non-manifest resources survive server-side errors.
Except for the "no-store" directive, HTTP caching rules that would cause a
file to be expired or otherwise not cached are ignored for the purposes of the
application cache download process.
Otherwise, the fetching succeeded. Store the resource in the new
cache.
If the user agent is not able to store the resource (e.g. because of quota restrictions),
the user agent may prompt the user or try to resolve the problem in some other manner (e.g.
automatically pruning content in other caches). If the problem cannot be resolved, the user
agent must run the cache failure steps.
If the URL being processed was flagged as an "explicit entry" in file
list, then categorise the entry as an explicit
entry.
If the URL being processed was flagged as a "fallback entry" in file
list, then categorise the entry as a fallback
entry.
If the URL being processed was flagged as an "master entry" in file
list, then categorise the entry as a master
entry.
As an optimization, if the resource is an HTML or XML file whose root element is an
html element with a manifest attribute
whose value doesn't match the manifest URL of the application cache being processed, then the
user agent should mark the entry as being foreign.
For each cache host associated with an application cache in cache group, queue a post-load task to fire a trusted
event with the name progress, which does not bubble,
which is cancelable, and which uses the ProgressEvent interface, at the
ApplicationCache singleton of the cache host. The lengthComputable attribute must be set to
true, the total and the loaded attributes must be set to the number of files in
file list. The default action of these events must be, if the user agent
shows caching progress, the display of some sort of user interface indicating to the
user that all the files have been downloaded. [XHR]
For each entry in cache group's list of pending master entries, wait for the
resource for this entry to have either completely downloaded or failed.
If the download failed (e.g. the server returns a 4xx or 5xx response or equivalent, or there is a DNS error, the
connection times out, or the user cancels the download), or if the resource is labeled with the
"no-store" cache directive, then run these substeps:
Unassociate the Document for this entry from new
cache.
Queue a post-load task to fire a simple event that is
cancelable named error at the
ApplicationCache singleton of the Document for this entry, if there
still is one. The default action of this event must be, if the user agent shows caching
progress, the display of some sort of user interface indicating to the user that the
user agent failed to save the application for offline use.
Otherwise, store the resource for this entry in new cache, if it isn't
already there, and categorise its entry as a master
entry.
Fetch the resource from manifest URL again, with
the synchronous flag set, and let second manifest be that resource.
HTTP caching semantics should again be honored for this request.
Since caching can be honored, authors are encouraged to avoid setting the cache
headers on the manifest in such a way that the user agent would simply not contact the network
for this second request; otherwise, the user agent would not notice if the cache had changed
during the cache update process.
If the previous step failed for any reason, or if the fetching attempt involved a redirect,
or if second manifest and manifest are not byte-for-byte
identical, then schedule a rerun of the entire algorithm with the same parameters after a short
delay, and run the cache failure steps.
Otherwise, store manifest in new cache, if it's not
there already, and categorise its entry as the
manifest.
If this is a cache attempt, then for each
cache host associated with an application cache in cache
group, create a task to fire a simple event
that is cancelable named cached at the
ApplicationCache singleton of the cache host, and append it to task list. The default action of these events must be, if the user agent
shows caching progress, the display of some sort of user interface indicating to
the user that the application has been cached and that they can now use it offline.
Otherwise, it is an upgrade attempt. For each
cache host associated with an application cache in cache
group, create a task to fire a simple event
that is cancelable named updateready at the
ApplicationCache singleton of the cache host, and append it to task list. The default action of these events must be, if the user agent
shows caching progress, the display of some sort of user interface indicating to
the user that a new version is available and that they can activate it by reloading the
page.
If appropriate, remove any user interface indicating that an update for this cache is in
progress.
For each entry in cache group's list of pending master entries, run the
following further substeps. These steps may be run in parallel for two or more entries at a
time.
Wait for the resource for this entry to have either completely downloaded or failed.
Create a task to fire a simple event that
is cancelable named error at the
ApplicationCache singleton of the Document for this entry, if there
still is one, and append it to task list. The default action of these
events must be, if the user agent shows caching progress, the display of some sort
of user interface indicating to the user that the user agent failed to save the application for
offline use.
For each cache host still associated with an application cache
in cache group, create a task to fire
a simple event that is cancelable named error at
the ApplicationCache singleton of the cache host, and append it to task list. The default action of these events must be, if the user agent
shows caching progress, the display of some sort of user interface indicating to the
user that the user agent failed to save the application for offline use.
Attempts to fetch resources as part of the application cache download
process may be done with cache-defeating semantics, to avoid problems with stale or
inconsistent intermediary caches.
Each Document has a list of pending application cache download process
tasks that is used to delay events fired by the algorithm above until the document's load event has fired. When the Document is created, the
list must be empty.
When the steps above say to queue a post-load task task, where
task is a task that dispatches an event on a
target ApplicationCache object target, the user agent must run
the appropriate steps from the following list:
When the application cache selection algorithm
algorithm is invoked with a Documentdocument and optionally a
manifest URLmanifest URL, the user agent must run the first
applicable set of steps from the following list:
If there are relevant application caches that
are identified by a URL with the same origin as the URL of document, and that have this URL as one of their entries, excluding entries
marked as foreign, then the user agent should use
the most appropriate application cache of those
that match as an HTTP cache for any subresource loads. User agents may also have other caches in
place that are also honored.
If there was a manifest URL, the user agent may report to the user that
it was ignored, to aid in application development.
6.7.6 Changes to the networking model
When a cache host is associated with an application cache whose completeness flag is complete, any and all
loads for resources related to that cache host other than those for child browsing contexts must go through the following steps
instead of immediately invoking the mechanisms appropriate to that resource's scheme:
If the resource is not to be fetched using the HTTP GET mechanism or equivalent, or if applying the URL
parser algorithm to both its URL and the application cache's
manifest's URL results in two parsed URLs with different scheme components,
then fetch the resource normally and abort these steps.
Fetch the resource normally. If this results in a redirect to a resource with
another origin (indicative of a captive portal), or a 4xx or 5xx status code or equivalent, or if there were network errors (but
not if the user canceled the download), then instead get, from the cache, the resource of the
fallback entry corresponding to the fallback namespacef. Abort
these steps.
Fail the resource load as if there had been a generic network error.
The above algorithm ensures that so long as the online whitelist wildcard flag is blocking, resources that are not present in the manifest will always fail to load (at least, after the
application cache has been primed the first time), making the testing of offline
applications simpler.
6.7.7 Expiring application caches
As a general rule, user agents should not expire application caches, except on request from the
user, or after having been left unused for an extended period of time.
Application caches and cookies have similar implications with respect to privacy (e.g. if the
site can identify the user when providing the cache, it can store data in the cache that can be
used for cookie resurrection). Implementors are therefore encouraged to expose application caches
in a manner related to HTTP cookies, allowing caches to be expunged together with cookies and
other origin-specific data.
For example, a user agent could have a "delete site-specific data" feature that
clears all cookies, application caches, local storage, databases, etc, from an origin all at
once.
6.7.8 Disk space
User agents should consider applying constraints on disk usage of application caches, and care should be taken to ensure that the restrictions cannot
be easily worked around using subdomains.
User agents should allow users to see how much space each domain is using, and may offer the
user the ability to delete specific application caches.
For predictability, quotas should be based on the uncompressed size of data stored.
How quotas are presented to the user is not defined by this specification. User
agents are encouraged to provide features such as allowing a user to indicate that certain sites
are trusted to use more than the default quota, e.g. by asynchronously presenting a user interface
while a cache is being updated, or by having an explicit whitelist in the user agent's
configuration interface.
There is a one-to-one mapping from cache hosts to
ApplicationCache objects. The applicationCache attribute on Window
objects must return the ApplicationCache object associated with the
Window object's active document. The applicationCache attribute
on SharedWorkerGlobalScope objects must return the ApplicationCache
object associated with the worker.
The status attribute, on getting, must
return the current state of the application cache that the
ApplicationCache object's cache host is associated with, if any. This
must be the appropriate value from the following list:
Let cache be the application cache with which the
ApplicationCache object's cache host is associated. (By definition,
this is the same as the one that was found in the previous step.)
The navigator.onLine attribute must return
false if the user agent will not contact the network when the user follows links or when a script
requests a remote page (or knows that such an attempt would fail), and must return true
otherwise.
On the other hand, when the value that would be returned by the navigator.onLine attribute of a Window or
WorkerGlobalScope changes from false to true, the user agent must queue a
task to fire a simple event named online at
the Window or WorkerGlobalScope object.
Scripting is enabled in a browsing
context when all of the following conditions are true:
The user agent supports scripting.
The user has not disabled scripting for this browsing context at this time.
(User agents may provide users with the option to disable scripting globally, or in a
finer-grained manner, e.g. on a per-origin basis.)
A code entry-point represents a block of executable code that the script exposes to other
scripts and to the user agent. Typically, the code corresponding to the code entry-point is
executed immediately after the script is parsed, but for event handlers, it is called each time
the handler is invoked.
In JavaScript script blocks, this corresponds to the execution
context of the global code.
Optionally, a muted errors flag
A flag which, if set, means that error information will not be provided for errors in this
script (used to mute errors for cross-origin scripts, since that can leak private
information).
A settings object
A script settings object, various settings that are shared with other scripts in
the same context.
A script settings object specifies algorithms for obtaining the following:
A script execution environment for each language supported by the user agent
The characteristics of the script execution environment depend on the language, and are not
defined by this specification.
In JavaScript, the script execution environment consists of the interpreter,
the stack of execution contexts, the global code and function code and the
Function objects resulting, and so forth.
A global object
An object that provides the APIs that can be called by the code in scripts that use this
settings object.
This is typically a Window object or a
WorkerGlobalScope object. When a global object is an empty object, it
can't do anything that interacts with the environment.
If the global object is a Window object, then, in JavaScript, the
ThisBinding of the global execution context for this script must be the Window
object's WindowProxy object, rather than the global object. [ECMA262]
This is a willful violation of the JavaScript specification current
at the time of writing (ECMAScript edition 5, as defined in section 10.4.1.1 Initial Global
Execution Context, step 3). The JavaScript specification requires that the this keyword in the global scope return the global object, but this is not
compatible with the security design prevalent in implementations as specified herein. [ECMA262]
An event loop that is used when it would not be immediately clear what event
loop to use.
An API referrer source
Either a Document (specifically, the responsible document), or a
URL, which is used by some APIs to determine what value to use for the Referer (sic) header in calls to the fetching algorithm.
An API URL character encoding
A character encoding used to encode URLs by APIs called by scripts that use this script
settings object.
The relevant settings object for a global object o is the
script settings object whose global object is o.
(There is always a 1:1 mapping of global objects to script settings objects.)
The relevant settings object for a script s is the
settings object of s.
7.1.3.2 Script settings for browsing contexts
Whenever a new Window object is created, it must also create a script
settings object whose algorithms are defined as follows:
When the script settings object is created, for each language supported by the
user agent, create an appropriate execution environment as defined by the relevant
specification.
Each unit of related similar-origin browsing contexts has a stack of script
settings objects, which must be initially empty. When a new script settings
object is pushed onto this stack, the specified script settings object
is to be added to the stack; when the script settings object on this stack that was
most recently pushed onto it is to be popped from the stack, it must be removed. Entries on
this stack can be labeled as candidate entry
settings objects.
When a user agent is to jump to a code entry-point for a scripts, the user agent must run the
following steps:
These algorithms are not invoked by one script directly calling another, but they
can be invoked reentrantly in an indirect manner, e.g. if a script dispatches an event which has
event listeners registered.
When a JavaScript SourceElements production is to be evaluated, the settings
object of the script corresponding to that
SourceElements must be pushed onto the stack of script settings objects before
the evaluation begins, and popped when the evaluation ends (regardless of whether it's an abrupt
completion or not).
The Web IDL specification also uses these algorithms. [WEBIDL]
Each unit of related similar-origin browsing contexts has a global script
clean-up jobs list, which must initially be empty. A global script clean-up job cannot run
scripts, and cannot be sensitive to the order in which other clean-up jobs are executed. The File
API uses this to release blob: URLs. [FILEAPI]
When the user agent is to run the global script clean-up jobs, the user agent must
perform each of the jobs in the global script clean-up jobs list and then empty the
list.
7.1.3.4 Creating scripts
When the specification says that a script is to be created, given some script source, a script source URL, its
scripting language, a script settings object, and optionally a muted
errors flag, the user agent must run the following steps:
Let script be a new script that
this algorithm will subsequently initialize.
If scripting is disabled for browsing
context passed to this algorithm, then abort these steps, as if the script source
described a program that did nothing but return void.
If the muted errors flag was set, then set script's muted errors flag.
If all the steps above succeeded (in particular, if the script was compiled successfully),
Jump to script's code
entry-point.
Otherwise, report the error for script, with the
problematic position (line number and column number), using the global object
specified by the script settings object as the target. If the error is still not handled after this, then the error may be reported to
the user.
7.1.3.5 Killing scripts
User agents may impose resource limitations on scripts, for example CPU quotas, memory limits,
total execution time limits, or bandwidth limitations. When a script exceeds a limit, the user
agent may either throw a QuotaExceededError exception, abort the script without an
exception, prompt the user, or throttle script execution.
For example, the following script never terminates. A user agent could, after waiting for a
few seconds, prompt the user to either terminate the script or let it continue.
<script>
while (true) { /* loop */ }
</script>
User agents are encouraged to allow users to disable scripting whenever the user is prompted
either by a script (e.g. using the window.alert() API) or because
of a script's actions (e.g. because it has exceeded a time limit).
If scripting is disabled while a script is executing, the script should be terminated
immediately.
User agents may allow users to specifically disable scripts just for the purposes of closing a
browsing context.
For example, the prompt mentioned in the example above could also offer the
user with a mechanism to just close the page entirely, without running any unload event handlers.
7.1.3.6 Runtime script errors
When the user agent is required to report an error for a
particular scriptscript with a particular
position line:col, using a particular target target, it must run these steps, after which the error is either handled or not
handled:
Let message be a user-agent-defined string describing the error in a
helpful manner.
Let error object be the object that represents the error: in the case
of an uncaught exception, that would be the object that was thrown; in the case of a JavaScript
error that would be an Error object. If there is no corresponding object, then the
null value must be used instead.
Let location be an absolute URL that corresponds to the
resource from which script was obtained.
The resource containing the script will typically be the file from which the
Document was parsed, e.g. for inline script elements or event
handler content attributes; or the JavaScript file that the script was in, for external
scripts. Even for dynamically-generated scripts, user agents are strongly encouraged to attempt
to keep track of the original source of a script. For example, if an external script uses the
document.write() API to insert an inline
script element during parsing, the URL of the resource containing the script would
ideally be reported as being the external script, and the line number might ideally be reported
as the line with the document.write() call or where the
string passed to that call was first constructed. Naturally, implementing this can be somewhat
non-trivial.
User agents are similarly encouraged to keep careful track of the original line
numbers, even in the face of document.write() calls
mutating the document as it is parsed, or event handler content attributes spanning
multiple lines.
If script has muted errors, then set message to "Script error.", set location
to the empty string, set line and col to 0, and set error object to null.
Let event be a new trustedErrorEvent object that does not bubble but is cancelable, and which has the event
name error.
If event was canceled, then the error is handled. Otherwise, the error is not handled.
7.1.3.6.1 Runtime script errors in documents
Whenever an uncaught runtime script error occurs in one of the scripts associated with a
Document, the user agent must report the error for the relevant script, with the problematic position (line number and column
number) in the resource containing the script, using the global object specified by
the script's settings object as the target. If the error is still not handled after this, then the error may be reported to
the user.
To coordinate events, user interaction, scripts, rendering, networking, and so forth, user
agents must use event loops as described in this section. There are
two kinds of event loops: those for browsing contexts, and
those for workers.
Worker event loops are simpler: each worker has one
event loop, and the worker processing model
manages the event loop's lifetime.
An event loop has one or more task queues. A
task queue is an ordered list of tasks, which are
algorithms that are responsible for such work as:
イベント
Asynchronously dispatching an Event object at a particular
EventTarget object is often done by a dedicated task.
Not all events are dispatched using the task queue, many are
dispatched synchronously during other tasks.
Parsing
The HTML parser tokenizing one or more bytes, and then processing any
resulting tokens, is typically a task.
Callbacks
Calling a callback asynchronously is often done by a dedicated task.
Using a resource
When an algorithm fetches a resource, if the fetching occurs
asynchronously then the processing of the resource once some or all of the resource is available
is performed by a task.
Reacting to DOM manipulation
Some elements have tasks that trigger in response to DOM manipulation, e.g. when that
element is inserted into the document.
When a user agent is to queue a task, it must add the given task to one of the task queues of the relevant event loop.
Each task is defined as coming from a specific task
source. All the tasks from one particular task source and destined to a
particular event loop (e.g. the callbacks generated by timers of a
Document, the events fired for mouse movements over that Document, the
tasks queued for the parser of that Document) must always be added to the same
task queue, but tasks from different task sources may be placed in different task
queues.
For example, a user agent could have one task queue for mouse and
key events (the user interaction task source), and another for everything else. The
user agent could then give keyboard and mouse events preference over other tasks three quarters of
the time, keeping the interface responsive but not starving other task queues, and never
processing events from any one task source out of order.
Each event loop has a currently running task. Initially, this is null.
It is used to handle reentrancy. Each event loop also has a performing a
microtask checkpoint flag, which must initially be false. It is used to prevent reentrant
invocation of the perform a microtask checkpoint algorithm.
A user agent may have one storage mutex. This mutex is used to control access to
shared state like cookies. At any one point, the storage mutex is either free, or
owned by a particular event loop or instance of the fetching algorithm.
If a user agent does not implement a storage mutex, it is exempt from implementing
the requirements that require it to acquire or release it.
User agent implementors have to make a choice between two evils. On the one hand,
not implementing the storage mutex means that there is a risk of data corruption: a site could,
for instance, try to read a cookie, increment its value, then write it back out, using the new
value of the cookie as a unique identifier for the session; if the site does this twice in two
different browser windows at the same time, it might end up using the same "unique" identifier for
both sessions, with potentially disastrous effects. On the other hand, implementing the storage
mutex has potentially serious performance implications: whenever a site uses Web Storage or
cookies, all other sites that try to use Web Storage or cookies are blocked until the first site
finishes.
So far, all browsers faced with this decision have opted to not implement the
storage mutex.
If this is a workerevent loop (i.e. one running for a
WorkerGlobalScope), but there are no tasks in the
event loop's task queues and the
WorkerGlobalScope object's closing flag is true, then destroy the event
loop, aborting these steps, resuming the run a worker steps described in the
Web Workers section below.
Each event loop has a microtask queue. A microtask is a
task that is originally to be queued on the microtask
queue rather than a task queue. There are two kinds of microtasks: solitary callback
microtasks, and compound microtasks.
When a user agent is to perform a microtask checkpoint, if the performing a
microtask checkpoint flag is false, then the user agent must run the following steps:
If, while a compound microtask is running, the user agent is required to
execute a compound microtask subtask to run a series of steps, the user agent must run
the following steps:
Let subtask be a new task that
consists of running the given series of steps. The task source of such a
microtask is the microtask task source. This is a compound
microtask subtask.
When an asynchronously-running algorithm is to await a stable state, the user agent
must queue a microtask that first runs the algorithm's synchronous
section, and then resumes running the asynchronous algorithm (if appropriate), as described
in the algorithm's steps.
Some of the algorithms in this specification, for historical reasons, require the user agent to
pause while running a task until a condition goal is met. This means running the following steps:
If necessary, update the rendering or user interface of any Document or
browsing context to reflect the current state.
Wait until the condition goal is met. While a user agent has a paused
task, the corresponding event loop must not run
further tasks, and any script in the currently running task must block. User agents should remain responsive to user input
while paused, however, albeit in a reduced capacity since the event loop will not be
doing anything.
When a user agent is to obtain the storage mutex as part of running a task, it must run through the following steps:
The following task sources are used by a number of mostly
unrelated features in this and other specifications.
The DOM manipulation task source
This task source is used for features that react to DOM manipulations, such as
things that happen asynchronously when an element is inserted into the document.
The user interaction task source
This task source is used for features that react to user interaction, for
example keyboard or mouse input.
An event handler can either have the value null, or be set
to a callback object, or be set to an internal raw uncompiled
handler. The EventHandler callback function type describes how this is
exposed to scripts. Initially, event handlers must be set to null.
An event handler IDL attribute is an IDL
attribute for a specific event handler. The name of the IDL
attribute is the same as the name of the event handler.
If an event handler IDL attribute exposes an
event handler of an object that doesn't exist, it must always
return null on getting and must do nothing on setting.
The listener is emphatically not the event handler itself. Every event handler ends up registering the same
listener, the algorithm defined below, which takes care of invoking the right callback, and
processing the callback's return value.
This only happens the first time the event
handler's value is set. Since listeners are called in the order they were registered, the
order of event listeners for a particular event type will always be first the event listeners
registered with addEventListener() before
the first time the event handler was set to a non-null value,
then the callback to which it is currently set, if any, and finally the event listeners registered
with addEventListener()after the
first time the event handler was set to a non-null value.
Invokecallback with five arguments,
the first one having the value of E's message attribute,
the second having the value of E's filename attribute,
the third having the value of E's lineno attribute,
the fourth having the value of E's colno attribute,
the fifth having the value of E's error attribute, and
with the callback this value set to E's currentTarget. Let return value be the callback's return value. [WEBIDL]
そうでなければ
Invokecallback
with one argument, the value of which is the Event object E,
with the callback this value set to E's currentTarget. Let return value be the callback's return value. [WEBIDL]
If the return value is null, then cancel the event.
Otherwise, If the Event object E is a
BeforeUnloadEvent object, and the Event object E's returnValue
attribute's value is the empty string, then set the returnValue attribute's value to return value.
そうでなければ
If return value is a Web IDL boolean false value, then cancel the
event.
The return value of the function affects whether the event is canceled or not:
as described above, if the return value is false, the event is canceled
(except for mouseover events, where the return value has to
be true to cancel the event). With beforeunload events,
the value is instead used to determine the message to show the user.
If H is an element's event
handler, then let element be the element, and document be the element's Document.
Otherwise, H is a Window object's event handler: let element be null, and let document be the Document most recently associated with that
Window object.
If body is not parsable as FunctionBody or if parsing detects
an early error, then follow these substeps:
Set H's value to null.
Report the error for the appropriate script and with the appropriate position (line number and
column number) given by location, using the global object
specified by script settings as the target. If the error is still not handled after this, then the error may be reported
to the user.
Jump to the step labeled end below.
FunctionBody is defined in ECMAScript edition 5 section 13 Function
Definition. Early error is defined in ECMAScript edition 5 section 16 Errors. [ECMA262]
If body begins with a Directive Prologue that contains a Use Strict
Directive then let strict be true, otherwise let strict be false.
The terms "Directive Prologue" and "Use Strict Directive" are defined in
ECMAScript edition 5 section 14.1 Directive Prologues and the Use Strict Directive. [ECMA262]
Using the script execution environment obtained above, create a function
object (as defined in ECMAScript edition 5 section 13.2 Creating Function Objects), with:
Certain operations and methods are defined as firing events on elements. For example, the click() method on the HTMLElement interface is defined as
firing a click event on the element. [DOMEVENTS]
Firing a simple event named e
means that a trusted event with the name e, which does not bubble (except where otherwise stated) and is not cancelable
(except where otherwise stated), and which uses the Event interface, must be created
and dispatched at the given target.
Firing a synthetic mouse event named e means that an event with the name e, which is trusted (except where otherwise stated), does not bubble
(except where otherwise stated), is not cancelable (except where otherwise stated), and which uses
the MouseEvent interface, must be created and dispatched at the given target. The
event object must have its screenX, screenY, clientX, clientY, and button
attributes initialised to 0, its ctrlKey, shiftKey,
altKey, and metaKey attributes initialised according
to the current state of the key input device, if any (false for any keys that are not available),
its detail attribute initialised to 1, and its relatedTarget attribute initialised to null (except
where otherwise stated). The getModifierState() method on the object must
return values appropriately describing the state of the key input device at the time the event is
created.
The WindowBase64 interface adds to the Window interface
and the WorkerGlobalScope interface (part of Web workers).
The btoa() method must throw an
InvalidCharacterError exception if the method's first argument contains any character
whose code point is greater than U+00FF. Otherwise, the user agent must convert that argument to a
sequence of octets whose nth octet is the eight-bit representation of the code
point of the nth character of the argument, and then must apply the base64
algorithm to that sequence of octets, and return the result. [RFC4648]
The atob() method must run the following
steps to parse the string passed in the method's first argument:
Let input be the string being parsed.
Let position be a pointer into input, initially
pointing at the start of the string.
If the length of input divides by 4 leaving no remainder, then: if
input ends with one or two "=" (U+003D) characters, remove them
from input.
If the length of input divides by 4 leaving a remainder of 1, throw an
InvalidCharacterError exception and abort these steps.
If input contains a character that is not in the following list of
characters and character ranges, throw an InvalidCharacterError exception and abort
these steps:
Let buffer be a buffer that can have bits appended to it, initially
empty.
While position does not point past the end of input,
run these substeps:
Find the character pointed to by position in the first column of the
following table. Let n be the number given in the second cell of the same
row.
Character
Number
A
0
B
1
C
2
D
3
E
4
F
5
G
6
H
7
I
8
J
9
K
10
L
11
M
12
N
13
O
14
P
15
Q
16
R
17
S
18
T
19
U
20
V
21
W
22
X
23
Y
24
Z
25
a
26
b
27
c
28
d
29
e
30
f
31
g
32
h
33
i
34
j
35
k
36
l
37
m
38
n
39
o
40
p
41
q
42
r
43
s
44
t
45
u
46
v
47
w
48
x
49
y
50
z
51
0
52
1
53
2
54
3
55
4
56
5
57
6
58
7
59
8
60
9
61
+
62
./
63
Append to buffer the six bits corresponding to number, most significant bit first.
If buffer has accumulated 24 bits, interpret them as three 8-bit
big-endian numbers. Append the three characters with code points equal to those numbers to output, in the same order, and then empty buffer.
Advance position by one character.
If buffer is not empty, it contains either 12 or 18 bits. If it contains
12 bits, discard the last four and interpret the remaining eight as an 8-bit big-endian number.
If it contains 18 bits, discard the last two and interpret the remaining 16 as two 8-bit
big-endian numbers. Append the one or two characters with code points equal to those one or two
numbers to output, in the same order.
The discarded bits mean that, for instance, atob("YQ") and
atob("YR") both return "a".
Document objects have an ignore-opens-during-unload counter, which is
used to prevent scripts from invoking the document.open()
method (directly or indirectly) while the document is being
unloaded. Initially, the counter must be set to zero.
When called with two arguments, the document.open()
method must act as follows:
If the Document has an active parser whose script nesting
level is greater than zero, 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 parsing, while still letting it
have an effect when called asynchronously.
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, and Navigator, objects, the
various BarProp objects, the two Storage objects, the various
HTMLCollection objects, and objects defined by other specifications, like
Selection and the document's UndoManager. 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.
If type is not now an ASCII case-insensitive match
for the string "text/html", then act as if the tokenizer had emitted a start tag
token with the tag name "pre" followed by a single "LF" (U+000A) character, then switch the
HTML parser's tokenizer to the PLAINTEXT state.
Remove any earlier entries that share the same Document.
If replace is false, then add a new entry, just before the last entry,
and associate with the new entry 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. This new entry
does not have a Document object, so a new one will be created if the session history
is traversed to that entry.
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 four arguments, the open() method on
the Document object must call the open() method on the
Window object of the Document object, with the same arguments as the
original call to the open() method, and return whatever
that method returned. If the Document object has no Window object, then
the method must throw an InvalidAccessError exception.
このメソッドは非常に特異な振る舞いを持つ。一部の場合において、このメソッドは、パーサが実行されている間、HTMLパーサの状態に影響を与えることができる。その結果、文書のソースに対応しないDOMをもたらす（たとえば、記述された文字列が、文字列"<plaintext>"または"<!--"である場合）。他の例では、あたかもdocument.open()が呼び出されていたかのように、呼び出しが最初に現在のページをクリアできる。さらに多くの例では、メソッドは単に無視されるか、または例外を投げる。さらに悪いことに、このメソッドの正確な動作は、いくつかのケースにおいて、デバッグに非常に困難な障害を招く可能性がある、ネットワークレイテンシに依存するかもしれない。, which can lead to failures that are very hard to debug. これらすべての理由から、このメソッドの使用を強く推奨しない。
Document objects have an ignore-destructive-writes counter, which is
used in conjunction with the processing of script elements to prevent external
scripts from being able to use document.write() to blow
away the document by implicitly calling document.open().
Initially, the counter must be set to zero.
The document.write(...) method must act as
follows:
If there is no pending parsing-blocking script, have the HTML
parser 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).
The WindowTimers interface adds to the Window interface
and the WorkerGlobalScope interface (part of Web workers).
Each object that implements the WindowTimers interface has a list of active
timers. Each entry in this lists is identified by a number, which must be unique within the
list for the lifetime of the object that implements the WindowTimers interface.
The setTimeout() method must return
the value returned by the timer initialization steps, passing them the method's
arguments, the object on which the method for which the algorithm is running is implemented (a
Window or WorkerGlobalScope object) as the method
context, and the repeat flag set to false.
The setInterval() method must
return the value returned by the timer initialization steps, passing them the
method's arguments, the object on which the method for which the algorithm is running is
implemented (a Window or WorkerGlobalScope object) as the method context, and the repeat flag set to true.
The clearTimeout() and clearInterval() methods must clear the
entry identified as handle from the list of active timers of the
WindowTimers object on which the method was invoked, if any, where handle is the argument passed to the method. (If handle does
not identify an entry in the list of active timers of the WindowTimers
object on which the method was invoked, the method does nothing.)
The timer initialization steps, which are invoked with some method arguments, a method context, a repeat flag which can be true or false, and
optionally (and only if the repeat flag is true) a previous
handle, are as follows:
Let method context proxy be method context if that
is a WorkerGlobalScope object, or else the WindowProxy that corresponds
to method context.
If previous handle was provided, let handle be
previous handle; otherwise, let handle be a
user-agent-defined integer that is greater than zero that will identify the timeout to be set by
this call in the list of active timers.
If previous handle was not provided, add an entry to the list of
active timers for handle.
Let task be a task that runs the
following substeps:
If the entry for handle in the list of active timers
has been cleared, then abort this task's substeps.
Run the appropriate set of steps from the following list:
If the first method argument is a Function
Call the Function. Use the third and subsequent method arguments (if any) as
the arguments for invoking the Function. Use method context
proxy as the thisArg for invoking the Function. [ECMA262]
Create a script using script source as the script
source, the URL where script source can be found, scripting language as the scripting language, and settings
object as the script settings object.
If the repeat flag is true, then call timer initialization
steps again, passing them the same method arguments, the same method
context, with the repeat flag still set to true, and with the previous handle set to handler.
Let timeout be the second method argument.
If the currently running task is a task that was created
by this algorithm, then let nesting level be the task's timer nesting level. Otherwise, let nesting level be zero.
If nesting level is greater than 5, and timeout is
less than 4, then increase timeout to 4.
Increment nesting level by one.
Let task's timer nesting level be nesting
level.
Return handle, and then continue running this algorithm
asynchronously.
If method context is a Window object, wait until the
Document associated with method context has been fully
active for a further timeout milliseconds (not necessarily
consecutively).
Otherwise, method context is a WorkerGlobalScope object;
wait until timeout milliseconds have passed with the worker not suspended
(not necessarily consecutively).
Wait until any invocations of this algorithm that had the same method
context, that started before this one, and whose timeout is equal to
or less than this one's, have completed.
Argument conversion as defined by Web IDL (for example, invoking toString() methods on objects passed as the first argument) happens in the
algorithms defined in Web IDL, before this algorithm is invoked.
So for example, the following rather silly code will result in the log containing "ONE TWO ":
var log = '';
function logger(s) { log += s + ' '; }
setTimeout({ toString: function () {
setTimeout("logger('ONE')", 100);
return "logger('TWO')";
} }, 100);
Optionally, wait a further user-agent defined length of time.
This is intended to allow user agents to pad timeouts as needed to optimise the
power usage of the device. For example, some processors have a low-power mode where the
granularity of timers is reduced; on such platforms, user agents can slow timers down to fit
this schedule instead of requiring the processor to use the more accurate mode with its
associated higher power usage.
Once the task has been processed, if the repeat flag is
false, it is safe to remove the entry for handle from the list of
active timers (there is no way for the entry's existence to be detected past this point,
so it does not technically matter one way or the other).
function doExpensiveWork() {
var done = false;
// ...
// this part of the function takes up to five milliseconds
// set done to true if we're done
// ...
return done;
}
function rescheduleWork() {
var handle = setTimeout(rescheduleWork, 0); // preschedule next iteration
if (doExpensiveWork())
clearTimeout(handle); // clear the timeout if we don't need it
}
function scheduleWork() {
setTimeout(rescheduleWork, 0);
}
scheduleWork(); // queues a task to do lots of work
Optionally, abort these steps. (For example, the user agent might give the user the option
to ignore all alerts, and would thus abort at this step whenever the method was
invoked.)
If the method was invoked with no arguments, then let message be the
empty string; otherwise, let message be the method's first
argument.
Show the given message to the user.
Optionally, pause while waiting for the user to acknowledge the
message.
The confirm(message) method,
when invoked, must run the following steps:
Optionally, return false and abort these steps. (For example, the user agent might give
the user the option to ignore all prompts, and would thus abort at this step whenever the method
was invoked.)
Show the given message to the user, and ask the user to respond with a
positive or negative response.
Pause until the user responds either positively or negatively.
If the user responded positively, return true; otherwise, the user responded negatively:
return false.
The prompt(message, default) method, when invoked, must run the following steps:
Optionally, return null and abort these steps. (For example, the user agent might give the
user the option to ignore all prompts, and would thus abort at this step whenever the method was
invoked.)
Show the given message to the user, and ask the user to either respond
with a string value or abort. The response must be defaulted to the value given by
default.
When the print() method is invoked, if the
Document is ready for post-load tasks, then the user agent must
synchronously run the printing steps. Otherwise, the user agent must only set the
print when loaded flag on the Document.
User agents should also run the printing steps whenever the user asks for the
opportunity to obtain a physical form (e.g. printed copy), or the representation of a
physical form (e.g. PDF copy), of a document.
The printing steps are as follows:
The user agent may display a message to the user or abort these steps (or both).
For instance, a kiosk browser could silently ignore any invocations of the
print() method.
For instance, a browser on a mobile device could detect that there are no
printers in the vicinity and display a message saying so before continuing to offer a "save to
PDF" option.
The user agent should offer the user the opportunity to obtain a physical form
(or the representation of a physical form) of the document. The user agent may wait for the user
to either accept or decline before returning; if so, the user agent must pause
while the method is waiting. Even if the user agent doesn't wait at this point, the user agent
must use the state of the relevant documents as they are at this point in the algorithm if and
when it eventually creates the alternate form.
The afterprint event can be used to
revert annotations added in the earlier event, as well as showing post-printing UI. For
instance, if a page is walking the user through the steps of applying for a home loan, the
script could automatically advance to the next step after having printed a form or other.
If the user agent is configured such that this invocation of showModalDialog() is somehow disabled, then return the empty
string and abort these steps.
User agents are expected to disable this method in certain cases to avoid user
annoyance (e.g. as part of their popup blocker feature). For instance, a user agent could
require that a site be white-listed before enabling this method, or the user agent could be
configured to only allow one modal dialog at a time.
...as well as any browsing contexts that are nested inside any of the browsing contexts
matching those conditions.
Disable the user interface for all the browsing contexts in the list of
background browsing contexts. This should prevent the user from navigating those browsing
contexts, causing events to be sent to those browsing context, or editing any content in those
browsing contexts. However, it does not prevent those browsing contexts from receiving events
from sources other than the user, from running scripts, from running animations, and so
forth.
When this happens, the members of the WindowModal interface, in
JavaScript environments, appear to actually be part of the Window interface (e.g.
they are on the same prototype chain as the window.alert()
method).
[NoInterfaceObject]
interface WindowModal {
readonly attribute any dialogArguments;
attribute any returnValue;
};
Such browsing contexts have associated dialog arguments, which are stored along with
the dialog arguments' origin. These values are set by the showModalDialog() method in the algorithm above, when the
browsing context is created, based on the arguments provided to the method.
These browsing contexts also have an associated return value and return value
origin. As with the previous two values, these values are set by the showModalDialog() method in the algorithm above, when the
browsing context is created.
The navigator attribute of the
Window interface must return an instance of the Navigator interface,
which represents the identity and state of the user agent (the client), and allows Web pages to
register themselves as potential protocol and content handlers:
Must return either the string "Netscape" or the full name of the
browser, e.g. "Mellblom Browsernator".
appVersion
Must return either the string "4.0" or a string representing the
version of the browser in detail, e.g. "1.0 (VMS; en-US)
Mellblomenator/9000".
platform
Must return either the empty string or a string representing the platform on which the
browser is executing, e.g. "MacIntel", "Win32",
"FreeBSD i386", "WebTV OS".
product
Must return the string "Gecko".
taintEnabled()
Must return false.
userAgent
Must return the string used for the value of the "User-Agent" header
in HTTP requests, or the empty string if no such header is ever sent.
Any information in this API that varies from user to user can be used to
profile the user. In fact, if enough such information is available, a user can actually be
uniquely identified. For this reason, user agent implementors are strongly urged to include as
little information in this API as possible.
Must return a valid BCP 47 language tag representing either a plausible
language or the user's most preferred language. [BCP47]
languages
Must return a read only array of valid BCP 47
language tags representing either one or more plausible
languages, or the user's preferred languages, ordered by preference with the most
preferred language first. The same object must be returned until the user agent needs to return
different values, or values in a different order. [BCP47]
Whenever the user agent needs to make the navigator.languages attribute of a Window
or WorkerGlobalScope object return a new set of language tags, the user agent must
queue a task to fire a simple event named languagechange at the Window or
WorkerGlobalScope object and wait until that task begins to be executed before
actually returning a new value.
To determine a plausible language, the user agent should bear in mind the following:
Any information in this API that varies from user to user can be used to profile or identify
the user.
If the user is not using a service that obfuscates the user's point of origin (e.g. the Tor
anonymity network), then the value that is least likely to distinguish the user from other users
with similar origins (e.g. from the same IP address block) is the language used by the majority
of such users. [TOR]
If the user is using an anonymizing service, then the value "en-US" is
suggested; if all users of the service use that same value, that reduces the possibility of
distinguishing the users from each other.
To avoid introducing any more fingerprinting vectors, user agents should use the same list for
the APIs defined in this function as for the HTTP Accept-Language header.
User agents may, within the constraints described in this section, do whatever they like when
the methods are called. A UA could, for instance, prompt the user and offer the user the
opportunity to add the site to a shortlist of handlers, or make the handlers his default, or
cancel the request. UAs could provide such a UI through modal UI or through a non-modal transient
notification interface. UAs could also simply silently collect the information, providing it only
when relevant to the user.
User agents should keep track of which sites have registered handlers (even if the user has
declined such registrations) so that the user is not repeatedly prompted with the same
request.
The arguments to the methods have the following meanings and corresponding implementation
requirements. The requirements that involve throwing exceptions must be processed in the order
given below, stopping at the first exception thrown. (So the exceptions for the first argument
take precedence over the exceptions for the second argument.)
A scheme, such as mailto or web+auth. The scheme must be compared
in an ASCII case-insensitive manner by user agents for the purposes of comparing
with the scheme part of URLs that they consider against the list of registered handlers.
The scheme value, if it contains a colon (as in "mailto:"),
will never match anything, since schemes don't contain colons.
If the registerProtocolHandler()
method is invoked with a scheme that is neither a whitelisted scheme nor a scheme
whose value starts with the substring "web+" and otherwise contains only
lowercase ASCII letters, and whose length is at least five characters (including
the "web+" prefix), the user agent must throw a SecurityError
exception.
The following schemes are the whitelisted schemes:
bitcoin
geo
im
irc
ircs
magnet
mailto
mms
news
nntp
sip
sms
smsto
ssh
tel
urn
webcal
wtai
xmpp
This list can be changed. If there are schemes that should be added, please send
feedback.
This list excludes any schemes that could reasonably be expected to be supported
inline, e.g. in an iframe, such as http or (more
theoretically) gopher. If those were supported, they could potentially be
used in man-in-the-middle attacks, by replacing pages that have frames with such content with
content under the control of the protocol handler. If the user agent has native support for the
schemes, this could further be used for cookie-theft attacks.
A MIME type, such as model/vnd.flatland.3dml or
application/vnd.google-earth.kml+xml. The MIME type must be compared
in an ASCII case-insensitive manner by user agents for the purposes of comparing
with MIME types of documents that they consider against the list of registered handlers.
User agents must compare the given values only to the MIME type/subtype parts of content
types, not to the complete type including parameters. Thus, if mimeType
values passed to this method include characters such as commas or whitespace, or include MIME
parameters, then the handler being registered will never be used.
The type is compared to the MIME type used by the user agent
after the sniffing algorithms have been applied.
All types that the user agent supports displaying natively in a browsing context during navigation, except for application/rss+xml and application/atom+xml
This list can be changed. If there are MIME types that should be added, please
send feedback.
url
A string used to build the URL of the page that will handle the requests.
User agents must throw a SyntaxError exception if the url
argument passed to one of these methods does not contain the exact literal string
"%s".
This site could then fetch the chickenkïwi.soup file and do whatever it is
that it does with soup (synthesise it and ship it to the user, or whatever).
title
A descriptive title of the handler, which the UA might use to remind the user what the site
in question is.
This section does not define how the pages registered by these methods are used, beyond the
requirements on how to process the url value (see above). To some extent, the
processing model for navigating across documents defines some cases
where these methods are relevant, but in general UAs may use this information wherever they would
otherwise consider handing content to native plugins or helper applications.
UAs must not use registered content handlers to handle content that was returned as part of a
non-GET transaction (or rather, as part of any non-idempotent transaction), as the remote site
would not be able to fetch the same data.
The isProtocolHandlerRegistered()
method must return the handler state string that most closely describes the current
state of the handler described by the two arguments to the method, where the first argument gives
the scheme and the second gives the string used to build the URL of the page that
will handle the requests.
The first argument must be compared to the schemes for which custom protocol handlers are
registered in an ASCII case-insensitive manner to find the relevant handlers.
The second argument must be preprocessed as described below, and if that is successful, must
then be matched against the proto-URLs of the relevant handlers to
find the described handler.
The isContentHandlerRegistered()
method must return the handler state string that most closely describes the current
state of the handler described by the two arguments to the method, where the first argument gives
the MIME type and the second gives the string used to build the URL of
the page that will handle the requests.
The first argument must be compared to the MIME types for which
custom content handlers are registered in an ASCII case-insensitive manner to find
the relevant handlers.
The second argument must be preprocessed as described below, and if that is successful, must
then be matched against the proto-URLs of the relevant handlers to
find the described handler.
The handler state strings are the following strings.
Each string describes several situations, as given by the following list.
new
The described handler has never been registered for the given scheme or type.
The described handler was once registered for the given scheme or type, but the site has
since unregistered it. If the handler were to be reregistered, the user would be notified
accordingly.
The described handler was once registered for the given scheme or type, but the site has
since unregistered it, but the user has indicated that the site is to be blocked from registering
the type again, so the user agent would ignore further registration attempts.
registered
An attempt was made to register the described handler for the given scheme or type, but the
user has not yet been notified, and the user agent would ignore further registration attempts.
(Maybe the user agent batches registration requests to display them when the user requests to be
notified about them, and the user has not yet requested that the user agent notify it of the
previous registration attempt.)
The described handler is registered for the given scheme or type (maybe, or maybe not, as the
default handler).
The described handler is permanently blocked from being (re)registered. (Maybe the user
marked the registration attempt as spam, or blocked the site for other reasons.)
declined
An attempt was made to register the described handler for the given scheme or type, but the
user has not yet been notified; however, the user might be notified if another registration
attempt were to be made. (Maybe the last registration attempt was made while the page was in the
background and the user closed the page without looking at it, and the user agent requires
confirmation for this registration attempt.)
An attempt was made to register the described handler for the given scheme or type, but the
user has not yet responded.
An attempt was made to register the described handler for the given scheme or type, but the
user declined the offer. The user has not indicated that the handler is to be permanently
blocked, however, so another attempt to register the described handler might result in the user
being prompted again.
The described handler was once registered for the given scheme or type, but the user has
since removed it. The user has not indicated that the handler is to be permanently blocked,
however, so another attempt to register the described handler might result in the user being
prompted again.
The unregisterProtocolHandler()
method must unregister the handler described by the two arguments to the method, where the first
argument gives the scheme and the second gives the string used to build the URL of
the page that will handle the requests.
The first argument must be compared to the schemes for which custom protocol handlers are
registered in an ASCII case-insensitive manner to find the relevant handlers.
The second argument must be preprocessed as described below, and if that is successful, must
then be matched against the proto-URLs of the relevant handlers to
find the described handler.
The unregisterContentHandler()
method must unregister the handler described by the two arguments to the method, where the first
argument gives the MIME type and the second gives the string used to build the
URL of the page that will handle the requests.
The first argument must be compared to the MIME types for which
custom content handlers are registered in an ASCII case-insensitive manner to find
the relevant handlers.
The second argument must be preprocessed as described below, and if that is successful, must
then be matched against the proto-URLs of the relevant handlers to
find the described handler.
The second argument of the four methods described above must be preprocessed as follows:
If the string does not contain the substring "%s", abort these
steps. There's no matching handler.
Return the resulting absolute URL as the result of preprocessing the
argument.
7.6.1.3.1 Security and privacy
These mechanisms can introduce a number of concerns, in particular privacy concerns.
Hijacking all Web usage. User agents should not allow schemes that are key to
its normal operation, such as http or https, to be rerouted through
third-party sites. This would allow a user's activities to be trivially tracked, and would allow
user information, even in secure connections, to be collected.
Hijacking defaults. User agents are strongly urged to not automatically change
any defaults, as this could lead the user to send data to remote hosts that the user is not
expecting. New handlers registering themselves should never automatically cause those sites to be
used.
Registration spamming. User agents should consider the possibility that a site
will attempt to register a large number of handlers, possibly from multiple domains (e.g. by
redirecting through a series of pages each on a different domain, and each registering a handler
for video/mpeg — analogous practices abusing other Web browser features have
been used by pornography Web sites for many years). User agents should gracefully handle such
hostile attempts, protecting the user.
Misleading titles. User agents should not rely wholly on the title argument to the methods when presenting the registered handlers to the user,
since sites could easily lie. For example, a site hostile.example.net could claim
that it was registering the "Cuddly Bear Happy Content Handler". User agents should therefore use
the handler's domain in any UI along with any title.
Hostile handler metadata. User agents should protect against typical attacks
against strings embedded in their interface, for example ensuring that markup or escape characters
in such strings are not executed, that null bytes are properly handled, that over-long strings do
not cause crashes or buffer overruns, and so forth.
Leaking Intranet URLs. The mechanism described in this section can result in
secret Intranet URLs being leaked, in the following manner:
The user registers a third-party content handler as the default handler for a content
type.
The user then browses his corporate Intranet site and accesses a document that uses that
content type.
The user agent contacts the third party and hands the third party the URL to the Intranet
content.
No actual confidential file data is leaked in this manner, but the URLs themselves could
contain confidential information. For example, the URL could be
http://www.corp.example.com/upcoming-aquisitions/the-sample-company.egf, which might
tell the third party that Example Corporation is intending to merge with The Sample Company.
Implementors might wish to consider allowing administrators to disable this feature for certain
subdomains, content types, or schemes.
Leaking secure URLs. User agents should not send HTTPS URLs to third-party
sites registered as content handlers without the user's informed consent, for the same reason that
user agents sometimes avoid sending Referer (sic) HTTP headers
from secure sites to third-party sites.
Leaking credentials. User agents must never send username or password
information in the URLs that are escaped and included sent to the handler sites. User agents may
even avoid attempting to pass to Web-based handlers the URLs of resources that are known to
require authentication to access, as such sites would be unable to access the resources in
question without prompting the user for credentials themselves (a practice that would require the
user to know whether to trust the third-party handler, a decision many users are unable to make or
even understand).
Interface interference. User agents should be prepared to handle intentionally
long arguments to the methods. For example, if the user interface exposed consists of an "accept"
button and a "deny" button, with the "accept" binding containing the name of the handler, it's
important that a long name not cause the "deny" button to be pushed off the screen.
Fingerprinting users. Since a site can detect if it has attempted to register
a particular handler or not, whether or not the user responds, the mechanism can be used to store
data. User agents are therefore strongly urged to treat registrations in the same manner as
cookies: clearing cookies for a site should also clear all registrations for that site, and
disabling cookies for a site should also disable registrations.
7.6.1.3.2 Sample user interface
この節は非規範的である。
A simple implementation of this feature for a desktop Web browser might work as follows.
In this dialog box, "Kittens at work" is the title of the page that invoked the method,
"http://kittens.example.org/" is the URL of that page, "application/x-meowmeow" is the string that
was passed to the registerContentHandler() method as its first
argument (mimeType), "http://kittens.example.org/?show=%s" was the second
argument (url), and "Kittens-at-work displayer" was the third argument (title).
If the user clicks the Cancel button, then nothing further happens. If the user clicks the
"Trust" button, then the handler is remembered.
When the user then attempts to fetch a URL that uses the "application/x-meowmeow" MIME
type, then it might display a dialog as follows:
In this dialog, the third option is the one that was primed by the site registering itself
earlier.
If the user does select that option, then the browser, in accordance with the requirements
described in the previous two sections, will redirect the user to
"http://kittens.example.org/?show=data%3Aapplication/x-meowmeow;base64,S2l0dGVucyBhcmUgdGhlIGN1dGVzdCE%253D".
The registerProtocolHandler() method
would work equivalently, but for schemes instead of unknown content types.
The cookieEnabled attribute must
return true if the user agent attempts to handle cookies according to the cookie specification,
and false if it ignores cookie change requests. [COOKIES]
The yieldForStorageUpdates() method,
when invoked, must, if the storage mutex is owned by the event loop of
the task that resulted in the method being called, release the
storage mutex so that it is once again free. Otherwise, it must do nothing.
The navigator.plugins attribute must
return a PluginArray object. The same object must be returned each time.
The navigator.mimeTypes attribute must
return a MimeTypeArray object. The same object must be returned each time.
A PluginArray object represents none, some, or all of the plugins supported by the user agent, each of which is represented by a Plugin object. Each of these Plugin
objects may be hidden plugins. A hidden plugin can't
be enumerated, but can still be inspected by using its name.
The fewer plugins are represented by the
PluginArray object, and of those, the more that are hidden, the more the user's privacy will be protected. Each exposed plugin
increases the number of bits that can be derived for fingerprinting. Hiding a plugin helps, but
unless it is an extremely rare plugin, it is likely that a site attempting to derive the list of
plugins can still determine whether the plugin is supported or not by probing for it by name (the
names of popular plugins are widely known). Therefore not exposing a plugin at all is preferred.
Unfortunately, many legacy sites use this feature to determine, for example, which plugin to use
to play video. Not exposing any plugins at all might therefore not be entirely plausible.
The PluginArray objects created by a user agent must not be live. The
set of plugins represented by the objects must not change once an object is created, except when
it is updated by the refresh() method.
Each plugin represented by a PluginArray can support a number of
MIME types. For each such plugin, the user agent must
pick one or more of these MIME types to be those that are
explicitly supported.
The explicitly supportedMIME types of
a plugin are those that are exposed through the Plugin and MimeTypeArray interfaces. As with plugins themselves, any variation between users regarding what is exposed
allows sites to fingerprint users. User agents are therefore encouraged to expose the same MIME types for all users of a plugin, regardless of the
actual types supported... at least, within the constraints imposed by compatibility with legacy
content.
The length attribute must return the
number of non-hiddenplugins
represented by the object.
The item() method of a
PluginArray object must return null if the argument is not one of the object's
supported property indices, and otherwise must return the result of running the
following steps, using the method's argument as index:
The namedItem() method of a
PluginArray object must return null if the argument is not one of the object's
supported property names, and otherwise must return the Plugin object, of those represented by the PluginArray
object, that has a name equal to the method's argument.
The refresh() method of the
PluginArray object of a Navigator object, when invoked, must check to
see if any plugins have been installed or reconfigured since the user
agent created the PluginArray object. If so, and the method's argument is true, then
the user agent must act as if the location.reload()
method was called instead. Otherwise, the user agent must update the PluginArray
object and MimeTypeArray object created for attributes of that Navigator
object, and the Plugin and MimeType objects created
for those PluginArray and MimeTypeArray objects, using the same Plugin objects for cases where the name is the same, and the same MimeType objects for
cases where the type is the same, and creating new objects
for cases where there were no matching objects immediately prior to the refresh() call. Old Plugin
and MimeType objects must continue to return the same values that they had prior to
the update, though naturally now the data is stale and may appear inconsistent (for example, an
old MimeType entry might list as its enabledPlugin a Plugin
object that no longer lists that MimeType as a supported MimeType).
The MimeTypeArray objects created by a user agent must not be live.
The set of MIME types represented by the objects must not change once an object is created, except
when it is updated by the PluginArray object's refresh() method.
The item() method of a
MimeTypeArray object must return null if the argument is not one of the object's
supported property indices, and otherwise must return the result of running the
following steps, using the method's argument as index:
The namedItem() method of a
MimeTypeArray object must return null if the argument is not one of the object's
supported property names, and otherwise must return the MimeType object
that has a type equal to the method's argument.
A Plugin object represents a plugin. It has
several attributes to provide details about the plugin, and can be enumerated to obtain the list
of MIME types that it explicitly
supports.
The Plugin objects created by a user agent must not be
live. The set of MIME types represented by the objects, and the values of the
objects' attributes, must not change once an object is created, except when updated by the
PluginArray object's refresh()
method.
The item() method of a Plugin object must return null if the argument is not one of the
object's supported property indices, and otherwise must return the result of running
the following steps, using the method's argument as index:
The namedItem() method of a Plugin object must return null if the argument is not one of the
object's supported property names, and otherwise must return the
MimeType object that has a type equal to the
method's argument.
The description and filename attributes must return user-agent-defined
(or, in all likelihood, plugin-defined) strings. In each case, the same string must
be returned each time, except that the strings returned may change when the PluginArray.refresh() method updates the object.
If the values returned by the description or filename attributes vary between versions of a
plugin, they can be used both as a fingerprinting vector and, even more importantly,
as a trivial way to determine what security vulnerabilities a plugin (and thus a
browser) may have. It is thus highly recommended that the description attribute just return the same value as the
name attribute, and that the filename attribute return the empty string.
The MimeType objects created by a user agent must not be live. The
values of the objects' attributes must not change once an object is created, except when updated
by the PluginArray object's refresh()
method.
The description and suffixes attributes must return
user-agent-defined (or, in all likelihood, plugin-defined) strings. In each case, the
same string must be returned each time, except that the strings returned may change when the PluginArray.refresh() method updates the object.
If the values returned by the description or suffxies attributes vary between versions of a
plugin, they can be used both as a fingerprinting vector and, even more importantly,
as a trivial way to determine what security vulnerabilities a plugin (and thus a
browser) may have. It is thus highly recommended that the description attribute just return the same value as the
type attribute, and that the suffixes attribute return the empty string.
Commas in the suffixes attribute are
interpreted as separating subsequent filename extensions, as in "htm,html".
The navigator.javaEnabled attribute
must return true if the user agent supports a plugin that supports the MIME
type "application/x-java-vm"; otherwise it must return false.
The AddSearchProvider() method,
when invoked, must run the following steps:
Optionally, abort these steps. User agents may implement the method as a stub method that
never does anything, or may arbitrarily ignore invocations with particular arguments for
security, privacy, or usability reasons.
The IsSearchProviderInstalled()
method, when invoked, must run the following steps:
Optionally, return 0 and abort these steps. User agents may implement the method as a
stub method that never returns a non-zero value, or may arbitrarily ignore invocations with
particular arguments for security, privacy, or usability reasons.
If the origin specified by the entry settings object is an
opaque identifier (i.e. it has no host component), then return 0 and abort these steps.
Let host2 be the host component
of the resulting parsed URL.
If the longest suffix in the Public Suffix List that matches the end of host1 is different than the longest suffix in the Public Suffix List that
matches the end of host2, then return 0 and abort these steps. [PSL]
If the next domain component of host1 and host2
after their common suffix are not the same, then return 0 and abort these steps.
Let search engines be the list of search engines known by the user
agent and made available to the user by the user agent for which the resulting absolute
URL is a prefix match of the search engine's URL, if any. For
search engines registered using OpenSearch description documents, the URL of the
search engine corresponds to the URL given in a Url element whose rel attribute is "results" (the default). [OPENSEARCH]
If search engines is empty, return 0 and abort these steps.
If the user's default search engine (as determined by the user agent) is one of the
search engines in search engines, then return 2 and abort these
steps.
An ImageBitmap object always has associated bitmap data, with a width and a
height. However, it is possible for this data to be corrupted. If an ImageBitmap
object's media data can be decoded without errors, it is said to be fully decodable.
An ImageBitmap object can be obtained from a variety of different objects, using
the createImageBitmap() method. When invoked, the
method must act as follows:
Let the ImageBitmap object's bitmap data be a copy of the img
element's media data, cropped to the source rectangle. If this is an animated
image, the ImageBitmap object's bitmap data must only be taken from the default
image of the animation (the one that the format defines is to be used when animation is not
supported or is disabled), or, if there is no such image, the first frame of the
animation.
Return a new Promise, but continue running these steps
asynchronously.
If either the sw or sh arguments are specified
but zero, throw an IndexSizeError exception and abort these steps.
If the canvas element's bitmap data does not have its origin-clean flag set, then throw an
InvalidStateError exception and abort these steps.
If the canvas element's bitmap has either a horizontal dimension or a
vertical dimension equal to zero, then throw an InvalidStateError exception and
abort these steps.
Apply the image sniffing rules to
determine the file format of the image data, with MIME type of the Blob (as given
by the Blob object's type attribute) giving the
official type.
If the image data is not in a supported file format (e.g. it's not actually an image at
all), or if the image data is corrupted in some fatal way such that the image dimensions cannot
be obtained, then reject the
Promise's associated resolver, with null as
the value, and abort these steps.
Let the ImageBitmap object's bitmap data be the image data read from the
Blob object, cropped to the source rectangle. If this is an animated
image, the ImageBitmap object's bitmap data must only be taken from the default
image of the animation (the one that the format defines is to be used when animation is not
supported or is disabled), or, if there is no such image, the first frame of the
animation.
If either the sw or sh arguments are specified
but zero, throw an IndexSizeError exception and abort these steps.
If the CanvasRenderingContext2D object's scratch bitmap does
not have its origin-clean flag set, then throw
an InvalidStateError exception and abort these steps.
If the CanvasRenderingContext2D object's scratch bitmap has
either a horizontal dimension or a vertical dimension equal to zero, then throw an
InvalidStateError exception and abort these steps.
When the steps above require that the user agent crop bitmap data to the source rectangle, the user agent must run the following
steps:
Let input be the image data being cropped.
If the sx, sy, sw, and sh arguments are omitted, return input.
Place input on an infinite transparent black grid plane, positioned so
that it's top left corner is at the origin of the plane, with the x-coordinate increasing to the right, and the y-coordinate
increasing down, and with each pixel in the input image data occupying a cell
on the plane's grid.
Let output be the rectangle on the plane denoted by the rectangle whose
corners are the four points (sx, sy), (sx+sw, sy), (sx+sw, sy+sh), (sx, sy+sh).
If either sw or sh are negative, then
the top-left corner of this rectangle will be to the left or above the (sx,
sy) point. If any of the pixels on this rectangle are outside the area where
the input bitmap was placed, then they will be transparent black in output.
Return output.
The width attribute must return the
ImageBitmap object's width, in CSS pixels.
The height attribute must return the
ImageBitmap object's height, in CSS pixels.
This section only applies to documents, authoring tools, and markup generators. In
particular, it does not apply to conformance checkers; conformance checkers must use the
requirements given in the next section ("parsing HTML documents").
<!DOCTYPE HTML>
<html lang="en">
<!-- where is this comment in the DOM? -->
<head>
<title>Hello</title>
</head>
<body>
<p>Welcome to this example.</p>
</body>
</html>
タグを除去するとともに、文書は実際に次と同じものを返す：
<!DOCTYPE HTML>
<!-- where is this comment in the DOM? -->
<html lang="en">
<head>
<title>Hello</title>
</head>
<body>
<p>Welcome to this example.</p>
</body>
</html>
An optgroup element's end tag may be omitted
if the optgroup element is
immediately followed by another optgroup element, or if there is no more content in
the parent element.
<p>You can add a string to a number, but this stringifies the number:</p>
<math>
<ms><![CDATA[x<y]]></ms>
<mo>+</mo>
<mn>3</mn>
<mo>=</mo>
<ms><![CDATA[x<y3]]></ms>
</math>
This section only applies to user agents, data mining tools, and conformance
checkers.
The rules for parsing XML documents into DOM trees are covered by the next
section, entitled "The XHTML syntax".
User agents must use the parsing rules described in this section to generate the DOM trees from
text/html resources. Together, these rules define what is referred to as the
HTML parser.
While the HTML syntax described in this specification bears a close resemblance to SGML and
XML, it is a separate language with its own parsing rules.
Some earlier versions of HTML (in particular from HTML2 to HTML4) were based on SGML and used
SGML parsing rules. However, few (if any) web browsers ever implemented true SGML parsing for
HTML documents; the only user agents to strictly handle HTML as an SGML application have
historically been validators. The resulting confusion — with validators claiming documents
to have one representation while widely deployed Web browsers interoperably implemented a
different representation — has wasted decades of productivity. This version of HTML thus
returns to a non-SGML basis.
Authors interested in using SGML tools in their authoring pipeline are encouraged to use XML
tools and the XML serialization of HTML.
This specification defines the parsing rules for HTML documents, whether they are syntactically
correct or not. Certain points in the parsing algorithm are said to be parse errors. The error handling for parse errors is well-defined (that's the
processing rules described throughout this specification), but user agents, while parsing an HTML
document, may abort the parser at the first parse
error that they encounter for which they do not wish to apply the rules described in this
specification.
Conformance checkers must report at least one parse error condition to the user if one or more
parse error conditions exist in the document and must not report parse error conditions if none
exist in the document. Conformance checkers may report more than one parse error condition if more
than one parse error condition exists in the document.
Parse errors are only errors with the syntax of HTML. In addition to
checking for parse errors, conformance checkers will also verify that the document obeys all the
other conformance requirements described in this specification.
For the purposes of conformance checkers, if a resource is determined to be in the HTML
syntax, then it is an HTML document.
As stated in the terminology
section, references to element types that do not
explicitly specify a namespace always refer to elements in the HTML namespace. For
example, if the spec talks about "a menuitem element", then that is an element with
the local name "menuitem", the namespace "http://www.w3.org/1999/xhtml", and the interface HTMLMenuItemElement.
Where possible, references to such elements are hyperlinked to their definition.
Implementations that do not support scripting do not
have to actually create a DOM Document object, but the DOM tree in such cases is
still used as the model for the rest of the specification.
In the common case, the data handled by the tokenization stage comes from the network, but
it can also come from script running in the user
agent, e.g. using the document.write() API.
There is only one set of states for the tokenizer stage and the tree
construction stage, but the tree construction stage is reentrant, meaning that while the tree
construction stage is handling one token, the tokenizer might be resumed, causing further tokens
to be emitted and processed before the first token's processing is complete.
In the following example, the tree construction stage will be called upon to handle a "p"
start tag token while handling the "script" end tag token:
...
<script>
document.write('<p>');
</script>
...
To handle these cases, parsers have a script nesting level, which must be initially
set to zero, and a parser pause flag, which must be initially set to false.
8.2.2 The input byte stream
The stream of Unicode code points that comprises the input to the tokenization stage will be
initially seen by the user agent as a stream of bytes (typically coming over the network or from
the local file system). The bytes encode the actual characters according to a particular
character encoding, which the user agent uses to decode the bytes into characters.
For XML documents, the algorithm user agents are required to use to determine the
character encoding is given by the XML specification. This section does not apply to XML
documents. [XML]
Given a character encoding, the bytes in the input byte stream must be converted
to Unicode code points for the tokenizer's input stream, as described by the rules
for that encoding's decoder.
Bytes or sequences of bytes in the original byte stream that did not conform to
the Encoding standard (e.g. invalid UTF-8 byte sequences in a UTF-8 input byte stream) are errors
that conformance checkers are expected to report. [ENCODING]
Leading Byte Order Marks (BOMs) are not stripped by the decoder algorithms, they
are stripped by the algorithm below.
The decoder algorithms describe how to handle invalid input; for security
reasons, it is imperative that those rules be followed precisely. Differences in how invalid byte
sequences are handled can result in, amongst other problems, script injection vulnerabilities
("XSS").
When the HTML parser is decoding an input byte stream, it uses a character encoding and a confidence. The confidence is either tentative,
certain, or irrelevant. The encoding used, and whether the confidence in that
encoding is tentative or certain, is used
during the parsing to determine whether to change the encoding. If no encoding is
necessary, e.g. because the parser is operating on a Unicode stream and doesn't have to use a
character encoding at all, then the confidence is
irrelevant.
Some algorithms feed the parser by directly adding characters to the input
stream rather than adding bytes to the input byte stream.
8.2.2.1 Parsing with a known character encoding
When the HTML parser is to operate on an input byte stream that has a known definite
encoding, then the character encoding is that encoding and the confidence is certain.
8.2.2.2 Determining the character encoding
In some cases, it might be impractical to unambiguously determine the encoding before parsing
the document. Because of this, this specification provides for a two-pass mechanism with an
optional pre-scan. Implementations are allowed, as described below, to apply a simplified parsing
algorithm to whatever bytes they have available before beginning to parse the document. Then, the
real parser is started, using a tentative encoding derived from this pre-parse and other
out-of-band metadata. If, while the document is being loaded, the user agent discovers a character
encoding declaration that conflicts with this information, then the parser can get reinvoked to
perform a parse of the document with the real encoding.
User agents must use the following algorithm, called the encoding
sniffing algorithm, to determine the character encoding to use when decoding a document in
the first pass. This algorithm takes as input any out-of-band metadata available to the user agent
(e.g. the Content-Type metadata of the document) and all the
bytes available so far, and returns a character encoding and a confidence that is either tentative or
certain.
If the user has explicitly instructed the user agent to override the document's character
encoding with a specific encoding, optionally return that encoding with the confidencecertain and abort these steps.
Typically, user agents remember such user requests across sessions, and in some
cases apply them to documents in iframes as well.
The user agent may wait for more bytes of the resource to be available, either in this step
or at any later step in this algorithm. For instance, a user agent might wait 500ms or 1024
bytes, whichever came first. In general preparsing the source to find the encoding improves
performance, as it reduces the need to throw away the data structures used when parsing upon
finding the encoding information. However, if the user agent delays too long to obtain data to
determine the encoding, then the cost of the delay could outweigh any performance improvements
from the preparse.
The authoring conformance requirements for character encoding declarations limit
them to only appearing in the first 1024 bytes. User agents are
therefore encouraged to use the prescan algorithm below (as invoked by these steps) on the first
1024 bytes, but not to stall beyond that.
For each of the rows in the following table, starting with the first one and going down, if
there are as many or more bytes available than the number of bytes in the first column, and the
first bytes of the file match the bytes given in the first column, then return the encoding
given in the cell in the second column of that row, with the confidencecertain, and abort these steps:
Bytes in Hexadecimal
Encoding
FE FF
Big-endian UTF-16
FF FE
Little-endian UTF-16
EF BB BF
UTF-8
This step looks for Unicode Byte Order Marks (BOMs).
That this step happens before the next one honoring the HTTP
Content-Type header is a willful violation of the HTTP specification,
motivated by a desire to be maximally compatible with legacy content. [HTTP]
If the transport layer specifies a character encoding, and it is supported, return that
encoding with the confidencecertain, and
abort these steps.
Optionally prescan the byte
stream to determine its encoding. The end condition is that the user
agent decides that scanning further bytes would not be efficient. User agents are encouraged to
only prescan the first 1024 bytes. User agents may decide that scanning any bytes is
not efficient, in which case these substeps are entirely skipped.
The aforementioned algorithm either aborts unsuccessfully or returns a character encoding. If
it returns a character encoding, then this algorithm must be aborted, returning the same
encoding, with confidencetentative.
Otherwise, if the user agent has information on the likely encoding for this page, e.g.
based on the encoding of the page when it was last visited, then return that encoding, with the
confidencetentative, and abort these
steps.
The user agent may attempt to autodetect the character encoding from applying frequency
analysis or other algorithms to the data stream. Such algorithms may use information about the
resource other than the resource's contents, including the address of the resource. If
autodetection succeeds in determining a character encoding, and that encoding is a supported
encoding, then return that encoding, with the confidencetentative, and abort these steps.
[UNIVCHARDET]
The UTF-8 encoding has a highly detectable bit pattern. Documents that contain
bytes with values greater than 0x7F which match the UTF-8 pattern are very likely to be UTF-8,
while documents with byte sequences that do not match it are very likely not. User-agents are
therefore encouraged to search for this common encoding. [PPUTF8][UTF8DET]
Otherwise, return an implementation-defined or user-specified default character encoding,
with the confidencetentative.
In controlled environments or in environments where the encoding of documents can be
prescribed (for example, for user agents intended for dedicated use in new networks), the
comprehensive UTF-8 encoding is suggested.
In other environments, the default encoding is typically dependent on the user's locale (an
approximation of the languages, and thus often encodings, of the pages that the user is likely
to frequent). The following table gives suggested defaults based on the user's locale, for
compatibility with legacy content. Locales are identified by BCP 47 language tags. [BCP47][ENCODING]
Locale language
Suggested default encoding
ar
Arabic
windows-1256
ba
Bashkir
windows-1251
be
Belarusian
windows-1251
bg
Bulgarian
windows-1251
cs
Czech
windows-1250
el
Greek
ISO-8859-7
et
Estonian
windows-1257
fa
Persian
windows-1256
he
Hebrew
windows-1255
hr
Croatian
windows-1250
hu
Hungarian
ISO-8859-2
ja
Japanese
Shift_JIS
kk
Kazakh
windows-1251
ko
Korean
euc-kr
ku
Kurdish
windows-1254
ky
Kyrgyz
windows-1251
lt
Lithuanian
windows-1257
lv
Latvian
windows-1257
mk
Macedonian
windows-1251
pl
Polish
ISO-8859-2
ru
Russian
windows-1251
sah
Yakut
windows-1251
sk
Slovak
windows-1250
sl
Slovenian
ISO-8859-2
sr
Serbian
windows-1251
tg
Tajik
windows-1251
th
Thai
windows-874
tr
Turkish
windows-1254
tt
Tatar
windows-1251
uk
Ukrainian
windows-1251
vi
Vietnamese
windows-1258
zh-CN
Chinese (People's Republic of China)
GB18030
zh-TW
Chinese (Taiwan)
Big5
All other locales
windows-1252
The contents of this table are derived from the intersection of
Windows, Chrome, and Firefox defaults.
The document's character encoding must immediately be set to the value returned
from this algorithm, at the same time as the user agent uses the returned value to select the
decoder to use for the input byte stream.
When an algorithm requires a user agent to prescan a byte stream to determine its
encoding, given some defined end condition, then it must run the
following steps. These steps either abort unsuccessfully or return a character encoding. If at any
point during these steps (including during instances of the get an attribute algorithm invoked by this
one) the user agent either runs out of bytes (meaning the position pointer
created in the first step below goes beyond the end of the byte stream obtained so far) or reaches
its end condition, then abort the prescan a byte stream to determine its
encoding algorithm unsuccessfully.
Let position be a pointer to a byte in the input byte stream, initially
pointing at the first byte.
Loop: If position points to:
A sequence of bytes starting with: 0x3C 0x21 0x2D 0x2D (ASCII '<!--')
Advance the position pointer so that it points at the first 0x3E byte
which is preceded by two 0x2D bytes (i.e. at the end of an ASCII '-->' sequence) and comes
after the 0x3C byte that was found. (The two 0x2D bytes can be the same as the those in the
'<!--' sequence.)
A sequence of bytes starting with: 0x3C, 0x4D or 0x6D, 0x45 or 0x65, 0x54 or 0x74, 0x41 or 0x61, and one of 0x09, 0x0A, 0x0C, 0x0D, 0x20, 0x2F (case-insensitive ASCII '<meta' followed by a space or slash)
Advance the position pointer so that it points at the next 0x09,
0x0A, 0x0C, 0x0D, 0x20, or 0x2F byte (the one in sequence of characters matched
above).
Let attribute list be an empty list of strings.
Let got pragma be false.
Let need pragma be null.
Let charset be the null value (which, for the purposes of this
algorithm, is distinct from an unrecognised encoding or the empty string).
Attributes: Get an
attribute and its value. If no attribute was sniffed, then jump to the
processing step below.
If the attribute's name is already in attribute list, then return
to the step labeled attributes.
Add the attribute's name to attribute list.
Run the appropriate step from the following list, if one applies:
If the attribute's name is "http-equiv"
If the attribute's value is "content-type", then set got pragma to true.
If the attribute's name is "content"
Apply the algorithm for extracting a character encoding from a
meta element, giving the attribute's value as the string to parse. If a
character encoding is returned, and if charset is still set to null,
let charset be the encoding returned, and set need
pragma to true.
If the attribute's name is "charset"
Let charset be the result of getting an encoding
from the attribute's value, and set need pragma to false.
Return to the step labeled attributes.
Processing: If need pragma is null, then jump to the step
below labeled next byte.
If need pragma is true but got pragma is
false, then jump to the step below labeled next byte.
If charset is a UTF-16 encoding, change the value of
charset to UTF-8.
If charset is the x-user-defined encoding, change the value of
charset to Windows-1252. [ENCODING]
If charset is not a supported character encoding, then jump to the
step below labeled next byte.
A sequence of bytes starting with a 0x3C byte (ASCII <), optionally a 0x2F byte (ASCII /), and finally a byte in the range 0x41-0x5A or 0x61-0x7A (an ASCII letter)
Advance the position pointer so that it points at the next 0x09
(ASCII TAB), 0x0A (ASCII LF), 0x0C (ASCII FF), 0x0D (ASCII CR), 0x20 (ASCII space), or 0x3E
(ASCII >) byte.
Repeatedly get an attribute
until no further attributes can be found, then jump to the step below labeled next
byte.
A sequence of bytes starting with: 0x3C 0x21 (ASCII '<!')
A sequence of bytes starting with: 0x3C 0x2F (ASCII '</')
A sequence of bytes starting with: 0x3C 0x3F (ASCII '
Advance the position pointer so that it points at the first 0x3E byte
(ASCII >) that comes after the 0x3C byte that was found.
Any other byte
Do nothing with that byte.
Next byte: Move position so it points at the next byte in the
input byte stream, and return to the step above labeled loop.
If the byte at position is one of 0x09 (ASCII TAB), 0x0A (ASCII LF),
0x0C (ASCII FF), 0x0D (ASCII CR), 0x20 (ASCII space), or 0x2F (ASCII /) then advance position to the next byte and redo this step.
If the byte at position is 0x3E (ASCII >), then abort the get an attribute algorithm. There isn't
one.
Otherwise, the byte at position is the start of the attribute name.
Let attribute name and attribute value be the empty
string.
Process the byte at position as follows:
If it is 0x3D (ASCII =), and the attribute name is longer than the
empty string
Advance position to the next byte and jump to the step below labeled
value.
If it is 0x09 (ASCII TAB), 0x0A (ASCII LF), 0x0C (ASCII FF), 0x0D (ASCII CR), or 0x20
(ASCII space)
Jump to the step below labeled spaces.
If it is 0x2F (ASCII /) or 0x3E (ASCII >)
Abort the get an attribute
algorithm. The attribute's name is the value of attribute name, its value
is the empty string.
If it is in the range 0x41 (ASCII A) to 0x5A (ASCII Z)
Append the Unicode character with code point b+0x20 to attribute name (where b
is the value of the byte at position). (This converts the input to
lowercase.)
Anything else
Append the Unicode character with the same code point as the value of the byte at position to attribute name. (It doesn't actually matter how
bytes outside the ASCII range are handled here, since only ASCII characters can contribute to
the detection of a character encoding.)
Advance position to the next byte and return to the previous
step.
Spaces: If the byte at position is one of 0x09 (ASCII TAB),
0x0A (ASCII LF), 0x0C (ASCII FF), 0x0D (ASCII CR), or 0x20 (ASCII space) then advance position to the next byte, then, repeat this step.
If the byte at position is not 0x3D (ASCII =), abort the
get an attribute algorithm. The
attribute's name is the value of attribute name, its value is the empty
string.
Advance position past the 0x3D (ASCII =) byte.
Value: If the byte at position is one of 0x09 (ASCII TAB), 0x0A
(ASCII LF), 0x0C (ASCII FF), 0x0D (ASCII CR), or 0x20 (ASCII space) then advance position to the next byte, then, repeat this step.
Process the byte at position as follows:
If it is 0x22 (ASCII ") or 0x27 (ASCII ')
Let b be the value of the byte at position.
Quote loop: Advance position to the next byte.
If the value of the byte at position is the value of b, then advance position to the next byte and abort the
"get an attribute" algorithm. The attribute's name is the value of attribute
name, and its value is the value of attribute value.
Otherwise, if the value of the byte at position is in the range 0x41
(ASCII A) to 0x5A (ASCII Z), then append a Unicode character to attribute
value whose code point is 0x20 more than the value of the byte at position.
Otherwise, append a Unicode character to attribute value whose code
point is the same as the value of the byte at position.
Return to the step above labeled quote loop.
If it is 0x3E (ASCII >)
Abort the get an attribute
algorithm. The attribute's name is the value of attribute name, its value
is the empty string.
If it is in the range 0x41 (ASCII A) to 0x5A (ASCII Z)
Append the Unicode character with code point b+0x20 to attribute value (where b is the value of the byte at position). Advance position to the next byte.
Anything else
Append the Unicode character with the same code point as the value of the byte at position to attribute value. Advance position to the next byte.
Process the byte at position as
follows:
If it is 0x09 (ASCII TAB), 0x0A (ASCII LF), 0x0C (ASCII FF), 0x0D (ASCII CR), 0x20 (ASCII
space), or 0x3E (ASCII >)
Abort the get an attribute
algorithm. The attribute's name is the value of attribute name and its
value is the value of attribute value.
If it is in the range 0x41 (ASCII A) to 0x5A (ASCII Z)
Append the Unicode character with code point b+0x20 to attribute value (where b is the value of the byte at position).
Anything else
Append the Unicode character with the same code point as the value of the byte at position to attribute value.
Advance position to the next byte and return to the previous
step.
For the sake of interoperability, user agents should not use a pre-scan algorithm that returns
different results than the one described above. (But, if you do, please at least let us know, so
that we can improve this algorithm and benefit everyone...)
8.2.2.3 Character encodings
User agents must support the encodings defined in the Encoding standard
[ENCODING]. User agents should not support other encodings.
Support for encodings based on EBCDIC is especially discouraged. This encoding is rarely used
for publicly-facing Web content. Support for UTF-32 is also especially discouraged. 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.
8.2.2.4 Changing the encoding while parsing
When the parser requires the user agent to change the encoding, it must run the
following steps. This might happen if the encoding sniffing algorithm described above
failed to find a character encoding, or if it found a character encoding that was not the actual
encoding of the file.
If the encoding that is already being used to interpret the input stream is a UTF-16
encoding, then set the confidence to
certain and abort these steps. The new encoding is ignored; if it was anything but the
same encoding, then it would be clearly incorrect.
If the new encoding is the x-user-defined encoding, change it to Windows-1252. [ENCODING]
If the new encoding is identical or equivalent to the encoding that is already being used
to interpret the input stream, then set the confidence to certain and abort these steps.
This happens when the encoding information found in the file matches what the encoding
sniffing algorithm determined to be the encoding, and in the second pass through the
parser if the first pass found that the encoding sniffing algorithm described in the earlier
section failed to find the right encoding.
If all the bytes up to the last byte converted by the current decoder have the same
Unicode interpretations in both the current encoding and the new encoding, and if the user agent
supports changing the converter on the fly, then the user agent may change to the new converter
for the encoding on the fly. Set the document's character encoding and the encoding
used to convert the input stream to the new encoding, set the confidence to certain, and abort these
steps.
Otherwise, navigate to the document again, with
replacement enabled, and using the same source browsing context, but
this time skip the encoding sniffing algorithm and instead just set the encoding to
the new encoding and the confidence to
certain. Whenever possible, this should be done without actually contacting the network
layer (the bytes should be re-parsed from memory), even if, e.g., the document is marked as not
being cacheable. If this is not possible and contacting the network layer would involve repeating
a request that uses a method other than HTTP GET (or
equivalent for non-HTTP URLs), then instead set the confidence to certain and ignore the new
encoding. The resource will be misinterpreted. User agents may notify the user of the situation,
to aid in application development.
This algorithm is only invoked when a new encoding is found declared on a
meta element.
8.2.2.5 Preprocessing the input stream
The input stream consists of the characters pushed into it as the input byte
stream is decoded or from the various APIs that directly manipulate the input stream.
One leading U+FEFF BYTE ORDER MARK character must be ignored if any are present in the
input stream.
The requirement to strip a U+FEFF BYTE ORDER MARK character regardless of whether
that character was used to determine the byte order is a willful violation of
Unicode, motivated by a desire to increase the resilience of user agents in the face of naïve
transcoders.
Any occurrences of any characters in the ranges U+0001 to U+0008, U+000E to U+001F,
U+007F to U+009F, U+FDD0 to U+FDEF, and
characters U+000B, U+FFFE, U+FFFF, U+1FFFE, U+1FFFF, U+2FFFE, U+2FFFF, U+3FFFE, U+3FFFF, U+4FFFE,
U+4FFFF, U+5FFFE, U+5FFFF, U+6FFFE, U+6FFFF, U+7FFFE, U+7FFFF, U+8FFFE, U+8FFFF, U+9FFFE, U+9FFFF,
U+AFFFE, U+AFFFF, U+BFFFE, U+BFFFF, U+CFFFE, U+CFFFF, U+DFFFE, U+DFFFF, U+EFFFE, U+EFFFF, U+FFFFE,
U+FFFFF, U+10FFFE, and U+10FFFF are parse errors. These are all
control characters or permanently undefined Unicode characters (noncharacters).
"CR" (U+000D) characters and "LF" (U+000A) characters are treated
specially. All CR characters must be converted to LF characters, and any LF characters that
immediately follow a CR character must be ignored. Thus, newlines in HTML DOMs are represented by
LF characters, and there are never any CR characters in the input to the tokenization
stage.
The next input character is the first character in the input stream
that has not yet been consumed or explicitly ignored by the requirements in this
section. Initially, the next input character is the first character in the input. The
current input character is the last character to have been consumed.
The insertion point is the position (just before a character or just before the end
of the input stream) where content inserted using document.write() is actually inserted. The insertion point is
relative to the position of the character immediately after it, it is not an absolute offset into
the input stream. Initially, the insertion point is undefined.
The "EOF" character in the tables below is a conceptual character representing the end of the
input stream. If the parser is a script-created parser, then the end of
the input stream is reached when an explicit "EOF" character (inserted by
the document.close() method) is consumed. Otherwise, the
"EOF" character is not a real character in the stream, but rather the lack of any further
characters.
The handling of U+0000 NULL characters varies based on where the characters are
found. In general, they are ignored except where doing so could plausibly introduce an attack
vector. This handling is, by necessity, spread across both the tokenization stage and the tree
construction stage.
8.2.3 Parse state
8.2.3.1 The insertion mode
The insertion mode is a state variable that controls the primary operation of the
tree construction stage.
Several of these modes, namely "in head", "in body", "in
table", and "in select", are special, in
that the other modes defer to them at various times. When the algorithm below says that the user
agent is to do something "using the rules for the m insertion
mode", where m is one of these modes, the user agent must use the rules
described under the minsertion mode's section, but must leave
the insertion mode unchanged unless the rules in m themselves
switch the insertion mode to a new value.
When the insertion mode is switched to "text" or
"in table text", the original insertion
mode is also set. This is the insertion mode to which the tree construction stage will
return.
Similarly, to parse nested template elements, a stack of template insertion
modes is used. It is initially empty. The current template insertion mode is the
insertion mode that was most recently added to the stack of template insertion modes.
The algorithms in the sections below will push insertion modes onto this stack, meaning
that the specified insertion mode is to be added to the stack, and pop insertion modes from
the stack, which means that the most recently added insertion mode must be removed from the
stack.
When the steps below require the UA to reset the insertion mode appropriately, it
means the UA must follow these steps:
Loop: If node is the first node in the stack of open elements,
then set last to true, and, if the parser was originally created as part of
the HTML fragment parsing algorithm (fragment case), set node to the context
element.
Initially, the stack of open elements is empty. The stack grows downwards; the
topmost node on the stack is the first one added to the stack, and the bottommost node of the
stack is the most recently added node in the stack (notwithstanding when the stack is manipulated
in a random access fashion as part of the handling for misnested
tags).
All other elements found while parsing an HTML document.
The stack of open elements is said to have an element target node in a specific scope consisting of a
list of element types list when the following algorithm terminates in a match
state:
Initialise node to be the current node (the bottommost
node of the stack).
If node is the target node, terminate in a match state.
Otherwise, if node is one of the element types in list, terminate in a failure state.
Otherwise, set node to the previous entry in the stack of open
elements and return to step 2. (This will never fail, since the loop will always terminate
in the previous step if the top of the stack — an html element — is
reached.)
Nothing happens if at any time any of the elements in the stack of open elements
are moved to a new location in, or removed from, the Document tree. In particular,
the stack is not changed in this situation. This can cause, amongst other strange effects, content
to be appended to nodes that are no longer in the DOM.
Initially, the list of active formatting elements is empty. It is used to handle
mis-nested formatting element tags.
The list contains elements in the formatting category, and markers. The
markers are inserted when entering applet elements, buttons,
object elements, marquees, table cells, and table captions, and are used to prevent
formatting from "leaking" intoapplet elements, buttons, object
elements, marquees, and tables.
In addition, each element in the list of active formatting elements is associated
with the token for which it was created, so that further elements can be created for that token if
necessary.
When the steps below require the UA to push onto the list of active formatting
elements an element element, the UA must perform the following
steps:
If there are already three elements in the list of active formatting elements
after the last marker, if any, or anywhere in the list if there are no markers, that
have the same tag name, namespace, and attributes as element, then remove the
earliest such element from the list of active formatting elements. For these
purposes, the attributes must be compared as they were when the elements were created by the
parser; two elements have the same attributes if all their parsed attributes can be paired such
that the two attributes in each pair have identical names, namespaces, and values (the order of
the attributes does not matter).
This is the Noah's Ark clause. But with three per family instead of two.
Create: Insert an HTML element for the token for which the element
entry was created, to obtain new element.
Replace the entry for entry in the list with an entry for new element.
If the entry for new element in the list of active formatting
elements is not the last entry in the list, return to the step labeled
advance.
This has the effect of reopening all the formatting elements that were opened in the current
body, cell, or caption (whichever is youngest) that haven't been explicitly closed.
The way this specification is written, the list of active formatting
elements always consists of elements in chronological order with the least recently added
element first and the most recently added element last (except for while steps 8 to 11 of the
above algorithm are being executed, of course).
When the steps below require the UA to clear the list of active formatting elements up to
the last marker, the UA must perform the following steps:
If entry was a marker, then stop the algorithm at this point. The list
has been cleared up to the last marker.
Go to step 1.
8.2.3.4 The element pointers
Initially, the head element pointer and the form element pointer are both null.
Once a head element has been parsed (whether implicitly or explicitly) the
head element pointer gets set to point to this node.
The form element pointer points to the last
form element that was opened and whose end tag has not yet been seen. It is used to
make form controls associate with forms in the face of dramatically bad markup, for historical
reasons. It is ignored inside template elements.
8.2.3.5 Other parsing state flags
The scripting flag is set to "enabled" if scripting
was enabled for the Document with which the parser is associated when the
parser was created, and "disabled" otherwise.
The frameset-ok flag is set to "ok" when the parser is created. It is set to "not
ok" after certain tokens are seen.
8.2.4 Tokenization
Implementations must act as if they used the following state machine to tokenise HTML. The
state machine must start in the data state. Most states consume a single character,
which may have various side-effects, and either switches the state machine to a new state to
reconsume the same character, or switches it to a new state to consume the next character,
or stays in the same state to consume the next character. Some states have more complicated
behavior and can consume several characters before switching to another state. In some cases, the
tokenizer state is also changed by the tree construction stage.
The exact behavior of certain states depends on the insertion mode and the
stack of open elements. Certain states also use a temporary
buffer to track progress.
The output of the tokenization step is a series of zero or more of the following tokens:
DOCTYPE, start tag, end tag, comment, character, end-of-file. DOCTYPE tokens have a name, a public
identifier, a system identifier, and a force-quirks flag. When a DOCTYPE token is created,
its name, public identifier, and system identifier must be marked as missing (which is a distinct
state from the empty string), and the force-quirks flag must be set to off (its
other state is on). Start and end tag tokens have a tag name, a self-closing flag,
and a list of attributes, each of which has a name and a value. When a start or end tag token is
created, its self-closing flag must be unset (its other state is that it be set), and its
attributes list must be empty. Comment and character tokens have data.
When a token is emitted, it must immediately be handled by the tree construction
stage. The tree construction stage can affect the state of the tokenization stage, and can insert
additional characters into the stream. (For example, the script element can result in
scripts executing and using the dynamic markup insertion APIs to insert characters
into the stream being tokenized.)
Creating a token and emitting it are distinct actions. It is possible for a token
to be created but implicitly abandoned (never emitted), e.g. if the file ends unexpectedly while
processing the characters that are being parsed into a start tag token.
When a start tag token is emitted with its self-closing flag set, if the flag is not
acknowledged when it is processed by the tree
construction stage, that is a parse error.
When an end tag token is emitted with attributes, that is a parse error.
When an end tag token is emitted with its self-closing flag set, that is a parse
error.
An appropriate end tag token is an end tag token whose tag name matches the tag name
of the last start tag to have been emitted from this tokenizer, if any. If no start tag has been
emitted from this tokenizer, then no end tag token is appropriate.
Before each step of the tokenizer, the user agent must first check the parser pause
flag. If it is true, then the tokenizer must abort the processing of any nested invocations
of the tokenizer, yielding control back to the caller.
The tokenizer state machine consists of the states defined in the following subsections.
Create a new start tag token, set its tag name to the lowercase version of the current
input character (add 0x0020 to the character's code point), then switch to the tag
name state. (Don't emit the token yet; further details will be filled in before it is
emitted.)
Create a new start tag token, set its tag name to the current input character,
then switch to the tag name state. (Don't emit the token yet; further details will
be filled in before it is emitted.)
Create a new end tag token, set its tag name to the lowercase version of the current
input character (add 0x0020 to the character's code point), then switch to the tag
name state. (Don't emit the token yet; further details will be filled in before it is
emitted.)
Create a new end tag token, set its tag name to the current input character,
then switch to the tag name state. (Don't emit the token yet; further details will
be filled in before it is emitted.)
If the current end tag token is an appropriate end tag token, then switch to the
data state and emit the current tag token. Otherwise, treat it as per the "anything
else" entry below.
Switch to the RCDATA state. Emit a U+003C LESS-THAN SIGN character token, a
U+002F SOLIDUS character token, and a character token for each of the characters in the
temporary buffer (in the order they were added to the buffer). Reconsume the
current input character.
If the current end tag token is an appropriate end tag token, then switch to the
data state and emit the current tag token. Otherwise, treat it as per the "anything
else" entry below.
Switch to the RAWTEXT state. Emit a U+003C LESS-THAN SIGN character token, a
U+002F SOLIDUS character token, and a character token for each of the characters in the
temporary buffer (in the order they were added to the buffer). Reconsume the
current input character.
If the current end tag token is an appropriate end tag token, then switch to the
data state and emit the current tag token. Otherwise, treat it as per the "anything
else" entry below.
Switch to the script data state. Emit a U+003C LESS-THAN SIGN character token, a
U+002F SOLIDUS character token, and a character token for each of the characters in the
temporary buffer (in the order they were added to the buffer). Reconsume the
current input character.
If the current end tag token is an appropriate end tag token, then switch to the
data state and emit the current tag token. Otherwise, treat it as per the "anything
else" entry below.
Switch to the script data escaped state. Emit a U+003C LESS-THAN SIGN character
token, a U+002F SOLIDUS character token, and a character token for each of the characters in the
temporary buffer (in the order they were added to the buffer). Reconsume the
current input character.
Start a new attribute in the current tag token. Set that attribute's name to the lowercase
version of the current input character (add 0x0020 to the character's code point),
and its value to the empty string. Switch to the attribute name state.
U+0000 NULL
Parse error. Start a new attribute in the current tag token. Set that
attribute's name to a U+FFFD REPLACEMENT CHARACTER character, and its value to the empty string.
Switch to the attribute name state.
U+0022 QUOTATION MARK (")
"'" (U+0027)
"<" (U+003C)
"=" (U+003D)
Parse error. Treat it as per the "anything else" entry below.
Start a new attribute in the current tag token. Set that attribute's name to the
current input character, and its value to the empty string. Switch to the
attribute name state.
When the user agent leaves the attribute name state (and before emitting the tag token, if
appropriate), the complete attribute's name must be compared to the other attributes on the same
token; if there is already an attribute on the token with the exact same name, then this is a
parse error and the new attribute must be removed from the token.
If an attribute is so removed from a token, it, and the value that gets associated
with it, if any, are never subsequently used by the parser, and are therefore effectively
discarded. Removing the attribute in this way does not change its status as the "current
attribute" for the purposes of the tokenizer, however.
Start a new attribute in the current tag token. Set that attribute's name to the lowercase
version of the current input character (add 0x0020 to the character's code point),
and its value to the empty string. Switch to the attribute name state.
U+0000 NULL
Parse error. Start a new attribute in the current tag token. Set that
attribute's name to a U+FFFD REPLACEMENT CHARACTER character, and its value to the empty string.
Switch to the attribute name state.
U+0022 QUOTATION MARK (")
"'" (U+0027)
"<" (U+003C)
Parse error. Treat it as per the "anything else" entry below.
Start a new attribute in the current tag token. Set that attribute's name to the
current input character, and its value to the empty string. Switch to the
attribute name state.
Consume every character up to and including the first ">" (U+003E) character
or the end of the file (EOF), whichever comes first. Emit a comment token whose data is the
concatenation of all the characters starting from and including the character that caused the
state machine to switch into the bogus comment state, up to and including the character
immediately before the last consumed character (i.e. up to the character just before the U+003E or
EOF character), but with any U+0000 NULL characters replaced by U+FFFD REPLACEMENT CHARACTER
characters. (If the comment was started by the end of the file (EOF), the token is empty.
Similarly, the token is empty if it was generated by the string "<!>".)
If the end of the file was reached, reconsume the EOF character.
8.2.4.45 Markup declaration open state
If the next two characters are both "-" (U+002D) characters, consume those two
characters, create a comment token whose data is the empty string, and switch to the comment
start state.
Otherwise, if the next seven characters are an ASCII case-insensitive match for
the word "DOCTYPE", then consume those characters and switch to the DOCTYPE
state.
Otherwise, if there is an adjusted current node and it is not an element in the
HTML namespace and the next seven characters are a case-sensitive match
for the string "[CDATA[" (the five uppercase letters "CDATA" with a U+005B LEFT SQUARE BRACKET
character before and after), then consume those characters and switch to the CDATA section
state.
Otherwise, this is a parse error. Switch to the bogus comment state.
The next character that is consumed, if any, is the first character that will be in the
comment.
Parse error. Append two "-" (U+002D) characters, a "!" (U+0021) character, and a U+FFFD REPLACEMENT CHARACTER character to the comment token's data.
Switch to the comment state.
EOF
Parse error. Switch to the data state. Emit the comment token.
Reconsume the EOF character.
Anything else
Append two "-" (U+002D) characters, a "!" (U+0021) character, and
the current input character to the comment token's data. Switch to the comment
state.
Create a new DOCTYPE token. Set the token's name to the lowercase version of the
current input character (add 0x0020 to the character's code point). Switch to the
DOCTYPE name state.
U+0000 NULL
Parse error. Create a new DOCTYPE token. Set the token's name to a U+FFFD
REPLACEMENT CHARACTER character. Switch to the DOCTYPE name state.
">" (U+003E)
Parse error. Create a new DOCTYPE token. Set its force-quirks flag to
on. Switch to the data state. Emit the token.
EOF
Parse error. Switch to the data state. Create a new DOCTYPE token.
Set its force-quirks flag to on. Emit the token. Reconsume the EOF character.
Consume every character up to the next occurrence of the three character sequence U+005D RIGHT
SQUARE BRACKET U+005D RIGHT SQUARE BRACKET U+003E GREATER-THAN SIGN (]]>),
or the end of the file (EOF), whichever comes first. Emit a series of character tokens consisting
of all the characters consumed except the matching three character sequence at the end (if one was
found before the end of the file)
If the end of the file was reached, reconsume the EOF character.
8.2.4.69 Tokenizing character references
This section defines how to consume a character reference, optionally with an
additional allowed character, which, if specified where the algorithm is invoked, adds
a character to the list of characters that cause there to not be a character reference.
This definition is used when parsing character references in text and in
attributes.
The behavior depends on the identity of the next character (the one immediately after the
U+0026 AMPERSAND character), as follows:
If no characters match the range, then don't consume any characters (and unconsume the U+0023
NUMBER SIGN character and, if appropriate, the X character). This is a parse error;
nothing is returned.
Otherwise, if the next character is a U+003B SEMICOLON, consume that too. If it isn't, there
is a parse error.
If one or more characters match the range, then take them all and interpret the string of
characters as a number (either hexadecimal or decimal as appropriate).
If that number is one of the numbers in the first column of the following table, then this is
a parse error. Find the row with that number in the first column, and return a
character token for the Unicode character given in the second column of that row.
Number
Unicode character
0x00
U+FFFD
REPLACEMENT CHARACTER
0x80
U+20AC
EURO SIGN (€)
0x82
U+201A
SINGLE LOW-9 QUOTATION MARK (‚)
0x83
U+0192
LATIN SMALL LETTER F WITH HOOK (ƒ)
0x84
U+201E
DOUBLE LOW-9 QUOTATION MARK („)
0x85
U+2026
HORIZONTAL ELLIPSIS (…)
0x86
U+2020
DAGGER (†)
0x87
U+2021
DOUBLE DAGGER (‡)
0x88
U+02C6
MODIFIER LETTER CIRCUMFLEX ACCENT (ˆ)
0x89
U+2030
PER MILLE SIGN (‰)
0x8A
U+0160
LATIN CAPITAL LETTER S WITH CARON (Š)
0x8B
U+2039
SINGLE LEFT-POINTING ANGLE QUOTATION MARK (‹)
0x8C
U+0152
LATIN CAPITAL LIGATURE OE (Œ)
0x8E
U+017D
LATIN CAPITAL LETTER Z WITH CARON (Ž)
0x91
U+2018
LEFT SINGLE QUOTATION MARK (‘)
0x92
U+2019
RIGHT SINGLE QUOTATION MARK (’)
0x93
U+201C
LEFT DOUBLE QUOTATION MARK (“)
0x94
U+201D
RIGHT DOUBLE QUOTATION MARK (”)
0x95
U+2022
BULLET (•)
0x96
U+2013
EN DASH (–)
0x97
U+2014
EM DASH (—)
0x98
U+02DC
SMALL TILDE (˜)
0x99
U+2122
TRADE MARK SIGN (™)
0x9A
U+0161
LATIN SMALL LETTER S WITH CARON (š)
0x9B
U+203A
SINGLE RIGHT-POINTING ANGLE QUOTATION MARK (›)
0x9C
U+0153
LATIN SMALL LIGATURE OE (œ)
0x9E
U+017E
LATIN SMALL LETTER Z WITH CARON (ž)
0x9F
U+0178
LATIN CAPITAL LETTER Y WITH DIAERESIS (Ÿ)
Otherwise, if the number is in the range 0xD800 to 0xDFFF or is greater
than 0x10FFFF, then this is a parse error. Return a U+FFFD REPLACEMENT CHARACTER
character token.
Otherwise, return a character token for the Unicode character whose code point is that
number.
Additionally, if the number is in the range 0x0001 to 0x0008, 0x000D to 0x001F, 0x007F to 0x009F, 0xFDD0 to 0xFDEF, or is
one of 0x000B, 0xFFFE, 0xFFFF, 0x1FFFE, 0x1FFFF, 0x2FFFE, 0x2FFFF, 0x3FFFE, 0x3FFFF, 0x4FFFE,
0x4FFFF, 0x5FFFE, 0x5FFFF, 0x6FFFE, 0x6FFFF, 0x7FFFE, 0x7FFFF, 0x8FFFE, 0x8FFFF, 0x9FFFE,
0x9FFFF, 0xAFFFE, 0xAFFFF, 0xBFFFE, 0xBFFFF, 0xCFFFE, 0xCFFFF, 0xDFFFE, 0xDFFFF, 0xEFFFE,
0xEFFFF, 0xFFFFE, 0xFFFFF, 0x10FFFE, or 0x10FFFF, then this is a parse error.
Anything else
Consume the maximum number of characters possible, with the consumed characters matching one
of the identifiers in the first column of the named character references table (in
a case-sensitive manner).
If no match can be made, then no characters are consumed, and nothing is returned. In this
case, if the characters after the U+0026 AMPERSAND character (&) consist of a sequence of
one or more alphanumeric ASCII characters followed by a U+003B SEMICOLON character
(;), then this is a parse error.
If the character reference is being consumed as part of an attribute, and the last character matched is not a ";" (U+003B) character, and the next character is either a "=" (U+003D) character or
an alphanumeric ASCII character, then, for
historical reasons, all the characters that were matched after the U+0026 AMPERSAND character
(&) must be unconsumed, and nothing is returned.
However, if this next character is in fact a "=" (U+003D) character, then this is a
parse error, because some legacy user agents will
misinterpret the markup in those cases.
Otherwise, a character reference is parsed. If the last character matched is not a ";" (U+003B) character, there is a parse error.
Return one or two character tokens for the character(s) corresponding to the character
reference name (as given by the second column of the named character references
table).
If the markup contains (not in an attribute) the string I'm ¬it; I
tell you, the character reference is parsed as "not", as in, I'm ¬it;
I tell you (and this is a parse error). But if the markup was I'm
∉ I tell you, the character reference would be parsed as "notin;", resulting
in I'm ∉ I tell you (and no parse error).
8.2.5 Tree construction
The input to the tree construction stage is a sequence of tokens from the
tokenization stage. The tree construction stage is associated with a DOM
Document object when a parser is created. The "output" of this stage consists of
dynamically modifying or extending that document's DOM tree.
This specification does not define when an interactive user agent has to render the
Document so that it is available to the user, or when it has to begin accepting user
input.
As each token is emitted from the tokenizer, the user agent must follow the appropriate steps
from the following list, known as the tree construction dispatcher:
A node is an HTML integration point if it is one of the following elements:
An annotation-xml element in the MathML namespace whose
start tag token had an attribute with the name "encoding" whose value was an ASCII
case-insensitive match for the string "text/html"
An annotation-xml element in the MathML namespace whose
start tag token had an attribute with the name "encoding" whose value was an ASCII
case-insensitive match for the string "application/xhtml+xml"
Not all of the tag names mentioned below are conformant tag names in this
specification; many are included to handle legacy content. They still form part of the algorithm
that implementations are required to implement to claim conformance.
The algorithm described below places no limit on the depth of the DOM tree
generated, or on the length of tag names, attribute names, attribute values, Text
nodes, etc. While implementors are encouraged to avoid arbitrary limits, it is recognised that practical concerns will likely force user agents to impose nesting
depth constraints.
8.2.5.1 Creating and inserting nodes
While the parser is processing a token, it can enable or disable foster parenting. This affects the following algorithm.
The appropriate place for inserting a node, optionally using a particular
override target, is the position in an element returned by running the following steps:
If there was an override target specified, then let target be the
override target.
If there is a last template and either there is no last table, or there is one, but last template is lower
(more recently added) than last table in the stack of open
elements, then: let adjusted insertion location be inside last template's template contents, after its last child (if any),
and abort these substeps.
If there is no last table, then let adjusted insertion
location be inside the first element in the stack of open elements (the
html element), after its last child (if any), and abort these substeps.
(fragment case)
If last table has a parent node, then let adjusted insertion location be inside last table's parent
node, immediately before last table, and abort these
substeps.
Let previous element be the element immediately above last table in the stack of open elements.
Let adjusted insertion location be inside previous
element, after its last child (if any).
These steps are involved in part because it's possible for elements, the
table element in this case in particular, to have been moved by a script around
in the DOM, or indeed removed from the DOM entirely, after the element was inserted by the
parser.
そうでなければ
Let adjusted insertion location be inside target,
after its last child (if any).
If the adjusted insertion location is inside a template
element, let it instead be inside the template element's template
contents, after its last child (if any).
Return the adjusted insertion location.
When the steps below require the UA to create an
element for a token in a particular given namespace and with a
particular intended parent, the UA must run the following steps:
Create a node implementing the interface appropriate for the element type corresponding to
the tag name of the token in given namespace (as given in the specification
that defines that element, e.g. for an a element in the HTML
namespace, this specification defines it to be the HTMLAnchorElement
interface), with the tag name being the name of that element, with the node being in the given
namespace, and with the attributes on the node being those given in the given token.
The interface appropriate for an element in the HTML namespace that is not
defined in this specification (or other applicable specifications) is
HTMLUnknownElement. Elements in other namespaces whose interface is not defined by
that namespace's specification must use the interface Element.
The ownerDocument of the newly created element
must be the same as that of the intended parent.
If the newly created element has an xmlns attribute in the
XMLNS namespace whose value is not exactly the same as the element's namespace,
that is a parse error. Similarly, if the newly created element has an xmlns:xlink attribute in the XMLNS namespace whose value is not the
XLink Namespace, that is a parse error.
Create an element for the token in the given namespace, with the intended
parent being the element in which the adjusted insertion location finds
itself.
If it is possible to insert an element at the adjusted insertion
location, then insert the newly created element at the adjusted insertion
location.
If the adjusted insertion location cannot accept more
elements, e.g. because it's a Document that already has an element child, then the
newly created element is dropped on the floor.
When the steps below require the user agent to insert an HTML element for a token,
the user agent must insert a foreign element for the token, in the HTML
namespace.
When the steps below require the user agent to adjust MathML attributes for a token,
then, if the token has an attribute named definitionurl, change its name to
definitionURL (note the case difference).
When the steps below require the user agent to adjust SVG attributes for a token,
then, for each attribute on the token whose attribute name is one of the ones in the first column
of the following table, change the attribute's name to the name given in the corresponding cell in
the second column. (This fixes the case of SVG attributes that are not all lowercase.)
Attribute name on token
Attribute name on element
attributename
attributeName
attributetype
attributeType
basefrequency
baseFrequency
baseprofile
baseProfile
calcmode
calcMode
clippathunits
clipPathUnits
diffuseconstant
diffuseConstant
edgemode
edgeMode
filterunits
filterUnits
glyphref
glyphRef
gradienttransform
gradientTransform
gradientunits
gradientUnits
kernelmatrix
kernelMatrix
kernelunitlength
kernelUnitLength
keypoints
keyPoints
keysplines
keySplines
keytimes
keyTimes
lengthadjust
lengthAdjust
limitingconeangle
limitingConeAngle
markerheight
markerHeight
markerunits
markerUnits
markerwidth
markerWidth
maskcontentunits
maskContentUnits
maskunits
maskUnits
numoctaves
numOctaves
pathlength
pathLength
patterncontentunits
patternContentUnits
patterntransform
patternTransform
patternunits
patternUnits
pointsatx
pointsAtX
pointsaty
pointsAtY
pointsatz
pointsAtZ
preservealpha
preserveAlpha
preserveaspectratio
preserveAspectRatio
primitiveunits
primitiveUnits
refx
refX
refy
refY
repeatcount
repeatCount
repeatdur
repeatDur
requiredextensions
requiredExtensions
requiredfeatures
requiredFeatures
specularconstant
specularConstant
specularexponent
specularExponent
spreadmethod
spreadMethod
startoffset
startOffset
stddeviation
stdDeviation
stitchtiles
stitchTiles
surfacescale
surfaceScale
systemlanguage
systemLanguage
tablevalues
tableValues
targetx
targetX
targety
targetY
textlength
textLength
viewbox
viewBox
viewtarget
viewTarget
xchannelselector
xChannelSelector
ychannelselector
yChannelSelector
zoomandpan
zoomAndPan
When the steps below require the user agent to adjust foreign attributes for a
token, then, if any of the attributes on the token match the strings given in the first column of
the following table, let the attribute be a namespaced attribute, with the prefix being the string
given in the corresponding cell in the second column, the local name being the string given in the
corresponding cell in the third column, and the namespace being the namespace given in the
corresponding cell in the fourth column. (This fixes the use of namespaced attributes, in
particular lang attributes in the XML
namespace.)
When the steps below require the user agent to insert a character while processing a
token, the user agent must run the following steps:
Let data be the characters passed to the algorithm, or, if no
characters were explicitly specified, the character of the character token being
processed.
If the adjusted insertion location is in a Document node,
then abort these steps.
The DOM will not let Document nodes have Text node
children, so they are dropped on the floor.
If there is a Text node immediately before the adjusted insertion
location, then append data to that Text node's data.
Otherwise, create a new Text node whose data is data and
whose ownerDocument is the same as that of the
element in which the adjusted insertion location finds itself, and insert
the newly created node at the adjusted insertion location.
Here are some sample inputs to the parser and the corresponding number of Text
nodes that they result in, assuming a user agent that executes scripts.
A<script>
var text = document.createTextNode('B');
document.body.appendChild(text);
</script>C
Three Text nodes; "A" before the script, the script's contents, and "BC" after the script (the parser appends to the Text node created by the script).
A<script>
var text = document.getElementsByTagName('script')[0].firstChild;
text.data = 'B';
document.body.appendChild(text);
</script>C
Two adjacent Text nodes in the document, containing "A" and "BC".
A<table>B<tr>C</tr>D</table>
One Text node before the table, containing "ABCD". (This is caused by foster parenting.)
A<table><tr> B</tr> C</table>
One Text node before the table, containing "A B C" (A-space-B-space-C). (This is caused by foster parenting.)
A<table><tr> B</tr> </em>C</table>
One Text node before the table, containing "A BC" (A-space-B-C), and one Text node inside the table (as a child of a tbody) with a single space character. (Space characters separated from non-space characters by non-character tokens are not affected by foster parenting, even if those other tokens then get ignored.)
When the steps below require the user agent to insert a comment while processing a
comment token, optionally with an explicitly insertion position position, the
user agent must run the following steps:
Let data be the data given in the comment token being
processed.
If position was specified, then let the adjusted
insertion location be position. Otherwise, let adjusted
insertion location be the appropriate place for inserting a node.
Create a Comment node whose data attribute is set to
data and whose ownerDocument is
the same as that of the node in which the adjusted insertion location finds
itself.
Insert the newly created node at the adjusted insertion
location.
DOM mutation events must not fire for changes caused by the UA
parsing the document. This includes the parsing of any content inserted using document.write() and document.writeln() calls. [DOMEVENTS]
However, mutation observers do fire, as required by the DOM specification.
8.2.5.2 Parsing elements that contain only text
The generic raw text element parsing algorithm and the generic RCDATA element
parsing algorithm consist of the following steps. These algorithms are always invoked in
response to a start tag token.
8.2.5.3 Closing elements that have implied end tags
When the steps below require the UA to generate implied end
tags, then, while the current node is a
dd element, a dt element, an
li element, an option element, an
optgroup element, a p element, an
rb element, an rp element, an rt
element, or an rtc element, the UA must
pop the current node off the stack of open
elements.
If a step requires the UA to generate implied end tags but lists
an element to exclude from the process, then the UA must perform the
above steps as if that element was not in the above list.
When the steps below require the UA to generate all implied end tags thoroughly,
then, while the current node is a caption element, a
colgroup element, a dd element, a dt element, an
li element, an option element, an optgroup element, a
p element, an rb element, an rp element, an rt element, an rtc element, a
tbody element, a td element, a tfoot element, a
th element, a thead element, or a tr element, the UA must
pop the current node off the stack of open elements.
8.2.5.4 The rules for parsing tokens in HTML content
8.2.5.4.1 The "initial" insertion mode
When the user agent is to apply the rules for the "initial" insertion mode, the user agent must handle the token as
follows:
A character token that is one of U+0009 CHARACTER
TABULATION, "LF" (U+000A), "FF" (U+000C),
"CR" (U+000D), or U+0020 SPACE
If the DOCTYPE token's name is not a case-sensitive match for the string "html", or the token's public identifier is not missing, or the token's system
identifier is neither missing nor a case-sensitive match for the string
"about:legacy-compat", and none of the sets of conditions in the following list are
matched, then there is a parse error.
The DOCTYPE token's name is a case-sensitive match for the string "html", the token's public identifier is the case-sensitive string
"-//W3C//DTD HTML 4.0//EN", and the token's system identifier
is either missing or the case-sensitive string "http://www.w3.org/TR/REC-html40/strict.dtd".
The DOCTYPE token's name is a case-sensitive match for the string "html", the token's public identifier is the case-sensitive string
"-//W3C//DTD HTML 4.01//EN", and the token's system identifier
is either missing or the case-sensitive string "http://www.w3.org/TR/html4/strict.dtd".
The DOCTYPE token's name is a case-sensitive match for the string "html", the token's public identifier is the case-sensitive string
"-//W3C//DTD XHTML 1.0 Strict//EN", and the token's system
identifier is the case-sensitive string "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd".
The DOCTYPE token's name is a case-sensitive match for the string "html", the token's public identifier is the case-sensitive string
"-//W3C//DTD XHTML 1.1//EN", and the token's system identifier
is the case-sensitive string "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd".
Conformance checkers may, based on the values (including presence or lack thereof) of the
DOCTYPE token's name, public identifier, or system identifier, switch to a conformance checking
mode for another language (e.g. based on the DOCTYPE token a conformance checker could recognise
that the document is an HTML4-era document, and defer to an HTML4 conformance checker.)
Append a DocumentType node to the Document node, with the name attribute set to the name given in the DOCTYPE token, or the empty string
if the name was missing; the publicId attribute set to the public
identifier given in the DOCTYPE token, or the empty string if the public identifier was missing;
the systemId attribute set to the system identifier given in the DOCTYPE
token, or the empty string if the system identifier was missing; and the other attributes
specific to DocumentType objects set to null and empty lists as appropriate.
Associate the DocumentType node with the Document object so that it is
returned as the value of the doctype attribute of the
Document object.
The public identifier starts with: "-//W3C//DTD XHTML 1.0 Frameset//"
The public identifier starts with: "-//W3C//DTD XHTML 1.0 Transitional//"
The system identifier is not missing and the public identifier starts with: "-//W3C//DTD HTML 4.01 Frameset//"
The system identifier is not missing and the public identifier starts with: "-//W3C//DTD HTML 4.01 Transitional//"
The system identifier and public identifier strings must be compared to the values given in
the lists above in an ASCII case-insensitive manner. A system identifier whose
value is the empty string is not considered missing for the purposes of the conditions
above.
If the Document is being loaded as part of navigation of a browsing context, then: if the newly
created element has a manifest attribute whose value is
not the empty string, then resolve the value of that
attribute to an absolute URL, relative to the newly created element, and if that is
successful, run the application cache selection
algorithm with the result of applying the URL
serializer algorithm to the resulting parsed URL with the exclude
fragment flag set; otherwise, if there is no such attribute, or its value is the empty
string, or resolving its value fails, run the application
cache selection algorithm with no manifest. The algorithm must be passed the
Document object.
The root element can end up being removed from the Document object, e.g. by
scripts; nothing in particular happens in such cases, content continues being appended to the
nodes as described in the next section.
8.2.5.4.3 The "before head" insertion mode
When the user agent is to apply the rules for the "before head" insertion mode, the user agent must handle the token as
follows:
A character token that is one of U+0009 CHARACTER
TABULATION, "LF" (U+000A), "FF" (U+000C),
"CR" (U+000D), or U+0020 SPACE
This ensures that, if the script is external, any document.write() calls in the script will execute in-line,
instead of blowing the document away, as would happen in most other cases. It also prevents
the script from executing until the end tag is seen.
Otherwise, for each attribute on the token, check to see if the attribute is already present
on the top element of the stack of open elements. If it is not, add the attribute
and its corresponding value to that element.
A start tag whose tag name is one of: "base", "basefont", "bgsound", "link", "meta",
"noframes", "script", "style", "template", "title"
Otherwise, set the frameset-ok flag to "not ok"; then, for each attribute on the
token, check to see if the attribute is already present on the body element (the
second element) on the stack of open elements, and if it is not, add the attribute
and its corresponding value to that element.
If there is a node in the stack of open elements that is not either a
dd element, a dt element, an li element, an
optgroup element, an option element, a p
element, an rb element, an rp element, an rt element,
an rtc element, a tbody element, a td element, a tfoot element,
a th element, a thead element, a tr element, the
body element, or the html element, then this is a parse
error.
Otherwise, if there is a node in the stack of open elements that is not either a
dd element, a dt element, an li element, an
optgroup element, an option element, a p element, an
rb element, an rp element, an rt element, an
rtc element, a tbody element, a td element, a
tfoot element, a th element, a thead element, a
tr element, the body element, or the html element, then
this is a parse error.
Otherwise, if there is a node in the stack of open elements that is not either a
dd element, a dt element, an li element, an
optgroup element, an option element, a p element, an
rb element, an rp element, an rt element, an
rtc element, a tbody element, a td element, a
tfoot element, a th element, a thead element, a
tr element, the body element, or the html element, then
this is a parse error.
If the next token is a "LF" (U+000A) character token, then ignore that
token and move on to the next one. (Newlines at the start of pre blocks are ignored
as an authoring convenience.)
Once a start tag with the tag name "plaintext" has been seen, that will be the
last token ever seen other than character tokens (and the end-of-file token), because there is
no way to switch out of the PLAINTEXT state.
An end tag whose tag name is one of: "address", "article", "aside", "blockquote", "button",
"center", "details", "dialog", "dir", "div", "dl", "fieldset", "figcaption", "figure", "footer",
"header", "hgroup", "listing", "main", "menu", "nav", "ol", "pre", "section", "summary",
"ul"
Pop elements from the stack of open elements until an HTML element whose tag name is one of "h1", "h2", "h3", "h4", "h5", or "h6"
has been popped from the stack.
An end tag whose tag name is "sarcasm"
Take a deep breath, then act as described in the "any other end
tag" entry below.
In the non-conforming stream
<a href="a">a<table><a href="b">b</table>x, the first
a element would be closed upon seeing the second one, and the "x" character would
be inside a link to "b", not to "a". This is despite the fact that the outer a
element is not in table scope (meaning that a regular </a> end tag at the start
of the table wouldn't close the outer a element). The result is that the two
a elements are indirectly nested inside each other — non-conforming markup
will often result in non-conforming DOMs when parsed.
Parse error. Drop the attributes from the token, and act as described in the
next entry; i.e. act as if this was a "br" start tag token with no attributes, rather than the
end tag token that it actually is.
A start tag whose tag name is one of: "area", "br", "embed",
"img", "keygen", "wbr"
If the token does not have an attribute with the name "type", or if it does, but that
attribute's value is not an ASCII case-insensitive match for the string "hidden", then: set the frameset-ok flag to "not ok".
A start tag whose tag name is one of: "menuitem", "param", "source", "track"
If the token has an attribute called "action", set the action attribute on the resulting form element to the
value of the "action" attribute of the token.
Insert an HTML element for an "input" start tag token with all the attributes
from the "isindex" token except "name", "action", and "prompt", and with an attribute named
"name" with the value "isindex". (This creates an input element with the name attribute set to the magic value "isindex".) Immediately pop the current node off
the stack of open elements.
Prompt: If the token has an attribute
with the name "prompt", then the first stream of characters must be the same string as given in
that attribute, and the second stream of characters must be empty. Otherwise, the two streams of
character tokens together should, together with the input element, express the
equivalent of "This is a searchable index. Enter search keywords: (input field)" in the user's
preferred language.
If the next token is a "LF" (U+000A) character token, then ignore
that token and move on to the next one. (Newlines at the start of textarea
elements are ignored as an authoring convenience.)
Pop elements from the stack of open elements until a p element
has been popped from the stack.
The adoption agency algorithm, which takes as its only argument
a tag name subject for which the algorithm is being run, consists of the
following steps:
If formatting element is not the current node, this is a
parse error. (But do not abort these steps.)
Let furthest block be the topmost node in the stack of open
elements that is lower in the stack than formatting element, and is an
element in the special category. There might not be one.
If there is no furthest block, then the UA must first pop all the
nodes from the bottom of the stack of open elements, from the current
node up to and including formatting element, then remove formatting element from the list of active formatting elements, and
finally abort these steps.
Let common ancestor be the element immediately above formatting element in the stack of open elements.
Let a bookmark note the position of formatting element in the
list of active formatting elements relative to the elements on either side of it in
the list.
Let node and last node be furthest
block. Follow these steps:
Let inner loop counter be zero.
Inner loop: Increment inner loop counter by one.
Let node be the element immediately above node
in the stack of open elements, or if node is no longer in the
stack of open elements (e.g. because it got removed by this algorithm), the element that was immediately above node in the stack of open elements before node
was removed.
If node is formatting element, then go to the
next step in the overall algorithm.
If last node is furthest block, then move the
aforementioned bookmark to be immediately after the new node in the
list of active formatting elements.
Insert last node into node, first removing it
from its previous parent node if any.
Let last node be node.
Return to the step labeled inner loop.
Insert whatever last node ended up being in the previous step at the
appropriate place for inserting a node, but using common
ancestor as the override target.
Remove formatting element from the stack of open
elements, and insert the new element into the stack of open elements
immediately below the position of furthest block in that stack.
Jump back to the step labeled outer loop.
This algorithm's name, the "adoption agency algorithm", comes from the way it
causes elements to change parents, and is in contrast with other possible algorithms for dealing
with misnested content, which included the "incest algorithm", the "secret affair algorithm", and
the "Heisenberg algorithm".
8.2.5.4.8 The "text" insertion mode
When the user agent is to apply the rules for the "text" insertion mode, the user agent must handle the token as
follows:
Let the insertion point have the value of the old insertion
point. (In other words, restore the insertion point to its previous value.
This value might be the "undefined" value.)
Set the parser pause flag to true, and abort the processing of any nested
invocations of the tokenizer, yielding control back to the caller. (Tokenization will resume
when the caller returns to the "outer" tree construction stage.)
If the token does not have an attribute with the name "type", or if it does, but that
attribute's value is not an ASCII case-insensitive match for the string "hidden", then: act as described in the "anything else" entry below.
When the steps above require the UA to clear the stack back to a table context, it
means that the UA must, while the current node is not a table,
template, or html element, pop elements from the stack of open
elements.
When the steps above require the UA to clear the stack back to a table row context,
it means that the UA must, while the current node is not a tr,
template, or html element, pop elements from the stack of open
elements.
If the adjusted current node is an element in the SVG namespace, and the
token's tag name is one of the ones in the first column of the following table, change the tag
name to the name given in the corresponding cell in the second column. (This fixes the case of
SVG elements that are not all lowercase.)
Let the insertion point have the value of the old insertion
point. (In other words, restore the insertion point to its previous value.
This value might be the "undefined" value.)
Any other end tag
Run these steps:
Initialise node to be the current node (the bottommost
node of the stack).
If node's tag name, converted to ASCII lowercase, is
the same as the tag name of the token, pop elements from the stack of open
elements until node has been popped from the stack, and then abort
these steps.
Fire a trusted event with the name pageshow at the Window object of the
Document, but with its target set to the
Document object (and the currentTarget set to the Window object),
using the PageTransitionEvent interface, with the persisted attribute initialised to false. This
event must not bubble, must not be cancelable, and has no default action.
When an application uses an HTML parser in conjunction with an XML pipeline, it is
possible that the constructed DOM is not compatible with the XML tool chain in certain subtle
ways. For example, an XML toolchain might not be able to represent attributes with the name xmlns, since they conflict with the Namespaces in XML syntax. There is also some
data that the HTML parser generates that isn't included in the DOM itself. This
section specifies some rules for handling these issues.
If the XML API being used doesn't support DOCTYPEs, the tool may drop DOCTYPEs altogether.
If the XML API doesn't support attributes in no namespace that are named "xmlns", attributes whose names start with "xmlns:", or
attributes in the XMLNS namespace, then the tool may drop such attributes.
The tool may annotate the output with any namespace declarations required for proper
operation.
If the XML API being used restricts the allowable characters in the local names of elements and
attributes, then the tool may map all element and attribute local names that the API wouldn't
support to a set of names that are allowed, by replacing any character that isn't
supported with the uppercase letter U and the six digits of the character's Unicode code point
when expressed in hexadecimal, using digits 0-9 and capital letters A-F as the symbols, in
increasing numeric order.
For example, the element name foo<bar, which can be
output by the HTML parser, though it is neither a legal HTML element name nor a
well-formed XML element name, would be converted into fooU00003Cbar, which
is a well-formed XML element name (though it's still not legal in HTML by any means).
As another example, consider the attribute xlink:href. Used on a
MathML element, it becomes, after being adjusted,
an attribute with a prefix "xlink" and a local name "href". However, used on an HTML element, it becomes an attribute with no prefix
and the local name "xlink:href", which is not a valid NCName, and thus might
not be accepted by an XML API. It could thus get converted, becoming "xlinkU00003Ahref".
The resulting names from this conversion conveniently can't clash with any
attribute generated by the HTML parser, since those are all either lowercase or those
listed in the adjust foreign attributes algorithm's table.
If the XML API restricts comments from having two consecutive U+002D HYPHEN-MINUS characters
(--), the tool may insert a single U+0020 SPACE character between any such offending
characters.
If the XML API restricts comments from ending in a "-" (U+002D) character, the tool
may insert a single U+0020 SPACE character at the end of such comments.
If the XML API restricts allowed characters in character data, attribute values, or comments,
the tool may replace any "FF" (U+000C) character with a U+0020 SPACE character, and any
other literal non-XML character with a U+FFFD REPLACEMENT CHARACTER.
If the tool has no way to convey out-of-band information, then the tool may drop the following
information:
The mutations allowed by this section apply after the HTML
parser's rules have been applied. For example, a <a::> start tag
will be closed by a </a::> end tag, and never by a </aU00003AU00003A> end tag, even if the user agent is using the rules above to
then generate an actual element in the DOM with the name aU00003AU00003A for
that start tag.
8.2.8 An introduction to error handling and strange cases in the parser
この節は非規範的である。
This section examines some erroneous markup and discusses how the HTML parser
handles these cases.
8.2.8.1 Misnested tags: <b><i></b></i>
この節は非規範的である。
The most-often discussed example of erroneous markup is as follows:
<p>1<b>2<i>3</b>4</i>5</p>
The parsing of this markup is straightforward up to the "3". At this point, the DOM looks like
this:
Upon receiving the end tag token with the tag name "b", the "adoption
agency algorithm" is invoked. This is a simple case, in that the formatting
element is the b element, and there is no furthest block.
Thus, the stack of open elements ends up with just three elements: html,
body, and p, while the list of active formatting elements
has just one: i. The DOM tree is unmodified at this point.
The next token is a character ("4"), triggers the reconstruction of the active formatting elements, in this case just
the i element. A new i element is thus created for the "4"
Text node. After the end tag token for the "i" is also received, and the "5"
Text node is inserted, the DOM looks as follows:
Upon receiving the end tag token with the tag name "b", the "adoption
agency algorithm" is invoked, as in the previous example. However, in this case, there
is a furthest block, namely the p element. Thus, this
time the adoption agency algorithm isn't skipped over.
The common ancestor is the body element. A conceptual
"bookmark" marks the position of the b in the list of active formatting
elements, but since that list has only one element in it, the bookmark won't have much
effect.
As the algorithm progresses, node ends up set to the formatting element
(b), and last node ends up set to the furthest
block (p).
The last node gets appended (moved) to the common
ancestor, so that the DOM looks like:
The highlighted b element start tag is not allowed directly inside a table like
that, and the parser handles this case by placing the element before the table. (This is
called foster parenting.) This can be seen by examining the DOM tree
as it stands just after the table element's start tag has been seen:
The tr start tag causes the b element to be popped off the stack and
a tbody start tag to be implied; the tbody and tr elements
are then handled in a rather straight-forward manner, taking the parser through the "in table body" and "in row" insertion modes, after which the DOM looks as follows:
Thus it is that the "bbb" character tokens are found. These trigger the "in table text" insertion mode to be used (with the original
insertion mode set to "in table body").
The character tokens are collected, and when the next token (the table element end
tag) is seen, they are processed as a group. Since they are not all spaces, they are handled as
per the "anything else" rules in the "in table"
insertion mode, which defer to the "in body"
insertion mode but with foster parenting.
Finally, the table is closed by a "table" end tag. This pops all the nodes from
the stack of open elements up to and including the table element, but it
doesn't affect the list of active formatting elements, so the "ccc" character tokens
after the table result in yet another b element being created, this time after the
table:
8.2.8.4 Scripts that modify the page as it is being parsed
この節は非規範的である。
Consider the following markup, which for this example we will assume is the document with
URLhttp://example.com/inner, being rendered as the content of
an iframe in another document with the URLhttp://example.com/outer:
<div id=a>
<script>
var div = document.getElementById('a');
parent.document.body.appendChild(div);
</script>
<script>
alert(document.URL);
</script>
</div>
<script>
alert(document.URL);
</script>
Up to the first "script" end tag, before the script is parsed, the result is relatively
straightforward:
This script does execute, resulting in an alert that says "http://example.com/inner".
8.2.8.5 The execution of scripts that are moving across multiple documents
この節は非規範的である。
Elaborating on the example in the previous section, consider the case where the second
script element is an external script (i.e. one with a src attribute). Since the element was not in the parser's
Document when it was created, that external script is not even downloaded.
In a case where a script element with a src
attribute is parsed normally into its parser's Document, but while the external
script is being downloaded, the element is moved to another document, the script continues to
download, but does not execute.
In general, moving script elements between Documents is
considered a bad practice.
8.2.8.6 Unclosed formatting elements
この節は非規範的である。
The following markup shows how nested formatting elements (such as b) get
collected and continue to be applied even as the elements they are contained in are closed, but
that excessive duplicates are thrown away.
Note how the second p element in the markup has no explicit b
elements, but in the resulting DOM, up to three of each kind of formatting element (in this case
three b elements with the class attribute, and two unadorned b elements)
get reconstructed before the element's "X".
Also note how this means that in the final paragraph only six b end tags are
needed to completely clear the list of active formatting elements, even though nine b start
tags have been seen up to this point.
8.3 Serializing HTML fragments
The following steps form the HTML fragment serialization algorithm. The algorithm
takes as input a DOM Element, Document, or DocumentFragment
referred to as the node, and either returns a string or throws an
exception.
This algorithm serializes the children of the node being serialized, not
the node itself.
Let s be a string, and initialise it to the empty string.
For each child node of the node, in tree order, run the
following steps:
Let current node be the child node being processed.
Append the appropriate string from the following list to s:
If current node is an Element
If current node is an element in the HTML namespace, the
MathML namespace, or the SVG namespace, then let tagname be current node's local name. Otherwise, let tagname be current node's qualified name.
Append a "<" (U+003C) character, followed by tagname.
For HTML elements created by the HTML parser or
Document.createElement(), tagname will be
lowercase.
For each attribute that the element has, append a U+0020 SPACE character, the attribute's serialised name as described below, a
"=" (U+003D) character, a U+0022 QUOTATION MARK character ("), the
attribute's value, escaped as described below in
attribute mode, and a second U+0022 QUOTATION MARK character (").
An attribute's serialised name for the purposes of the previous paragraph must
be determined as follows:
If the attribute has no namespace
The attribute's serialised name is the attribute's local name.
For attributes on HTML elements set by the HTML
parser or by Element.setAttribute(), the local name will be
lowercase.
The attribute's serialised name is the string "xlink:"
followed by the attribute's local name.
If the attribute is in some other namespace
The attribute's serialised name is the attribute's qualified name.
While the exact order of attributes is UA-defined, and may depend on factors such as the
order that the attributes were given in the original markup, the sort order must be stable,
such that consecutive invocations of this algorithm serialise an element's attributes in the
same order.
If current node is a pre, textarea, or
listing element, and the first child node of the element, if any, is a
Text node whose character data has as its first character a "LF" (U+000A) character, then append a "LF" (U+000A) character.
Append the value of running the HTML fragment serialization algorithm on the
current node element (thus recursing into this algorithm for that
element), followed by a "<" (U+003C) character, a U+002F SOLIDUS character
(/), tagname again, and finally a U+003E GREATER-THAN SIGN character
(>).
Append the literal string <!-- (U+003C LESS-THAN SIGN, U+0021 EXCLAMATION
MARK, U+002D HYPHEN-MINUS, U+002D HYPHEN-MINUS), followed by the value of current node's data IDL attribute, followed by the
literal string --> (U+002D HYPHEN-MINUS, U+002D HYPHEN-MINUS, U+003E
GREATER-THAN SIGN).
If current node is a ProcessingInstruction
Append the literal string (U+003C LESS-THAN SIGN, U+003F QUESTION
MARK), followed by the value of current node's target IDL attribute, followed by a single U+0020 SPACE character, followed
by the value of current node's data IDL attribute,
followed by a single ">" (U+003E) character.
If current node is a DocumentType
Append the literal string <!DOCTYPE (U+003C LESS-THAN SIGN, U+0021
EXCLAMATION MARK, U+0044 LATIN CAPITAL LETTER D, U+004F LATIN CAPITAL LETTER O, U+0043 LATIN
CAPITAL LETTER C, U+0054 LATIN CAPITAL LETTER T, U+0059 LATIN CAPITAL LETTER Y, U+0050 LATIN
CAPITAL LETTER P, U+0045 LATIN CAPITAL LETTER E), followed by a space (U+0020 SPACE),
followed by the value of current node's name IDL
attribute, followed by the literal string > (U+003E GREATER-THAN SIGN).
The result of the algorithm is the string s.
It is possible that the output of this algorithm, if parsed with an HTML
parser, will not return the original tree structure.
For instance, if a textarea element to which a Comment node
has been appended is serialised and the output is then reparsed, the comment will end up being
displayed in the text field. Similarly, if, as a result of DOM manipulation, an element contains
a comment that contains the literal string "-->", then when the result
of serializing the element is parsed, the comment will be truncated at that point and the rest of
the comment will be interpreted as markup. More examples would be making a script
element contain a Text node with the text string "</script>", or
having a p element that contains a ul element (as the ul
element's start tag would imply the end tag for the
p).
This can enable cross-site scripting attacks. An example of this would be a page that lets the
user enter some font family names that are then inserted into a CSS style block via
the DOM and which then uses the innerHTML IDL attribute to get
the HTML serialization of that style element: if the user enters
"</style><script>attack</script>" as a font family name, innerHTML will return markup that, if parsed in a different context,
would contain a script node, even though no script node existed in the
original DOM.
Escaping a string (for the purposes of the algorithm above)
consists of running the following steps:
Replace any occurrence of the "&" character by the string "&".
Replace any occurrences of the U+00A0 NO-BREAK SPACE character by the string " ".
If the algorithm was invoked in the attribute mode, replace any occurrences of the
""" character by the string """.
If the algorithm was not invoked in the attribute mode, replace any
occurrences of the "<" character by the string "<", and any occurrences of the ">" character by
the string ">".
8.4 Parsing HTML fragments
The following steps form the HTML fragment parsing algorithm. The algorithm
optionally takes as input an Element node, referred to as the context element, which gives the context for
the parser, as well as input, a string to parse, and returns a list of zero or
more nodes.
Parts marked fragment case in algorithms in the parser section are
parts that only occur if the parser was created for the purposes of this algorithm (and with a
context element). The algorithms have been annotated
with such markings for informational purposes only; such markings have no normative weight. If it
is possible for a condition described as a fragment case to occur even when the
parser wasn't created for the purposes of handling this algorithm, then that is an error in the
specification.
For performance reasons, an implementation that does not report errors and
that uses the actual state machine described in this specification directly could use the
PLAINTEXT state instead of the RAWTEXT and script data states where those are mentioned in the
list above. Except for rules regarding parse errors, they are equivalent, since there is no
appropriate end tag token in the fragment case, yet they involve far fewer state
transitions.
Let root be a new html element with no attributes.
Append the element root to the Document node created
above.
Set up the parser's stack of open elements so that it contains just the single
element root.
The parser will reference the context element as part of that algorithm.
Set the parser's form element pointer to the nearest node to the
context element that is a form
element (going straight up the ancestor chain, and including the element itself, if it is a
form element), if any. (If there is no such form element, the
form element pointer keeps its initial value, null.)
This section describes the relationship between XML and the DOM, with a particular emphasis on
how this interacts with HTML.
An XML parser, for the purposes of this specification, is a construct that follows
the rules given in the XML specification to map a string of bytes or characters into a
Document object.
At the time of writing, no such rules actually exist.
An XML parser is either associated with a Document object when it is
created, or creates one implicitly.
This Document must then be populated with DOM nodes that represent the tree
structure of the input passed to the parser, as defined by the XML specification, the Namespaces
in XML specification, and the DOM specification. DOM mutation events must not fire for the
operations that the XML parser performs on the Document's tree, but the
user agent must act as if elements and attributes were individually appended and set respectively
so as to trigger rules in this specification regarding what happens when an element is inserted
into a document or has its attributes set, and the DOM specification's requirements regarding
mutation observers mean that mutation observers are fired (unlike mutation events). [XML][XMLNS][DOM][DOMEVENTS]
Between the time an element's start tag is parsed and the time either the element's end tag is
parsed or the parser detects a well-formedness error, the user agent must act as if the element
was in a stack of open elements.
This is used by the object element to avoid instantiating plugins
before the param element children have been parsed.
This specification provides the following additional information that user agents should use
when retrieving an external entity: the public identifiers given in the following list all
correspond to the URL given by this link. (This
URL is a DTD containing the entity
declarations for the names listed in the named character references section.) [XML]
-//W3C//DTD XHTML 1.0 Transitional//EN
-//W3C//DTD XHTML 1.1//EN
-//W3C//DTD XHTML 1.0 Strict//EN
-//W3C//DTD XHTML 1.0 Frameset//EN
-//W3C//DTD XHTML Basic 1.0//EN
-//W3C//DTD XHTML 1.1 plus MathML 2.0//EN
-//W3C//DTD XHTML 1.1 plus MathML 2.0 plus SVG 1.1//EN
-//W3C//DTD MathML 2.0//EN
-//WAPFORUM//DTD XHTML Mobile 1.0//EN
Furthermore, user agents should attempt to retrieve the above external entity's content when
one of the above public identifiers is used, and should not attempt to retrieve any other external
entity's content.
This is not strictly a violation of the XML
specification, but it does contradict the spirit of the XML specification's requirements. This is
motivated by a desire for user agents to all handle entities in an interoperable fashion without
requiring any network access for handling external subsets. [XML]
This is a willful violation of the XML specification; unfortunately,
XML is not formally extensible in the manner that is needed for template processing.
[XML]
When an XML parser creates a Node object, its ownerDocument must be set to the Document of
the node into which the newly created node is to be inserted.
Certain algorithms in this specification spoon-feed the
parser characters one string at a time. In such cases, the XML parser must act
as it would have if faced with a single string consisting of the concatenation of all those
characters.
For the purposes of conformance checkers, if a resource is determined to be in the XHTML
syntax, then it is an XML document.
9.3 Serializing XHTML fragments
The XML fragment serialization algorithm for a Document or
Element node either returns a fragment of XML that represents that node or throws an
exception.
For Documents, the algorithm must return a string in the form of a document entity, if none of the error cases
below apply.
In both cases, the string returned must be XML namespace-well-formed and must be an isomorphic
serialization of all of that node's relevant child nodes, in tree order.
User agents may adjust prefixes and namespace declarations in the serialization (and indeed might
be forced to do so in some cases to obtain namespace-well-formed XML). User agents may use a
combination of regular text and character references to represent Text nodes in the
DOM.
A node's relevant child nodes are those that apply given the following rules:
For Elements, if any of the elements in the serialization are in no namespace, the
default namespace in scope for those elements must be explicitly declared as the empty string. (This doesn't apply in the Document case.) [XML][XMLNS]
For the purposes of this section, an internal general parsed entity is considered XML
namespace-well-formed if a document consisting of an element with no namespace declarations whose
contents are the internal general parsed entity would itself be XML namespace-well-formed.
If any of the following error cases are found in the DOM subtree being serialized, then the
algorithm must throw an InvalidStateError exception instead of returning a
string:
A DocumentType node that has an external subset public identifier that contains
characters that are not matched by the XML PubidChar production. [XML]
A DocumentType node that has an external subset system identifier that contains
both a """ (U+0022) and a "'" (U+0027) or that contains characters that are
not matched by the XML Char production. [XML]
A node with a local name containing a ":" (U+003A).
A node with a local name that does not match the XML Name production. [XML]
An Attr node with no namespace whose local name is the lowercase string "xmlns". [XMLNS]
An Element node with two or more attributes with the same local name and
namespace.
These are the only ways to make a DOM unserializable. The DOM enforces all the
other XML constraints; for example, trying to append two elements to a Document node
will throw a HierarchyRequestError exception.
When the algorithm must produce a serialization of a template element, the string
returned must contain a serialization of the child nodes of the template element's contentDocumentFragment, rather than the
template element's children.
9.4 Parsing XHTML fragments
The XML fragment parsing algorithm either returns a Document or throws
a SyntaxError exception. Given a string input and an optional
context element context, the algorithm is as
follows:
If there is a context element, feed the
parser just created the string corresponding to the start tag of that element, declaring
all the namespace prefixes that are in scope on that element in the DOM, as well as declaring
the default namespace (if any) that is in scope on that element in the DOM.
A namespace prefix is in scope if the DOM lookupNamespaceURI() method
on the element would return a non-null value for that prefix.
The default namespace is the namespace for which the DOM isDefaultNamespace() method on the element would return true.
If there is a context element, no
DOCTYPE is passed to the parser, and therefore no external subset is
referenced, and therefore no entities will be recognized.
If there is a context element, feed the
parser just created the string corresponding to the end tag of that element.
If there is an XML well-formedness or XML namespace well-formedness error, then throw a
SyntaxError exception and abort these steps.
If there is a context element, and the root
element of the resulting Document has any sibling nodes, then throw a
SyntaxError exception and abort these steps.
If there is a context element, then return the
child nodes of the root element of the resulting Document, in tree
order.
User agents are not required to present HTML documents in any particular way. However, this
section provides a set of suggestions for rendering HTML documents that, if followed, are likely
to lead to a user experience that closely resembles the experience intended by the documents'
authors. So as to avoid confusion regarding the normativity of this section, RFC2119 terms have
not been used. Instead, the term "expected" is used to indicate behavior that will lead to this
experience. For the purposes of conformance for user agents designated as supporting the suggested default rendering, the term "expected" in this
section has the same conformance implications as the RFC2119-defined term "must".
10.1 Introduction
In general, user agents are expected to support CSS, and many of the suggestions in this
section are expressed in CSS terms. User agents that use other presentation mechanisms can derive
their expected behavior by translating from the CSS rules given in this section.
In the absence of style-layer rules to the contrary (e.g. author style sheets), user agents are
expected to render an element so that it conveys to the user the meaning that the element
represents, as described by this specification.
The suggestions in this section generally assume a visual output medium with a resolution of
96dpi or greater, but HTML is intended to apply to multiple media (it is a
media-independent language). User agent implementors are encouraged to adapt the
suggestions in this section to their target media.
An element is being rendered if it has any associated CSS layout boxes, SVG layout
boxes, or some equivalent in other styling languages.
Just being off-screen does not mean the element is not being
rendered. The presence of the hidden attribute normally
means the element is not being rendered, though this might be overridden by the style
sheets.
User agents that do not honor author-level CSS style sheets are nonetheless expected to act as
if they applied the CSS rules given in these sections in a manner consistent with this
specification and the relevant CSS and Unicode specifications. [CSS][UNICODE][BIDI]
This is especially important for issues relating to the 'display', 'unicode-bidi',
and 'direction' properties.
10.2 The CSS user agent style sheet and presentational hints
The CSS rules given in these subsections are, except where otherwise specified, expected to be
used as part of the user-agent level style sheet defaults for all documents that contain
HTML elements.
Some rules are intended for the author-level zero-specificity presentational hints part of the
CSS cascade; these are explicitly called out as presentational hints.
Some of the rules regarding left and right margins are given here as appropriate for elements
whose 'direction' property is 'ltr', and are expected to be flipped around on elements whose
'direction' property is 'rtl'. These are marked "LTR-specific".
These markings only affect the handling of attribute values, not
attribute names or element names.
When the text below says that an attribute attribute on an element element maps to the pixel length property (or properties) properties, it means that if element has an attribute attribute set, and parsing that attribute's value using the rules for parsing
non-negative integers doesn't generate an error, then the user agent is expected to use the
parsed value as a pixel length for a presentational hint
for properties.
When the text below says that an attribute attribute on an element element maps to the dimension property (or properties) properties, it means that if element has an attribute attribute set, and parsing that attribute's value using the rules for parsing
dimension values doesn't generate an error, then the user agent is expected to use the
parsed dimension as the value for a presentational hint
for properties, with the value given as a pixel length if the dimension was an
integer, and with the value given as a percentage if the dimension was a percentage.
When a user agent is to align descendants of a node, the user agent is expected to
align only those descendants that have both their 'margin-left' and 'margin-right' properties
computing to a value other than 'auto', that are over-constrained and that have one of those two
margins with a used value forced to a greater value, and that do not themselves have an applicable
align attribute. When multiple elements are to align a particular descendant, the most deeply nested such element is expected
to override the others. Aligned elements are expected to be aligned by having the used values of
their left and right margins be set accordingly.
The user agent is expected to force the 'display' property of noscript elements
for whom scripting is enabled to compute to 'none',
irrespective of CSS rules.
The user agent is expected to force the 'display' property of input elements whose
type attribute is in the Hidden state to compute to 'none', irrespective of CSS
rules.
10.3.2 The page
@namespace url(http://www.w3.org/1999/xhtml);
html, body { display: block; }
For each property in the table below, given a body element, the first attribute
that exists maps to the pixel length property on the body element. If
none of the attributes for a property are found, or if the value of the attribute that was found
cannot be parsed successfully, then, if the body element's Document's
browsing context does not have its seamless browsing context flag set, a
default value of 8px is expected to be used for that property instead.
The above requirements imply that a page can change the margins of another page
(including one from another origin) using, for example, an iframe. This
is potentially a security risk, as it might in some cases allow an attack to contrive a situation
in which a page is rendered not as the author intended, possibly for the purposes of phishing or
otherwise misleading the user.
When a body element has a background
attribute set to a non-empty value, the new value is expected to be resolved relative to the element, and if this is successful, the user agent is
expected to treat the attribute as a presentational hint
setting the element's 'background-image' property to the resulting absolute URL.
When a body element has a bgcolor attribute
set, the new value is expected to be parsed using the rules for parsing a legacy color
value, and if that does not return an error, the user agent is expected to treat the
attribute as a presentational hint setting the element's
'background-color' property to the resulting color.
When a body element has a text attribute, its
value is expected to be parsed using the rules for parsing a legacy color value, and
if that does not return an error, the user agent is expected to treat the attribute as a presentational hint setting the element's 'color' property to
the resulting color.
When a body element has a link attribute, its
value is expected to be parsed using the rules for parsing a legacy color value, and
if that does not return an error, the user agent is expected to treat the attribute as a presentational hint setting the 'color' property of any
element in the Document matching the ':link' pseudo-class to the resulting color.
When a body element has a vlink attribute,
its value is expected to be parsed using the rules for parsing a legacy color value,
and if that does not return an error, the user agent is expected to treat the attribute as a presentational hint setting the 'color' property of any
element in the Document matching the ':visited' pseudo-class to the resulting
color.
When a body element has an alink attribute,
its value is expected to be parsed using the rules for parsing a legacy color value,
and if that does not return an error, the user agent is expected to treat the attribute as a presentational hint setting the 'color' property of any
element in the Document matching the ':active' pseudo-class and either the ':link'
pseudo-class or the ':visited' pseudo-class to the resulting color.
In quirks mode, the following rules are also expected to apply:
@namespace url(http://www.w3.org/1999/xhtml);
form { margin-bottom: 1em; }
The center element, and the div element when it has an align attribute whose value is an ASCII
case-insensitive match for either the string "center" or the string
"middle", are expected to center text within themselves, as if they had
their 'text-align' property set to 'center' in a presentational
hint, and to align descendants to the center.
The div element, when it has an align attribute
whose value is an ASCII case-insensitive match for the string "left", is expected to left-align text within itself, as if it had its 'text-align'
property set to 'left' in a presentational hint, and to
align descendants to the left.
The div element, when it has an align attribute
whose value is an ASCII case-insensitive match for the string "right", is expected to right-align text within itself, as if it had its
'text-align' property set to 'right' in a presentational
hint, and to align descendants to the right.
The div element, when it has an align attribute
whose value is an ASCII case-insensitive match for the string "justify", is expected to full-justify text within itself, as if it had its
'text-align' property set to 'justify' in a presentational
hint, and to align descendants to the left.
10.3.4 Phrasing content
@namespace url(http://www.w3.org/1999/xhtml);
cite, dfn, em, i, var { font-style: italic; }
b, strong { font-weight: bolder; }
code, kbd, samp, tt { font-family: monospace; }
big { font-size: larger; }
small { font-size: smaller; }
sub { vertical-align: sub; }
sup { vertical-align: super; }
sub, sup { line-height: normal; font-size: smaller; }
ruby { display: ruby; }
rb { display: ruby-base; white-space: nowrap; }
rt {
display: ruby-text;
white-space: nowrap;
font-size: 50%;
font-variant-east-asian: ruby;
text-emphasis: none;
}
rbc { display: ruby-base-container; }
rtc { display: ruby-text-container; }
ruby, rb, rt, rbc, rtc { unicode-bidi: isolate; }
:link { color: #0000EE; }
:visited { color: #551A8B; }
:link, :visited { text-decoration: underline; }
a:link[rel~=help], a:visited[rel~=help],
area:link[rel~=help], area:visited[rel~=help] { cursor: help; }
:focus { outline: auto; }
mark { background: yellow; color: black; } /* this color is just a suggestion and can be changed based on implementation feedback */
abbr[title], acronym[title] { text-decoration: dotted underline; }
ins, u { text-decoration: underline; }
del, s, strike { text-decoration: line-through; }
blink { text-decoration: blink; }
q::before { content: open-quote; }
q::after { content: close-quote; }
br { content: '\A'; white-space: pre; } /* this also has bidi implications */
nobr { white-space: nowrap; }
wbr { content: '\200B'; } /* this also has bidi implications */
nobr wbr { white-space: normal; }
User agents that do not support correct ruby rendering are expected to render parentheses
around the text of rt elements in the absence of rp elements.
[CSSRUBY]
User agents are expected to support the 'clear' property on inline elements (in order to render
br elements with clear attributes) in the manner
described in the non-normative note to this effect in CSS2.1.
The initial value for the 'color' property is expected to be black. The initial value for the
'background-color' property is expected to be 'transparent'. The canvas' background is expected to
be white.
When a font element has a color attribute,
its value is expected to be parsed using the rules for parsing a legacy color value,
and if that does not return an error, the user agent is expected to treat the attribute as a presentational hint setting the element's 'color' property to
the resulting color.
When a font element has a face attribute, the
user agent is expected to treat the attribute as a presentational hint setting the element's 'font-family' property to the attribute's
value.
When a font element has a size attribute, the
user agent is expected to use the following steps, known as the rules for parsing a legacy
font size, to treat the attribute as a presentational
hint setting the element's 'font-size' property:
Let input be the attribute's value.
Let position be a pointer into input, initially
pointing at the start of the string.
If position is past the end of input, there is no
presentational hint. Abort these steps.
If the character at position is a "+" (U+002B) character, then
let mode be relative-plus, and advance position to
the next character. Otherwise, if the character at position is a "-" (U+002D) character, then let mode be relative-minus, and
advance position to the next character. Otherwise, let mode be absolute.
Input fields (i.e. textarea elements, and input elements when their
type attribute is in the Text, Search,
Telephone, URL,
or E-mail state) are expected to present an editing
user interface with a directionality that matches the element's 'direction' property.
When the document's character encoding is ISO-8859-8, the following rules are additionally
expected to apply, following those above: [ENCODING]
This block is automatically generated from the Unicode Common Locale Data Repository. [CLDR]
User agents are expected to use either the block below (which will be regularly updated) or to
automatically generate their own copy directly from the source material. The language codes are
derived from the CLDR file names. The quotes are derived from the delimiter
blocks, with fallback handled as specified in the CLDR documentation.
The article, aside, nav, and section
elements are expected to affect the margins and font size of h1 elements, as well as
h2–h5 elements that follow h1 elements in
hgroup elements, based on the nesting depth. If x is a selector
that matches elements that are either article, aside, nav,
or section elements, then the following rules capture what is expected:
@namespace url(http://www.w3.org/1999/xhtml);
dir, dd, dl, dt, menu, ol, ul { display: block; }
li { display: list-item; }
dir, dl, menu, ol, ul { margin-top: 1em; margin-bottom: 1em; }
dir dir, dir dl, dir menu, dir ol, dir ul,
dl dir, dl dl, dl menu, dl ol, dl ul,
menu dir, menu dl, menu menu, menu ol, menu ul,
ol dir, ol dl, ol menu, ol ol, ol ul,
ul dir, ul dl, ul menu, ul ol, ul ul {
margin-top: 0; margin-bottom: 0;
}
dd { margin-left: 40px; } /* LTR-specific: use 'margin-right' for rtl elements */
dir, menu, ol, ul { padding-left: 40px; } /* LTR-specific: use 'padding-right' for rtl elements */
ol { list-style-type: decimal; }
dir, menu, ul { list-style-type: disc; }
dir dir, dir menu, dir ul,
menu dir, menu menu, menu ul,
ol dir, ol menu, ol ul,
ul dir, ul menu, ul ul {
list-style-type: circle;
}
dir dir dir, dir dir menu, dir dir ul,
dir menu dir, dir menu menu, dir menu ul,
dir ol dir, dir ol menu, dir ol ul,
dir ul dir, dir ul menu, dir ul ul,
menu dir dir, menu dir menu, menu dir ul,
menu menu dir, menu menu menu, menu menu ul,
menu ol dir, menu ol menu, menu ol ul,
menu ul dir, menu ul menu, menu ul ul,
ol dir dir, ol dir menu, ol dir ul,
ol menu dir, ol menu menu, ol menu ul,
ol ol dir, ol ol menu, ol ol ul,
ol ul dir, ol ul menu, ol ul ul,
ul dir dir, ul dir menu, ul dir ul,
ul menu dir, ul menu menu, ul menu ul,
ul ol dir, ul ol menu, ul ol ul,
ul ul dir, ul ul menu, ul ul ul {
list-style-type: square;
}
When rendering li elements, non-CSS user agents are expected to use the
ordinal value of the li element to render the counter in the list item
marker.
This specification does not yet define the
CSS-specific rules for rendering li elements, because CSS doesn't yet provide
sufficient hooks for this purpose.
For the purposes of the CSS table model, the col element is expected to be treated
as if it was present as many times as its span attribute specifies.
For the purposes of the CSS table model, the colgroup element, if it contains no
col element, is expected to be treated as if it had as many such children as its
span attribute specifies.
For the purposes of the CSS table model, the colspan and
rowspan attributes on td and th
elements are expected to provide the
special knowledge regarding cells spanning rows and columns.
In HTML documents, the user agent is expected to force the 'display' property of
form elements that are children of table, thead,
tbody, tfoot, or tr elements to compute to 'none',
irrespective of CSS rules.
The caption element unless specified otherwise below, and the thead,
tbody, tfoot, tr, td, and th
elements when they have an align attribute whose value is an
ASCII case-insensitive match for either the string "center" or
the string "middle", are expected to center text within themselves, as if
they had their 'text-align' property set to 'center' in a presentational hint, and to align descendants to the center.
User agents are expected to have a rule in their user agent stylesheet that matches
th elements that have a parent node whose computed value for the 'text-align'
property is its initial value, whose declaration block consists of just a single declaration that
sets the 'text-align' property to the value 'center'.
When a table, thead, tbody, tfoot,
tr, td, or th element has a background attribute set to a non-empty value, the new value is
expected to be resolved relative to the element, and if this is
successful, the user agent is expected to treat the attribute as a presentational hint setting the element's 'background-image' property to the
resulting absolute URL.
When a table, thead, tbody, tfoot,
tr, td, or th element has a bgcolor
attribute set, the new value is expected to be parsed using the rules for parsing a legacy
color value, and if that does not return an error, the user agent is expected to treat the
attribute as a presentational hint setting the element's
'background-color' property to the resulting color.
When a table element has a bordercolor
attribute, its value is expected to be parsed using the rules for parsing a legacy color
value, and if that does not return an error, the user agent is expected to treat the
attribute as a presentational hint setting the element's
'border-top-color', 'border-right-color', 'border-bottom-color', and 'border-right-color'
properties to the resulting color.
The table element's border attribute maps to the pixel length properties
'border-top-width', 'border-right-width', 'border-bottom-width', 'border-left-width' on the
element. If the attribute is present but parsing the attribute's value using the rules for
parsing non-negative integers generates an error, a default value of 1px is expected to be
used for that property instead.
Rules marked "only if border is not equivalent to zero"
in the CSS block above is expected to only be applied if the border attribute mentioned in the selectors for the rule is not
only present but, when parsed using the rules for parsing non-negative integers, is
also found to have a value other than zero or to generate an error.
In quirks mode, a td element or a th element that has a
nowrap attribute but also has a width attribute whose value, when parsed using the rules for
parsing dimension values, is found to be a length (not an error or a number classified as a
percentage), is expected to have a presentational hint
setting the element's 'white-space' property to 'normal', overriding the rule in the CSS block
above that sets it to 'nowrap'.
User agents are expected to render sorting interface th elements in such a manner as to indicate that
activating the elements will cause the table to be sorted.
10.3.10 Margin collapsing quirks
A node is substantial if it is a text node
that is not inter-element whitespace, or if it is an element node.
A node is blank if it is an element that contains no
substantial nodes.
In quirks mode, any element
with default margins that is the child of a body, td, or
th element and has no substantial
previous siblings is expected to have a user-agent level style sheet rule that sets its
'margin-top' property to zero.
In quirks mode, any element
with default margins that is the child of a body, td, or
th element, has no substantial
previous siblings, and is blank, is expected to have
a user-agent level style sheet rule that sets its 'margin-bottom' property to zero also.
In quirks mode, any element
with default margins that is the child of a td or th element, has
no substantial following siblings, and is blank, is expected to have a user-agent level style sheet
rule that sets its 'margin-top' property to zero.
In quirks mode, any p element that is the child of a td
or th element and has no substantial following siblings, is expected to have a
user-agent level style sheet rule that sets its 'margin-bottom' property to zero.
Each kind of form control is also given a specific default binding, as described in subsequent
sections, which implements the look and feel of the control.
If an hr element has either a color attribute
or a noshade attribute, and furthermore also has a size attribute, and parsing that attribute's value using the
rules for parsing non-negative integers doesn't generate an error, then the user
agent is expected to use the parsed value divided by two as a pixel length for
presentational hints for the properties 'border-top-width', 'border-right-width',
'border-bottom-width', and 'border-left-width' on the element.
Otherwise, if an hr element has neither a color
attribute nor a noshade attribute, but does have a size attribute, and parsing that attribute's value using the
rules for parsing non-negative integers doesn't generate an error, then: if the
parsed value is one, then the user agent is expected to use the attribute as a presentational hint setting the element's
'border-bottom-width' to 0; otherwise, if the parsed value is greater than one, then the user
agent is expected to use the parsed value minus two as a pixel length for presentational
hints for the 'height' property on the element.
When an hr element has a color attribute, its
value is expected to be parsed using the rules for parsing a legacy color value, and
if that does not return an error, the user agent is expected to treat the attribute as a presentational hint setting the element's 'color' property to
the resulting color.
The fieldset element is expected to establish a new block formatting context.
If the fieldset element has a child that matches the conditions in the list below,
then the first such child is the fieldset element's rendered legend:
The child is not out-of-flow (e.g. not absolutely positioned or floated).
The child is generating a box (e.g. it is not 'display:none').
A fieldset element's rendered legend, if any, is expected to be
rendered over the top border edge of the fieldset element as a 'block' box
(overriding any explicit 'display' value). In the absence of an explicit width, the box should
shrink-wrap. If the legend element in question has an align attribute, and its value is an ASCII
case-insensitive match for one of the strings in the first column of the following table,
then the legend is expected to be rendered horizontally aligned over the border edge
in the position given in the corresponding cell on the same row in the second column. If the
attribute is absent or has a value that doesn't match any of the cases in the table, then the
position is expected to be on the right if the 'direction' property on this element has a computed
value of 'rtl', and on the left otherwise.
Attribute value
Alignment position
left
On the left
right
On the right
center
In the middle
10.4 Replaced elements
10.4.1 Embedded content
The embed, iframe, and video elements are expected to be
treated as replaced elements.
A canvas element that representsembedded content is
expected to be treated as a replaced element; the contents of such elements are the element's
bitmap, if any, or else a transparent black bitmap with the same intrinsic dimensions as the
element. Other canvas elements are expected to be treated as ordinary elements in the
rendering model.
An object element that represents an image, plugin, or nested
browsing context is expected to be treated as a replaced element. Other object
elements are expected to be treated as ordinary elements in the rendering model.
An applet element that represents a plugin is expected
to be treated as a replaced element. Other applet elements are expected to be treated
as ordinary elements in the rendering model.
The audio element, when it is exposing a user interface, is expected to be treated as a replaced element about one
line high, as wide as is necessary to expose the user agent's user interface features. When an
audio element is not exposing a
user interface, the user agent is expected to force its 'display' property to compute to
'none', irrespective of CSS rules.
Whether a video element is exposing a user interface is not expected to affect the size of the rendering;
controls are expected to be overlaid above the page content without causing any layout changes,
and are expected to disappear when the user does not need them.
When a video element represents a poster frame or frame of video, the poster frame
or frame of video is expected to be rendered at the largest size that maintains the aspect ratio
of that poster frame or frame of video without being taller or wider than the video
element itself, and is expected to be centered in the video element.
User agents are expected to render img elements and input elements
whose type attributes are in the Image Button state, according to the first applicable rules
from the following list:
The user agent is expected to treat the element as a replaced element and render the image
according to the rules for doing so defined in CSS.
If the element does not represent an image, but the element
already has intrinsic dimensions (e.g. from the dimension attributes or CSS rules),
and either:
the user agent has reason to believe that the image will become available and be rendered in due
course, or
The user agent is expected to treat the element as a replaced element whose content is the
text that the element represents, if any, optionally alongside an icon indicating that the image
is being obtained (if applicable). For input elements, the element is expected to
appear button-like to indicate that the element is a button.
If the element is an img element that represents some text and the
user agent does not expect this to change
The user agent is expected to treat the element as a non-replaced phrasing element whose
content is the text, optionally with an icon indicating that an image is missing, so that the
user can request the image be displayed or investigate why it is not rendering. In non-graphical
contexts, such an icon should be omitted.
If the element is an img element that represents nothing and the
user agent does not expect this to change
The user agent is expected to treat the element as an empty inline element. (In the absence
of further styles, this will cause the element to essentially not be rendered.)
If the element is an input element that does not represent an image and the user agent does not expect this to change
The user agent is expected to treat the element as a replaced element consisting of a button
whose content is the element's alternative text. The intrinsic dimensions of the button are
expected to be about one line in height and whatever width is necessary to render the text on one
line.
The icons mentioned above are expected to be relatively small so as not to disrupt most text
but be easily clickable. In a visual environment, for instance, icons could be 16 pixels by 16
pixels square, or 1em by 1em if the images are scalable. In an audio environment, the icon could
be a short bleep. The icons are intended to indicate to the user that they can be used to get to
whatever options the UA provides for images, and, where appropriate, are expected to provide
access to the context menu that would have come up if the user interacted with the actual
image.
All animated images with the same absolute URL and the same image data are
expected to be rendered synchronised to the same timeline as a group, with the timeline starting
at the time of the least recent addition to the group.
In other words, the animation loop of an animated image is restarted each time
another image with the same absolute URL and image data begins to animate, e.g. after
being inserted into the document.
The following CSS rules are expected to apply when the Document is in quirks
mode:
When an applet, embed, iframe, img, or
object element, or an input element whose type attribute is in the Image
Button state, has an align attribute whose value is an
ASCII case-insensitive match for the string "center" or the
string "middle", the user agent is expected to act as if the element's
'vertical-align' property was set to a value that aligns the vertical middle of the element with
the parent element's baseline.
When an img element, object element, or input element
with a type attribute in the Image Button state has a border attribute whose value, when parsed using the rules for
parsing non-negative integers, is found to be a number greater than zero, the user agent is
expected to use the parsed value for eight presentational hints: four setting the
parsed value as a pixel length for the element's 'border-top-width', 'border-right-width',
'border-bottom-width', and 'border-left-width' properties, and four setting the element's
'border-top-style', 'border-right-style', 'border-bottom-style', and 'border-left-style'
properties to the value 'solid'.
Shapes on an image map are expected to act, for the purpose of the CSS cascade, as
elements independent of the original area element that happen to match the same style
rules but inherit from the img or object element.
For the purposes of the rendering, only the 'cursor' property is expected to have any effect on
the shape.
Thus, for example, if an area element has a style attribute that sets the 'cursor' property to 'help', then when the
user designates that shape, the cursor would change to a Help cursor.
Similarly, if an area element had a CSS rule that set its 'cursor'
property to 'inherit' (or if no rule setting the 'cursor' property matched the element at all),
the shape's cursor would be inherited from the img or object element of
the image map, not from the parent of the area element.
10.5 Bindings
10.5.1 Introduction
A number of elements have their rendering defined in terms of the 'binding' property. [BECSS]
The CSS snippets below set the 'binding' property to a user-agent-defined value, represented
below by keywords like button. The rules then described for
these bindings are only expected to apply if the element's 'binding' property has not been
overridden (e.g. by the author) to have another value.
Exactly how the bindings are implemented is not specified by this specification. User agents
are encouraged to make their bindings set the 'appearance' CSS property appropriately to achieve
platform-native appearances for widgets, and are expected to implement any relevant animations,
etc, that are appropriate for the platform. [CSSUI]
When the button binding applies to a button element, the element
is expected to render as an 'inline-block' box rendered as a button whose contents are the
contents of the element.
When the button element's type attribute is
in the Menu state, the user agent is expected to
indicate that activating the element will display a menu, e.g. by displaying a down-pointing
triangle after the button's label.
When the details binding applies to a details element, the element
is expected to render as a 'block' box with its 'padding-left' property set to '40px' for
left-to-right elements (LTR-specific) and with its 'padding-right' property set to
'40px' for right-to-left elements. The element's shadow tree is expected to take the element's
first child summary element, if any, and place it in a first 'block' box container,
and then take the element's remaining descendants, if any, and place them in a second 'block' box
container.
The first container is expected to contain at least one line box, and that line box is expected
to contain a disclosure widget (typically a triangle), horizontally positioned within the left
padding of the details element. That widget is expected to allow the user to request
that the details be shown or hidden.
The second container is expected to have its 'overflow' property set to 'hidden'. When the
details element does not have an open
attribute, this second container is expected to be removed from the rendering.
@namespace url(http://www.w3.org/1999/xhtml);
input { binding: input-textfield; }
input[type=password i] { binding: input-password; }
/* later rules override this for other values of type="" */
When the input-textfield binding applies to an input element whose
type attribute is in the Text, Search,
Telephone, URL,
or E-mail state, the element is expected to render as
an 'inline-block' box rendered as a text field.
When the input-password binding applies to an input element whose
type attribute is in the Password state, the element is expected to render as an
'inline-block' box rendered as a text field whose contents are obscured.
If these text fields provide a text selection, then, when the user changes the currect
selection in such a binding, the user agent is expected to queue a task to fire
a simple event that bubbles named select at the element,
using the user interaction task source as the task source.
If an input element whose type attribute is
in one of the above states has a size attribute, and parsing
that attribute's value using the rules for parsing non-negative integers doesn't
generate an error, then the user agent is expected to use the attribute as a presentational hint for the 'width' property on the element,
with the value obtained from applying the converting a character width to pixels
algorithm to the value of the attribute.
If an input element whose type attribute is
in one of the above states does not have a size
attribute, then the user agent is expected to act as if it had a user-agent-level style sheet rule
setting the 'width' property on the element to the value obtained from applying the
converting a character width to pixels algorithm to the number 20.
The converting a character width to pixels algorithm returns (size-1)×avg + max,
where size is the character width to convert, avg is the
average character width of the primary font for the element for which the algorithm is being run,
in pixels, and max is the maximum character width of that same font, also in
pixels. (The element's 'letter-spacing' property does not affect the result.)
When the input-textfield binding applies to an element, the 'line-height'
property, if it has a computed value equivalent to a value that is less than 1.0, must have a used
value of 1.0.
10.5.5 The input element as domain-specific widgets
When the input-datetime binding applies to an input element whose
type attribute is in the Date and Time state, the element is expected to render as
an 'inline-block' box depicting a Date and Time control.
When the input-date binding applies to an input element whose
type attribute is in the Date state, the element is expected to render as an
'inline-block' box depicting a Date control.
When the input-month binding applies to an input element whose
type attribute is in the Month state, the element is expected to render as an
'inline-block' box depicting a Month control.
When the input-week binding applies to an input element whose
type attribute is in the Week state, the element is expected to render as an
'inline-block' box depicting a Week control.
When the input-time binding applies to an input element whose
type attribute is in the Time state, the element is expected to render as an
'inline-block' box depicting a Time control.
When the input-number binding applies to an input element whose
type attribute is in the Number state, the element is expected to render as an
'inline-block' box depicting a Number control.
These controls are all expected to be about one line high, and about as wide as necessary to
show the widest possible value.
When the input-range binding applies to an input element whose
type attribute is in the Range state, the element is expected to render as an
'inline-block' box depicting a slider control.
When the control is wider than it is tall (or square), the control is expected to be a
horizontal slider, with the lowest value on the right if the 'direction' property on this element
has a computed value of 'rtl', and on the left otherwise. When the control is taller than it is
wide, it is expected to be a vertical slider, with the lowest value on the bottom.
Predefined suggested values (provided by the list
attribute) are expected to be shown as tick marks on the slider, which the slider can snap to.
User agents are expected to use the used value of the 'direction' property on the element to
determine the direction in which the slider operates. Typically, a left-to-right ('ltr')
horizontal control would have the lowest value on the left and the highest value on the right, and
vice versa.
When the input-color binding applies to an input element whose
type attribute is in the Color state, the element is expected to render as an
'inline-block' box depicting a color well, which, when activated, provides the user with a color
picker (e.g. a color wheel or color palette) from which the color can be changed.
Predefined suggested values (provided by the list
attribute) are expected to be shown in the color picker interface, not on the color well
itself.
10.5.8 The input element as a checkbox and radio button widgets
When the input-checkbox binding applies to an input element whose
type attribute is in the Checkbox state, the element is expected to render as an
'inline-block' box containing a single checkbox control, with no label.
When the input-radio binding applies to an input element whose
type attribute is in the Radio Button state, the element is expected to render as an
'inline-block' box containing a single radio button control, with no label.
When the input-file binding applies to an input element whose
type attribute is in the File Upload state, the element is expected to render as an
'inline-block' box containing a span of text giving the file name(s) of the selected files, if any, followed by a button that,
when activated, provides the user with a file picker from which the selection can be changed.
When the input-button binding applies to an input element whose
type attribute is in the Submit Button, Reset
Button, or Button state, the element is
expected to render as an 'inline-block' box rendered as a button, about one line high, containing
the contents of the element's value attribute, if any, or
text derived from the element's type attribute in a
user-agent-defined (and probably locale-specific) fashion, if not.
When the marquee binding applies to a marquee element, while the
element is turned on, the element is expected to render in
an animated fashion according to its attributes as follows:
If the element's behavior attribute is in the
scroll state
Slide the contents of the element in the direction described by the direction attribute as defined below, such that it begins
off the start side of the marquee, and ends flush with the inner end side.
For example, if the direction
attribute is left (the default), then the
contents would start such that their left edge are off the side of the right edge of the
marquee's content area, and the contents would then slide up to the point where the
left edge of the contents are flush with the left inner edge of the marquee's
content area.
Once the animation has ended, the user agent is expected to increment the marquee
current loop index. If the element is still turned
on after this, then the user agent is expected to restart the animation.
If the element's behavior attribute is in the
slide state
Slide the contents of the element in the direction described by the direction attribute as defined below, such that it begins
off the start side of the marquee, and ends off the end side of the
marquee.
For example, if the direction
attribute is left (the default), then the
contents would start such that their left edge are off the side of the right edge of the
marquee's content area, and the contents would then slide up to the point where the
right edge of the contents are flush with the left inner edge of the
marquee's content area.
Once the animation has ended, the user agent is expected to increment the marquee
current loop index. If the element is still turned
on after this, then the user agent is expected to restart the animation.
When the marquee current loop index is even (or zero), slide the contents of the
element in the direction described by the direction
attribute as defined below, such that it begins flush with the start side of the
marquee, and ends flush with the end side of the marquee.
When the marquee current loop index is odd, slide the contents of the element in
the opposite direction than that described by the direction attribute as defined below, such that it begins
flush with the end side of the marquee, and ends flush with the start side of the
marquee.
For example, if the direction
attribute is left (the default), then the
contents would with their right edge flush with the right inner edge of the
marquee's content area, and the contents would then slide up to the point where the
left edge of the contents are flush with the left inner edge of the
marquee's content area.
Once the animation has ended, the user agent is expected to increment the marquee
current loop index. If the element is still turned
on after this, then the user agent is expected to continue the animation.
The direction attribute has the meanings described
in the following table:
In any case, the animation should proceed such that there is a delay given by the marquee
scroll interval between each frame, and such that the content moves at most the distance
given by the marquee scroll distance with each frame.
When a marquee element has a bgcolor
attribute set, the value is expected to be parsed using the rules for parsing a legacy color
value, and if that does not return an error, the user agent is expected to treat the
attribute as a presentational hint setting the element's
'background-color' property to the resulting color.
@namespace url(http://www.w3.org/1999/xhtml);
meter { binding: meter; }
When the meter binding applies to a meter element, the element is
expected to render as an 'inline-block' box with a 'height' of '1em' and a 'width' of '5em', a
'vertical-align' of '-0.2em', and with its contents depicting a gauge.
When the element is wider than it is tall (or square), the depiction is expected to be of a
horizontal gauge, with the minimum value on the right if the 'direction' property on this element
has a computed value of 'rtl', and on the left otherwise. When the element is taller than it is
wide, it is expected to depict a vertical gauge, with the minimum value on the bottom.
User agents are expected to use a presentation consistent with platform conventions for gauges,
if any.
Requirements for what must be depicted in the gauge are included in the definition
of the meter element.
When the progress binding applies to a progress element, the
element is expected to render as an 'inline-block' box with a 'height' of '1em' and a 'width' of
'10em', and a 'vertical-align' of '-0.2em'.
When the
element is wider than it is tall, the element is expected to be depicted as a horizontal progress
bar, with the start on the right and the end on the left if the 'direction' property on this
element has a computed value of 'rtl', and with the start on the left and the end on the right
otherwise. When the element is taller than it is wide, it is expected to depicted as a vertical
progress bar, with the lowest value on the bottom. When the element is square, it is expected to
be depicted as a direction-independent progress widget (e.g. a circular progress ring).
User agents are expected to use a presentation consistent with platform conventions for
progress bars. In particular, user agents are expected to use different presentations for
determinate and indeterminate progress bars. User agents are also expected to vary the
presentation based on the dimensions of the element.
For example, on some platforms for showing indeterminate progress there is an
asynchronous progress indicator with square dimensions, which could be used when the element is
square, and an indeterminate progress bar, which could be used when the element is wide.
Requirements for how to determine if the progress bar is determinate or
indeterminate, and what progress a determinate progress bar is to show, are included in the
definition of the progress element.
When the select binding applies to a select element whose multiple attribute is present, the element is expected to
render as a multi-select list box.
When the select binding applies to a select element whose multiple attribute is absent, and the element's display size is greater than 1, the element is expected to
render as a single-select list box.
When the element renders as a list box, it is expected to render as an 'inline-block' box whose
'height' is the height necessary to contain as many rows for items as given by the element's display size, or four rows if the attribute is absent, and
whose 'width' is the width of the select's labels plus the width of a
scrollbar.
When the select binding applies to a select element whose multiple attribute is absent, and the element's display size is 1, the element is expected to render as a
one-line drop down box whose width is the width of the select's
labels.
In either case (list box or drop-down box), the element's items are expected to be the
element's list of options, with the element's
optgroup element children providing headers for groups of options where
applicable.
An optgroup element is expected to be rendered by displaying the element's label attribute.
An option element is expected to be rendered by displaying the element's label, indented under its optgroup element if it
has one.
The width of the select's labels is the wider of the width necessary to
render the widest optgroup, and the width necessary to render the widest
option element in the element's list of
options (including its indent, if any).
If a select element contains a placeholder label option, the user
agent is expected to render that option in a manner that conveys that it is a label,
rather than a valid option of the control. This can include preventing the placeholder label
option from being explicitly selected by the user. When the placeholder label
option's selectedness is true, the control
is expected to be displayed in a fashion that indicates that no valid option is currently
selected.
User agents are expected to render the labels in a select in such a manner that
any alignment remains consistent whether the label is being displayed as part of the page or in a
menu control.
When the textarea binding applies to a textarea element, the
element is expected to render as an 'inline-block' box rendered as a multiline text field. If this
text field provides a selection, then, when the user changes the currect selection in such a
binding, the user agent is expected to queue a task to fire a simple
event that bubbles named select at the element, using
the user interaction task source as the task source.
If the element has a cols attribute, and parsing that
attribute's value using the rules for parsing non-negative integers doesn't generate
an error, then the user agent is expected to use the attribute as a presentational hint for the 'width' property on the element, with the value being
the textarea effective width (as defined below). Otherwise, the user agent is
expected to act as if it had a user-agent-level style sheet rule setting the 'width' property on
the element to the textarea effective width.
The textarea effective width of a textarea element is size×avg + sbw, where size is the element's character width, avg is the average
character width of the primary font of the element, in CSS pixels, and sbw is
the width of a scroll bar, in CSS pixels. (The element's 'letter-spacing' property does not affect
the result.)
If the element has a rows attribute, and parsing that
attribute's value using the rules for parsing non-negative integers doesn't generate
an error, then the user agent is expected to use the attribute as a presentational hint for the 'height' property on the element, with the value being
the textarea effective height (as defined below). Otherwise, the user agent is
expected to act as if it had a user-agent-level style sheet rule setting the 'height' property on
the element to the textarea effective height.
The textarea effective height of a textarea element is the height in
CSS pixels of the number of lines specified the element's character height, plus the height of a scrollbar in CSS
pixels.
User agents are expected to apply the 'white-space' CSS property to textarea
elements. For historical reasons, if the element has a wrap attribute whose value is an ASCII
case-insensitive match for the string "off",
then the user agent is expected to treat the attribute as a presentational hint setting the element's 'white-space' property to 'pre'.
When the keygen binding applies to a keygen element, the element
is expected to render as an 'inline-block' box containing a user interface to configure the key
pair to be generated.
10.6 Frames and framesets
User agent are expected to render frameset elements as a box with the height and
width of the viewport, with a surface rendered according to the following layout algorithm:
The cols and rows variables are lists of zero or more
pairs consisting of a number and a unit, the unit being one of percentage,
relative, and absolute.
Use the rules for parsing a list of dimensions to parse the value of the
element's cols attribute, if there is one. Let cols be the result, or an empty list if there is no such attribute.
Use the rules for parsing a list of dimensions to parse the value of the
element's rows attribute, if there is one. Let rows be the result, or an empty list if there is no such attribute.
For any of the entries in cols or rows that have the
number zero and the unit relative, change the entry's number to one.
If cols has no entries, then add a single entry consisting of the value 1
and the unit relative to cols.
If rows has no entries, then add a single entry consisting of the value 1
and the unit relative to rows.
Invoke the algorithm defined below to convert a list of dimensions to a list of pixel
values using cols as the input list, and the width of the surface
that the frameset is being rendered into, in CSS pixels, as the input dimension.
Let sized cols be the resulting list.
Invoke the algorithm defined below to convert a list of dimensions to a list of pixel
values using rows as the input list, and the height of the surface
that the frameset is being rendered into, in CSS pixels, as the input dimension.
Let sized rows be the resulting list.
Split the surface into a grid of w×h rectangles, where w is the number of entries in sized cols and h is the number of entries in sized rows.
Size the columns so that each column in the grid is as many CSS pixels wide as the
corresponding entry in the sized cols list.
Size the rows so that each row in the grid is as many CSS pixels high as the corresponding
entry in the sized rows list.
Let children be the list of frame and frameset
elements that are children of the frameset element for which the algorithm was
invoked.
For each row of the grid of rectangles created in the previous step, from top to bottom, run
these substeps:
For each rectangle in the row, from left to right, run these substeps:
If there are any elements left in children, take the first element in
the list, and assign it to the rectangle.
If this is a frameset element, then recurse the entire frameset
layout algorithm for that frameset element, with the rectangle as the
surface.
For each rectangle, if there is an element assigned to that rectangle, and that element
has a border, draw an inner set of borders around that rectangle, using the
element's frame border color.
For each (visible) border that does not abut a rectangle that is assigned a
frame element with a noresize attribute
(including rectangles in further nested frameset elements), the user agent is
expected to allow the user to move the border, resizing the rectangles within, keeping the
proportions of any nested frameset grids.
A frameset or frame element has a border if the
following algorithm returns true:
If the element has a frameborder attribute
whose value is not the empty string and whose first character is either a "1" (U+0031)
character, a "y" (U+0079) character, or a "Y" (U+0059) character, then return true.
Otherwise, if the element has a frameborder
attribute, return false.
Otherwise, if the element has a parent element that is a frameset element,
then return true if that element has a border, and false if it does
not.
Otherwise, return true.
The frame border color of a frameset or frame element is
the color obtained from the following algorithm:
If the element has a bordercolor attribute,
and applying the rules for parsing a legacy color value to that attribute's value
does not result in an error, then return the color so obtained.
Otherwise, if the element has a parent element that is a frameset element,
then return the frame border color of that element.
Otherwise, return gray.
The algorithm to convert a list of dimensions to a list of pixel values consists of
the following steps:
Let input list be the list of numbers and units passed to the
algorithm.
Let output list be a list of numbers the same length as input list, all zero.
Entries in output list correspond to the entries in input
list that have the same position.
Let input dimension be the size passed to the algorithm.
Let count percentage be the number of entries in input
list whose unit is percentage.
Let total percentage be the sum of all the numbers in input
list whose unit is percentage.
Let count relative be the number of entries in input
list whose unit is relative.
Let total relative be the sum of all the numbers in input
list whose unit is relative.
Let count absolute be the number of entries in input
list whose unit is absolute.
Let total absolute be the sum of all the numbers in input
list whose unit is absolute.
Let remaining space be the value of input
dimension.
If total absolute is greater than remaining space,
then for each entry in input list whose unit is absolute, set the
corresponding value in output list to the number of the entry in input list multiplied by remaining space and divided by total absolute. Then, set remaining space to zero.
Otherwise, for each entry in input list whose unit is absolute,
set the corresponding value in output list to the number of the entry in
input list. Then, decrement remaining space by total absolute.
If total percentage multiplied by the input dimension
and divided by 100 is greater than remaining space, then for each entry in
input list whose unit is percentage, set the corresponding value in
output list to the number of the entry in input list
multiplied by remaining space and divided by total
percentage. Then, set remaining space to zero.
Otherwise, for each entry in input list whose unit is percentage,
set the corresponding value in output list to the number of the entry in
input list multiplied by the input dimension and divided
by 100. Then, decrement remaining space by total
percentage multiplied by the input dimension and divided by 100.
For each entry in input list whose unit is relative, set the
corresponding value in output list to the number of the entry in input list multiplied by remaining space and divided by total relative.
Return output list.
User agents working with integer values for frame widths (as opposed to user agents that can
lay frames out with subpixel accuracy) are expected to distribute the remainder first to the last
entry whose unit is relative, then equally (not proportionally) to each entry whose unit is
percentage, then equally (not proportionally) to each entry whose unit is absolute,
and finally, failing all else, to the last entry.
The contents of a frame element that does not have a frameset parent
are expected to be rendered as transparent black; the user agent is expected to not render the
nested browsing context in this case, and that nested browsing context
is expected to have a viewport with zero width and zero height.
User agents may surface hyperlinks created by link
elements in their user interface.
While link elements that create hyperlinks will match the ':link' or ':visited' pseudo-classes, will
react to clicks if visible, and so forth, this does not extend to any browser interface constructs
that expose those same links. Activating a link through the browser's interface, rather than in
the page itself, does not trigger click events and the like.
User agents are expected to expose the advisory information of elements upon user
request, and to make the user aware of the presence of such information.
On interactive graphical systems where the user can use a pointing device, this could take the
form of a tooltip. When the user is unable to use a pointing device, then the user agent is
expected to make the content available in some other fashion, e.g. by making the element a
focusable area and always displaying the advisory information of the currently
focused element, or by showing the advisory information of the elements
under the user's finger on a touch device as the user pans around the screen.
"LF" (U+000A) characters are expected to cause line breaks in the tooltip; "tab" (U+0009) characters are expected to render as a non-zero horizontal shift that
lines up the next glyph with the next tab stop, with tab stops occurring at points that are
multiples of 8 times the width of a U+0020 SPACE character.
For example, a visual user agent could make elements with a title attribute focusable, and could make any focused element with a
title attribute show its tooltip under the element while the
element has focus. This would allow a user to tab around the document to find all the advisory
text.
As another example, a screen reader could provide an audio cue when reading an element with a
tooltip, with an associated key to read the last tooltip for which a cue was played.
10.7.3 Editing hosts
The current text editing caret (i.e. the active range, if it is empty and in an
editing host), if any, is expected to act like an inline replaced element with the
vertical dimensions of the caret and with zero width for the purposes of the CSS rendering
model.
This means that even an empty block can have the caret inside it, and that when
the caret is in such an element, it prevents margins from collapsing through the element.
10.7.4 Text rendered in native user interfaces
User agents are expected to honor the Unicode semantics of text that is exposed in user
interfaces, for example supporting the bidirectional algorithm in text shown in dialogs, title
bars, pop-up menus, and tooltips. Text from the contents of elements is expected to be rendered in
a manner that honors the directionality of the element from which the text was
obtained. Text from attributes is expected to be rendered in a manner that honours the
directionality of the attribute.
Consider the following markup, which has Hebrew text asking for a programming language, the
languages being text for which a left-to-right direction is important given the punctuation in
some of their names:
<p dir="rtl" lang="he">
<label>
בחר שפת תכנות:
<select>
<option dir="ltr">C++</option>
<option dir="ltr">C#</option>
<option dir="ltr">FreePascal</option>
<option dir="ltr">F#</option>
</select>
</label>
</p>
If the select element was rendered as a drop down box, a correct rendering would
ensure that the punctuation was the same both in the drop down, and in the box showing the
current selection.
The directionality of attributes depends on the attribute and on the element's dir attribute, as the following example demonstrates. Consider this
markup:
If the abbr attributes are rendered, e.g. in a tooltip or
other user interface, the first will have a left parenthesis (because the direction is 'ltr'),
the second will have a right parenthesis (because the direction is 'rtl'), and the third will
have a right parenthesis (because the direction is determined from the attribute value
to be 'rtl').
In this case, if the user agent were to expose the data-abbr attribute
in the user interface (e.g. in a debugging environment), the last case would be rendered with a
left parenthesis, because the direction would be determined from the element's
contents.
A string provided by a script (e.g. the argument to window.alert()) is expected to be treated as an independent set of one or
more bidirectional algorithm paragraphs when displayed, as defined by the bidirectional algorithm,
including, for instance, supporting the paragraph-breaking behaviour of "LF" (U+000A)
characters. For the purposes of determining the paragraph level of such text in the bidirectional
algorithm, this specification does not provide a higher-level override of rules P2 and
P3. [BIDI]
When necessary, authors can enforce a particular direction for a given paragraph by starting it
with the Unicode U+200E LEFT-TO-RIGHT MARK or U+200F RIGHT-TO-LEFT MARK characters.
Thus, the following script:
alert('\u05DC\u05DE\u05D3 HTML \u05D4\u05D9\u05D5\u05DD!')
...would always result in a message reading
"למד LMTH היום!"
(not "דמל HTML םויה!"),
regardless of the language of the user agent interface or the
direction of the page or any of its elements.
For a more complex example, consider the following script:
/* Warning: this script does not handle right-to-left scripts correctly */
var s;
if (s = prompt('What is your name?')) {
alert(s + '! Ok, Fred, ' + s + ', and Wilma will get the car.');
}
When the user enters "Kitty", the user agent would alert "Kitty! Ok, Fred,
Kitty, and Wilma will get the car.". However, if the user enters "لا أفهم", then the bidirectional
algorithm will determine that the direction of the paragraph is right-to-left, and so the output
will be the following unintended mess: "لا أفهم! derF ,kO, لا أفهم, rac eht teg lliw amliW dna."
To force an alert that starts with user-provided text (or other text of unknown
directionality) to render left-to-right, the string can be prefixed with a U+200E LEFT-TO-RIGHT
MARK character:
var s;
if (s = prompt('What is your name?')) {
alert('\u200E' + s + '! Ok, Fred, ' + s + ', and Wilma will get the car.');
}
10.8 Print media
User agents are expected to allow the user to request the opportunity to obtain a physical
form (or a representation of a physical form) of a Document. For example,
selecting the option to print a page or convert it to PDF format. [PDF]
When the user actually obtains a physical form (or
a representation of a physical form) of a Document, the user agent is expected to
create a new rendering of the Document for the print media.
10.9 Unstyled XML documents
HTML user agents may, in certain circumstances, find themselves rendering non-HTML documents
that use vocabularies for which they lack any built-in knowledge. This section provides for a way
for user agents to handle such documents in a somewhat useful manner.
A Document is an unstyled document while it matches the following
conditions:
The Document has no author style sheets (whether referenced by HTTP headers, processing instructions, elements like link, inline elements like style, or any other mechanism).
None of the elements in the Document have any registered event listeners.
An unstyled document view is one where the DOM is not rendered according to CSS
(which would, since there are no applicable styles in this context, just result in a wall of
text), but is instead rendered in a manner that is useful for a developer. This could consist of
just showing the Document object's source, maybe with syntax highlighting, or it
could consist of displaying just the DOM tree, or simply a message saying that the page is not a
styled document.
If a Document stops being an unstyled document, then the
conditions above stop applying, and thus a user agent following these requirements will switch to
using the regular CSS rendering.
11.1.1 Warnings for obsolete but conforming features
To ease the transition from HTML4 Transitional documents to the language defined in
this specification, and to discourage certain features that are only allowed in very few
circumstances, conformance checkers must warn the user when the following features are used in a
document. These are generally old obsolete features that have no effect, and are allowed only to
distinguish between likely mistakes (regular conformance errors) and mere vestigial markup or
unusual and discouraged practices (these warnings).
The following features must be categorised as described
above:
The presence of a border attribute on an
img element if its value is the string "0".
The presence of a language attribute on a
script element if its value is an ASCII case-insensitive match for the
string "JavaScript" and if there is no type attribute or there is and its value is an ASCII
case-insensitive match for the string "text/javascript".
The presence of a name attribute on an a
element, if its value is not the empty string.
The presence of a maxlength attribute on an
input element whose type attribute is in the
Number state.
The presence of a size attribute on an
input element whose type attribute is in the
Number state.
Conformance checkers must distinguish between pages that have no conformance errors and have
none of these obsolete features, and pages that have no conformance errors but do have some of
these obsolete features.
For example, a validator could report some pages as "Valid HTML" and others as
"Valid HTML with warnings".
The applet element is a Java-specific variant of the embed element.
The applet element is now obsoleted so that all extension frameworks (Java, .NET,
Flash, etc) are handled in a consistent manner.
When the element matches any of the following conditions, it represents its
contents:
A Java runtime plugin is available but it is disabled.
Otherwise, the user agent should instantiate a Java Language runtime plugin, and
should pass the names and values of all the attributes on the element, in the order they were
added to the element, with the attributes added by the parser being ordered in source order, and
then a parameter named "PARAM" whose value is null, and then all the names and values of parameters given by param elements that are
children of the applet element, in tree order, to the
plugin used. If the plugin supports a scriptable interface, the
HTMLAppletElement object representing the element should expose that interface. The
applet element represents the plugin.
The applet element is unaffected by the CSS 'display' property. The
Java Language runtime is instantiated even if the element is hidden with a 'display:none' CSS
style.
interface HTMLAppletElement : HTMLElement {
attribute DOMString align;
attribute DOMString alt;
attribute DOMString archive;
attribute DOMString code;
attribute DOMString codeBase;
attribute DOMString height;
attribute unsigned long hspace;
attribute DOMString name;
attribute DOMString _object; // the underscore is not part of the identifier
attribute unsigned long vspace;
attribute DOMString width;
};
The align, alt, archive, code, height, hspace, name, object, vspace, and width IDL attributes must reflect the
respective content attributes of the same name. For the purposes of reflection, the
applet element's object content attribute is
defined as containing a URL.
The codeBase IDL attribute must
reflect the codebase content attribute,
which for the purposes of reflection is defined as containing a URL.
11.3.2 The marquee element
The marquee element is a presentational element that animates content. CSS
transitions and animations are a more appropriate mechanism. [CSSANIMATIONS][CSSTRANSITIONS]
A marquee element has a marquee scroll interval, which is obtained as
follows:
If the element has a scrolldelay attribute,
and parsing its value using the rules for parsing non-negative integers does not
return an error, then let delay be the parsed value. Otherwise, let delay be 85.
If the element does not have a truespeed
attribute, and the delay value is less than 60, then let delay be 60 instead.
A marquee element has a marquee scroll distance, which, if the element
has a scrollamount attribute, and parsing its value
using the rules for parsing non-negative integers does not return an error, is the
parsed value interpreted in CSS pixels, and otherwise is 6 CSS pixels.
A marquee element has a marquee loop count, which, if the element has a
loop attribute, and parsing its value using the rules
for parsing integers does not return an error or a number less than 1, is the parsed value,
and otherwise is −1.
The loop IDL attribute, on getting, must
return the element's marquee loop count; and on setting, if the new value is
different than the element's marquee loop count and either greater than zero or equal
to −1, must set the element's loop content attribute
(adding it if necessary) to the valid integer that represents the new value. (Other
values are ignored.)
A marquee element also has a marquee current loop index, which is zero
when the element is created.
The rendering layer will occasionally increment the marquee current loop index,
which must cause the following steps to be run:
When the browsing context is created, if a name attribute
is present, the browsing context name must be set to the value of this attribute;
otherwise, the browsing context name must be set to the empty string.
Whenever the name attribute is set, the nested
browsing context's name must be changed to
the new value. If the attribute is removed, the browsing context name must be set to
the empty string.
The name, scrolling, and src IDL attributes of the frame element must
reflect the respective content attributes of the same name. For the purposes of
reflection, the frame element's src content
attribute is defined as containing a URL.
The frameBorder IDL attribute of the
frame element must reflect the element's frameborder content attribute.
The longDesc IDL attribute of the
frame element must reflect the element's longdesc content attribute, which for the purposes of
reflection is defined as containing a URL.
The noResize IDL attribute of the
frame element must reflect the element's noresize content attribute.
The text IDL attribute of the body
element must reflect the element's text content
attribute.
The link IDL attribute of the body
element must reflect the element's link content
attribute.
The aLink IDL attribute of the body
element must reflect the element's alink content
attribute.
The vLink IDL attribute of the body
element must reflect the element's vlink content
attribute.
The bgColor IDL attribute of the
body element must reflect the element's bgcolor content attribute.
The background IDL attribute of the
body element must reflect the element's background content attribute. (The background content is not defined to contain a
URL, despite rules regarding its handling in the rendering section above.)
The align IDL attribute of the
h1–h6 elements must reflect the content attribute of
the same name.
The profile IDL attribute on
head elements (with the HTMLHeadElement interface) is intentionally
omitted. Unless so required by another applicable
specification, implementations would therefore not support this attribute. (It is mentioned
here as it was defined in a previous version of the DOM specifications.)
The align and scrolling IDL attributes of the
iframe element must reflect the respective content attributes of the
same name.
The frameBorder IDL attribute of the
iframe element must reflect the element's frameborder content attribute.
The longDesc IDL attribute of the
iframe element must reflect the element's longdesc content attribute, which for the purposes of
reflection is defined as containing a URL.
The marginHeight IDL attribute of the
iframe element must reflect the element's marginheight content attribute.
The marginWidth IDL attribute of the
iframe element must reflect the element's marginwidth content attribute.
The name, align, border, hspace, and vspace IDL attributes of the img element
must reflect the respective content attributes of the same name.
The longDesc IDL attribute of the
img element must reflect the element's longdesc content attribute, which for the purposes of reflection
is defined as containing a URL.
The lowsrc IDL attribute of the img
element must reflect the element's lowsrc
content attribute, which for the purposes of reflection is defined as containing a
URL.
User agents may treat the scheme content attribute on the
meta element as an extension of the element's name content attribute when processing a meta element
with a name attribute whose value is one that the user agent
recognizes as supporting the scheme attribute.
User agents are encouraged to ignore the scheme attribute
and instead process the value given to the metadata name as if it had been specified for each
expected value of the scheme attribute.
For example, if the user agent acts on meta elements with name attributes having the value "eGMS.subject.keyword", and knows
that the scheme attribute is used with this metadata name,
then it could take the scheme attribute into account,
acting as if it was an extension of the name attribute. Thus
the following two meta elements could be treated as two elements giving values for
two different metadata names, one consisting of a combination of "eGMS.subject.keyword" and
"LGCL", and the other consisting of a combination of "eGMS.subject.keyword" and "ORLY":
<!-- this markup is invalid -->
<meta name="eGMS.subject.keyword" scheme="LGCL" content="Abandoned vehicles">
<meta name="eGMS.subject.keyword" scheme="ORLY" content="Mah car: kthxbye">
The suggested processing of this markup, however, would be equivalent to the following:
The align, archive, border, code, declare, hspace, standby, and vspace IDL attributes of the object
element must reflect the respective content attributes of the same name.
The codeBase IDL attribute of the
object element must reflect the element's codebase content attribute, which for the purposes of
reflection is defined as containing a URL.
The codeType IDL attribute of the
object element must reflect the element's codetype content attribute.
The type IDL
attribute of the param element must
reflect the content attribute of the same name.
The valueType
IDL attribute of the param element must
reflect the element's valuetype content attribute.
User agents must treat plaintext elements in a manner equivalent to
pre elements in terms of semantics and for purposes of rendering. (The parser has
special behavior for this element, though.)
The align, border, frame, summary, rules, and width, IDL attributes of the table element
must reflect the respective content attributes of the same name.
The bgColor IDL attribute of the
table element must reflect the element's bgcolor content attribute.
The cellPadding IDL attribute of the
table element must reflect the element's cellpadding content attribute.
The cellSpacing IDL attribute of the
table element must reflect the element's cellspacing content attribute.
The compact and type IDL attributes of the ul element must
reflect the respective content attributes of the same name.
User agents must treat xmp elements in a manner equivalent to pre
elements in terms of semantics and for purposes of rendering. (The parser has special behavior for
this element though.)
The attributes of the Document object listed in the first column of the following
table must reflect the content attribute on the body element with the
name given in the corresponding cell in the second column on the same row, if the body
element is a body element (as opposed to a frameset element).
When there is no body element or if it is a
frameset element, the attributes must instead return the empty string on getting and
do nothing on setting.
The anchors attribute must return an
HTMLCollection rooted at the Document node, whose filter matches only
a elements with name attributes.
The applets attribute must return an
HTMLCollection rooted at the Document node, whose filter matches only
applet elements.
The clear(), captureEvents(), and releaseEvents() methods must do nothing.
The all attribute must return an
HTMLAllCollection rooted at the Document node, whose filter matches all
elements.
The object returned for all has several unusual
behaviors:
The user agent must act as if the ToBoolean() operator in JavaScript converts the object
returned for all to the false value.
The user agent must act as if, for the purposes of the == and != operators in JavaScript, the object returned for all compares as equal to the undefined and
null values. (Comparisons using the === operator, and
comparisons to other values such as strings or objects, are unaffected.)
The user agent must act such that the typeof operator in JavaScript
returns the string undefined when applied to the object returned for all.
These requirements are a willful violation of the JavaScript
specification current at the time of writing (ECMAScript edition 5). The JavaScript specification
requires that the ToBoolean() operator convert all objects to the true value, and does not have
provisions for objects acting as if they were undefined for the purposes of
certain operators. This violation is motivated by a desire for compatibility with two classes of
legacy content: one that uses the presence of document.all
as a way to detect legacy user agents, and one that only supports those legacy user agents and
uses the document.all object without testing for its
presence first. [ECMA262]
(Non-normative) Computer Graphics: Principles and Practice in C, Second Edition, J. Foley, A. van Dam, S. Feiner, J. Hughes. Addison-Wesley. ISBN 0-201-84840-6.
[GREGORIAN]
(Non-normative) Inter Gravissimas, A. Lilius, C. Clavius. Gregory XIII Papal Bull, February 1582.
Thanks to Tim Berners-Lee for inventing HTML, without which none of this would exist.
Thanks to
Aankhen,
Aaron Boodman,
Aaron Leventhal,
Adam Barth,
Adam de Boor,
Adam Hepton,
Adam Klein,
Adam Roben,
Addison Phillips,
Adele Peterson,
Adrian Bateman,
Adrian Sutton,
Agustín Fernández,
Aharon (Vladimir) Lanin,
Ajai Tirumali,
Akatsuki Kitamura,
Alan Plum,
Alastair Campbell,
Alejandro G. Castro,
Alex Bishop,
Alex Nicolaou,
Alex Rousskov,
Alexander Farkas,
Alexander J. Vincent,
Alexandre Morgaut,
Alexey Feldgendler,
Алексей Проскуряков (Alexey Proskuryakov),
Alexis Deveria,
Allan Clements,
Ami Fischman,
Amos Jeffries,
Anders Carlsson,
André E. Veltstra,
Andrea Rendine,
Andreas,
Andreas Kling,
Andrei Popescu,
Andres Gomez,
Andrew Barfield,
Andrew Clover,
Andrew Gove,
Andrew Grieve,
Andrew Oakley,
Andrew Sidwell,
Andrew Simons,
Andrew Smith,
Andrew W. Hagen,
Andrey V. Lukyanov,
Andry Rendy,
Andy Earnshaw,
Andy Heydon,
Andy Palay,
Anne van Kesteren,
Anthony Boyd,
Anthony Bryan,
Anthony Hickson,
Anthony Ricaud,
Antti Koivisto,
Arkadiusz Michalski,
Arne Thomassen,
Aron Spohr,
Arphen Lin,
Arthur Stolyar,
Arun Patole,
Aryeh Gregor,
Asbjørn Ulsberg,
Ashley Gullen,
Ashley Sheridan,
Atsushi Takayama,
Aurelien Levy,
Ave Wrigley,
Axel Dahmen,
Ben Boyle,
Ben Godfrey,
Ben Lerner,
Ben Leslie,
Ben Meadowcroft,
Ben Millard,
Benjamin Carl Wiley Sittler,
Benjamin Hawkes-Lewis,
Benoit Ren,
Bert Bos,
Bijan Parsia,
Bil Corry,
Bill Mason,
Bill McCoy,
Billy Wong,
Bjartur Thorlacius,
Björn Höhrmann,
Blake Frantz,
Bob Lund,
Bob Owen,
Boris Zbarsky,
Brad Fults,
Brad Neuberg,
Brad Spencer,
Brady Eidson,
Brendan Eich,
Brenton Simpson,
Brett Wilson,
Brett Zamir,
Brian Blakely,
Brian Campbell,
Brian Korver,
Brian Kuhn,
Brian M. Dube,
Brian Ryner,
Brian Smith,
Brian Wilson,
Bryan Sullivan,
Bruce Bailey,
Bruce D'Arcus,
Bruce Lawson,
Bruce Miller,
C. Williams,
Cameron McCormack,
Cameron Zemek,
Cao Yipeng,
Carlos Amengual,
Carlos Gabriel Cardona,
Carlos Perelló Marín,
Chao Cai,
윤석찬 (Channy Yun),
Charl van Niekerk,
Charles Iliya Krempeaux,
Charles McCathieNevile,
Chris Apers,
Chris Cressman,
Chris Evans,
Chris Morris,
Chris Pearce,
Chris Peterson,
Chris Weber,
Christian Biesinger,
Christian Johansen,
Christian Schmidt,
Christoph Päper,
Christophe Dumez,
Christopher Aillon,
Christopher Ferris,
Chriswa,
Clark Buehler,
Cole Robison,
Colin Fine,
Collin Jackson,
Corprew Reed,
Craig Cockburn,
Csaba Gabor,
Csaba Marton,
Cynthia Shelly,
Dan Yoder,
Daniel Barclay,
Daniel Bratell,
Daniel Brooks,
Daniel Brumbaugh Keeney,
Daniel Cheng,
Daniel Davis,
Daniel Glazman,
Daniel Peng,
Daniel Schattenkirchner,
Daniel Spång,
Daniel Steinberg,
Daniel Trebbien,
Danny Sullivan,
Darin Adler,
Darin Fisher,
Darxus,
Dave Camp,
Dave Hodder,
Dave Lampton,
Dave Singer,
Dave Townsend,
David Baron,
David Bloom,
David Bruant,
David Carlisle,
David E. Cleary,
David Egan Evans,
David Fink,
David Flanagan,
David Gerard,
David Håsäther,
David Hyatt,
David I. Lehn,
David John Burrowes,
David Kendal,
David MacDonald,
David Matja,
David Remahl,
David Smith,
David Woolley,
DeWitt Clinton,
Dean Edridge,
Dean Edwards,
Debi Orton,
Derek Featherstone,
Devarshi Pant,
Devdatta,
Dimitri Glazkov,
Dimitry Golubovsky,
Dirk Pranke,
Dirk Schulze,
Dirkjan Ochtman,
Divya Manian,
Dmitry Titov,
dolphinling,
Domenic Denicola,
Dominique Hazaël-Massieux,
Don Brutzman,
Doron Rosenberg,
Doug Kramer,
Doug Simpkinson,
Drew Wilson,
Edmund Lai,
Eduard Pascual,
Eduardo Vela,
Edward O'Connor,
Edward Welbourne,
Edward Z. Yang,
Ehsan Akhgari,
Eira Monstad,
Eitan Adler,
Eliot Graff,
Elisabeth Robson,
Elizabeth Castro,
Elliott Sprehn,
Elliotte Harold,
Eric Carlson,
Eric Casler,
Eric Lawrence,
Eric Rescorla,
Eric Semling,
Erik Arvidsson,
Erik Rose,
Evan Martin,
Evan Prodromou,
Evan Stade,
Evert,
fantasai,
Felix Sasaki,
Francesco Schwarz,
Francis Brosnan Blazquez,
Franck 'Shift' Quélain,
Frank Barchard,
Fredrik Söderquist,
鵜飼文敏 (Fumitoshi Ukai),
Futomi Hatano,
Gavin Carothers,
Gavin Kistner,
Gareth Rees,
Garrett Smith,
Geoff Richards,
Geoffrey Garen,
Geoffrey Sneddon,
Gez Lemon,
George Lund,
Gianmarco Armellin,
Giovanni Campagna,
Giuseppe Pascale,
Glenn Adams,
Glenn Maynard,
Graham Klyne,
Greg Botten,
Greg Houston,
Greg Wilkins,
Gregg Tavares,
Gregory J. Rosmaita,
Grey,
Guilherme Johansson Tramontina,
Gytis Jakutonis,
Håkon Wium Lie,
Habib Virji,
Hallvord Reiar Michaelsen Steen,
Hans S. Tømmerhalt,
Hans Stimer,
Harald Alvestrand,
Henri Sivonen,
Henrik Lied,
Henry Mason,
Henry Story,
Heydon Pickering,
Hugh Guiney,
Hugh Winkler,
Ian Bicking,
Ian Clelland,
Ian Davis,
Ian Fette,
Ido Green,
Ignacio Javier,
Ivan Enderlin,
Ivo Emanuel Gonçalves,
J. King,
Jacob Davies,
Jacques Distler,
Jake Verbaten,
Jakub Łopuszański,
James Craig,
James Graham,
James Greene,
James Justin Harrell,
James Kozianski,
James M Snell,
James Perrett,
James Robinson,
Jamie Lokier,
Janusz Majnert,
Jan-Klaas Kollhof,
Jared Jacobs,
Jason Duell,
Jason Kersey,
Jason Lustig,
Jason White,
Jasper Bryant-Greene,
Jasper St. Pierre,
Jatinder Mann,
Jed Hartman,
Jeff Balogh,
Jeff Cutsinger,
Jeff Schiller,
Jeff Walden,
Jeffrey Zeldman,
胡慧鋒 (Jennifer Braithwaite),
Jens Bannmann,
Jens Fendler,
Jens Lindström,
Jens Meiert,
Jeremey Hustman,
Jeremy Keith,
Jeremy Orlow,
Jeroen van der Meer,
Jian Li,
Jim Jewett,
Jim Ley,
Jim Meehan,
Jim Michaels,
Jirka Kosek,
Jjgod Jiang,
João Eiras,
Joe Clark,
Joe Gregorio,
Joel Spolsky,
Joel Verhagen,
Johan Herland,
John Boyer,
John Bussjaeger,
John Carpenter,
John Daggett,
John Fallows,
John Foliot,
John Harding,
John Keiser,
John Snyders,
John Stockton,
John-Mark Bell,
Johnny Stenback,
Jon Ferraiolo,
Jon Gibbins,
Jon Perlow,
Jonas Sicking,
Jonathan Cook,
Jonathan Rees,
Jonathan Watt,
Jonathan Worent,
Jonny Axelsson,
Jordan Tucker,
Jorgen Horstink,
Jorunn Danielsen Newth,
Joseph Kesselman,
Joseph Mansfield,
Joseph Pecoraro,
Josh Aas,
Josh Hart,
Josh Levenberg,
Joshua Bell,
Joshua Randall,
Jukka K. Korpela,
Jules Clément-Ripoche,
Julian Reschke,
Jürgen Jeka,
Justin Lebar,
Justin Novosad,
Justin Schuh,
Justin Sinclair,
Ka-Sing Chou,
Kai Hendry,
呂康豪 (KangHao Lu),
Kartikaya Gupta,
Kathy Walton,
Kelly Ford,
Kelly Norton,
Kevin Benson,
Kevin Gadd,
Kevin Cole,
Kornél Pál,
Kornel Lesinski,
Kris Northfield,
Kristof Zelechovski,
Krzysztof Maczyński,
黒澤剛志 (Kurosawa Takeshi),
Kyle Barnhart,
Kyle Hofmann,
Kyle Huey,
Léonard Bouchet,
Léonie Watson,
Lachlan Hunt,
Larry Masinter,
Larry Page,
Lars Gunther,
Lars Solberg,
Laura Carlson,
Laura Granka,
Laura L. Carlson,
Laura Wisewell,
Laurens Holst,
Lawrence Forooghian,
Lee Kowalkowski,
Leif Halvard Silli,
Leif Kornstaedt,
Lenny Domnitser,
Leonard Rosenthol,
Leonie Watson,
Leons Petrazickis,
Lobotom Dysmon,
Logan,
Loune,
Łukasz Pilorz,
Luke Kenneth Casson Leighton,
Maciej Stachowiak,
Magnus Kristiansen,
Maik Merten,
Malcolm Rowe,
Manish Tripathi,
Marc Hoyois,
Marcus Bointon,
Mark Birbeck,
Mark Davis,
Mark Miller,
Mark Nottingham,
Mark Pilgrim,
Mark Rowe,
Mark Schenk,
Mark Vickers,
Mark Wilton-Jones,
Martijn Wargers,
Martin Atkins,
Martin Dürst,
Martin Honnen,
Martin Janecke,
Martin Kutschker,
Martin Nilsson,
Martin Thomson,
Masataka Yakura,
Matt May,
Masatoshi Kimura,
Mathias Bynens,
Mathieu Henri,
Matias Larsson,
Matt Falkenhagen,
Matt Schmidt,
Matt Wright,
Matthew Gregan,
Matthew Mastracci,
Matthew Noorenberghe,
Matthew Raymond,
Matthew Thomas,
Mattias Waldau,
Max Romantschuk,
Menachem Salomon,
Menno van Slooten,
Micah Dubinko,
Michael 'Ratt' Iannarelli,
Michael A. Nachbaur,
Michael A. Puls II,
Michael Carter,
Michael Daskalov,
Michael Day,
Michael Dyck,
Michael Enright,
Michael Gratton,
Michael Nordman,
Michael Powers,
Michael Rakowski,
Michael(tm) Smith,
Michael Walmsley,
Michal Zalewski,
Michel Fortin,
Michelangelo De Simone,
Michiel van der Blonk,
Mihai Şucan,
Mihai Parparita,
Mike Brown,
Mike Dierken,
Mike Dixon,
Mike Hearn,
Mike Schinkel,
Mike Shaver,
Mikko Rantalainen,
Mohamed Zergaoui,
Mohammad Al Houssami,
Mounir Lamouri,
Ms2ger,
Nadia Heninger,
NARUSE Yui,
Neil Deakin,
Neil Rashbrook,
Neil Soiffer,
Nicholas Shanks,
Nicholas Stimpson,
Nicholas Zakas,
Nickolay Ponomarev,
Nicolas Gallagher,
Noah Mendelsohn,
Noah Slater,
Noel Gordon,
Nolan Waite,
NoozNooz42,
Norbert Lindenberg,
Ojan Vafai,
Olaf Hoffmann,
Olav Junker Kjær,
Oldřich Vetešník,
Oli Studholme,
Oliver Hunt,
Oliver Rigby,
Olivier Gendrin,
Olli Pettay,
oSand,
Pablo Flouret,
Patrick Garies,
Patrick H. Lauke,
Patrik Persson,
Paul Adenot,
Paul Norman,
Per-Erik Brodin,
Perry Smith,
Peter Beverloo,
Peter Karlsson,
Peter Kasting,
Peter Moulder,
Peter Occil,
Peter Stark,
Peter Van der Beken,
Peter-Paul Koch,
Phil Pickering,
Philip Jägenstedt,
Philip Taylor,
Philip TAYLOR,
Philippe De Ryck,
Prateek Rungta,
Pravir Gupta,
李普君 (Pujun Li),
Rachid Finge,
Rafael Weinstein,
Rafał Miłecki,
Raj Doshi,
Rajas Moonka,
Ralf Stoltze,
Ralph Giles,
Raphael Champeimont,
Remci Mizkur,
Remco,
Remy Sharp,
Rene Saarsoo,
Rene Stach,
Ric Hardacre,
Rich Clark,
Rich Doughty,
Richard Ishida,
Rigo Wenning,
Rikkert Koppes,
Rimantas Liubertas,
Riona Macnamara,
Rob Ennals,
Rob Jellinghaus,
Rob S,
Robert Blaut,
Robert Collins,
Robert Kieffer,
Robert Millan,
Robert O'Callahan,
Robert Sayre,
Robin Berjon,
Robin Schaufler,
Rodger Combs,
Roland Steiner,
Roma Matusevich,
Roman Ivanov,
Roy Fielding,
Ruud Steltenpool,
Ryan King,
Ryosuke Niwa,
S. Mike Dierken,
Salvatore Loreto,
Sam Dutton,
Sam Kuper,
Sam Ruby,
Sam Weinig,
Samuel Bronson,
Samy Kamkar,
Sander van Lambalgen,
Sarven Capadisli,
Scott González,
Scott Hess,
Sean Fraser,
Sean Hayes,
Sean Hogan,
Sean Knapp,
Sebastian Markbåge,
Sebastian Schnitzenbaumer,
Seth Call,
Seth Dillingham,
Shannon Moeller,
Shanti Rao,
Shaun Inman,
Shiki Okasaka,
Sierk Bornemann,
Sigbjørn Finne,
Sigbjørn Vik,
Silver Ghost,
Silvia Pfeiffer,
Šime Vidas,
Simon Montagu,
Simon Pieters,
Simon Spiegel,
skeww,
Smylers,
Stanton McCandlish,
Stefan Håkansson,
Stefan Haustein,
Stefan Santesson,
Stefan Weiss,
Steffen Meschkat,
Stephen Ma,
Stephen White,
Steve Comstock,
Steve Faulkner,
Steve Runyon,
Steven Bennett,
Steven Garrity,
Steven Tate,
Stewart Brodie,
Stuart Ballard,
Stuart Langridge,
Stuart Parmenter,
Subramanian Peruvemba,
Sunava Dutta,
Susan Borgrink,
Susan Lesch,
Sylvain Pasche,
T. J. Crowder,
Tab Atkins,
Takeshi Yoshino,
Tantek Çelik,
田村健人 (TAMURA Kent),
Ted Mielczarek,
Terrence Wood,
Thijs van der Vossen,
Thomas Broyer,
Thomas Koetter,
Thomas O'Connor,
Tim Altman,
Tim Johansson,
TJ VanToll,
Toby Inkster,
Todd Moody,
Tom Baker,
Tom Pike,
Tommy Thorsen,
Tony Ross,
Travis Leithead,
Trevor Saunders,
Tyler Close,
Victor Carbune,
Vipul Snehadeep Chawathe,
Vitya Muhachev,
Vladimir Katardjiev,
Vladimir Vukićević,
voracity,
Wakaba,
Wayne Carr,
Wayne Pollock,
Wellington Fernando de Macedo,
Weston Ruter,
Wilhelm Joys Andersen,
Will Levine,
William Chen,
William Swanson,
Wladimir Palant,
Wojciech Mach,
Wolfram Kriesing,
Xan Gregg,
Yang Chen,
Ye-Kui Wang,
Yehuda Katz,
Yi-An Huang,
Yngve Nysaeter Pettersen,
Yonathan Randolph,
Yuzo Fujishima,
Zhenbin Xu,
Zoltan Herczeg,
and
Øistein E. Andersen,
for their useful comments, both large and small, that have led to changes to this specification
over the years.
Thanks also to everyone who has ever posted about HTML to their blogs, public mailing lists, or
forums, including all the contributors to the various
W3C HTML WG lists and the various WHATWG
lists.
Special thanks to Richard Williamson for creating the first implementation of
canvas in Safari, from which the canvas feature was designed.
Special thanks also to the Microsoft employees who first implemented the event-based
drag-and-drop mechanism, contenteditable, and other
features first widely deployed by the Windows Internet Explorer browser.
Special thanks and $10,000 to David Hyatt who came up with a broken implementation
of the adoption agency algorithm that the editor had to reverse
engineer and fix before using it in the parsing section.
Thanks to the participants of the microdata usability study for allowing us to use their
mistakes as a guide for designing the microdata feature.
Thanks to the many sources that provided inspiration for the examples used in the
specification.
Thanks also to the Microsoft blogging community for some ideas, to the attendees of the W3C
Workshop on Web Applications and Compound Documents for inspiration, to the #mrt crew, the #mrt.no
crew, and the #whatwg crew, and to Pillar and Hedral for their ideas and support.
Thanks to the many sources that provided inspiration for the examples used in the
specification.
The image of two cute kittens in a basket used in the context menu example is based on
a photo
by Alex G.
(CC BY 2.0)
The photograph of robot 148 climbing the tower at the FIRST Robotics Competition 2013 Silicon Valley Regional is based on
a work by
Lenore Edman.
(CC BY 2.0)
IDEAS
v2 * library of resources:
var library = new ZipFile("data.zip");
library.onload = function() {
var sound1 = library.getAudio("sound1.wav"); // returns an Audio object
var image1 = library.getImage("image1.png"); // returns an HTMLImageElement
var doc1 = library.getXMLDocument("doc1.xml"); // returns a Document (XML Document mode)
var doc2 = library.getHTMLDocument("doc1.html"); // returns a Document (HTML Document mode)
}
or:
var library = new ResourceLoader("data.zip");
library.add("moredata.zip");
library.onload = function() { ... }
library.onloading = function() {
reportLoadProgress(library.progress); // 0.0 .. 1.0
}
or:
var library = new AudioZip("sounds.zip");
library.onload = function() {
var sound1 = library["sound1.wav"];
sound.play();
}
v2 * a fairly common situation for web authors is to have two lists, where the contents of the
second depends on the value of the first. Is there any way we could extend the current model
to include this functionality? (e.g. bugzilla product/component ui)
v2 * quick-searchable select
v2 * include/exclude selectors (two multi-select columns with arrows to move selected items) and
that sort of thing. http://slashdot.org/comments.pl?sid=110240&cid=9357022
v2 * Oh, and forms need a standardised Help widget/icon. I know I can turn my cursor into a
question mark, but I'm looking for something simple and pervasive. Maybe you can wrap fields
in a help tag, just as you do for fieldsets. And in that help tag, attributes are available
that allow for a nice, formatted, clean, full help text popup/area/thing.
http://slashdot.org/comments.pl?sid=110240&cid=9359006
v2 * Validating only part of a form. - Anja Lehmann
v2 * Reminder to add a way to expose access keys in buttons, i.e. Sub&mit where & signifies the m
is the access key to use. Possibly automatic? browser
would be smart enough to underline the first instance of the access key if it exists (case
insensitive)? - kerz
[or deprecate the lot (->web apps)]
v2 * need an attribute that says "the children of this element are in their own tabbing universe,
tabindex should be relative to each other, not to the document"
-> web apps?
v2 * make select widgets have multiple columns
or ->web apps with list view
v2 * required as a group (one of the following must be available):
+ i propose something like the following:
Voice phone
Fax
Mobile phone
E-mail
if the user fills out none of the form fields in the "contact" group, an error message is
shown and the form is not submitted.
- Peter-Paul Koch
v2 * formatting of number fields, text fields, etc, so that when the field is not focused, the
value is displayed differently. Seems like this would also be useful e.g. for
5.99!
nce upon a time and a long long time ago...
you.
Warning! Your session is about to expire.
and other developer resources
WebPlatform.org
When the
element is wider than it is tall, the element is expected to be depicted as a horizontal progress
bar, with the start on the right and the end on the left if the 'direction' property on this
element has a computed value of 'rtl', and with the start on the left and the end on the right
otherwise. When the element is taller than it is wide, it is expected to depicted as a vertical
progress bar, with the lowest value on the bottom. When the element is square, it is expected to
be depicted as a direction-independent progress widget (e.g. a circular progress ring).