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, false /* no div */);
  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, $config
  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
1519                 $e_name = $this->characters('0-9A-Za-z;', $this->char + 1);
1520                 $len = strlen($e_name);
1521
1522                 for ($c = 1; $c <= $len; $c++) {
1523                     $id = substr($e_name, 0, $c);
1524                     $this->char++;
1525
1526                     if (in_array($id, $this->entities)) {
1527                         if ($e_name[$c - 1] !== ';') {
1528                             if ($c < $len && $e_name[$c] == ';') {
1529                                 $this->char++; // consume extra semicolon
1530                             }
1531                         }
1532                         $entity = $id;
1533                         break;
1534                     }
1535                 }
1536
1537                 $cond = isset($entity);
1538                 // The rest of the parsing happens bellow.
1539                 break;
1540         }
1541
1542         if (!$cond) {
1543             // If no match can be made, then this is a parse error. No
1544             // characters are consumed, and nothing is returned.
1545             $this->char = $start;
1546             return false;
1547         }
1548
1549         // Return a character token for the character corresponding to the
1550         // entity name (as given by the second column of the entities table).
1551         return html_entity_decode('&' . rtrim($entity, ';') . ';', ENT_QUOTES, 'UTF-8');
1552     }
1553
1554     private function emitToken($token)
1555     {
1556         $emit = $this->tree->emitToken($token);
1557
1558         if (is_int($emit)) {
1559             $this->content_model = $emit;
1560
1561         } elseif ($token['type'] === self::ENDTAG) {
1562             $this->content_model = self::PCDATA;
1563         }
1564     }
1565
1566     private function EOF()
1567     {
1568         $this->state = null;
1569         $this->tree->emitToken(
1570             array(
1571                 'type' => self::EOF
1572             )
1573         );
1574     }
1575 }
1576
1577 class HTML5TreeConstructer
1578 {
1579     public $stack = array();
1580
1581     private $phase;
1582     private $mode;
1583     private $dom;
1584     private $foster_parent = null;
1585     private $a_formatting = array();
1586
1587     private $head_pointer = null;
1588     private $form_pointer = null;
1589
1590     private $scoping = array('button', 'caption', 'html', 'marquee', 'object', 'table', 'td', 'th');
1591     private $formatting = array(
1592         'a',
1593         'b',
1594         'big',
1595         'em',
1596         'font',
1597         'i',
1598         'nobr',
1599         's',
1600         'small',
1601         'strike',
1602         'strong',
1603         'tt',
1604         'u'
1605     );
1606     private $special = array(
1607         'address',
1608         'area',
1609         'base',
1610         'basefont',
1611         'bgsound',
1612         'blockquote',
1613         'body',
1614         'br',
1615         'center',
1616         'col',
1617         'colgroup',
1618         'dd',
1619         'dir',
1620         'div',
1621         'dl',
1622         'dt',
1623         'embed',
1624         'fieldset',
1625         'form',
1626         'frame',
1627         'frameset',
1628         'h1',
1629         'h2',
1630         'h3',
1631         'h4',
1632         'h5',
1633         'h6',
1634         'head',
1635         'hr',
1636         'iframe',
1637         'image',
1638         'img',
1639         'input',
1640         'isindex',
1641         'li',
1642         'link',
1643         'listing',
1644         'menu',
1645         'meta',
1646         'noembed',
1647         'noframes',
1648         'noscript',
1649         'ol',
1650         'optgroup',
1651         'option',
1652         'p',
1653         'param',
1654         'plaintext',
1655         'pre',
1656         'script',
1657         'select',
1658         'spacer',
1659         'style',
1660         'tbody',
1661         'textarea',
1662         'tfoot',
1663         'thead',
1664         'title',
1665         'tr',
1666         'ul',
1667         'wbr'
1668     );
1669
1670     // The different phases.
1671     const INIT_PHASE = 0;
1672     const ROOT_PHASE = 1;
1673     const MAIN_PHASE = 2;
1674     const END_PHASE = 3;
1675
1676     // The different insertion modes for the main phase.
1677     const BEFOR_HEAD = 0;
1678     const IN_HEAD = 1;
1679     const AFTER_HEAD = 2;
1680     const IN_BODY = 3;
1681     const IN_TABLE = 4;
1682     const IN_CAPTION = 5;
1683     const IN_CGROUP = 6;
1684     const IN_TBODY = 7;
1685     const IN_ROW = 8;
1686     const IN_CELL = 9;
1687     const IN_SELECT = 10;
1688     const AFTER_BODY = 11;
1689     const IN_FRAME = 12;
1690     const AFTR_FRAME = 13;
1691
1692     // The different types of elements.
1693     const SPECIAL = 0;
1694     const SCOPING = 1;
1695     const FORMATTING = 2;
1696     const PHRASING = 3;
1697
1698     const MARKER = 0;
1699
1700     public function __construct()
1701     {
1702         $this->phase = self::INIT_PHASE;
1703         $this->mode = self::BEFOR_HEAD;
1704         $this->dom = new DOMDocument;
1705
1706         $this->dom->encoding = 'UTF-8';
1707         $this->dom->preserveWhiteSpace = true;
1708         $this->dom->substituteEntities = true;
1709         $this->dom->strictErrorChecking = false;
1710     }
1711
1712     // Process tag tokens
1713     public function emitToken($token)
1714     {
1715         switch ($this->phase) {
1716             case self::INIT_PHASE:
1717                 return $this->initPhase($token);
1718                 break;
1719             case self::ROOT_PHASE:
1720                 return $this->rootElementPhase($token);
1721                 break;
1722             case self::MAIN_PHASE:
1723                 return $this->mainPhase($token);
1724                 break;
1725             case self::END_PHASE :
1726                 return $this->trailingEndPhase($token);
1727                 break;
1728         }
1729     }
1730
1731     private function initPhase($token)
1732     {
1733         /* Initially, the tree construction stage must handle each token
1734         emitted from the tokenisation stage as follows: */
1735
1736         /* A DOCTYPE token that is marked as being in error
1737         A comment token
1738         A start tag token
1739         An end tag token
1740         A character token that is not one of one of U+0009 CHARACTER TABULATION,
1741             U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1742             or U+0020 SPACE
1743         An end-of-file token */
1744         if ((isset($token['error']) && $token['error']) ||
1745             $token['type'] === HTML5::COMMENT ||
1746             $token['type'] === HTML5::STARTTAG ||
1747             $token['type'] === HTML5::ENDTAG ||
1748             $token['type'] === HTML5::EOF ||
1749             ($token['type'] === HTML5::CHARACTR && isset($token['data']) &&
1750                 !preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data']))
1751         ) {
1752             /* This specification does not define how to handle this case. In
1753             particular, user agents may ignore the entirety of this specification
1754             altogether for such documents, and instead invoke special parse modes
1755             with a greater emphasis on backwards compatibility. */
1756
1757             $this->phase = self::ROOT_PHASE;
1758             return $this->rootElementPhase($token);
1759
1760             /* A DOCTYPE token marked as being correct */
1761         } elseif (isset($token['error']) && !$token['error']) {
1762             /* Append a DocumentType node to the Document  node, with the name
1763             attribute set to the name given in the DOCTYPE token (which will be
1764             "HTML"), and the other attributes specific to DocumentType objects
1765             set to null, empty lists, or the empty string as appropriate. */
1766             $doctype = new DOMDocumentType(null, null, 'HTML');
1767
1768             /* Then, switch to the root element phase of the tree construction
1769             stage. */
1770             $this->phase = self::ROOT_PHASE;
1771
1772             /* A character token that is one of one of U+0009 CHARACTER TABULATION,
1773             U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1774             or U+0020 SPACE */
1775         } elseif (isset($token['data']) && preg_match(
1776                 '/^[\t\n\x0b\x0c ]+$/',
1777                 $token['data']
1778             )
1779         ) {
1780             /* Append that character  to the Document node. */
1781             $text = $this->dom->createTextNode($token['data']);
1782             $this->dom->appendChild($text);
1783         }
1784     }
1785
1786     private function rootElementPhase($token)
1787     {
1788         /* After the initial phase, as each token is emitted from the tokenisation
1789         stage, it must be processed as described in this section. */
1790
1791         /* A DOCTYPE token */
1792         if ($token['type'] === HTML5::DOCTYPE) {
1793             // Parse error. Ignore the token.
1794
1795             /* A comment token */
1796         } elseif ($token['type'] === HTML5::COMMENT) {
1797             /* Append a Comment node to the Document object with the data
1798             attribute set to the data given in the comment token. */
1799             $comment = $this->dom->createComment($token['data']);
1800             $this->dom->appendChild($comment);
1801
1802             /* A character token that is one of one of U+0009 CHARACTER TABULATION,
1803             U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1804             or U+0020 SPACE */
1805         } elseif ($token['type'] === HTML5::CHARACTR &&
1806             preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])
1807         ) {
1808             /* Append that character  to the Document node. */
1809             $text = $this->dom->createTextNode($token['data']);
1810             $this->dom->appendChild($text);
1811
1812             /* A character token that is not one of U+0009 CHARACTER TABULATION,
1813                 U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED
1814                 (FF), or U+0020 SPACE
1815             A start tag token
1816             An end tag token
1817             An end-of-file token */
1818         } elseif (($token['type'] === HTML5::CHARACTR &&
1819                 !preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) ||
1820             $token['type'] === HTML5::STARTTAG ||
1821             $token['type'] === HTML5::ENDTAG ||
1822             $token['type'] === HTML5::EOF
1823         ) {
1824             /* Create an HTMLElement node with the tag name html, in the HTML
1825             namespace. Append it to the Document object. Switch to the main
1826             phase and reprocess the current token. */
1827             $html = $this->dom->createElement('html');
1828             $this->dom->appendChild($html);
1829             $this->stack[] = $html;
1830
1831             $this->phase = self::MAIN_PHASE;
1832             return $this->mainPhase($token);
1833         }
1834     }
1835
1836     private function mainPhase($token)
1837     {
1838         /* Tokens in the main phase must be handled as follows: */
1839
1840         /* A DOCTYPE token */
1841         if ($token['type'] === HTML5::DOCTYPE) {
1842             // Parse error. Ignore the token.
1843
1844             /* A start tag token with the tag name "html" */
1845         } elseif ($token['type'] === HTML5::STARTTAG && $token['name'] === 'html') {
1846             /* If this start tag token was not the first start tag token, then
1847             it is a parse error. */
1848
1849             /* For each attribute on the token, check to see if the attribute
1850             is already present on the top element of the stack of open elements.
1851             If it is not, add the attribute and its corresponding value to that
1852             element. */
1853             foreach ($token['attr'] as $attr) {
1854                 if (!$this->stack[0]->hasAttribute($attr['name'])) {
1855                     $this->stack[0]->setAttribute($attr['name'], $attr['value']);
1856                 }
1857             }
1858
1859             /* An end-of-file token */
1860         } elseif ($token['type'] === HTML5::EOF) {
1861             /* Generate implied end tags. */
1862             $this->generateImpliedEndTags();
1863
1864             /* Anything else. */
1865         } else {
1866             /* Depends on the insertion mode: */
1867             switch ($this->mode) {
1868                 case self::BEFOR_HEAD:
1869                     return $this->beforeHead($token);
1870                     break;
1871                 case self::IN_HEAD:
1872                     return $this->inHead($token);
1873                     break;
1874                 case self::AFTER_HEAD:
1875                     return $this->afterHead($token);
1876                     break;
1877                 case self::IN_BODY:
1878                     return $this->inBody($token);
1879                     break;
1880                 case self::IN_TABLE:
1881                     return $this->inTable($token);
1882                     break;
1883                 case self::IN_CAPTION:
1884                     return $this->inCaption($token);
1885                     break;
1886                 case self::IN_CGROUP:
1887                     return $this->inColumnGroup($token);
1888                     break;
1889                 case self::IN_TBODY:
1890                     return $this->inTableBody($token);
1891                     break;
1892                 case self::IN_ROW:
1893                     return $this->inRow($token);
1894                     break;
1895                 case self::IN_CELL:
1896                     return $this->inCell($token);
1897                     break;
1898                 case self::IN_SELECT:
1899                     return $this->inSelect($token);
1900                     break;
1901                 case self::AFTER_BODY:
1902                     return $this->afterBody($token);
1903                     break;
1904                 case self::IN_FRAME:
1905                     return $this->inFrameset($token);
1906                     break;
1907                 case self::AFTR_FRAME:
1908                     return $this->afterFrameset($token);
1909                     break;
1910                 case self::END_PHASE:
1911                     return $this->trailingEndPhase($token);
1912                     break;
1913             }
1914         }
1915     }
1916
1917     private function beforeHead($token)
1918     {
1919         /* Handle the token as follows: */
1920
1921         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
1922         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1923         or U+0020 SPACE */
1924         if ($token['type'] === HTML5::CHARACTR &&
1925             preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])
1926         ) {
1927             /* Append the character to the current node. */
1928             $this->insertText($token['data']);
1929
1930             /* A comment token */
1931         } elseif ($token['type'] === HTML5::COMMENT) {
1932             /* Append a Comment node to the current node with the data attribute
1933             set to the data given in the comment token. */
1934             $this->insertComment($token['data']);
1935
1936             /* A start tag token with the tag name "head" */
1937         } elseif ($token['type'] === HTML5::STARTTAG && $token['name'] === 'head') {
1938             /* Create an element for the token, append the new element to the
1939             current node and push it onto the stack of open elements. */
1940             $element = $this->insertElement($token);
1941
1942             /* Set the head element pointer to this new element node. */
1943             $this->head_pointer = $element;
1944
1945             /* Change the insertion mode to "in head". */
1946             $this->mode = self::IN_HEAD;
1947
1948             /* A start tag token whose tag name is one of: "base", "link", "meta",
1949             "script", "style", "title". Or an end tag with the tag name "html".
1950             Or a character token that is not one of U+0009 CHARACTER TABULATION,
1951             U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1952             or U+0020 SPACE. Or any other start tag token */
1953         } elseif ($token['type'] === HTML5::STARTTAG ||
1954             ($token['type'] === HTML5::ENDTAG && $token['name'] === 'html') ||
1955             ($token['type'] === HTML5::CHARACTR && !preg_match(
1956                     '/^[\t\n\x0b\x0c ]$/',
1957                     $token['data']
1958                 ))
1959         ) {
1960             /* Act as if a start tag token with the tag name "head" and no
1961             attributes had been seen, then reprocess the current token. */
1962             $this->beforeHead(
1963                 array(
1964                     'name' => 'head',
1965                     'type' => HTML5::STARTTAG,
1966                     'attr' => array()
1967                 )
1968             );
1969
1970             return $this->inHead($token);
1971
1972             /* Any other end tag */
1973         } elseif ($token['type'] === HTML5::ENDTAG) {
1974             /* Parse error. Ignore the token. */
1975         }
1976     }
1977
1978     private function inHead($token)
1979     {
1980         /* Handle the token as follows: */
1981
1982         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
1983         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1984         or U+0020 SPACE.
1985
1986         THIS DIFFERS FROM THE SPEC: If the current node is either a title, style
1987         or script element, append the character to the current node regardless
1988         of its content. */
1989         if (($token['type'] === HTML5::CHARACTR &&
1990                 preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) || (
1991                 $token['type'] === HTML5::CHARACTR && in_array(
1992                     end($this->stack)->nodeName,
1993                     array('title', 'style', 'script')
1994                 ))
1995         ) {
1996             /* Append the character to the current node. */
1997             $this->insertText($token['data']);
1998
1999             /* A comment token */
2000         } elseif ($token['type'] === HTML5::COMMENT) {
2001             /* Append a Comment node to the current node with the data attribute
2002             set to the data given in the comment token. */
2003             $this->insertComment($token['data']);
2004
2005         } elseif ($token['type'] === HTML5::ENDTAG &&
2006             in_array($token['name'], array('title', 'style', 'script'))
2007         ) {
2008             array_pop($this->stack);
2009             return HTML5::PCDATA;
2010
2011             /* A start tag with the tag name "title" */
2012         } elseif ($token['type'] === HTML5::STARTTAG && $token['name'] === 'title') {
2013             /* Create an element for the token and append the new element to the
2014             node pointed to by the head element pointer, or, if that is null
2015             (innerHTML case), to the current node. */
2016             if ($this->head_pointer !== null) {
2017                 $element = $this->insertElement($token, false);
2018                 $this->head_pointer->appendChild($element);
2019
2020             } else {
2021                 $element = $this->insertElement($token);
2022             }
2023
2024             /* Switch the tokeniser's content model flag  to the RCDATA state. */
2025             return HTML5::RCDATA;
2026
2027             /* A start tag with the tag name "style" */
2028         } elseif ($token['type'] === HTML5::STARTTAG && $token['name'] === 'style') {
2029             /* Create an element for the token and append the new element to the
2030             node pointed to by the head element pointer, or, if that is null
2031             (innerHTML case), to the current node. */
2032             if ($this->head_pointer !== null) {
2033                 $element = $this->insertElement($token, false);
2034                 $this->head_pointer->appendChild($element);
2035
2036             } else {
2037                 $this->insertElement($token);
2038             }
2039
2040             /* Switch the tokeniser's content model flag  to the CDATA state. */
2041             return HTML5::CDATA;
2042
2043             /* A start tag with the tag name "script" */
2044         } elseif ($token['type'] === HTML5::STARTTAG && $token['name'] === 'script') {
2045             /* Create an element for the token. */
2046             $element = $this->insertElement($token, false);
2047             $this->head_pointer->appendChild($element);
2048
2049             /* Switch the tokeniser's content model flag  to the CDATA state. */
2050             return HTML5::CDATA;
2051
2052             /* A start tag with the tag name "base", "link", or "meta" */
2053         } elseif ($token['type'] === HTML5::STARTTAG && in_array(
2054                 $token['name'],
2055                 array('base', 'link', 'meta')
2056             )
2057         ) {
2058             /* Create an element for the token and append the new element to the
2059             node pointed to by the head element pointer, or, if that is null
2060             (innerHTML case), to the current node. */
2061             if ($this->head_pointer !== null) {
2062                 $element = $this->insertElement($token, false);
2063                 $this->head_pointer->appendChild($element);
2064                 array_pop($this->stack);
2065
2066             } else {
2067                 $this->insertElement($token);
2068             }
2069
2070             /* An end tag with the tag name "head" */
2071         } elseif ($token['type'] === HTML5::ENDTAG && $token['name'] === 'head') {
2072             /* If the current node is a head element, pop the current node off
2073             the stack of open elements. */
2074             if ($this->head_pointer->isSameNode(end($this->stack))) {
2075                 array_pop($this->stack);
2076
2077                 /* Otherwise, this is a parse error. */
2078             } else {
2079                 // k
2080             }
2081
2082             /* Change the insertion mode to "after head". */
2083             $this->mode = self::AFTER_HEAD;
2084
2085             /* A start tag with the tag name "head" or an end tag except "html". */
2086         } elseif (($token['type'] === HTML5::STARTTAG && $token['name'] === 'head') ||
2087             ($token['type'] === HTML5::ENDTAG && $token['name'] !== 'html')
2088         ) {
2089             // Parse error. Ignore the token.
2090
2091             /* Anything else */
2092         } else {
2093             /* If the current node is a head element, act as if an end tag
2094             token with the tag name "head" had been seen. */
2095             if ($this->head_pointer->isSameNode(end($this->stack))) {
2096                 $this->inHead(
2097                     array(
2098                         'name' => 'head',
2099                         'type' => HTML5::ENDTAG
2100                     )
2101                 );
2102
2103                 /* Otherwise, change the insertion mode to "after head". */
2104             } else {
2105                 $this->mode = self::AFTER_HEAD;
2106             }
2107
2108             /* Then, reprocess the current token. */
2109             return $this->afterHead($token);
2110         }
2111     }
2112
2113     private function afterHead($token)
2114     {
2115         /* Handle the token as follows: */
2116
2117         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
2118         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
2119         or U+0020 SPACE */
2120         if ($token['type'] === HTML5::CHARACTR &&
2121             preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])
2122         ) {
2123             /* Append the character to the current node. */
2124             $this->insertText($token['data']);
2125
2126             /* A comment token */
2127         } elseif ($token['type'] === HTML5::COMMENT) {
2128             /* Append a Comment node to the current node with the data attribute
2129             set to the data given in the comment token. */
2130             $this->insertComment($token['data']);
2131
2132             /* A start tag token with the tag name "body" */
2133         } elseif ($token['type'] === HTML5::STARTTAG && $token['name'] === 'body') {
2134             /* Insert a body element for the token. */
2135             $this->insertElement($token);
2136
2137             /* Change the insertion mode to "in body". */
2138             $this->mode = self::IN_BODY;
2139
2140             /* A start tag token with the tag name "frameset" */
2141         } elseif ($token['type'] === HTML5::STARTTAG && $token['name'] === 'frameset') {
2142             /* Insert a frameset element for the token. */
2143             $this->insertElement($token);
2144
2145             /* Change the insertion mode to "in frameset". */
2146             $this->mode = self::IN_FRAME;
2147
2148             /* A start tag token whose tag name is one of: "base", "link", "meta",
2149             "script", "style", "title" */
2150         } elseif ($token['type'] === HTML5::STARTTAG && in_array(
2151                 $token['name'],
2152                 array('base', 'link', 'meta', 'script', 'style', 'title')
2153             )
2154         ) {
2155             /* Parse error. Switch the insertion mode back to "in head" and
2156             reprocess the token. */
2157             $this->mode = self::IN_HEAD;
2158             return $this->inHead($token);
2159
2160             /* Anything else */
2161         } else {
2162             /* Act as if a start tag token with the tag name "body" and no
2163             attributes had been seen, and then reprocess the current token. */
2164             $this->afterHead(
2165                 array(
2166                     'name' => 'body',
2167                     'type' => HTML5::STARTTAG,
2168                     'attr' => array()
2169                 )
2170             );
2171
2172             return $this->inBody($token);
2173         }
2174     }
2175
2176     private function inBody($token)
2177     {
2178         /* Handle the token as follows: */
2179
2180         switch ($token['type']) {
2181             /* A character token */
2182             case HTML5::CHARACTR:
2183                 /* Reconstruct the active formatting elements, if any. */
2184                 $this->reconstructActiveFormattingElements();
2185
2186                 /* Append the token's character to the current node. */
2187                 $this->insertText($token['data']);
2188                 break;
2189
2190             /* A comment token */
2191             case HTML5::COMMENT:
2192                 /* Append a Comment node to the current node with the data
2193                 attribute set to the data given in the comment token. */
2194                 $this->insertComment($token['data']);
2195                 break;
2196
2197             case HTML5::STARTTAG:
2198                 switch ($token['name']) {
2199                     /* A start tag token whose tag name is one of: "script",
2200                     "style" */
2201                     case 'script':
2202                     case 'style':
2203                         /* Process the token as if the insertion mode had been "in
2204                         head". */
2205                         return $this->inHead($token);
2206                         break;
2207
2208                     /* A start tag token whose tag name is one of: "base", "link",
2209                     "meta", "title" */
2210                     case 'base':
2211                     case 'link':
2212                     case 'meta':
2213                     case 'title':
2214                         /* Parse error. Process the token as if the insertion mode
2215                         had    been "in head". */
2216                         return $this->inHead($token);
2217                         break;
2218
2219                     /* A start tag token with the tag name "body" */
2220                     case 'body':
2221                         /* Parse error. If the second element on the stack of open
2222                         elements is not a body element, or, if the stack of open
2223                         elements has only one node on it, then ignore the token.
2224                         (innerHTML case) */
2225                         if (count($this->stack) === 1 || $this->stack[1]->nodeName !== 'body') {
2226                             // Ignore
2227
2228                             /* Otherwise, for each attribute on the token, check to see
2229                             if the attribute is already present on the body element (the
2230                             second element)    on the stack of open elements. If it is not,
2231                             add the attribute and its corresponding value to that
2232                             element. */
2233                         } else {
2234                             foreach ($token['attr'] as $attr) {
2235                                 if (!$this->stack[1]->hasAttribute($attr['name'])) {
2236                                     $this->stack[1]->setAttribute($attr['name'], $attr['value']);
2237                                 }
2238                             }
2239                         }
2240                         break;
2241
2242                     /* A start tag whose tag name is one of: "address",
2243                     "blockquote", "center", "dir", "div", "dl", "fieldset",
2244                     "listing", "menu", "ol", "p", "ul" */
2245                     case 'address':
2246                     case 'blockquote':
2247                     case 'center':
2248                     case 'dir':
2249                     case 'div':
2250                     case 'dl':
2251                     case 'fieldset':
2252                     case 'listing':
2253                     case 'menu':
2254                     case 'ol':
2255                     case 'p':
2256                     case 'ul':
2257                         /* If the stack of open elements has a p element in scope,
2258                         then act as if an end tag with the tag name p had been
2259                         seen. */
2260                         if ($this->elementInScope('p')) {
2261                             $this->emitToken(
2262                                 array(
2263                                     'name' => 'p',
2264                                     'type' => HTML5::ENDTAG
2265                                 )
2266                             );
2267                         }
2268
2269                         /* Insert an HTML element for the token. */
2270                         $this->insertElement($token);
2271                         break;
2272
2273                     /* A start tag whose tag name is "form" */
2274                     case 'form':
2275                         /* If the form element pointer is not null, ignore the
2276                         token with a parse error. */
2277                         if ($this->form_pointer !== null) {
2278                             // Ignore.
2279
2280                             /* Otherwise: */
2281                         } else {
2282                             /* If the stack of open elements has a p element in
2283                             scope, then act as if an end tag with the tag name p
2284                             had been seen. */
2285                             if ($this->elementInScope('p')) {
2286                                 $this->emitToken(
2287                                     array(
2288                                         'name' => 'p',
2289                                         'type' => HTML5::ENDTAG
2290                                     )
2291                                 );
2292                             }
2293
2294                             /* Insert an HTML element for the token, and set the
2295                             form element pointer to point to the element created. */
2296                             $element = $this->insertElement($token);
2297                             $this->form_pointer = $element;
2298                         }
2299                         break;
2300
2301                     /* A start tag whose tag name is "li", "dd" or "dt" */
2302                     case 'li':
2303                     case 'dd':
2304                     case 'dt':
2305                         /* If the stack of open elements has a p  element in scope,
2306                         then act as if an end tag with the tag name p had been
2307                         seen. */
2308                         if ($this->elementInScope('p')) {
2309                             $this->emitToken(
2310                                 array(
2311                                     'name' => 'p',
2312                                     'type' => HTML5::ENDTAG
2313                                 )
2314                             );
2315                         }
2316
2317                         $stack_length = count($this->stack) - 1;
2318
2319                         for ($n = $stack_length; 0 <= $n; $n--) {
2320                             /* 1. Initialise node to be the current node (the
2321                             bottommost node of the stack). */
2322                             $stop = false;
2323                             $node = $this->stack[$n];
2324                             $cat = $this->getElementCategory($node->tagName);
2325
2326                             /* 2. If node is an li, dd or dt element, then pop all
2327                             the    nodes from the current node up to node, including
2328                             node, then stop this algorithm. */
2329                             if ($token['name'] === $node->tagName || ($token['name'] !== 'li'
2330                                     && ($node->tagName === 'dd' || $node->tagName === 'dt'))
2331                             ) {
2332                                 for ($x = $stack_length; $x >= $n; $x--) {
2333                                     array_pop($this->stack);
2334                                 }
2335
2336                                 break;
2337                             }
2338
2339                             /* 3. If node is not in the formatting category, and is
2340                             not    in the phrasing category, and is not an address or
2341                             div element, then stop this algorithm. */
2342                             if ($cat !== self::FORMATTING && $cat !== self::PHRASING &&
2343                                 $node->tagName !== 'address' && $node->tagName !== 'div'
2344                             ) {
2345                                 break;
2346                             }
2347                         }
2348
2349                         /* Finally, insert an HTML element with the same tag
2350                         name as the    token's. */
2351                         $this->insertElement($token);
2352                         break;
2353
2354                     /* A start tag token whose tag name is "plaintext" */
2355                     case 'plaintext':
2356                         /* If the stack of open elements has a p  element in scope,
2357                         then act as if an end tag with the tag name p had been
2358                         seen. */
2359                         if ($this->elementInScope('p')) {
2360                             $this->emitToken(
2361                                 array(
2362                                     'name' => 'p',
2363                                     'type' => HTML5::ENDTAG
2364                                 )
2365                             );
2366                         }
2367
2368                         /* Insert an HTML element for the token. */
2369                         $this->insertElement($token);
2370
2371                         return HTML5::PLAINTEXT;
2372                         break;
2373
2374                     /* A start tag whose tag name is one of: "h1", "h2", "h3", "h4",
2375                     "h5", "h6" */
2376                     case 'h1':
2377                     case 'h2':
2378                     case 'h3':
2379                     case 'h4':
2380                     case 'h5':
2381                     case 'h6':
2382                         /* If the stack of open elements has a p  element in scope,
2383                         then act as if an end tag with the tag name p had been seen. */
2384                         if ($this->elementInScope('p')) {
2385                             $this->emitToken(
2386                                 array(
2387                                     'name' => 'p',
2388                                     'type' => HTML5::ENDTAG
2389                                 )
2390                             );
2391                         }
2392
2393                         /* If the stack of open elements has in scope an element whose
2394                         tag name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
2395                         this is a parse error; pop elements from the stack until an
2396                         element with one of those tag names has been popped from the
2397                         stack. */
2398                         while ($this->elementInScope(array('h1', 'h2', 'h3', 'h4', 'h5', 'h6'))) {
2399                             array_pop($this->stack);
2400                         }
2401
2402                         /* Insert an HTML element for the token. */
2403                         $this->insertElement($token);
2404                         break;
2405
2406                     /* A start tag whose tag name is "a" */
2407                     case 'a':
2408                         /* If the list of active formatting elements contains
2409                         an element whose tag name is "a" between the end of the
2410                         list and the last marker on the list (or the start of
2411                         the list if there is no marker on the list), then this
2412                         is a parse error; act as if an end tag with the tag name
2413                         "a" had been seen, then remove that element from the list
2414                         of active formatting elements and the stack of open
2415                         elements if the end tag didn't already remove it (it
2416                         might not have if the element is not in table scope). */
2417                         $leng = count($this->a_formatting);
2418
2419                         for ($n = $leng - 1; $n >= 0; $n--) {
2420                             if ($this->a_formatting[$n] === self::MARKER) {
2421                                 break;
2422
2423                             } elseif ($this->a_formatting[$n]->nodeName === 'a') {
2424                                 $this->emitToken(
2425                                     array(
2426                                         'name' => 'a',
2427                                         'type' => HTML5::ENDTAG
2428                                     )
2429                                 );
2430                                 break;
2431                             }
2432                         }
2433
2434                         /* Reconstruct the active formatting elements, if any. */
2435                         $this->reconstructActiveFormattingElements();
2436
2437                         /* Insert an HTML element for the token. */
2438                         $el = $this->insertElement($token);
2439
2440                         /* Add that element to the list of active formatting
2441                         elements. */
2442                         $this->a_formatting[] = $el;
2443                         break;
2444
2445                     /* A start tag whose tag name is one of: "b", "big", "em", "font",
2446                     "i", "nobr", "s", "small", "strike", "strong", "tt", "u" */
2447                     case 'b':
2448                     case 'big':
2449                     case 'em':
2450                     case 'font':
2451                     case 'i':
2452                     case 'nobr':
2453                     case 's':
2454                     case 'small':
2455                     case 'strike':
2456                     case 'strong':
2457                     case 'tt':
2458                     case 'u':
2459                         /* Reconstruct the active formatting elements, if any. */
2460                         $this->reconstructActiveFormattingElements();
2461
2462                         /* Insert an HTML element for the token. */
2463                         $el = $this->insertElement($token);
2464
2465                         /* Add that element to the list of active formatting
2466                         elements. */
2467                         $this->a_formatting[] = $el;
2468                         break;
2469
2470                     /* A start tag token whose tag name is "button" */
2471                     case 'button':
2472                         /* If the stack of open elements has a button element in scope,
2473                         then this is a parse error; act as if an end tag with the tag
2474                         name "button" had been seen, then reprocess the token. (We don't
2475                         do that. Unnecessary.) */
2476                         if ($this->elementInScope('button')) {
2477                             $this->inBody(
2478                                 array(
2479                                     'name' => 'button',
2480                                     'type' => HTML5::ENDTAG
2481                                 )
2482                             );
2483                         }
2484
2485                         /* Reconstruct the active formatting elements, if any. */
2486                         $this->reconstructActiveFormattingElements();
2487
2488                         /* Insert an HTML element for the token. */
2489                         $this->insertElement($token);
2490
2491                         /* Insert a marker at the end of the list of active
2492                         formatting elements. */
2493                         $this->a_formatting[] = self::MARKER;
2494                         break;
2495
2496                     /* A start tag token whose tag name is one of: "marquee", "object" */
2497                     case 'marquee':
2498                     case 'object':
2499                         /* Reconstruct the active formatting elements, if any. */
2500                         $this->reconstructActiveFormattingElements();
2501
2502                         /* Insert an HTML element for the token. */
2503                         $this->insertElement($token);
2504
2505                         /* Insert a marker at the end of the list of active
2506                         formatting elements. */
2507                         $this->a_formatting[] = self::MARKER;
2508                         break;
2509
2510                     /* A start tag token whose tag name is "xmp" */
2511                     case 'xmp':
2512                         /* Reconstruct the active formatting elements, if any. */
2513                         $this->reconstructActiveFormattingElements();
2514
2515                         /* Insert an HTML element for the token. */
2516                         $this->insertElement($token);
2517
2518                         /* Switch the content model flag to the CDATA state. */
2519                         return HTML5::CDATA;
2520                         break;
2521
2522                     /* A start tag whose tag name is "table" */
2523                     case 'table':
2524                         /* If the stack of open elements has a p element in scope,
2525                         then act as if an end tag with the tag name p had been seen. */
2526                         if ($this->elementInScope('p')) {
2527                             $this->emitToken(
2528                                 array(
2529                                     'name' => 'p',
2530                                     'type' => HTML5::ENDTAG
2531                                 )
2532                             );
2533                         }
2534
2535                         /* Insert an HTML element for the token. */
2536                         $this->insertElement($token);
2537
2538                         /* Change the insertion mode to "in table". */
2539                         $this->mode = self::IN_TABLE;
2540                         break;
2541
2542                     /* A start tag whose tag name is one of: "area", "basefont",
2543                     "bgsound", "br", "embed", "img", "param", "spacer", "wbr" */
2544                     case 'area':
2545                     case 'basefont':
2546                     case 'bgsound':
2547                     case 'br':
2548                     case 'embed':
2549                     case 'img':
2550                     case 'param':
2551                     case 'spacer':
2552                     case 'wbr':
2553                         /* Reconstruct the active formatting elements, if any. */
2554                         $this->reconstructActiveFormattingElements();
2555
2556                         /* Insert an HTML element for the token. */
2557                         $this->insertElement($token);
2558
2559                         /* Immediately pop the current node off the stack of open elements. */
2560                         array_pop($this->stack);
2561                         break;
2562
2563                     /* A start tag whose tag name is "hr" */
2564                     case 'hr':
2565                         /* If the stack of open elements has a p element in scope,
2566                         then act as if an end tag with the tag name p had been seen. */
2567                         if ($this->elementInScope('p')) {
2568                             $this->emitToken(
2569                                 array(
2570                                     'name' => 'p',
2571                                     'type' => HTML5::ENDTAG
2572                                 )
2573                             );
2574                         }
2575
2576                         /* Insert an HTML element for the token. */
2577                         $this->insertElement($token);
2578
2579                         /* Immediately pop the current node off the stack of open elements. */
2580                         array_pop($this->stack);
2581                         break;
2582
2583                     /* A start tag whose tag name is "image" */
2584                     case 'image':
2585                         /* Parse error. Change the token's tag name to "img" and
2586                         reprocess it. (Don't ask.) */
2587                         $token['name'] = 'img';
2588                         return $this->inBody($token);
2589                         break;
2590
2591                     /* A start tag whose tag name is "input" */
2592                     case 'input':
2593                         /* Reconstruct the active formatting elements, if any. */
2594                         $this->reconstructActiveFormattingElements();
2595
2596                         /* Insert an input element for the token. */
2597                         $element = $this->insertElement($token, false);
2598
2599                         /* If the form element pointer is not null, then associate the
2600                         input element with the form element pointed to by the form
2601                         element pointer. */
2602                         $this->form_pointer !== null
2603                             ? $this->form_pointer->appendChild($element)
2604                             : end($this->stack)->appendChild($element);
2605
2606                         /* Pop that input element off the stack of open elements. */
2607                         array_pop($this->stack);
2608                         break;
2609
2610                     /* A start tag whose tag name is "isindex" */
2611                     case 'isindex':
2612                         /* Parse error. */
2613                         // w/e
2614
2615                         /* If the form element pointer is not null,
2616                         then ignore the token. */
2617                         if ($this->form_pointer === null) {
2618                             /* Act as if a start tag token with the tag name "form" had
2619                             been seen. */
2620                             $this->inBody(
2621                                 array(
2622                                     'name' => 'body',
2623                                     'type' => HTML5::STARTTAG,
2624                                     'attr' => array()
2625                                 )
2626                             );
2627
2628                             /* Act as if a start tag token with the tag name "hr" had
2629                             been seen. */
2630                             $this->inBody(
2631                                 array(
2632                                     'name' => 'hr',
2633                                     'type' => HTML5::STARTTAG,
2634                                     'attr' => array()
2635                                 )
2636                             );
2637
2638                             /* Act as if a start tag token with the tag name "p" had
2639                             been seen. */
2640                             $this->inBody(
2641                                 array(
2642                                     'name' => 'p',
2643                                     'type' => HTML5::STARTTAG,
2644                                     'attr' => array()
2645                                 )
2646                             );
2647
2648                             /* Act as if a start tag token with the tag name "label"
2649                             had been seen. */
2650                             $this->inBody(
2651                                 array(
2652                                     'name' => 'label',
2653                                     'type' => HTML5::STARTTAG,
2654                                     'attr' => array()
2655                                 )
2656                             );
2657
2658                             /* Act as if a stream of character tokens had been seen. */
2659                             $this->insertText(
2660                                 'This is a searchable index. ' .
2661                                 'Insert your search keywords here: '
2662                             );
2663
2664                             /* Act as if a start tag token with the tag name "input"
2665                             had been seen, with all the attributes from the "isindex"
2666                             token, except with the "name" attribute set to the value
2667                             "isindex" (ignoring any explicit "name" attribute). */
2668                             $attr = $token['attr'];
2669                             $attr[] = array('name' => 'name', 'value' => 'isindex');
2670
2671                             $this->inBody(
2672                                 array(
2673                                     'name' => 'input',
2674                                     'type' => HTML5::STARTTAG,
2675                                     'attr' => $attr
2676                                 )
2677                             );
2678
2679                             /* Act as if a stream of character tokens had been seen
2680                             (see below for what they should say). */
2681                             $this->insertText(
2682                                 'This is a searchable index. ' .
2683                                 'Insert your search keywords here: '
2684                             );
2685
2686                             /* Act as if an end tag token with the tag name "label"
2687                             had been seen. */
2688                             $this->inBody(
2689                                 array(
2690                                     'name' => 'label',
2691                                     'type' => HTML5::ENDTAG
2692                                 )
2693                             );
2694
2695                             /* Act as if an end tag token with the tag name "p" had
2696                             been seen. */
2697                             $this->inBody(
2698                                 array(
2699                                     'name' => 'p',
2700                                     'type' => HTML5::ENDTAG
2701                                 )
2702                             );
2703
2704                             /* Act as if a start tag token with the tag name "hr" had
2705                             been seen. */
2706                             $this->inBody(
2707                                 array(
2708                                     'name' => 'hr',
2709                                     'type' => HTML5::ENDTAG
2710                                 )
2711                             );
2712
2713                             /* Act as if an end tag token with the tag name "form" had
2714                             been seen. */
2715                             $this->inBody(
2716                                 array(
2717                                     'name' => 'form',
2718                                     'type' => HTML5::ENDTAG
2719                                 )
2720                             );
2721                         }
2722                         break;
2723
2724                     /* A start tag whose tag name is "textarea" */
2725                     case 'textarea':
2726                         $this->insertElement($token);
2727
2728                         /* Switch the tokeniser's content model flag to the
2729                         RCDATA state. */
2730                         return HTML5::RCDATA;
2731                         break;
2732
2733                     /* A start tag whose tag name is one of: "iframe", "noembed",
2734                     "noframes" */
2735                     case 'iframe':
2736                     case 'noembed':
2737                     case 'noframes':
2738                         $this->insertElement($token);
2739
2740                         /* Switch the tokeniser's content model flag to the CDATA state. */
2741                         return HTML5::CDATA;
2742                         break;
2743
2744                     /* A start tag whose tag name is "select" */
2745                     case 'select':
2746                         /* Reconstruct the active formatting elements, if any. */
2747                         $this->reconstructActiveFormattingElements();
2748
2749                         /* Insert an HTML element for the token. */
2750                         $this->insertElement($token);
2751
2752                         /* Change the insertion mode to "in select". */
2753                         $this->mode = self::IN_SELECT;
2754                         break;
2755
2756                     /* A start or end tag whose tag name is one of: "caption", "col",
2757                     "colgroup", "frame", "frameset", "head", "option", "optgroup",
2758                     "tbody", "td", "tfoot", "th", "thead", "tr". */
2759                     case 'caption':
2760                     case 'col':
2761                     case 'colgroup':
2762                     case 'frame':
2763                     case 'frameset':
2764                     case 'head':
2765                     case 'option':
2766                     case 'optgroup':
2767                     case 'tbody':
2768                     case 'td':
2769                     case 'tfoot':
2770                     case 'th':
2771                     case 'thead':
2772                     case 'tr':
2773                         // Parse error. Ignore the token.
2774                         break;
2775
2776                     /* A start or end tag whose tag name is one of: "event-source",
2777                     "section", "nav", "article", "aside", "header", "footer",
2778                     "datagrid", "command" */
2779                     case 'event-source':
2780                     case 'section':
2781                     case 'nav':
2782                     case 'article':
2783                     case 'aside':
2784                     case 'header':
2785                     case 'footer':
2786                     case 'datagrid':
2787                     case 'command':
2788                         // Work in progress!
2789                         break;
2790
2791                     /* A start tag token not covered by the previous entries */
2792                     default:
2793                         /* Reconstruct the active formatting elements, if any. */
2794                         $this->reconstructActiveFormattingElements();
2795
2796                         $this->insertElement($token, true, true);
2797                         break;
2798                 }
2799                 break;
2800
2801             case HTML5::ENDTAG:
2802                 switch ($token['name']) {
2803                     /* An end tag with the tag name "body" */
2804                     case 'body':
2805                         /* If the second element in the stack of open elements is
2806                         not a body element, this is a parse error. Ignore the token.
2807                         (innerHTML case) */
2808                         if (count($this->stack) < 2 || $this->stack[1]->nodeName !== 'body') {
2809                             // Ignore.
2810
2811                             /* If the current node is not the body element, then this
2812                             is a parse error. */
2813                         } elseif (end($this->stack)->nodeName !== 'body') {
2814                             // Parse error.
2815                         }
2816
2817                         /* Change the insertion mode to "after body". */
2818                         $this->mode = self::AFTER_BODY;
2819                         break;
2820
2821                     /* An end tag with the tag name "html" */
2822                     case 'html':
2823                         /* Act as if an end tag with tag name "body" had been seen,
2824                         then, if that token wasn't ignored, reprocess the current
2825                         token. */
2826                         $this->inBody(
2827                             array(
2828                                 'name' => 'body',
2829                                 'type' => HTML5::ENDTAG
2830                             )
2831                         );
2832
2833                         return $this->afterBody($token);
2834                         break;
2835
2836                     /* An end tag whose tag name is one of: "address", "blockquote",
2837                     "center", "dir", "div", "dl", "fieldset", "listing", "menu",
2838                     "ol", "pre", "ul" */
2839                     case 'address':
2840                     case 'blockquote':
2841                     case 'center':
2842                     case 'dir':
2843                     case 'div':
2844                     case 'dl':
2845                     case 'fieldset':
2846                     case 'listing':
2847                     case 'menu':
2848                     case 'ol':
2849                     case 'pre':
2850                     case 'ul':
2851                         /* If the stack of open elements has an element in scope
2852                         with the same tag name as that of the token, then generate
2853                         implied end tags. */
2854                         if ($this->elementInScope($token['name'])) {
2855                             $this->generateImpliedEndTags();
2856
2857                             /* Now, if the current node is not an element with
2858                             the same tag name as that of the token, then this
2859                             is a parse error. */
2860                             // w/e
2861
2862                             /* If the stack of open elements has an element in
2863                             scope with the same tag name as that of the token,
2864                             then pop elements from this stack until an element
2865                             with that tag name has been popped from the stack. */
2866                             for ($n = count($this->stack) - 1; $n >= 0; $n--) {
2867                                 if ($this->stack[$n]->nodeName === $token['name']) {
2868                                     $n = -1;
2869                                 }
2870
2871                                 array_pop($this->stack);
2872                             }
2873                         }
2874                         break;
2875
2876                     /* An end tag whose tag name is "form" */
2877                     case 'form':
2878                         /* If the stack of open elements has an element in scope
2879                         with the same tag name as that of the token, then generate
2880                         implied    end tags. */
2881                         if ($this->elementInScope($token['name'])) {
2882                             $this->generateImpliedEndTags();
2883
2884                         }
2885
2886                         if (end($this->stack)->nodeName !== $token['name']) {
2887                             /* Now, if the current node is not an element with the
2888                             same tag name as that of the token, then this is a parse
2889                             error. */
2890                             // w/e
2891
2892                         } else {
2893                             /* Otherwise, if the current node is an element with
2894                             the same tag name as that of the token pop that element
2895                             from the stack. */
2896                             array_pop($this->stack);
2897                         }
2898
2899                         /* In any case, set the form element pointer to null. */
2900                         $this->form_pointer = null;
2901                         break;
2902
2903                     /* An end tag whose tag name is "p" */
2904                     case 'p':
2905                         /* If the stack of open elements has a p element in scope,
2906                         then generate implied end tags, except for p elements. */
2907                         if ($this->elementInScope('p')) {
2908                             $this->generateImpliedEndTags(array('p'));
2909
2910                             /* If the current node is not a p element, then this is
2911                             a parse error. */
2912                             // k
2913
2914                             /* If the stack of open elements has a p element in
2915                             scope, then pop elements from this stack until the stack
2916                             no longer has a p element in scope. */
2917                             for ($n = count($this->stack) - 1; $n >= 0; $n--) {
2918                                 if ($this->elementInScope('p')) {
2919                                     array_pop($this->stack);
2920
2921                                 } else {
2922                                     break;
2923                                 }
2924                             }
2925                         }
2926                         break;
2927
2928                     /* An end tag whose tag name is "dd", "dt", or "li" */
2929                     case 'dd':
2930                     case 'dt':
2931                     case 'li':
2932                         /* If the stack of open elements has an element in scope
2933                         whose tag name matches the tag name of the token, then
2934                         generate implied end tags, except for elements with the
2935                         same tag name as the token. */
2936                         if ($this->elementInScope($token['name'])) {
2937                             $this->generateImpliedEndTags(array($token['name']));
2938
2939                             /* If the current node is not an element with the same
2940                             tag name as the token, then this is a parse error. */
2941                             // w/e
2942
2943                             /* If the stack of open elements has an element in scope
2944                             whose tag name matches the tag name of the token, then
2945                             pop elements from this stack until an element with that
2946                             tag name has been popped from the stack. */
2947                             for ($n = count($this->stack) - 1; $n >= 0; $n--) {
2948                                 if ($this->stack[$n]->nodeName === $token['name']) {
2949                                     $n = -1;
2950                                 }
2951
2952                                 array_pop($this->stack);
2953                             }
2954                         }
2955                         break;
2956
2957                     /* An end tag whose tag name is one of: "h1", "h2", "h3", "h4",
2958                     "h5", "h6" */
2959                     case 'h1':
2960                     case 'h2':
2961                     case 'h3':
2962                     case 'h4':
2963                     case 'h5':
2964                     case 'h6':
2965                         $elements = array('h1', 'h2', 'h3', 'h4', 'h5', 'h6');
2966
2967                         /* If the stack of open elements has in scope an element whose
2968                         tag name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
2969                         generate implied end tags. */
2970                         if ($this->elementInScope($elements)) {
2971                             $this->generateImpliedEndTags();
2972
2973                             /* Now, if the current node is not an element with the same
2974                             tag name as that of the token, then this is a parse error. */
2975                             // w/e
2976
2977                             /* If the stack of open elements has in scope an element
2978                             whose tag name is one of "h1", "h2", "h3", "h4", "h5", or
2979                             "h6", then pop elements from the stack until an element
2980                             with one of those tag names has been popped from the stack. */
2981                             while ($this->elementInScope($elements)) {
2982                                 array_pop($this->stack);
2983                             }
2984                         }
2985                         break;
2986
2987                     /* An end tag whose tag name is one of: "a", "b", "big", "em",
2988                     "font", "i", "nobr", "s", "small", "strike", "strong", "tt", "u" */
2989                     case 'a':
2990                     case 'b':
2991                     case 'big':
2992                     case 'em':
2993                     case 'font':
2994                     case 'i':
2995                     case 'nobr':
2996                     case 's':
2997                     case 'small':
2998                     case 'strike':
2999                     case 'strong':
3000                     case 'tt':
3001                     case 'u':
3002                         /* 1. Let the formatting element be the last element in
3003                         the list of active formatting elements that:
3004                             * is between the end of the list and the last scope
3005                             marker in the list, if any, or the start of the list
3006                             otherwise, and
3007                             * has the same tag name as the token.
3008                         */
3009                         while (true) {
3010                             for ($a = count($this->a_formatting) - 1; $a >= 0; $a--) {
3011                                 if ($this->a_formatting[$a] === self::MARKER) {
3012                                     break;
3013
3014                                 } elseif ($this->a_formatting[$a]->tagName === $token['name']) {
3015                                     $formatting_element = $this->a_formatting[$a];
3016                                     $in_stack = in_array($formatting_element, $this->stack, true);
3017                                     $fe_af_pos = $a;
3018                                     break;
3019                                 }
3020                             }
3021
3022                             /* If there is no such node, or, if that node is
3023                             also in the stack of open elements but the element
3024                             is not in scope, then this is a parse error. Abort
3025                             these steps. The token is ignored. */
3026                             if (!isset($formatting_element) || ($in_stack &&
3027                                     !$this->elementInScope($token['name']))
3028                             ) {
3029                                 break;
3030
3031                                 /* Otherwise, if there is such a node, but that node
3032                                 is not in the stack of open elements, then this is a
3033                                 parse error; remove the element from the list, and
3034                                 abort these steps. */
3035                             } elseif (isset($formatting_element) && !$in_stack) {
3036                                 unset($this->a_formatting[$fe_af_pos]);
3037                                 $this->a_formatting = array_merge($this->a_formatting);
3038                                 break;
3039                             }
3040
3041                             /* 2. Let the furthest block be the topmost node in the
3042                             stack of open elements that is lower in the stack
3043                             than the formatting element, and is not an element in
3044                             the phrasing or formatting categories. There might
3045                             not be one. */
3046                             $fe_s_pos = array_search($formatting_element, $this->stack, true);
3047                             $length = count($this->stack);
3048
3049                             for ($s = $fe_s_pos + 1; $s < $length; $s++) {
3050                                 $category = $this->getElementCategory($this->stack[$s]->nodeName);
3051
3052                                 if ($category !== self::PHRASING && $category !== self::FORMATTING) {
3053                                     $furthest_block = $this->stack[$s];
3054                                 }
3055                             }
3056
3057                             /* 3. If there is no furthest block, then the UA must
3058                             skip the subsequent steps and instead just pop all
3059                             the nodes from the bottom of the stack of open
3060                             elements, from the current node up to the formatting
3061                             element, and remove the formatting element from the
3062                             list of active formatting elements. */
3063                             if (!isset($furthest_block)) {
3064                                 for ($n = $length - 1; $n >= $fe_s_pos; $n--) {
3065                                     array_pop($this->stack);
3066                                 }
3067
3068                                 unset($this->a_formatting[$fe_af_pos]);
3069                                 $this->a_formatting = array_merge($this->a_formatting);
3070                                 break;
3071                             }
3072
3073                             /* 4. Let the common ancestor be the element
3074                             immediately above the formatting element in the stack
3075                             of open elements. */
3076                             $common_ancestor = $this->stack[$fe_s_pos - 1];
3077
3078                             /* 5. If the furthest block has a parent node, then
3079                             remove the furthest block from its parent node. */
3080                             if ($furthest_block->parentNode !== null) {
3081                                 $furthest_block->parentNode->removeChild($furthest_block);
3082                             }
3083
3084                             /* 6. Let a bookmark note the position of the
3085                             formatting element in the list of active formatting
3086                             elements relative to the elements on either side
3087                             of it in the list. */
3088                             $bookmark = $fe_af_pos;
3089
3090                             /* 7. Let node and last node  be the furthest block.
3091                             Follow these steps: */
3092                             $node = $furthest_block;
3093                             $last_node = $furthest_block;
3094
3095                             while (true) {
3096                                 for ($n = array_search($node, $this->stack, true) - 1; $n >= 0; $n--) {
3097                                     /* 7.1 Let node be the element immediately
3098                                     prior to node in the stack of open elements. */
3099                                     $node = $this->stack[$n];
3100
3101                                     /* 7.2 If node is not in the list of active
3102                                     formatting elements, then remove node from
3103                                     the stack of open elements and then go back
3104                                     to step 1. */
3105                                     if (!in_array($node, $this->a_formatting, true)) {
3106                                         unset($this->stack[$n]);
3107                                         $this->stack = array_merge($this->stack);
3108
3109                                     } else {
3110                                         break;
3111                                     }
3112                                 }
3113
3114                                 /* 7.3 Otherwise, if node is the formatting
3115                                 element, then go to the next step in the overall
3116                                 algorithm. */
3117                                 if ($node === $formatting_element) {
3118                                     break;
3119
3120                                     /* 7.4 Otherwise, if last node is the furthest
3121                                     block, then move the aforementioned bookmark to
3122                                     be immediately after the node in the list of
3123                                     active formatting elements. */
3124                                 } elseif ($last_node === $furthest_block) {
3125                                     $bookmark = array_search($node, $this->a_formatting, true) + 1;
3126                                 }
3127
3128                                 /* 7.5 If node has any children, perform a
3129                                 shallow clone of node, replace the entry for
3130                                 node in the list of active formatting elements
3131                                 with an entry for the clone, replace the entry
3132                                 for node in the stack of open elements with an
3133                                 entry for the clone, and let node be the clone. */
3134                                 if ($node->hasChildNodes()) {
3135                                     $clone = $node->cloneNode();
3136                                     $s_pos = array_search($node, $this->stack, true);
3137                                     $a_pos = array_search($node, $this->a_formatting, true);
3138
3139                                     $this->stack[$s_pos] = $clone;
3140                                     $this->a_formatting[$a_pos] = $clone;
3141                                     $node = $clone;
3142                                 }
3143
3144                                 /* 7.6 Insert last node into node, first removing
3145                                 it from its previous parent node if any. */
3146                                 if ($last_node->parentNode !== null) {
3147                                     $last_node->parentNode->removeChild($last_node);
3148                                 }
3149
3150                                 $node->appendChild($last_node);
3151
3152                                 /* 7.7 Let last node be node. */
3153                                 $last_node = $node;
3154                             }
3155
3156                             /* 8. Insert whatever last node ended up being in
3157                             the previous step into the common ancestor node,
3158                             first removing it from its previous parent node if
3159                             any. */
3160                             if ($last_node->parentNode !== null) {
3161                                 $last_node->parentNode->removeChild($last_node);
3162                             }
3163
3164                             $common_ancestor->appendChild($last_node);
3165
3166                             /* 9. Perform a shallow clone of the formatting
3167                             element. */
3168                             $clone = $formatting_element->cloneNode();
3169
3170                             /* 10. Take all of the child nodes of the furthest
3171                             block and append them to the clone created in the
3172                             last step. */
3173                             while ($furthest_block->hasChildNodes()) {
3174                                 $child = $furthest_block->firstChild;
3175                                 $furthest_block->removeChild($child);
3176                                 $clone->appendChild($child);
3177                             }
3178
3179                             /* 11. Append that clone to the furthest block. */
3180                             $furthest_block->appendChild($clone);
3181
3182                             /* 12. Remove the formatting element from the list
3183                             of active formatting elements, and insert the clone
3184                             into the list of active formatting elements at the
3185                             position of the aforementioned bookmark. */
3186                             $fe_af_pos = array_search($formatting_element, $this->a_formatting, true);
3187                             unset($this->a_formatting[$fe_af_pos]);
3188                             $this->a_formatting = array_merge($this->a_formatting);
3189
3190                             $af_part1 = array_slice($this->a_formatting, 0, $bookmark - 1);
3191                             $af_part2 = array_slice($this->a_formatting, $bookmark, count($this->a_formatting));
3192                             $this->a_formatting = array_merge($af_part1, array($clone), $af_part2);
3193
3194                             /* 13. Remove the formatting element from the stack
3195                             of open elements, and insert the clone into the stack
3196                             of open elements immediately after (i.e. in a more
3197                             deeply nested position than) the position of the
3198                             furthest block in that stack. */
3199                             $fe_s_pos = array_search($formatting_element, $this->stack, true);
3200                             $fb_s_pos = array_search($furthest_block, $this->stack, true);
3201                             unset($this->stack[$fe_s_pos]);
3202
3203                             $s_part1 = array_slice($this->stack, 0, $fb_s_pos);
3204                             $s_part2 = array_slice($this->stack, $fb_s_pos + 1, count($this->stack));
3205                             $this->stack = array_merge($s_part1, array($clone), $s_part2);
3206
3207                             /* 14. Jump back to step 1 in this series of steps. */
3208                             unset($formatting_element, $fe_af_pos, $fe_s_pos, $furthest_block);
3209                         }
3210                         break;
3211
3212                     /* An end tag token whose tag name is one of: "button",
3213                     "marquee", "object" */
3214                     case 'button':
3215                     case 'marquee':
3216                     case 'object':
3217                         /* If the stack of open elements has an element in scope whose
3218                         tag name matches the tag name of the token, then generate implied
3219                         tags. */
3220                         if ($this->elementInScope($token['name'])) {
3221                             $this->generateImpliedEndTags();
3222
3223                             /* Now, if the current node is not an element with the same
3224                             tag name as the token, then this is a parse error. */
3225                             // k
3226
3227                             /* Now, if the stack of open elements has an element in scope
3228                             whose tag name matches the tag name of the token, then pop
3229                             elements from the stack until that element has been popped from
3230                             the stack, and clear the list of active formatting elements up
3231                             to the last marker. */
3232                             for ($n = count($this->stack) - 1; $n >= 0; $n--) {
3233                                 if ($this->stack[$n]->nodeName === $token['name']) {
3234                                     $n = -1;
3235                                 }
3236
3237                                 array_pop($this->stack);
3238                             }
3239
3240                             $marker = end(array_keys($this->a_formatting, self::MARKER, true));
3241
3242                             for ($n = count($this->a_formatting) - 1; $n > $marker; $n--) {
3243                                 array_pop($this->a_formatting);
3244                             }
3245                         }
3246                         break;
3247
3248                     /* Or an end tag whose tag name is one of: "area", "basefont",
3249                     "bgsound", "br", "embed", "hr", "iframe", "image", "img",
3250                     "input", "isindex", "noembed", "noframes", "param", "select",
3251                     "spacer", "table", "textarea", "wbr" */
3252                     case 'area':
3253                     case 'basefont':
3254                     case 'bgsound':
3255                     case 'br':
3256                     case 'embed':
3257                     case 'hr':
3258                     case 'iframe':
3259                     case 'image':
3260                     case 'img':
3261                     case 'input':
3262                     case 'isindex':
3263                     case 'noembed':
3264                     case 'noframes':
3265                     case 'param':
3266                     case 'select':
3267                     case 'spacer':
3268                     case 'table':
3269                     case 'textarea':
3270                     case 'wbr':
3271                         // Parse error. Ignore the token.
3272                         break;
3273
3274                     /* An end tag token not covered by the previous entries */
3275                     default:
3276                         for ($n = count($this->stack) - 1; $n >= 0; $n--) {
3277                             /* Initialise node to be the current node (the bottommost
3278                             node of the stack). */
3279                             $node = end($this->stack);
3280
3281                             /* If node has the same tag name as the end tag token,
3282                             then: */
3283                             if ($token['name'] === $node->nodeName) {
3284                                 /* Generate implied end tags. */
3285                                 $this->generateImpliedEndTags();
3286
3287                                 /* If the tag name of the end tag token does not
3288                                 match the tag name of the current node, this is a
3289                                 parse error. */
3290                                 // k
3291
3292                                 /* Pop all the nodes from the current node up to
3293                                 node, including node, then stop this algorithm. */
3294                                 for ($x = count($this->stack) - $n; $x >= $n; $x--) {
3295                                     array_pop($this->stack);
3296                                 }
3297
3298                             } else {
3299                                 $category = $this->getElementCategory($node);
3300
3301                                 if ($category !== self::SPECIAL && $category !== self::SCOPING) {
3302                                     /* Otherwise, if node is in neither the formatting
3303                                     category nor the phrasing category, then this is a
3304                                     parse error. Stop this algorithm. The end tag token
3305                                     is ignored. */
3306                                     return false;
3307                                 }
3308                             }
3309                         }
3310                         break;
3311                 }
3312                 break;
3313         }
3314     }
3315
3316     private function inTable($token)
3317     {
3318         $clear = array('html', 'table');
3319
3320         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
3321         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
3322         or U+0020 SPACE */
3323         if ($token['type'] === HTML5::CHARACTR &&
3324             preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])
3325         ) {
3326             /* Append the character to the current node. */
3327             $text = $this->dom->createTextNode($token['data']);
3328             end($this->stack)->appendChild($text);
3329
3330             /* A comment token */
3331         } elseif ($token['type'] === HTML5::COMMENT) {
3332             /* Append a Comment node to the current node with the data
3333             attribute set to the data given in the comment token. */
3334             $comment = $this->dom->createComment($token['data']);
3335             end($this->stack)->appendChild($comment);
3336
3337             /* A start tag whose tag name is "caption" */
3338         } elseif ($token['type'] === HTML5::STARTTAG &&
3339             $token['name'] === 'caption'
3340         ) {
3341             /* Clear the stack back to a table context. */
3342             $this->clearStackToTableContext($clear);
3343
3344             /* Insert a marker at the end of the list of active
3345             formatting elements. */
3346             $this->a_formatting[] = self::MARKER;
3347
3348             /* Insert an HTML element for the token, then switch the
3349             insertion mode to "in caption". */
3350             $this->insertElement($token);
3351             $this->mode = self::IN_CAPTION;
3352
3353             /* A start tag whose tag name is "colgroup" */
3354         } elseif ($token['type'] === HTML5::STARTTAG &&
3355             $token['name'] === 'colgroup'
3356         ) {
3357             /* Clear the stack back to a table context. */
3358             $this->clearStackToTableContext($clear);
3359
3360             /* Insert an HTML element for the token, then switch the
3361             insertion mode to "in column group". */
3362             $this->insertElement($token);
3363             $this->mode = self::IN_CGROUP;
3364
3365             /* A start tag whose tag name is "col" */
3366         } elseif ($token['type'] === HTML5::STARTTAG &&
3367             $token['name'] === 'col'
3368         ) {
3369             $this->inTable(
3370                 array(
3371                     'name' => 'colgroup',
3372                     'type' => HTML5::STARTTAG,
3373                     'attr' => array()
3374                 )
3375             );
3376
3377             $this->inColumnGroup($token);
3378
3379             /* A start tag whose tag name is one of: "tbody", "tfoot", "thead" */
3380         } elseif ($token['type'] === HTML5::STARTTAG && in_array(
3381                 $token['name'],
3382                 array('tbody', 'tfoot', 'thead')
3383             )
3384         ) {
3385             /* Clear the stack back to a table context. */
3386             $this->clearStackToTableContext($clear);
3387
3388             /* Insert an HTML element for the token, then switch the insertion
3389             mode to "in table body". */
3390             $this->insertElement($token);
3391             $this->mode = self::IN_TBODY;
3392
3393             /* A start tag whose tag name is one of: "td", "th", "tr" */
3394         } elseif ($token['type'] === HTML5::STARTTAG &&
3395             in_array($token['name'], array('td', 'th', 'tr'))
3396         ) {
3397             /* Act as if a start tag token with the tag name "tbody" had been
3398             seen, then reprocess the current token. */
3399             $this->inTable(
3400                 array(
3401                     'name' => 'tbody',
3402                     'type' => HTML5::STARTTAG,
3403                     'attr' => array()
3404                 )
3405             );
3406
3407             return $this->inTableBody($token);
3408
3409             /* A start tag whose tag name is "table" */
3410         } elseif ($token['type'] === HTML5::STARTTAG &&
3411             $token['name'] === 'table'
3412         ) {
3413             /* Parse error. Act as if an end tag token with the tag name "table"
3414             had been seen, then, if that token wasn't ignored, reprocess the
3415             current token. */
3416             $this->inTable(
3417                 array(
3418                     'name' => 'table',
3419                     'type' => HTML5::ENDTAG
3420                 )
3421             );
3422
3423             return $this->mainPhase($token);
3424
3425             /* An end tag whose tag name is "table" */
3426         } elseif ($token['type'] === HTML5::ENDTAG &&
3427             $token['name'] === 'table'
3428         ) {
3429             /* If the stack of open elements does not have an element in table
3430             scope with the same tag name as the token, this is a parse error.
3431             Ignore the token. (innerHTML case) */
3432             if (!$this->elementInScope($token['name'], true)) {
3433                 return false;
3434
3435                 /* Otherwise: */
3436             } else {
3437                 /* Generate implied end tags. */
3438                 $this->generateImpliedEndTags();
3439
3440                 /* Now, if the current node is not a table element, then this
3441                 is a parse error. */
3442                 // w/e
3443
3444                 /* Pop elements from this stack until a table element has been
3445                 popped from the stack. */
3446                 while (true) {
3447                     $current = end($this->stack)->nodeName;
3448                     array_pop($this->stack);
3449
3450                     if ($current === 'table') {
3451                         break;
3452                     }
3453                 }
3454
3455                 /* Reset the insertion mode appropriately. */
3456                 $this->resetInsertionMode();
3457             }
3458
3459             /* An end tag whose tag name is one of: "body", "caption", "col",
3460             "colgroup", "html", "tbody", "td", "tfoot", "th", "thead", "tr" */
3461         } elseif ($token['type'] === HTML5::ENDTAG && in_array(
3462                 $token['name'],
3463                 array(
3464                     'body',
3465                     'caption',
3466                     'col',
3467                     'colgroup',
3468                     'html',
3469                     'tbody',
3470                     'td',
3471                     'tfoot',
3472                     'th',
3473                     'thead',
3474                     'tr'
3475                 )
3476             )
3477         ) {
3478             // Parse error. Ignore the token.
3479
3480             /* Anything else */
3481         } else {
3482             /* Parse error. Process the token as if the insertion mode was "in
3483             body", with the following exception: */
3484
3485             /* If the current node is a table, tbody, tfoot, thead, or tr
3486             element, then, whenever a node would be inserted into the current
3487             node, it must instead be inserted into the foster parent element. */
3488             if (in_array(
3489                 end($this->stack)->nodeName,
3490                 array('table', 'tbody', 'tfoot', 'thead', 'tr')
3491             )
3492             ) {
3493                 /* The foster parent element is the parent element of the last
3494                 table element in the stack of open elements, if there is a
3495                 table element and it has such a parent element. If there is no
3496                 table element in the stack of open elements (innerHTML case),
3497                 then the foster parent element is the first element in the
3498                 stack of open elements (the html  element). Otherwise, if there
3499                 is a table element in the stack of open elements, but the last
3500                 table element in the stack of open elements has no parent, or
3501                 its parent node is not an element, then the foster parent
3502                 element is the element before the last table element in the
3503                 stack of open elements. */
3504                 for ($n = count($this->stack) - 1; $n >= 0; $n--) {
3505                     if ($this->stack[$n]->nodeName === 'table') {
3506                         $table = $this->stack[$n];
3507                         break;
3508                     }
3509                 }
3510
3511                 if (isset($table) && $table->parentNode !== null) {
3512                     $this->foster_parent = $table->parentNode;
3513
3514                 } elseif (!isset($table)) {
3515                     $this->foster_parent = $this->stack[0];
3516
3517                 } elseif (isset($table) && ($table->parentNode === null ||
3518                         $table->parentNode->nodeType !== XML_ELEMENT_NODE)
3519                 ) {
3520                     $this->foster_parent = $this->stack[$n - 1];
3521                 }
3522             }
3523
3524             $this->inBody($token);
3525         }
3526     }
3527
3528     private function inCaption($token)
3529     {
3530         /* An end tag whose tag name is "caption" */
3531         if ($token['type'] === HTML5::ENDTAG && $token['name'] === 'caption') {
3532             /* If the stack of open elements does not have an element in table
3533             scope with the same tag name as the token, this is a parse error.
3534             Ignore the token. (innerHTML case) */
3535             if (!$this->elementInScope($token['name'], true)) {
3536                 // Ignore
3537
3538                 /* Otherwise: */
3539             } else {
3540                 /* Generate implied end tags. */
3541                 $this->generateImpliedEndTags();
3542
3543                 /* Now, if the current node is not a caption element, then this
3544                 is a parse error. */
3545                 // w/e
3546
3547                 /* Pop elements from this stack until a caption element has
3548                 been popped from the stack. */
3549                 while (true) {
3550                     $node = end($this->stack)->nodeName;
3551                     array_pop($this->stack);
3552
3553                     if ($node === 'caption') {
3554                         break;
3555                     }
3556                 }
3557
3558                 /* Clear the list of active formatting elements up to the last
3559                 marker. */
3560                 $this->clearTheActiveFormattingElementsUpToTheLastMarker();
3561
3562                 /* Switch the insertion mode to "in table". */
3563                 $this->mode = self::IN_TABLE;
3564             }
3565
3566             /* A start tag whose tag name is one of: "caption", "col", "colgroup",
3567             "tbody", "td", "tfoot", "th", "thead", "tr", or an end tag whose tag
3568             name is "table" */
3569         } elseif (($token['type'] === HTML5::STARTTAG && in_array(
3570                     $token['name'],
3571                     array(
3572                         'caption',
3573                         'col',
3574                         'colgroup',
3575                         'tbody',
3576                         'td',
3577                         'tfoot',
3578                         'th',
3579                         'thead',
3580                         'tr'
3581                     )
3582                 )) || ($token['type'] === HTML5::ENDTAG &&
3583                 $token['name'] === 'table')
3584         ) {
3585             /* Parse error. Act as if an end tag with the tag name "caption"
3586             had been seen, then, if that token wasn't ignored, reprocess the
3587             current token. */
3588             $this->inCaption(
3589                 array(
3590                     'name' => 'caption',
3591                     'type' => HTML5::ENDTAG
3592                 )
3593             );
3594
3595             return $this->inTable($token);
3596
3597             /* An end tag whose tag name is one of: "body", "col", "colgroup",
3598             "html", "tbody", "td", "tfoot", "th", "thead", "tr" */
3599         } elseif ($token['type'] === HTML5::ENDTAG && in_array(
3600                 $token['name'],
3601                 array(
3602                     'body',
3603                     'col',
3604                     'colgroup',
3605                     'html',
3606                     'tbody',
3607                     'tfoot',
3608                     'th',
3609                     'thead',
3610                     'tr'
3611                 )
3612             )
3613         ) {
3614             // Parse error. Ignore the token.
3615
3616             /* Anything else */
3617         } else {
3618             /* Process the token as if the insertion mode was "in body". */
3619             $this->inBody($token);
3620         }
3621     }
3622
3623     private function inColumnGroup($token)
3624     {
3625         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
3626         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
3627         or U+0020 SPACE */
3628         if ($token['type'] === HTML5::CHARACTR &&
3629             preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])
3630         ) {
3631             /* Append the character to the current node. */
3632             $text = $this->dom->createTextNode($token['data']);
3633             end($this->stack)->appendChild($text);
3634
3635             /* A comment token */
3636         } elseif ($token['type'] === HTML5::COMMENT) {
3637             /* Append a Comment node to the current node with the data
3638             attribute set to the data given in the comment token. */
3639             $comment = $this->dom->createComment($token['data']);
3640             end($this->stack)->appendChild($comment);
3641
3642             /* A start tag whose tag name is "col" */
3643         } elseif ($token['type'] === HTML5::STARTTAG && $token['name'] === 'col') {
3644             /* Insert a col element for the token. Immediately pop the current
3645             node off the stack of open elements. */
3646             $this->insertElement($token);
3647             array_pop($this->stack);
3648
3649             /* An end tag whose tag name is "colgroup" */
3650         } elseif ($token['type'] === HTML5::ENDTAG &&
3651             $token['name'] === 'colgroup'
3652         ) {
3653             /* If the current node is the root html element, then this is a
3654             parse error, ignore the token. (innerHTML case) */
3655             if (end($this->stack)->nodeName === 'html') {
3656                 // Ignore
3657
3658                 /* Otherwise, pop the current node (which will be a colgroup
3659                 element) from the stack of open elements. Switch the insertion
3660                 mode to "in table". */
3661             } else {
3662                 array_pop($this->stack);
3663                 $this->mode = self::IN_TABLE;
3664             }
3665
3666             /* An end tag whose tag name is "col" */
3667         } elseif ($token['type'] === HTML5::ENDTAG && $token['name'] === 'col') {
3668             /* Parse error. Ignore the token. */
3669
3670             /* Anything else */
3671         } else {
3672             /* Act as if an end tag with the tag name "colgroup" had been seen,
3673             and then, if that token wasn't ignored, reprocess the current token. */
3674             $this->inColumnGroup(
3675                 array(
3676                     'name' => 'colgroup',
3677                     'type' => HTML5::ENDTAG
3678                 )
3679             );
3680
3681             return $this->inTable($token);
3682         }
3683     }
3684
3685     private function inTableBody($token)
3686     {
3687         $clear = array('tbody', 'tfoot', 'thead', 'html');
3688
3689         /* A start tag whose tag name is "tr" */
3690         if ($token['type'] === HTML5::STARTTAG && $token['name'] === 'tr') {
3691             /* Clear the stack back to a table body context. */
3692             $this->clearStackToTableContext($clear);
3693
3694             /* Insert a tr element for the token, then switch the insertion
3695             mode to "in row". */
3696             $this->insertElement($token);
3697             $this->mode = self::IN_ROW;
3698
3699             /* A start tag whose tag name is one of: "th", "td" */
3700         } elseif ($token['type'] === HTML5::STARTTAG &&
3701             ($token['name'] === 'th' || $token['name'] === 'td')
3702         ) {
3703             /* Parse error. Act as if a start tag with the tag name "tr" had
3704             been seen, then reprocess the current token. */
3705             $this->inTableBody(
3706                 array(
3707                     'name' => 'tr',
3708                     'type' => HTML5::STARTTAG,
3709                     'attr' => array()
3710                 )
3711             );
3712
3713             return $this->inRow($token);
3714
3715             /* An end tag whose tag name is one of: "tbody", "tfoot", "thead" */
3716         } elseif ($token['type'] === HTML5::ENDTAG &&
3717             in_array($token['name'], array('tbody', 'tfoot', 'thead'))
3718         ) {
3719             /* If the stack of open elements does not have an element in table
3720             scope with the same tag name as the token, this is a parse error.
3721             Ignore the token. */
3722             if (!$this->elementInScope($token['name'], true)) {
3723                 // Ignore
3724
3725                 /* Otherwise: */
3726             } else {
3727                 /* Clear the stack back to a table body context. */
3728                 $this->clearStackToTableContext($clear);
3729
3730                 /* Pop the current node from the stack of open elements. Switch
3731                 the insertion mode to "in table". */
3732                 array_pop($this->stack);
3733                 $this->mode = self::IN_TABLE;
3734             }
3735
3736             /* A start tag whose tag name is one of: "caption", "col", "colgroup",
3737             "tbody", "tfoot", "thead", or an end tag whose tag name is "table" */
3738         } elseif (($token['type'] === HTML5::STARTTAG && in_array(
3739                     $token['name'],
3740                     array('caption', 'col', 'colgroup', 'tbody', 'tfoor', 'thead')
3741                 )) ||
3742             ($token['type'] === HTML5::STARTTAG && $token['name'] === 'table')
3743         ) {
3744             /* If the stack of open elements does not have a tbody, thead, or
3745             tfoot element in table scope, this is a parse error. Ignore the
3746             token. (innerHTML case) */
3747             if (!$this->elementInScope(array('tbody', 'thead', 'tfoot'), true)) {
3748                 // Ignore.
3749
3750                 /* Otherwise: */
3751             } else {
3752                 /* Clear the stack back to a table body context. */
3753                 $this->clearStackToTableContext($clear);
3754
3755                 /* Act as if an end tag with the same tag name as the current
3756                 node ("tbody", "tfoot", or "thead") had been seen, then
3757                 reprocess the current token. */
3758                 $this->inTableBody(
3759                     array(
3760                         'name' => end($this->stack)->nodeName,
3761                         'type' => HTML5::ENDTAG
3762                     )
3763                 );
3764
3765                 return $this->mainPhase($token);
3766             }
3767
3768             /* An end tag whose tag name is one of: "body", "caption", "col",
3769             "colgroup", "html", "td", "th", "tr" */
3770         } elseif ($token['type'] === HTML5::ENDTAG && in_array(
3771                 $token['name'],
3772                 array('body', 'caption', 'col', 'colgroup', 'html', 'td', 'th', 'tr')
3773             )
3774         ) {
3775             /* Parse error. Ignore the token. */
3776
3777             /* Anything else */
3778         } else {
3779             /* Process the token as if the insertion mode was "in table". */
3780             $this->inTable($token);
3781         }
3782     }
3783
3784     private function inRow($token)
3785     {
3786         $clear = array('tr', 'html');
3787
3788         /* A start tag whose tag name is one of: "th", "td" */
3789         if ($token['type'] === HTML5::STARTTAG &&
3790             ($token['name'] === 'th' || $token['name'] === 'td')
3791         ) {
3792             /* Clear the stack back to a table row context. */
3793             $this->clearStackToTableContext($clear);
3794
3795             /* Insert an HTML element for the token, then switch the insertion
3796             mode to "in cell". */
3797             $this->insertElement($token);
3798             $this->mode = self::IN_CELL;
3799
3800             /* Insert a marker at the end of the list of active formatting
3801             elements. */
3802             $this->a_formatting[] = self::MARKER;
3803
3804             /* An end tag whose tag name is "tr" */
3805         } elseif ($token['type'] === HTML5::ENDTAG && $token['name'] === 'tr') {
3806             /* If the stack of open elements does not have an element in table
3807             scope with the same tag name as the token, this is a parse error.
3808             Ignore the token. (innerHTML case) */
3809             if (!$this->elementInScope($token['name'], true)) {
3810                 // Ignore.
3811
3812                 /* Otherwise: */
3813             } else {
3814                 /* Clear the stack back to a table row context. */
3815                 $this->clearStackToTableContext($clear);
3816
3817                 /* Pop the current node (which will be a tr element) from the
3818                 stack of open elements. Switch the insertion mode to "in table
3819                 body". */
3820                 array_pop($this->stack);
3821                 $this->mode = self::IN_TBODY;
3822             }
3823
3824             /* A start tag whose tag name is one of: "caption", "col", "colgroup",
3825             "tbody", "tfoot", "thead", "tr" or an end tag whose tag name is "table" */
3826         } elseif ($token['type'] === HTML5::STARTTAG && in_array(
3827                 $token['name'],
3828                 array('caption', 'col', 'colgroup', 'tbody', 'tfoot', 'thead', 'tr')
3829             )
3830         ) {
3831             /* Act as if an end tag with the tag name "tr" had been seen, then,
3832             if that token wasn't ignored, reprocess the current token. */
3833             $this->inRow(
3834                 array(
3835                     'name' => 'tr',
3836                     'type' => HTML5::ENDTAG
3837                 )
3838             );
3839
3840             return $this->inCell($token);
3841
3842             /* An end tag whose tag name is one of: "tbody", "tfoot", "thead" */
3843         } elseif ($token['type'] === HTML5::ENDTAG &&
3844             in_array($token['name'], array('tbody', 'tfoot', 'thead'))
3845         ) {
3846             /* If the stack of open elements does not have an element in table
3847             scope with the same tag name as the token, this is a parse error.
3848             Ignore the token. */
3849             if (!$this->elementInScope($token['name'], true)) {
3850                 // Ignore.
3851
3852                 /* Otherwise: */
3853             } else {
3854                 /* Otherwise, act as if an end tag with the tag name "tr" had
3855                 been seen, then reprocess the current token. */
3856                 $this->inRow(
3857                     array(
3858                         'name' => 'tr',
3859                         'type' => HTML5::ENDTAG
3860                     )
3861                 );
3862
3863                 return $this->inCell($token);
3864             }
3865
3866             /* An end tag whose tag name is one of: "body", "caption", "col",
3867             "colgroup", "html", "td", "th" */
3868         } elseif ($token['type'] === HTML5::ENDTAG && in_array(
3869                 $token['name'],
3870                 array('body', 'caption', 'col', 'colgroup', 'html', 'td', 'th', 'tr')
3871             )
3872         ) {
3873             /* Parse error. Ignore the token. */
3874
3875             /* Anything else */
3876         } else {
3877             /* Process the token as if the insertion mode was "in table". */
3878             $this->inTable($token);
3879         }
3880     }
3881
3882     private function inCell($token)
3883     {
3884         /* An end tag whose tag name is one of: "td", "th" */
3885         if ($token['type'] === HTML5::ENDTAG &&
3886             ($token['name'] === 'td' || $token['name'] === 'th')
3887         ) {
3888             /* If the stack of open elements does not have an element in table
3889             scope with the same tag name as that of the token, then this is a
3890             parse error and the token must be ignored. */
3891             if (!$this->elementInScope($token['name'], true)) {
3892                 // Ignore.
3893
3894                 /* Otherwise: */
3895             } else {
3896                 /* Generate implied end tags, except for elements with the same
3897                 tag name as the token. */
3898                 $this->generateImpliedEndTags(array($token['name']));
3899
3900                 /* Now, if the current node is not an element with the same tag
3901                 name as the token, then this is a parse error. */
3902                 // k
3903
3904                 /* Pop elements from this stack until an element with the same
3905                 tag name as the token has been popped from the stack. */
3906                 while (true) {
3907                     $node = end($this->stack)->nodeName;
3908                     array_pop($this->stack);
3909
3910                     if ($node === $token['name']) {
3911                         break;
3912                     }
3913                 }
3914
3915                 /* Clear the list of active formatting elements up to the last
3916                 marker. */
3917                 $this->clearTheActiveFormattingElementsUpToTheLastMarker();
3918
3919                 /* Switch the insertion mode to "in row". (The current node
3920                 will be a tr element at this point.) */
3921                 $this->mode = self::IN_ROW;
3922             }
3923
3924             /* A start tag whose tag name is one of: "caption", "col", "colgroup",
3925             "tbody", "td", "tfoot", "th", "thead", "tr" */
3926         } elseif ($token['type'] === HTML5::STARTTAG && in_array(
3927                 $token['name'],
3928                 array(
3929                     'caption',
3930                     'col',
3931                     'colgroup',
3932                     'tbody',
3933                     'td',
3934                     'tfoot',
3935                     'th',
3936                     'thead',
3937                     'tr'
3938                 )
3939             )
3940         ) {
3941             /* If the stack of open elements does not have a td or th element
3942             in table scope, then this is a parse error; ignore the token.
3943             (innerHTML case) */
3944             if (!$this->elementInScope(array('td', 'th'), true)) {
3945                 // Ignore.
3946
3947                 /* Otherwise, close the cell (see below) and reprocess the current
3948                 token. */
3949             } else {
3950                 $this->closeCell();
3951                 return $this->inRow($token);
3952             }
3953
3954             /* A start tag whose tag name is one of: "caption", "col", "colgroup",
3955             "tbody", "td", "tfoot", "th", "thead", "tr" */
3956         } elseif ($token['type'] === HTML5::STARTTAG && in_array(
3957                 $token['name'],
3958                 array(
3959                     'caption',
3960                     'col',
3961                     'colgroup',
3962                     'tbody',
3963                     'td',
3964                     'tfoot',
3965                     'th',
3966                     'thead',
3967                     'tr'
3968                 )
3969             )
3970         ) {
3971             /* If the stack of open elements does not have a td or th element
3972             in table scope, then this is a parse error; ignore the token.
3973             (innerHTML case) */
3974             if (!$this->elementInScope(array('td', 'th'), true)) {
3975                 // Ignore.
3976
3977                 /* Otherwise, close the cell (see below) and reprocess the current
3978                 token. */
3979             } else {
3980                 $this->closeCell();
3981                 return $this->inRow($token);
3982             }
3983
3984             /* An end tag whose tag name is one of: "body", "caption", "col",
3985             "colgroup", "html" */
3986         } elseif ($token['type'] === HTML5::ENDTAG && in_array(
3987                 $token['name'],
3988                 array('body', 'caption', 'col', 'colgroup', 'html')
3989             )
3990         ) {
3991             /* Parse error. Ignore the token. */
3992
3993             /* An end tag whose tag name is one of: "table", "tbody", "tfoot",
3994             "thead", "tr" */
3995         } elseif ($token['type'] === HTML5::ENDTAG && in_array(
3996                 $token['name'],
3997                 array('table', 'tbody', 'tfoot', 'thead', 'tr')
3998             )
3999         ) {
4000             /* If the stack of open elements does not have an element in table
4001             scope with the same tag name as that of the token (which can only
4002             happen for "tbody", "tfoot" and "thead", or, in the innerHTML case),
4003             then this is a parse error and the token must be ignored. */
4004             if (!$this->elementInScope($token['name'], true)) {
4005                 // Ignore.
4006
4007                 /* Otherwise, close the cell (see below) and reprocess the current
4008                 token. */
4009             } else {
4010                 $this->closeCell();
4011                 return $this->inRow($token);
4012             }
4013
4014             /* Anything else */
4015         } else {
4016             /* Process the token as if the insertion mode was "in body". */
4017             $this->inBody($token);
4018         }
4019     }
4020
4021     private function inSelect($token)
4022     {
4023         /* Handle the token as follows: */
4024
4025         /* A character token */
4026         if ($token['type'] === HTML5::CHARACTR) {
4027             /* Append the token's character to the current node. */
4028             $this->insertText($token['data']);
4029
4030             /* A comment token */
4031         } elseif ($token['type'] === HTML5::COMMENT) {
4032             /* Append a Comment node to the current node with the data
4033             attribute set to the data given in the comment token. */
4034             $this->insertComment($token['data']);
4035
4036             /* A start tag token whose tag name is "option" */
4037         } elseif ($token['type'] === HTML5::STARTTAG &&
4038             $token['name'] === 'option'
4039         ) {
4040             /* If the current node is an option element, act as if an end tag
4041             with the tag name "option" had been seen. */
4042             if (end($this->stack)->nodeName === 'option') {
4043                 $this->inSelect(
4044                     array(
4045                         'name' => 'option',
4046                         'type' => HTML5::ENDTAG
4047                     )
4048                 );
4049             }
4050
4051             /* Insert an HTML element for the token. */
4052             $this->insertElement($token);
4053
4054             /* A start tag token whose tag name is "optgroup" */
4055         } elseif ($token['type'] === HTML5::STARTTAG &&
4056             $token['name'] === 'optgroup'
4057         ) {
4058             /* If the current node is an option element, act as if an end tag
4059             with the tag name "option" had been seen. */
4060             if (end($this->stack)->nodeName === 'option') {
4061                 $this->inSelect(
4062                     array(
4063                         'name' => 'option',
4064                         'type' => HTML5::ENDTAG
4065                     )
4066                 );
4067             }
4068
4069             /* If the current node is an optgroup element, act as if an end tag
4070             with the tag name "optgroup" had been seen. */
4071             if (end($this->stack)->nodeName === 'optgroup') {
4072                 $this->inSelect(
4073                     array(
4074                         'name' => 'optgroup',
4075                         'type' => HTML5::ENDTAG
4076                     )
4077                 );
4078             }
4079
4080             /* Insert an HTML element for the token. */
4081             $this->insertElement($token);
4082
4083             /* An end tag token whose tag name is "optgroup" */
4084         } elseif ($token['type'] === HTML5::ENDTAG &&
4085             $token['name'] === 'optgroup'
4086         ) {
4087             /* First, if the current node is an option element, and the node
4088             immediately before it in the stack of open elements is an optgroup
4089             element, then act as if an end tag with the tag name "option" had
4090             been seen. */
4091             $elements_in_stack = count($this->stack);
4092
4093             if ($this->stack[$elements_in_stack - 1]->nodeName === 'option' &&
4094                 $this->stack[$elements_in_stack - 2]->nodeName === 'optgroup'
4095             ) {
4096                 $this->inSelect(
4097                     array(
4098                         'name' => 'option',
4099                         'type' => HTML5::ENDTAG
4100                     )
4101                 );
4102             }
4103
4104             /* If the current node is an optgroup element, then pop that node
4105             from the stack of open elements. Otherwise, this is a parse error,
4106             ignore the token. */
4107             if ($this->stack[$elements_in_stack - 1] === 'optgroup') {
4108                 array_pop($this->stack);
4109             }
4110
4111             /* An end tag token whose tag name is "option" */
4112         } elseif ($token['type'] === HTML5::ENDTAG &&
4113             $token['name'] === 'option'
4114         ) {
4115             /* If the current node is an option element, then pop that node
4116             from the stack of open elements. Otherwise, this is a parse error,
4117             ignore the token. */
4118             if (end($this->stack)->nodeName === 'option') {
4119                 array_pop($this->stack);
4120             }
4121
4122             /* An end tag whose tag name is "select" */
4123         } elseif ($token['type'] === HTML5::ENDTAG &&
4124             $token['name'] === 'select'
4125         ) {
4126             /* If the stack of open elements does not have an element in table
4127             scope with the same tag name as the token, this is a parse error.
4128             Ignore the token. (innerHTML case) */
4129             if (!$this->elementInScope($token['name'], true)) {
4130                 // w/e
4131
4132                 /* Otherwise: */
4133             } else {
4134                 /* Pop elements from the stack of open elements until a select
4135                 element has been popped from the stack. */
4136                 while (true) {
4137                     $current = end($this->stack)->nodeName;
4138                     array_pop($this->stack);
4139
4140                     if ($current === 'select') {
4141                         break;
4142                     }
4143                 }
4144
4145                 /* Reset the insertion mode appropriately. */
4146                 $this->resetInsertionMode();
4147             }
4148
4149             /* A start tag whose tag name is "select" */
4150         } elseif ($token['name'] === 'select' &&
4151             $token['type'] === HTML5::STARTTAG
4152         ) {
4153             /* Parse error. Act as if the token had been an end tag with the
4154             tag name "select" instead. */
4155             $this->inSelect(
4156                 array(
4157                     'name' => 'select',
4158                     'type' => HTML5::ENDTAG
4159                 )
4160             );
4161
4162             /* An end tag whose tag name is one of: "caption", "table", "tbody",
4163             "tfoot", "thead", "tr", "td", "th" */
4164         } elseif (in_array(
4165                 $token['name'],
4166                 array(
4167                     'caption',
4168                     'table',
4169                     'tbody',
4170                     'tfoot',
4171                     'thead',
4172                     'tr',
4173                     'td',
4174                     'th'
4175                 )
4176             ) && $token['type'] === HTML5::ENDTAG
4177         ) {
4178             /* Parse error. */
4179             // w/e
4180
4181             /* If the stack of open elements has an element in table scope with
4182             the same tag name as that of the token, then act as if an end tag
4183             with the tag name "select" had been seen, and reprocess the token.
4184             Otherwise, ignore the token. */
4185             if ($this->elementInScope($token['name'], true)) {
4186                 $this->inSelect(
4187                     array(
4188                         'name' => 'select',
4189                         'type' => HTML5::ENDTAG
4190                     )
4191                 );
4192
4193                 $this->mainPhase($token);
4194             }
4195
4196             /* Anything else */
4197         } else {
4198             /* Parse error. Ignore the token. */
4199         }
4200     }
4201
4202     private function afterBody($token)
4203     {
4204         /* Handle the token as follows: */
4205
4206         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
4207         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
4208         or U+0020 SPACE */
4209         if ($token['type'] === HTML5::CHARACTR &&
4210             preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])
4211         ) {
4212             /* Process the token as it would be processed if the insertion mode
4213             was "in body". */
4214             $this->inBody($token);
4215
4216             /* A comment token */
4217         } elseif ($token['type'] === HTML5::COMMENT) {
4218             /* Append a Comment node to the first element in the stack of open
4219             elements (the html element), with the data attribute set to the
4220             data given in the comment token. */
4221             $comment = $this->dom->createComment($token['data']);
4222             $this->stack[0]->appendChild($comment);
4223
4224             /* An end tag with the tag name "html" */
4225         } elseif ($token['type'] === HTML5::ENDTAG && $token['name'] === 'html') {
4226             /* If the parser was originally created in order to handle the
4227             setting of an element's innerHTML attribute, this is a parse error;
4228             ignore the token. (The element will be an html element in this
4229             case.) (innerHTML case) */
4230
4231             /* Otherwise, switch to the trailing end phase. */
4232             $this->phase = self::END_PHASE;
4233
4234             /* Anything else */
4235         } else {
4236             /* Parse error. Set the insertion mode to "in body" and reprocess
4237             the token. */
4238             $this->mode = self::IN_BODY;
4239             return $this->inBody($token);
4240         }
4241     }
4242
4243     private function inFrameset($token)
4244     {
4245         /* Handle the token as follows: */
4246
4247         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
4248         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
4249         U+000D CARRIAGE RETURN (CR), or U+0020 SPACE */
4250         if ($token['type'] === HTML5::CHARACTR &&
4251             preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])
4252         ) {
4253             /* Append the character to the current node. */
4254             $this->insertText($token['data']);
4255
4256             /* A comment token */
4257         } elseif ($token['type'] === HTML5::COMMENT) {
4258             /* Append a Comment node to the current node with the data
4259             attribute set to the data given in the comment token. */
4260             $this->insertComment($token['data']);
4261
4262             /* A start tag with the tag name "frameset" */
4263         } elseif ($token['name'] === 'frameset' &&
4264             $token['type'] === HTML5::STARTTAG
4265         ) {
4266             $this->insertElement($token);
4267
4268             /* An end tag with the tag name "frameset" */
4269         } elseif ($token['name'] === 'frameset' &&
4270             $token['type'] === HTML5::ENDTAG
4271         ) {
4272             /* If the current node is the root html element, then this is a
4273             parse error; ignore the token. (innerHTML case) */
4274             if (end($this->stack)->nodeName === 'html') {
4275                 // Ignore
4276
4277             } else {
4278                 /* Otherwise, pop the current node from the stack of open
4279                 elements. */
4280                 array_pop($this->stack);
4281
4282                 /* If the parser was not originally created in order to handle
4283                 the setting of an element's innerHTML attribute (innerHTML case),
4284                 and the current node is no longer a frameset element, then change
4285                 the insertion mode to "after frameset". */
4286                 $this->mode = self::AFTR_FRAME;
4287             }
4288
4289             /* A start tag with the tag name "frame" */
4290         } elseif ($token['name'] === 'frame' &&
4291             $token['type'] === HTML5::STARTTAG
4292         ) {
4293             /* Insert an HTML element for the token. */
4294             $this->insertElement($token);
4295
4296             /* Immediately pop the current node off the stack of open elements. */
4297             array_pop($this->stack);
4298
4299             /* A start tag with the tag name "noframes" */
4300         } elseif ($token['name'] === 'noframes' &&
4301             $token['type'] === HTML5::STARTTAG
4302         ) {
4303             /* Process the token as if the insertion mode had been "in body". */
4304             $this->inBody($token);
4305
4306             /* Anything else */
4307         } else {
4308             /* Parse error. Ignore the token. */
4309         }
4310     }
4311
4312     private function afterFrameset($token)
4313     {
4314         /* Handle the token as follows: */
4315
4316         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
4317         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
4318         U+000D CARRIAGE RETURN (CR), or U+0020 SPACE */
4319         if ($token['type'] === HTML5::CHARACTR &&
4320             preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])
4321         ) {
4322             /* Append the character to the current node. */
4323             $this->insertText($token['data']);
4324
4325             /* A comment token */
4326         } elseif ($token['type'] === HTML5::COMMENT) {
4327             /* Append a Comment node to the current node with the data
4328             attribute set to the data given in the comment token. */
4329             $this->insertComment($token['data']);
4330
4331             /* An end tag with the tag name "html" */
4332         } elseif ($token['name'] === 'html' &&
4333             $token['type'] === HTML5::ENDTAG
4334         ) {
4335             /* Switch to the trailing end phase. */
4336             $this->phase = self::END_PHASE;
4337
4338             /* A start tag with the tag name "noframes" */
4339         } elseif ($token['name'] === 'noframes' &&
4340             $token['type'] === HTML5::STARTTAG
4341         ) {
4342             /* Process the token as if the insertion mode had been "in body". */
4343             $this->inBody($token);
4344
4345             /* Anything else */
4346         } else {
4347             /* Parse error. Ignore the token. */
4348         }
4349     }
4350
4351     private function trailingEndPhase($token)
4352     {
4353         /* After the main phase, as each token is emitted from the tokenisation
4354         stage, it must be processed as described in this section. */
4355
4356         /* A DOCTYPE token */
4357         if ($token['type'] === HTML5::DOCTYPE) {
4358             // Parse error. Ignore the token.
4359
4360             /* A comment token */
4361         } elseif ($token['type'] === HTML5::COMMENT) {
4362             /* Append a Comment node to the Document object with the data
4363             attribute set to the data given in the comment token. */
4364             $comment = $this->dom->createComment($token['data']);
4365             $this->dom->appendChild($comment);
4366
4367             /* A character token that is one of one of U+0009 CHARACTER TABULATION,
4368             U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
4369             or U+0020 SPACE */
4370         } elseif ($token['type'] === HTML5::CHARACTR &&
4371             preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])
4372         ) {
4373             /* Process the token as it would be processed in the main phase. */
4374             $this->mainPhase($token);
4375
4376             /* A character token that is not one of U+0009 CHARACTER TABULATION,
4377             U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
4378             or U+0020 SPACE. Or a start tag token. Or an end tag token. */
4379         } elseif (($token['type'] === HTML5::CHARACTR &&
4380                 preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) ||
4381             $token['type'] === HTML5::STARTTAG || $token['type'] === HTML5::ENDTAG
4382         ) {
4383             /* Parse error. Switch back to the main phase and reprocess the
4384             token. */
4385             $this->phase = self::MAIN_PHASE;
4386             return $this->mainPhase($token);
4387
4388             /* An end-of-file token */
4389         } elseif ($token['type'] === HTML5::EOF) {
4390             /* OMG DONE!! */
4391         }
4392     }
4393
4394     private function insertElement($token, $append = true, $check = false)
4395     {
4396         // Proprietary workaround for libxml2's limitations with tag names
4397         if ($check) {
4398             // Slightly modified HTML5 tag-name modification,
4399             // removing anything that's not an ASCII letter, digit, or hyphen
4400             $token['name'] = preg_replace('/[^a-z0-9-]/i', '', $token['name']);
4401             // Remove leading hyphens and numbers
4402             $token['name'] = ltrim($token['name'], '-0..9');
4403             // In theory, this should ever be needed, but just in case
4404             if ($token['name'] === '') {
4405                 $token['name'] = 'span';
4406             } // arbitrary generic choice
4407         }
4408
4409         $el = $this->dom->createElement($token['name']);
4410
4411         foreach ($token['attr'] as $attr) {
4412             if (!$el->hasAttribute($attr['name'])) {
4413                 $el->setAttribute($attr['name'], $attr['value']);
4414             }
4415         }
4416
4417         $this->appendToRealParent($el);
4418         $this->stack[] = $el;
4419
4420         return $el;
4421     }
4422
4423     private function insertText($data)
4424     {
4425         $text = $this->dom->createTextNode($data);
4426         $this->appendToRealParent($text);
4427     }
4428
4429     private function insertComment($data)
4430     {
4431         $comment = $this->dom->createComment($data);
4432         $this->appendToRealParent($comment);
4433     }
4434
4435     private function appendToRealParent($node)
4436     {
4437         if ($this->foster_parent === null) {
4438             end($this->stack)->appendChild($node);
4439
4440         } elseif ($this->foster_parent !== null) {
4441             /* If the foster parent element is the parent element of the
4442             last table element in the stack of open elements, then the new
4443             node must be inserted immediately before the last table element
4444             in the stack of open elements in the foster parent element;
4445             otherwise, the new node must be appended to the foster parent
4446             element. */
4447             for ($n = count($this->stack) - 1; $n >= 0; $n--) {
4448                 if ($this->stack[$n]->nodeName === 'table' &&
4449                     $this->stack[$n]->parentNode !== null
4450                 ) {
4451                     $table = $this->stack[$n];
4452                     break;
4453                 }
4454             }
4455
4456             if (isset($table) && $this->foster_parent->isSameNode($table->parentNode)) {
4457                 $this->foster_parent->insertBefore($node, $table);
4458             } else {
4459                 $this->foster_parent->appendChild($node);
4460             }
4461
4462             $this->foster_parent = null;
4463         }
4464     }
4465
4466     private function elementInScope($el, $table = false)
4467     {
4468         if (is_array($el)) {
4469             foreach ($el as $element) {
4470                 if ($this->elementInScope($element, $table)) {
4471                     return true;
4472                 }
4473             }
4474
4475             return false;
4476         }
4477
4478         $leng = count($this->stack);
4479
4480         for ($n = 0; $n < $leng; $n++) {
4481             /* 1. Initialise node to be the current node (the bottommost node of
4482             the stack). */
4483             $node = $this->stack[$leng - 1 - $n];
4484
4485             if ($node->tagName === $el) {
4486                 /* 2. If node is the target node, terminate in a match state. */
4487                 return true;
4488
4489             } elseif ($node->tagName === 'table') {
4490                 /* 3. Otherwise, if node is a table element, terminate in a failure
4491                 state. */
4492                 return false;
4493
4494             } elseif ($table === true && in_array(
4495                     $node->tagName,
4496                     array(
4497                         'caption',
4498                         'td',
4499                         'th',
4500                         'button',
4501                         'marquee',
4502                         'object'
4503                     )
4504                 )
4505             ) {
4506                 /* 4. Otherwise, if the algorithm is the "has an element in scope"
4507                 variant (rather than the "has an element in table scope" variant),
4508                 and node is one of the following, terminate in a failure state. */
4509                 return false;
4510
4511             } elseif ($node === $node->ownerDocument->documentElement) {
4512                 /* 5. Otherwise, if node is an html element (root element), terminate
4513                 in a failure state. (This can only happen if the node is the topmost
4514                 node of the    stack of open elements, and prevents the next step from
4515                 being invoked if there are no more elements in the stack.) */
4516                 return false;
4517             }
4518
4519             /* Otherwise, set node to the previous entry in the stack of open
4520             elements and return to step 2. (This will never fail, since the loop
4521             will always terminate in the previous step if the top of the stack
4522             is reached.) */
4523         }
4524     }
4525
4526     private function reconstructActiveFormattingElements()
4527     {
4528         /* 1. If there are no entries in the list of active formatting elements,
4529         then there is nothing to reconstruct; stop this algorithm. */
4530         $formatting_elements = count($this->a_formatting);
4531
4532         if ($formatting_elements === 0) {
4533             return false;
4534         }
4535
4536         /* 3. Let entry be the last (most recently added) element in the list
4537         of active formatting elements. */
4538         $entry = end($this->a_formatting);
4539
4540         /* 2. If the last (most recently added) entry in the list of active
4541         formatting elements is a marker, or if it is an element that is in the
4542         stack of open elements, then there is nothing to reconstruct; stop this
4543         algorithm. */
4544         if ($entry === self::MARKER || in_array($entry, $this->stack, true)) {
4545             return false;
4546         }
4547
4548         for ($a = $formatting_elements - 1; $a >= 0; true) {
4549             /* 4. If there are no entries before entry in the list of active
4550             formatting elements, then jump to step 8. */
4551             if ($a === 0) {
4552                 $step_seven = false;
4553                 break;
4554             }
4555
4556             /* 5. Let entry be the entry one earlier than entry in the list of
4557             active formatting elements. */
4558             $a--;
4559             $entry = $this->a_formatting[$a];
4560
4561             /* 6. If entry is neither a marker nor an element that is also in
4562             thetack of open elements, go to step 4. */
4563             if ($entry === self::MARKER || in_array($entry, $this->stack, true)) {
4564                 break;
4565             }
4566         }
4567
4568         while (true) {
4569             /* 7. Let entry be the element one later than entry in the list of
4570             active formatting elements. */
4571             if (isset($step_seven) && $step_seven === true) {
4572                 $a++;
4573                 $entry = $this->a_formatting[$a];
4574             }
4575
4576             /* 8. Perform a shallow clone of the element entry to obtain clone. */
4577             $clone = $entry->cloneNode();
4578
4579             /* 9. Append clone to the current node and push it onto the stack
4580             of open elements  so that it is the new current node. */
4581             end($this->stack)->appendChild($clone);
4582             $this->stack[] = $clone;
4583
4584             /* 10. Replace the entry for entry in the list with an entry for
4585             clone. */
4586             $this->a_formatting[$a] = $clone;
4587
4588             /* 11. If the entry for clone in the list of active formatting
4589             elements is not the last entry in the list, return to step 7. */
4590             if (end($this->a_formatting) !== $clone) {
4591                 $step_seven = true;
4592             } else {
4593                 break;
4594             }
4595         }
4596     }
4597
4598     private function clearTheActiveFormattingElementsUpToTheLastMarker()
4599     {
4600         /* When the steps below require the UA to clear the list of active
4601         formatting elements up to the last marker, the UA must perform the
4602         following steps: */
4603
4604         while (true) {
4605             /* 1. Let entry be the last (most recently added) entry in the list
4606             of active formatting elements. */
4607             $entry = end($this->a_formatting);
4608
4609             /* 2. Remove entry from the list of active formatting elements. */
4610             array_pop($this->a_formatting);
4611
4612             /* 3. If entry was a marker, then stop the algorithm at this point.
4613             The list has been cleared up to the last marker. */
4614             if ($entry === self::MARKER) {
4615                 break;
4616             }
4617         }
4618     }
4619
4620     private function generateImpliedEndTags($exclude = array())
4621     {
4622         /* When the steps below require the UA to generate implied end tags,
4623         then, if the current node is a dd element, a dt element, an li element,
4624         a p element, a td element, a th  element, or a tr element, the UA must
4625         act as if an end tag with the respective tag name had been seen and
4626         then generate implied end tags again. */
4627         $node = end($this->stack);
4628         $elements = array_diff(array('dd', 'dt', 'li', 'p', 'td', 'th', 'tr'), $exclude);
4629
4630         while (in_array(end($this->stack)->nodeName, $elements)) {
4631             array_pop($this->stack);
4632         }
4633     }
4634
4635     private function getElementCategory($node)
4636     {
4637         $name = $node->tagName;
4638         if (in_array($name, $this->special)) {
4639             return self::SPECIAL;
4640         } elseif (in_array($name, $this->scoping)) {
4641             return self::SCOPING;
4642         } elseif (in_array($name, $this->formatting)) {
4643             return self::FORMATTING;
4644         } else {
4645             return self::PHRASING;
4646         }
4647     }
4648
4649     private function clearStackToTableContext($elements)
4650     {
4651         /* When the steps above require the UA to clear the stack back to a
4652         table context, it means that the UA must, while the current node is not
4653         a table element or an html element, pop elements from the stack of open
4654         elements. If this causes any elements to be popped from the stack, then
4655         this is a parse error. */
4656         while (true) {
4657             $node = end($this->stack)->nodeName;
4658
4659             if (in_array($node, $elements)) {
4660                 break;
4661             } else {
4662                 array_pop($this->stack);
4663             }
4664         }
4665     }
4666
4667     private function resetInsertionMode()
4668     {
4669         /* 1. Let last be false. */
4670         $last = false;
4671         $leng = count($this->stack);
4672
4673         for ($n = $leng - 1; $n >= 0; $n--) {
4674             /* 2. Let node be the last node in the stack of open elements. */
4675             $node = $this->stack[$n];
4676
4677             /* 3. If node is the first node in the stack of open elements, then
4678             set last to true. If the element whose innerHTML  attribute is being
4679             set is neither a td  element nor a th element, then set node to the
4680             element whose innerHTML  attribute is being set. (innerHTML  case) */
4681             if ($this->stack[0]->isSameNode($node)) {
4682                 $last = true;
4683             }
4684
4685             /* 4. If node is a select element, then switch the insertion mode to
4686             "in select" and abort these steps. (innerHTML case) */
4687             if ($node->nodeName === 'select') {
4688                 $this->mode = self::IN_SELECT;
4689                 break;
4690
4691                 /* 5. If node is a td or th element, then switch the insertion mode
4692                 to "in cell" and abort these steps. */
4693             } elseif ($node->nodeName === 'td' || $node->nodeName === 'th') {
4694                 $this->mode = self::IN_CELL;
4695                 break;
4696
4697                 /* 6. If node is a tr element, then switch the insertion mode to
4698                 "in    row" and abort these steps. */
4699             } elseif ($node->nodeName === 'tr') {
4700                 $this->mode = self::IN_ROW;
4701                 break;
4702
4703                 /* 7. If node is a tbody, thead, or tfoot element, then switch the
4704                 insertion mode to "in table body" and abort these steps. */
4705             } elseif (in_array($node->nodeName, array('tbody', 'thead', 'tfoot'))) {
4706                 $this->mode = self::IN_TBODY;
4707                 break;
4708
4709                 /* 8. If node is a caption element, then switch the insertion mode
4710                 to "in caption" and abort these steps. */
4711             } elseif ($node->nodeName === 'caption') {
4712                 $this->mode = self::IN_CAPTION;
4713                 break;
4714
4715                 /* 9. If node is a colgroup element, then switch the insertion mode
4716                 to "in column group" and abort these steps. (innerHTML case) */
4717             } elseif ($node->nodeName === 'colgroup') {
4718                 $this->mode = self::IN_CGROUP;
4719                 break;
4720
4721                 /* 10. If node is a table element, then switch the insertion mode
4722                 to "in table" and abort these steps. */
4723             } elseif ($node->nodeName === 'table') {
4724                 $this->mode = self::IN_TABLE;
4725                 break;
4726
4727                 /* 11. If node is a head element, then switch the insertion mode
4728                 to "in body" ("in body"! not "in head"!) and abort these steps.
4729                 (innerHTML case) */
4730             } elseif ($node->nodeName === 'head') {
4731                 $this->mode = self::IN_BODY;
4732                 break;
4733
4734                 /* 12. If node is a body element, then switch the insertion mode to
4735                 "in body" and abort these steps. */
4736             } elseif ($node->nodeName === 'body') {
4737                 $this->mode = self::IN_BODY;
4738                 break;
4739
4740                 /* 13. If node is a frameset element, then switch the insertion
4741                 mode to "in frameset" and abort these steps. (innerHTML case) */
4742             } elseif ($node->nodeName === 'frameset') {
4743                 $this->mode = self::IN_FRAME;
4744                 break;
4745
4746                 /* 14. If node is an html element, then: if the head element
4747                 pointer is null, switch the insertion mode to "before head",
4748                 otherwise, switch the insertion mode to "after head". In either
4749                 case, abort these steps. (innerHTML case) */
4750             } elseif ($node->nodeName === 'html') {
4751                 $this->mode = ($this->head_pointer === null)
4752                     ? self::BEFOR_HEAD
4753                     : self::AFTER_HEAD;
4754
4755                 break;
4756
4757                 /* 15. If last is true, then set the insertion mode to "in body"
4758                 and    abort these steps. (innerHTML case) */
4759             } elseif ($last) {
4760                 $this->mode = self::IN_BODY;
4761                 break;
4762             }
4763         }
4764     }
4765
4766     private function closeCell()
4767     {
4768         /* If the stack of open elements has a td or th element in table scope,
4769         then act as if an end tag token with that tag name had been seen. */
4770         foreach (array('td', 'th') as $cell) {
4771             if ($this->elementInScope($cell, true)) {
4772                 $this->inCell(
4773                     array(
4774                         'name' => $cell,
4775                         'type' => HTML5::ENDTAG
4776                     )
4777                 );
4778
4779                 break;
4780             }
4781         }
4782     }
4783
4784     public function save()
4785     {
4786         return $this->dom;
4787     }
4788 }