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