[html5] r1310 - /

whatwg at whatwg.org whatwg at whatwg.org
Sun Mar 2 17:07:57 PST 2008


Author: ianh
Date: 2008-03-02 17:07:54 -0800 (Sun, 02 Mar 2008)
New Revision: 1310

Modified:
   index
   source
Log:
[e] (0) deindent the source

Modified: index
===================================================================
--- index	2008-03-03 01:02:46 UTC (rev 1309)
+++ index	2008-03-03 01:07:54 UTC (rev 1310)
@@ -42105,13 +42105,13 @@
        href="#div">div</a></code> element, then stop this algorithm.
      </li>
      <!-- an element <foo> is in this
-         list if the following markup:
+     list if the following markup:
 
-             <!DOCTYPE html><body><ol><li><foo><li>
+         <!DOCTYPE html><body><ol><li><foo><li>
 
-         ...results in the second <li> not being (in any way) a
-         descendant of the first <li>, or if <foo> is a formatting
-         element that gets reopened later. -->
+     ...results in the second <li> not being (in any way) a
+     descendant of the first <li>, or if <foo> is a formatting
+     element that gets reopened later. -->
 
      <li>
       <p>Otherwise, set <var title="">node</var> to the previous entry in the
@@ -42152,13 +42152,13 @@
        href="#div">div</a></code> element, then stop this algorithm.
      </li>
      <!-- an element <foo> is in this
-         list if the following markup:
+     list if the following markup:
 
-             <!DOCTYPE html><body><ol><dt><foo><dt>
+         <!DOCTYPE html><body><ol><dt><foo><dt>
 
-         ...results in the second <li> not being (in any way) a
-         descendant of the first <li>, or if <foo> is a formatting
-         element that gets reopened later. -->
+     ...results in the second <li> not being (in any way) a
+     descendant of the first <li>, or if <foo> is a formatting
+     element that gets reopened later. -->
 
      <li>
       <p>Otherwise, set <var title="">node</var> to the previous entry in the
@@ -42206,9 +42206,9 @@
      that of the token, then pop elements from this stack until an element
      with that tag name has been popped from the stack.</p>
     <!-- XXX quirk (except for in certain cases?):
-        <p>Otherwise, act as if a start tag with the tag name given in
-        the token had been seen, then reprocess the current token.</p>
-        -->
+    <p>Otherwise, act as if a start tag with the tag name given in
+    the token had been seen, then reprocess the current token.</p>
+    -->
     
 
    <dt>An end tag whose tag name is "form"
@@ -42277,16 +42277,16 @@
      scope</a>, then act as if an end tag with the tag name <code><a
      href="#p">p</a></code> had been seen.</p>
     <!-- Removed for compatibility with IE7, though all other
-             browsers do it this way. If you do put this back, make
-             sure to handle <h1><a><h2>, as in Webkit bug 12646.
-             http://bugs.webkit.org/show_bug.cgi?id=12646
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has in scope</span> an element whose tag
-        name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
-        this is a <span>parse error</span>; pop elements from the
-        stack until an element with one of those tag names has been
-        popped from the stack.</p>
-        -->
+         browsers do it this way. If you do put this back, make
+         sure to handle <h1><a><h2>, as in Webkit bug 12646.
+         http://bugs.webkit.org/show_bug.cgi?id=12646
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has in scope</span> an element whose tag
+    name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
+    this is a <span>parse error</span>; pop elements from the
+    stack until an element with one of those tag names has been
+    popped from the stack.</p>
+    -->
     
     <p><a href="#insert" title="insert an html element">Insert an HTML
      element</a> for the token.</p>
@@ -42310,14 +42310,14 @@
      from the stack until an element with one of those tag names has been
      popped from the stack.</p>
     <!-- XXX quirk:
-        <p>Otherwise, act as if a start tag with the tag name given in
-        the token had been seen, then reprocess the current token.</p>
-        -->
+    <p>Otherwise, act as if a start tag with the tag name given in
+    the token had been seen, then reprocess the current token.</p>
+    -->
     </dd>
    <!-- ADOPTION AGENCY ELEMENTS
-            Mozilla-only: bdo blink del ins sub sup q
-            Safari-only: code dfn kbd nobr samp var wbr
-            Both: a b big em font i s small strike strong tt u -->
+        Mozilla-only: bdo blink del ins sub sup q
+        Safari-only: code dfn kbd nobr samp var wbr
+        Both: a b big em font i s small strike strong tt u -->
 
    <dt>A start tag whose tag name is "a"
 
@@ -42523,9 +42523,9 @@
      href="#formatting">formatting</a> category ever get cloned by this
      algorithm.</p>
     <!--XXX
-        <div class="example">
-         <p class="big-issue">Need an example.</p>
-        </div>
+    <div class="example">
+     <p class="big-issue">Need an example.</p>
+    </div>
 -->
     
     <p class=note>Because of the way this algorithm causes elements to change
@@ -42637,8 +42637,8 @@
     <p><a href="#parse0">Parse error</a>. Change the token's tag name to
      "img" and reprocess it. (Don't ask.)</p>
     <!-- As of
-        2005-12, studies showed that around 0.2% of pages used the
-        <image> element. -->
+    2005-12, studies showed that around 0.2% of pages used the
+    <image> element. -->
     
 
    <dt>A start tag whose tag name is "input"
@@ -42652,7 +42652,7 @@
 
     <p>If the <a href="#form-element"><code title="">form</code> element
      pointer</a> is not null, then <span>associate</span><!--XXX
-        xref! -->
+    xref! -->
      the <code>input</code> element with the <code>form</code> element
      pointed to by the <a href="#form-element"><code title="">form</code>
      element pointer</a>.</p>
@@ -42717,10 +42717,10 @@
    </dd>
    <!-- XXX keygen support; don't forget form element pointer!
 
-       <dt>A start tag whose tag name is "keygen"</dt>
-       <dd>
-        ...
-       </dd>
+   <dt>A start tag whose tag name is "keygen"</dt>
+   <dd>
+    ...
+   </dd>
 -->
 
    <dt>A start tag whose tag name is "textarea"
@@ -42730,7 +42730,7 @@
 
     <p>If the <a href="#form-element"><code title="">form</code> element
      pointer</a> is not null, then <span>associate</span><!--XXX
-        xref! -->
+    xref! -->
      the <code>textarea</code> element with the <code>form</code> element
      pointed to by the <a href="#form-element"><code title="">form</code>
      element pointer</a>.</p>
@@ -42820,10 +42820,10 @@
      element.</p>
     <!--
 Put the following into the MathML namespace if parsed:
-   math, mrow, mfrac, msqrt, mroot, mstyle, merror, mpadded, 
-   mphantom, mfenced, menclose, msub, msup, msubsup, munder, 
-   mover, munderover, mmultiscripts, mtable, mlabeledtr, mtr, 
-   mtd, maction
+math, mrow, mfrac, msqrt, mroot, mstyle, merror, mpadded, 
+mphantom, mfenced, menclose, msub, msup, msubsup, munder, 
+mover, munderover, mmultiscripts, mtable, mlabeledtr, mtr, 
+mtd, maction
 -->
     
 

Modified: source
===================================================================
--- source	2008-03-03 01:02:46 UTC (rev 1309)
+++ source	2008-03-03 01:07:54 UTC (rev 1310)
@@ -38516,2561 +38516,2561 @@
 -->
 
 
-      <h6>The <dfn title="insertion mode: before head">before head</dfn> insertion mode</h6>
+  <h6>The <dfn title="insertion mode: before head">before head</dfn> insertion mode</h6>
 
-      <p>Handle the token as follows:</p>
+  <p>Handle the token as follows:</p>
 
-      <dl class="switch">
+  <dl class="switch">
 
-       <dt>An end-of-file token</dt>
-       <dd>
-        <p><span>Stop parsing, with prejudice.</span></p>
-       </dd>
+   <dt>An end-of-file token</dt>
+   <dd>
+    <p><span>Stop parsing, with prejudice.</span></p>
+   </dd>
 
-       <dt>A character token that is one of one of U+0009
-       CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
-       TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
-       or U+0020 SPACE</dt>
-       <dd>
-        <p><span title="append a character">Append the character</span> to
-        the <span>current node</span>.</p>
-       </dd>
+   <dt>A character token that is one of one of U+0009
+   CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+   TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+   or U+0020 SPACE</dt>
+   <dd>
+    <p><span title="append a character">Append the character</span> to
+    the <span>current node</span>.</p>
+   </dd>
 
-       <dt>A comment token</dt>
-       <dd>
-        <p>Append a <code>Comment</code> node to the <span>current
-        node</span> with the <code title="">data</code> attribute set to
-        the data given in the comment token.</p>
-       </dd>
+   <dt>A comment token</dt>
+   <dd>
+    <p>Append a <code>Comment</code> node to the <span>current
+    node</span> with the <code title="">data</code> attribute set to
+    the data given in the comment token.</p>
+   </dd>
 
-       <dt>A DOCTYPE token</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>A DOCTYPE token</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "html"</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in body">in
-        body</span>".</p>
-       </dd>
+   <dt>A start tag whose tag name is "html"</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in body">in
+    body</span>".</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "head"</dt>
-       <dd>
+   <dt>A start tag whose tag name is "head"</dt>
+   <dd>
 
-        <p><span>Create an element for the token</span>.</p>
+    <p><span>Create an element for the token</span>.</p>
 
-        <p>Set the <span><code title="">head</code> element
-        pointer</span> to this new element node.</p>
+    <p>Set the <span><code title="">head</code> element
+    pointer</span> to this new element node.</p>
 
-        <p>Append the new element to the <span>current node</span> and
-        push it onto the <span>stack of open elements</span>.</p>
+    <p>Append the new element to the <span>current node</span> and
+    push it onto the <span>stack of open elements</span>.</p>
 
-        <p>Change the <span>insertion mode</span> to "<span
-        title="insertion mode: in head">in head</span>".</p>
+    <p>Change the <span>insertion mode</span> to "<span
+    title="insertion mode: in head">in head</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag token whose tag name is one of: "base", "link",
-       "meta", "script", "style", "title"</dt>
+   <dt>A start tag token whose tag name is one of: "base", "link",
+   "meta", "script", "style", "title"</dt>
 
-       <dd>
+   <dd>
 
-        <p>Act as if a start tag token with the tag name "head" and no
-        attributes had been seen, then reprocess the current
-        token.</p>
+    <p>Act as if a start tag token with the tag name "head" and no
+    attributes had been seen, then reprocess the current
+    token.</p>
 
-        <p class="note">This will result in a <code>head</code>
-        element being generated, and with the current token being
-        reprocessed in the "<span title="insertion mode: in head">in
-        head</span>" <span>insertion mode</span>.</p>
+    <p class="note">This will result in a <code>head</code>
+    element being generated, and with the current token being
+    reprocessed in the "<span title="insertion mode: in head">in
+    head</span>" <span>insertion mode</span>.</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is one of: "head", "body", "html", "p", "br"</dt>
-       <dd>
+   <dt>An end tag whose tag name is one of: "head", "body", "html", "p", "br"</dt>
+   <dd>
 
-        <p>Act as if a start tag token with the tag name "head" and no
-        attributes had been seen, then reprocess the current
-        token.</p>
+    <p>Act as if a start tag token with the tag name "head" and no
+    attributes had been seen, then reprocess the current
+    token.</p>
 
-       </dd>
+   </dd>
 
-       <dt>Any other end tag</dt>
-       <dd>
+   <dt>Any other end tag</dt>
+   <dd>
 
-        <p><span>Parse error</span>. Ignore the token.</p>
+    <p><span>Parse error</span>. Ignore the token.</p>
 
-        <p class="big-issue">Do we really want to ignore end tags here?</p>
+    <p class="big-issue">Do we really want to ignore end tags here?</p>
 
-       </dd>
+   </dd>
 
-       <dt>A character token that is <em>not</em> one of U+0009 CHARACTER
-       TABULATION, U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C
-       FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),--> or U+0020 SPACE</dt>
-       <dt>Any other start tag token</dt>
-       <dd>
+   <dt>A character token that is <em>not</em> one of U+0009 CHARACTER
+   TABULATION, U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C
+   FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),--> or U+0020 SPACE</dt>
+   <dt>Any other start tag token</dt>
+   <dd>
 
-        <p>Act as if a start tag token with the tag name "head" and no
-        attributes had been seen, then reprocess the current
-        token.</p>
+    <p>Act as if a start tag token with the tag name "head" and no
+    attributes had been seen, then reprocess the current
+    token.</p>
 
-        <p class="note">This will result in an empty <code>head</code>
-        element being generated, with the current token being
-        reprocessed in the "<span title="insertion mode: after
-        head">after head</span>" <span>insertion mode</span>.</p>
+    <p class="note">This will result in an empty <code>head</code>
+    element being generated, with the current token being
+    reprocessed in the "<span title="insertion mode: after
+    head">after head</span>" <span>insertion mode</span>.</p>
 
-       </dd>
+   </dd>
 
-      </dl>
+  </dl>
 
 
-      <h6 id="parsing-main-inhead">The <dfn title="insertion mode: in head">in head</dfn> insertion mode</h6>
+  <h6 id="parsing-main-inhead">The <dfn title="insertion mode: in head">in head</dfn> insertion mode</h6>
 
-      <p>Handle the token as follows.</p>
+  <p>Handle the token as follows.</p>
 
-      <dl class="switch">
+  <dl class="switch">
 
-       <dt>An end-of-file token</dt>
-       <dd>
-        <p><span>Stop parsing, with prejudice.</span></p>
-       </dd>
+   <dt>An end-of-file token</dt>
+   <dd>
+    <p><span>Stop parsing, with prejudice.</span></p>
+   </dd>
 
-       <dt>A character token that is one of one of U+0009
-       CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
-       TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
-       or U+0020 SPACE</dt>
-       <dd>
-        <p><span title="append a character">Append the character</span> to
-        the <span>current node</span>.</p>
-       </dd>
+   <dt>A character token that is one of one of U+0009
+   CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+   TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+   or U+0020 SPACE</dt>
+   <dd>
+    <p><span title="append a character">Append the character</span> to
+    the <span>current node</span>.</p>
+   </dd>
 
-       <dt>A comment token</dt>
-       <dd>
-        <p>Append a <code>Comment</code> node to the <span>current
-        node</span> with the <code title="">data</code> attribute set to
-        the data given in the comment token.</p>
-       </dd>
+   <dt>A comment token</dt>
+   <dd>
+    <p>Append a <code>Comment</code> node to the <span>current
+    node</span> with the <code title="">data</code> attribute set to
+    the data given in the comment token.</p>
+   </dd>
 
-       <dt>A DOCTYPE token</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>A DOCTYPE token</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "html"</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in body">in
-        body</span>".</p>
-       </dd>
+   <dt>A start tag whose tag name is "html"</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in body">in
+    body</span>".</p>
+   </dd>
 
-       <dt>A start tag whose tag name is one of: "base", "link"</dt>
-       <dd>
-        <p><span title="insert an html element">Insert an HTML
-        element</span> for the token.</p>
-       </dd>
+   <dt>A start tag whose tag name is one of: "base", "link"</dt>
+   <dd>
+    <p><span title="insert an html element">Insert an HTML
+    element</span> for the token.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "meta"</dt>
-       <dd>
-        <p><span title="insert an html element">Insert an HTML
-        element</span> for the token.</p>
+   <dt>A start tag whose tag name is "meta"</dt>
+   <dd>
+    <p><span title="insert an html element">Insert an HTML
+    element</span> for the token.</p>
 
-        <p id="meta-charset-during-parse">If the element has a <code
-        title="attr-meta-charset">charset</code> attribute, and its
-        value is a supported encoding, and the <span
-        title="concept-encoding-confidence">confidence</span> is
-        currently <i>tentative</i>, then <span>change the
-        encoding</span> to the encoding given by the value of the
-        <code title="attr-meta-charset">charset</code> attribute.</p>
+    <p id="meta-charset-during-parse">If the element has a <code
+    title="attr-meta-charset">charset</code> attribute, and its
+    value is a supported encoding, and the <span
+    title="concept-encoding-confidence">confidence</span> is
+    currently <i>tentative</i>, then <span>change the
+    encoding</span> to the encoding given by the value of the
+    <code title="attr-meta-charset">charset</code> attribute.</p>
 
-        <p>Otherwise, if the element has a <code
-        title="attr-meta-charset">content</code> attribute, and
-        applying the <span>algorithm for extracting an encoding from a
-        Content-Type</span> to its value returns a supported encoding
-        <var title="">encoding</var>, and the <span
-        title="concept-encoding-confidence">confidence</span> is
-        currently <i>tentative</i>, then <span>change the
-        encoding</span> to the encoding <var
-        title="">encoding</var>.</p>
+    <p>Otherwise, if the element has a <code
+    title="attr-meta-charset">content</code> attribute, and
+    applying the <span>algorithm for extracting an encoding from a
+    Content-Type</span> to its value returns a supported encoding
+    <var title="">encoding</var>, and the <span
+    title="concept-encoding-confidence">confidence</span> is
+    currently <i>tentative</i>, then <span>change the
+    encoding</span> to the encoding <var
+    title="">encoding</var>.</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is "title"</dt>
-       <dd>
-        <p>Follow the <span>generic RCDATA parsing algorithm</span>,
-        with the <span><code>head</code> element pointer</span> as the
-        <var title="">context node</var>, unless that's null, in which
-        case use the <span>current node</span> (<span>fragment
-        cose</span>).</p>
-       </dd>
+   <dt>A start tag whose tag name is "title"</dt>
+   <dd>
+    <p>Follow the <span>generic RCDATA parsing algorithm</span>,
+    with the <span><code>head</code> element pointer</span> as the
+    <var title="">context node</var>, unless that's null, in which
+    case use the <span>current node</span> (<span>fragment
+    cose</span>).</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "noscript", if <span>scripting is enabled</span>:</dt>
-       <dt>A start tag whose tag name is "style"</dt>
-       <dd>
-        <p>Follow the <span>generic CDATA parsing algorithm</span>,
-        with the <span>current node</span> as the <var
-        title="">context node</var>.</p>
-       </dd>
+   <dt>A start tag whose tag name is "noscript", if <span>scripting is enabled</span>:</dt>
+   <dt>A start tag whose tag name is "style"</dt>
+   <dd>
+    <p>Follow the <span>generic CDATA parsing algorithm</span>,
+    with the <span>current node</span> as the <var
+    title="">context node</var>.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "noscript", if <span>scripting is disabled</span>:</dt>
-       <dd>
+   <dt>A start tag whose tag name is "noscript", if <span>scripting is disabled</span>:</dt>
+   <dd>
 
-        <p><span title="insert an HTML element">Insert a
-        <code>noscript</code> element</span> for the token.</p>
+    <p><span title="insert an HTML element">Insert a
+    <code>noscript</code> element</span> for the token.</p>
 
-        <p>Change the <span>insertion mode</span> to "<span
-        title="insertion mode: in head noscript">in head
-        noscript</span>".</p>
+    <p>Change the <span>insertion mode</span> to "<span
+    title="insertion mode: in head noscript">in head
+    noscript</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt id="scriptTag">A start tag whose tag name is "script"</dt>
-       <dd>
+   <dt id="scriptTag">A start tag whose tag name is "script"</dt>
+   <dd>
 
-        <p><span>Create an element for the token</span>.</p>
+    <p><span>Create an element for the token</span>.</p>
 
-        <p>Mark the element as being
-        <span>"parser-inserted"</span>. This ensures that, if the
-        script is external, any <code
-        title="dom-document-write-HTML">document.write()</code> calls
-        in the script will execute in-line, instead of blowing the
-        document away, as would happen in most other cases.</p>
+    <p>Mark the element as being
+    <span>"parser-inserted"</span>. This ensures that, if the
+    script is external, any <code
+    title="dom-document-write-HTML">document.write()</code> calls
+    in the script will execute in-line, instead of blowing the
+    document away, as would happen in most other cases.</p>
 
-        <p>Switch the tokeniser's <span>content model flag</span> to
-        the CDATA state.</p>
+    <p>Switch the tokeniser's <span>content model flag</span> to
+    the CDATA state.</p>
 
-        <p>Then, collect all the character tokens that the tokeniser
-        returns until it returns a token that is not a character
-        token, or until it stops tokenising.</p>
+    <p>Then, collect all the character tokens that the tokeniser
+    returns until it returns a token that is not a character
+    token, or until it stops tokenising.</p>
 
-        <p>If this process resulted in a collection of character
-        tokens, append a single <code>Text</code> node to the
-        <code>script</code> element node whose contents is the
-        concatenation of all those tokens' characters.</p>
+    <p>If this process resulted in a collection of character
+    tokens, append a single <code>Text</code> node to the
+    <code>script</code> element node whose contents is the
+    concatenation of all those tokens' characters.</p>
 
-        <p>The tokeniser's <span>content model flag</span> will have
-        switched back to the PCDATA state.</p>
+    <p>The tokeniser's <span>content model flag</span> will have
+    switched back to the PCDATA state.</p>
 
-        <p>If the next token is not an end tag token with the tag name
-        "script", then this is a <span>parse error</span>; mark the
-        <code>script</code> element as <span>"already
-        executed"</span>. Otherwise, the token is the
-        <code>script</code> element's end tag, so ignore it.</p>
+    <p>If the next token is not an end tag token with the tag name
+    "script", then this is a <span>parse error</span>; mark the
+    <code>script</code> element as <span>"already
+    executed"</span>. Otherwise, the token is the
+    <code>script</code> element's end tag, so ignore it.</p>
 
-        <p>If the parser was originally created for the <span>HTML
-        fragment parsing algorithm</span>, then mark the
-        <code>script</code> element as <span>"already
-        executed"</span>, and skip the rest of the processing
-        described for this token (including the part below where
-        "<span title="the script that will execute as soon as the
-        parser resumes">scripts that will execute as soon as the
-        parser resumes</span>" are executed). (<span>fragment
-        case</span>)</p>
+    <p>If the parser was originally created for the <span>HTML
+    fragment parsing algorithm</span>, then mark the
+    <code>script</code> element as <span>"already
+    executed"</span>, and skip the rest of the processing
+    described for this token (including the part below where
+    "<span title="the script that will execute as soon as the
+    parser resumes">scripts that will execute as soon as the
+    parser resumes</span>" are executed). (<span>fragment
+    case</span>)</p>
 
-        <p class="note">Marking the <code>script</code> element as
-        "already executed" prevents it from executing when it is
-        inserted into the document a few paragraphs below. Thus,
-        scripts missing their end tags and scripts that were inserted
-        using <code title="dom-innerHTML-HTML">innerHTML</code> aren't
-        executed.</p>
+    <p class="note">Marking the <code>script</code> element as
+    "already executed" prevents it from executing when it is
+    inserted into the document a few paragraphs below. Thus,
+    scripts missing their end tags and scripts that were inserted
+    using <code title="dom-innerHTML-HTML">innerHTML</code> aren't
+    executed.</p>
 
-        <p>Let the <var title="">old insertion point</var> have the
-        same value as the current <span>insertion point</span>. Let
-        the <span>insertion point</span> be just before the <span>next
-        input character</span>.</p>
+    <p>Let the <var title="">old insertion point</var> have the
+    same value as the current <span>insertion point</span>. Let
+    the <span>insertion point</span> be just before the <span>next
+    input character</span>.</p>
 
-        <p>Append the new element to the <span>current node</span>.
-        <span title="running a script">Special processing occurs when
-        a <code>script</code> element is inserted into a
-        document</span> that might cause some script to execute, which
-        might cause <span title="dom-document-write-HTML">new
-        characters to be inserted into the tokeniser</span>.</p>
+    <p>Append the new element to the <span>current node</span>.
+    <span title="running a script">Special processing occurs when
+    a <code>script</code> element is inserted into a
+    document</span> that might cause some script to execute, which
+    might cause <span title="dom-document-write-HTML">new
+    characters to be inserted into the tokeniser</span>.</p>
 
-        <p>Let the <span>insertion point</span> have the value of the
-        <var title="">old insertion point</var>. (In other words,
-        restore the <span>insertion point</span> to the value it had
-        before the previous paragraph. This value might be the
-        "undefined" value.)</p>
+    <p>Let the <span>insertion point</span> have the value of the
+    <var title="">old insertion point</var>. (In other words,
+    restore the <span>insertion point</span> to the value it had
+    before the previous paragraph. This value might be the
+    "undefined" value.)</p>
 
-        <p id="scriptTagParserResumes">At this stage, if there is
-        <span title="the script that will execute as soon as the
-        parser resumes">a script that will execute as soon as the
-        parser resumes</span>, then:</p>
+    <p id="scriptTagParserResumes">At this stage, if there is
+    <span title="the script that will execute as soon as the
+    parser resumes">a script that will execute as soon as the
+    parser resumes</span>, then:</p>
 
-        <dl class="switch">
+    <dl class="switch">
 
-         <dt>If the tree construction stage is <a
-         href="#nestedParsing">being called reentrantly</a>, say from
-         a call to <code
-         title="dom-document-write-HTML">document.write()</code>:</dt>
+     <dt>If the tree construction stage is <a
+     href="#nestedParsing">being called reentrantly</a>, say from
+     a call to <code
+     title="dom-document-write-HTML">document.write()</code>:</dt>
 
-         <dd><p>Abort the processing of any nested invokations of the
-         tokeniser, yielding control back to the caller. (Tokenisation
-         will resume when the caller returns to the "outer" tree
-         construction stage.)</p></dd>
+     <dd><p>Abort the processing of any nested invokations of the
+     tokeniser, yielding control back to the caller. (Tokenisation
+     will resume when the caller returns to the "outer" tree
+     construction stage.)</p></dd>
 
-         <dt>Otherwise:</dt>
+     <dt>Otherwise:</dt>
 
-         <dd>
+     <dd>
 
-          <p>Follow these steps:</p>
+      <p>Follow these steps:</p>
 
-          <ol>
+      <ol>
 
-           <li><p>Let <var title="">the script</var> be <span>the
-           script that will execute as soon as the parser
-           resumes</span>. There is no longer <span title="the script
-           that will execute as soon as the parser resumes">a script
-           that will execute as soon as the parser
-           resumes</span>.</p></li>
+       <li><p>Let <var title="">the script</var> be <span>the
+       script that will execute as soon as the parser
+       resumes</span>. There is no longer <span title="the script
+       that will execute as soon as the parser resumes">a script
+       that will execute as soon as the parser
+       resumes</span>.</p></li>
 
-           <li><p><span>Pause</span> until the script has <span>completed
-           loading</span><!-- XXX xref -->.</p></li>
+       <li><p><span>Pause</span> until the script has <span>completed
+       loading</span><!-- XXX xref -->.</p></li>
 
-           <li><p>Let the <span>insertion point</span> be just before the
-           <span>next input character</span>.</p></li>
+       <li><p>Let the <span>insertion point</span> be just before the
+       <span>next input character</span>.</p></li>
 
-           <li><p><span title="executing a script block">Execute the
-           script</span>.</p></li>
+       <li><p><span title="executing a script block">Execute the
+       script</span>.</p></li>
 
-           <li><p>Let the <span>insertion point</span> be undefined
-           again.</p></li>
+       <li><p>Let the <span>insertion point</span> be undefined
+       again.</p></li>
 
-           <li><p>If there is once again <span title="the script that
-           will execute as soon as the parser resumes">a script that
-           will execute as soon as the parser resumes</span>, then
-           repeat these steps from step 1.</p></li>
+       <li><p>If there is once again <span title="the script that
+       will execute as soon as the parser resumes">a script that
+       will execute as soon as the parser resumes</span>, then
+       repeat these steps from step 1.</p></li>
 
-          </ol>
+      </ol>
 
-         </dd>
+     </dd>
 
-        </dl>
+    </dl>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is "head"</dt>
-       <dd>
+   <dt>An end tag whose tag name is "head"</dt>
+   <dd>
 
-        <p>Pop the <span>current node</span> (which will be the
-        <code>head</code> element) off the <span>stack of open
-        elements</span>.</p>
+    <p>Pop the <span>current node</span> (which will be the
+    <code>head</code> element) off the <span>stack of open
+    elements</span>.</p>
 
-        <p>Change the <span>insertion mode</span> to "<span
-        title="insertion mode: after head">after head</span>".</p>
+    <p>Change the <span>insertion mode</span> to "<span
+    title="insertion mode: after head">after head</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is one of: "body", "html", "p", "br"</dt>
-       <dd>
-        <p>Act as described in the "anything else" entry below.</p>
-       </dd>
+   <dt>An end tag whose tag name is one of: "body", "html", "p", "br"</dt>
+   <dd>
+    <p>Act as described in the "anything else" entry below.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "head"</dt>
-       <dt>Any other end tag</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>A start tag whose tag name is "head"</dt>
+   <dt>Any other end tag</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>Anything else</dt>
-       <dd>
+   <dt>Anything else</dt>
+   <dd>
 
-        <p>Act as if an end tag token with the tag name "head" had
-        been seen, and reprocess the current token.</p>
+    <p>Act as if an end tag token with the tag name "head" had
+    been seen, and reprocess the current token.</p>
 
-        <p class="big-issue">In certain UAs, <a
-        href="https://bugzilla.mozilla.org/attachment.cgi?id=180157&action=view">some
-        elements</a> don't trigger the "in body" mode straight away,
-        but instead get put into the head. Do we want to copy
-        that?</p>
+    <p class="big-issue">In certain UAs, <a
+    href="https://bugzilla.mozilla.org/attachment.cgi?id=180157&action=view">some
+    elements</a> don't trigger the "in body" mode straight away,
+    but instead get put into the head. Do we want to copy
+    that?</p>
 
-       </dd>
+   </dd>
 
-      </dl>
+  </dl>
 
 
-      <h6 id="parsing-main-inheadnoscript">The <dfn title="insertion mode: in head noscript">in head noscript</dfn> insertion mode</h6>
+  <h6 id="parsing-main-inheadnoscript">The <dfn title="insertion mode: in head noscript">in head noscript</dfn> insertion mode</h6>
 
-      <p>Handle the token as follows.</p>
+  <p>Handle the token as follows.</p>
 
-      <dl class="switch">
+  <dl class="switch">
 
-       <dt>An end-of-file token</dt>
-       <dd>
-        <p><span>Stop parsing, with prejudice.</span></p>
-       </dd>
+   <dt>An end-of-file token</dt>
+   <dd>
+    <p><span>Stop parsing, with prejudice.</span></p>
+   </dd>
 
-       <dt>A DOCTYPE token</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>A DOCTYPE token</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "html"</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in body">in
-        body</span>".</p>
-       </dd>
+   <dt>A start tag whose tag name is "html"</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in body">in
+    body</span>".</p>
+   </dd>
 
-       <dt>An end tag whose tag name is "noscript"</dt>
-       <dd>
+   <dt>An end tag whose tag name is "noscript"</dt>
+   <dd>
 
-        <p>Pop the <span>current node</span> (which will be a
-        <code>noscript</code> element) from the <span>stack of open
-        elements</span>; the new <span>current node</span> will be a
-        <code>head</code> element.</p>
+    <p>Pop the <span>current node</span> (which will be a
+    <code>noscript</code> element) from the <span>stack of open
+    elements</span>; the new <span>current node</span> will be a
+    <code>head</code> element.</p>
 
-        <p>Switch the <span>insertion mode</span> to "<span
-        title="insertion mode: in head">in head</span>".</p>
+    <p>Switch the <span>insertion mode</span> to "<span
+    title="insertion mode: in head">in head</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>A character token that is one of one of U+0009
-       CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
-       TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
-       or U+0020 SPACE</dt>
-       <dt>A comment token</dt>
-       <dt>A start tag whose tag name is one of: "link", "meta", "style"</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in head">in
-        head</span>".</p>
-       </dd>
+   <dt>A character token that is one of one of U+0009
+   CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+   TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+   or U+0020 SPACE</dt>
+   <dt>A comment token</dt>
+   <dt>A start tag whose tag name is one of: "link", "meta", "style"</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in head">in
+    head</span>".</p>
+   </dd>
 
-       <dt>An end tag whose tag name is one of: "p", "br"</dt>
-       <dd>
-        <p>Act as described in the "anything else" entry below.</p>
-       </dd>
+   <dt>An end tag whose tag name is one of: "p", "br"</dt>
+   <dd>
+    <p>Act as described in the "anything else" entry below.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is one of: "head", "noscript"</dt>
-       <dt>Any other end tag</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>A start tag whose tag name is one of: "head", "noscript"</dt>
+   <dt>Any other end tag</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>Anything else</dt>
-       <dd>
-        <p><span>Parse error</span>. Act as if an end tag with the tag
-        name "noscript" had been seen and reprocess the current
-        token.</p>
-       </dd>
+   <dt>Anything else</dt>
+   <dd>
+    <p><span>Parse error</span>. Act as if an end tag with the tag
+    name "noscript" had been seen and reprocess the current
+    token.</p>
+   </dd>
 
-      </dl>
+  </dl>
 
 
-      <h6>The <dfn title="insertion mode: after head">after head</dfn> insertion mode</h6>
+  <h6>The <dfn title="insertion mode: after head">after head</dfn> insertion mode</h6>
 
-      <p>Handle the token as follows:</p>
+  <p>Handle the token as follows:</p>
 
-      <dl class="switch">
+  <dl class="switch">
 
-       <dt>An end-of-file token</dt>
-       <dd>
-        <p><span>Stop parsing, with prejudice.</span></p>
-       </dd>
+   <dt>An end-of-file token</dt>
+   <dd>
+    <p><span>Stop parsing, with prejudice.</span></p>
+   </dd>
 
-       <dt>A character token that is one of one of U+0009
-       CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
-       TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
-       or U+0020 SPACE</dt>
-       <dd>
-        <p><span title="append a character">Append the character</span> to
-        the <span>current node</span>.</p>
-       </dd>
+   <dt>A character token that is one of one of U+0009
+   CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+   TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+   or U+0020 SPACE</dt>
+   <dd>
+    <p><span title="append a character">Append the character</span> to
+    the <span>current node</span>.</p>
+   </dd>
 
-       <dt>A comment token</dt>
-       <dd>
-        <p>Append a <code>Comment</code> node to the <span>current
-        node</span> with the <code title="">data</code> attribute set to
-        the data given in the comment token.</p>
-       </dd>
+   <dt>A comment token</dt>
+   <dd>
+    <p>Append a <code>Comment</code> node to the <span>current
+    node</span> with the <code title="">data</code> attribute set to
+    the data given in the comment token.</p>
+   </dd>
 
-       <dt>A DOCTYPE token</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>A DOCTYPE token</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "html"</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in body">in
-        body</span>".</p>
-       </dd>
+   <dt>A start tag whose tag name is "html"</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in body">in
+    body</span>".</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "body"</dt>
-       <dd>
+   <dt>A start tag whose tag name is "body"</dt>
+   <dd>
 
-        <p><span title="insert an HTML element">Insert a
-        <code>body</code> element</span> for the token.</p>
+    <p><span title="insert an HTML element">Insert a
+    <code>body</code> element</span> for the token.</p>
 
-        <p>Change the <span>insertion mode</span> to "<span
-        title="insertion mode: in body">in body</span>".</p>
+    <p>Change the <span>insertion mode</span> to "<span
+    title="insertion mode: in body">in body</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is "frameset"</dt>
-       <dd>
+   <dt>A start tag whose tag name is "frameset"</dt>
+   <dd>
 
-        <p><span title="insert an HTML element">Insert a
-        <code>frameset</code> element</span> for the token.</p>
+    <p><span title="insert an HTML element">Insert a
+    <code>frameset</code> element</span> for the token.</p>
 
-        <p>Change the <span>insertion mode</span> to "<span
-        title="insertion mode: in frameset">in frameset</span>".</p>
+    <p>Change the <span>insertion mode</span> to "<span
+    title="insertion mode: in frameset">in frameset</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag token whose tag name is one of: "base", "link",
-       "meta", "script", "style", "title"</dt>
-       <dd>
+   <dt>A start tag token whose tag name is one of: "base", "link",
+   "meta", "script", "style", "title"</dt>
+   <dd>
 
-        <p><span>Parse error</span>.</p>
+    <p><span>Parse error</span>.</p>
 
-        <p>Push the node pointed to by the <span><code
-        title="">head</code> element pointer</span> onto the
-        <span>stack of open elements</span>.</p>
+    <p>Push the node pointed to by the <span><code
+    title="">head</code> element pointer</span> onto the
+    <span>stack of open elements</span>.</p>
 
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in head">in
-        head</span>".</p>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in head">in
+    head</span>".</p>
 
-        <p>Pop the <span>current node</span> (which will be the node
-        pointed to by the <span><code title="">head</code> element
-        pointer</span>) off the <span>stack of open
-        elements</span>.</p>
+    <p>Pop the <span>current node</span> (which will be the node
+    pointed to by the <span><code title="">head</code> element
+    pointer</span>) off the <span>stack of open
+    elements</span>.</p>
 
-       </dd>
+   </dd>
 
-       <dt>Anything else</dt>
-       <dd>
-        <p>Act as if a start tag token with the tag name "body" and no
-        attributes had been seen, and then reprocess the current
-        token.</p>
-       </dd>
-      
-      </dl>
+   <dt>Anything else</dt>
+   <dd>
+    <p>Act as if a start tag token with the tag name "body" and no
+    attributes had been seen, and then reprocess the current
+    token.</p>
+   </dd>
 
+  </dl>
 
-      <h6 id="parsing-main-inbody">The <dfn title="insertion mode: in body">in body</dfn> insertion mode</h6>
 
-      <p>Handle the token as follows:</p>
+  <h6 id="parsing-main-inbody">The <dfn title="insertion mode: in body">in body</dfn> insertion mode</h6>
 
-      <dl class="switch">
+  <p>Handle the token as follows:</p>
 
-       <dt>An end-of-file token</dt>
-       <dd>
-        <p><span>Stop parsing, with prejudice.</span></p>
-       </dd>
+  <dl class="switch">
 
-       <dt>A character token</dt>
-       <dd>
+   <dt>An end-of-file token</dt>
+   <dd>
+    <p><span>Stop parsing, with prejudice.</span></p>
+   </dd>
 
-        <p><span>Reconstruct the active formatting elements</span>, if
-        any.</p>
+   <dt>A character token</dt>
+   <dd>
 
-        <p><span title="append a character">Append the token's
-        character</span> to the <span>current node</span>.</p>
+    <p><span>Reconstruct the active formatting elements</span>, if
+    any.</p>
 
-       </dd>
+    <p><span title="append a character">Append the token's
+    character</span> to the <span>current node</span>.</p>
 
-       <dt>A comment token</dt>
-       <dd>
-        <p>Append a <code>Comment</code> node to the <span>current
-        node</span> with the <code title="">data</code> attribute set to
-        the data given in the comment token.</p>
-       </dd>
+   </dd>
 
-       <dt>A DOCTYPE token</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>A comment token</dt>
+   <dd>
+    <p>Append a <code>Comment</code> node to the <span>current
+    node</span> with the <code title="">data</code> attribute set to
+    the data given in the comment token.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "html"</dt>
-       <dd>
-        <p>If this start tag token was not the first start tag token, then
-        it is a <span>parse error</span>.</p>
-        <p>For each attribute on the token, check to see if the attribute
-        is already present on the top element of the <span>stack of open
-        elements</span>. If it is not, add the attribute and its
-        corresponding value to that element.</p>
-       </dd>
+   <dt>A DOCTYPE token</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>A start tag token whose tag name is one of: "base", "link",
-       "meta", "script", "style"</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in head">in head</span>".</p>
-       </dd>
+   <dt>A start tag whose tag name is "html"</dt>
+   <dd>
+    <p>If this start tag token was not the first start tag token, then
+    it is a <span>parse error</span>.</p>
+    <p>For each attribute on the token, check to see if the attribute
+    is already present on the top element of the <span>stack of open
+    elements</span>. If it is not, add the attribute and its
+    corresponding value to that element.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "title"</dt>
-       <dd>
-        <p><span>Parse error</span>. Process the token as if the
-        <span>insertion mode</span> had been "<span title="insertion
-        mode: in head">in head</span>".</p>
-       </dd>
+   <dt>A start tag token whose tag name is one of: "base", "link",
+   "meta", "script", "style"</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in head">in head</span>".</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "body"</dt>
-       <dd>
+   <dt>A start tag whose tag name is "title"</dt>
+   <dd>
+    <p><span>Parse error</span>. Process the token as if the
+    <span>insertion mode</span> had been "<span title="insertion
+    mode: in head">in head</span>".</p>
+   </dd>
 
-        <p><span>Parse error</span>.</p>
+   <dt>A start tag whose tag name is "body"</dt>
+   <dd>
 
-        <p>If the second element on the <span>stack of open
-        elements</span> is not a <code>body</code> element, or, if the
-        <span>stack of open elements</span> has only one node on it,
-        then ignore the token. (<span>fragment case</span>)</p>
+    <p><span>Parse error</span>.</p>
 
-        <p>Otherwise, for each attribute on the token, check to see if
-        the attribute is already present on the <code>body</code>
-        element (the second element) on the <span>stack of open
-        elements</span>. If it is not, add the attribute and its
-        corresponding value to that element.</p>
+    <p>If the second element on the <span>stack of open
+    elements</span> is not a <code>body</code> element, or, if the
+    <span>stack of open elements</span> has only one node on it,
+    then ignore the token. (<span>fragment case</span>)</p>
 
-       </dd>
+    <p>Otherwise, for each attribute on the token, check to see if
+    the attribute is already present on the <code>body</code>
+    element (the second element) on the <span>stack of open
+    elements</span>. If it is not, add the attribute and its
+    corresponding value to that element.</p>
 
-       <dt>An end tag whose tag name is "body"</dt>
-       <dd>
+   </dd>
 
-        <p>If the second element in the <span>stack of open
-        elements</span> is not a <code>body</code> element, this is a
-        <span>parse error</span>. Ignore the token.  (<span>fragment
-        case</span>)</p>
+   <dt>An end tag whose tag name is "body"</dt>
+   <dd>
 
-        <p>Otherwise, if there is a node in the <span>stack of open
-        elements</span> that is not either a <code>dd</code> element,
-        a <code>dt</code> element, an <code>li</code> element, a
-        <code>p</code> element, a <code>tbody</code> element, a
-        <code>td</code> element, a <code>tfoot</code> element, a
-        <code>th</code> element, a <code>thead</code> element, a
-        <code>tr</code> element, the <code>body</code> element, or the
-        <code>html</code> element, then this is a <span>parse
-        error</span>.</li>
+    <p>If the second element in the <span>stack of open
+    elements</span> is not a <code>body</code> element, this is a
+    <span>parse error</span>. Ignore the token.  (<span>fragment
+    case</span>)</p>
 
-        <p>Change the <span>insertion mode</span> to "<span
-        title="insertion mode: after body">after body</span>".</p>
+    <p>Otherwise, if there is a node in the <span>stack of open
+    elements</span> that is not either a <code>dd</code> element,
+    a <code>dt</code> element, an <code>li</code> element, a
+    <code>p</code> element, a <code>tbody</code> element, a
+    <code>td</code> element, a <code>tfoot</code> element, a
+    <code>th</code> element, a <code>thead</code> element, a
+    <code>tr</code> element, the <code>body</code> element, or the
+    <code>html</code> element, then this is a <span>parse
+    error</span>.</li>
 
-       </dd>
+    <p>Change the <span>insertion mode</span> to "<span
+    title="insertion mode: after body">after body</span>".</p>
 
-       <dt>An end tag whose tag name is "html"</dt>
-       <dd>
+   </dd>
 
-        <p>Act as if an end tag with tag name "body" had been seen,
-        then, if that token wasn't ignored, reprocess the current
-        token.</p>
+   <dt>An end tag whose tag name is "html"</dt>
+   <dd>
 
-        <p class="note">The fake end tag token here can only be
-        ignored in the <span>fragment case</span>.</p>
+    <p>Act as if an end tag with tag name "body" had been seen,
+    then, if that token wasn't ignored, reprocess the current
+    token.</p>
 
-       </dd>
+    <p class="note">The fake end tag token here can only be
+    ignored in the <span>fragment case</span>.</p>
 
-       <dt>A start tag whose tag name is one of: "address",
-       "blockquote", "center", "dir", "div", "dl", "fieldset",
-       "listing", "menu", "ol", "p", "ul"</dt>
-       <dd>
+   </dd>
 
-        <p class="big-issue">This doesn't match browsers.</p>
-        <!-- XXX <p><i><p>: http://software.hixie.ch/utilities/js/live-dom-viewer/?%3C!DOCTYPE%20html%3E%3Cp%3E%3Ci%3E%3Cp%3E%3C%2Fp%3E%3C%2Fi%3E%3C%2Fp%3E -->
-        <!-- XXX <p><i><div><p>: http://software.hixie.ch/utilities/js/live-dom-viewer/?%3C!DOCTYPE%20html%3E%3Cp%3E%3Ci%3E%3Cdiv%3E%3Cp%3E%3C%2Fp%3E%3C%2Fdiv%3E%3C%2Fi%3E%3C%2Fp%3E -->
+   <dt>A start tag whose tag name is one of: "address",
+   "blockquote", "center", "dir", "div", "dl", "fieldset",
+   "listing", "menu", "ol", "p", "ul"</dt>
+   <dd>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has a <code>p</code> element in
-        scope</span>, then act as if an end tag with the tag name
-        <code>p</code> had been seen.</p>
+    <p class="big-issue">This doesn't match browsers.</p>
+    <!-- XXX <p><i><p>: http://software.hixie.ch/utilities/js/live-dom-viewer/?%3C!DOCTYPE%20html%3E%3Cp%3E%3Ci%3E%3Cp%3E%3C%2Fp%3E%3C%2Fi%3E%3C%2Fp%3E -->
+    <!-- XXX <p><i><div><p>: http://software.hixie.ch/utilities/js/live-dom-viewer/?%3C!DOCTYPE%20html%3E%3Cp%3E%3Ci%3E%3Cdiv%3E%3Cp%3E%3C%2Fp%3E%3C%2Fdiv%3E%3C%2Fi%3E%3C%2Fp%3E -->
 
-        <p><span title="insert an html element">Insert an HTML
-        element</span> for the token.</p>
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has a <code>p</code> element in
+    scope</span>, then act as if an end tag with the tag name
+    <code>p</code> had been seen.</p>
 
-       </dd>
+    <p><span title="insert an html element">Insert an HTML
+    element</span> for the token.</p>
 
-       <dt>A start tag whose tag name is "pre"</dt>
-       <dd>
+   </dd>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has a <code>p</code> element in
-        scope</span>, then act as if an end tag with the tag name
-        <code>p</code> had been seen.</p>
+   <dt>A start tag whose tag name is "pre"</dt>
+   <dd>
 
-        <p><span title="insert an html element">Insert an HTML
-        element</span> for the token.</p>
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has a <code>p</code> element in
+    scope</span>, then act as if an end tag with the tag name
+    <code>p</code> had been seen.</p>
 
-        <p>If the next token is a U+000A LINE FEED (LF) character
-        token, then ignore that token and move on to the next
-        one. (Newlines at the start of <code>pre</code> blocks are
-        ignored as an authoring convenience.)</p>
+    <p><span title="insert an html element">Insert an HTML
+    element</span> for the token.</p>
 
-       </dd>
+    <p>If the next token is a U+000A LINE FEED (LF) character
+    token, then ignore that token and move on to the next
+    one. (Newlines at the start of <code>pre</code> blocks are
+    ignored as an authoring convenience.)</p>
 
-       <dt>A start tag whose tag name is "form"</dt>
-       <dd>
+   </dd>
 
-        <p>If the <span><code title="form">form</code> element
-        pointer</span> is not null, ignore the token with a
-        <span>parse error</span>.</p>
+   <dt>A start tag whose tag name is "form"</dt>
+   <dd>
 
-        <p>Otherwise:</p>
+    <p>If the <span><code title="form">form</code> element
+    pointer</span> is not null, ignore the token with a
+    <span>parse error</span>.</p>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has a <code>p</code> element in
-        scope</span>, then act as if an end tag with the tag name
-        <code>p</code> had been seen.</p>
+    <p>Otherwise:</p>
 
-        <p><span title="insert an html Element">Insert an HTML
-        element</span> for the token, and set the <code
-        title="form">form</code> element pointer to point to the
-        element created.</p>
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has a <code>p</code> element in
+    scope</span>, then act as if an end tag with the tag name
+    <code>p</code> had been seen.</p>
 
-       </dd>
+    <p><span title="insert an html Element">Insert an HTML
+    element</span> for the token, and set the <code
+    title="form">form</code> element pointer to point to the
+    element created.</p>
 
-       <dt>A start tag whose tag name is "li"</dt>
-       <dd>
+   </dd>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has a <code>p</code> element in
-        scope</span>, then act as if an end tag with the tag name
-        <code>p</code> had been seen.</p>
+   <dt>A start tag whose tag name is "li"</dt>
+   <dd>
 
-        <p>Run the following algorithm:</p>
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has a <code>p</code> element in
+    scope</span>, then act as if an end tag with the tag name
+    <code>p</code> had been seen.</p>
 
-        <ol>
+    <p>Run the following algorithm:</p>
 
-         <li><p>Initialise <var title="">node</var> to be the <span>current
-         node</span> (the bottommost node of the stack).</p></li>
+    <ol>
 
-         <li><p>If <var title="">node</var> is an <code>li</code>
-         element, then pop all the nodes from the <span>current
-         node</span> up to <var title="">node</var>, including <var
-         title="">node</var>, then stop this algorithm. If more than
-         one node is popped, then this is a <span>parse
-         error</span>.</p></li>
+     <li><p>Initialise <var title="">node</var> to be the <span>current
+     node</span> (the bottommost node of the stack).</p></li>
 
-         <li><p>If <var title="">node</var> is not in the
-         <span>formatting</span> category, and is not in the
-         <span>phrasing</span> category, and is not an
-         <code>address</code> or <code>div</code> element, then stop
-         this algorithm.</p></li> <!-- an element <foo> is in this
-         list if the following markup:
+     <li><p>If <var title="">node</var> is an <code>li</code>
+     element, then pop all the nodes from the <span>current
+     node</span> up to <var title="">node</var>, including <var
+     title="">node</var>, then stop this algorithm. If more than
+     one node is popped, then this is a <span>parse
+     error</span>.</p></li>
 
-             <!DOCTYPE html><body><ol><li><foo><li>
+     <li><p>If <var title="">node</var> is not in the
+     <span>formatting</span> category, and is not in the
+     <span>phrasing</span> category, and is not an
+     <code>address</code> or <code>div</code> element, then stop
+     this algorithm.</p></li> <!-- an element <foo> is in this
+     list if the following markup:
 
-         ...results in the second <li> not being (in any way) a
-         descendant of the first <li>, or if <foo> is a formatting
-         element that gets reopened later. -->
+         <!DOCTYPE html><body><ol><li><foo><li>
 
-         <li><p>Otherwise, set <var title="">node</var> to the previous entry
-         in the <span>stack of open elements</span> and return to step
-         2.</p></li>
+     ...results in the second <li> not being (in any way) a
+     descendant of the first <li>, or if <foo> is a formatting
+     element that gets reopened later. -->
 
-        </ol>
+     <li><p>Otherwise, set <var title="">node</var> to the previous entry
+     in the <span>stack of open elements</span> and return to step
+     2.</p></li>
 
-        <p>Finally, <span title="insert an html element">insert an
-        <code>li</code> element</span>.</p>
+    </ol>
 
-       </dd>
+    <p>Finally, <span title="insert an html element">insert an
+    <code>li</code> element</span>.</p>
 
-       <dt>A start tag whose tag name is one of: "dd", "dt"</dt>
-       <dd>
+   </dd>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has a <code>p</code> element in
-        scope</span>, then act as if an end tag with the tag name
-        <code>p</code> had been seen.</p>
+   <dt>A start tag whose tag name is one of: "dd", "dt"</dt>
+   <dd>
 
-        <p>Run the following algorithm:</p>
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has a <code>p</code> element in
+    scope</span>, then act as if an end tag with the tag name
+    <code>p</code> had been seen.</p>
 
-        <ol>
+    <p>Run the following algorithm:</p>
 
-         <li><p>Initialise <var title="">node</var> to be the <span>current
-         node</span> (the bottommost node of the stack).</p></li>
+    <ol>
 
-         <li><p>If <var title="">node</var> is a <code>dd</code> or
-         <code>dt</code> element, then pop all the nodes from the
-         <span>current node</span> up to <var title="">node</var>,
-         including <var title="">node</var>, then stop this algorithm.
-         If more than one node is popped, then this is a <span>parse
-         error</span>.</p></li>
+     <li><p>Initialise <var title="">node</var> to be the <span>current
+     node</span> (the bottommost node of the stack).</p></li>
 
-         <li><p>If <var title="">node</var> is not in the
-         <span>formatting</span> category, and is not in the
-         <span>phrasing</span> category, and is not an
-         <code>address</code> or <code>div</code> element, then stop
-         this algorithm.</p></li> <!-- an element <foo> is in this
-         list if the following markup:
+     <li><p>If <var title="">node</var> is a <code>dd</code> or
+     <code>dt</code> element, then pop all the nodes from the
+     <span>current node</span> up to <var title="">node</var>,
+     including <var title="">node</var>, then stop this algorithm.
+     If more than one node is popped, then this is a <span>parse
+     error</span>.</p></li>
 
-             <!DOCTYPE html><body><ol><dt><foo><dt>
+     <li><p>If <var title="">node</var> is not in the
+     <span>formatting</span> category, and is not in the
+     <span>phrasing</span> category, and is not an
+     <code>address</code> or <code>div</code> element, then stop
+     this algorithm.</p></li> <!-- an element <foo> is in this
+     list if the following markup:
 
-         ...results in the second <li> not being (in any way) a
-         descendant of the first <li>, or if <foo> is a formatting
-         element that gets reopened later. -->
+         <!DOCTYPE html><body><ol><dt><foo><dt>
 
-         <li><p>Otherwise, set <var title="">node</var> to the previous entry
-         in the <span>stack of open elements</span> and return to step
-         2.</p></li>
+     ...results in the second <li> not being (in any way) a
+     descendant of the first <li>, or if <foo> is a formatting
+     element that gets reopened later. -->
 
-        </ol>
+     <li><p>Otherwise, set <var title="">node</var> to the previous entry
+     in the <span>stack of open elements</span> and return to step
+     2.</p></li>
 
-        <p>Finally, <span title="insert an html element">insert an
-        HTML element</span> with the same tag name as the token's.</p>
+    </ol>
 
-       </dd>
+    <p>Finally, <span title="insert an html element">insert an
+    HTML element</span> with the same tag name as the token's.</p>
 
-       <dt>A start tag whose tag name is "plaintext"</dt>
-       <dd>
+   </dd>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has a <code>p</code> element in
-        scope</span>, then act as if an end tag with the tag name
-        <code>p</code> had been seen.</p>
+   <dt>A start tag whose tag name is "plaintext"</dt>
+   <dd>
 
-        <p><span title="insert an html element">Insert an HTML
-        element</span> for the token.</p>
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has a <code>p</code> element in
+    scope</span>, then act as if an end tag with the tag name
+    <code>p</code> had been seen.</p>
 
-        <p>Switch the <span>content model flag</span> to the PLAINTEXT
-        state.</p>
+    <p><span title="insert an html element">Insert an HTML
+    element</span> for the token.</p>
 
-        <p class="note">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 the <span>content model flag</span>
-        out of the PLAINTEXT state.</p>
+    <p>Switch the <span>content model flag</span> to the PLAINTEXT
+    state.</p>
 
-       </dd>
+    <p class="note">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 the <span>content model flag</span>
+    out of the PLAINTEXT state.</p>
 
-       <dt>An end tag whose tag name is one of: "address",
-       "blockquote", "center", "dir", "div", "dl", "fieldset",
-       "listing", "menu", "ol", "pre", "ul"</dt>
-       <dd>
+   </dd>
 
-        <p>If the <span>stack of open elements</span> <span>has an
-        element in scope</span> with the same tag name as that of the
-        token, then <span>generate implied end tags</span>.</p>
+   <dt>An end tag whose tag name is one of: "address",
+   "blockquote", "center", "dir", "div", "dl", "fieldset",
+   "listing", "menu", "ol", "pre", "ul"</dt>
+   <dd>
 
-        <p>Now, if the <span>current node</span> is not an element
-        with the same tag name as that of the token, then this is a
-        <span>parse error</span>.</p>
+    <p>If the <span>stack of open elements</span> <span>has an
+    element in scope</span> with the same tag name as that of the
+    token, then <span>generate implied end tags</span>.</p>
 
-        <p>If the <span>stack of open elements</span> <span>has an
-        element in scope</span> with the same tag name as that of the
-        token, then pop elements from this stack until an element with
-        that tag name has been popped from the stack.</p>
+    <p>Now, if the <span>current node</span> is not an element
+    with the same tag name as that of the token, then this is a
+    <span>parse error</span>.</p>
 
-        <!-- XXX quirk (except for in certain cases?):
-        <p>Otherwise, act as if a start tag with the tag name given in
-        the token had been seen, then reprocess the current token.</p>
-        -->
+    <p>If the <span>stack of open elements</span> <span>has an
+    element in scope</span> with the same tag name as that of the
+    token, then pop elements from this stack until an element with
+    that tag name has been popped from the stack.</p>
 
-       </dd>
+    <!-- XXX quirk (except for in certain cases?):
+    <p>Otherwise, act as if a start tag with the tag name given in
+    the token had been seen, then reprocess the current token.</p>
+    -->
 
-       <dt>An end tag whose tag name is "form"</dt>
-       <dd>
+   </dd>
 
-        <p>If the <span>stack of open elements</span> <span>has an
-        element in scope</span> with the same tag name as that of the
-        token, then <span>generate implied end tags</span>.</p>
+   <dt>An end tag whose tag name is "form"</dt>
+   <dd>
 
-        <p>Now, if the <span>current node</span> is not an element
-        with the same tag name as that of the token, then this is a
-        <span>parse error</span>.</p>
+    <p>If the <span>stack of open elements</span> <span>has an
+    element in scope</span> with the same tag name as that of the
+    token, then <span>generate implied end tags</span>.</p>
 
-        <p>Otherwise, if the <span>current node</span> is an element
-        with the same tag name as that of the token pop that element
-        from the stack.</p>
+    <p>Now, if the <span>current node</span> is not an element
+    with the same tag name as that of the token, then this is a
+    <span>parse error</span>.</p>
 
-        <p>In any case, set the <span><code title="">form</code>
-        element pointer</span> to null.</p>
+    <p>Otherwise, if the <span>current node</span> is an element
+    with the same tag name as that of the token pop that element
+    from the stack.</p>
 
-       </dd>
+    <p>In any case, set the <span><code title="">form</code>
+    element pointer</span> to null.</p>
 
-       <dt>An end tag whose tag name is "p"</dt>
-       <dd>
+   </dd>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has a <code>p</code> element in
-        scope</span>, then <span>generate implied end tags</span>,
-        except for <code>p</code> elements.</p>
+   <dt>An end tag whose tag name is "p"</dt>
+   <dd>
 
-        <p>If the <span>current node</span> is not a <code>p</code>
-        element, then this is a <span>parse error</span>.</p>
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has a <code>p</code> element in
+    scope</span>, then <span>generate implied end tags</span>,
+    except for <code>p</code> elements.</p>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has a <code>p</code> element in
-        scope</span>, then pop elements from this stack until the
-        stack no longer <span title="has an element in scope">has a
-        <code>p</code> element in scope</span>.</p>
+    <p>If the <span>current node</span> is not a <code>p</code>
+    element, then this is a <span>parse error</span>.</p>
 
-        <p>Otherwise, act as if a start tag with the tag name
-        <code>p</code> had been seen, then reprocess the current
-        token.</p>
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has a <code>p</code> element in
+    scope</span>, then pop elements from this stack until the
+    stack no longer <span title="has an element in scope">has a
+    <code>p</code> element in scope</span>.</p>
 
-       </dd>
+    <p>Otherwise, act as if a start tag with the tag name
+    <code>p</code> had been seen, then reprocess the current
+    token.</p>
 
-       <dt>An end tag whose tag name is one of: "dd", "dt", "li"</dt>
-       <dd>
+   </dd>
 
-        <p>If the <span>stack of open elements</span> <span>has an
-        element in scope</span> whose tag name matches the tag name of
-        the token, then <span>generate implied end tags</span>, except
-        for elements with the same tag name as the token.</p>
+   <dt>An end tag whose tag name is one of: "dd", "dt", "li"</dt>
+   <dd>
 
-        <p>If the <span>current node</span> is not an element with the
-        same tag name as the token, then this is a <span>parse
-        error</span>.</p>
+    <p>If the <span>stack of open elements</span> <span>has an
+    element in scope</span> whose tag name matches the tag name of
+    the token, then <span>generate implied end tags</span>, except
+    for elements with the same tag name as the token.</p>
 
-        <p>If the <span>stack of open elements</span> <span>has an
-        element in scope</span> whose tag name matches the tag name of
-        the token, then pop elements from this stack until an element
-        with that tag name has been popped from the stack.</p>
+    <p>If the <span>current node</span> is not an element with the
+    same tag name as the token, then this is a <span>parse
+    error</span>.</p>
 
-       </dd>
+    <p>If the <span>stack of open elements</span> <span>has an
+    element in scope</span> whose tag name matches the tag name of
+    the token, then pop elements from this stack until an element
+    with that tag name has been popped from the stack.</p>
 
-       <dt>A start tag whose tag name is one of: "h1", "h2", "h3",
-       "h4", "h5", "h6"</dt>
-       <dd>
+   </dd>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has a <code>p</code> element in
-        scope</span>, then act as if an end tag with the tag name
-        <code>p</code> had been seen.</p>
+   <dt>A start tag whose tag name is one of: "h1", "h2", "h3",
+   "h4", "h5", "h6"</dt>
+   <dd>
 
-        <!-- Removed for compatibility with IE7, though all other
-             browsers do it this way. If you do put this back, make
-             sure to handle <h1><a><h2>, as in Webkit bug 12646.
-             http://bugs.webkit.org/show_bug.cgi?id=12646
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has in scope</span> an element whose tag
-        name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
-        this is a <span>parse error</span>; pop elements from the
-        stack until an element with one of those tag names has been
-        popped from the stack.</p>
-        -->
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has a <code>p</code> element in
+    scope</span>, then act as if an end tag with the tag name
+    <code>p</code> had been seen.</p>
 
-        <p><span title="insert an html element">Insert an HTML
-        element</span> for the token.</p>
+    <!-- Removed for compatibility with IE7, though all other
+         browsers do it this way. If you do put this back, make
+         sure to handle <h1><a><h2>, as in Webkit bug 12646.
+         http://bugs.webkit.org/show_bug.cgi?id=12646
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has in scope</span> an element whose tag
+    name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
+    this is a <span>parse error</span>; pop elements from the
+    stack until an element with one of those tag names has been
+    popped from the stack.</p>
+    -->
 
-       </dd>
+    <p><span title="insert an html element">Insert an HTML
+    element</span> for the token.</p>
 
-       <dt>An end tag whose tag name is one of: "h1", "h2", "h3",
-       "h4", "h5", "h6"</dt>
-       <dd>
+   </dd>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has in scope</span> an element whose tag
-        name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
-        <span>generate implied end tags</span>.</p>
+   <dt>An end tag whose tag name is one of: "h1", "h2", "h3",
+   "h4", "h5", "h6"</dt>
+   <dd>
 
-        <p>Now, if the <span>current node</span> is not an element
-        with the same tag name as that of the token, then this is a
-        <span>parse error</span>.</p>
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has in scope</span> an element whose tag
+    name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
+    <span>generate implied end tags</span>.</p>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has in scope</span> an element whose tag
-        name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then pop
-        elements from the stack until an element with one of those tag
-        names has been popped from the stack.</p>
+    <p>Now, if the <span>current node</span> is not an element
+    with the same tag name as that of the token, then this is a
+    <span>parse error</span>.</p>
 
-        <!-- XXX quirk:
-        <p>Otherwise, act as if a start tag with the tag name given in
-        the token had been seen, then reprocess the current token.</p>
-        -->
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has in scope</span> an element whose tag
+    name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then pop
+    elements from the stack until an element with one of those tag
+    names has been popped from the stack.</p>
 
-       </dd>
+    <!-- XXX quirk:
+    <p>Otherwise, act as if a start tag with the tag name given in
+    the token had been seen, then reprocess the current token.</p>
+    -->
 
-       <!-- ADOPTION AGENCY ELEMENTS
-            Mozilla-only: bdo blink del ins sub sup q
-            Safari-only: code dfn kbd nobr samp var wbr
-            Both: a b big em font i s small strike strong tt u -->
+   </dd>
 
-       <dt>A start tag whose tag name is "a"</dt>
-       <dd>
+   <!-- ADOPTION AGENCY ELEMENTS
+        Mozilla-only: bdo blink del ins sub sup q
+        Safari-only: code dfn kbd nobr samp var wbr
+        Both: a b big em font i s small strike strong tt u -->
 
-        <p>If the <span>list of active formatting elements</span>
-        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
-        <span>parse error</span>; act as if an end tag with the tag
-        name "a" had been seen, then remove that element from the
-        <span>list of active formatting elements</span> and the
-        <span>stack of open elements</span> if the end tag didn't
-        already remove it (it might not have if the element is not
-        <span title="has an element in table scope">in table
-        scope</span>).</p>
+   <dt>A start tag whose tag name is "a"</dt>
+   <dd>
 
-        <p class="example">In the non-conforming stream
-        <code><a href="a">a<table><a href="b">b</table>x</code>,
-        the first <code>a</code> 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
-        <code>a</code> element is not in table scope (meaning that a
-        regular <code></a></code> end tag at the start of the table
-        wouldn't close the outer <code>a</code> element).</p>
+    <p>If the <span>list of active formatting elements</span>
+    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
+    <span>parse error</span>; act as if an end tag with the tag
+    name "a" had been seen, then remove that element from the
+    <span>list of active formatting elements</span> and the
+    <span>stack of open elements</span> if the end tag didn't
+    already remove it (it might not have if the element is not
+    <span title="has an element in table scope">in table
+    scope</span>).</p>
 
-        <p><span>Reconstruct the active formatting elements</span>, if
-        any.</p>
+    <p class="example">In the non-conforming stream
+    <code><a href="a">a<table><a href="b">b</table>x</code>,
+    the first <code>a</code> 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
+    <code>a</code> element is not in table scope (meaning that a
+    regular <code></a></code> end tag at the start of the table
+    wouldn't close the outer <code>a</code> element).</p>
 
-        <p><span title="insert an html element">Insert an HTML
-        element</span> for the token. Add that element to the
-        <span>list of active formatting elements</span>.</p>
+    <p><span>Reconstruct the active formatting elements</span>, if
+    any.</p>
 
-       </dd>
+    <p><span title="insert an html element">Insert an HTML
+    element</span> for the token. Add that element to the
+    <span>list of active formatting elements</span>.</p>
 
-       <dt>A start tag whose tag name is one of: "b", "big", "em",
-       "font", "i", "s", "small", "strike", "strong", "tt", "u"</dt>
-       <dd>
+   </dd>
 
-        <p><span>Reconstruct the active formatting elements</span>, if
-        any.</p>
+   <dt>A start tag whose tag name is one of: "b", "big", "em",
+   "font", "i", "s", "small", "strike", "strong", "tt", "u"</dt>
+   <dd>
 
-        <p><span title="insert an html element">Insert an HTML
-        element</span> for the token. Add that element to the
-        <span>list of active formatting elements</span>.</p>
+    <p><span>Reconstruct the active formatting elements</span>, if
+    any.</p>
 
-       </dd>
+    <p><span title="insert an html element">Insert an HTML
+    element</span> for the token. Add that element to the
+    <span>list of active formatting elements</span>.</p>
 
-       <dt>A start tag whose tag name is "nobr"</dt>
-       <dd>
+   </dd>
 
-        <p><span>Reconstruct the active formatting elements</span>, if
-        any.</p>
+   <dt>A start tag whose tag name is "nobr"</dt>
+   <dd>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has a <code>nobr</code> element in
-        scope</span>, then this is a <span>parse error</span>. Act as
-        if an end tag with the tag name <code>nobr</code> had been
-        seen, then once again <span>reconstruct the active formatting
-        elements</span>, if any.</p>
+    <p><span>Reconstruct the active formatting elements</span>, if
+    any.</p>
 
-        <p><span title="insert an html element">Insert an HTML
-        element</span> for the token. Add that element to the
-        <span>list of active formatting elements</span>.</p>
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has a <code>nobr</code> element in
+    scope</span>, then this is a <span>parse error</span>. Act as
+    if an end tag with the tag name <code>nobr</code> had been
+    seen, then once again <span>reconstruct the active formatting
+    elements</span>, if any.</p>
 
-       </dd>
+    <p><span title="insert an html element">Insert an HTML
+    element</span> for the token. Add that element to the
+    <span>list of active formatting elements</span>.</p>
 
-       <dt id="adoptionAgency">An end tag whose tag name is one of:
-       "a", "b", "big", "em", "font", "i", "nobr", "s", "small",
-       "strike", "strong", "tt", "u"</dt>
-       <dd>
+   </dd>
 
-        <p>Follow these steps:</p>
+   <dt id="adoptionAgency">An end tag whose tag name is one of:
+   "a", "b", "big", "em", "font", "i", "nobr", "s", "small",
+   "strike", "strong", "tt", "u"</dt>
+   <dd>
 
-        <ol>
+    <p>Follow these steps:</p>
 
-         <li>
+    <ol>
 
-          <p>Let the <var title="">formatting element</var> be the
-          last element in the <span>list of active formatting
-          elements</span> that:</p>
+     <li>
 
-          <ul>
+      <p>Let the <var title="">formatting element</var> be the
+      last element in the <span>list of active formatting
+      elements</span> that:</p>
 
-           <li>is between the end of the list and the last scope
-           marker in the list, if any, or the start of the list
-           otherwise, and</li>
+      <ul>
 
-           <li>has the same tag name as the token.</li>
+       <li>is between the end of the list and the last scope
+       marker in the list, if any, or the start of the list
+       otherwise, and</li>
 
-          </ul>
+       <li>has the same tag name as the token.</li>
 
-          <p>If there is no such node, or, if that node is also in the
-          <span>stack of open elements</span> but the element is not
-          <span title="has an element in scope">in scope</span>, then
-          this is a <span>parse error</span>. Abort these steps. The
-          token is ignored.</p>
+      </ul>
 
-          <p>Otherwise, if there is such a node, but that node is not
-          in the <span>stack of open elements</span>, then this is a
-          <span>parse error</span>; remove the element from the list,
-          and abort these steps.</p>
+      <p>If there is no such node, or, if that node is also in the
+      <span>stack of open elements</span> but the element is not
+      <span title="has an element in scope">in scope</span>, then
+      this is a <span>parse error</span>. Abort these steps. The
+      token is ignored.</p>
 
-          <p>Otherwise, there is a <var title="">formatting
-          element</var> and that element is in <span title="stack of
-          open elements">the stack</span> and is <span title="has an
-          element in scope">in scope</span>. If the element is not the
-          <span>current node</span>, this is a <span>parse
-          error</span>. In any case, proceed with the algorithm as
-          written in the following steps.</p>
+      <p>Otherwise, if there is such a node, but that node is not
+      in the <span>stack of open elements</span>, then this is a
+      <span>parse error</span>; remove the element from the list,
+      and abort these steps.</p>
 
-         </li>
+      <p>Otherwise, there is a <var title="">formatting
+      element</var> and that element is in <span title="stack of
+      open elements">the stack</span> and is <span title="has an
+      element in scope">in scope</span>. If the element is not the
+      <span>current node</span>, this is a <span>parse
+      error</span>. In any case, proceed with the algorithm as
+      written in the following steps.</p>
 
-         <li><p>Let the <var title="">furthest block</var> be the
-         topmost node in the <span>stack of open elements</span> that
-         is lower in the stack than the <var title="">formatting
-         element</var>, and is not an element in the
-         <span>phrasing</span> or <span>formatting</span>
-         categories. There might not be one.</p></li>
+     </li>
 
-         <li><p>If there is no <var title="">furthest block</var>,
-         then the UA must skip the subsequent steps and instead just
-         pop all the nodes from the bottom of the <span>stack of open
-         elements</span>, from the <span>current node</span> up to and
-         including the <var title="">formatting element</var>, and
-         remove the <var title="">formatting element</var> from the
-         <span>list of active formatting elements</span>.</p></li>
+     <li><p>Let the <var title="">furthest block</var> be the
+     topmost node in the <span>stack of open elements</span> that
+     is lower in the stack than the <var title="">formatting
+     element</var>, and is not an element in the
+     <span>phrasing</span> or <span>formatting</span>
+     categories. There might not be one.</p></li>
 
-         <li><p>Let the <var title="">common ancestor</var> be the element
-         immediately above the <var title="">formatting element</var> in the
-         <span>stack of open elements</span>.</p></li>
+     <li><p>If there is no <var title="">furthest block</var>,
+     then the UA must skip the subsequent steps and instead just
+     pop all the nodes from the bottom of the <span>stack of open
+     elements</span>, from the <span>current node</span> up to and
+     including the <var title="">formatting element</var>, and
+     remove the <var title="">formatting element</var> from the
+     <span>list of active formatting elements</span>.</p></li>
 
-         <li><p>If the <var title="">furthest block</var> has a parent node,
-         then remove the <var title="">furthest block</var> from its parent
-         node.</p></li>
+     <li><p>Let the <var title="">common ancestor</var> be the element
+     immediately above the <var title="">formatting element</var> in the
+     <span>stack of open elements</span>.</p></li>
 
-         <li><p>Let a bookmark note the position of the <var
-         title="">formatting element</var> in the <span>list of active
-         formatting elements</span> relative to the elements on either
-         side of it in the list.</p></li>
+     <li><p>If the <var title="">furthest block</var> has a parent node,
+     then remove the <var title="">furthest block</var> from its parent
+     node.</p></li>
 
-         <li>
+     <li><p>Let a bookmark note the position of the <var
+     title="">formatting element</var> in the <span>list of active
+     formatting elements</span> relative to the elements on either
+     side of it in the list.</p></li>
 
-          <p>Let <var title="">node</var> and <var title="">last node</var> be the
-          <var title="">furthest block</var>. Follow these steps:</p>
+     <li>
 
-          <ol>
+      <p>Let <var title="">node</var> and <var title="">last node</var> be the
+      <var title="">furthest block</var>. Follow these steps:</p>
 
-           <li>Let <var title="">node</var> be the element immediately prior to
-           <var title="">node</var> in the <span>stack of open
-           elements</span>.</li>
+      <ol>
 
-           <li>If <var title="">node</var> is not in the <span>list of
-           active formatting elements</span>, then remove <var
-           title="">node</var> from the <span>stack of open
-           elements</span> and then go back to step 1.</li>
+       <li>Let <var title="">node</var> be the element immediately prior to
+       <var title="">node</var> in the <span>stack of open
+       elements</span>.</li>
 
-           <li>Otherwise, if <var title="">node</var> is the <var
-           title="">formatting element</var>, then go to the next step
-           in the overall algorithm.</li>
+       <li>If <var title="">node</var> is not in the <span>list of
+       active formatting elements</span>, then remove <var
+       title="">node</var> from the <span>stack of open
+       elements</span> and then go back to step 1.</li>
 
-           <li>Otherwise, if <var title="">last node</var> is the <var
-           title="">furthest block</var>, then move the aforementioned
-           bookmark to be immediately after the <var
-           title="">node</var> in the <span>list of active formatting
-           elements</span>.</li>
+       <li>Otherwise, if <var title="">node</var> is the <var
+       title="">formatting element</var>, then go to the next step
+       in the overall algorithm.</li>
 
-           <li>If <var title="">node</var> has any children, perform a shallow
-           clone of <var title="">node</var>, replace the entry for
-           <var title="">node</var> in the <span>list of active formatting
-           elements</span> with an entry for the clone, replace the
-           entry for <var title="">node</var> in the <span>stack of open
-           elements</span> with an entry for the clone, and let
-           <var title="">node</var> be the clone.</li>
+       <li>Otherwise, if <var title="">last node</var> is the <var
+       title="">furthest block</var>, then move the aforementioned
+       bookmark to be immediately after the <var
+       title="">node</var> in the <span>list of active formatting
+       elements</span>.</li>
 
-           <li>Insert <var title="">last node</var> into <var
-           title="">node</var>, first removing it from its previous
-           parent node if any.</li>
+       <li>If <var title="">node</var> has any children, perform a shallow
+       clone of <var title="">node</var>, replace the entry for
+       <var title="">node</var> in the <span>list of active formatting
+       elements</span> with an entry for the clone, replace the
+       entry for <var title="">node</var> in the <span>stack of open
+       elements</span> with an entry for the clone, and let
+       <var title="">node</var> be the clone.</li>
 
-           <li>Let <var title="">last node</var> be <var title="">node</var>.</li>
+       <li>Insert <var title="">last node</var> into <var
+       title="">node</var>, first removing it from its previous
+       parent node if any.</li>
 
-           <li>Return to step 1 of this inner set of steps.</li>
+       <li>Let <var title="">last node</var> be <var title="">node</var>.</li>
 
-          </ol>
+       <li>Return to step 1 of this inner set of steps.</li>
 
-         </li>
+      </ol>
 
-         <li><p>Insert whatever <var title="">last node</var> ended up
-         being in the previous step into the <var title="">common
-         ancestor</var> node, first removing it from its previous
-         parent node if any.</p></li>
+     </li>
 
-         <li><p>Perform a shallow clone of the <var title="">formatting
-         element</var>.</p></li>
+     <li><p>Insert whatever <var title="">last node</var> ended up
+     being in the previous step into the <var title="">common
+     ancestor</var> node, first removing it from its previous
+     parent node if any.</p></li>
 
-         <li><p>Take all of the child nodes of the <var title="">furthest
-         block</var> and append them to the clone created in the last
-         step.</p></li>
+     <li><p>Perform a shallow clone of the <var title="">formatting
+     element</var>.</p></li>
 
-         <li><p>Append that clone to the <var title="">furthest
-         block</var>.</p></li>
+     <li><p>Take all of the child nodes of the <var title="">furthest
+     block</var> and append them to the clone created in the last
+     step.</p></li>
 
-         <li><p>Remove the <var title="">formatting element</var> from the
-         <span>list of active formatting elements</span>, and insert
-         the clone into the <span>list of active formatting
-         elements</span> at the position of the aforementioned
-         bookmark.</p></li>
+     <li><p>Append that clone to the <var title="">furthest
+     block</var>.</p></li>
 
-         <li><p>Remove the <var title="">formatting element</var> from the
-         <span>stack of open elements</span>, and insert the clone
-         into the <span>stack of open elements</span> immediately
-         after (i.e. in a more deeply nested position than) the
-         position of the <var title="">furthest block</var> in that
-         stack.</p></li>
+     <li><p>Remove the <var title="">formatting element</var> from the
+     <span>list of active formatting elements</span>, and insert
+     the clone into the <span>list of active formatting
+     elements</span> at the position of the aforementioned
+     bookmark.</p></li>
 
-         <li><p>Jump back to step 1 in this series of steps.</p></li>
+     <li><p>Remove the <var title="">formatting element</var> from the
+     <span>stack of open elements</span>, and insert the clone
+     into the <span>stack of open elements</span> immediately
+     after (i.e. in a more deeply nested position than) the
+     position of the <var title="">furthest block</var> in that
+     stack.</p></li>
 
-        </ol>
+     <li><p>Jump back to step 1 in this series of steps.</p></li>
 
-        <p class="note">The way these steps are defined, only elements
-        in the <span>formatting</span> category ever get cloned by
-        this algorithm.</p>
+    </ol>
 
+    <p class="note">The way these steps are defined, only elements
+    in the <span>formatting</span> category ever get cloned by
+    this algorithm.</p>
+
 <!--XXX
-        <div class="example">
-         <p class="big-issue">Need an example.</p>
-        </div>
+    <div class="example">
+     <p class="big-issue">Need an example.</p>
+    </div>
 -->
 
-        <p class="note">Because of the way this algorithm causes elements to
-        change parents, it has been dubbed the "adoption agency algorithm"
-        (in contrast with other possibly algorithms for dealing with
-        misnested content, which included the "incest algorithm", the
-        "secret affair algorithm", and the "Heisenberg algorithm").</p>
+    <p class="note">Because of the way this algorithm causes elements to
+    change parents, it has been dubbed the "adoption agency algorithm"
+    (in contrast with other possibly algorithms for dealing with
+    misnested content, which included the "incest algorithm", the
+    "secret affair algorithm", and the "Heisenberg algorithm").</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is "button"</dt>
-       <dd>
-        
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has a <code>button</code> element in
-        scope</span>, then this is a <span>parse error</span>;
-        act as if an end tag with the tag name "button" had been seen,
-        then reprocess the token.</p>
+   <dt>A start tag whose tag name is "button"</dt>
+   <dd>
 
-        <p>Otherwise:</p>
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has a <code>button</code> element in
+    scope</span>, then this is a <span>parse error</span>;
+    act as if an end tag with the tag name "button" had been seen,
+    then reprocess the token.</p>
 
-        <p><span>Reconstruct the active formatting elements</span>, if
-        any.</p>
+    <p>Otherwise:</p>
 
-        <p><span>Insert an HTML element</span> for the token.</p>
+    <p><span>Reconstruct the active formatting elements</span>, if
+    any.</p>
 
-        <p>Insert a marker at the end of the <span>list of active
-        formatting elements</span>.</p>
+    <p><span>Insert an HTML element</span> for the token.</p>
 
-       </dd>
+    <p>Insert a marker at the end of the <span>list of active
+    formatting elements</span>.</p>
 
-       <dt>A start tag token whose tag name is one of: "marquee",
-       "object"</dt>
-       <dd>
+   </dd>
 
-        <p><span>Reconstruct the active formatting elements</span>, if
-        any.</p>
+   <dt>A start tag token whose tag name is one of: "marquee",
+   "object"</dt>
+   <dd>
 
-        <p><span>Insert an HTML element</span> for the token.</p>
+    <p><span>Reconstruct the active formatting elements</span>, if
+    any.</p>
 
-        <p>Insert a marker at the end of the <span>list of active
-        formatting elements</span>.</p>
+    <p><span>Insert an HTML element</span> for the token.</p>
 
-       </dd>
+    <p>Insert a marker at the end of the <span>list of active
+    formatting elements</span>.</p>
 
-       <dt>An end tag token whose tag name is one of: "button",
-       "marquee", "object"</dt>
-       <dd>
+   </dd>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has in scope</span> an element whose tag
-        name is the same as the tag name of the token, then
-        <span>generate implied end tags</span>.</p>
+   <dt>An end tag token whose tag name is one of: "button",
+   "marquee", "object"</dt>
+   <dd>
 
-        <p>Now, if the <span>current node</span> is not an element
-        with the same tag name as the token, then this is a
-        <span>parse error</span>.</p>
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has in scope</span> an element whose tag
+    name is the same as the tag name of the token, then
+    <span>generate implied end tags</span>.</p>
 
-        <p>Now, if the <span>stack of open elements</span> <span>has
-        an element in scope</span> whose tag name matches the tag name
-        of the token, then pop elements from the stack until that
-        element has been popped from the stack, and <span>clear the
-        list of active formatting elements up to the last
-        marker</span>.</p>
+    <p>Now, if the <span>current node</span> is not an element
+    with the same tag name as the token, then this is a
+    <span>parse error</span>.</p>
 
-       </dd>
+    <p>Now, if the <span>stack of open elements</span> <span>has
+    an element in scope</span> whose tag name matches the tag name
+    of the token, then pop elements from the stack until that
+    element has been popped from the stack, and <span>clear the
+    list of active formatting elements up to the last
+    marker</span>.</p>
 
-       <dt>A start tag whose tag name is "xmp"</dt>
-       <dd>
+   </dd>
 
-        <p><span>Reconstruct the active formatting elements</span>, if
-        any.</p>
+   <dt>A start tag whose tag name is "xmp"</dt>
+   <dd>
 
-        <p>Follow the <span>generic CDATA parsing algorithm</span>,
-        with the <span>current node</span> as the <var
-        title="">context node</var>.</p>
+    <p><span>Reconstruct the active formatting elements</span>, if
+    any.</p>
 
-       </dd>
+    <p>Follow the <span>generic CDATA parsing algorithm</span>,
+    with the <span>current node</span> as the <var
+    title="">context node</var>.</p>
 
-       <dt>A start tag whose tag name is "table"</dt>
-       <dd>
+   </dd>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has a <code>p</code> element in
-        scope</span>, then act as if an end tag with the tag name
-        <code>p</code> had been seen.</p> <!-- XXX quirks: don't do this -->
+   <dt>A start tag whose tag name is "table"</dt>
+   <dd>
 
-        <p><span>Insert an HTML element</span> for the token.</p>
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has a <code>p</code> element in
+    scope</span>, then act as if an end tag with the tag name
+    <code>p</code> had been seen.</p> <!-- XXX quirks: don't do this -->
 
-        <p>Change the <span>insertion mode</span> to "<span
-        title="insertion mode: in table">in table</span>".</p>
+    <p><span>Insert an HTML element</span> for the token.</p>
 
-       </dd>
+    <p>Change the <span>insertion mode</span> to "<span
+    title="insertion mode: in table">in table</span>".</p>
 
-       <dt>A start tag whose tag name is one of: "area", "basefont",
-       "bgsound", "br", "embed", "img", "param", "spacer", "wbr"</dt>
-       <dd>
+   </dd>
 
-        <p><span>Reconstruct the active formatting elements</span>, if
-        any.</p>
+   <dt>A start tag whose tag name is one of: "area", "basefont",
+   "bgsound", "br", "embed", "img", "param", "spacer", "wbr"</dt>
+   <dd>
 
-        <p><span title="insert an html element">Insert an HTML
-        element</span> for the token. Immediately pop the
-        <span>current node</span> off the <span>stack of open
-        elements</span>.</p>
+    <p><span>Reconstruct the active formatting elements</span>, if
+    any.</p>
 
-       </dd>
+    <p><span title="insert an html element">Insert an HTML
+    element</span> for the token. Immediately pop the
+    <span>current node</span> off the <span>stack of open
+    elements</span>.</p>
 
-       <dt>A start tag whose tag name is "hr"</dt>
-       <dd>
+   </dd>
 
-        <p>If the <span>stack of open elements</span> <span title="has
-        an element in scope">has a <code>p</code> element in
-        scope</span>, then act as if an end tag with the tag name
-        <code>p</code> had been seen.</p> <!-- XXX quirks: don't do this -->
+   <dt>A start tag whose tag name is "hr"</dt>
+   <dd>
 
-        <p><span title="insert an html element">Insert an HTML
-        element</span> for the token. Immediately pop the
-        <span>current node</span> off the <span>stack of open
-        elements</span>.</p>
+    <p>If the <span>stack of open elements</span> <span title="has
+    an element in scope">has a <code>p</code> element in
+    scope</span>, then act as if an end tag with the tag name
+    <code>p</code> had been seen.</p> <!-- XXX quirks: don't do this -->
 
-       </dd>
+    <p><span title="insert an html element">Insert an HTML
+    element</span> for the token. Immediately pop the
+    <span>current node</span> off the <span>stack of open
+    elements</span>.</p>
 
-       <dt>A start tag whose tag name is "image"</dt>
-       <dd>
-        <p><span>Parse error</span>. Change the token's tag name
-        to "img" and reprocess it. (Don't ask.)</p> <!-- As of
-        2005-12, studies showed that around 0.2% of pages used the
-        <image> element. -->
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is "input"</dt>
-       <dd>
+   <dt>A start tag whose tag name is "image"</dt>
+   <dd>
+    <p><span>Parse error</span>. Change the token's tag name
+    to "img" and reprocess it. (Don't ask.)</p> <!-- As of
+    2005-12, studies showed that around 0.2% of pages used the
+    <image> element. -->
+   </dd>
 
-        <p><span>Reconstruct the active formatting elements</span>, if
-        any.</p>
+   <dt>A start tag whose tag name is "input"</dt>
+   <dd>
 
-        <p><span title="insert an html element">Insert an
-        <code>input</code> element</span> for the token.</p>
+    <p><span>Reconstruct the active formatting elements</span>, if
+    any.</p>
 
-        <p>If the <span><code title="">form</code> element
-        pointer</span> is not null, then <span>associate</span><!--XXX
-        xref! --> the <code>input</code> element with the
-        <code>form</code> element pointed to by the <span><code
-        title="">form</code> element pointer</span>.</p>
+    <p><span title="insert an html element">Insert an
+    <code>input</code> element</span> for the token.</p>
 
-        <p>Pop that <code>input</code> element off the <span>stack of
-        open elements</span>.</p>
+    <p>If the <span><code title="">form</code> element
+    pointer</span> is not null, then <span>associate</span><!--XXX
+    xref! --> the <code>input</code> element with the
+    <code>form</code> element pointed to by the <span><code
+    title="">form</code> element pointer</span>.</p>
 
-       </dd>
+    <p>Pop that <code>input</code> element off the <span>stack of
+    open elements</span>.</p>
 
-       <dt id="isindex">A start tag whose tag name is "isindex"</dt>
-       <dd>
+   </dd>
 
-        <p><span>Parse error</span>.</p>
+   <dt id="isindex">A start tag whose tag name is "isindex"</dt>
+   <dd>
 
-        <p>If the <span><code title="">form</code> element
-        pointer</span> is not null, then ignore the token.</p>
+    <p><span>Parse error</span>.</p>
 
-        <p>Otherwise:</p>
+    <p>If the <span><code title="">form</code> element
+    pointer</span> is not null, then ignore the token.</p>
 
-        <p>Act as if a start tag token with the tag name "form" had been seen.</p>
+    <p>Otherwise:</p>
 
-        <p>If the token has an attribute called "action", set the
-        <code title="attr-form-action">action</code> attribute on the
-        resulting <code>form</code> element to the value of the
-        "action" attribute of the token.</p>
+    <p>Act as if a start tag token with the tag name "form" had been seen.</p>
 
-        <p>Act as if a start tag token with the tag name "hr" had been seen.</p>
+    <p>If the token has an attribute called "action", set the
+    <code title="attr-form-action">action</code> attribute on the
+    resulting <code>form</code> element to the value of the
+    "action" attribute of the token.</p>
 
-        <p>Act as if a start tag token with the tag name "p" had been seen.</p>
+    <p>Act as if a start tag token with the tag name "hr" had been seen.</p>
 
-        <p>Act as if a start tag token with the tag name "label" had been seen.</p
+    <p>Act as if a start tag token with the tag name "p" had been seen.</p>
 
-        <p>Act as if a stream of character tokens had been seen (see
-        below for what they should say).</p>
+    <p>Act as if a start tag token with the tag name "label" had been seen.</p
 
-        <p>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 <code
-        title="attr-input-name">name</code> attribute of the resulting
-        <code>input</code> element to the value "<code
-        title="">isindex</code>".</p>
+    <p>Act as if a stream of character tokens had been seen (see
+    below for what they should say).</p>
 
-        <p>Act as if a stream of character tokens had been seen (see
-        below for what they should say).</p>
+    <p>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 <code
+    title="attr-input-name">name</code> attribute of the resulting
+    <code>input</code> element to the value "<code
+    title="">isindex</code>".</p>
 
-        <p>Act as if an end tag token with the tag name "label" had been seen.</p>
+    <p>Act as if a stream of character tokens had been seen (see
+    below for what they should say).</p>
 
-        <p>Act as if an end tag token with the tag name "p" had been seen.</p>
+    <p>Act as if an end tag token with the tag name "label" had been seen.</p>
 
-        <p>Act as if a start tag token with the tag name "hr" had been seen.</p>
+    <p>Act as if an end tag token with the tag name "p" had been seen.</p>
 
-        <p>Act as if an end tag token with the tag name "form" had been seen.</p>
+    <p>Act as if a start tag token with the tag name "hr" had been seen.</p>
 
-        <p>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 <code>input</code> element,
-        express the equivalent of "This is a searchable index. Insert
-        your search keywords here: (input field)" in the user's
-        preferred language.</p>
+    <p>Act as if an end tag token with the tag name "form" had been seen.</p>
 
-        <p class="big-issue">
-        Then need to specify that if the form submission causes just a single
-        form control, whose name is "isindex", to be submitted, then we submit
-        just the value part, not the "isindex=" part.
-        </p>
+    <p>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 <code>input</code> element,
+    express the equivalent of "This is a searchable index. Insert
+    your search keywords here: (input field)" in the user's
+    preferred language.</p>
 
-       </dd>
+    <p class="big-issue">
+    Then need to specify that if the form submission causes just a single
+    form control, whose name is "isindex", to be submitted, then we submit
+    just the value part, not the "isindex=" part.
+    </p>
 
+   </dd>
+
 <!-- XXX keygen support; don't forget form element pointer!
 
-       <dt>A start tag whose tag name is "keygen"</dt>
-       <dd>
-        ...
-       </dd>
+   <dt>A start tag whose tag name is "keygen"</dt>
+   <dd>
+    ...
+   </dd>
 -->
 
-       <dt>A start tag whose tag name is "textarea"</dt>
-       <dd>
+   <dt>A start tag whose tag name is "textarea"</dt>
+   <dd>
 
-        <p><span>Create an element for the token</span>.</p>
+    <p><span>Create an element for the token</span>.</p>
 
-        <p>If the <span><code title="">form</code> element
-        pointer</span> is not null, then <span>associate</span><!--XXX
-        xref! --> the <code>textarea</code> element with the
-        <code>form</code> element pointed to by the <span><code
-        title="">form</code> element pointer</span>.</p>
+    <p>If the <span><code title="">form</code> element
+    pointer</span> is not null, then <span>associate</span><!--XXX
+    xref! --> the <code>textarea</code> element with the
+    <code>form</code> element pointed to by the <span><code
+    title="">form</code> element pointer</span>.</p>
 
-        <p>Append the new element to the <span>current
-        node</span>.</p>
+    <p>Append the new element to the <span>current
+    node</span>.</p>
 
-        <p>Switch the tokeniser's <span>content model flag</span> to
-        the RCDATA state.</p>
+    <p>Switch the tokeniser's <span>content model flag</span> to
+    the RCDATA state.</p>
 
-        <p>If the next token is a U+000A LINE FEED (LF) character
-        token, then ignore that token and move on to the next
-        one. (Newlines at the start of <code>textarea</code> elements
-        are ignored as an authoring convenience.)</p>
+    <p>If the next token is a U+000A LINE FEED (LF) character
+    token, then ignore that token and move on to the next
+    one. (Newlines at the start of <code>textarea</code> elements
+    are ignored as an authoring convenience.)</p>
 
-        <p>Then, collect all the character tokens that the tokeniser
-        returns until it returns a token that is not a character
-        token, or until it stops tokenising.</p>
+    <p>Then, collect all the character tokens that the tokeniser
+    returns until it returns a token that is not a character
+    token, or until it stops tokenising.</p>
 
-        <p>If this process resulted in a collection of character
-        tokens, append a single <code>Text</code> node, whose contents
-        is the concatenation of all those tokens' characters, to the
-        new element node.</p>
+    <p>If this process resulted in a collection of character
+    tokens, append a single <code>Text</code> node, whose contents
+    is the concatenation of all those tokens' characters, to the
+    new element node.</p>
 
-        <p>The tokeniser's <span>content model flag</span> will have
-        switched back to the PCDATA state.</p>
+    <p>The tokeniser's <span>content model flag</span> will have
+    switched back to the PCDATA state.</p>
 
-        <p>If the next token is an end tag token with the tag name
-        "textarea", ignore it. Otherwise, this is a <span>parse
-        error</span>.</p>
+    <p>If the next token is an end tag token with the tag name
+    "textarea", ignore it. Otherwise, this is a <span>parse
+    error</span>.</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is one of: "iframe",
-       "noembed", "noframes"</dt>
-       <dt>A start tag whose tag name is "noscript", if
-       <span>scripting is enabled</span>:</dt>
-       <dd>
+   <dt>A start tag whose tag name is one of: "iframe",
+   "noembed", "noframes"</dt>
+   <dt>A start tag whose tag name is "noscript", if
+   <span>scripting is enabled</span>:</dt>
+   <dd>
 
-        <p>Follow the <span>generic CDATA parsing algorithm</span>,
-        with the <span>current node</span> as the <var
-        title="">context node</var>.</p>
+    <p>Follow the <span>generic CDATA parsing algorithm</span>,
+    with the <span>current node</span> as the <var
+    title="">context node</var>.</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is "select"</dt>
-       <dd>
+   <dt>A start tag whose tag name is "select"</dt>
+   <dd>
 
-        <p><span>Reconstruct the active formatting elements</span>, if
-        any.</p>
+    <p><span>Reconstruct the active formatting elements</span>, if
+    any.</p>
 
-        <p><span>Insert an HTML element</span> for the token.</p>
+    <p><span>Insert an HTML element</span> for the token.</p>
 
-        <p>Change the <span>insertion mode</span> to "<span
-        title="insertion mode: in select">in select</span>".</p>
+    <p>Change the <span>insertion mode</span> to "<span
+    title="insertion mode: in select">in select</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is "br"</dt>
-       <dd>
-        <p><span>Parse error</span>. Act as if a start tag token with
-        the tag name "br" had been seen. Ignore the end tag token.</p>
-       </dd>
+   <dt>An end tag whose tag name is "br"</dt>
+   <dd>
+    <p><span>Parse error</span>. Act as if a start tag token with
+    the tag name "br" had been seen. Ignore the end tag token.</p>
+   </dd>
 
-       <dt>A start or end tag whose tag name is one of: "caption",
-       "col", "colgroup", "frame", "frameset", "head", "option",
-       "optgroup", "tbody", "td", "tfoot", "th", "thead", "tr"</dt>
-       <dt>An end tag whose tag name is one of: "area", "basefont",
-       "bgsound", <!--XXX quirks: remove br-->"br", "embed", "hr",
-       "iframe", "image", "img", "input", "isindex", "noembed",
-       "noframes", "param", "select", "spacer", "table", "textarea",
-       "wbr"</dt> <!-- add keygen if we add the start tag -->
-       <dt>An end tag whose tag name is "noscript", if <span>scripting
-       is enabled</span>:</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>A start or end tag whose tag name is one of: "caption",
+   "col", "colgroup", "frame", "frameset", "head", "option",
+   "optgroup", "tbody", "td", "tfoot", "th", "thead", "tr"</dt>
+   <dt>An end tag whose tag name is one of: "area", "basefont",
+   "bgsound", <!--XXX quirks: remove br-->"br", "embed", "hr",
+   "iframe", "image", "img", "input", "isindex", "noembed",
+   "noframes", "param", "select", "spacer", "table", "textarea",
+   "wbr"</dt> <!-- add keygen if we add the start tag -->
+   <dt>An end tag whose tag name is "noscript", if <span>scripting
+   is enabled</span>:</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>A start or end tag whose tag name is one of:
-       "event-source", "section", "nav", "article", "aside", "header",
-       "footer", "datagrid", "command"</dt>
+   <dt>A start or end tag whose tag name is one of:
+   "event-source", "section", "nav", "article", "aside", "header",
+   "footer", "datagrid", "command"</dt>
 
-       <dd>
+   <dd>
 
-        <!-- XXXX -->
+    <!-- XXXX -->
 
-        <p class="big-issue">Work in progress!</p>
+    <p class="big-issue">Work in progress!</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag token not covered by the previous entries</dt>
-       <dd>
+   <dt>A start tag token not covered by the previous entries</dt>
+   <dd>
 
-        <p><span>Reconstruct the active formatting elements</span>, if
-        any.</p>
+    <p><span>Reconstruct the active formatting elements</span>, if
+    any.</p>
 
-        <p><span>Insert an HTML element</span> for the token.</p>
+    <p><span>Insert an HTML element</span> for the token.</p>
 
-        <p class="note">This element will be a <span>phrasing</span>
-        element.</p>
+    <p class="note">This element will be a <span>phrasing</span>
+    element.</p>
 
 <!--
 Put the following into the MathML namespace if parsed:
-   math, mrow, mfrac, msqrt, mroot, mstyle, merror, mpadded, 
-   mphantom, mfenced, menclose, msub, msup, msubsup, munder, 
-   mover, munderover, mmultiscripts, mtable, mlabeledtr, mtr, 
-   mtd, maction
+math, mrow, mfrac, msqrt, mroot, mstyle, merror, mpadded, 
+mphantom, mfenced, menclose, msub, msup, msubsup, munder, 
+mover, munderover, mmultiscripts, mtable, mlabeledtr, mtr, 
+mtd, maction
 -->
 
-       </dd>
+   </dd>
 
-       <dt>An end tag token not covered by the previous entries</dt>
-       <dd>
+   <dt>An end tag token not covered by the previous entries</dt>
+   <dd>
 
-        <p>Run the following algorithm:</p>
+    <p>Run the following algorithm:</p>
 
-        <ol>
+    <ol>
 
-         <li><p>Initialise <var title="">node</var> to be the <span>current
-         node</span> (the bottommost node of the stack).</p></li>
+     <li><p>Initialise <var title="">node</var> to be the <span>current
+     node</span> (the bottommost node of the stack).</p></li>
 
-         <li><p>If <var title="">node</var> has the same tag name as
-         the end tag token, then:</p>
+     <li><p>If <var title="">node</var> has the same tag name as
+     the end tag token, then:</p>
 
-          <ol>
+      <ol>
 
-           <li><p><span>Generate implied end tags</span>.</p></li>
+       <li><p><span>Generate implied end tags</span>.</p></li>
 
-           <li><p>If the tag name of the end tag token does not match
-           the tag name of the <span>current node</span>, this is a
-           <span>parse error</span>.</p></li>
+       <li><p>If the tag name of the end tag token does not match
+       the tag name of the <span>current node</span>, this is a
+       <span>parse error</span>.</p></li>
 
-           <li><p>Pop all the nodes from the <span>current node</span>
-           up to <var title="">node</var>, including <var title="">node</var>, then stop
-           this algorithm.</p></li>
+       <li><p>Pop all the nodes from the <span>current node</span>
+       up to <var title="">node</var>, including <var title="">node</var>, then stop
+       this algorithm.</p></li>
 
-          </ol>
+      </ol>
 
-         </li>
+     </li>
 
-         <li><p>Otherwise, if <var title="">node</var> is in neither
-         the <span>formatting</span> category nor the
-         <span>phrasing</span> category, then this is a <span>parse
-         error</span>. Stop this algorithm. The end tag token is
-         ignored.</p></li>
+     <li><p>Otherwise, if <var title="">node</var> is in neither
+     the <span>formatting</span> category nor the
+     <span>phrasing</span> category, then this is a <span>parse
+     error</span>. Stop this algorithm. The end tag token is
+     ignored.</p></li>
 
-         <li><p>Set <var title="">node</var> to the previous entry in the
-         <span>stack of open elements</span>.</p></li>
+     <li><p>Set <var title="">node</var> to the previous entry in the
+     <span>stack of open elements</span>.</p></li>
 
-         <li><p>Return to step 2.</p></li>
+     <li><p>Return to step 2.</p></li>
 
-        </ol>
+    </ol>
 
-       </dd>
+   </dd>
 
-      </dl>
+  </dl>
 
 
-      <h6 id="parsing-main-intable">The <dfn title="insertion mode: in table">in table</dfn> insertion mode</h6>
+  <h6 id="parsing-main-intable">The <dfn title="insertion mode: in table">in table</dfn> insertion mode</h6>
 
-      <dl class="switch">
+  <dl class="switch">
 
-       <dt>An end-of-file token</dt>
-       <dd>
-        <p><span>Stop parsing, with prejudice.</span></p>
-       </dd>
+   <dt>An end-of-file token</dt>
+   <dd>
+    <p><span>Stop parsing, with prejudice.</span></p>
+   </dd>
 
-       <dt>A character token that is one of one of U+0009
-       CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
-       TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
-       or U+0020 SPACE</dt>
-       <dd>
-        <p><span title="append a character">Append the character</span> to
-        the <span>current node</span>.</p>
-       </dd>
+   <dt>A character token that is one of one of U+0009
+   CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+   TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+   or U+0020 SPACE</dt>
+   <dd>
+    <p><span title="append a character">Append the character</span> to
+    the <span>current node</span>.</p>
+   </dd>
 
-       <dt>A comment token</dt>
-       <dd>
-        <p>Append a <code>Comment</code> node to the <span>current
-        node</span> with the <code title="">data</code> attribute set to
-        the data given in the comment token.</p>
-       </dd>
+   <dt>A comment token</dt>
+   <dd>
+    <p>Append a <code>Comment</code> node to the <span>current
+    node</span> with the <code title="">data</code> attribute set to
+    the data given in the comment token.</p>
+   </dd>
 
-       <dt>A DOCTYPE token</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>A DOCTYPE token</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "html"</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in body">in
-        body</span>".</p>
-       </dd>
+   <dt>A start tag whose tag name is "html"</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in body">in
+    body</span>".</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "caption"</dt>
-       <dd>
+   <dt>A start tag whose tag name is "caption"</dt>
+   <dd>
 
-        <p><span>Clear the stack back to a table context</span>. (See
-        below.)</p>
+    <p><span>Clear the stack back to a table context</span>. (See
+    below.)</p>
 
-        <p>Insert a marker at the end of the <span>list of active
-        formatting elements</span>.</p>
+    <p>Insert a marker at the end of the <span>list of active
+    formatting elements</span>.</p>
 
-        <p><span>Insert an HTML element</span> for the token, then
-        switch the <span>insertion mode</span> to "<span
-        title="insertion mode: in caption">in caption</span>".</p>
+    <p><span>Insert an HTML element</span> for the token, then
+    switch the <span>insertion mode</span> to "<span
+    title="insertion mode: in caption">in caption</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is "colgroup"</dt>
-       <dd>
+   <dt>A start tag whose tag name is "colgroup"</dt>
+   <dd>
 
-        <p><span>Clear the stack back to a table context</span>. (See
-        below.)</p>
+    <p><span>Clear the stack back to a table context</span>. (See
+    below.)</p>
 
-        <p><span>Insert an HTML element</span> for the token, then
-        switch the <span>insertion mode</span> to "<span
-        title="insertion mode: in column group">in column
-        group</span>".</p>
+    <p><span>Insert an HTML element</span> for the token, then
+    switch the <span>insertion mode</span> to "<span
+    title="insertion mode: in column group">in column
+    group</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is "col"</dt>
-       <dd>
-        <p>Act as if a start tag token with the tag name "colgroup"
-        had been seen, then reprocess the current token.</p>
-       </dd>
+   <dt>A start tag whose tag name is "col"</dt>
+   <dd>
+    <p>Act as if a start tag token with the tag name "colgroup"
+    had been seen, then reprocess the current token.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is one of: "tbody", "tfoot", "thead"</dt>
-       <dd>
+   <dt>A start tag whose tag name is one of: "tbody", "tfoot", "thead"</dt>
+   <dd>
 
-        <p><span>Clear the stack back to a table context</span>. (See
-        below.)</p>
+    <p><span>Clear the stack back to a table context</span>. (See
+    below.)</p>
 
-        <p><span>Insert an HTML element</span> for the token, then
-        switch the <span>insertion mode</span> to "<span
-        title="insertion mode: in table body">in table
-        body</span>".</p>
+    <p><span>Insert an HTML element</span> for the token, then
+    switch the <span>insertion mode</span> to "<span
+    title="insertion mode: in table body">in table
+    body</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is one of: "td", "th", "tr"</dt>
-       <dd>
-        <p>Act as if a start tag token with the tag name "tbody" had
-        been seen, then reprocess the current token.</p>
-       </dd>
+   <dt>A start tag whose tag name is one of: "td", "th", "tr"</dt>
+   <dd>
+    <p>Act as if a start tag token with the tag name "tbody" had
+    been seen, then reprocess the current token.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "table"</dt>
-       <dd>
+   <dt>A start tag whose tag name is "table"</dt>
+   <dd>
 
-        <p><span>Parse error</span>. 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.</p>
+    <p><span>Parse error</span>. 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.</p>
 
-        <p class="note">The fake end tag token here can only be
-        ignored in the <span>fragment case</span>.</p>
+    <p class="note">The fake end tag token here can only be
+    ignored in the <span>fragment case</span>.</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is "table"</dt>
-       <dd>
+   <dt>An end tag whose tag name is "table"</dt>
+   <dd>
 
-        <p>If the <span>stack of open elements</span> does not <span
-        title="has an element in table scope">have an element in table
-        scope</span> with the same tag name as the token, this is a
-        <span>parse error</span>. Ignore the token. (<span>fragment
-        case</span>)</p>
+    <p>If the <span>stack of open elements</span> does not <span
+    title="has an element in table scope">have an element in table
+    scope</span> with the same tag name as the token, this is a
+    <span>parse error</span>. Ignore the token. (<span>fragment
+    case</span>)</p>
 
-        <p>Otherwise:</p>
+    <p>Otherwise:</p>
 
-        <p><span>Generate implied end tags</span>.</p>
+    <p><span>Generate implied end tags</span>.</p>
 
-        <p>Now, if the <span>current node</span> is not a
-        <code>table</code> element, then this is a <span>parse
-        error</span>.</p>
+    <p>Now, if the <span>current node</span> is not a
+    <code>table</code> element, then this is a <span>parse
+    error</span>.</p>
 
-        <p>Pop elements from this stack until a <code>table</code>
-        element has been popped from the stack.</p>
+    <p>Pop elements from this stack until a <code>table</code>
+    element has been popped from the stack.</p>
 
-        <p><span>Reset the insertion mode appropriately</span>.</p>
+    <p><span>Reset the insertion mode appropriately</span>.</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is one of: "body", "caption",
-       "col", "colgroup", "html", "tbody", "td", "tfoot", "th",
-       "thead", "tr"</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>An end tag whose tag name is one of: "body", "caption",
+   "col", "colgroup", "html", "tbody", "td", "tfoot", "th",
+   "thead", "tr"</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>Anything else</dt>
-       <dd>
+   <dt>Anything else</dt>
+   <dd>
 
-        <p><span>Parse error</span>. Process the token as if the
-        <span>insertion mode</span> was "<span title="insertion mode:
-        in body">in body</span>", with the following exception:</p>
+    <p><span>Parse error</span>. Process the token as if the
+    <span>insertion mode</span> was "<span title="insertion mode:
+    in body">in body</span>", with the following exception:</p>
 
-        <p>If the <span>current node</span> is a <code>table</code>,
-        <code>tbody</code>, <code>tfoot</code>, <code>thead</code>, or
-        <code>tr</code> element, then, whenever a node would be
-        inserted into the <span>current node</span>, it must instead
-        be inserted into the <em>foster parent element</em>.</p>
+    <p>If the <span>current node</span> is a <code>table</code>,
+    <code>tbody</code>, <code>tfoot</code>, <code>thead</code>, or
+    <code>tr</code> element, then, whenever a node would be
+    inserted into the <span>current node</span>, it must instead
+    be inserted into the <em>foster parent element</em>.</p>
 
-        <p>The <dfn>foster parent element</dfn> is the parent element
-        of the last <code>table</code> element in the <span>stack of
-        open elements</span>, if there is a <code>table</code> element
-        and it has such a parent element. If there is no
-        <code>table</code> element in the <span>stack of open
-        elements</span> (<span>fragment case</span>), then the
-        <em>foster parent element</em> is the first element in the
-        <span>stack of open elements</span> (the <code>html</code>
-        element). Otherwise, if there is a <code>table</code> element
-        in the <span>stack of open elements</span>, but the last
-        <code>table</code> element in the <span>stack of open
-        elements</span> has no parent, or its parent node is not an
-        element, then the <em>foster parent element</em> is the
-        element before the last <code>table</code> element in the
-        <span>stack of open elements</span>.</p>
+    <p>The <dfn>foster parent element</dfn> is the parent element
+    of the last <code>table</code> element in the <span>stack of
+    open elements</span>, if there is a <code>table</code> element
+    and it has such a parent element. If there is no
+    <code>table</code> element in the <span>stack of open
+    elements</span> (<span>fragment case</span>), then the
+    <em>foster parent element</em> is the first element in the
+    <span>stack of open elements</span> (the <code>html</code>
+    element). Otherwise, if there is a <code>table</code> element
+    in the <span>stack of open elements</span>, but the last
+    <code>table</code> element in the <span>stack of open
+    elements</span> has no parent, or its parent node is not an
+    element, then the <em>foster parent element</em> is the
+    element before the last <code>table</code> element in the
+    <span>stack of open elements</span>.</p>
 
-        <p>If the <em>foster parent element</em> is the parent element
-        of the last <code>table</code> element in the <span>stack of
-        open elements</span>, then the new node must be inserted
-        immediately <em>before</em> the last <code>table</code>
-        element in the <span>stack of open elements</span> in the
-        <span>foster parent element</span>; otherwise, the new node
-        must be <em>appended</em> to the <span>foster parent
-        element</span>.</p>
+    <p>If the <em>foster parent element</em> is the parent element
+    of the last <code>table</code> element in the <span>stack of
+    open elements</span>, then the new node must be inserted
+    immediately <em>before</em> the last <code>table</code>
+    element in the <span>stack of open elements</span> in the
+    <span>foster parent element</span>; otherwise, the new node
+    must be <em>appended</em> to the <span>foster parent
+    element</span>.</p>
 
-       </dd>
+   </dd>
 
-      </dl>
+  </dl>
 
-      <p>When the steps above require the UA to <dfn>clear the stack
-      back to a table context</dfn>, it means that the UA must, while
-      the <span>current node</span> is not a <code>table</code>
-      element or an <code>html</code> element, pop elements from the
-      <span>stack of open elements</span>. If this causes any elements
-      to be popped from the stack, then this is a <span>parse
-      error</span>.</p>
+  <p>When the steps above require the UA to <dfn>clear the stack
+  back to a table context</dfn>, it means that the UA must, while
+  the <span>current node</span> is not a <code>table</code>
+  element or an <code>html</code> element, pop elements from the
+  <span>stack of open elements</span>. If this causes any elements
+  to be popped from the stack, then this is a <span>parse
+  error</span>.</p>
 
-      <p class="note">The <span>current node</span> being an
-      <code>html</code> element after this process is a <span>fragment
-      case</span>.</p>
+  <p class="note">The <span>current node</span> being an
+  <code>html</code> element after this process is a <span>fragment
+  case</span>.</p>
 
 
-      <h6 id="parsing-main-incaption">The <dfn title="insertion mode: in caption">in caption</dfn> insertion mode</h6>
+  <h6 id="parsing-main-incaption">The <dfn title="insertion mode: in caption">in caption</dfn> insertion mode</h6>
 
-      <p>Handle the token as follows.</p>
+  <p>Handle the token as follows.</p>
 
-      <dl class="switch">
+  <dl class="switch">
 
-       <dt>An end tag whose tag name is "caption"</dt>
-       <dd>
+   <dt>An end tag whose tag name is "caption"</dt>
+   <dd>
 
-        <p>If the <span>stack of open elements</span> does not <span
-        title="has an element in table scope">have an element in table
-        scope</span> with the same tag name as the token, this is a
-        <span>parse error</span>. Ignore the token. (<span>fragment
-        case</span>)</p>
+    <p>If the <span>stack of open elements</span> does not <span
+    title="has an element in table scope">have an element in table
+    scope</span> with the same tag name as the token, this is a
+    <span>parse error</span>. Ignore the token. (<span>fragment
+    case</span>)</p>
 
-        <p>Otherwise:</p>
+    <p>Otherwise:</p>
 
-        <p><span>Generate implied end tags</span>.</p>
+    <p><span>Generate implied end tags</span>.</p>
 
-        <p>Now, if the <span>current node</span> is not a
-        <code>caption</code> element, then this is a <span>parse
-        error</span>.</p>
+    <p>Now, if the <span>current node</span> is not a
+    <code>caption</code> element, then this is a <span>parse
+    error</span>.</p>
 
-        <p>Pop elements from this stack until a <code>caption</code>
-        element has been popped from the stack.</p>
+    <p>Pop elements from this stack until a <code>caption</code>
+    element has been popped from the stack.</p>
 
-        <p><span>Clear the list of active formatting elements up to
-        the last marker</span>.</p>
+    <p><span>Clear the list of active formatting elements up to
+    the last marker</span>.</p>
 
-        <p>Switch the <span>insertion mode</span> to "<span
-        title="insertion mode: in table">in table</span>".</p>
+    <p>Switch the <span>insertion mode</span> to "<span
+    title="insertion mode: in table">in table</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is one of: "caption", "col",
-       "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr"</dt>
-       <dt>An end tag whose tag name is "table"</dt>
-       <dd>
+   <dt>A start tag whose tag name is one of: "caption", "col",
+   "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr"</dt>
+   <dt>An end tag whose tag name is "table"</dt>
+   <dd>
 
-        <p><span>Parse error</span>. 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.</p>
+    <p><span>Parse error</span>. 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.</p>
 
-        <p class="note">The fake end tag token here can only be
-        ignored in the <span>fragment case</span>.</p>
+    <p class="note">The fake end tag token here can only be
+    ignored in the <span>fragment case</span>.</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is one of: "body", "col",
-       "colgroup", "html", "tbody", "td", "tfoot", "th", "thead",
-       "tr"</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>An end tag whose tag name is one of: "body", "col",
+   "colgroup", "html", "tbody", "td", "tfoot", "th", "thead",
+   "tr"</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>Anything else</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> was
-        "<span title="insertion mode: in body">in body</span>".</p>
-       </dd>
+   <dt>Anything else</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> was
+    "<span title="insertion mode: in body">in body</span>".</p>
+   </dd>
 
-      </dl>
+  </dl>
 
 
-      <h6 id="parsing-main-incolgroup">The <dfn title="insertion mode: in column group">in column group</dfn> insertion mode</h6>
+  <h6 id="parsing-main-incolgroup">The <dfn title="insertion mode: in column group">in column group</dfn> insertion mode</h6>
 
-      <p>Handle the token as follows.</p>
+  <p>Handle the token as follows.</p>
 
-      <dl class="switch">
+  <dl class="switch">
 
-       <dt>An end-of-file token</dt>
-       <dd>
-        <p><span>Stop parsing, with prejudice.</span></p>
-       </dd>
+   <dt>An end-of-file token</dt>
+   <dd>
+    <p><span>Stop parsing, with prejudice.</span></p>
+   </dd>
 
-       <dt>A character token that is one of one of U+0009
-       CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
-       TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
-       or U+0020 SPACE</dt>
-       <dd>
-        <p><span title="append a character">Append the character</span> to
-        the <span>current node</span>.</p>
-       </dd>
+   <dt>A character token that is one of one of U+0009
+   CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+   TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+   or U+0020 SPACE</dt>
+   <dd>
+    <p><span title="append a character">Append the character</span> to
+    the <span>current node</span>.</p>
+   </dd>
 
-       <dt>A comment token</dt>
-       <dd>
-        <p>Append a <code>Comment</code> node to the <span>current
-        node</span> with the <code title="">data</code> attribute set to
-        the data given in the comment token.</p>
-       </dd>
+   <dt>A comment token</dt>
+   <dd>
+    <p>Append a <code>Comment</code> node to the <span>current
+    node</span> with the <code title="">data</code> attribute set to
+    the data given in the comment token.</p>
+   </dd>
 
-       <dt>A DOCTYPE token</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>A DOCTYPE token</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "html"</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in body">in
-        body</span>".</p>
-       </dd>
+   <dt>A start tag whose tag name is "html"</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in body">in
+    body</span>".</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "col"</dt>
-       <dd>
-        <p><span title="insert an HTML element">Insert a
-        <code>col</code> element</span> for the token. Immediately
-        pop the <span>current node</span> off the <span>stack of open
-        elements</span>.</p>
-       </dd>
+   <dt>A start tag whose tag name is "col"</dt>
+   <dd>
+    <p><span title="insert an HTML element">Insert a
+    <code>col</code> element</span> for the token. Immediately
+    pop the <span>current node</span> off the <span>stack of open
+    elements</span>.</p>
+   </dd>
 
-       <dt>An end tag whose tag name is "colgroup"</dt>
-       <dd>
+   <dt>An end tag whose tag name is "colgroup"</dt>
+   <dd>
 
-        <p>If the <span>current node</span> is the root
-        <code>html</code> element, then this is a <span>parse
-        error</span>, ignore the token. (<span>fragment
-        case</span>)</p>
+    <p>If the <span>current node</span> is the root
+    <code>html</code> element, then this is a <span>parse
+    error</span>, ignore the token. (<span>fragment
+    case</span>)</p>
 
-        <p>Otherwise, pop the <span>current node</span> (which will be
-        a <code>colgroup</code> element) from the <span>stack of open
-        elements</span>. Switch the <span>insertion mode</span> to
-        "<span title="insertion mode: in table">in table</span>".</p>
+    <p>Otherwise, pop the <span>current node</span> (which will be
+    a <code>colgroup</code> element) from the <span>stack of open
+    elements</span>. Switch the <span>insertion mode</span> to
+    "<span title="insertion mode: in table">in table</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is "col"</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>An end tag whose tag name is "col"</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>Anything else</dt>
-       <dd>
+   <dt>Anything else</dt>
+   <dd>
 
-        <p>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.</p>
+    <p>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.</p>
 
-        <p class="note">The fake end tag token here can only be
-        ignored in the <span>fragment case</span>.</p>
+    <p class="note">The fake end tag token here can only be
+    ignored in the <span>fragment case</span>.</p>
 
-       </dd>
+   </dd>
 
-      </dl>
+  </dl>
 
 
-      <h6 id="parsing-main-intbody">The <dfn title="insertion mode: in table body">in table body</dfn> insertion mode</h6>
+  <h6 id="parsing-main-intbody">The <dfn title="insertion mode: in table body">in table body</dfn> insertion mode</h6>
 
-      <p>Handle the token as follows.</p>
+  <p>Handle the token as follows.</p>
 
-      <dl class="switch">
+  <dl class="switch">
 
-       <dt>A start tag whose tag name is "tr"</dt>
-       <dd>
+   <dt>A start tag whose tag name is "tr"</dt>
+   <dd>
 
-        <p><span>Clear the stack back to a table body
-        context</span>. (See below.)</p>
+    <p><span>Clear the stack back to a table body
+    context</span>. (See below.)</p>
 
-        <p><span title="insert an HTML element">Insert a
-        <code>tr</code> element</span> for the token, then switch the
-        <span>insertion mode</span> to "<span title="insertion mode:
-        in row">in row</span>".</p>
+    <p><span title="insert an HTML element">Insert a
+    <code>tr</code> element</span> for the token, then switch the
+    <span>insertion mode</span> to "<span title="insertion mode:
+    in row">in row</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is one of: "th", "td"</dt>
-       <dd>
-        <p><span>Parse error</span>. Act as if a start tag with
-        the tag name "tr" had been seen, then reprocess the current
-        token.</p>
-       </dd>
+   <dt>A start tag whose tag name is one of: "th", "td"</dt>
+   <dd>
+    <p><span>Parse error</span>. Act as if a start tag with
+    the tag name "tr" had been seen, then reprocess the current
+    token.</p>
+   </dd>
 
-       <dt>An end tag whose tag name is one of: "tbody", "tfoot",
-       "thead"</dt>
-       <dd>
+   <dt>An end tag whose tag name is one of: "tbody", "tfoot",
+   "thead"</dt>
+   <dd>
 
-        <p>If the <span>stack of open elements</span> does not <span
-        title="has an element in table scope">have an element in table
-        scope</span> with the same tag name as the token, this is a
-        <span>parse error</span>. Ignore the token.</p>
+    <p>If the <span>stack of open elements</span> does not <span
+    title="has an element in table scope">have an element in table
+    scope</span> with the same tag name as the token, this is a
+    <span>parse error</span>. Ignore the token.</p>
 
-        <p>Otherwise:</p>
+    <p>Otherwise:</p>
 
-        <p><span>Clear the stack back to a table body
-        context</span>. (See below.)</p>
+    <p><span>Clear the stack back to a table body
+    context</span>. (See below.)</p>
 
-        <p>Pop the <span>current node</span> from the <span>stack of
-        open elements</span>. Switch the <span>insertion mode</span>
-        to "<span title="insertion mode: in table">in table</span>".</p>
+    <p>Pop the <span>current node</span> from the <span>stack of
+    open elements</span>. Switch the <span>insertion mode</span>
+    to "<span title="insertion mode: in table">in table</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is one of: "caption", "col",
-       "colgroup", "tbody", "tfoot", "thead"</dt>
-       <dt>An end tag whose tag name is "table"</dt>
-       <dd>
+   <dt>A start tag whose tag name is one of: "caption", "col",
+   "colgroup", "tbody", "tfoot", "thead"</dt>
+   <dt>An end tag whose tag name is "table"</dt>
+   <dd>
 
-        <p>If the <span>stack of open elements</span> does not <span
-        title="has an element in table scope">have a
-        <code>tbody</code>, <code>thead</code>, or <code>tfoot</code>
-        element in table scope</span>, this is a <span>parse
-        error</span>. Ignore the token. (<span>fragment
-        case</span>)</p>
+    <p>If the <span>stack of open elements</span> does not <span
+    title="has an element in table scope">have a
+    <code>tbody</code>, <code>thead</code>, or <code>tfoot</code>
+    element in table scope</span>, this is a <span>parse
+    error</span>. Ignore the token. (<span>fragment
+    case</span>)</p>
 
-        <p>Otherwise:</p>
+    <p>Otherwise:</p>
 
-        <p><span>Clear the stack back to a table body
-        context</span>. (See below.)</p>
+    <p><span>Clear the stack back to a table body
+    context</span>. (See below.)</p>
 
-        <p>Act as if an end tag with the same tag name as the
-        <span>current node</span> ("tbody", "tfoot", or "thead") had
-        been seen, then reprocess the current token.</p>
+    <p>Act as if an end tag with the same tag name as the
+    <span>current node</span> ("tbody", "tfoot", or "thead") had
+    been seen, then reprocess the current token.</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is one of: "body", "caption",
-       "col", "colgroup", "html", "td", "th", "tr"</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>An end tag whose tag name is one of: "body", "caption",
+   "col", "colgroup", "html", "td", "th", "tr"</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>Anything else</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> was
-        "<span title="insertion mode: in table">in table</span>".</p>
-       </dd>
+   <dt>Anything else</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> was
+    "<span title="insertion mode: in table">in table</span>".</p>
+   </dd>
 
-      </dl>
+  </dl>
 
-      <p>When the steps above require the UA to <dfn>clear the stack
-      back to a table body context</dfn>, it means that the UA must,
-      while the <span>current node</span> is not a <code>tbody</code>,
-      <code>tfoot</code>, <code>thead</code>, or <code>html</code>
-      element, pop elements from the <span>stack of open
-      elements</span>. If this causes any elements to be popped from
-      the stack, then this is a
-      <span>parse error</span>.</p>
+  <p>When the steps above require the UA to <dfn>clear the stack
+  back to a table body context</dfn>, it means that the UA must,
+  while the <span>current node</span> is not a <code>tbody</code>,
+  <code>tfoot</code>, <code>thead</code>, or <code>html</code>
+  element, pop elements from the <span>stack of open
+  elements</span>. If this causes any elements to be popped from
+  the stack, then this is a
+  <span>parse error</span>.</p>
 
-      <p class="note">The <span>current node</span> being an
-      <code>html</code> element after this process is a <span>fragment
-      case</span>.</p>
+  <p class="note">The <span>current node</span> being an
+  <code>html</code> element after this process is a <span>fragment
+  case</span>.</p>
 
 
-      <h6 id="parsing-main-intr">The <dfn title="insertion mode: in row">in row</dfn> insertion mode</h6>
+  <h6 id="parsing-main-intr">The <dfn title="insertion mode: in row">in row</dfn> insertion mode</h6>
 
-      <p>Handle the token as follows.</p>
+  <p>Handle the token as follows.</p>
 
-      <dl class="switch">
+  <dl class="switch">
 
-       <dt>A start tag whose tag name is one of: "th", "td"</dt>
-       <dd>
+   <dt>A start tag whose tag name is one of: "th", "td"</dt>
+   <dd>
 
-        <p><span>Clear the stack back to a table row
-        context</span>. (See below.)</p>
+    <p><span>Clear the stack back to a table row
+    context</span>. (See below.)</p>
 
-        <p><span title="insert an HTML element">Insert an HTML
-        element</span> for the token, then switch the <span>insertion
-        mode</span> to "<span title="insertion mode: in cell">in
-        cell</span>".</p>
+    <p><span title="insert an HTML element">Insert an HTML
+    element</span> for the token, then switch the <span>insertion
+    mode</span> to "<span title="insertion mode: in cell">in
+    cell</span>".</p>
 
-        <p>Insert a marker at the end of the <span>list of active
-        formatting elements</span>.</p>
+    <p>Insert a marker at the end of the <span>list of active
+    formatting elements</span>.</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is "tr"</dt>
-       <dd>
+   <dt>An end tag whose tag name is "tr"</dt>
+   <dd>
 
-        <p>If the <span>stack of open elements</span> does not <span
-        title="has an element in table scope">have an element in table
-        scope</span> with the same tag name as the token, this is a
-        <span>parse error</span>. Ignore the token. (<span>fragment
-        case</span>)</p>
+    <p>If the <span>stack of open elements</span> does not <span
+    title="has an element in table scope">have an element in table
+    scope</span> with the same tag name as the token, this is a
+    <span>parse error</span>. Ignore the token. (<span>fragment
+    case</span>)</p>
 
-        <p>Otherwise:</p>
+    <p>Otherwise:</p>
 
-        <p><span>Clear the stack back to a table row
-        context</span>. (See below.)</p>
+    <p><span>Clear the stack back to a table row
+    context</span>. (See below.)</p>
 
-        <p>Pop the <span>current node</span> (which will be a
-        <code>tr</code> element) from the <span>stack of open
-        elements</span>. Switch the <span>insertion mode</span> to
-        "<span title="insertion mode: in table body">in table
-        body</span>".</p>
+    <p>Pop the <span>current node</span> (which will be a
+    <code>tr</code> element) from the <span>stack of open
+    elements</span>. Switch the <span>insertion mode</span> to
+    "<span title="insertion mode: in table body">in table
+    body</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is one of: "caption", "col",
-       "colgroup", "tbody", "tfoot", "thead", "tr"</dt>
-       <dt>An end tag whose tag name is "table"</dt>
-       <dd>
+   <dt>A start tag whose tag name is one of: "caption", "col",
+   "colgroup", "tbody", "tfoot", "thead", "tr"</dt>
+   <dt>An end tag whose tag name is "table"</dt>
+   <dd>
 
-        <p>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.</p>
+    <p>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.</p>
 
-        <p class="note">The fake end tag token here can only be
-        ignored in the <span>fragment case</span>.</p>
+    <p class="note">The fake end tag token here can only be
+    ignored in the <span>fragment case</span>.</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is one of: "tbody", "tfoot",
-       "thead"</dt>
-       <dd>
+   <dt>An end tag whose tag name is one of: "tbody", "tfoot",
+   "thead"</dt>
+   <dd>
 
-        <p>If the <span>stack of open elements</span> does not <span
-        title="has an element in table scope">have an element in table
-        scope</span> with the same tag name as the token, this is a
-        <span>parse error</span>. Ignore the token.</p>
+    <p>If the <span>stack of open elements</span> does not <span
+    title="has an element in table scope">have an element in table
+    scope</span> with the same tag name as the token, this is a
+    <span>parse error</span>. Ignore the token.</p>
 
-        <p>Otherwise, act as if an end tag with the tag name "tr" had
-        been seen, then reprocess the current token.</p>
+    <p>Otherwise, act as if an end tag with the tag name "tr" had
+    been seen, then reprocess the current token.</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is one of: "body", "caption",
-       "col", "colgroup", "html", "td", "th"</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>An end tag whose tag name is one of: "body", "caption",
+   "col", "colgroup", "html", "td", "th"</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>Anything else</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> was
-        "<span title="insertion mode: in table">in table</span>".</p>
-       </dd>
+   <dt>Anything else</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> was
+    "<span title="insertion mode: in table">in table</span>".</p>
+   </dd>
 
-      </dl>
+  </dl>
 
-      <p>When the steps above require the UA to <dfn>clear the stack
-      back to a table row context</dfn>, it means that the UA must,
-      while the <span>current node</span> is not a <code>tr</code>
-      element or an <code>html</code> element, pop elements from the
-      <span>stack of open elements</span>. If this causes any elements
-      to be popped from the stack, then this is a <span>parse
-      error</span>.</p>
+  <p>When the steps above require the UA to <dfn>clear the stack
+  back to a table row context</dfn>, it means that the UA must,
+  while the <span>current node</span> is not a <code>tr</code>
+  element or an <code>html</code> element, pop elements from the
+  <span>stack of open elements</span>. If this causes any elements
+  to be popped from the stack, then this is a <span>parse
+  error</span>.</p>
 
-      <p class="note">The <span>current node</span> being an
-      <code>html</code> element after this process is a <span>fragment
-      case</span>.</p>
+  <p class="note">The <span>current node</span> being an
+  <code>html</code> element after this process is a <span>fragment
+  case</span>.</p>
 
 
-      <h6 id="parsing-main-intd">The <dfn title="insertion mode: in cell">in cell</dfn> insertion mode</h6>
+  <h6 id="parsing-main-intd">The <dfn title="insertion mode: in cell">in cell</dfn> insertion mode</h6>
 
-      <p>Handle the token as follows.</p>
+  <p>Handle the token as follows.</p>
 
-      <dl class="switch">
+  <dl class="switch">
 
-       <dt>An end tag whose tag name is one of: "td", "th"</dt>
-       <dd>
+   <dt>An end tag whose tag name is one of: "td", "th"</dt>
+   <dd>
 
-        <p>If the <span>stack of open elements</span> does not <span
-        title="has an element in table scope">have an element in table
-        scope</span> with the same tag name as that of the token, then
-        this is a <span>parse error</span> and the token must be
-        ignored.</p>
+    <p>If the <span>stack of open elements</span> does not <span
+    title="has an element in table scope">have an element in table
+    scope</span> with the same tag name as that of the token, then
+    this is a <span>parse error</span> and the token must be
+    ignored.</p>
 
-        <p>Otherwise:</p>
+    <p>Otherwise:</p>
 
-        <p><span>Generate implied end tags</span>, except for elements
-        with the same tag name as the token.</p>
+    <p><span>Generate implied end tags</span>, except for elements
+    with the same tag name as the token.</p>
 
-        <p>Now, if the <span>current node</span> is not an element
-        with the same tag name as the token, then this is a
-        <span>parse error</span>.</p>
+    <p>Now, if the <span>current node</span> is not an element
+    with the same tag name as the token, then this is a
+    <span>parse error</span>.</p>
 
-        <p>Pop elements from this stack until an element with the same
-        tag name as the token has been popped from the stack.</p>
+    <p>Pop elements from this stack until an element with the same
+    tag name as the token has been popped from the stack.</p>
 
-        <p><span>Clear the list of active formatting elements up to
-        the last marker</span>.</p>
+    <p><span>Clear the list of active formatting elements up to
+    the last marker</span>.</p>
 
-        <p>Switch the <span>insertion mode</span> to "<span
-        title="insertion mode: in row">in row</span>". (The
-        <span>current node</span> will be a <code>tr</code> element at
-        this point.)</p>
+    <p>Switch the <span>insertion mode</span> to "<span
+    title="insertion mode: in row">in row</span>". (The
+    <span>current node</span> will be a <code>tr</code> element at
+    this point.)</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is one of: "caption", "col",
-       "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr"</dt>
-       <dd>
+   <dt>A start tag whose tag name is one of: "caption", "col",
+   "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr"</dt>
+   <dd>
 
-        <p>If the <span>stack of open elements</span> does
-        <em>not</em> <span title="has an element in table scope">have
-        a <code>td</code> or <code>th</code> element in table
-        scope</span>, then this is a <span>parse error</span>; ignore
-        the token. (<span>fragment case</span>)</p>
+    <p>If the <span>stack of open elements</span> does
+    <em>not</em> <span title="has an element in table scope">have
+    a <code>td</code> or <code>th</code> element in table
+    scope</span>, then this is a <span>parse error</span>; ignore
+    the token. (<span>fragment case</span>)</p>
 
-        <p>Otherwise, <span>close the cell</span> (see below) and
-        reprocess the current token.</p>
+    <p>Otherwise, <span>close the cell</span> (see below) and
+    reprocess the current token.</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is one of: "body", "caption",
-       "col", "colgroup", "html"</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>An end tag whose tag name is one of: "body", "caption",
+   "col", "colgroup", "html"</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>An end tag whose tag name is one of: "table", "tbody",
-       "tfoot", "thead", "tr"</dt>
-       <dd>
+   <dt>An end tag whose tag name is one of: "table", "tbody",
+   "tfoot", "thead", "tr"</dt>
+   <dd>
 
-        <p>If the <span>stack of open elements</span> does not <span
-        title="has an element in table scope">have an element in table
-        scope</span> with the same tag name as that of the token
-        (which can only happen for "tbody", "tfoot" and "thead", or,
-        in the <span>fragment case</span>), then this is a <span>parse
-        error</span> and the token must be ignored.</p>
+    <p>If the <span>stack of open elements</span> does not <span
+    title="has an element in table scope">have an element in table
+    scope</span> with the same tag name as that of the token
+    (which can only happen for "tbody", "tfoot" and "thead", or,
+    in the <span>fragment case</span>), then this is a <span>parse
+    error</span> and the token must be ignored.</p>
 
-        <p>Otherwise, <span>close the cell</span> (see below) and
-        reprocess the current token.</p>
+    <p>Otherwise, <span>close the cell</span> (see below) and
+    reprocess the current token.</p>
 
-       </dd>
+   </dd>
 
-       <dt>Anything else</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> was
-        "<span title="insertion mode: in body">in body</span>".</p>
-       </dd>
+   <dt>Anything else</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> was
+    "<span title="insertion mode: in body">in body</span>".</p>
+   </dd>
 
-      </dl>
+  </dl>
 
-      <p>Where the steps above say to <dfn>close the cell</dfn>, they
-      mean to run the following algorithm:</p>
+  <p>Where the steps above say to <dfn>close the cell</dfn>, they
+  mean to run the following algorithm:</p>
 
-      <ol>
+  <ol>
 
-       <li><p>If the <span>stack of open elements</span> <span
-       title="has an element in table scope">has a <code>td</code>
-       element in table scope</span>, then act as if an end tag token
-       with the tag name "td" had been seen.</p></li>
+   <li><p>If the <span>stack of open elements</span> <span
+   title="has an element in table scope">has a <code>td</code>
+   element in table scope</span>, then act as if an end tag token
+   with the tag name "td" had been seen.</p></li>
 
-       <li><p>Otherwise, the <span>stack of open elements</span> will
-       <span title="has an element in table scope">have a
-       <code>th</code> element in table scope</span>; act as if an end
-       tag token with the tag name "th" had been seen.</p></li>
+   <li><p>Otherwise, the <span>stack of open elements</span> will
+   <span title="has an element in table scope">have a
+   <code>th</code> element in table scope</span>; act as if an end
+   tag token with the tag name "th" had been seen.</p></li>
 
-      </ol>
+  </ol>
 
-      <p class="note">The <span>stack of open elements</span> cannot
-      have both a <code>td</code> and a <code>th</code> element <span
-      title="has an element in table scope">in table scope</span> at
-      the same time, nor can it have neither when the <span>insertion
-      mode</span> is "<span title="insertion mode: in cell">in
-      cell</span>".</p>
+  <p class="note">The <span>stack of open elements</span> cannot
+  have both a <code>td</code> and a <code>th</code> element <span
+  title="has an element in table scope">in table scope</span> at
+  the same time, nor can it have neither when the <span>insertion
+  mode</span> is "<span title="insertion mode: in cell">in
+  cell</span>".</p>
 
 
-      <h6 id="parsing-main-inselect">The <dfn title="insertion mode: in select">in select</dfn> insertion mode</h6>
+  <h6 id="parsing-main-inselect">The <dfn title="insertion mode: in select">in select</dfn> insertion mode</h6>
 
-      <p>Handle the token as follows:</p>
+  <p>Handle the token as follows:</p>
 
-      <dl class="switch">
+  <dl class="switch">
 
-       <dt>An end-of-file token</dt>
-       <dd>
-        <p><span>Stop parsing, with prejudice.</span></p>
-       </dd>
+   <dt>An end-of-file token</dt>
+   <dd>
+    <p><span>Stop parsing, with prejudice.</span></p>
+   </dd>
 
-       <dt>A character token</dt>
-       <dd>
-        <p><span title="append a character">Append the token's
-        character</span> to the <span>current node</span>.</p>
-       </dd>
+   <dt>A character token</dt>
+   <dd>
+    <p><span title="append a character">Append the token's
+    character</span> to the <span>current node</span>.</p>
+   </dd>
 
-       <dt>A comment token</dt>
-       <dd>
-        <p>Append a <code>Comment</code> node to the <span>current
-        node</span> with the <code title="">data</code> attribute set to
-        the data given in the comment token.</p>
-       </dd>
+   <dt>A comment token</dt>
+   <dd>
+    <p>Append a <code>Comment</code> node to the <span>current
+    node</span> with the <code title="">data</code> attribute set to
+    the data given in the comment token.</p>
+   </dd>
 
-       <dt>A DOCTYPE token</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>A DOCTYPE token</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "html"</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in body">in
-        body</span>".</p>
-       </dd>
+   <dt>A start tag whose tag name is "html"</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in body">in
+    body</span>".</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "option"</dt>
-       <dd>
+   <dt>A start tag whose tag name is "option"</dt>
+   <dd>
 
-        <p>If the <span>current node</span> is an <code>option</code>
-        element, act as if an end tag with the tag name "option" had
-        been seen.</p>
+    <p>If the <span>current node</span> is an <code>option</code>
+    element, act as if an end tag with the tag name "option" had
+    been seen.</p>
 
-        <p><span>Insert an HTML element</span> for the token.</p>
+    <p><span>Insert an HTML element</span> for the token.</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is "optgroup"</dt>
-       <dd>
+   <dt>A start tag whose tag name is "optgroup"</dt>
+   <dd>
 
-        <p>If the <span>current node</span> is an <code>option</code>
-        element, act as if an end tag with the tag name "option" had
-        been seen.</p>
+    <p>If the <span>current node</span> is an <code>option</code>
+    element, act as if an end tag with the tag name "option" had
+    been seen.</p>
 
-        <p>If the <span>current node</span> is an
-        <code>optgroup</code> element, act as if an end tag with the
-        tag name "optgroup" had been seen.</p>
+    <p>If the <span>current node</span> is an
+    <code>optgroup</code> element, act as if an end tag with the
+    tag name "optgroup" had been seen.</p>
 
-        <p><span>Insert an HTML element</span> for the token.</p>
+    <p><span>Insert an HTML element</span> for the token.</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is "optgroup"</dt>
-       <dd>
+   <dt>An end tag whose tag name is "optgroup"</dt>
+   <dd>
 
-        <p>First, if the <span>current node</span> is an
-        <code>option</code> element, and the node immediately before
-        it in the <span>stack of open elements</span> is an
-        <code>optgroup</code> element, then act as if an end tag with
-        the tag name "option" had been seen.</p>
+    <p>First, if the <span>current node</span> is an
+    <code>option</code> element, and the node immediately before
+    it in the <span>stack of open elements</span> is an
+    <code>optgroup</code> element, then act as if an end tag with
+    the tag name "option" had been seen.</p>
 
-        <p>If the <span>current node</span> is an
-        <code>optgroup</code> element, then pop that node from the
-        <span>stack of open elements</span>. Otherwise, this is a
-        <span>parse error</span>, ignore the token.</p>
+    <p>If the <span>current node</span> is an
+    <code>optgroup</code> element, then pop that node from the
+    <span>stack of open elements</span>. Otherwise, this is a
+    <span>parse error</span>, ignore the token.</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is "option"</dt>
-       <dd>
+   <dt>An end tag whose tag name is "option"</dt>
+   <dd>
 
-        <p>If the <span>current node</span> is an <code>option</code>
-        element, then pop that node from the <span>stack of open
-        elements</span>. Otherwise, this is a <span>parse
-        error</span>, ignore the token.</p>
+    <p>If the <span>current node</span> is an <code>option</code>
+    element, then pop that node from the <span>stack of open
+    elements</span>. Otherwise, this is a <span>parse
+    error</span>, ignore the token.</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is "select"</dt>
-       <dd>
+   <dt>An end tag whose tag name is "select"</dt>
+   <dd>
 
-        <p>If the <span>stack of open elements</span> does not <span
-        title="has an element in table scope">have an element in table
-        scope</span> with the same tag name as the token, this is a
-        <span>parse error</span>. Ignore the token. (<span>fragment
-        case</span>)</p>
+    <p>If the <span>stack of open elements</span> does not <span
+    title="has an element in table scope">have an element in table
+    scope</span> with the same tag name as the token, this is a
+    <span>parse error</span>. Ignore the token. (<span>fragment
+    case</span>)</p>
 
-        <p>Otherwise:</p>
+    <p>Otherwise:</p>
 
-        <p>Pop elements from the <span>stack of open elements</span>
-        until a <code>select</code> element has been popped from the
-        stack.</p>
+    <p>Pop elements from the <span>stack of open elements</span>
+    until a <code>select</code> element has been popped from the
+    stack.</p>
 
-        <p><span>Reset the insertion mode appropriately</span>.</p>
+    <p><span>Reset the insertion mode appropriately</span>.</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is "select"</dt>
-       <dd>
+   <dt>A start tag whose tag name is "select"</dt>
+   <dd>
 
-        <p><span>Parse error</span>. Act as if the token had been
-        an end tag with the tag name "select" instead.</p>
+    <p><span>Parse error</span>. Act as if the token had been
+    an end tag with the tag name "select" instead.</p>
 
-       </dd>
+   </dd>
 
-       <dt>An end tag whose tag name is one of: "caption", "table",
-       "tbody", "tfoot", "thead", "tr", "td", "th"</dt>
-       <dd>
+   <dt>An end tag whose tag name is one of: "caption", "table",
+   "tbody", "tfoot", "thead", "tr", "td", "th"</dt>
+   <dd>
 
-        <p><span>Parse error</span>.</p>
+    <p><span>Parse error</span>.</p>
 
-        <p>If the <span>stack of open elements</span> <span>has an
-        element in table scope</span> 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.</p>
+    <p>If the <span>stack of open elements</span> <span>has an
+    element in table scope</span> 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.</p>
 
-       </dd>
+   </dd>
 
-       <dt>Anything else</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>Anything else</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-      </dl>
+  </dl>
 
 
-      <h6 id="parsing-main-afterbody">The <dfn title="insertion mode: after body">after body</dfn> insertion mode</h6>
+  <h6 id="parsing-main-afterbody">The <dfn title="insertion mode: after body">after body</dfn> insertion mode</h6>
 
-      <p>Handle the token as follows:</p>
+  <p>Handle the token as follows:</p>
 
-      <dl class="switch">
+  <dl class="switch">
 
-       <dt>An end-of-file token</dt>
-       <dd>
-        <p><span>Stop parsing, with prejudice.</span></p>
-       </dd>
+   <dt>An end-of-file token</dt>
+   <dd>
+    <p><span>Stop parsing, with prejudice.</span></p>
+   </dd>
 
-       <dt>A character token that is one of one of U+0009
-       CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
-       TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
-       or U+0020 SPACE</dt>
-       <dd>
-        <p>Process the token as it would be processed if the
-        <span>insertion mode</span> was "<span title="insertion mode:
-        in body">in body</span>".</p>
-       </dd>
+   <dt>A character token that is one of one of U+0009
+   CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+   TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+   or U+0020 SPACE</dt>
+   <dd>
+    <p>Process the token as it would be processed if the
+    <span>insertion mode</span> was "<span title="insertion mode:
+    in body">in body</span>".</p>
+   </dd>
 
-       <dt>A comment token</dt>
-       <dd>
-        <p>Append a <code>Comment</code> node to the first element in
-        the <span>stack of open elements</span> (the <code>html</code>
-        element), with the <code title="">data</code> attribute set to
-        the data given in the comment token.</p>
-       </dd>
+   <dt>A comment token</dt>
+   <dd>
+    <p>Append a <code>Comment</code> node to the first element in
+    the <span>stack of open elements</span> (the <code>html</code>
+    element), with the <code title="">data</code> attribute set to
+    the data given in the comment token.</p>
+   </dd>
 
-       <dt>A DOCTYPE token</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>A DOCTYPE token</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "html"</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in body">in
-        body</span>".</p>
-       </dd>
+   <dt>A start tag whose tag name is "html"</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in body">in
+    body</span>".</p>
+   </dd>
 
-       <dt>An end tag whose tag name is "html"</dt>
-       <dd>
+   <dt>An end tag whose tag name is "html"</dt>
+   <dd>
 
-        <p>If the parser was originally created as part of the
-        <span>HTML fragment parsing algorithm</span>, this is a
-        <span>parse error</span>; ignore the token. (The element will
-        be an <code>html</code> element in this case.)
-        (<span>fragment case</span>)</p>
+    <p>If the parser was originally created as part of the
+    <span>HTML fragment parsing algorithm</span>, this is a
+    <span>parse error</span>; ignore the token. (The element will
+    be an <code>html</code> element in this case.)
+    (<span>fragment case</span>)</p>
 
-        <p>Otherwise, switch to <span>the trailing end
-        phase</span>.</p>
+    <p>Otherwise, switch to <span>the trailing end
+    phase</span>.</p>
 
-       </dd>
+   </dd>
 
-       <dt>Anything else</dt>
-       <dd>
+   <dt>Anything else</dt>
+   <dd>
 
-        <p><span>Parse error</span>. Set the <span>insertion
-        mode</span> to "<span title="insertion mode: in body">in
-        body</span>" and reprocess the token.</p>
+    <p><span>Parse error</span>. Set the <span>insertion
+    mode</span> to "<span title="insertion mode: in body">in
+    body</span>" and reprocess the token.</p>
 
-       </dd>
+   </dd>
 
-      </dl>
+  </dl>
 
 
-      <h6 id="parsing-main-inframeset">The <dfn title="insertion mode: in frameset">in frameset</dfn> insertion mode</h6>
+  <h6 id="parsing-main-inframeset">The <dfn title="insertion mode: in frameset">in frameset</dfn> insertion mode</h6>
 
-      <p>Handle the token as follows:</p>
+  <p>Handle the token as follows:</p>
 
-      <dl class="switch">
+  <dl class="switch">
 
-       <dt>An end-of-file token</dt>
-       <dd>
-        <p><span>Stop parsing, with prejudice.</span></p>
-       </dd>
+   <dt>An end-of-file token</dt>
+   <dd>
+    <p><span>Stop parsing, with prejudice.</span></p>
+   </dd>
 
-       <dt>A character token that is one of one of U+0009
-       CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
-       TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
-       or U+0020 SPACE</dt>
-       <dd>
-        <p><span title="append a character">Append the character</span> to
-        the <span>current node</span>.</p>
-       </dd>
+   <dt>A character token that is one of one of U+0009
+   CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+   TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+   or U+0020 SPACE</dt>
+   <dd>
+    <p><span title="append a character">Append the character</span> to
+    the <span>current node</span>.</p>
+   </dd>
 
-       <dt>A comment token</dt>
-       <dd>
-        <p>Append a <code>Comment</code> node to the <span>current
-        node</span> with the <code title="">data</code> attribute set to
-        the data given in the comment token.</p>
-       </dd>
+   <dt>A comment token</dt>
+   <dd>
+    <p>Append a <code>Comment</code> node to the <span>current
+    node</span> with the <code title="">data</code> attribute set to
+    the data given in the comment token.</p>
+   </dd>
 
-       <dt>A DOCTYPE token</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>A DOCTYPE token</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "html"</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in body">in
-        body</span>".</p>
-       </dd>
+   <dt>A start tag whose tag name is "html"</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in body">in
+    body</span>".</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "frameset"</dt>
-       <dd>
-        <p><span title="Insert an HTML element">Insert a
-        <code>frameset</code> element</span> for the token.</p>
-       </dd>
+   <dt>A start tag whose tag name is "frameset"</dt>
+   <dd>
+    <p><span title="Insert an HTML element">Insert a
+    <code>frameset</code> element</span> for the token.</p>
+   </dd>
 
-       <dt>An end tag whose tag name is "frameset"</dt>
-       <dd>
+   <dt>An end tag whose tag name is "frameset"</dt>
+   <dd>
 
-        <p>If the <span>current node</span> is the root
-        <code>html</code> element, then this is a <span>parse
-        error</span>; ignore the token. (<span>fragment
-        case</span>)</p>
+    <p>If the <span>current node</span> is the root
+    <code>html</code> element, then this is a <span>parse
+    error</span>; ignore the token. (<span>fragment
+    case</span>)</p>
 
-        <p>Otherwise, pop the <span>current node</span> from the
-        <span>stack of open elements</span>.</p>
+    <p>Otherwise, pop the <span>current node</span> from the
+    <span>stack of open elements</span>.</p>
 
-        <p>If the parser was <em>not</em> originally created as part
-        of the <span>HTML fragment parsing algorithm</span>
-        (<span>fragment case</span>), and the <span>current
-        node</span> is no longer a <code>frameset</code> element, then
-        change the <span>insertion mode</span> to "<span
-        title="insertion mode: after frameset">after
-        frameset</span>".</p>
+    <p>If the parser was <em>not</em> originally created as part
+    of the <span>HTML fragment parsing algorithm</span>
+    (<span>fragment case</span>), and the <span>current
+    node</span> is no longer a <code>frameset</code> element, then
+    change the <span>insertion mode</span> to "<span
+    title="insertion mode: after frameset">after
+    frameset</span>".</p>
 
-       </dd>
+   </dd>
 
-       <dt>A start tag whose tag name is "frame"</dt>
-       <dd>
-        <p><span>Insert an HTML element</span> for the token.
-        Immediately pop the <span>current node</span> off the
-        <span>stack of open elements</span>.</p>
-       </dd>
+   <dt>A start tag whose tag name is "frame"</dt>
+   <dd>
+    <p><span>Insert an HTML element</span> for the token.
+    Immediately pop the <span>current node</span> off the
+    <span>stack of open elements</span>.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "noframes"</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in body">in body</span>".</p>
-       </dd>
+   <dt>A start tag whose tag name is "noframes"</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in body">in body</span>".</p>
+   </dd>
 
-       <dt>Anything else</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>Anything else</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-      </dl>
+  </dl>
 
 
-      <h6 id="parsing-main-afterframeset">The <dfn title="insertion mode: after frameset">after frameset</dfn> insertion mode</h6>
+  <h6 id="parsing-main-afterframeset">The <dfn title="insertion mode: after frameset">after frameset</dfn> insertion mode</h6>
 
-      <p>Handle the token as follows:</p>
+  <p>Handle the token as follows:</p>
 
-      <dl class="switch">
+  <dl class="switch">
 
-       <dt>An end-of-file token</dt>
-       <dd>
-        <p><span>Stop parsing, with prejudice.</span></p>
-       </dd>
+   <dt>An end-of-file token</dt>
+   <dd>
+    <p><span>Stop parsing, with prejudice.</span></p>
+   </dd>
 
-       <dt>A character token that is one of one of U+0009
-       CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
-       TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
-       or U+0020 SPACE</dt>
-       <dd>
-        <p><span title="append a character">Append the character</span> to
-        the <span>current node</span>.</p>
-       </dd>
+   <dt>A character token that is one of one of U+0009
+   CHARACTER TABULATION, U+000A LINE FEED (LF), U+000B LINE
+   TABULATION, U+000C FORM FEED (FF), <!--U+000D CARRIAGE RETURN (CR),-->
+   or U+0020 SPACE</dt>
+   <dd>
+    <p><span title="append a character">Append the character</span> to
+    the <span>current node</span>.</p>
+   </dd>
 
-       <dt>A comment token</dt>
-       <dd>
-        <p>Append a <code>Comment</code> node to the <span>current
-        node</span> with the <code title="">data</code> attribute set to
-        the data given in the comment token.</p>
-       </dd>
+   <dt>A comment token</dt>
+   <dd>
+    <p>Append a <code>Comment</code> node to the <span>current
+    node</span> with the <code title="">data</code> attribute set to
+    the data given in the comment token.</p>
+   </dd>
 
-       <dt>A DOCTYPE token</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>A DOCTYPE token</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "html"</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in body">in
-        body</span>".</p>
-       </dd>
+   <dt>A start tag whose tag name is "html"</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in body">in
+    body</span>".</p>
+   </dd>
 
-       <dt>An end tag whose tag name is "html"</dt>
-       <dd>
-        <p>Switch to <span>the trailing end phase</span>.</p>
-       </dd>
+   <dt>An end tag whose tag name is "html"</dt>
+   <dd>
+    <p>Switch to <span>the trailing end phase</span>.</p>
+   </dd>
 
-       <dt>A start tag whose tag name is "noframes"</dt>
-       <dd>
-        <p>Process the token as if the <span>insertion mode</span> had
-        been "<span title="insertion mode: in body">in body</span>".</p>
-       </dd>
+   <dt>A start tag whose tag name is "noframes"</dt>
+   <dd>
+    <p>Process the token as if the <span>insertion mode</span> had
+    been "<span title="insertion mode: in body">in body</span>".</p>
+   </dd>
 
-       <dt>Anything else</dt>
-       <dd>
-        <p><span>Parse error</span>. Ignore the token.</p>
-       </dd>
+   <dt>Anything else</dt>
+   <dd>
+    <p><span>Parse error</span>. Ignore the token.</p>
+   </dd>
 
-      </dl>
+  </dl>
 
   <p class="big-issue">This doesn't handle UAs that don't support
   frames, or that do support frames but want to show the NOFRAMES




More information about the Commit-Watchers mailing list