Implementations must act as if they used the following state machine to tokenize 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.)
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.
Consume the next input character:
Switch to the data state.
Attempt to consume a character reference, with no additional allowed character.
If nothing is returned, emit a U+0026 AMPERSAND character (&) token.
Otherwise, emit the character tokens that were returned.
Consume the next input character:
Switch to the RCDATA state.
Attempt to consume a character reference, with no additional allowed character.
If nothing is returned, emit a U+0026 AMPERSAND character (&) token.
Otherwise, emit the character tokens that were returned.
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
script
", then switch to the script data
double escaped state. Otherwise, switch to the script
data escaped state. Emit the current input
character as a character token.Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
script
", then switch to the script data
escaped state. Otherwise, switch to the script data
double escaped state. Emit the current input
character as a character token.Consume the next input character:
Consume the next input character:
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 dropped, along with the value that gets associated with it (if any).
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Attempt to consume a character reference.
If nothing is returned, append a U+0026 AMPERSAND character (&) to the current attribute's value.
Otherwise, append the returned character tokens to the current attribute's value.
Finally, switch back to the attribute value state that switched into this state.
Consume the next input character:
Consume the next input character:
Consume every character up to and including the first U+003E
GREATER-THAN SIGN 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
"<!>
".)
Switch to the data state.
If the end of the file was reached, reconsume the EOF character.
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 a 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.
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
If the six characters starting from the current input character are an ASCII case-insensitive match for the word "PUBLIC", then consume those characters and switch to the after DOCTYPE public keyword state.
Otherwise, if the six characters starting from the current input character are an ASCII case-insensitive match for the word "SYSTEM", then consume those characters and switch to the after DOCTYPE system keyword state.
Otherwise, this is a parse error. Set the DOCTYPE token's force-quirks flag to on. Switch to the bogus DOCTYPE state.
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Consume the next input character:
Switch to the data state.
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.
This section defines how to consume 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):
Consume the U+0023 NUMBER SIGN.
The behavior further depends on the character after the U+0023 NUMBER SIGN:
Consume the X.
Follow the steps below, but using the range of characters ASCII digits, U+0061 LATIN SMALL LETTER A to U+0066 LATIN SMALL LETTER F, and U+0041 LATIN CAPITAL LETTER A to U+0046 LATIN CAPITAL LETTER F (in other words, 0-9, A-F, a-f).
When it comes to interpreting the number, interpret it as a hexadecimal number.
Follow the steps below, but using the range of characters ASCII digits.
When it comes to interpreting the number, interpret it as a decimal number.
Consume as many characters as match the range of characters given above.
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 |
0x0D | U+000D | CARRIAGE RETURN (CR) |
0x80 | U+20AC | EURO SIGN (€) |
0x81 | U+0081 | <control> |
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 (Œ) |
0x8D | U+008D | <control> |
0x8E | U+017D | LATIN CAPITAL LETTER Z WITH CARON (Ž) |
0x8F | U+008F | <control> |
0x90 | U+0090 | <control> |
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 (œ) |
0x9D | U+009D | <control> |
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.
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, 0x000E 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.
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 characters in the range ASCII digits, lowercase ASCII letters, and uppercase ASCII letters, followed by a ";" (U+003B) 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 in the range ASCII digits, uppercase ASCII letters, or lowercase ASCII letters, then, for historical reasons, all the characters that were matched after the U+0026 AMPERSAND character (&) must be unconsumed, and nothing is returned.
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).
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:
annotation-xml
element in the MathML namespace and the token is a start tag whose tag name is "svg"When the specification says that a user agent is to act as if a token had been seen, it means that the user agent is to follow the appropriate steps from the above list.
The current node is a MathML text integration point if it is one of the following elements:
mi
element in the MathML namespacemo
element in the MathML namespacemn
element in the MathML namespacems
element in the MathML namespacemtext
element in the MathML namespaceThe current node is an HTML integration point if it is one of the following elements:
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
"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
"foreignObject
element in the SVG namespacedesc
element in the SVG namespacetitle
element in the SVG namespaceWhen the steps below require the UA to insert a
character into a node, if that node has a child immediately
before where the character is to be inserted, and that child is a
Text
node, then the character must be appended to that
Text
node; otherwise, a new Text
node
whose data is just that character must be inserted in the
appropriate place.
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.
Input | Number of Text nodes
|
---|---|
A<script> var script = document.getElementsByTagName('script')[0]; document.body.removeChild(script); </script>B | One Text node in the document, containing "AB".
|
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.)
|
DOM mutation events and mutation
observers must not fire for changes caused by the UA parsing the
document. (Conceptually, the parser is not mutating the DOM, it is
constructing it.) This includes the parsing of any content inserted
using document.write()
and
document.writeln()
calls.
[DOMEVENTS]
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
recognized that practical
concerns will likely force user agents to impose nesting depth
constraints.
When the steps below require the UA to create an element for a token in a
particular namespace, the UA must create a node implementing the
interface appropriate for the element type corresponding to the tag
name of the token in the 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
.
When a resettable element is created in this manner, its reset algorithm must be invoked once the attributes are set. (This initializes the element's value and checkedness based on the element's attributes.)
When the steps below require the UA to insert an HTML element for a token, the UA must first create an element for the token in the HTML namespace, and then append this node to the current node, and push it onto the stack of open elements so that it is the new current node.
The steps below may also require that the UA insert an HTML element in a particular place, in which case the UA must follow the same steps except that it must insert or append the new node in the location specified instead of appending it to the current node. (This happens in particular during the parsing of tables with invalid content.)
If an element created by the insert an HTML element
algorithm is a form-associated element, and the
form
element pointer is not null,
and the newly created element doesn't have a form
attribute, the user agent must
associate the newly
created element with the form
element pointed to by the
form
element pointer when the
element is inserted, instead of running the reset the form
owner algorithm.
When the steps below require the UA to insert a foreign
element for a token, the UA must first create an element
for the token in the given namespace, and then append this
node to the current node, and push it onto the
stack of open elements so that it is the new
current node. 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.
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
|
contentscripttype | contentScriptType
|
contentstyletype | contentStyleType
|
diffuseconstant | diffuseConstant
|
edgemode | edgeMode
|
externalresourcesrequired | externalResourcesRequired
|
filterres | filterRes
|
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.)
Attribute name | Prefix | Local name | Namespace |
---|---|---|---|
xlink:actuate | xlink | actuate | XLink namespace |
xlink:arcrole | xlink | arcrole | XLink namespace |
xlink:href | xlink | href | XLink namespace |
xlink:role | xlink | role | XLink namespace |
xlink:show | xlink | show | XLink namespace |
xlink:title | xlink | title | XLink namespace |
xlink:type | xlink | type | XLink namespace |
xml:base | xml | base | XML namespace |
xml:lang | xml | lang | XML namespace |
xml:space | xml | space | XML namespace |
xmlns | (none) | xmlns | XMLNS namespace |
xmlns:xlink | xmlns | xlink | XMLNS namespace |
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.
Insert an HTML element for the token.
If the algorithm that was invoked is the generic raw text element parsing algorithm, switch the tokenizer to the RAWTEXT state; otherwise the algorithm invoked was the generic RCDATA element parsing algorithm, switch the tokenizer to the RCDATA state.
Let the original insertion mode be the current insertion mode.
Then, switch the insertion mode to "text".
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
rp
element, or an rt
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.
Foster parenting happens when content is misnested in tables.
When a node node is to be foster parented, the node node must be inserted into the foster parent element.
The foster parent element is the parent element of the
last table
element in the stack of open
elements, if there is a table
element and it has
such a parent element.
It might have no parent or some other kind parent if a script manipulated the DOM after the element was inserted by the parser.
If there is no table
element in the stack of
open elements (fragment case), then the
foster parent element is the first element in the stack
of open elements (the html
element). Otherwise,
if there is a table
element in the stack of open
elements, but the last table
element in the
stack of open elements has no parent, or its parent
node is not an element, then the foster parent element is the
element before the last table
element in the
stack of open elements.
If the foster parent element is the parent element of the
last table
element in the stack of open
elements, then node must be inserted into
the foster parent element, immediately before the
last table
element in the stack of open
elements; otherwise, node must be
appended to the foster parent element.
When the user agent is to apply the rules for the "initial" insertion mode, the user agent must handle the token as follows:
Ignore the token.
Append a Comment
node to the Document
object with the data
attribute set to the
data given in the comment token.
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.
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
".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
".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
".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 recognize 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.
Then, if the DOCTYPE token matches
one of the conditions in the following list, then set the
Document
to quirks mode:
html
" (compared case-sensitively). +//Silmaril//dtd html Pro v0r11 19970101//
" -//AdvaSoft Ltd//DTD HTML 3.0 asWedit + extensions//
" -//AS//DTD HTML 3.0 asWedit + extensions//
" -//IETF//DTD HTML 2.0 Level 1//
" -//IETF//DTD HTML 2.0 Level 2//
" -//IETF//DTD HTML 2.0 Strict Level 1//
" -//IETF//DTD HTML 2.0 Strict Level 2//
" -//IETF//DTD HTML 2.0 Strict//
" -//IETF//DTD HTML 2.0//
" -//IETF//DTD HTML 2.1E//
" -//IETF//DTD HTML 3.0//
" -//IETF//DTD HTML 3.2 Final//
" -//IETF//DTD HTML 3.2//
" -//IETF//DTD HTML 3//
" -//IETF//DTD HTML Level 0//
" -//IETF//DTD HTML Level 1//
" -//IETF//DTD HTML Level 2//
" -//IETF//DTD HTML Level 3//
" -//IETF//DTD HTML Strict Level 0//
" -//IETF//DTD HTML Strict Level 1//
" -//IETF//DTD HTML Strict Level 2//
" -//IETF//DTD HTML Strict Level 3//
" -//IETF//DTD HTML Strict//
" -//IETF//DTD HTML//
" -//Metrius//DTD Metrius Presentational//
" -//Microsoft//DTD Internet Explorer 2.0 HTML Strict//
" -//Microsoft//DTD Internet Explorer 2.0 HTML//
" -//Microsoft//DTD Internet Explorer 2.0 Tables//
" -//Microsoft//DTD Internet Explorer 3.0 HTML Strict//
" -//Microsoft//DTD Internet Explorer 3.0 HTML//
" -//Microsoft//DTD Internet Explorer 3.0 Tables//
" -//Netscape Comm. Corp.//DTD HTML//
" -//Netscape Comm. Corp.//DTD Strict HTML//
" -//O'Reilly and Associates//DTD HTML 2.0//
" -//O'Reilly and Associates//DTD HTML Extended 1.0//
" -//O'Reilly and Associates//DTD HTML Extended Relaxed 1.0//
" -//SoftQuad Software//DTD HoTMetaL PRO 6.0::19990601::extensions to HTML 4.0//
" -//SoftQuad//DTD HoTMetaL PRO 4.0::19971010::extensions to HTML 4.0//
" -//Spyglass//DTD HTML 2.0 Extended//
" -//SQ//DTD HTML 2.0 HoTMetaL + extensions//
" -//Sun Microsystems Corp.//DTD HotJava HTML//
" -//Sun Microsystems Corp.//DTD HotJava Strict HTML//
" -//W3C//DTD HTML 3 1995-03-24//
" -//W3C//DTD HTML 3.2 Draft//
" -//W3C//DTD HTML 3.2 Final//
" -//W3C//DTD HTML 3.2//
" -//W3C//DTD HTML 3.2S Draft//
" -//W3C//DTD HTML 4.0 Frameset//
" -//W3C//DTD HTML 4.0 Transitional//
" -//W3C//DTD HTML Experimental 19960712//
" -//W3C//DTD HTML Experimental 970421//
" -//W3C//DTD W3 HTML//
" -//W3O//DTD W3 HTML 3.0//
" -//W3O//DTD W3 HTML Strict 3.0//EN//
" -//WebTechs//DTD Mozilla HTML 2.0//
" -//WebTechs//DTD Mozilla HTML//
" -/W3C/DTD HTML 4.0 Transitional/EN
" HTML
" http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd
" -//W3C//DTD HTML 4.01 Frameset//
" -//W3C//DTD HTML 4.01 Transitional//
" Otherwise, if the DOCTYPE token matches one of the conditions
in the following list, then set the Document
to
limited-quirks mode:
-//W3C//DTD XHTML 1.0 Frameset//
" -//W3C//DTD XHTML 1.0 Transitional//
" -//W3C//DTD HTML 4.01 Frameset//
" -//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.
Then, switch the insertion mode to "before html".
If the document is not an iframe
srcdoc
document,
then this is a parse error; set the
Document
to quirks mode.
In any case, switch the insertion mode to "before html", then reprocess the current token.
When the user agent is to apply the rules for the "before html" insertion mode, the user agent must handle the token as follows:
Parse error. Ignore the token.
Append a Comment
node to the Document
object with the data
attribute set to the
data given in the comment token.
Ignore the token.
Create an element for the token in the HTML
namespace. Append it to the Document
object. Put this element in the stack of open
elements.
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 resulting absolute URL with
any <fragment> component
removed; 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.
Switch the insertion mode to "before head".
Act as described in the "anything else" entry below.
Parse error. Ignore the token.
Create an html
element. Append it to the
Document
object. Put this element in the stack
of open elements.
If the Document
is being loaded as part of navigation of a browsing
context, then: run the application cache selection
algorithm with no manifest, passing it the
Document
object.
Switch the insertion mode to "before head", then reprocess the current token.
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.
When the user agent is to apply the rules for the "before head" insertion mode, the user agent must handle the token as follows:
Ignore the token.
Append a Comment
node to the current
node with the data
attribute set to
the data given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
Insert an HTML element for the token.
Set the head
element pointer
to the newly created head
element.
Switch the insertion mode to "in head".
Act as if a start tag token with the tag name "head" and no attributes had been seen, then reprocess the current token.
Parse error. Ignore the token.
Act as if a start tag token with the tag name "head" and no attributes had been seen, then reprocess the current token.
When the user agent is to apply the rules for the "in head" insertion mode, the user agent must handle the token as follows:
Insert the character into the current node.
Append a Comment
node to the current
node with the data
attribute set to
the data given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
Insert an HTML element for the token. Immediately pop the current node off the stack of open elements.
Acknowledge the token's self-closing flag, if it is set.
Insert an HTML element for the token. Immediately pop the current node off the stack of open elements.
Acknowledge the token's self-closing flag, if it is set.
If the element has a charset
attribute, and its value
is either a supported ASCII-compatible character
encoding or a UTF-16 encoding, and the confidence is currently
tentative, then change the encoding to the
encoding given by the value of the charset
attribute.
Otherwise, if the element has an http-equiv
attribute whose
value is an ASCII case-insensitive match for the
string "Content-Type
", and the element has a
content
attribute, and
applying the algorithm for extracting a character encoding from a
meta
element to that attribute's value returns
a supported ASCII-compatible character encoding or
a UTF-16 encoding, and the confidence is currently
tentative, then change the encoding to the
extracted encoding.
Follow the generic RCDATA element parsing algorithm.
Follow the generic raw text element parsing algorithm.
Insert an HTML element for the token.
Switch the insertion mode to "in head noscript".
Run these steps:
Mark the element as being "parser-inserted" and unset the element's "force-async" flag.
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.
If the parser was originally created for the HTML
fragment parsing algorithm, then mark the
script
element as "already
started". (fragment case)
Append the new element to the current node and push it onto the stack of open elements.
Switch the tokenizer to the script data state.
Let the original insertion mode be the current insertion mode.
Switch the insertion mode to "text".
Pop the current node (which will be the
head
element) off the stack of open
elements.
Switch the insertion mode to "after head".
Act as described in the "anything else" entry below.
Parse error. Ignore the token.
Act as if an end tag token with the tag name "head" had been seen, and reprocess the current token.
When the user agent is to apply the rules for the "in head noscript" insertion mode, the user agent must handle the token as follows:
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
Pop the current node (which will be a
noscript
element) from the stack of open
elements; the new current node will be a
head
element.
Switch the insertion mode to "in head".
Process the token using the rules for the "in head" insertion mode.
Act as described in the "anything else" entry below.
Parse error. Ignore the token.
Parse error. Act as if an end tag with the tag name "noscript" had been seen and reprocess the current token.
When the user agent is to apply the rules for the "after head" insertion mode, the user agent must handle the token as follows:
Insert the character into the current node.
Append a Comment
node to the current
node with the data
attribute set to
the data given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
Insert an HTML element for the token.
Set the frameset-ok flag to "not ok".
Switch the insertion mode to "in body".
Insert an HTML element for the token.
Switch the insertion mode to "in frameset".
Push the node pointed to by the head
element pointer onto the
stack of open elements.
Process the token using the rules for the "in head" insertion mode.
Remove the node pointed to by the head
element pointer from the stack
of open elements.
The head
element
pointer cannot be null at this point.
Act as described in the "anything else" entry below.
Parse error. Ignore the token.
Act as if a start tag token with the tag name "body" and no attributes had been seen, then set the frameset-ok flag back to "ok", and then reprocess the current token.
When the user agent is to apply the rules for the "in body" insertion mode, the user agent must handle the token as follows:
Parse error. Ignore the token.
Reconstruct the active formatting elements, if any.
Insert the token's character into the current node.
Reconstruct the active formatting elements, if any.
Insert the token's character into the current node.
Set the frameset-ok flag to "not ok".
Append a Comment
node to the current
node with the data
attribute set to
the data given in the comment token.
Parse error. Ignore the token.
Parse error. 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.
Process the token using the rules for the "in head" insertion mode.
If the second element on the stack of open
elements is not a body
element, or, if the
stack of open elements has only one node on it,
then ignore the token. (fragment case)
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 the second element on the stack of open
elements is not a body
element, or, if the
stack of open elements has only one node on it,
then ignore the token. (fragment case)
If the frameset-ok flag is set to "not ok", ignore the token.
Otherwise, run the following steps:
Remove the second element on the stack of open elements from its parent node, if it has one.
Pop all the nodes from the bottom of the stack of
open elements, from the current node up to,
but not including, the root html
element.
Insert an HTML element for the token.
Switch the insertion mode to "in frameset".
If there is a node in the stack of open elements
that is not either a dd
element, a dt
element, an li
element, a p
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 stack of open elements does not have a body
element
in scope, this is a parse error; ignore the
token.
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 rp
element, an
rt
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.
Switch the insertion mode to "after body".
Act as if an end tag with tag name "body" had been seen, then, if that token wasn't ignored, reprocess the current token.
If the stack of open elements has a p
element in button
scope, then act as if an end tag with the tag name "p" had
been seen.
Insert an HTML element for the token.
If the stack of open elements has a p
element in button
scope, then act as if an end tag with the tag name
"p" had been seen.
If the current node is an element whose tag name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then this is a parse error; pop the current node off the stack of open elements.
Insert an HTML element for the token.
If the stack of open elements has a p
element in button
scope, then act as if an end tag with the tag name
"p" had been seen.
Insert an HTML element for the token.
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.)
Set the frameset-ok flag to "not ok".
If the form
element
pointer is not null, then this is a parse
error; ignore the token.
Otherwise:
If the stack of open elements has a p
element in button
scope, then act as if an end tag with the tag name
"p" had been seen.
Insert an HTML element for the token, and set the
form
element pointer to
point to the element created.
Run these steps:
Set the frameset-ok flag to "not ok".
Initialize node to be the current node (the bottommost node of the stack).
Loop: If node is an
li
element, then act as if an end tag with the tag
name "li" had been seen, then jump to the last step.
If node is in the special
category, but is not an address
, div
,
or p
element, then jump to the last step.
Otherwise, set node to the previous entry in the stack of open elements and return to the step labeled loop.
This is the last step.
If the stack of open elements has a p
element in button
scope, then act as if an end tag with the tag name
"p" had been seen.
Finally, insert an HTML element for the token.
Run these steps:
Set the frameset-ok flag to "not ok".
Initialize node to be the current node (the bottommost node of the stack).
Loop: If node is a
dd
or dt
element, then act as if an end
tag with the same tag name as node had been
seen, then jump to the last step.
If node is in the special
category, but is not an address
, div
,
or p
element, then jump to the last step.
Otherwise, set node to the previous entry in the stack of open elements and return to the step labeled loop.
This is the last step.
If the stack of open elements has a p
element in button
scope, then act as if an end tag with the tag name
"p" had been seen.
Finally, insert an HTML element for the token.
If the stack of open elements has a p
element in button
scope, then act as if an end tag with the tag name
"p" had been seen.
Insert an HTML element for the token.
Switch the tokenizer to the PLAINTEXT state.
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.
If the stack of open elements has a button
element in
scope, then this is a parse error;
act as if an end tag with the tag name "button" had been seen,
then reprocess the token.
Otherwise:
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token.
Set the frameset-ok flag to "not ok".
If the stack of open elements does not have an element in scope with the same tag name as that of the token, then this is a parse error; ignore the token.
Otherwise, run these steps:
If the current node is not an element with the same tag name as that of the token, then this is a parse error.
Pop elements from the stack of open elements until an element with the same tag name as the token has been popped from the stack.
Let node be the element that the
form
element pointer is set
to.
Set the form
element pointer
to null.
If node is null or the stack of open elements does not have node in scope, then this is a parse error; ignore the token.
Otherwise, run these steps:
If the current node is not node, then this is a parse error.
Remove node from the stack of open elements.
If the stack of open elements does not have an element in button scope with the same tag name as that of the token, then this is a parse error; act as if a start tag with the tag name "p" had been seen, then reprocess the current token.
Otherwise, run these steps:
Generate implied end tags, except for elements with the same tag name as the token.
If the current node is not an element with the same tag name as that of the token, then this is a parse error.
Pop elements from the stack of open elements until an element with the same tag name as the token has been popped from the stack.
If the stack of open elements does not have an element in list item scope with the same tag name as that of the token, then this is a parse error; ignore the token.
Otherwise, run these steps:
Generate implied end tags, except for elements with the same tag name as the token.
If the current node is not an element with the same tag name as that of the token, then this is a parse error.
Pop elements from the stack of open elements until an element with the same tag name as the token has been popped from the stack.
If the stack of open elements does not have an element in scope with the same tag name as that of the token, then this is a parse error; ignore the token.
Otherwise, run these steps:
Generate implied end tags, except for elements with the same tag name as the token.
If the current node is not an element with the same tag name as that of the token, then this is a parse error.
Pop elements from the stack of open elements until an element with the same tag name as the token has been popped from the stack.
If the stack of open elements does not have an element in scope whose tag name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then this is a parse error; ignore the token.
Otherwise, run these steps:
If the current node is not an element with the same tag name as that of the token, then this is a parse error.
Pop elements from the stack of open elements until an element whose tag name is one of "h1", "h2", "h3", "h4", "h5", or "h6" has been popped from the stack.
Take a deep breath, then act as described in the "any other end tag" entry below.
If the list of active formatting elements contains an element whose tag name is "a" between the end of the list and the last marker on the list (or the start of the list if there is no marker on the list), then this is a parse error; act as if an end tag with the tag name "a" had been seen, then remove that element from the list of active formatting elements and the stack of open elements if the end tag didn't already remove it (it might not have if the element is not in table scope).
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.
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token. Push onto the list of active formatting elements that element.
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token. Push onto the list of active formatting elements that element.
Reconstruct the active formatting elements, if any.
If the stack of open elements has a nobr
element in scope,
then this is a parse error; act as if an end tag with
the tag name "nobr" had been seen, then once again
reconstruct the active formatting elements, if
any.
Insert an HTML element for the token. Push onto the list of active formatting elements that element.
Run these steps:
Let outer loop counter be zero.
Outer loop: If outer loop counter is greater than or equal to eight, then abort these steps.
Increment outer loop counter by one.
Let the formatting element be the last element in the list of active formatting elements that:
If there is no such node, then abort these steps and instead act as described in the "any other end tag" entry below.
Otherwise, if there is such a node, but that node is not in the stack of open elements, then this is a parse error; remove the element from the list, and abort these steps.
Otherwise, if there is such a node, and that node is also in the stack of open elements, but the element is not in scope, then this is a parse error; ignore the token, and abort these steps.
Otherwise, there is a formatting element and that element is in the stack and is in scope. If the element is not the current node, this is a parse error. In any case, proceed with the algorithm as written in the following steps.
Let the furthest block be the topmost node in the stack of open elements that is lower in the stack than the 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 the formatting element, then remove the formatting element from the list of active formatting elements, and finally abort these steps.
Let the common ancestor be the element immediately above the formatting element in the stack of open elements.
Let a bookmark note the position of the 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 the furthest block. Follow these steps:
Let inner loop counter be zero.
Inner loop: If inner loop counter is greater than or equal to three, then go to the next step in the overall algorithm.
Increment inner loop counter by one.
If the common ancestor node is a
table
, tbody
, tfoot
,
thead
, or tr
element, then,
foster parent whatever last
node ended up being in the previous step, first removing
it from its previous parent node if any.
Otherwise, append whatever last node ended up being in the previous step to the common ancestor node, first removing it from its previous parent node if any.
Create an element for the token for which the formatting element was created.
Take all of the child nodes of the furthest block and append them to the element created in the last step.
Append that new element to the furthest block.
Remove the formatting element from the list of active formatting elements, and insert the new element into the list of active formatting elements at the position of the aforementioned bookmark.
Remove the formatting element from the stack of open elements, and insert the new element into the stack of open elements immediately below the position of the furthest block in that stack.
Jump back to the step labeled outer loop.
Because of the way this algorithm causes elements to change parents, it has been dubbed the "adoption agency algorithm" (in contrast with other possible algorithms for dealing with misnested content, which included the "incest algorithm", the "secret affair algorithm", and the "Heisenberg algorithm").
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token.
Insert a marker at the end of the list of active formatting elements.
Set the frameset-ok flag to "not ok".
If the stack of open elements does not have an element in scope with the same tag name as that of the token, then this is a parse error; ignore the token.
Otherwise, run these steps:
If the current node is not an element with the same tag name as that of the token, then this is a parse error.
Pop elements from the stack of open elements until an element with the same tag name as the token has been popped from the stack.
If the Document
is not set to
quirks mode, and the stack of open
elements has a
p
element in button scope, then act as if an
end tag with the tag name "p" had been seen.
Insert an HTML element for the token.
Set the frameset-ok flag to "not ok".
Switch the insertion mode to "in table".
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token. Immediately pop the current node off the stack of open elements.
Acknowledge the token's self-closing flag, if it is set.
Set the frameset-ok flag to "not ok".
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token. Immediately pop the current node off the stack of open elements.
Acknowledge the token's self-closing flag, if it is set.
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".
Insert an HTML element for the token. Immediately pop the current node off the stack of open elements.
Acknowledge the token's self-closing flag, if it is set.
If the stack of open elements has a p
element in button
scope, then act as if an end tag with the tag name
"p" had been seen.
Insert an HTML element for the token. Immediately pop the current node off the stack of open elements.
Acknowledge the token's self-closing flag, if it is set.
Set the frameset-ok flag to "not ok".
Parse error. Change the token's tag name to "img" and reprocess it. (Don't ask.)
If the form
element
pointer is not null, then ignore the token.
Otherwise:
Acknowledge the token's self-closing flag, if it is set.
Act as if a start tag token with the tag name "form" had been seen.
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.
Act as if a start tag token with the tag name "hr" had been seen.
Act as if a start tag token with the tag name "label" had been seen.
Act as if a stream of character tokens had been seen (see below for what they should say).
Act as if a start tag token with the tag name "input" had been
seen, with all the attributes from the "isindex" token except
"name", "action", and "prompt". Set the name
attribute of the resulting
input
element to the value "isindex
".
Act as if a stream of character tokens had been seen (see below for what they should say).
Act as if an end tag token with the tag name "label" had been seen.
Act as if a start tag token with the tag name "hr" had been seen.
Act as if an end tag token with the tag name "form" had been seen.
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.
Run these steps:
Insert an HTML element for the token.
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.)
Switch the tokenizer to the RCDATA state.
Let the original insertion mode be the current insertion mode.
Set the frameset-ok flag to "not ok".
Switch the insertion mode to "text".
If the stack of open elements has a p
element in button
scope, then act as if an end tag with the tag name
"p" had been seen.
Reconstruct the active formatting elements, if any.
Set the frameset-ok flag to "not ok".
Follow the generic raw text element parsing algorithm.
Set the frameset-ok flag to "not ok".
Follow the generic raw text element parsing algorithm.
Follow the generic raw text element parsing algorithm.
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token.
Set the frameset-ok flag to "not ok".
If the insertion mode is one of "in table", "in caption", "in table body", "in row", or "in cell", then switch the insertion mode to "in select in table". Otherwise, switch the insertion mode to "in select".
If the current node is an option
element, then act as if an end tag with the tag name "option" had
been seen.
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token.
If the stack of open elements has a ruby
element in scope,
then generate implied end tags. If the current
node is not then a ruby
element, this is a
parse error.
Insert an HTML element for the token.
Parse error. Act as if a start tag token with the tag name "br" had been seen. Ignore the end tag token.
Reconstruct the active formatting elements, if any.
Adjust MathML attributes for the token. (This fixes the case of MathML attributes that are not all lowercase.)
Adjust foreign attributes for the token. (This fixes the use of namespaced attributes, in particular XLink.)
Insert a foreign element for the token, in the MathML namespace.
If the token has its self-closing flag set, pop the current node off the stack of open elements and acknowledge the token's self-closing flag.
Reconstruct the active formatting elements, if any.
Adjust SVG attributes for the token. (This fixes the case of SVG attributes that are not all lowercase.)
Adjust foreign attributes for the token. (This fixes the use of namespaced attributes, in particular XLink in SVG.)
Insert a foreign element for the token, in the SVG namespace.
If the token has its self-closing flag set, pop the current node off the stack of open elements and acknowledge the token's self-closing flag.
Parse error. Ignore the token.
Reconstruct the active formatting elements, if any.
Insert an HTML element for the token.
This element will be an ordinary element.
Run these steps:
Initialize node to be the current node (the bottommost node of the stack).
Loop: If node has the same tag name as the token, then:
Generate implied end tags, except for elements with the same tag name as the token.
If the tag name of the end tag token does not match the tag name of the current node, this is a parse error.
Pop all the nodes from the current node up to node, including node, then stop these steps.
Otherwise, if node is in the special category, then this is a parse error; ignore the token, and abort these steps.
Set node to the previous entry in the stack of open elements.
Return to the step labeled loop.
When the user agent is to apply the rules for the "text" insertion mode, the user agent must handle the token as follows:
Insert the token's character into the current node.
This can never be a U+0000 NULL character; the tokenizer converts those to U+FFFD REPLACEMENT CHARACTER characters.
If the current node is a script
element, mark the script
element as "already
started".
Pop the current node off the stack of open elements.
Switch the insertion mode to the original insertion mode and reprocess the current token.
Let script be the current node
(which will be a script
element).
Pop the current node off the stack of open elements.
Switch the insertion mode to the original insertion mode.
Let the old insertion point have the same value as the current insertion point. Let the insertion point be just before the next input character.
Increment the parser's script nesting level by one.
Prepare the script. This might cause some script to execute, which might cause new characters to be inserted into the tokenizer, and might cause the tokenizer to output more tokens, resulting in a reentrant invocation of the parser.
Decrement the parser's script nesting level by one. If the parser's script nesting level is zero, then set the parser pause flag to false.
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.)
At this stage, if there is a pending parsing-blocking script, then:
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.)
The tree construction stage of this particular
parser is being called reentrantly,
say from a call to document.write()
.
Run these steps:
Let the script be the pending parsing-blocking script. There is no longer a pending parsing-blocking script.
Block the tokenizer for this instance of the HTML parser, such that the event loop will not run tasks that invoke the tokenizer.
If the parser's Document
has a style
sheet that is blocking scripts or the
script's "ready to be parser-executed" flag
is not set: spin the event loop until the parser's
Document
has no style sheet that is blocking
scripts and the script's
"ready to be parser-executed" flag is
set.
Unblock the tokenizer for this instance of the HTML parser, such that tasks that invoke the tokenizer can again be run.
Let the insertion point be just before the next input character.
Increment the parser's script nesting level by one (it should be zero before this step, so this sets it to one).
Execute the script.
Decrement the parser's script nesting level by one. If the parser's script nesting level is zero (which it always should be at this point), then set the parser pause flag to false.
Let the insertion point be undefined again.
If there is once again a pending parsing-blocking script, then repeat these steps from step 1.
Pop the current node off the stack of open elements.
Switch the insertion mode to the original insertion mode.
When the user agent is to apply the rules for the "in table" insertion mode, the user agent must handle the token as follows:
table
, tbody
, tfoot
, thead
, or tr
elementLet the pending table character tokens be an empty list of tokens.
Let the original insertion mode be the current insertion mode.
Switch the insertion mode to "in table text" and reprocess the token.
Append a Comment
node to the current
node with the data
attribute set to
the data given in the comment token.
Parse error. Ignore the token.
Clear the stack back to a table context. (See below.)
Insert a marker at the end of the list of active formatting elements.
Insert an HTML element for the token, then switch the insertion mode to "in caption".
Clear the stack back to a table context. (See below.)
Insert an HTML element for the token, then switch the insertion mode to "in column group".
Act as if a start tag token with the tag name "colgroup" had been seen, then reprocess the current token.
Clear the stack back to a table context. (See below.)
Insert an HTML element for the token, then switch the insertion mode to "in table body".
Act as if a start tag token with the tag name "tbody" had been seen, then reprocess the current token.
Parse error. Act as if an end tag token with the tag name "table" had been seen, then, if that token wasn't ignored, reprocess the current token.
The fake end tag token here can only be ignored in the fragment case.
If the stack of open elements does not have an element in table scope with the same tag name as the token, this is a parse error. Ignore the token. (fragment case)
Otherwise:
Pop elements from this stack until a table
element has been popped from the stack.
Parse error. Ignore the token.
Process the token using the rules for the "in head" insertion mode.
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.
Otherwise:
Insert an HTML element for the token.
Pop that input
element off the stack of
open elements.
Acknowledge the token's self-closing flag, if it is set.
If the form
element
pointer is not null, ignore the token.
Otherwise:
Insert an HTML element for the token, and set the
form
element pointer to
point to the element created.
Pop that form
element off the stack of
open elements.
If the current node is not the root
html
element, then this is a parse
error.
The current node can only be the root
html
element in the fragment case.
Parse error. Process the token using the
rules for the "in
body" insertion mode, except that whenever a
node would be inserted into the current node when the
current node is a table
,
tbody
, tfoot
, thead
, or
tr
element, then it must instead be foster parented.
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
element or an html
element, pop elements from the
stack of open elements.
The current node being an
html
element after this process is a fragment
case.
When the user agent is to apply the rules for the "in table text" insertion mode, the user agent must handle the token as follows:
Parse error. Ignore the token.
Append the character token to the pending table character tokens list.
If any of the tokens in the pending table character tokens list are character tokens that are not space characters, then reprocess the character tokens in the pending table character tokens list using the rules given in the "anything else" entry in the "in table" insertion mode.
Otherwise, insert the characters given by the pending table character tokens list into the current node.
Switch the insertion mode to the original insertion mode and reprocess the token.
When the user agent is to apply the rules for the "in caption" insertion mode, the user agent must handle the token as follows:
If the stack of open elements does not have an element in table scope with the same tag name as the token, this is a parse error. Ignore the token. (fragment case)
Otherwise:
Now, if the current node is not a
caption
element, then this is a parse
error.
Pop elements from this stack until a caption
element has been popped from the stack.
Clear the list of active formatting elements up to the last marker.
Switch the insertion mode to "in table".
Parse error. Act as if an end tag with the tag name "caption" had been seen, then, if that token wasn't ignored, reprocess the current token.
The fake end tag token here can only be ignored in the fragment case.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
When the user agent is to apply the rules for the "in column group" insertion mode, the user agent must handle the token as follows:
Insert the character into the current node.
Append a Comment
node to the current
node with the data
attribute set to
the data given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
Insert an HTML element for the token. Immediately pop the current node off the stack of open elements.
Acknowledge the token's self-closing flag, if it is set.
If the current node is the root
html
element, then this is a parse
error; ignore the token. (fragment
case)
Otherwise, pop the current node (which will be
a colgroup
element) from the stack of open
elements. Switch the insertion mode to
"in table".
Parse error. Ignore the token.
If the current node is the root html
element, then stop parsing. (fragment
case)
Otherwise, act as described in the "anything else" entry below.
Act as if an end tag with the tag name "colgroup" had been seen, and then, if that token wasn't ignored, reprocess the current token.
The fake end tag token here can only be ignored in the fragment case.
When the user agent is to apply the rules for the "in table body" insertion mode, the user agent must handle the token as follows:
Clear the stack back to a table body context. (See below.)
Insert an HTML element for the token, then switch the insertion mode to "in row".
Parse error. Act as if a start tag with the tag name "tr" had been seen, then reprocess the current token.
If the stack of open elements does not have an element in table scope with the same tag name as the token, this is a parse error. Ignore the token.
Otherwise:
Clear the stack back to a table body context. (See below.)
Pop the current node from the stack of open elements. Switch the insertion mode to "in table".
If the stack of open elements does not have a
tbody
, thead
, or tfoot
element in table scope, this is a parse
error. Ignore the token. (fragment
case)
Otherwise:
Clear the stack back to a table body context. (See below.)
Act as if an end tag with the same tag name as the current node ("tbody", "tfoot", or "thead") had been seen, then reprocess the current token.
Parse error. Ignore the token.
Process the token using the rules for the "in table" insertion mode.
When the steps above require the UA to clear the stack
back to a table body context, it means that the UA must,
while the current node is not a tbody
,
tfoot
, thead
, or html
element, pop elements from the stack of open
elements.
The current node being an
html
element after this process is a fragment
case.
When the user agent is to apply the rules for the "in row" insertion mode, the user agent must handle the token as follows:
Clear the stack back to a table row context. (See below.)
Insert an HTML element for the token, then switch the insertion mode to "in cell".
Insert a marker at the end of the list of active formatting elements.
If the stack of open elements does not have an element in table scope with the same tag name as the token, this is a parse error. Ignore the token. (fragment case)
Otherwise:
Clear the stack back to a table row context. (See below.)
Pop the current node (which will be a
tr
element) from the stack of open
elements. Switch the insertion mode to
"in table
body".
Act as if an end tag with the tag name "tr" had been seen, then, if that token wasn't ignored, reprocess the current token.
The fake end tag token here can only be ignored in the fragment case.
If the stack of open elements does not have an element in table scope with the same tag name as the token, this is a parse error. Ignore the token.
Otherwise, act as if an end tag with the tag name "tr" had been seen, then reprocess the current token.
Parse error. Ignore the token.
Process the token using the rules for the "in table" insertion mode.
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
element or an html
element, pop elements from the
stack of open elements.
The current node being an
html
element after this process is a fragment
case.
When the user agent is to apply the rules for the "in cell" insertion mode, the user agent must handle the token as follows:
If the stack of open elements does not have an element in table scope with the same tag name as that of the token, then this is a parse error and the token must be ignored.
Otherwise:
Now, if the current node is not an element with the same tag name as the token, then this is a parse error.
Pop elements from the stack of open elements stack until an element with the same tag name as the token has been popped from the stack.
Clear the list of active formatting elements up to the last marker.
Switch the insertion mode to "in row".
If the stack of open elements does
not have
a td
or th
element in table
scope, then this is a parse error; ignore
the token. (fragment case)
Otherwise, close the cell (see below) and reprocess the current token.
Parse error. Ignore the token.
If the stack of open elements does not have an element in table scope with the same tag name as that of the token (which can only happen for "tbody", "tfoot" and "thead", or in the fragment case), then this is a parse error and the token must be ignored.
Otherwise, close the cell (see below) and reprocess the current token.
Process the token using the rules for the "in body" insertion mode.
Where the steps above say to close the cell, they mean to run the following algorithm:
If the stack of open elements has a td
element in table scope, then act as if an end tag token
with the tag name "td" had been seen.
Otherwise, the stack of open elements will
have a
th
element in table scope; act as if an end
tag token with the tag name "th" had been seen.
The stack of open elements cannot have
both a td
and a th
element in table scope at the
same time, nor can it have neither when the close the
cell algorithm is invoked.
When the user agent is to apply the rules for the "in select" insertion mode, the user agent must handle the token as follows:
Parse error. Ignore the token.
Insert the token's character into the current node.
Append a Comment
node to the current
node with the data
attribute set to
the data given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
If the current node is an option
element, act as if an end tag with the tag name "option" had
been seen.
Insert an HTML element for the token.
If the current node is an option
element, act as if an end tag with the tag name "option" had
been seen.
If the current node is an
optgroup
element, act as if an end tag with the
tag name "optgroup" had been seen.
Insert an HTML element for the token.
First, if the current node is an
option
element, and the node immediately before
it in the stack of open elements is an
optgroup
element, then act as if an end tag with
the tag name "option" had been seen.
If the current node is an
optgroup
element, then pop that node from the
stack of open elements. Otherwise, this is a
parse error; ignore the token.
If the current node is an option
element, then pop that node from the stack of open
elements. Otherwise, this is a parse
error; ignore the token.
If the stack of open elements does not have an element in select scope with the same tag name as the token, this is a parse error. Ignore the token. (fragment case)
Otherwise:
Pop elements from the stack of open elements
until a select
element has been popped from the
stack.
Parse error. Act as if the token had been an end tag with the tag name "select" instead.
If the stack of open elements does not have a select
element in select scope, ignore the token. (fragment
case)
Otherwise, act as if an end tag with the tag name "select" had been seen, and reprocess the token.
Process the token using the rules for the "in head" insertion mode.
If the current node is not the root
html
element, then this is a parse
error.
The current node can only be the root
html
element in the fragment case.
Parse error. Ignore the token.
When the user agent is to apply the rules for the "in select in table" insertion mode, the user agent must handle the token as follows:
Parse error. Act as if an end tag with the tag name "select" had been seen, and reprocess the token.
If the stack of open elements has an element in table scope with the same tag name as that of the token, then act as if an end tag with the tag name "select" had been seen, and reprocess the token. Otherwise, ignore the token.
Process the token using the rules for the "in select" insertion mode.
When the user agent is to apply the rules for the "after body" insertion mode, the user agent must handle the token as follows:
Process the token using the rules for the "in body" insertion mode.
Append a Comment
node to the first element in
the stack of open elements (the html
element), with the data
attribute set to
the data given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
If the parser was originally created as part of the HTML fragment parsing algorithm, this is a parse error; ignore the token. (fragment case)
Otherwise, switch the insertion mode to "after after body".
Parse error. Switch the insertion mode to "in body" and reprocess the token.
When the user agent is to apply the rules for the "in frameset" insertion mode, the user agent must handle the token as follows:
Insert the character into the current node.
Append a Comment
node to the current
node with the data
attribute set to
the data given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
Insert an HTML element for the token.
If the current node is the root
html
element, then this is a parse
error; ignore the token. (fragment
case)
Otherwise, pop the current node from the stack of open elements.
If the parser was not originally created as part
of the HTML fragment parsing algorithm
(fragment case), and the current
node is no longer a frameset
element, then
switch the insertion mode to "after
frameset".
Insert an HTML element for the token. Immediately pop the current node off the stack of open elements.
Acknowledge the token's self-closing flag, if it is set.
Process the token using the rules for the "in head" insertion mode.
If the current node is not the root
html
element, then this is a parse
error.
The current node can only be the root
html
element in the fragment case.
Parse error. Ignore the token.
When the user agent is to apply the rules for the "after frameset" insertion mode, the user agent must handle the token as follows:
Insert the character into the current node.
Append a Comment
node to the current
node with the data
attribute set to
the data given in the comment token.
Parse error. Ignore the token.
Process the token using the rules for the "in body" insertion mode.
Switch the insertion mode to "after after frameset".
Process the token using the rules for the "in head" insertion mode.
Parse error. Ignore the token.
When the user agent is to apply the rules for the "after after body" insertion mode, the user agent must handle the token as follows:
Append a Comment
node to the Document
object with the data
attribute set to the
data given in the comment token.
Process the token using the rules for the "in body" insertion mode.
Parse error. Switch the insertion mode to "in body" and reprocess the token.
When the user agent is to apply the rules for the "after after frameset" insertion mode, the user agent must handle the token as follows:
Append a Comment
node to the Document
object with the data
attribute set to the
data given in the comment token.
Process the token using the rules for the "in body" insertion mode.
Process the token using the rules for the "in head" insertion mode.
Parse error. Ignore the token.
When the user agent is to apply the rules for parsing tokens in foreign content, the user agent must handle the token as follows:
Parse error. Insert a U+FFFD REPLACEMENT CHARACTER character into the current node.
Insert the token's character into the current node.
Insert the token's character into the current node.
Set the frameset-ok flag to "not ok".
Append a Comment
node to the current
node with the data
attribute set to
the data given in the comment token.
Parse error. Ignore the token.
Pop an element from the stack of open elements, and then keep popping more elements from the stack of open elements until the current node is a MathML text integration point, an HTML integration point, or an element in the HTML namespace.
Then, reprocess the token.
If the current node is an element in the MathML namespace, adjust MathML attributes for the token. (This fixes the case of MathML attributes that are not all lowercase.)
If the 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.)
Tag name | Element name |
---|---|
altglyph | altGlyph
|
altglyphdef | altGlyphDef
|
altglyphitem | altGlyphItem
|
animatecolor | animateColor
|
animatemotion | animateMotion
|
animatetransform | animateTransform
|
clippath | clipPath
|
feblend | feBlend
|
fecolormatrix | feColorMatrix
|
fecomponenttransfer | feComponentTransfer
|
fecomposite | feComposite
|
feconvolvematrix | feConvolveMatrix
|
fediffuselighting | feDiffuseLighting
|
fedisplacementmap | feDisplacementMap
|
fedistantlight | feDistantLight
|
feflood | feFlood
|
fefunca | feFuncA
|
fefuncb | feFuncB
|
fefuncg | feFuncG
|
fefuncr | feFuncR
|
fegaussianblur | feGaussianBlur
|
feimage | feImage
|
femerge | feMerge
|
femergenode | feMergeNode
|
femorphology | feMorphology
|
feoffset | feOffset
|
fepointlight | fePointLight
|
fespecularlighting | feSpecularLighting
|
fespotlight | feSpotLight
|
fetile | feTile
|
feturbulence | feTurbulence
|
foreignobject | foreignObject
|
glyphref | glyphRef
|
lineargradient | linearGradient
|
radialgradient | radialGradient
|
textpath | textPath
|
If the current node is an element in the SVG namespace, adjust SVG attributes for the token. (This fixes the case of SVG attributes that are not all lowercase.)
Adjust foreign attributes for the token. (This fixes the use of namespaced attributes, in particular XLink in SVG.)
Insert a foreign element for the token, in the same namespace as the current node.
If the token has its self-closing flag set, then run the appropriate steps from the following list:
Acknowledge the token's self-closing flag, and then act as if an end tag with the tag name "script" had been seen.
Pop the current node off the stack of open elements and acknowledge the token's self-closing flag.
script
element in the SVG namespacePop the current node off the stack of open elements.
Let the old insertion point have the same value as the current insertion point. Let the insertion point be just before the next input character.
Increment the parser's script nesting level by one. Set the parser pause flag to true.
Process
the script
element according to the SVG
rules, if the user agent supports SVG. [SVG]
Even if this causes new characters to be inserted into the tokenizer, the parser will not be executed reentrantly, since the parser pause flag is true.
Decrement the parser's script nesting level by one. If the parser's script nesting level is zero, then set the parser pause flag to false.
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.)
Run these steps:
Initialize node to be the current node (the bottommost node of the stack).
If node is not an element with the same tag name as the token, then this is a parse error.
Loop: 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.
Set node to the previous entry in the stack of open elements.
If node is not an element in the HTML namespace, return to the step labeled loop.
Otherwise, process the token according to the rules given in the section corresponding to the current insertion mode in HTML content.