lib/htmlpurifier/library/HTMLPurifier/Lexer/PH5P.php

   1 <?php
   2
   3 /**
   4  * Experimental HTML5-based parser using Jeroen van der Meer's PH5P library.
   5  * Occupies space in the HTML5 pseudo-namespace, which may cause conflicts.
   6  *
   7  * @note
   8  *    Recent changes to PHP's DOM extension have resulted in some fatal
   9  *    error conditions with the original version of PH5P. Pending changes,
  10  *    this lexer will punt to DirectLex if DOM throughs an exception.
  11  */
  12
  13 class HTMLPurifier_Lexer_PH5P extends HTMLPurifier_Lexer_DOMLex {
  14
  15     public function tokenizeHTML($html, $config, $context) {
  16         $new_html = $this->normalize($html, $config, $context);
  17         $new_html = $this->wrapHTML($new_html, $config, $context);
  18         try {
  19             $parser = new HTML5($new_html);
  20             $doc = $parser->save();
  21         } catch (DOMException $e) {
  22             // Uh oh, it failed. Punt to DirectLex.
  23             $lexer = new HTMLPurifier_Lexer_DirectLex();
  24             $context->register('PH5PError', $e); // save the error, so we can detect it
  25             return $lexer->tokenizeHTML($html, $config, $context); // use original HTML
  26         }
  27         $tokens = array();
  28         $this->tokenizeDOM(
  29             $doc->getElementsByTagName('html')->item(0)-> // <html>
  30                   getElementsByTagName('body')->item(0)-> //   <body>
  31                   getElementsByTagName('div')->item(0)    //     <div>
  32             , $tokens);
  33         return $tokens;
  34     }
  35
  36 }
  37
  38 /*
  39
  40 Copyright 2007 Jeroen van der Meer <http://jero.net/>
  41
  42 Permission is hereby granted, free of charge, to any person obtaining a
  43 copy of this software and associated documentation files (the
  44 "Software"), to deal in the Software without restriction, including
  45 without limitation the rights to use, copy, modify, merge, publish,
  46 distribute, sublicense, and/or sell copies of the Software, and to
  47 permit persons to whom the Software is furnished to do so, subject to
  48 the following conditions:
  49
  50 The above copyright notice and this permission notice shall be included
  51 in all copies or substantial portions of the Software.
  52
  53 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  54 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  55 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  56 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  57 CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  58 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  59 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  60
  61 */
  62
  63 class HTML5 {
  64     private $data;
  65     private $char;
  66     private $EOF;
  67     private $state;
  68     private $tree;
  69     private $token;
  70     private $content_model;
  71     private $escape = false;
  72     private $entities = array('AElig;','AElig','AMP;','AMP','Aacute;','Aacute',
  73     'Acirc;','Acirc','Agrave;','Agrave','Alpha;','Aring;','Aring','Atilde;',
  74     'Atilde','Auml;','Auml','Beta;','COPY;','COPY','Ccedil;','Ccedil','Chi;',
  75     'Dagger;','Delta;','ETH;','ETH','Eacute;','Eacute','Ecirc;','Ecirc','Egrave;',
  76     'Egrave','Epsilon;','Eta;','Euml;','Euml','GT;','GT','Gamma;','Iacute;',
  77     'Iacute','Icirc;','Icirc','Igrave;','Igrave','Iota;','Iuml;','Iuml','Kappa;',
  78     'LT;','LT','Lambda;','Mu;','Ntilde;','Ntilde','Nu;','OElig;','Oacute;',
  79     'Oacute','Ocirc;','Ocirc','Ograve;','Ograve','Omega;','Omicron;','Oslash;',
  80     'Oslash','Otilde;','Otilde','Ouml;','Ouml','Phi;','Pi;','Prime;','Psi;',
  81     'QUOT;','QUOT','REG;','REG','Rho;','Scaron;','Sigma;','THORN;','THORN',
  82     'TRADE;','Tau;','Theta;','Uacute;','Uacute','Ucirc;','Ucirc','Ugrave;',
  83     'Ugrave','Upsilon;','Uuml;','Uuml','Xi;','Yacute;','Yacute','Yuml;','Zeta;',
  84     'aacute;','aacute','acirc;','acirc','acute;','acute','aelig;','aelig',
  85     'agrave;','agrave','alefsym;','alpha;','amp;','amp','and;','ang;','apos;',
  86     'aring;','aring','asymp;','atilde;','atilde','auml;','auml','bdquo;','beta;',
  87     'brvbar;','brvbar','bull;','cap;','ccedil;','ccedil','cedil;','cedil',
  88     'cent;','cent','chi;','circ;','clubs;','cong;','copy;','copy','crarr;',
  89     'cup;','curren;','curren','dArr;','dagger;','darr;','deg;','deg','delta;',
  90     'diams;','divide;','divide','eacute;','eacute','ecirc;','ecirc','egrave;',
  91     'egrave','empty;','emsp;','ensp;','epsilon;','equiv;','eta;','eth;','eth',
  92     'euml;','euml','euro;','exist;','fnof;','forall;','frac12;','frac12',
  93     'frac14;','frac14','frac34;','frac34','frasl;','gamma;','ge;','gt;','gt',
  94     'hArr;','harr;','hearts;','hellip;','iacute;','iacute','icirc;','icirc',
  95     'iexcl;','iexcl','igrave;','igrave','image;','infin;','int;','iota;',
  96     'iquest;','iquest','isin;','iuml;','iuml','kappa;','lArr;','lambda;','lang;',
  97     'laquo;','laquo','larr;','lceil;','ldquo;','le;','lfloor;','lowast;','loz;',
  98     'lrm;','lsaquo;','lsquo;','lt;','lt','macr;','macr','mdash;','micro;','micro',
  99     'middot;','middot','minus;','mu;','nabla;','nbsp;','nbsp','ndash;','ne;',
 100     'ni;','not;','not','notin;','nsub;','ntilde;','ntilde','nu;','oacute;',
 101     'oacute','ocirc;','ocirc','oelig;','ograve;','ograve','oline;','omega;',
 102     'omicron;','oplus;','or;','ordf;','ordf','ordm;','ordm','oslash;','oslash',
 103     'otilde;','otilde','otimes;','ouml;','ouml','para;','para','part;','permil;',
 104     'perp;','phi;','pi;','piv;','plusmn;','plusmn','pound;','pound','prime;',
 105     'prod;','prop;','psi;','quot;','quot','rArr;','radic;','rang;','raquo;',
 106     'raquo','rarr;','rceil;','rdquo;','real;','reg;','reg','rfloor;','rho;',
 107     'rlm;','rsaquo;','rsquo;','sbquo;','scaron;','sdot;','sect;','sect','shy;',
 108     'shy','sigma;','sigmaf;','sim;','spades;','sub;','sube;','sum;','sup1;',
 109     'sup1','sup2;','sup2','sup3;','sup3','sup;','supe;','szlig;','szlig','tau;',
 110     'there4;','theta;','thetasym;','thinsp;','thorn;','thorn','tilde;','times;',
 111     'times','trade;','uArr;','uacute;','uacute','uarr;','ucirc;','ucirc',
 112     'ugrave;','ugrave','uml;','uml','upsih;','upsilon;','uuml;','uuml','weierp;',
 113     'xi;','yacute;','yacute','yen;','yen','yuml;','yuml','zeta;','zwj;','zwnj;');
 114
 115     const PCDATA    = 0;
 116     const RCDATA    = 1;
 117     const CDATA     = 2;
 118     const PLAINTEXT = 3;
 119
 120     const DOCTYPE  = 0;
 121     const STARTTAG = 1;
 122     const ENDTAG   = 2;
 123     const COMMENT  = 3;
 124     const CHARACTR = 4;
 125     const EOF      = 5;
 126
 127     public function __construct($data) {
 128         $data = str_replace("\r\n", "\n", $data);
 129         $data = str_replace("\r", null, $data);
 130
 131         $this->data = $data;
 132         $this->char = -1;
 133         $this->EOF  = strlen($data);
 134         $this->tree = new HTML5TreeConstructer;
 135         $this->content_model = self::PCDATA;
 136
 137         $this->state = 'data';
 138
 139         while($this->state !== null) {
 140             $this->{$this->state.'State'}();
 141         }
 142     }
 143
 144     public function save() {
 145         return $this->tree->save();
 146     }
 147
 148     private function char() {
 149         return ($this->char < $this->EOF)
 150             ? $this->data[$this->char]
 151             : false;
 152     }
 153
 154     private function character($s, $l = 0) {
 155         if($s + $l < $this->EOF) {
 156             if($l === 0) {
 157                 return $this->data[$s];
 158             } else {
 159                 return substr($this->data, $s, $l);
 160             }
 161         }
 162     }
 163
 164     private function characters($char_class, $start) {
 165         return preg_replace('#^(['.$char_class.']+).*#s', '\\1', substr($this->data, $start));
 166     }
 167
 168     private function dataState() {
 169         // Consume the next input character
 170         $this->char++;
 171         $char = $this->char();
 172
 173         if($char === '&' && ($this->content_model === self::PCDATA || $this->content_model === self::RCDATA)) {
 174             /* U+0026 AMPERSAND (&)
 175             When the content model flag is set to one of the PCDATA or RCDATA
 176             states: switch to the entity data state. Otherwise: treat it as per
 177             the "anything else"    entry below. */
 178             $this->state = 'entityData';
 179
 180         } elseif($char === '-') {
 181             /* If the content model flag is set to either the RCDATA state or
 182             the CDATA state, and the escape flag is false, and there are at
 183             least three characters before this one in the input stream, and the
 184             last four characters in the input stream, including this one, are
 185             U+003C LESS-THAN SIGN, U+0021 EXCLAMATION MARK, U+002D HYPHEN-MINUS,
 186             and U+002D HYPHEN-MINUS ("<!--"), then set the escape flag to true. */
 187             if(($this->content_model === self::RCDATA || $this->content_model ===
 188             self::CDATA) && $this->escape === false &&
 189             $this->char >= 3 && $this->character($this->char - 4, 4) === '<!--') {
 190                 $this->escape = true;
 191             }
 192
 193             /* In any case, emit the input character as a character token. Stay
 194             in the data state. */
 195             $this->emitToken(array(
 196                 'type' => self::CHARACTR,
 197                 'data' => $char
 198             ));
 199
 200         /* U+003C LESS-THAN SIGN (<) */
 201         } elseif($char === '<' && ($this->content_model === self::PCDATA ||
 202         (($this->content_model === self::RCDATA ||
 203         $this->content_model === self::CDATA) && $this->escape === false))) {
 204             /* When the content model flag is set to the PCDATA state: switch
 205             to the tag open state.
 206
 207             When the content model flag is set to either the RCDATA state or
 208             the CDATA state and the escape flag is false: switch to the tag
 209             open state.
 210
 211             Otherwise: treat it as per the "anything else" entry below. */
 212             $this->state = 'tagOpen';
 213
 214         /* U+003E GREATER-THAN SIGN (>) */
 215         } elseif($char === '>') {
 216             /* If the content model flag is set to either the RCDATA state or
 217             the CDATA state, and the escape flag is true, and the last three
 218             characters in the input stream including this one are U+002D
 219             HYPHEN-MINUS, U+002D HYPHEN-MINUS, U+003E GREATER-THAN SIGN ("-->"),
 220             set the escape flag to false. */
 221             if(($this->content_model === self::RCDATA ||
 222             $this->content_model === self::CDATA) && $this->escape === true &&
 223             $this->character($this->char, 3) === '-->') {
 224                 $this->escape = false;
 225             }
 226
 227             /* In any case, emit the input character as a character token.
 228             Stay in the data state. */
 229             $this->emitToken(array(
 230                 'type' => self::CHARACTR,
 231                 'data' => $char
 232             ));
 233
 234         } elseif($this->char === $this->EOF) {
 235             /* EOF
 236             Emit an end-of-file token. */
 237             $this->EOF();
 238
 239         } elseif($this->content_model === self::PLAINTEXT) {
 240             /* When the content model flag is set to the PLAINTEXT state
 241             THIS DIFFERS GREATLY FROM THE SPEC: Get the remaining characters of
 242             the text and emit it as a character token. */
 243             $this->emitToken(array(
 244                 'type' => self::CHARACTR,
 245                 'data' => substr($this->data, $this->char)
 246             ));
 247
 248             $this->EOF();
 249
 250         } else {
 251             /* Anything else
 252             THIS DIFFERS GREATLY FROM THE SPEC: Get as many character that
 253             otherwise would also be treated as a character token and emit it
 254             as a single character token. Stay in the data state. */
 255             $len  = strcspn($this->data, '<&', $this->char);
 256             $char = substr($this->data, $this->char, $len);
 257             $this->char += $len - 1;
 258
 259             $this->emitToken(array(
 260                 'type' => self::CHARACTR,
 261                 'data' => $char
 262             ));
 263
 264             $this->state = 'data';
 265         }
 266     }
 267
 268     private function entityDataState() {
 269         // Attempt to consume an entity.
 270         $entity = $this->entity();
 271
 272         // If nothing is returned, emit a U+0026 AMPERSAND character token.
 273         // Otherwise, emit the character token that was returned.
 274         $char = (!$entity) ? '&' : $entity;
 275         $this->emitToken(array(
 276             'type' => self::CHARACTR,
 277             'data' => $char
 278         ));
 279
 280         // Finally, switch to the data state.
 281         $this->state = 'data';
 282     }
 283
 284     private function tagOpenState() {
 285         switch($this->content_model) {
 286             case self::RCDATA:
 287             case self::CDATA:
 288                 /* If the next input character is a U+002F SOLIDUS (/) character,
 289                 consume it and switch to the close tag open state. If the next
 290                 input character is not a U+002F SOLIDUS (/) character, emit a
 291                 U+003C LESS-THAN SIGN character token and switch to the data
 292                 state to process the next input character. */
 293                 if($this->character($this->char + 1) === '/') {
 294                     $this->char++;
 295                     $this->state = 'closeTagOpen';
 296
 297                 } else {
 298                     $this->emitToken(array(
 299                         'type' => self::CHARACTR,
 300                         'data' => '<'
 301                     ));
 302
 303                     $this->state = 'data';
 304                 }
 305             break;
 306
 307             case self::PCDATA:
 308                 // If the content model flag is set to the PCDATA state
 309                 // Consume the next input character:
 310                 $this->char++;
 311                 $char = $this->char();
 312
 313                 if($char === '!') {
 314                     /* U+0021 EXCLAMATION MARK (!)
 315                     Switch to the markup declaration open state. */
 316                     $this->state = 'markupDeclarationOpen';
 317
 318                 } elseif($char === '/') {
 319                     /* U+002F SOLIDUS (/)
 320                     Switch to the close tag open state. */
 321                     $this->state = 'closeTagOpen';
 322
 323                 } elseif(preg_match('/^[A-Za-z]$/', $char)) {
 324                     /* U+0041 LATIN LETTER A through to U+005A LATIN LETTER Z
 325                     Create a new start tag token, set its tag name to the lowercase
 326                     version of the input character (add 0x0020 to the character's code
 327                     point), then switch to the tag name state. (Don't emit the token
 328                     yet; further details will be filled in before it is emitted.) */
 329                     $this->token = array(
 330                         'name'  => strtolower($char),
 331                         'type'  => self::STARTTAG,
 332                         'attr'  => array()
 333                     );
 334
 335                     $this->state = 'tagName';
 336
 337                 } elseif($char === '>') {
 338                     /* U+003E GREATER-THAN SIGN (>)
 339                     Parse error. Emit a U+003C LESS-THAN SIGN character token and a
 340                     U+003E GREATER-THAN SIGN character token. Switch to the data state. */
 341                     $this->emitToken(array(
 342                         'type' => self::CHARACTR,
 343                         'data' => '<>'
 344                     ));
 345
 346                     $this->state = 'data';
 347
 348                 } elseif($char === '?') {
 349                     /* U+003F QUESTION MARK (?)
 350                     Parse error. Switch to the bogus comment state. */
 351                     $this->state = 'bogusComment';
 352
 353                 } else {
 354                     /* Anything else
 355                     Parse error. Emit a U+003C LESS-THAN SIGN character token and
 356                     reconsume the current input character in the data state. */
 357                     $this->emitToken(array(
 358                         'type' => self::CHARACTR,
 359                         'data' => '<'
 360                     ));
 361
 362                     $this->char--;
 363                     $this->state = 'data';
 364                 }
 365             break;
 366         }
 367     }
 368
 369     private function closeTagOpenState() {
 370         $next_node = strtolower($this->characters('A-Za-z', $this->char + 1));
 371         $the_same = count($this->tree->stack) > 0 && $next_node === end($this->tree->stack)->nodeName;
 372
 373         if(($this->content_model === self::RCDATA || $this->content_model === self::CDATA) &&
 374         (!$the_same || ($the_same && (!preg_match('/[\t\n\x0b\x0c >\/]/',
 375         $this->character($this->char + 1 + strlen($next_node))) || $this->EOF === $this->char)))) {
 376             /* If the content model flag is set to the RCDATA or CDATA states then
 377             examine the next few characters. If they do not match the tag name of
 378             the last start tag token emitted (case insensitively), or if they do but
 379             they are not immediately followed by one of the following characters:
 380                 * U+0009 CHARACTER TABULATION
 381                 * U+000A LINE FEED (LF)
 382                 * U+000B LINE TABULATION
 383                 * U+000C FORM FEED (FF)
 384                 * U+0020 SPACE
 385                 * U+003E GREATER-THAN SIGN (>)
 386                 * U+002F SOLIDUS (/)
 387                 * EOF
 388             ...then there is a parse error. Emit a U+003C LESS-THAN SIGN character
 389             token, a U+002F SOLIDUS character token, and switch to the data state
 390             to process the next input character. */
 391             $this->emitToken(array(
 392                 'type' => self::CHARACTR,
 393                 'data' => '</'
 394             ));
 395
 396             $this->state = 'data';
 397
 398         } else {
 399             /* Otherwise, if the content model flag is set to the PCDATA state,
 400             or if the next few characters do match that tag name, consume the
 401             next input character: */
 402             $this->char++;
 403             $char = $this->char();
 404
 405             if(preg_match('/^[A-Za-z]$/', $char)) {
 406                 /* U+0041 LATIN LETTER A through to U+005A LATIN LETTER Z
 407                 Create a new end tag token, set its tag name to the lowercase version
 408                 of the input character (add 0x0020 to the character's code point), then
 409                 switch to the tag name state. (Don't emit the token yet; further details
 410                 will be filled in before it is emitted.) */
 411                 $this->token = array(
 412                     'name'  => strtolower($char),
 413                     'type'  => self::ENDTAG
 414                 );
 415
 416                 $this->state = 'tagName';
 417
 418             } elseif($char === '>') {
 419                 /* U+003E GREATER-THAN SIGN (>)
 420                 Parse error. Switch to the data state. */
 421                 $this->state = 'data';
 422
 423             } elseif($this->char === $this->EOF) {
 424                 /* EOF
 425                 Parse error. Emit a U+003C LESS-THAN SIGN character token and a U+002F
 426                 SOLIDUS character token. Reconsume the EOF character in the data state. */
 427                 $this->emitToken(array(
 428                     'type' => self::CHARACTR,
 429                     'data' => '</'
 430                 ));
 431
 432                 $this->char--;
 433                 $this->state = 'data';
 434
 435             } else {
 436                 /* Parse error. Switch to the bogus comment state. */
 437                 $this->state = 'bogusComment';
 438             }
 439         }
 440     }
 441
 442     private function tagNameState() {
 443         // Consume the next input character:
 444         $this->char++;
 445         $char = $this->character($this->char);
 446
 447         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
 448             /* U+0009 CHARACTER TABULATION
 449             U+000A LINE FEED (LF)
 450             U+000B LINE TABULATION
 451             U+000C FORM FEED (FF)
 452             U+0020 SPACE
 453             Switch to the before attribute name state. */
 454             $this->state = 'beforeAttributeName';
 455
 456         } elseif($char === '>') {
 457             /* U+003E GREATER-THAN SIGN (>)
 458             Emit the current tag token. Switch to the data state. */
 459             $this->emitToken($this->token);
 460             $this->state = 'data';
 461
 462         } elseif($this->char === $this->EOF) {
 463             /* EOF
 464             Parse error. Emit the current tag token. Reconsume the EOF
 465             character in the data state. */
 466             $this->emitToken($this->token);
 467
 468             $this->char--;
 469             $this->state = 'data';
 470
 471         } elseif($char === '/') {
 472             /* U+002F SOLIDUS (/)
 473             Parse error unless this is a permitted slash. Switch to the before
 474             attribute name state. */
 475             $this->state = 'beforeAttributeName';
 476
 477         } else {
 478             /* Anything else
 479             Append the current input character to the current tag token's tag name.
 480             Stay in the tag name state. */
 481             $this->token['name'] .= strtolower($char);
 482             $this->state = 'tagName';
 483         }
 484     }
 485
 486     private function beforeAttributeNameState() {
 487         // Consume the next input character:
 488         $this->char++;
 489         $char = $this->character($this->char);
 490
 491         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
 492             /* U+0009 CHARACTER TABULATION
 493             U+000A LINE FEED (LF)
 494             U+000B LINE TABULATION
 495             U+000C FORM FEED (FF)
 496             U+0020 SPACE
 497             Stay in the before attribute name state. */
 498             $this->state = 'beforeAttributeName';
 499
 500         } elseif($char === '>') {
 501             /* U+003E GREATER-THAN SIGN (>)
 502             Emit the current tag token. Switch to the data state. */
 503             $this->emitToken($this->token);
 504             $this->state = 'data';
 505
 506         } elseif($char === '/') {
 507             /* U+002F SOLIDUS (/)
 508             Parse error unless this is a permitted slash. Stay in the before
 509             attribute name state. */
 510             $this->state = 'beforeAttributeName';
 511
 512         } elseif($this->char === $this->EOF) {
 513             /* EOF
 514             Parse error. Emit the current tag token. Reconsume the EOF
 515             character in the data state. */
 516             $this->emitToken($this->token);
 517
 518             $this->char--;
 519             $this->state = 'data';
 520
 521         } else {
 522             /* Anything else
 523             Start a new attribute in the current tag token. Set that attribute's
 524             name to the current input character, and its value to the empty string.
 525             Switch to the attribute name state. */
 526             $this->token['attr'][] = array(
 527                 'name'  => strtolower($char),
 528                 'value' => null
 529             );
 530
 531             $this->state = 'attributeName';
 532         }
 533     }
 534
 535     private function attributeNameState() {
 536         // Consume the next input character:
 537         $this->char++;
 538         $char = $this->character($this->char);
 539
 540         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
 541             /* U+0009 CHARACTER TABULATION
 542             U+000A LINE FEED (LF)
 543             U+000B LINE TABULATION
 544             U+000C FORM FEED (FF)
 545             U+0020 SPACE
 546             Stay in the before attribute name state. */
 547             $this->state = 'afterAttributeName';
 548
 549         } elseif($char === '=') {
 550             /* U+003D EQUALS SIGN (=)
 551             Switch to the before attribute value state. */
 552             $this->state = 'beforeAttributeValue';
 553
 554         } elseif($char === '>') {
 555             /* U+003E GREATER-THAN SIGN (>)
 556             Emit the current tag token. Switch to the data state. */
 557             $this->emitToken($this->token);
 558             $this->state = 'data';
 559
 560         } elseif($char === '/' && $this->character($this->char + 1) !== '>') {
 561             /* U+002F SOLIDUS (/)
 562             Parse error unless this is a permitted slash. Switch to the before
 563             attribute name state. */
 564             $this->state = 'beforeAttributeName';
 565
 566         } elseif($this->char === $this->EOF) {
 567             /* EOF
 568             Parse error. Emit the current tag token. Reconsume the EOF
 569             character in the data state. */
 570             $this->emitToken($this->token);
 571
 572             $this->char--;
 573             $this->state = 'data';
 574
 575         } else {
 576             /* Anything else
 577             Append the current input character to the current attribute's name.
 578             Stay in the attribute name state. */
 579             $last = count($this->token['attr']) - 1;
 580             $this->token['attr'][$last]['name'] .= strtolower($char);
 581
 582             $this->state = 'attributeName';
 583         }
 584     }
 585
 586     private function afterAttributeNameState() {
 587         // Consume the next input character:
 588         $this->char++;
 589         $char = $this->character($this->char);
 590
 591         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
 592             /* U+0009 CHARACTER TABULATION
 593             U+000A LINE FEED (LF)
 594             U+000B LINE TABULATION
 595             U+000C FORM FEED (FF)
 596             U+0020 SPACE
 597             Stay in the after attribute name state. */
 598             $this->state = 'afterAttributeName';
 599
 600         } elseif($char === '=') {
 601             /* U+003D EQUALS SIGN (=)
 602             Switch to the before attribute value state. */
 603             $this->state = 'beforeAttributeValue';
 604
 605         } elseif($char === '>') {
 606             /* U+003E GREATER-THAN SIGN (>)
 607             Emit the current tag token. Switch to the data state. */
 608             $this->emitToken($this->token);
 609             $this->state = 'data';
 610
 611         } elseif($char === '/' && $this->character($this->char + 1) !== '>') {
 612             /* U+002F SOLIDUS (/)
 613             Parse error unless this is a permitted slash. Switch to the
 614             before attribute name state. */
 615             $this->state = 'beforeAttributeName';
 616
 617         } elseif($this->char === $this->EOF) {
 618             /* EOF
 619             Parse error. Emit the current tag token. Reconsume the EOF
 620             character in the data state. */
 621             $this->emitToken($this->token);
 622
 623             $this->char--;
 624             $this->state = 'data';
 625
 626         } else {
 627             /* Anything else
 628             Start a new attribute in the current tag token. Set that attribute's
 629             name to the current input character, and its value to the empty string.
 630             Switch to the attribute name state. */
 631             $this->token['attr'][] = array(
 632                 'name'  => strtolower($char),
 633                 'value' => null
 634             );
 635
 636             $this->state = 'attributeName';
 637         }
 638     }
 639
 640     private function beforeAttributeValueState() {
 641         // Consume the next input character:
 642         $this->char++;
 643         $char = $this->character($this->char);
 644
 645         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
 646             /* U+0009 CHARACTER TABULATION
 647             U+000A LINE FEED (LF)
 648             U+000B LINE TABULATION
 649             U+000C FORM FEED (FF)
 650             U+0020 SPACE
 651             Stay in the before attribute value state. */
 652             $this->state = 'beforeAttributeValue';
 653
 654         } elseif($char === '"') {
 655             /* U+0022 QUOTATION MARK (")
 656             Switch to the attribute value (double-quoted) state. */
 657             $this->state = 'attributeValueDoubleQuoted';
 658
 659         } elseif($char === '&') {
 660             /* U+0026 AMPERSAND (&)
 661             Switch to the attribute value (unquoted) state and reconsume
 662             this input character. */
 663             $this->char--;
 664             $this->state = 'attributeValueUnquoted';
 665
 666         } elseif($char === '\'') {
 667             /* U+0027 APOSTROPHE (')
 668             Switch to the attribute value (single-quoted) state. */
 669             $this->state = 'attributeValueSingleQuoted';
 670
 671         } elseif($char === '>') {
 672             /* U+003E GREATER-THAN SIGN (>)
 673             Emit the current tag token. Switch to the data state. */
 674             $this->emitToken($this->token);
 675             $this->state = 'data';
 676
 677         } else {
 678             /* Anything else
 679             Append the current input character to the current attribute's value.
 680             Switch to the attribute value (unquoted) state. */
 681             $last = count($this->token['attr']) - 1;
 682             $this->token['attr'][$last]['value'] .= $char;
 683
 684             $this->state = 'attributeValueUnquoted';
 685         }
 686     }
 687
 688     private function attributeValueDoubleQuotedState() {
 689         // Consume the next input character:
 690         $this->char++;
 691         $char = $this->character($this->char);
 692
 693         if($char === '"') {
 694             /* U+0022 QUOTATION MARK (")
 695             Switch to the before attribute name state. */
 696             $this->state = 'beforeAttributeName';
 697
 698         } elseif($char === '&') {
 699             /* U+0026 AMPERSAND (&)
 700             Switch to the entity in attribute value state. */
 701             $this->entityInAttributeValueState('double');
 702
 703         } elseif($this->char === $this->EOF) {
 704             /* EOF
 705             Parse error. Emit the current tag token. Reconsume the character
 706             in the data state. */
 707             $this->emitToken($this->token);
 708
 709             $this->char--;
 710             $this->state = 'data';
 711
 712         } else {
 713             /* Anything else
 714             Append the current input character to the current attribute's value.
 715             Stay in the attribute value (double-quoted) state. */
 716             $last = count($this->token['attr']) - 1;
 717             $this->token['attr'][$last]['value'] .= $char;
 718
 719             $this->state = 'attributeValueDoubleQuoted';
 720         }
 721     }
 722
 723     private function attributeValueSingleQuotedState() {
 724         // Consume the next input character:
 725         $this->char++;
 726         $char = $this->character($this->char);
 727
 728         if($char === '\'') {
 729             /* U+0022 QUOTATION MARK (')
 730             Switch to the before attribute name state. */
 731             $this->state = 'beforeAttributeName';
 732
 733         } elseif($char === '&') {
 734             /* U+0026 AMPERSAND (&)
 735             Switch to the entity in attribute value state. */
 736             $this->entityInAttributeValueState('single');
 737
 738         } elseif($this->char === $this->EOF) {
 739             /* EOF
 740             Parse error. Emit the current tag token. Reconsume the character
 741             in the data state. */
 742             $this->emitToken($this->token);
 743
 744             $this->char--;
 745             $this->state = 'data';
 746
 747         } else {
 748             /* Anything else
 749             Append the current input character to the current attribute's value.
 750             Stay in the attribute value (single-quoted) state. */
 751             $last = count($this->token['attr']) - 1;
 752             $this->token['attr'][$last]['value'] .= $char;
 753
 754             $this->state = 'attributeValueSingleQuoted';
 755         }
 756     }
 757
 758     private function attributeValueUnquotedState() {
 759         // Consume the next input character:
 760         $this->char++;
 761         $char = $this->character($this->char);
 762
 763         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
 764             /* U+0009 CHARACTER TABULATION
 765             U+000A LINE FEED (LF)
 766             U+000B LINE TABULATION
 767             U+000C FORM FEED (FF)
 768             U+0020 SPACE
 769             Switch to the before attribute name state. */
 770             $this->state = 'beforeAttributeName';
 771
 772         } elseif($char === '&') {
 773             /* U+0026 AMPERSAND (&)
 774             Switch to the entity in attribute value state. */
 775             $this->entityInAttributeValueState();
 776
 777         } elseif($char === '>') {
 778             /* U+003E GREATER-THAN SIGN (>)
 779             Emit the current tag token. Switch to the data state. */
 780             $this->emitToken($this->token);
 781             $this->state = 'data';
 782
 783         } else {
 784             /* Anything else
 785             Append the current input character to the current attribute's value.
 786             Stay in the attribute value (unquoted) state. */
 787             $last = count($this->token['attr']) - 1;
 788             $this->token['attr'][$last]['value'] .= $char;
 789
 790             $this->state = 'attributeValueUnquoted';
 791         }
 792     }
 793
 794     private function entityInAttributeValueState() {
 795         // Attempt to consume an entity.
 796         $entity = $this->entity();
 797
 798         // If nothing is returned, append a U+0026 AMPERSAND character to the
 799         // current attribute's value. Otherwise, emit the character token that
 800         // was returned.
 801         $char = (!$entity)
 802             ? '&'
 803             : $entity;
 804
 805         $last = count($this->token['attr']) - 1;
 806         $this->token['attr'][$last]['value'] .= $char;
 807     }
 808
 809     private function bogusCommentState() {
 810         /* Consume every character up to the first U+003E GREATER-THAN SIGN
 811         character (>) or the end of the file (EOF), whichever comes first. Emit
 812         a comment token whose data is the concatenation of all the characters
 813         starting from and including the character that caused the state machine
 814         to switch into the bogus comment state, up to and including the last
 815         consumed character before the U+003E character, if any, or up to the
 816         end of the file otherwise. (If the comment was started by the end of
 817         the file (EOF), the token is empty.) */
 818         $data = $this->characters('^>', $this->char);
 819         $this->emitToken(array(
 820             'data' => $data,
 821             'type' => self::COMMENT
 822         ));
 823
 824         $this->char += strlen($data);
 825
 826         /* Switch to the data state. */
 827         $this->state = 'data';
 828
 829         /* If the end of the file was reached, reconsume the EOF character. */
 830         if($this->char === $this->EOF) {
 831             $this->char = $this->EOF - 1;
 832         }
 833     }
 834
 835     private function markupDeclarationOpenState() {
 836         /* If the next two characters are both U+002D HYPHEN-MINUS (-)
 837         characters, consume those two characters, create a comment token whose
 838         data is the empty string, and switch to the comment state. */
 839         if($this->character($this->char + 1, 2) === '--') {
 840             $this->char += 2;
 841             $this->state = 'comment';
 842             $this->token = array(
 843                 'data' => null,
 844                 'type' => self::COMMENT
 845             );
 846
 847         /* Otherwise if the next seven chacacters are a case-insensitive match
 848         for the word "DOCTYPE", then consume those characters and switch to the
 849         DOCTYPE state. */
 850         } elseif(strtolower($this->character($this->char + 1, 7)) === 'doctype') {
 851             $this->char += 7;
 852             $this->state = 'doctype';
 853
 854         /* Otherwise, is is a parse error. Switch to the bogus comment state.
 855         The next character that is consumed, if any, is the first character
 856         that will be in the comment. */
 857         } else {
 858             $this->char++;
 859             $this->state = 'bogusComment';
 860         }
 861     }
 862
 863     private function commentState() {
 864         /* Consume the next input character: */
 865         $this->char++;
 866         $char = $this->char();
 867
 868         /* U+002D HYPHEN-MINUS (-) */
 869         if($char === '-') {
 870             /* Switch to the comment dash state  */
 871             $this->state = 'commentDash';
 872
 873         /* EOF */
 874         } elseif($this->char === $this->EOF) {
 875             /* Parse error. Emit the comment token. Reconsume the EOF character
 876             in the data state. */
 877             $this->emitToken($this->token);
 878             $this->char--;
 879             $this->state = 'data';
 880
 881         /* Anything else */
 882         } else {
 883             /* Append the input character to the comment token's data. Stay in
 884             the comment state. */
 885             $this->token['data'] .= $char;
 886         }
 887     }
 888
 889     private function commentDashState() {
 890         /* Consume the next input character: */
 891         $this->char++;
 892         $char = $this->char();
 893
 894         /* U+002D HYPHEN-MINUS (-) */
 895         if($char === '-') {
 896             /* Switch to the comment end state  */
 897             $this->state = 'commentEnd';
 898
 899         /* EOF */
 900         } elseif($this->char === $this->EOF) {
 901             /* Parse error. Emit the comment token. Reconsume the EOF character
 902             in the data state. */
 903             $this->emitToken($this->token);
 904             $this->char--;
 905             $this->state = 'data';
 906
 907         /* Anything else */
 908         } else {
 909             /* Append a U+002D HYPHEN-MINUS (-) character and the input
 910             character to the comment token's data. Switch to the comment state. */
 911             $this->token['data'] .= '-'.$char;
 912             $this->state = 'comment';
 913         }
 914     }
 915
 916     private function commentEndState() {
 917         /* Consume the next input character: */
 918         $this->char++;
 919         $char = $this->char();
 920
 921         if($char === '>') {
 922             $this->emitToken($this->token);
 923             $this->state = 'data';
 924
 925         } elseif($char === '-') {
 926             $this->token['data'] .= '-';
 927
 928         } elseif($this->char === $this->EOF) {
 929             $this->emitToken($this->token);
 930             $this->char--;
 931             $this->state = 'data';
 932
 933         } else {
 934             $this->token['data'] .= '--'.$char;
 935             $this->state = 'comment';
 936         }
 937     }
 938
 939     private function doctypeState() {
 940         /* Consume the next input character: */
 941         $this->char++;
 942         $char = $this->char();
 943
 944         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
 945             $this->state = 'beforeDoctypeName';
 946
 947         } else {
 948             $this->char--;
 949             $this->state = 'beforeDoctypeName';
 950         }
 951     }
 952
 953     private function beforeDoctypeNameState() {
 954         /* Consume the next input character: */
 955         $this->char++;
 956         $char = $this->char();
 957
 958         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
 959             // Stay in the before DOCTYPE name state.
 960
 961         } elseif(preg_match('/^[a-z]$/', $char)) {
 962             $this->token = array(
 963                 'name' => strtoupper($char),
 964                 'type' => self::DOCTYPE,
 965                 'error' => true
 966             );
 967
 968             $this->state = 'doctypeName';
 969
 970         } elseif($char === '>') {
 971             $this->emitToken(array(
 972                 'name' => null,
 973                 'type' => self::DOCTYPE,
 974                 'error' => true
 975             ));
 976
 977             $this->state = 'data';
 978
 979         } elseif($this->char === $this->EOF) {
 980             $this->emitToken(array(
 981                 'name' => null,
 982                 'type' => self::DOCTYPE,
 983                 'error' => true
 984             ));
 985
 986             $this->char--;
 987             $this->state = 'data';
 988
 989         } else {
 990             $this->token = array(
 991                 'name' => $char,
 992                 'type' => self::DOCTYPE,
 993                 'error' => true
 994             );
 995
 996             $this->state = 'doctypeName';
 997         }
 998     }
 999
1000     private function doctypeNameState() {
1001         /* Consume the next input character: */
1002         $this->char++;
1003         $char = $this->char();
1004
1005         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
1006             $this->state = 'AfterDoctypeName';
1007
1008         } elseif($char === '>') {
1009             $this->emitToken($this->token);
1010             $this->state = 'data';
1011
1012         } elseif(preg_match('/^[a-z]$/', $char)) {
1013             $this->token['name'] .= strtoupper($char);
1014
1015         } elseif($this->char === $this->EOF) {
1016             $this->emitToken($this->token);
1017             $this->char--;
1018             $this->state = 'data';
1019
1020         } else {
1021             $this->token['name'] .= $char;
1022         }
1023
1024         $this->token['error'] = ($this->token['name'] === 'HTML')
1025             ? false
1026             : true;
1027     }
1028
1029     private function afterDoctypeNameState() {
1030         /* Consume the next input character: */
1031         $this->char++;
1032         $char = $this->char();
1033
1034         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
1035             // Stay in the DOCTYPE name state.
1036
1037         } elseif($char === '>') {
1038             $this->emitToken($this->token);
1039             $this->state = 'data';
1040
1041         } elseif($this->char === $this->EOF) {
1042             $this->emitToken($this->token);
1043             $this->char--;
1044             $this->state = 'data';
1045
1046         } else {
1047             $this->token['error'] = true;
1048             $this->state = 'bogusDoctype';
1049         }
1050     }
1051
1052     private function bogusDoctypeState() {
1053         /* Consume the next input character: */
1054         $this->char++;
1055         $char = $this->char();
1056
1057         if($char === '>') {
1058             $this->emitToken($this->token);
1059             $this->state = 'data';
1060
1061         } elseif($this->char === $this->EOF) {
1062             $this->emitToken($this->token);
1063             $this->char--;
1064             $this->state = 'data';
1065
1066         } else {
1067             // Stay in the bogus DOCTYPE state.
1068         }
1069     }
1070
1071     private function entity() {
1072         $start = $this->char;
1073
1074         // This section defines how to consume an entity. This definition is
1075         // used when parsing entities in text and in attributes.
1076
1077         // The behaviour depends on the identity of the next character (the
1078         // one immediately after the U+0026 AMPERSAND character):
1079
1080         switch($this->character($this->char + 1)) {
1081             // U+0023 NUMBER SIGN (#)
1082             case '#':
1083
1084                 // The behaviour further depends on the character after the
1085                 // U+0023 NUMBER SIGN:
1086                 switch($this->character($this->char + 1)) {
1087                     // U+0078 LATIN SMALL LETTER X
1088                     // U+0058 LATIN CAPITAL LETTER X
1089                     case 'x':
1090                     case 'X':
1091                         // Follow the steps below, but using the range of
1092                         // characters U+0030 DIGIT ZERO through to U+0039 DIGIT
1093                         // NINE, U+0061 LATIN SMALL LETTER A through to U+0066
1094                         // LATIN SMALL LETTER F, and U+0041 LATIN CAPITAL LETTER
1095                         // A, through to U+0046 LATIN CAPITAL LETTER F (in other
1096                         // words, 0-9, A-F, a-f).
1097                         $char = 1;
1098                         $char_class = '0-9A-Fa-f';
1099                     break;
1100
1101                     // Anything else
1102                     default:
1103                         // Follow the steps below, but using the range of
1104                         // characters U+0030 DIGIT ZERO through to U+0039 DIGIT
1105                         // NINE (i.e. just 0-9).
1106                         $char = 0;
1107                         $char_class = '0-9';
1108                     break;
1109                 }
1110
1111                 // Consume as many characters as match the range of characters
1112                 // given above.
1113                 $this->char++;
1114                 $e_name = $this->characters($char_class, $this->char + $char + 1);
1115                 $entity = $this->character($start, $this->char);
1116                 $cond = strlen($e_name) > 0;
1117
1118                 // The rest of the parsing happens bellow.
1119             break;
1120
1121             // Anything else
1122             default:
1123                 // Consume the maximum number of characters possible, with the
1124                 // consumed characters case-sensitively matching one of the
1125                 // identifiers in the first column of the entities table.
1126                 $e_name = $this->characters('0-9A-Za-z;', $this->char + 1);
1127                 $len = strlen($e_name);
1128
1129                 for($c = 1; $c <= $len; $c++) {
1130                     $id = substr($e_name, 0, $c);
1131                     $this->char++;
1132
1133                     if(in_array($id, $this->entities)) {
1134                         if ($e_name[$c-1] !== ';') {
1135                             if ($c < $len && $e_name[$c] == ';') {
1136                                 $this->char++; // consume extra semicolon
1137                             }
1138                         }
1139                         $entity = $id;
1140                         break;
1141                     }
1142                 }
1143
1144                 $cond = isset($entity);
1145                 // The rest of the parsing happens bellow.
1146             break;
1147         }
1148
1149         if(!$cond) {
1150             // If no match can be made, then this is a parse error. No
1151             // characters are consumed, and nothing is returned.
1152             $this->char = $start;
1153             return false;
1154         }
1155
1156         // Return a character token for the character corresponding to the
1157         // entity name (as given by the second column of the entities table).
1158         return html_entity_decode('&'.$entity.';', ENT_QUOTES, 'UTF-8');
1159     }
1160
1161     private function emitToken($token) {
1162         $emit = $this->tree->emitToken($token);
1163
1164         if(is_int($emit)) {
1165             $this->content_model = $emit;
1166
1167         } elseif($token['type'] === self::ENDTAG) {
1168             $this->content_model = self::PCDATA;
1169         }
1170     }
1171
1172     private function EOF() {
1173         $this->state = null;
1174         $this->tree->emitToken(array(
1175             'type' => self::EOF
1176         ));
1177     }
1178 }
1179
1180 class HTML5TreeConstructer {
1181     public $stack = array();
1182
1183     private $phase;
1184     private $mode;
1185     private $dom;
1186     private $foster_parent = null;
1187     private $a_formatting  = array();
1188
1189     private $head_pointer = null;
1190     private $form_pointer = null;
1191
1192     private $scoping = array('button','caption','html','marquee','object','table','td','th');
1193     private $formatting = array('a','b','big','em','font','i','nobr','s','small','strike','strong','tt','u');
1194     private $special = array('address','area','base','basefont','bgsound',
1195     'blockquote','body','br','center','col','colgroup','dd','dir','div','dl',
1196     'dt','embed','fieldset','form','frame','frameset','h1','h2','h3','h4','h5',
1197     'h6','head','hr','iframe','image','img','input','isindex','li','link',
1198     'listing','menu','meta','noembed','noframes','noscript','ol','optgroup',
1199     'option','p','param','plaintext','pre','script','select','spacer','style',
1200     'tbody','textarea','tfoot','thead','title','tr','ul','wbr');
1201
1202     // The different phases.
1203     const INIT_PHASE = 0;
1204     const ROOT_PHASE = 1;
1205     const MAIN_PHASE = 2;
1206     const END_PHASE  = 3;
1207
1208     // The different insertion modes for the main phase.
1209     const BEFOR_HEAD = 0;
1210     const IN_HEAD    = 1;
1211     const AFTER_HEAD = 2;
1212     const IN_BODY    = 3;
1213     const IN_TABLE   = 4;
1214     const IN_CAPTION = 5;
1215     const IN_CGROUP  = 6;
1216     const IN_TBODY   = 7;
1217     const IN_ROW     = 8;
1218     const IN_CELL    = 9;
1219     const IN_SELECT  = 10;
1220     const AFTER_BODY = 11;
1221     const IN_FRAME   = 12;
1222     const AFTR_FRAME = 13;
1223
1224     // The different types of elements.
1225     const SPECIAL    = 0;
1226     const SCOPING    = 1;
1227     const FORMATTING = 2;
1228     const PHRASING   = 3;
1229
1230     const MARKER     = 0;
1231
1232     public function __construct() {
1233         $this->phase = self::INIT_PHASE;
1234         $this->mode = self::BEFOR_HEAD;
1235         $this->dom = new DOMDocument;
1236
1237         $this->dom->encoding = 'UTF-8';
1238         $this->dom->preserveWhiteSpace = true;
1239         $this->dom->substituteEntities = true;
1240         $this->dom->strictErrorChecking = false;
1241     }
1242
1243     // Process tag tokens
1244     public function emitToken($token) {
1245         switch($this->phase) {
1246             case self::INIT_PHASE: return $this->initPhase($token); break;
1247             case self::ROOT_PHASE: return $this->rootElementPhase($token); break;
1248             case self::MAIN_PHASE: return $this->mainPhase($token); break;
1249             case self::END_PHASE : return $this->trailingEndPhase($token); break;
1250         }
1251     }
1252
1253     private function initPhase($token) {
1254         /* Initially, the tree construction stage must handle each token
1255         emitted from the tokenisation stage as follows: */
1256
1257         /* A DOCTYPE token that is marked as being in error
1258         A comment token
1259         A start tag token
1260         An end tag token
1261         A character token that is not one of one of U+0009 CHARACTER TABULATION,
1262             U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1263             or U+0020 SPACE
1264         An end-of-file token */
1265         if((isset($token['error']) && $token['error']) ||
1266         $token['type'] === HTML5::COMMENT ||
1267         $token['type'] === HTML5::STARTTAG ||
1268         $token['type'] === HTML5::ENDTAG ||
1269         $token['type'] === HTML5::EOF ||
1270         ($token['type'] === HTML5::CHARACTR && isset($token['data']) &&
1271         !preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data']))) {
1272             /* This specification does not define how to handle this case. In
1273             particular, user agents may ignore the entirety of this specification
1274             altogether for such documents, and instead invoke special parse modes
1275             with a greater emphasis on backwards compatibility. */
1276
1277             $this->phase = self::ROOT_PHASE;
1278             return $this->rootElementPhase($token);
1279
1280         /* A DOCTYPE token marked as being correct */
1281         } elseif(isset($token['error']) && !$token['error']) {
1282             /* Append a DocumentType node to the Document  node, with the name
1283             attribute set to the name given in the DOCTYPE token (which will be
1284             "HTML"), and the other attributes specific to DocumentType objects
1285             set to null, empty lists, or the empty string as appropriate. */
1286             $doctype = new DOMDocumentType(null, null, 'HTML');
1287
1288             /* Then, switch to the root element phase of the tree construction
1289             stage. */
1290             $this->phase = self::ROOT_PHASE;
1291
1292         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
1293         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1294         or U+0020 SPACE */
1295         } elseif(isset($token['data']) && preg_match('/^[\t\n\x0b\x0c ]+$/',
1296         $token['data'])) {
1297             /* Append that character  to the Document node. */
1298             $text = $this->dom->createTextNode($token['data']);
1299             $this->dom->appendChild($text);
1300         }
1301     }
1302
1303     private function rootElementPhase($token) {
1304         /* After the initial phase, as each token is emitted from the tokenisation
1305         stage, it must be processed as described in this section. */
1306
1307         /* A DOCTYPE token */
1308         if($token['type'] === HTML5::DOCTYPE) {
1309             // Parse error. Ignore the token.
1310
1311         /* A comment token */
1312         } elseif($token['type'] === HTML5::COMMENT) {
1313             /* Append a Comment node to the Document object with the data
1314             attribute set to the data given in the comment token. */
1315             $comment = $this->dom->createComment($token['data']);
1316             $this->dom->appendChild($comment);
1317
1318         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
1319         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1320         or U+0020 SPACE */
1321         } elseif($token['type'] === HTML5::CHARACTR &&
1322         preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
1323             /* Append that character  to the Document node. */
1324             $text = $this->dom->createTextNode($token['data']);
1325             $this->dom->appendChild($text);
1326
1327         /* A character token that is not one of U+0009 CHARACTER TABULATION,
1328             U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED
1329             (FF), or U+0020 SPACE
1330         A start tag token
1331         An end tag token
1332         An end-of-file token */
1333         } elseif(($token['type'] === HTML5::CHARACTR &&
1334         !preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) ||
1335         $token['type'] === HTML5::STARTTAG ||
1336         $token['type'] === HTML5::ENDTAG ||
1337         $token['type'] === HTML5::EOF) {
1338             /* Create an HTMLElement node with the tag name html, in the HTML
1339             namespace. Append it to the Document object. Switch to the main
1340             phase and reprocess the current token. */
1341             $html = $this->dom->createElement('html');
1342             $this->dom->appendChild($html);
1343             $this->stack[] = $html;
1344
1345             $this->phase = self::MAIN_PHASE;
1346             return $this->mainPhase($token);
1347         }
1348     }
1349
1350     private function mainPhase($token) {
1351         /* Tokens in the main phase must be handled as follows: */
1352
1353         /* A DOCTYPE token */
1354         if($token['type'] === HTML5::DOCTYPE) {
1355             // Parse error. Ignore the token.
1356
1357         /* A start tag token with the tag name "html" */
1358         } elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'html') {
1359             /* If this start tag token was not the first start tag token, then
1360             it is a parse error. */
1361
1362             /* For each attribute on the token, check to see if the attribute
1363             is already present on the top element of the stack of open elements.
1364             If it is not, add the attribute and its corresponding value to that
1365             element. */
1366             foreach($token['attr'] as $attr) {
1367                 if(!$this->stack[0]->hasAttribute($attr['name'])) {
1368                     $this->stack[0]->setAttribute($attr['name'], $attr['value']);
1369                 }
1370             }
1371
1372         /* An end-of-file token */
1373         } elseif($token['type'] === HTML5::EOF) {
1374             /* Generate implied end tags. */
1375             $this->generateImpliedEndTags();
1376
1377         /* Anything else. */
1378         } else {
1379             /* Depends on the insertion mode: */
1380             switch($this->mode) {
1381                 case self::BEFOR_HEAD: return $this->beforeHead($token); break;
1382                 case self::IN_HEAD:    return $this->inHead($token); break;
1383                 case self::AFTER_HEAD: return $this->afterHead($token); break;
1384                 case self::IN_BODY:    return $this->inBody($token); break;
1385                 case self::IN_TABLE:   return $this->inTable($token); break;
1386                 case self::IN_CAPTION: return $this->inCaption($token); break;
1387                 case self::IN_CGROUP:  return $this->inColumnGroup($token); break;
1388                 case self::IN_TBODY:   return $this->inTableBody($token); break;
1389                 case self::IN_ROW:     return $this->inRow($token); break;
1390                 case self::IN_CELL:    return $this->inCell($token); break;
1391                 case self::IN_SELECT:  return $this->inSelect($token); break;
1392                 case self::AFTER_BODY: return $this->afterBody($token); break;
1393                 case self::IN_FRAME:   return $this->inFrameset($token); break;
1394                 case self::AFTR_FRAME: return $this->afterFrameset($token); break;
1395                 case self::END_PHASE:  return $this->trailingEndPhase($token); break;
1396             }
1397         }
1398     }
1399
1400     private function beforeHead($token) {
1401         /* Handle the token as follows: */
1402
1403         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
1404         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1405         or U+0020 SPACE */
1406         if($token['type'] === HTML5::CHARACTR &&
1407         preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
1408             /* Append the character to the current node. */
1409             $this->insertText($token['data']);
1410
1411         /* A comment token */
1412         } elseif($token['type'] === HTML5::COMMENT) {
1413             /* Append a Comment node to the current node with the data attribute
1414             set to the data given in the comment token. */
1415             $this->insertComment($token['data']);
1416
1417         /* A start tag token with the tag name "head" */
1418         } elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'head') {
1419             /* Create an element for the token, append the new element to the
1420             current node and push it onto the stack of open elements. */
1421             $element = $this->insertElement($token);
1422
1423             /* Set the head element pointer to this new element node. */
1424             $this->head_pointer = $element;
1425
1426             /* Change the insertion mode to "in head". */
1427             $this->mode = self::IN_HEAD;
1428
1429         /* A start tag token whose tag name is one of: "base", "link", "meta",
1430         "script", "style", "title". Or an end tag with the tag name "html".
1431         Or a character token that is not one of U+0009 CHARACTER TABULATION,
1432         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1433         or U+0020 SPACE. Or any other start tag token */
1434         } elseif($token['type'] === HTML5::STARTTAG ||
1435         ($token['type'] === HTML5::ENDTAG && $token['name'] === 'html') ||
1436         ($token['type'] === HTML5::CHARACTR && !preg_match('/^[\t\n\x0b\x0c ]$/',
1437         $token['data']))) {
1438             /* Act as if a start tag token with the tag name "head" and no
1439             attributes had been seen, then reprocess the current token. */
1440             $this->beforeHead(array(
1441                 'name' => 'head',
1442                 'type' => HTML5::STARTTAG,
1443                 'attr' => array()
1444             ));
1445
1446             return $this->inHead($token);
1447
1448         /* Any other end tag */
1449         } elseif($token['type'] === HTML5::ENDTAG) {
1450             /* Parse error. Ignore the token. */
1451         }
1452     }
1453
1454     private function inHead($token) {
1455         /* Handle the token as follows: */
1456
1457         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
1458         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1459         or U+0020 SPACE.
1460
1461         THIS DIFFERS FROM THE SPEC: If the current node is either a title, style
1462         or script element, append the character to the current node regardless
1463         of its content. */
1464         if(($token['type'] === HTML5::CHARACTR &&
1465         preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) || (
1466         $token['type'] === HTML5::CHARACTR && in_array(end($this->stack)->nodeName,
1467         array('title', 'style', 'script')))) {
1468             /* Append the character to the current node. */
1469             $this->insertText($token['data']);
1470
1471         /* A comment token */
1472         } elseif($token['type'] === HTML5::COMMENT) {
1473             /* Append a Comment node to the current node with the data attribute
1474             set to the data given in the comment token. */
1475             $this->insertComment($token['data']);
1476
1477         } elseif($token['type'] === HTML5::ENDTAG &&
1478         in_array($token['name'], array('title', 'style', 'script'))) {
1479             array_pop($this->stack);
1480             return HTML5::PCDATA;
1481
1482         /* A start tag with the tag name "title" */
1483         } elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'title') {
1484             /* Create an element for the token and append the new element to the
1485             node pointed to by the head element pointer, or, if that is null
1486             (innerHTML case), to the current node. */
1487             if($this->head_pointer !== null) {
1488                 $element = $this->insertElement($token, false);
1489                 $this->head_pointer->appendChild($element);
1490
1491             } else {
1492                 $element = $this->insertElement($token);
1493             }
1494
1495             /* Switch the tokeniser's content model flag  to the RCDATA state. */
1496             return HTML5::RCDATA;
1497
1498         /* A start tag with the tag name "style" */
1499         } elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'style') {
1500             /* Create an element for the token and append the new element to the
1501             node pointed to by the head element pointer, or, if that is null
1502             (innerHTML case), to the current node. */
1503             if($this->head_pointer !== null) {
1504                 $element = $this->insertElement($token, false);
1505                 $this->head_pointer->appendChild($element);
1506
1507             } else {
1508                 $this->insertElement($token);
1509             }
1510
1511             /* Switch the tokeniser's content model flag  to the CDATA state. */
1512             return HTML5::CDATA;
1513
1514         /* A start tag with the tag name "script" */
1515         } elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'script') {
1516             /* Create an element for the token. */
1517             $element = $this->insertElement($token, false);
1518             $this->head_pointer->appendChild($element);
1519
1520             /* Switch the tokeniser's content model flag  to the CDATA state. */
1521             return HTML5::CDATA;
1522
1523         /* A start tag with the tag name "base", "link", or "meta" */
1524         } elseif($token['type'] === HTML5::STARTTAG && in_array($token['name'],
1525         array('base', 'link', 'meta'))) {
1526             /* Create an element for the token and append the new element to the
1527             node pointed to by the head element pointer, or, if that is null
1528             (innerHTML case), to the current node. */
1529             if($this->head_pointer !== null) {
1530                 $element = $this->insertElement($token, false);
1531                 $this->head_pointer->appendChild($element);
1532                 array_pop($this->stack);
1533
1534             } else {
1535                 $this->insertElement($token);
1536             }
1537
1538         /* An end tag with the tag name "head" */
1539         } elseif($token['type'] === HTML5::ENDTAG && $token['name'] === 'head') {
1540             /* If the current node is a head element, pop the current node off
1541             the stack of open elements. */
1542             if($this->head_pointer->isSameNode(end($this->stack))) {
1543                 array_pop($this->stack);
1544
1545             /* Otherwise, this is a parse error. */
1546             } else {
1547                 // k
1548             }
1549
1550             /* Change the insertion mode to "after head". */
1551             $this->mode = self::AFTER_HEAD;
1552
1553         /* A start tag with the tag name "head" or an end tag except "html". */
1554         } elseif(($token['type'] === HTML5::STARTTAG && $token['name'] === 'head') ||
1555         ($token['type'] === HTML5::ENDTAG && $token['name'] !== 'html')) {
1556             // Parse error. Ignore the token.
1557
1558         /* Anything else */
1559         } else {
1560             /* If the current node is a head element, act as if an end tag
1561             token with the tag name "head" had been seen. */
1562             if($this->head_pointer->isSameNode(end($this->stack))) {
1563                 $this->inHead(array(
1564                     'name' => 'head',
1565                     'type' => HTML5::ENDTAG
1566                 ));
1567
1568             /* Otherwise, change the insertion mode to "after head". */
1569             } else {
1570                 $this->mode = self::AFTER_HEAD;
1571             }
1572
1573             /* Then, reprocess the current token. */
1574             return $this->afterHead($token);
1575         }
1576     }
1577
1578     private function afterHead($token) {
1579         /* Handle the token as follows: */
1580
1581         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
1582         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1583         or U+0020 SPACE */
1584         if($token['type'] === HTML5::CHARACTR &&
1585         preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
1586             /* Append the character to the current node. */
1587             $this->insertText($token['data']);
1588
1589         /* A comment token */
1590         } elseif($token['type'] === HTML5::COMMENT) {
1591             /* Append a Comment node to the current node with the data attribute
1592             set to the data given in the comment token. */
1593             $this->insertComment($token['data']);
1594
1595         /* A start tag token with the tag name "body" */
1596         } elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'body') {
1597             /* Insert a body element for the token. */
1598             $this->insertElement($token);
1599
1600             /* Change the insertion mode to "in body". */
1601             $this->mode = self::IN_BODY;
1602
1603         /* A start tag token with the tag name "frameset" */
1604         } elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'frameset') {
1605             /* Insert a frameset element for the token. */
1606             $this->insertElement($token);
1607
1608             /* Change the insertion mode to "in frameset". */
1609             $this->mode = self::IN_FRAME;
1610
1611         /* A start tag token whose tag name is one of: "base", "link", "meta",
1612         "script", "style", "title" */
1613         } elseif($token['type'] === HTML5::STARTTAG && in_array($token['name'],
1614         array('base', 'link', 'meta', 'script', 'style', 'title'))) {
1615             /* Parse error. Switch the insertion mode back to "in head" and
1616             reprocess the token. */
1617             $this->mode = self::IN_HEAD;
1618             return $this->inHead($token);
1619
1620         /* Anything else */
1621         } else {
1622             /* Act as if a start tag token with the tag name "body" and no
1623             attributes had been seen, and then reprocess the current token. */
1624             $this->afterHead(array(
1625                 'name' => 'body',
1626                 'type' => HTML5::STARTTAG,
1627                 'attr' => array()
1628             ));
1629
1630             return $this->inBody($token);
1631         }
1632     }
1633
1634     private function inBody($token) {
1635         /* Handle the token as follows: */
1636
1637         switch($token['type']) {
1638             /* A character token */
1639             case HTML5::CHARACTR:
1640                 /* Reconstruct the active formatting elements, if any. */
1641                 $this->reconstructActiveFormattingElements();
1642
1643                 /* Append the token's character to the current node. */
1644                 $this->insertText($token['data']);
1645             break;
1646
1647             /* A comment token */
1648             case HTML5::COMMENT:
1649                 /* Append a Comment node to the current node with the data
1650                 attribute set to the data given in the comment token. */
1651                 $this->insertComment($token['data']);
1652             break;
1653
1654             case HTML5::STARTTAG:
1655             switch($token['name']) {
1656                 /* A start tag token whose tag name is one of: "script",
1657                 "style" */
1658                 case 'script': case 'style':
1659                     /* Process the token as if the insertion mode had been "in
1660                     head". */
1661                     return $this->inHead($token);
1662                 break;
1663
1664                 /* A start tag token whose tag name is one of: "base", "link",
1665                 "meta", "title" */
1666                 case 'base': case 'link': case 'meta': case 'title':
1667                     /* Parse error. Process the token as if the insertion mode
1668                     had    been "in head". */
1669                     return $this->inHead($token);
1670                 break;
1671
1672                 /* A start tag token with the tag name "body" */
1673                 case 'body':
1674                     /* Parse error. If the second element on the stack of open
1675                     elements is not a body element, or, if the stack of open
1676                     elements has only one node on it, then ignore the token.
1677                     (innerHTML case) */
1678                     if(count($this->stack) === 1 || $this->stack[1]->nodeName !== 'body') {
1679                         // Ignore
1680
1681                     /* Otherwise, for each attribute on the token, check to see
1682                     if the attribute is already present on the body element (the
1683                     second element)    on the stack of open elements. If it is not,
1684                     add the attribute and its corresponding value to that
1685                     element. */
1686                     } else {
1687                         foreach($token['attr'] as $attr) {
1688                             if(!$this->stack[1]->hasAttribute($attr['name'])) {
1689                                 $this->stack[1]->setAttribute($attr['name'], $attr['value']);
1690                             }
1691                         }
1692                     }
1693                 break;
1694
1695                 /* A start tag whose tag name is one of: "address",
1696                 "blockquote", "center", "dir", "div", "dl", "fieldset",
1697                 "listing", "menu", "ol", "p", "ul" */
1698                 case 'address': case 'blockquote': case 'center': case 'dir':
1699                 case 'div': case 'dl': case 'fieldset': case 'listing':
1700                 case 'menu': case 'ol': case 'p': case 'ul':
1701                     /* If the stack of open elements has a p element in scope,
1702                     then act as if an end tag with the tag name p had been
1703                     seen. */
1704                     if($this->elementInScope('p')) {
1705                         $this->emitToken(array(
1706                             'name' => 'p',
1707                             'type' => HTML5::ENDTAG
1708                         ));
1709                     }
1710
1711                     /* Insert an HTML element for the token. */
1712                     $this->insertElement($token);
1713                 break;
1714
1715                 /* A start tag whose tag name is "form" */
1716                 case 'form':
1717                     /* If the form element pointer is not null, ignore the
1718                     token with a parse error. */
1719                     if($this->form_pointer !== null) {
1720                         // Ignore.
1721
1722                     /* Otherwise: */
1723                     } else {
1724                         /* If the stack of open elements has a p element in
1725                         scope, then act as if an end tag with the tag name p
1726                         had been seen. */
1727                         if($this->elementInScope('p')) {
1728                             $this->emitToken(array(
1729                                 'name' => 'p',
1730                                 'type' => HTML5::ENDTAG
1731                             ));
1732                         }
1733
1734                         /* Insert an HTML element for the token, and set the
1735                         form element pointer to point to the element created. */
1736                         $element = $this->insertElement($token);
1737                         $this->form_pointer = $element;
1738                     }
1739                 break;
1740
1741                 /* A start tag whose tag name is "li", "dd" or "dt" */
1742                 case 'li': case 'dd': case 'dt':
1743                     /* If the stack of open elements has a p  element in scope,
1744                     then act as if an end tag with the tag name p had been
1745                     seen. */
1746                     if($this->elementInScope('p')) {
1747                         $this->emitToken(array(
1748                             'name' => 'p',
1749                             'type' => HTML5::ENDTAG
1750                         ));
1751                     }
1752
1753                     $stack_length = count($this->stack) - 1;
1754
1755                     for($n = $stack_length; 0 <= $n; $n--) {
1756                         /* 1. Initialise node to be the current node (the
1757                         bottommost node of the stack). */
1758                         $stop = false;
1759                         $node = $this->stack[$n];
1760                         $cat  = $this->getElementCategory($node->tagName);
1761
1762                         /* 2. If node is an li, dd or dt element, then pop all
1763                         the    nodes from the current node up to node, including
1764                         node, then stop this algorithm. */
1765                         if($token['name'] === $node->tagName ||    ($token['name'] !== 'li'
1766                         && ($node->tagName === 'dd' || $node->tagName === 'dt'))) {
1767                             for($x = $stack_length; $x >= $n ; $x--) {
1768                                 array_pop($this->stack);
1769                             }
1770
1771                             break;
1772                         }
1773
1774                         /* 3. If node is not in the formatting category, and is
1775                         not    in the phrasing category, and is not an address or
1776                         div element, then stop this algorithm. */
1777                         if($cat !== self::FORMATTING && $cat !== self::PHRASING &&
1778                         $node->tagName !== 'address' && $node->tagName !== 'div') {
1779                             break;
1780                         }
1781                     }
1782
1783                     /* Finally, insert an HTML element with the same tag
1784                     name as the    token's. */
1785                     $this->insertElement($token);
1786                 break;
1787
1788                 /* A start tag token whose tag name is "plaintext" */
1789                 case 'plaintext':
1790                     /* If the stack of open elements has a p  element in scope,
1791                     then act as if an end tag with the tag name p had been
1792                     seen. */
1793                     if($this->elementInScope('p')) {
1794                         $this->emitToken(array(
1795                             'name' => 'p',
1796                             'type' => HTML5::ENDTAG
1797                         ));
1798                     }
1799
1800                     /* Insert an HTML element for the token. */
1801                     $this->insertElement($token);
1802
1803                     return HTML5::PLAINTEXT;
1804                 break;
1805
1806                 /* A start tag whose tag name is one of: "h1", "h2", "h3", "h4",
1807                 "h5", "h6" */
1808                 case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6':
1809                     /* If the stack of open elements has a p  element in scope,
1810                     then act as if an end tag with the tag name p had been seen. */
1811                     if($this->elementInScope('p')) {
1812                         $this->emitToken(array(
1813                             'name' => 'p',
1814                             'type' => HTML5::ENDTAG
1815                         ));
1816                     }
1817
1818                     /* If the stack of open elements has in scope an element whose
1819                     tag name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
1820                     this is a parse error; pop elements from the stack until an
1821                     element with one of those tag names has been popped from the
1822                     stack. */
1823                     while($this->elementInScope(array('h1', 'h2', 'h3', 'h4', 'h5', 'h6'))) {
1824                         array_pop($this->stack);
1825                     }
1826
1827                     /* Insert an HTML element for the token. */
1828                     $this->insertElement($token);
1829                 break;
1830
1831                 /* A start tag whose tag name is "a" */
1832                 case 'a':
1833                     /* If the list of active formatting elements contains
1834                     an element whose tag name is "a" between the end of the
1835                     list and the last marker on the list (or the start of
1836                     the list if there is no marker on the list), then this
1837                     is a parse error; act as if an end tag with the tag name
1838                     "a" had been seen, then remove that element from the list
1839                     of active formatting elements and the stack of open
1840                     elements if the end tag didn't already remove it (it
1841                     might not have if the element is not in table scope). */
1842                     $leng = count($this->a_formatting);
1843
1844                     for($n = $leng - 1; $n >= 0; $n--) {
1845                         if($this->a_formatting[$n] === self::MARKER) {
1846                             break;
1847
1848                         } elseif($this->a_formatting[$n]->nodeName === 'a') {
1849                             $this->emitToken(array(
1850                                 'name' => 'a',
1851                                 'type' => HTML5::ENDTAG
1852                             ));
1853                             break;
1854                         }
1855                     }
1856
1857                     /* Reconstruct the active formatting elements, if any. */
1858                     $this->reconstructActiveFormattingElements();
1859
1860                     /* Insert an HTML element for the token. */
1861                     $el = $this->insertElement($token);
1862
1863                     /* Add that element to the list of active formatting
1864                     elements. */
1865                     $this->a_formatting[] = $el;
1866                 break;
1867
1868                 /* A start tag whose tag name is one of: "b", "big", "em", "font",
1869                 "i", "nobr", "s", "small", "strike", "strong", "tt", "u" */
1870                 case 'b': case 'big': case 'em': case 'font': case 'i':
1871                 case 'nobr': case 's': case 'small': case 'strike':
1872                 case 'strong': case 'tt': case 'u':
1873                     /* Reconstruct the active formatting elements, if any. */
1874                     $this->reconstructActiveFormattingElements();
1875
1876                     /* Insert an HTML element for the token. */
1877                     $el = $this->insertElement($token);
1878
1879                     /* Add that element to the list of active formatting
1880                     elements. */
1881                     $this->a_formatting[] = $el;
1882                 break;
1883
1884                 /* A start tag token whose tag name is "button" */
1885                 case 'button':
1886                     /* If the stack of open elements has a button element in scope,
1887                     then this is a parse error; act as if an end tag with the tag
1888                     name "button" had been seen, then reprocess the token. (We don't
1889                     do that. Unnecessary.) */
1890                     if($this->elementInScope('button')) {
1891                         $this->inBody(array(
1892                             'name' => 'button',
1893                             'type' => HTML5::ENDTAG
1894                         ));
1895                     }
1896
1897                     /* Reconstruct the active formatting elements, if any. */
1898                     $this->reconstructActiveFormattingElements();
1899
1900                     /* Insert an HTML element for the token. */
1901                     $this->insertElement($token);
1902
1903                     /* Insert a marker at the end of the list of active
1904                     formatting elements. */
1905                     $this->a_formatting[] = self::MARKER;
1906                 break;
1907
1908                 /* A start tag token whose tag name is one of: "marquee", "object" */
1909                 case 'marquee': case 'object':
1910                     /* Reconstruct the active formatting elements, if any. */
1911                     $this->reconstructActiveFormattingElements();
1912
1913                     /* Insert an HTML element for the token. */
1914                     $this->insertElement($token);
1915
1916                     /* Insert a marker at the end of the list of active
1917                     formatting elements. */
1918                     $this->a_formatting[] = self::MARKER;
1919                 break;
1920
1921                 /* A start tag token whose tag name is "xmp" */
1922                 case 'xmp':
1923                     /* Reconstruct the active formatting elements, if any. */
1924                     $this->reconstructActiveFormattingElements();
1925
1926                     /* Insert an HTML element for the token. */
1927                     $this->insertElement($token);
1928
1929                     /* Switch the content model flag to the CDATA state. */
1930                     return HTML5::CDATA;
1931                 break;
1932
1933                 /* A start tag whose tag name is "table" */
1934                 case 'table':
1935                     /* If the stack of open elements has a p element in scope,
1936                     then act as if an end tag with the tag name p had been seen. */
1937                     if($this->elementInScope('p')) {
1938                         $this->emitToken(array(
1939                             'name' => 'p',
1940                             'type' => HTML5::ENDTAG
1941                         ));
1942                     }
1943
1944                     /* Insert an HTML element for the token. */
1945                     $this->insertElement($token);
1946
1947                     /* Change the insertion mode to "in table". */
1948                     $this->mode = self::IN_TABLE;
1949                 break;
1950
1951                 /* A start tag whose tag name is one of: "area", "basefont",
1952                 "bgsound", "br", "embed", "img", "param", "spacer", "wbr" */
1953                 case 'area': case 'basefont': case 'bgsound': case 'br':
1954                 case 'embed': case 'img': case 'param': case 'spacer':
1955                 case 'wbr':
1956                     /* Reconstruct the active formatting elements, if any. */
1957                     $this->reconstructActiveFormattingElements();
1958
1959                     /* Insert an HTML element for the token. */
1960                     $this->insertElement($token);
1961
1962                     /* Immediately pop the current node off the stack of open elements. */
1963                     array_pop($this->stack);
1964                 break;
1965
1966                 /* A start tag whose tag name is "hr" */
1967                 case 'hr':
1968                     /* If the stack of open elements has a p element in scope,
1969                     then act as if an end tag with the tag name p had been seen. */
1970                     if($this->elementInScope('p')) {
1971                         $this->emitToken(array(
1972                             'name' => 'p',
1973                             'type' => HTML5::ENDTAG
1974                         ));
1975                     }
1976
1977                     /* Insert an HTML element for the token. */
1978                     $this->insertElement($token);
1979
1980                     /* Immediately pop the current node off the stack of open elements. */
1981                     array_pop($this->stack);
1982                 break;
1983
1984                 /* A start tag whose tag name is "image" */
1985                 case 'image':
1986                     /* Parse error. Change the token's tag name to "img" and
1987                     reprocess it. (Don't ask.) */
1988                     $token['name'] = 'img';
1989                     return $this->inBody($token);
1990                 break;
1991
1992                 /* A start tag whose tag name is "input" */
1993                 case 'input':
1994                     /* Reconstruct the active formatting elements, if any. */
1995                     $this->reconstructActiveFormattingElements();
1996
1997                     /* Insert an input element for the token. */
1998                     $element = $this->insertElement($token, false);
1999
2000                     /* If the form element pointer is not null, then associate the
2001                     input element with the form element pointed to by the form
2002                     element pointer. */
2003                     $this->form_pointer !== null
2004                         ? $this->form_pointer->appendChild($element)
2005                         : end($this->stack)->appendChild($element);
2006
2007                     /* Pop that input element off the stack of open elements. */
2008                     array_pop($this->stack);
2009                 break;
2010
2011                 /* A start tag whose tag name is "isindex" */
2012                 case 'isindex':
2013                     /* Parse error. */
2014                     // w/e
2015
2016                     /* If the form element pointer is not null,
2017                     then ignore the token. */
2018                     if($this->form_pointer === null) {
2019                         /* Act as if a start tag token with the tag name "form" had
2020                         been seen. */
2021                         $this->inBody(array(
2022                             'name' => 'body',
2023                             'type' => HTML5::STARTTAG,
2024                             'attr' => array()
2025                         ));
2026
2027                         /* Act as if a start tag token with the tag name "hr" had
2028                         been seen. */
2029                         $this->inBody(array(
2030                             'name' => 'hr',
2031                             'type' => HTML5::STARTTAG,
2032                             'attr' => array()
2033                         ));
2034
2035                         /* Act as if a start tag token with the tag name "p" had
2036                         been seen. */
2037                         $this->inBody(array(
2038                             'name' => 'p',
2039                             'type' => HTML5::STARTTAG,
2040                             'attr' => array()
2041                         ));
2042
2043                         /* Act as if a start tag token with the tag name "label"
2044                         had been seen. */
2045                         $this->inBody(array(
2046                             'name' => 'label',
2047                             'type' => HTML5::STARTTAG,
2048                             'attr' => array()
2049                         ));
2050
2051                         /* Act as if a stream of character tokens had been seen. */
2052                         $this->insertText('This is a searchable index. '.
2053                         'Insert your search keywords here: ');
2054
2055                         /* Act as if a start tag token with the tag name "input"
2056                         had been seen, with all the attributes from the "isindex"
2057                         token, except with the "name" attribute set to the value
2058                         "isindex" (ignoring any explicit "name" attribute). */
2059                         $attr = $token['attr'];
2060                         $attr[] = array('name' => 'name', 'value' => 'isindex');
2061
2062                         $this->inBody(array(
2063                             'name' => 'input',
2064                             'type' => HTML5::STARTTAG,
2065                             'attr' => $attr
2066                         ));
2067
2068                         /* Act as if a stream of character tokens had been seen
2069                         (see below for what they should say). */
2070                         $this->insertText('This is a searchable index. '.
2071                         'Insert your search keywords here: ');
2072
2073                         /* Act as if an end tag token with the tag name "label"
2074                         had been seen. */
2075                         $this->inBody(array(
2076                             'name' => 'label',
2077                             'type' => HTML5::ENDTAG
2078                         ));
2079
2080                         /* Act as if an end tag token with the tag name "p" had
2081                         been seen. */
2082                         $this->inBody(array(
2083                             'name' => 'p',
2084                             'type' => HTML5::ENDTAG
2085                         ));
2086
2087                         /* Act as if a start tag token with the tag name "hr" had
2088                         been seen. */
2089                         $this->inBody(array(
2090                             'name' => 'hr',
2091                             'type' => HTML5::ENDTAG
2092                         ));
2093
2094                         /* Act as if an end tag token with the tag name "form" had
2095                         been seen. */
2096                         $this->inBody(array(
2097                             'name' => 'form',
2098                             'type' => HTML5::ENDTAG
2099                         ));
2100                     }
2101                 break;
2102
2103                 /* A start tag whose tag name is "textarea" */
2104                 case 'textarea':
2105                     $this->insertElement($token);
2106
2107                     /* Switch the tokeniser's content model flag to the
2108                     RCDATA state. */
2109                     return HTML5::RCDATA;
2110                 break;
2111
2112                 /* A start tag whose tag name is one of: "iframe", "noembed",
2113                 "noframes" */
2114                 case 'iframe': case 'noembed': case 'noframes':
2115                     $this->insertElement($token);
2116
2117                     /* Switch the tokeniser's content model flag to the CDATA state. */
2118                     return HTML5::CDATA;
2119                 break;
2120
2121                 /* A start tag whose tag name is "select" */
2122                 case 'select':
2123                     /* Reconstruct the active formatting elements, if any. */
2124                     $this->reconstructActiveFormattingElements();
2125
2126                     /* Insert an HTML element for the token. */
2127                     $this->insertElement($token);
2128
2129                     /* Change the insertion mode to "in select". */
2130                     $this->mode = self::IN_SELECT;
2131                 break;
2132
2133                 /* A start or end tag whose tag name is one of: "caption", "col",
2134                 "colgroup", "frame", "frameset", "head", "option", "optgroup",
2135                 "tbody", "td", "tfoot", "th", "thead", "tr". */
2136                 case 'caption': case 'col': case 'colgroup': case 'frame':
2137                 case 'frameset': case 'head': case 'option': case 'optgroup':
2138                 case 'tbody': case 'td': case 'tfoot': case 'th': case 'thead':
2139                 case 'tr':
2140                     // Parse error. Ignore the token.
2141                 break;
2142
2143                 /* A start or end tag whose tag name is one of: "event-source",
2144                 "section", "nav", "article", "aside", "header", "footer",
2145                 "datagrid", "command" */
2146                 case 'event-source': case 'section': case 'nav': case 'article':
2147                 case 'aside': case 'header': case 'footer': case 'datagrid':
2148                 case 'command':
2149                     // Work in progress!
2150                 break;
2151
2152                 /* A start tag token not covered by the previous entries */
2153                 default:
2154                     /* Reconstruct the active formatting elements, if any. */
2155                     $this->reconstructActiveFormattingElements();
2156
2157                     $this->insertElement($token, true, true);
2158                 break;
2159             }
2160             break;
2161
2162             case HTML5::ENDTAG:
2163             switch($token['name']) {
2164                 /* An end tag with the tag name "body" */
2165                 case 'body':
2166                     /* If the second element in the stack of open elements is
2167                     not a body element, this is a parse error. Ignore the token.
2168                     (innerHTML case) */
2169                     if(count($this->stack) < 2 || $this->stack[1]->nodeName !== 'body') {
2170                         // Ignore.
2171
2172                     /* If the current node is not the body element, then this
2173                     is a parse error. */
2174                     } elseif(end($this->stack)->nodeName !== 'body') {
2175                         // Parse error.
2176                     }
2177
2178                     /* Change the insertion mode to "after body". */
2179                     $this->mode = self::AFTER_BODY;
2180                 break;
2181
2182                 /* An end tag with the tag name "html" */
2183                 case 'html':
2184                     /* Act as if an end tag with tag name "body" had been seen,
2185                     then, if that token wasn't ignored, reprocess the current
2186                     token. */
2187                     $this->inBody(array(
2188                         'name' => 'body',
2189                         'type' => HTML5::ENDTAG
2190                     ));
2191
2192                     return $this->afterBody($token);
2193                 break;
2194
2195                 /* An end tag whose tag name is one of: "address", "blockquote",
2196                 "center", "dir", "div", "dl", "fieldset", "listing", "menu",
2197                 "ol", "pre", "ul" */
2198                 case 'address': case 'blockquote': case 'center': case 'dir':
2199                 case 'div': case 'dl': case 'fieldset': case 'listing':
2200                 case 'menu': case 'ol': case 'pre': case 'ul':
2201                     /* If the stack of open elements has an element in scope
2202                     with the same tag name as that of the token, then generate
2203                     implied end tags. */
2204                     if($this->elementInScope($token['name'])) {
2205                         $this->generateImpliedEndTags();
2206
2207                         /* Now, if the current node is not an element with
2208                         the same tag name as that of the token, then this
2209                         is a parse error. */
2210                         // w/e
2211
2212                         /* If the stack of open elements has an element in
2213                         scope with the same tag name as that of the token,
2214                         then pop elements from this stack until an element
2215                         with that tag name has been popped from the stack. */
2216                         for($n = count($this->stack) - 1; $n >= 0; $n--) {
2217                             if($this->stack[$n]->nodeName === $token['name']) {
2218                                 $n = -1;
2219                             }
2220
2221                             array_pop($this->stack);
2222                         }
2223                     }
2224                 break;
2225
2226                 /* An end tag whose tag name is "form" */
2227                 case 'form':
2228                     /* If the stack of open elements has an element in scope
2229                     with the same tag name as that of the token, then generate
2230                     implied    end tags. */
2231                     if($this->elementInScope($token['name'])) {
2232                         $this->generateImpliedEndTags();
2233
2234                     }
2235
2236                     if(end($this->stack)->nodeName !== $token['name']) {
2237                         /* Now, if the current node is not an element with the
2238                         same tag name as that of the token, then this is a parse
2239                         error. */
2240                         // w/e
2241
2242                     } else {
2243                         /* Otherwise, if the current node is an element with
2244                         the same tag name as that of the token pop that element
2245                         from the stack. */
2246                         array_pop($this->stack);
2247                     }
2248
2249                     /* In any case, set the form element pointer to null. */
2250                     $this->form_pointer = null;
2251                 break;
2252
2253                 /* An end tag whose tag name is "p" */
2254                 case 'p':
2255                     /* If the stack of open elements has a p element in scope,
2256                     then generate implied end tags, except for p elements. */
2257                     if($this->elementInScope('p')) {
2258                         $this->generateImpliedEndTags(array('p'));
2259
2260                         /* If the current node is not a p element, then this is
2261                         a parse error. */
2262                         // k
2263
2264                         /* If the stack of open elements has a p element in
2265                         scope, then pop elements from this stack until the stack
2266                         no longer has a p element in scope. */
2267                         for($n = count($this->stack) - 1; $n >= 0; $n--) {
2268                             if($this->elementInScope('p')) {
2269                                 array_pop($this->stack);
2270
2271                             } else {
2272                                 break;
2273                             }
2274                         }
2275                     }
2276                 break;
2277
2278                 /* An end tag whose tag name is "dd", "dt", or "li" */
2279                 case 'dd': case 'dt': case 'li':
2280                     /* If the stack of open elements has an element in scope
2281                     whose tag name matches the tag name of the token, then
2282                     generate implied end tags, except for elements with the
2283                     same tag name as the token. */
2284                     if($this->elementInScope($token['name'])) {
2285                         $this->generateImpliedEndTags(array($token['name']));
2286
2287                         /* If the current node is not an element with the same
2288                         tag name as the token, then this is a parse error. */
2289                         // w/e
2290
2291                         /* If the stack of open elements has an element in scope
2292                         whose tag name matches the tag name of the token, then
2293                         pop elements from this stack until an element with that
2294                         tag name has been popped from the stack. */
2295                         for($n = count($this->stack) - 1; $n >= 0; $n--) {
2296                             if($this->stack[$n]->nodeName === $token['name']) {
2297                                 $n = -1;
2298                             }
2299
2300                             array_pop($this->stack);
2301                         }
2302                     }
2303                 break;
2304
2305                 /* An end tag whose tag name is one of: "h1", "h2", "h3", "h4",
2306                 "h5", "h6" */
2307                 case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6':
2308                     $elements = array('h1', 'h2', 'h3', 'h4', 'h5', 'h6');
2309
2310                     /* If the stack of open elements has in scope an element whose
2311                     tag name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
2312                     generate implied end tags. */
2313                     if($this->elementInScope($elements)) {
2314                         $this->generateImpliedEndTags();
2315
2316                         /* Now, if the current node is not an element with the same
2317                         tag name as that of the token, then this is a parse error. */
2318                         // w/e
2319
2320                         /* If the stack of open elements has in scope an element
2321                         whose tag name is one of "h1", "h2", "h3", "h4", "h5", or
2322                         "h6", then pop elements from the stack until an element
2323                         with one of those tag names has been popped from the stack. */
2324                         while($this->elementInScope($elements)) {
2325                             array_pop($this->stack);
2326                         }
2327                     }
2328                 break;
2329
2330                 /* An end tag whose tag name is one of: "a", "b", "big", "em",
2331                 "font", "i", "nobr", "s", "small", "strike", "strong", "tt", "u" */
2332                 case 'a': case 'b': case 'big': case 'em': case 'font':
2333                 case 'i': case 'nobr': case 's': case 'small': case 'strike':
2334                 case 'strong': case 'tt': case 'u':
2335                     /* 1. Let the formatting element be the last element in
2336                     the list of active formatting elements that:
2337                         * is between the end of the list and the last scope
2338                         marker in the list, if any, or the start of the list
2339                         otherwise, and
2340                         * has the same tag name as the token.
2341                     */
2342                     while(true) {
2343                         for($a = count($this->a_formatting) - 1; $a >= 0; $a--) {
2344                             if($this->a_formatting[$a] === self::MARKER) {
2345                                 break;
2346
2347                             } elseif($this->a_formatting[$a]->tagName === $token['name']) {
2348                                 $formatting_element = $this->a_formatting[$a];
2349                                 $in_stack = in_array($formatting_element, $this->stack, true);
2350                                 $fe_af_pos = $a;
2351                                 break;
2352                             }
2353                         }
2354
2355                         /* If there is no such node, or, if that node is
2356                         also in the stack of open elements but the element
2357                         is not in scope, then this is a parse error. Abort
2358                         these steps. The token is ignored. */
2359                         if(!isset($formatting_element) || ($in_stack &&
2360                         !$this->elementInScope($token['name']))) {
2361                             break;
2362
2363                         /* Otherwise, if there is such a node, but that node
2364                         is not in the stack of open elements, then this is a
2365                         parse error; remove the element from the list, and
2366                         abort these steps. */
2367                         } elseif(isset($formatting_element) && !$in_stack) {
2368                             unset($this->a_formatting[$fe_af_pos]);
2369                             $this->a_formatting = array_merge($this->a_formatting);
2370                             break;
2371                         }
2372
2373                         /* 2. Let the furthest block be the topmost node in the
2374                         stack of open elements that is lower in the stack
2375                         than the formatting element, and is not an element in
2376                         the phrasing or formatting categories. There might
2377                         not be one. */
2378                         $fe_s_pos = array_search($formatting_element, $this->stack, true);
2379                         $length = count($this->stack);
2380
2381                         for($s = $fe_s_pos + 1; $s < $length; $s++) {
2382                             $category = $this->getElementCategory($this->stack[$s]->nodeName);
2383
2384                             if($category !== self::PHRASING && $category !== self::FORMATTING) {
2385                                 $furthest_block = $this->stack[$s];
2386                             }
2387                         }
2388
2389                         /* 3. If there is no furthest block, then the UA must
2390                         skip the subsequent steps and instead just pop all
2391                         the nodes from the bottom of the stack of open
2392                         elements, from the current node up to the formatting
2393                         element, and remove the formatting element from the
2394                         list of active formatting elements. */
2395                         if(!isset($furthest_block)) {
2396                             for($n = $length - 1; $n >= $fe_s_pos; $n--) {
2397                                 array_pop($this->stack);
2398                             }
2399
2400                             unset($this->a_formatting[$fe_af_pos]);
2401                             $this->a_formatting = array_merge($this->a_formatting);
2402                             break;
2403                         }
2404
2405                         /* 4. Let the common ancestor be the element
2406                         immediately above the formatting element in the stack
2407                         of open elements. */
2408                         $common_ancestor = $this->stack[$fe_s_pos - 1];
2409
2410                         /* 5. If the furthest block has a parent node, then
2411                         remove the furthest block from its parent node. */
2412                         if($furthest_block->parentNode !== null) {
2413                             $furthest_block->parentNode->removeChild($furthest_block);
2414                         }
2415
2416                         /* 6. Let a bookmark note the position of the
2417                         formatting element in the list of active formatting
2418                         elements relative to the elements on either side
2419                         of it in the list. */
2420                         $bookmark = $fe_af_pos;
2421
2422                         /* 7. Let node and last node  be the furthest block.
2423                         Follow these steps: */
2424                         $node = $furthest_block;
2425                         $last_node = $furthest_block;
2426
2427                         while(true) {
2428                             for($n = array_search($node, $this->stack, true) - 1; $n >= 0; $n--) {
2429                                 /* 7.1 Let node be the element immediately
2430                                 prior to node in the stack of open elements. */
2431                                 $node = $this->stack[$n];
2432
2433                                 /* 7.2 If node is not in the list of active
2434                                 formatting elements, then remove node from
2435                                 the stack of open elements and then go back
2436                                 to step 1. */
2437                                 if(!in_array($node, $this->a_formatting, true)) {
2438                                     unset($this->stack[$n]);
2439                                     $this->stack = array_merge($this->stack);
2440
2441                                 } else {
2442                                     break;
2443                                 }
2444                             }
2445
2446                             /* 7.3 Otherwise, if node is the formatting
2447                             element, then go to the next step in the overall
2448                             algorithm. */
2449                             if($node === $formatting_element) {
2450                                 break;
2451
2452                             /* 7.4 Otherwise, if last node is the furthest
2453                             block, then move the aforementioned bookmark to
2454                             be immediately after the node in the list of
2455                             active formatting elements. */
2456                             } elseif($last_node === $furthest_block) {
2457                                 $bookmark = array_search($node, $this->a_formatting, true) + 1;
2458                             }
2459
2460                             /* 7.5 If node has any children, perform a
2461                             shallow clone of node, replace the entry for
2462                             node in the list of active formatting elements
2463                             with an entry for the clone, replace the entry
2464                             for node in the stack of open elements with an
2465                             entry for the clone, and let node be the clone. */
2466                             if($node->hasChildNodes()) {
2467                                 $clone = $node->cloneNode();
2468                                 $s_pos = array_search($node, $this->stack, true);
2469                                 $a_pos = array_search($node, $this->a_formatting, true);
2470
2471                                 $this->stack[$s_pos] = $clone;
2472                                 $this->a_formatting[$a_pos] = $clone;
2473                                 $node = $clone;
2474                             }
2475
2476                             /* 7.6 Insert last node into node, first removing
2477                             it from its previous parent node if any. */
2478                             if($last_node->parentNode !== null) {
2479                                 $last_node->parentNode->removeChild($last_node);
2480                             }
2481
2482                             $node->appendChild($last_node);
2483
2484                             /* 7.7 Let last node be node. */
2485                             $last_node = $node;
2486                         }
2487
2488                         /* 8. Insert whatever last node ended up being in
2489                         the previous step into the common ancestor node,
2490                         first removing it from its previous parent node if
2491                         any. */
2492                         if($last_node->parentNode !== null) {
2493                             $last_node->parentNode->removeChild($last_node);
2494                         }
2495
2496                         $common_ancestor->appendChild($last_node);
2497
2498                         /* 9. Perform a shallow clone of the formatting
2499                         element. */
2500                         $clone = $formatting_element->cloneNode();
2501
2502                         /* 10. Take all of the child nodes of the furthest
2503                         block and append them to the clone created in the
2504                         last step. */
2505                         while($furthest_block->hasChildNodes()) {
2506                             $child = $furthest_block->firstChild;
2507                             $furthest_block->removeChild($child);
2508                             $clone->appendChild($child);
2509                         }
2510
2511                         /* 11. Append that clone to the furthest block. */
2512                         $furthest_block->appendChild($clone);
2513
2514                         /* 12. Remove the formatting element from the list
2515                         of active formatting elements, and insert the clone
2516                         into the list of active formatting elements at the
2517                         position of the aforementioned bookmark. */
2518                         $fe_af_pos = array_search($formatting_element, $this->a_formatting, true);
2519                         unset($this->a_formatting[$fe_af_pos]);
2520                         $this->a_formatting = array_merge($this->a_formatting);
2521
2522                         $af_part1 = array_slice($this->a_formatting, 0, $bookmark - 1);
2523                         $af_part2 = array_slice($this->a_formatting, $bookmark, count($this->a_formatting));
2524                         $this->a_formatting = array_merge($af_part1, array($clone), $af_part2);
2525
2526                         /* 13. Remove the formatting element from the stack
2527                         of open elements, and insert the clone into the stack
2528                         of open elements immediately after (i.e. in a more
2529                         deeply nested position than) the position of the
2530                         furthest block in that stack. */
2531                         $fe_s_pos = array_search($formatting_element, $this->stack, true);
2532                         $fb_s_pos = array_search($furthest_block, $this->stack, true);
2533                         unset($this->stack[$fe_s_pos]);
2534
2535                         $s_part1 = array_slice($this->stack, 0, $fb_s_pos);
2536                         $s_part2 = array_slice($this->stack, $fb_s_pos + 1, count($this->stack));
2537                         $this->stack = array_merge($s_part1, array($clone), $s_part2);
2538
2539                         /* 14. Jump back to step 1 in this series of steps. */
2540                         unset($formatting_element, $fe_af_pos, $fe_s_pos, $furthest_block);
2541                     }
2542                 break;
2543
2544                 /* An end tag token whose tag name is one of: "button",
2545                 "marquee", "object" */
2546                 case 'button': case 'marquee': case 'object':
2547                     /* If the stack of open elements has an element in scope whose
2548                     tag name matches the tag name of the token, then generate implied
2549                     tags. */
2550                     if($this->elementInScope($token['name'])) {
2551                         $this->generateImpliedEndTags();
2552
2553                         /* Now, if the current node is not an element with the same
2554                         tag name as the token, then this is a parse error. */
2555                         // k
2556
2557                         /* Now, if the stack of open elements has an element in scope
2558                         whose tag name matches the tag name of the token, then pop
2559                         elements from the stack until that element has been popped from
2560                         the stack, and clear the list of active formatting elements up
2561                         to the last marker. */
2562                         for($n = count($this->stack) - 1; $n >= 0; $n--) {
2563                             if($this->stack[$n]->nodeName === $token['name']) {
2564                                 $n = -1;
2565                             }
2566
2567                             array_pop($this->stack);
2568                         }
2569
2570                         $marker = end(array_keys($this->a_formatting, self::MARKER, true));
2571
2572                         for($n = count($this->a_formatting) - 1; $n > $marker; $n--) {
2573                             array_pop($this->a_formatting);
2574                         }
2575                     }
2576                 break;
2577
2578                 /* Or an end tag whose tag name is one of: "area", "basefont",
2579                 "bgsound", "br", "embed", "hr", "iframe", "image", "img",
2580                 "input", "isindex", "noembed", "noframes", "param", "select",
2581                 "spacer", "table", "textarea", "wbr" */
2582                 case 'area': case 'basefont': case 'bgsound': case 'br':
2583                 case 'embed': case 'hr': case 'iframe': case 'image':
2584                 case 'img': case 'input': case 'isindex': case 'noembed':
2585                 case 'noframes': case 'param': case 'select': case 'spacer':
2586                 case 'table': case 'textarea': case 'wbr':
2587                     // Parse error. Ignore the token.
2588                 break;
2589
2590                 /* An end tag token not covered by the previous entries */
2591                 default:
2592                     for($n = count($this->stack) - 1; $n >= 0; $n--) {
2593                         /* Initialise node to be the current node (the bottommost
2594                         node of the stack). */
2595                         $node = end($this->stack);
2596
2597                         /* If node has the same tag name as the end tag token,
2598                         then: */
2599                         if($token['name'] === $node->nodeName) {
2600                             /* Generate implied end tags. */
2601                             $this->generateImpliedEndTags();
2602
2603                             /* If the tag name of the end tag token does not
2604                             match the tag name of the current node, this is a
2605                             parse error. */
2606                             // k
2607
2608                             /* Pop all the nodes from the current node up to
2609                             node, including node, then stop this algorithm. */
2610                             for($x = count($this->stack) - $n; $x >= $n; $x--) {
2611                                 array_pop($this->stack);
2612                             }
2613
2614                         } else {
2615                             $category = $this->getElementCategory($node);
2616
2617                             if($category !== self::SPECIAL && $category !== self::SCOPING) {
2618                                 /* Otherwise, if node is in neither the formatting
2619                                 category nor the phrasing category, then this is a
2620                                 parse error. Stop this algorithm. The end tag token
2621                                 is ignored. */
2622                                 return false;
2623                             }
2624                         }
2625                     }
2626                 break;
2627             }
2628             break;
2629         }
2630     }
2631
2632     private function inTable($token) {
2633         $clear = array('html', 'table');
2634
2635         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
2636         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
2637         or U+0020 SPACE */
2638         if($token['type'] === HTML5::CHARACTR &&
2639         preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
2640             /* Append the character to the current node. */
2641             $text = $this->dom->createTextNode($token['data']);
2642             end($this->stack)->appendChild($text);
2643
2644         /* A comment token */
2645         } elseif($token['type'] === HTML5::COMMENT) {
2646             /* Append a Comment node to the current node with the data
2647             attribute set to the data given in the comment token. */
2648             $comment = $this->dom->createComment($token['data']);
2649             end($this->stack)->appendChild($comment);
2650
2651         /* A start tag whose tag name is "caption" */
2652         } elseif($token['type'] === HTML5::STARTTAG &&
2653         $token['name'] === 'caption') {
2654             /* Clear the stack back to a table context. */
2655             $this->clearStackToTableContext($clear);
2656
2657             /* Insert a marker at the end of the list of active
2658             formatting elements. */
2659             $this->a_formatting[] = self::MARKER;
2660
2661             /* Insert an HTML element for the token, then switch the
2662             insertion mode to "in caption". */
2663             $this->insertElement($token);
2664             $this->mode = self::IN_CAPTION;
2665
2666         /* A start tag whose tag name is "colgroup" */
2667         } elseif($token['type'] === HTML5::STARTTAG &&
2668         $token['name'] === 'colgroup') {
2669             /* Clear the stack back to a table context. */
2670             $this->clearStackToTableContext($clear);
2671
2672             /* Insert an HTML element for the token, then switch the
2673             insertion mode to "in column group". */
2674             $this->insertElement($token);
2675             $this->mode = self::IN_CGROUP;
2676
2677         /* A start tag whose tag name is "col" */
2678         } elseif($token['type'] === HTML5::STARTTAG &&
2679         $token['name'] === 'col') {
2680             $this->inTable(array(
2681                 'name' => 'colgroup',
2682                 'type' => HTML5::STARTTAG,
2683                 'attr' => array()
2684             ));
2685
2686             $this->inColumnGroup($token);
2687
2688         /* A start tag whose tag name is one of: "tbody", "tfoot", "thead" */
2689         } elseif($token['type'] === HTML5::STARTTAG && in_array($token['name'],
2690         array('tbody', 'tfoot', 'thead'))) {
2691             /* Clear the stack back to a table context. */
2692             $this->clearStackToTableContext($clear);
2693
2694             /* Insert an HTML element for the token, then switch the insertion
2695             mode to "in table body". */
2696             $this->insertElement($token);
2697             $this->mode = self::IN_TBODY;
2698
2699         /* A start tag whose tag name is one of: "td", "th", "tr" */
2700         } elseif($token['type'] === HTML5::STARTTAG &&
2701         in_array($token['name'], array('td', 'th', 'tr'))) {
2702             /* Act as if a start tag token with the tag name "tbody" had been
2703             seen, then reprocess the current token. */
2704             $this->inTable(array(
2705                 'name' => 'tbody',
2706                 'type' => HTML5::STARTTAG,
2707                 'attr' => array()
2708             ));
2709
2710             return $this->inTableBody($token);
2711
2712         /* A start tag whose tag name is "table" */
2713         } elseif($token['type'] === HTML5::STARTTAG &&
2714         $token['name'] === 'table') {
2715             /* Parse error. Act as if an end tag token with the tag name "table"
2716             had been seen, then, if that token wasn't ignored, reprocess the
2717             current token. */
2718             $this->inTable(array(
2719                 'name' => 'table',
2720                 'type' => HTML5::ENDTAG
2721             ));
2722
2723             return $this->mainPhase($token);
2724
2725         /* An end tag whose tag name is "table" */
2726         } elseif($token['type'] === HTML5::ENDTAG &&
2727         $token['name'] === 'table') {
2728             /* If the stack of open elements does not have an element in table
2729             scope with the same tag name as the token, this is a parse error.
2730             Ignore the token. (innerHTML case) */
2731             if(!$this->elementInScope($token['name'], true)) {
2732                 return false;
2733
2734             /* Otherwise: */
2735             } else {
2736                 /* Generate implied end tags. */
2737                 $this->generateImpliedEndTags();
2738
2739                 /* Now, if the current node is not a table element, then this
2740                 is a parse error. */
2741                 // w/e
2742
2743                 /* Pop elements from this stack until a table element has been
2744                 popped from the stack. */
2745                 while(true) {
2746                     $current = end($this->stack)->nodeName;
2747                     array_pop($this->stack);
2748
2749                     if($current === 'table') {
2750                         break;
2751                     }
2752                 }
2753
2754                 /* Reset the insertion mode appropriately. */
2755                 $this->resetInsertionMode();
2756             }
2757
2758         /* An end tag whose tag name is one of: "body", "caption", "col",
2759         "colgroup", "html", "tbody", "td", "tfoot", "th", "thead", "tr" */
2760         } elseif($token['type'] === HTML5::ENDTAG && in_array($token['name'],
2761         array('body', 'caption', 'col', 'colgroup', 'html', 'tbody', 'td',
2762         'tfoot', 'th', 'thead', 'tr'))) {
2763             // Parse error. Ignore the token.
2764
2765         /* Anything else */
2766         } else {
2767             /* Parse error. Process the token as if the insertion mode was "in
2768             body", with the following exception: */
2769
2770             /* If the current node is a table, tbody, tfoot, thead, or tr
2771             element, then, whenever a node would be inserted into the current
2772             node, it must instead be inserted into the foster parent element. */
2773             if(in_array(end($this->stack)->nodeName,
2774             array('table', 'tbody', 'tfoot', 'thead', 'tr'))) {
2775                 /* The foster parent element is the parent element of the last
2776                 table element in the stack of open elements, if there is a
2777                 table element and it has such a parent element. If there is no
2778                 table element in the stack of open elements (innerHTML case),
2779                 then the foster parent element is the first element in the
2780                 stack of open elements (the html  element). Otherwise, if there
2781                 is a table element in the stack of open elements, but the last
2782                 table element in the stack of open elements has no parent, or
2783                 its parent node is not an element, then the foster parent
2784                 element is the element before the last table element in the
2785                 stack of open elements. */
2786                 for($n = count($this->stack) - 1; $n >= 0; $n--) {
2787                     if($this->stack[$n]->nodeName === 'table') {
2788                         $table = $this->stack[$n];
2789                         break;
2790                     }
2791                 }
2792
2793                 if(isset($table) && $table->parentNode !== null) {
2794                     $this->foster_parent = $table->parentNode;
2795
2796                 } elseif(!isset($table)) {
2797                     $this->foster_parent = $this->stack[0];
2798
2799                 } elseif(isset($table) && ($table->parentNode === null ||
2800                 $table->parentNode->nodeType !== XML_ELEMENT_NODE)) {
2801                     $this->foster_parent = $this->stack[$n - 1];
2802                 }
2803             }
2804
2805             $this->inBody($token);
2806         }
2807     }
2808
2809     private function inCaption($token) {
2810         /* An end tag whose tag name is "caption" */
2811         if($token['type'] === HTML5::ENDTAG && $token['name'] === 'caption') {
2812             /* If the stack of open elements does not have an element in table
2813             scope with the same tag name as the token, this is a parse error.
2814             Ignore the token. (innerHTML case) */
2815             if(!$this->elementInScope($token['name'], true)) {
2816                 // Ignore
2817
2818             /* Otherwise: */
2819             } else {
2820                 /* Generate implied end tags. */
2821                 $this->generateImpliedEndTags();
2822
2823                 /* Now, if the current node is not a caption element, then this
2824                 is a parse error. */
2825                 // w/e
2826
2827                 /* Pop elements from this stack until a caption element has
2828                 been popped from the stack. */
2829                 while(true) {
2830                     $node = end($this->stack)->nodeName;
2831                     array_pop($this->stack);
2832
2833                     if($node === 'caption') {
2834                         break;
2835                     }
2836                 }
2837
2838                 /* Clear the list of active formatting elements up to the last
2839                 marker. */
2840                 $this->clearTheActiveFormattingElementsUpToTheLastMarker();
2841
2842                 /* Switch the insertion mode to "in table". */
2843                 $this->mode = self::IN_TABLE;
2844             }
2845
2846         /* A start tag whose tag name is one of: "caption", "col", "colgroup",
2847         "tbody", "td", "tfoot", "th", "thead", "tr", or an end tag whose tag
2848         name is "table" */
2849         } elseif(($token['type'] === HTML5::STARTTAG && in_array($token['name'],
2850         array('caption', 'col', 'colgroup', 'tbody', 'td', 'tfoot', 'th',
2851         'thead', 'tr'))) || ($token['type'] === HTML5::ENDTAG &&
2852         $token['name'] === 'table')) {
2853             /* Parse error. Act as if an end tag with the tag name "caption"
2854             had been seen, then, if that token wasn't ignored, reprocess the
2855             current token. */
2856             $this->inCaption(array(
2857                 'name' => 'caption',
2858                 'type' => HTML5::ENDTAG
2859             ));
2860
2861             return $this->inTable($token);
2862
2863         /* An end tag whose tag name is one of: "body", "col", "colgroup",
2864         "html", "tbody", "td", "tfoot", "th", "thead", "tr" */
2865         } elseif($token['type'] === HTML5::ENDTAG && in_array($token['name'],
2866         array('body', 'col', 'colgroup', 'html', 'tbody', 'tfoot', 'th',
2867         'thead', 'tr'))) {
2868             // Parse error. Ignore the token.
2869
2870         /* Anything else */
2871         } else {
2872             /* Process the token as if the insertion mode was "in body". */
2873             $this->inBody($token);
2874         }
2875     }
2876
2877     private function inColumnGroup($token) {
2878         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
2879         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
2880         or U+0020 SPACE */
2881         if($token['type'] === HTML5::CHARACTR &&
2882         preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
2883             /* Append the character to the current node. */
2884             $text = $this->dom->createTextNode($token['data']);
2885             end($this->stack)->appendChild($text);
2886
2887         /* A comment token */
2888         } elseif($token['type'] === HTML5::COMMENT) {
2889             /* Append a Comment node to the current node with the data
2890             attribute set to the data given in the comment token. */
2891             $comment = $this->dom->createComment($token['data']);
2892             end($this->stack)->appendChild($comment);
2893
2894         /* A start tag whose tag name is "col" */
2895         } elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'col') {
2896             /* Insert a col element for the token. Immediately pop the current
2897             node off the stack of open elements. */
2898             $this->insertElement($token);
2899             array_pop($this->stack);
2900
2901         /* An end tag whose tag name is "colgroup" */
2902         } elseif($token['type'] === HTML5::ENDTAG &&
2903         $token['name'] === 'colgroup') {
2904             /* If the current node is the root html element, then this is a
2905             parse error, ignore the token. (innerHTML case) */
2906             if(end($this->stack)->nodeName === 'html') {
2907                 // Ignore
2908
2909             /* Otherwise, pop the current node (which will be a colgroup
2910             element) from the stack of open elements. Switch the insertion
2911             mode to "in table". */
2912             } else {
2913                 array_pop($this->stack);
2914                 $this->mode = self::IN_TABLE;
2915             }
2916
2917         /* An end tag whose tag name is "col" */
2918         } elseif($token['type'] === HTML5::ENDTAG && $token['name'] === 'col') {
2919             /* Parse error. Ignore the token. */
2920
2921         /* Anything else */
2922         } else {
2923             /* Act as if an end tag with the tag name "colgroup" had been seen,
2924             and then, if that token wasn't ignored, reprocess the current token. */
2925             $this->inColumnGroup(array(
2926                 'name' => 'colgroup',
2927                 'type' => HTML5::ENDTAG
2928             ));
2929
2930             return $this->inTable($token);
2931         }
2932     }
2933
2934     private function inTableBody($token) {
2935         $clear = array('tbody', 'tfoot', 'thead', 'html');
2936
2937         /* A start tag whose tag name is "tr" */
2938         if($token['type'] === HTML5::STARTTAG && $token['name'] === 'tr') {
2939             /* Clear the stack back to a table body context. */
2940             $this->clearStackToTableContext($clear);
2941
2942             /* Insert a tr element for the token, then switch the insertion
2943             mode to "in row". */
2944             $this->insertElement($token);
2945             $this->mode = self::IN_ROW;
2946
2947         /* A start tag whose tag name is one of: "th", "td" */
2948         } elseif($token['type'] === HTML5::STARTTAG &&
2949         ($token['name'] === 'th' ||    $token['name'] === 'td')) {
2950             /* Parse error. Act as if a start tag with the tag name "tr" had
2951             been seen, then reprocess the current token. */
2952             $this->inTableBody(array(
2953                 'name' => 'tr',
2954                 'type' => HTML5::STARTTAG,
2955                 'attr' => array()
2956             ));
2957
2958             return $this->inRow($token);
2959
2960         /* An end tag whose tag name is one of: "tbody", "tfoot", "thead" */
2961         } elseif($token['type'] === HTML5::ENDTAG &&
2962         in_array($token['name'], array('tbody', 'tfoot', 'thead'))) {
2963             /* If the stack of open elements does not have an element in table
2964             scope with the same tag name as the token, this is a parse error.
2965             Ignore the token. */
2966             if(!$this->elementInScope($token['name'], true)) {
2967                 // Ignore
2968
2969             /* Otherwise: */
2970             } else {
2971                 /* Clear the stack back to a table body context. */
2972                 $this->clearStackToTableContext($clear);
2973
2974                 /* Pop the current node from the stack of open elements. Switch
2975                 the insertion mode to "in table". */
2976                 array_pop($this->stack);
2977                 $this->mode = self::IN_TABLE;
2978             }
2979
2980         /* A start tag whose tag name is one of: "caption", "col", "colgroup",
2981         "tbody", "tfoot", "thead", or an end tag whose tag name is "table" */
2982         } elseif(($token['type'] === HTML5::STARTTAG && in_array($token['name'],
2983         array('caption', 'col', 'colgroup', 'tbody', 'tfoor', 'thead'))) ||
2984         ($token['type'] === HTML5::STARTTAG && $token['name'] === 'table')) {
2985             /* If the stack of open elements does not have a tbody, thead, or
2986             tfoot element in table scope, this is a parse error. Ignore the
2987             token. (innerHTML case) */
2988             if(!$this->elementInScope(array('tbody', 'thead', 'tfoot'), true)) {
2989                 // Ignore.
2990
2991             /* Otherwise: */
2992             } else {
2993                 /* Clear the stack back to a table body context. */
2994                 $this->clearStackToTableContext($clear);
2995
2996                 /* Act as if an end tag with the same tag name as the current
2997                 node ("tbody", "tfoot", or "thead") had been seen, then
2998                 reprocess the current token. */
2999                 $this->inTableBody(array(
3000                     'name' => end($this->stack)->nodeName,
3001                     'type' => HTML5::ENDTAG
3002                 ));
3003
3004                 return $this->mainPhase($token);
3005             }
3006
3007         /* An end tag whose tag name is one of: "body", "caption", "col",
3008         "colgroup", "html", "td", "th", "tr" */
3009         } elseif($token['type'] === HTML5::ENDTAG && in_array($token['name'],
3010         array('body', 'caption', 'col', 'colgroup', 'html', 'td', 'th', 'tr'))) {
3011             /* Parse error. Ignore the token. */
3012
3013         /* Anything else */
3014         } else {
3015             /* Process the token as if the insertion mode was "in table". */
3016             $this->inTable($token);
3017         }
3018     }
3019
3020     private function inRow($token) {
3021         $clear = array('tr', 'html');
3022
3023         /* A start tag whose tag name is one of: "th", "td" */
3024         if($token['type'] === HTML5::STARTTAG &&
3025         ($token['name'] === 'th' || $token['name'] === 'td')) {
3026             /* Clear the stack back to a table row context. */
3027             $this->clearStackToTableContext($clear);
3028
3029             /* Insert an HTML element for the token, then switch the insertion
3030             mode to "in cell". */
3031             $this->insertElement($token);
3032             $this->mode = self::IN_CELL;
3033
3034             /* Insert a marker at the end of the list of active formatting
3035             elements. */
3036             $this->a_formatting[] = self::MARKER;
3037
3038         /* An end tag whose tag name is "tr" */
3039         } elseif($token['type'] === HTML5::ENDTAG && $token['name'] === 'tr') {
3040             /* If the stack of open elements does not have an element in table
3041             scope with the same tag name as the token, this is a parse error.
3042             Ignore the token. (innerHTML case) */
3043             if(!$this->elementInScope($token['name'], true)) {
3044                 // Ignore.
3045
3046             /* Otherwise: */
3047             } else {
3048                 /* Clear the stack back to a table row context. */
3049                 $this->clearStackToTableContext($clear);
3050
3051                 /* Pop the current node (which will be a tr element) from the
3052                 stack of open elements. Switch the insertion mode to "in table
3053                 body". */
3054                 array_pop($this->stack);
3055                 $this->mode = self::IN_TBODY;
3056             }
3057
3058         /* A start tag whose tag name is one of: "caption", "col", "colgroup",
3059         "tbody", "tfoot", "thead", "tr" or an end tag whose tag name is "table" */
3060         } elseif($token['type'] === HTML5::STARTTAG && in_array($token['name'],
3061         array('caption', 'col', 'colgroup', 'tbody', 'tfoot', 'thead', 'tr'))) {
3062             /* Act as if an end tag with the tag name "tr" had been seen, then,
3063             if that token wasn't ignored, reprocess the current token. */
3064             $this->inRow(array(
3065                 'name' => 'tr',
3066                 'type' => HTML5::ENDTAG
3067             ));
3068
3069             return $this->inCell($token);
3070
3071         /* An end tag whose tag name is one of: "tbody", "tfoot", "thead" */
3072         } elseif($token['type'] === HTML5::ENDTAG &&
3073         in_array($token['name'], array('tbody', 'tfoot', 'thead'))) {
3074             /* If the stack of open elements does not have an element in table
3075             scope with the same tag name as the token, this is a parse error.
3076             Ignore the token. */
3077             if(!$this->elementInScope($token['name'], true)) {
3078                 // Ignore.
3079
3080             /* Otherwise: */
3081             } else {
3082                 /* Otherwise, act as if an end tag with the tag name "tr" had
3083                 been seen, then reprocess the current token. */
3084                 $this->inRow(array(
3085                     'name' => 'tr',
3086                     'type' => HTML5::ENDTAG
3087                 ));
3088
3089                 return $this->inCell($token);
3090             }
3091
3092         /* An end tag whose tag name is one of: "body", "caption", "col",
3093         "colgroup", "html", "td", "th" */
3094         } elseif($token['type'] === HTML5::ENDTAG && in_array($token['name'],
3095         array('body', 'caption', 'col', 'colgroup', 'html', 'td', 'th', 'tr'))) {
3096             /* Parse error. Ignore the token. */
3097
3098         /* Anything else */
3099         } else {
3100             /* Process the token as if the insertion mode was "in table". */
3101             $this->inTable($token);
3102         }
3103     }
3104
3105     private function inCell($token) {
3106         /* An end tag whose tag name is one of: "td", "th" */
3107         if($token['type'] === HTML5::ENDTAG &&
3108         ($token['name'] === 'td' || $token['name'] === 'th')) {
3109             /* If the stack of open elements does not have an element in table
3110             scope with the same tag name as that of the token, then this is a
3111             parse error and the token must be ignored. */
3112             if(!$this->elementInScope($token['name'], true)) {
3113                 // Ignore.
3114
3115             /* Otherwise: */
3116             } else {
3117                 /* Generate implied end tags, except for elements with the same
3118                 tag name as the token. */
3119                 $this->generateImpliedEndTags(array($token['name']));
3120
3121                 /* Now, if the current node is not an element with the same tag
3122                 name as the token, then this is a parse error. */
3123                 // k
3124
3125                 /* Pop elements from this stack until an element with the same
3126                 tag name as the token has been popped from the stack. */
3127                 while(true) {
3128                     $node = end($this->stack)->nodeName;
3129                     array_pop($this->stack);
3130
3131                     if($node === $token['name']) {
3132                         break;
3133                     }
3134                 }
3135
3136                 /* Clear the list of active formatting elements up to the last
3137                 marker. */
3138                 $this->clearTheActiveFormattingElementsUpToTheLastMarker();
3139
3140                 /* Switch the insertion mode to "in row". (The current node
3141                 will be a tr element at this point.) */
3142                 $this->mode = self::IN_ROW;
3143             }
3144
3145         /* A start tag whose tag name is one of: "caption", "col", "colgroup",
3146         "tbody", "td", "tfoot", "th", "thead", "tr" */
3147         } elseif($token['type'] === HTML5::STARTTAG && in_array($token['name'],
3148         array('caption', 'col', 'colgroup', 'tbody', 'td', 'tfoot', 'th',
3149         'thead', 'tr'))) {
3150             /* If the stack of open elements does not have a td or th element
3151             in table scope, then this is a parse error; ignore the token.
3152             (innerHTML case) */
3153             if(!$this->elementInScope(array('td', 'th'), true)) {
3154                 // Ignore.
3155
3156             /* Otherwise, close the cell (see below) and reprocess the current
3157             token. */
3158             } else {
3159                 $this->closeCell();
3160                 return $this->inRow($token);
3161             }
3162
3163         /* A start tag whose tag name is one of: "caption", "col", "colgroup",
3164         "tbody", "td", "tfoot", "th", "thead", "tr" */
3165         } elseif($token['type'] === HTML5::STARTTAG && in_array($token['name'],
3166         array('caption', 'col', 'colgroup', 'tbody', 'td', 'tfoot', 'th',
3167         'thead', 'tr'))) {
3168             /* If the stack of open elements does not have a td or th element
3169             in table scope, then this is a parse error; ignore the token.
3170             (innerHTML case) */
3171             if(!$this->elementInScope(array('td', 'th'), true)) {
3172                 // Ignore.
3173
3174             /* Otherwise, close the cell (see below) and reprocess the current
3175             token. */
3176             } else {
3177                 $this->closeCell();
3178                 return $this->inRow($token);
3179             }
3180
3181         /* An end tag whose tag name is one of: "body", "caption", "col",
3182         "colgroup", "html" */
3183         } elseif($token['type'] === HTML5::ENDTAG && in_array($token['name'],
3184         array('body', 'caption', 'col', 'colgroup', 'html'))) {
3185             /* Parse error. Ignore the token. */
3186
3187         /* An end tag whose tag name is one of: "table", "tbody", "tfoot",
3188         "thead", "tr" */
3189         } elseif($token['type'] === HTML5::ENDTAG && in_array($token['name'],
3190         array('table', 'tbody', 'tfoot', 'thead', 'tr'))) {
3191             /* If the stack of open elements does not have an element in table
3192             scope with the same tag name as that of the token (which can only
3193             happen for "tbody", "tfoot" and "thead", or, in the innerHTML case),
3194             then this is a parse error and the token must be ignored. */
3195             if(!$this->elementInScope($token['name'], true)) {
3196                 // Ignore.
3197
3198             /* Otherwise, close the cell (see below) and reprocess the current
3199             token. */
3200             } else {
3201                 $this->closeCell();
3202                 return $this->inRow($token);
3203             }
3204
3205         /* Anything else */
3206         } else {
3207             /* Process the token as if the insertion mode was "in body". */
3208             $this->inBody($token);
3209         }
3210     }
3211
3212     private function inSelect($token) {
3213         /* Handle the token as follows: */
3214
3215         /* A character token */
3216         if($token['type'] === HTML5::CHARACTR) {
3217             /* Append the token's character to the current node. */
3218             $this->insertText($token['data']);
3219
3220         /* A comment token */
3221         } elseif($token['type'] === HTML5::COMMENT) {
3222             /* Append a Comment node to the current node with the data
3223             attribute set to the data given in the comment token. */
3224             $this->insertComment($token['data']);
3225
3226         /* A start tag token whose tag name is "option" */
3227         } elseif($token['type'] === HTML5::STARTTAG &&
3228         $token['name'] === 'option') {
3229             /* If the current node is an option element, act as if an end tag
3230             with the tag name "option" had been seen. */
3231             if(end($this->stack)->nodeName === 'option') {
3232                 $this->inSelect(array(
3233                     'name' => 'option',
3234                     'type' => HTML5::ENDTAG
3235                 ));
3236             }
3237
3238             /* Insert an HTML element for the token. */
3239             $this->insertElement($token);
3240
3241         /* A start tag token whose tag name is "optgroup" */
3242         } elseif($token['type'] === HTML5::STARTTAG &&
3243         $token['name'] === 'optgroup') {
3244             /* If the current node is an option element, act as if an end tag
3245             with the tag name "option" had been seen. */
3246             if(end($this->stack)->nodeName === 'option') {
3247                 $this->inSelect(array(
3248                     'name' => 'option',
3249                     'type' => HTML5::ENDTAG
3250                 ));
3251             }
3252
3253             /* If the current node is an optgroup element, act as if an end tag
3254             with the tag name "optgroup" had been seen. */
3255             if(end($this->stack)->nodeName === 'optgroup') {
3256                 $this->inSelect(array(
3257                     'name' => 'optgroup',
3258                     'type' => HTML5::ENDTAG
3259                 ));
3260             }
3261
3262             /* Insert an HTML element for the token. */
3263             $this->insertElement($token);
3264
3265         /* An end tag token whose tag name is "optgroup" */
3266         } elseif($token['type'] === HTML5::ENDTAG &&
3267         $token['name'] === 'optgroup') {
3268             /* First, if the current node is an option element, and the node
3269             immediately before it in the stack of open elements is an optgroup
3270             element, then act as if an end tag with the tag name "option" had
3271             been seen. */
3272             $elements_in_stack = count($this->stack);
3273
3274             if($this->stack[$elements_in_stack - 1]->nodeName === 'option' &&
3275             $this->stack[$elements_in_stack - 2]->nodeName === 'optgroup') {
3276                 $this->inSelect(array(
3277                     'name' => 'option',
3278                     'type' => HTML5::ENDTAG
3279                 ));
3280             }
3281
3282             /* If the current node is an optgroup element, then pop that node
3283             from the stack of open elements. Otherwise, this is a parse error,
3284             ignore the token. */
3285             if($this->stack[$elements_in_stack - 1] === 'optgroup') {
3286                 array_pop($this->stack);
3287             }
3288
3289         /* An end tag token whose tag name is "option" */
3290         } elseif($token['type'] === HTML5::ENDTAG &&
3291         $token['name'] === 'option') {
3292             /* If the current node is an option element, then pop that node
3293             from the stack of open elements. Otherwise, this is a parse error,
3294             ignore the token. */
3295             if(end($this->stack)->nodeName === 'option') {
3296                 array_pop($this->stack);
3297             }
3298
3299         /* An end tag whose tag name is "select" */
3300         } elseif($token['type'] === HTML5::ENDTAG &&
3301         $token['name'] === 'select') {
3302             /* If the stack of open elements does not have an element in table
3303             scope with the same tag name as the token, this is a parse error.
3304             Ignore the token. (innerHTML case) */
3305             if(!$this->elementInScope($token['name'], true)) {
3306                 // w/e
3307
3308             /* Otherwise: */
3309             } else {
3310                 /* Pop elements from the stack of open elements until a select
3311                 element has been popped from the stack. */
3312                 while(true) {
3313                     $current = end($this->stack)->nodeName;
3314                     array_pop($this->stack);
3315
3316                     if($current === 'select') {
3317                         break;
3318                     }
3319                 }
3320
3321                 /* Reset the insertion mode appropriately. */
3322                 $this->resetInsertionMode();
3323             }
3324
3325         /* A start tag whose tag name is "select" */
3326         } elseif($token['name'] === 'select' &&
3327         $token['type'] === HTML5::STARTTAG) {
3328             /* Parse error. Act as if the token had been an end tag with the
3329             tag name "select" instead. */
3330             $this->inSelect(array(
3331                 'name' => 'select',
3332                 'type' => HTML5::ENDTAG
3333             ));
3334
3335         /* An end tag whose tag name is one of: "caption", "table", "tbody",
3336         "tfoot", "thead", "tr", "td", "th" */
3337         } elseif(in_array($token['name'], array('caption', 'table', 'tbody',
3338         'tfoot', 'thead', 'tr', 'td', 'th')) && $token['type'] === HTML5::ENDTAG) {
3339             /* Parse error. */
3340             // w/e
3341
3342             /* If the stack of open elements has an element in table scope with
3343             the same tag name as that of the token, then act as if an end tag
3344             with the tag name "select" had been seen, and reprocess the token.
3345             Otherwise, ignore the token. */
3346             if($this->elementInScope($token['name'], true)) {
3347                 $this->inSelect(array(
3348                     'name' => 'select',
3349                     'type' => HTML5::ENDTAG
3350                 ));
3351
3352                 $this->mainPhase($token);
3353             }
3354
3355         /* Anything else */
3356         } else {
3357             /* Parse error. Ignore the token. */
3358         }
3359     }
3360
3361     private function afterBody($token) {
3362         /* Handle the token as follows: */
3363
3364         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
3365         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
3366         or U+0020 SPACE */
3367         if($token['type'] === HTML5::CHARACTR &&
3368         preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
3369             /* Process the token as it would be processed if the insertion mode
3370             was "in body". */
3371             $this->inBody($token);
3372
3373         /* A comment token */
3374         } elseif($token['type'] === HTML5::COMMENT) {
3375             /* Append a Comment node to the first element in the stack of open
3376             elements (the html element), with the data attribute set to the
3377             data given in the comment token. */
3378             $comment = $this->dom->createComment($token['data']);
3379             $this->stack[0]->appendChild($comment);
3380
3381         /* An end tag with the tag name "html" */
3382         } elseif($token['type'] === HTML5::ENDTAG && $token['name'] === 'html') {
3383             /* If the parser was originally created in order to handle the
3384             setting of an element's innerHTML attribute, this is a parse error;
3385             ignore the token. (The element will be an html element in this
3386             case.) (innerHTML case) */
3387
3388             /* Otherwise, switch to the trailing end phase. */
3389             $this->phase = self::END_PHASE;
3390
3391         /* Anything else */
3392         } else {
3393             /* Parse error. Set the insertion mode to "in body" and reprocess
3394             the token. */
3395             $this->mode = self::IN_BODY;
3396             return $this->inBody($token);
3397         }
3398     }
3399
3400     private function inFrameset($token) {
3401         /* Handle the token as follows: */
3402
3403         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
3404         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
3405         U+000D CARRIAGE RETURN (CR), or U+0020 SPACE */
3406         if($token['type'] === HTML5::CHARACTR &&
3407         preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
3408             /* Append the character to the current node. */
3409             $this->insertText($token['data']);
3410
3411         /* A comment token */
3412         } elseif($token['type'] === HTML5::COMMENT) {
3413             /* Append a Comment node to the current node with the data
3414             attribute set to the data given in the comment token. */
3415             $this->insertComment($token['data']);
3416
3417         /* A start tag with the tag name "frameset" */
3418         } elseif($token['name'] === 'frameset' &&
3419         $token['type'] === HTML5::STARTTAG) {
3420             $this->insertElement($token);
3421
3422         /* An end tag with the tag name "frameset" */
3423         } elseif($token['name'] === 'frameset' &&
3424         $token['type'] === HTML5::ENDTAG) {
3425             /* If the current node is the root html element, then this is a
3426             parse error; ignore the token. (innerHTML case) */
3427             if(end($this->stack)->nodeName === 'html') {
3428                 // Ignore
3429
3430             } else {
3431                 /* Otherwise, pop the current node from the stack of open
3432                 elements. */
3433                 array_pop($this->stack);
3434
3435                 /* If the parser was not originally created in order to handle
3436                 the setting of an element's innerHTML attribute (innerHTML case),
3437                 and the current node is no longer a frameset element, then change
3438                 the insertion mode to "after frameset". */
3439                 $this->mode = self::AFTR_FRAME;
3440             }
3441
3442         /* A start tag with the tag name "frame" */
3443         } elseif($token['name'] === 'frame' &&
3444         $token['type'] === HTML5::STARTTAG) {
3445             /* Insert an HTML element for the token. */
3446             $this->insertElement($token);
3447
3448             /* Immediately pop the current node off the stack of open elements. */
3449             array_pop($this->stack);
3450
3451         /* A start tag with the tag name "noframes" */
3452         } elseif($token['name'] === 'noframes' &&
3453         $token['type'] === HTML5::STARTTAG) {
3454             /* Process the token as if the insertion mode had been "in body". */
3455             $this->inBody($token);
3456
3457         /* Anything else */
3458         } else {
3459             /* Parse error. Ignore the token. */
3460         }
3461     }
3462
3463     private function afterFrameset($token) {
3464         /* Handle the token as follows: */
3465
3466         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
3467         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
3468         U+000D CARRIAGE RETURN (CR), or U+0020 SPACE */
3469         if($token['type'] === HTML5::CHARACTR &&
3470         preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
3471             /* Append the character to the current node. */
3472             $this->insertText($token['data']);
3473
3474         /* A comment token */
3475         } elseif($token['type'] === HTML5::COMMENT) {
3476             /* Append a Comment node to the current node with the data
3477             attribute set to the data given in the comment token. */
3478             $this->insertComment($token['data']);
3479
3480         /* An end tag with the tag name "html" */
3481         } elseif($token['name'] === 'html' &&
3482         $token['type'] === HTML5::ENDTAG) {
3483             /* Switch to the trailing end phase. */
3484             $this->phase = self::END_PHASE;
3485
3486         /* A start tag with the tag name "noframes" */
3487         } elseif($token['name'] === 'noframes' &&
3488         $token['type'] === HTML5::STARTTAG) {
3489             /* Process the token as if the insertion mode had been "in body". */
3490             $this->inBody($token);
3491
3492         /* Anything else */
3493         } else {
3494             /* Parse error. Ignore the token. */
3495         }
3496     }
3497
3498     private function trailingEndPhase($token) {
3499         /* After the main phase, as each token is emitted from the tokenisation
3500         stage, it must be processed as described in this section. */
3501
3502         /* A DOCTYPE token */
3503         if($token['type'] === HTML5::DOCTYPE) {
3504             // Parse error. Ignore the token.
3505
3506         /* A comment token */
3507         } elseif($token['type'] === HTML5::COMMENT) {
3508             /* Append a Comment node to the Document object with the data
3509             attribute set to the data given in the comment token. */
3510             $comment = $this->dom->createComment($token['data']);
3511             $this->dom->appendChild($comment);
3512
3513         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
3514         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
3515         or U+0020 SPACE */
3516         } elseif($token['type'] === HTML5::CHARACTR &&
3517         preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
3518             /* Process the token as it would be processed in the main phase. */
3519             $this->mainPhase($token);
3520
3521         /* A character token that is not one of U+0009 CHARACTER TABULATION,
3522         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
3523         or U+0020 SPACE. Or a start tag token. Or an end tag token. */
3524         } elseif(($token['type'] === HTML5::CHARACTR &&
3525         preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) ||
3526         $token['type'] === HTML5::STARTTAG || $token['type'] === HTML5::ENDTAG) {
3527             /* Parse error. Switch back to the main phase and reprocess the
3528             token. */
3529             $this->phase = self::MAIN_PHASE;
3530             return $this->mainPhase($token);
3531
3532         /* An end-of-file token */
3533         } elseif($token['type'] === HTML5::EOF) {
3534             /* OMG DONE!! */
3535         }
3536     }
3537
3538     private function insertElement($token, $append = true, $check = false) {
3539         // Proprietary workaround for libxml2's limitations with tag names
3540         if ($check) {
3541             // Slightly modified HTML5 tag-name modification,
3542             // removing anything that's not an ASCII letter, digit, or hyphen
3543             $token['name'] = preg_replace('/[^a-z0-9-]/i', '', $token['name']);
3544             // Remove leading hyphens and numbers
3545             $token['name'] = ltrim($token['name'], '-0..9');
3546             // In theory, this should ever be needed, but just in case
3547             if ($token['name'] === '') $token['name'] = 'span'; // arbitrary generic choice
3548         }
3549
3550         $el = $this->dom->createElement($token['name']);
3551
3552         foreach($token['attr'] as $attr) {
3553             if(!$el->hasAttribute($attr['name'])) {
3554                 $el->setAttribute($attr['name'], $attr['value']);
3555             }
3556         }
3557
3558         $this->appendToRealParent($el);
3559         $this->stack[] = $el;
3560
3561         return $el;
3562     }
3563
3564     private function insertText($data) {
3565         $text = $this->dom->createTextNode($data);
3566         $this->appendToRealParent($text);
3567     }
3568
3569     private function insertComment($data) {
3570         $comment = $this->dom->createComment($data);
3571         $this->appendToRealParent($comment);
3572     }
3573
3574     private function appendToRealParent($node) {
3575         if($this->foster_parent === null) {
3576             end($this->stack)->appendChild($node);
3577
3578         } elseif($this->foster_parent !== null) {
3579             /* If the foster parent element is the parent element of the
3580             last table element in the stack of open elements, then the new
3581             node must be inserted immediately before the last table element
3582             in the stack of open elements in the foster parent element;
3583             otherwise, the new node must be appended to the foster parent
3584             element. */
3585             for($n = count($this->stack) - 1; $n >= 0; $n--) {
3586                 if($this->stack[$n]->nodeName === 'table' &&
3587                 $this->stack[$n]->parentNode !== null) {
3588                     $table = $this->stack[$n];
3589                     break;
3590                 }
3591             }
3592
3593             if(isset($table) && $this->foster_parent->isSameNode($table->parentNode))
3594                 $this->foster_parent->insertBefore($node, $table);
3595             else
3596                 $this->foster_parent->appendChild($node);
3597
3598             $this->foster_parent = null;
3599         }
3600     }
3601
3602     private function elementInScope($el, $table = false) {
3603         if(is_array($el)) {
3604             foreach($el as $element) {
3605                 if($this->elementInScope($element, $table)) {
3606                     return true;
3607                 }
3608             }
3609
3610             return false;
3611         }
3612
3613         $leng = count($this->stack);
3614
3615         for($n = 0; $n < $leng; $n++) {
3616             /* 1. Initialise node to be the current node (the bottommost node of
3617             the stack). */
3618             $node = $this->stack[$leng - 1 - $n];
3619
3620             if($node->tagName === $el) {
3621                 /* 2. If node is the target node, terminate in a match state. */
3622                 return true;
3623
3624             } elseif($node->tagName === 'table') {
3625                 /* 3. Otherwise, if node is a table element, terminate in a failure
3626                 state. */
3627                 return false;
3628
3629             } elseif($table === true && in_array($node->tagName, array('caption', 'td',
3630             'th', 'button', 'marquee', 'object'))) {
3631                 /* 4. Otherwise, if the algorithm is the "has an element in scope"
3632                 variant (rather than the "has an element in table scope" variant),
3633                 and node is one of the following, terminate in a failure state. */
3634                 return false;
3635
3636             } elseif($node === $node->ownerDocument->documentElement) {
3637                 /* 5. Otherwise, if node is an html element (root element), terminate
3638                 in a failure state. (This can only happen if the node is the topmost
3639                 node of the    stack of open elements, and prevents the next step from
3640                 being invoked if there are no more elements in the stack.) */
3641                 return false;
3642             }
3643
3644             /* Otherwise, set node to the previous entry in the stack of open
3645             elements and return to step 2. (This will never fail, since the loop
3646             will always terminate in the previous step if the top of the stack
3647             is reached.) */
3648         }
3649     }
3650
3651     private function reconstructActiveFormattingElements() {
3652         /* 1. If there are no entries in the list of active formatting elements,
3653         then there is nothing to reconstruct; stop this algorithm. */
3654         $formatting_elements = count($this->a_formatting);
3655
3656         if($formatting_elements === 0) {
3657             return false;
3658         }
3659
3660         /* 3. Let entry be the last (most recently added) element in the list
3661         of active formatting elements. */
3662         $entry = end($this->a_formatting);
3663
3664         /* 2. If the last (most recently added) entry in the list of active
3665         formatting elements is a marker, or if it is an element that is in the
3666         stack of open elements, then there is nothing to reconstruct; stop this
3667         algorithm. */
3668         if($entry === self::MARKER || in_array($entry, $this->stack, true)) {
3669             return false;
3670         }
3671
3672         for($a = $formatting_elements - 1; $a >= 0; true) {
3673             /* 4. If there are no entries before entry in the list of active
3674             formatting elements, then jump to step 8. */
3675             if($a === 0) {
3676                 $step_seven = false;
3677                 break;
3678             }
3679
3680             /* 5. Let entry be the entry one earlier than entry in the list of
3681             active formatting elements. */
3682             $a--;
3683             $entry = $this->a_formatting[$a];
3684
3685             /* 6. If entry is neither a marker nor an element that is also in
3686             thetack of open elements, go to step 4. */
3687             if($entry === self::MARKER || in_array($entry, $this->stack, true)) {
3688                 break;
3689             }
3690         }
3691
3692         while(true) {
3693             /* 7. Let entry be the element one later than entry in the list of
3694             active formatting elements. */
3695             if(isset($step_seven) && $step_seven === true) {
3696                 $a++;
3697                 $entry = $this->a_formatting[$a];
3698             }
3699
3700             /* 8. Perform a shallow clone of the element entry to obtain clone. */
3701             $clone = $entry->cloneNode();
3702
3703             /* 9. Append clone to the current node and push it onto the stack
3704             of open elements  so that it is the new current node. */
3705             end($this->stack)->appendChild($clone);
3706             $this->stack[] = $clone;
3707
3708             /* 10. Replace the entry for entry in the list with an entry for
3709             clone. */
3710             $this->a_formatting[$a] = $clone;
3711
3712             /* 11. If the entry for clone in the list of active formatting
3713             elements is not the last entry in the list, return to step 7. */
3714             if(end($this->a_formatting) !== $clone) {
3715                 $step_seven = true;
3716             } else {
3717                 break;
3718             }
3719         }
3720     }
3721
3722     private function clearTheActiveFormattingElementsUpToTheLastMarker() {
3723         /* When the steps below require the UA to clear the list of active
3724         formatting elements up to the last marker, the UA must perform the
3725         following steps: */
3726
3727         while(true) {
3728             /* 1. Let entry be the last (most recently added) entry in the list
3729             of active formatting elements. */
3730             $entry = end($this->a_formatting);
3731
3732             /* 2. Remove entry from the list of active formatting elements. */
3733             array_pop($this->a_formatting);
3734
3735             /* 3. If entry was a marker, then stop the algorithm at this point.
3736             The list has been cleared up to the last marker. */
3737             if($entry === self::MARKER) {
3738                 break;
3739             }
3740         }
3741     }
3742
3743     private function generateImpliedEndTags($exclude = array()) {
3744         /* When the steps below require the UA to generate implied end tags,
3745         then, if the current node is a dd element, a dt element, an li element,
3746         a p element, a td element, a th  element, or a tr element, the UA must
3747         act as if an end tag with the respective tag name had been seen and
3748         then generate implied end tags again. */
3749         $node = end($this->stack);
3750         $elements = array_diff(array('dd', 'dt', 'li', 'p', 'td', 'th', 'tr'), $exclude);
3751
3752         while(in_array(end($this->stack)->nodeName, $elements)) {
3753             array_pop($this->stack);
3754         }
3755     }
3756
3757     private function getElementCategory($node) {
3758         $name = $node->tagName;
3759         if(in_array($name, $this->special))
3760             return self::SPECIAL;
3761
3762         elseif(in_array($name, $this->scoping))
3763             return self::SCOPING;
3764
3765         elseif(in_array($name, $this->formatting))
3766             return self::FORMATTING;
3767
3768         else
3769             return self::PHRASING;
3770     }
3771
3772     private function clearStackToTableContext($elements) {
3773         /* When the steps above require the UA to clear the stack back to a
3774         table context, it means that the UA must, while the current node is not
3775         a table element or an html element, pop elements from the stack of open
3776         elements. If this causes any elements to be popped from the stack, then
3777         this is a parse error. */
3778         while(true) {
3779             $node = end($this->stack)->nodeName;
3780
3781             if(in_array($node, $elements)) {
3782                 break;
3783             } else {
3784                 array_pop($this->stack);
3785             }
3786         }
3787     }
3788
3789     private function resetInsertionMode() {
3790         /* 1. Let last be false. */
3791         $last = false;
3792         $leng = count($this->stack);
3793
3794         for($n = $leng - 1; $n >= 0; $n--) {
3795             /* 2. Let node be the last node in the stack of open elements. */
3796             $node = $this->stack[$n];
3797
3798             /* 3. If node is the first node in the stack of open elements, then
3799             set last to true. If the element whose innerHTML  attribute is being
3800             set is neither a td  element nor a th element, then set node to the
3801             element whose innerHTML  attribute is being set. (innerHTML  case) */
3802             if($this->stack[0]->isSameNode($node)) {
3803                 $last = true;
3804             }
3805
3806             /* 4. If node is a select element, then switch the insertion mode to
3807             "in select" and abort these steps. (innerHTML case) */
3808             if($node->nodeName === 'select') {
3809                 $this->mode = self::IN_SELECT;
3810                 break;
3811
3812             /* 5. If node is a td or th element, then switch the insertion mode
3813             to "in cell" and abort these steps. */
3814             } elseif($node->nodeName === 'td' || $node->nodeName === 'th') {
3815                 $this->mode = self::IN_CELL;
3816                 break;
3817
3818             /* 6. If node is a tr element, then switch the insertion mode to
3819             "in    row" and abort these steps. */
3820             } elseif($node->nodeName === 'tr') {
3821                 $this->mode = self::IN_ROW;
3822                 break;
3823
3824             /* 7. If node is a tbody, thead, or tfoot element, then switch the
3825             insertion mode to "in table body" and abort these steps. */
3826             } elseif(in_array($node->nodeName, array('tbody', 'thead', 'tfoot'))) {
3827                 $this->mode = self::IN_TBODY;
3828                 break;
3829
3830             /* 8. If node is a caption element, then switch the insertion mode
3831             to "in caption" and abort these steps. */
3832             } elseif($node->nodeName === 'caption') {
3833                 $this->mode = self::IN_CAPTION;
3834                 break;
3835
3836             /* 9. If node is a colgroup element, then switch the insertion mode
3837             to "in column group" and abort these steps. (innerHTML case) */
3838             } elseif($node->nodeName === 'colgroup') {
3839                 $this->mode = self::IN_CGROUP;
3840                 break;
3841
3842             /* 10. If node is a table element, then switch the insertion mode
3843             to "in table" and abort these steps. */
3844             } elseif($node->nodeName === 'table') {
3845                 $this->mode = self::IN_TABLE;
3846                 break;
3847
3848             /* 11. If node is a head element, then switch the insertion mode
3849             to "in body" ("in body"! not "in head"!) and abort these steps.
3850             (innerHTML case) */
3851             } elseif($node->nodeName === 'head') {
3852                 $this->mode = self::IN_BODY;
3853                 break;
3854
3855             /* 12. If node is a body element, then switch the insertion mode to
3856             "in body" and abort these steps. */
3857             } elseif($node->nodeName === 'body') {
3858                 $this->mode = self::IN_BODY;
3859                 break;
3860
3861             /* 13. If node is a frameset element, then switch the insertion
3862             mode to "in frameset" and abort these steps. (innerHTML case) */
3863             } elseif($node->nodeName === 'frameset') {
3864                 $this->mode = self::IN_FRAME;
3865                 break;
3866
3867             /* 14. If node is an html element, then: if the head element
3868             pointer is null, switch the insertion mode to "before head",
3869             otherwise, switch the insertion mode to "after head". In either
3870             case, abort these steps. (innerHTML case) */
3871             } elseif($node->nodeName === 'html') {
3872                 $this->mode = ($this->head_pointer === null)
3873                     ? self::BEFOR_HEAD
3874                     : self::AFTER_HEAD;
3875
3876                 break;
3877
3878             /* 15. If last is true, then set the insertion mode to "in body"
3879             and    abort these steps. (innerHTML case) */
3880             } elseif($last) {
3881                 $this->mode = self::IN_BODY;
3882                 break;
3883             }
3884         }
3885     }
3886
3887     private function closeCell() {
3888         /* If the stack of open elements has a td or th element in table scope,
3889         then act as if an end tag token with that tag name had been seen. */
3890         foreach(array('td', 'th') as $cell) {
3891             if($this->elementInScope($cell, true)) {
3892                 $this->inCell(array(
3893                     'name' => $cell,
3894                     'type' => HTML5::ENDTAG
3895                 ));
3896
3897                 break;
3898             }
3899         }
3900     }
3901
3902     public function save() {
3903         return $this->dom;
3904     }
3905 }
3906 ?>