parse5 3.0.3 → 5.1.0

package/lib/tokenizer/index.js

@@ -1,95 +1,132 @@
 'use strict';
 
-var Preprocessor = require('./preprocessor'),
-    UNICODE = require('../common/unicode'),
-    neTree = require('./named_entity_data');
+const Preprocessor = require('./preprocessor');
+const unicode = require('../common/unicode');
+const neTree = require('./named-entity-data');
+const ERR = require('../common/error-codes');
 
 //Aliases
-var $ = UNICODE.CODE_POINTS,
-    $$ = UNICODE.CODE_POINT_SEQUENCES;
-
-//Replacement code points for numeric entities
-var NUMERIC_ENTITY_REPLACEMENTS = {
-    0x00: 0xFFFD, 0x0D: 0x000D, 0x80: 0x20AC, 0x81: 0x0081, 0x82: 0x201A, 0x83: 0x0192, 0x84: 0x201E,
-    0x85: 0x2026, 0x86: 0x2020, 0x87: 0x2021, 0x88: 0x02C6, 0x89: 0x2030, 0x8A: 0x0160, 0x8B: 0x2039,
-    0x8C: 0x0152, 0x8D: 0x008D, 0x8E: 0x017D, 0x8F: 0x008F, 0x90: 0x0090, 0x91: 0x2018, 0x92: 0x2019,
-    0x93: 0x201C, 0x94: 0x201D, 0x95: 0x2022, 0x96: 0x2013, 0x97: 0x2014, 0x98: 0x02DC, 0x99: 0x2122,
-    0x9A: 0x0161, 0x9B: 0x203A, 0x9C: 0x0153, 0x9D: 0x009D, 0x9E: 0x017E, 0x9F: 0x0178
+const $ = unicode.CODE_POINTS;
+const $$ = unicode.CODE_POINT_SEQUENCES;
+
+//C1 Unicode control character reference replacements
+const C1_CONTROLS_REFERENCE_REPLACEMENTS = {
+    0x80: 0x20ac,
+    0x82: 0x201a,
+    0x83: 0x0192,
+    0x84: 0x201e,
+    0x85: 0x2026,
+    0x86: 0x2020,
+    0x87: 0x2021,
+    0x88: 0x02c6,
+    0x89: 0x2030,
+    0x8a: 0x0160,
+    0x8b: 0x2039,
+    0x8c: 0x0152,
+    0x8e: 0x017d,
+    0x91: 0x2018,
+    0x92: 0x2019,
+    0x93: 0x201c,
+    0x94: 0x201d,
+    0x95: 0x2022,
+    0x96: 0x2013,
+    0x97: 0x2014,
+    0x98: 0x02dc,
+    0x99: 0x2122,
+    0x9a: 0x0161,
+    0x9b: 0x203a,
+    0x9c: 0x0153,
+    0x9e: 0x017e,
+    0x9f: 0x0178
 };
 
 // Named entity tree flags
-var HAS_DATA_FLAG = 1 << 0;
-var DATA_DUPLET_FLAG = 1 << 1;
-var HAS_BRANCHES_FLAG = 1 << 2;
-var MAX_BRANCH_MARKER_VALUE = HAS_DATA_FLAG | DATA_DUPLET_FLAG | HAS_BRANCHES_FLAG;
-
+const HAS_DATA_FLAG = 1 << 0;
+const DATA_DUPLET_FLAG = 1 << 1;
+const HAS_BRANCHES_FLAG = 1 << 2;
+const MAX_BRANCH_MARKER_VALUE = HAS_DATA_FLAG | DATA_DUPLET_FLAG | HAS_BRANCHES_FLAG;
 
 //States
-var DATA_STATE = 'DATA_STATE',
-    CHARACTER_REFERENCE_IN_DATA_STATE = 'CHARACTER_REFERENCE_IN_DATA_STATE',
-    RCDATA_STATE = 'RCDATA_STATE',
-    CHARACTER_REFERENCE_IN_RCDATA_STATE = 'CHARACTER_REFERENCE_IN_RCDATA_STATE',
-    RAWTEXT_STATE = 'RAWTEXT_STATE',
-    SCRIPT_DATA_STATE = 'SCRIPT_DATA_STATE',
-    PLAINTEXT_STATE = 'PLAINTEXT_STATE',
-    TAG_OPEN_STATE = 'TAG_OPEN_STATE',
-    END_TAG_OPEN_STATE = 'END_TAG_OPEN_STATE',
-    TAG_NAME_STATE = 'TAG_NAME_STATE',
-    RCDATA_LESS_THAN_SIGN_STATE = 'RCDATA_LESS_THAN_SIGN_STATE',
-    RCDATA_END_TAG_OPEN_STATE = 'RCDATA_END_TAG_OPEN_STATE',
-    RCDATA_END_TAG_NAME_STATE = 'RCDATA_END_TAG_NAME_STATE',
-    RAWTEXT_LESS_THAN_SIGN_STATE = 'RAWTEXT_LESS_THAN_SIGN_STATE',
-    RAWTEXT_END_TAG_OPEN_STATE = 'RAWTEXT_END_TAG_OPEN_STATE',
-    RAWTEXT_END_TAG_NAME_STATE = 'RAWTEXT_END_TAG_NAME_STATE',
-    SCRIPT_DATA_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_LESS_THAN_SIGN_STATE',
-    SCRIPT_DATA_END_TAG_OPEN_STATE = 'SCRIPT_DATA_END_TAG_OPEN_STATE',
-    SCRIPT_DATA_END_TAG_NAME_STATE = 'SCRIPT_DATA_END_TAG_NAME_STATE',
-    SCRIPT_DATA_ESCAPE_START_STATE = 'SCRIPT_DATA_ESCAPE_START_STATE',
-    SCRIPT_DATA_ESCAPE_START_DASH_STATE = 'SCRIPT_DATA_ESCAPE_START_DASH_STATE',
-    SCRIPT_DATA_ESCAPED_STATE = 'SCRIPT_DATA_ESCAPED_STATE',
-    SCRIPT_DATA_ESCAPED_DASH_STATE = 'SCRIPT_DATA_ESCAPED_DASH_STATE',
-    SCRIPT_DATA_ESCAPED_DASH_DASH_STATE = 'SCRIPT_DATA_ESCAPED_DASH_DASH_STATE',
-    SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE',
-    SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE = 'SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE',
-    SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE = 'SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE',
-    SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE',
-    SCRIPT_DATA_DOUBLE_ESCAPED_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_STATE',
-    SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE',
-    SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE',
-    SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE',
-    SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE',
-    BEFORE_ATTRIBUTE_NAME_STATE = 'BEFORE_ATTRIBUTE_NAME_STATE',
-    ATTRIBUTE_NAME_STATE = 'ATTRIBUTE_NAME_STATE',
-    AFTER_ATTRIBUTE_NAME_STATE = 'AFTER_ATTRIBUTE_NAME_STATE',
-    BEFORE_ATTRIBUTE_VALUE_STATE = 'BEFORE_ATTRIBUTE_VALUE_STATE',
-    ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE = 'ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE',
-    ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE = 'ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE',
-    ATTRIBUTE_VALUE_UNQUOTED_STATE = 'ATTRIBUTE_VALUE_UNQUOTED_STATE',
-    CHARACTER_REFERENCE_IN_ATTRIBUTE_VALUE_STATE = 'CHARACTER_REFERENCE_IN_ATTRIBUTE_VALUE_STATE',
-    AFTER_ATTRIBUTE_VALUE_QUOTED_STATE = 'AFTER_ATTRIBUTE_VALUE_QUOTED_STATE',
-    SELF_CLOSING_START_TAG_STATE = 'SELF_CLOSING_START_TAG_STATE',
-    BOGUS_COMMENT_STATE = 'BOGUS_COMMENT_STATE',
-    BOGUS_COMMENT_STATE_CONTINUATION = 'BOGUS_COMMENT_STATE_CONTINUATION',
-    MARKUP_DECLARATION_OPEN_STATE = 'MARKUP_DECLARATION_OPEN_STATE',
-    COMMENT_START_STATE = 'COMMENT_START_STATE',
-    COMMENT_START_DASH_STATE = 'COMMENT_START_DASH_STATE',
-    COMMENT_STATE = 'COMMENT_STATE',
-    COMMENT_END_DASH_STATE = 'COMMENT_END_DASH_STATE',
-    COMMENT_END_STATE = 'COMMENT_END_STATE',
-    COMMENT_END_BANG_STATE = 'COMMENT_END_BANG_STATE',
-    DOCTYPE_STATE = 'DOCTYPE_STATE',
-    DOCTYPE_NAME_STATE = 'DOCTYPE_NAME_STATE',
-    AFTER_DOCTYPE_NAME_STATE = 'AFTER_DOCTYPE_NAME_STATE',
-    BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE = 'BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE',
-    DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE = 'DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE',
-    DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE = 'DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE',
-    BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE = 'BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE',
-    BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE = 'BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE',
-    DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE = 'DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE',
-    DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE = 'DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE',
-    AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE = 'AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE',
-    BOGUS_DOCTYPE_STATE = 'BOGUS_DOCTYPE_STATE',
-    CDATA_SECTION_STATE = 'CDATA_SECTION_STATE';
+const DATA_STATE = 'DATA_STATE';
+const RCDATA_STATE = 'RCDATA_STATE';
+const RAWTEXT_STATE = 'RAWTEXT_STATE';
+const SCRIPT_DATA_STATE = 'SCRIPT_DATA_STATE';
+const PLAINTEXT_STATE = 'PLAINTEXT_STATE';
+const TAG_OPEN_STATE = 'TAG_OPEN_STATE';
+const END_TAG_OPEN_STATE = 'END_TAG_OPEN_STATE';
+const TAG_NAME_STATE = 'TAG_NAME_STATE';
+const RCDATA_LESS_THAN_SIGN_STATE = 'RCDATA_LESS_THAN_SIGN_STATE';
+const RCDATA_END_TAG_OPEN_STATE = 'RCDATA_END_TAG_OPEN_STATE';
+const RCDATA_END_TAG_NAME_STATE = 'RCDATA_END_TAG_NAME_STATE';
+const RAWTEXT_LESS_THAN_SIGN_STATE = 'RAWTEXT_LESS_THAN_SIGN_STATE';
+const RAWTEXT_END_TAG_OPEN_STATE = 'RAWTEXT_END_TAG_OPEN_STATE';
+const RAWTEXT_END_TAG_NAME_STATE = 'RAWTEXT_END_TAG_NAME_STATE';
+const SCRIPT_DATA_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_LESS_THAN_SIGN_STATE';
+const SCRIPT_DATA_END_TAG_OPEN_STATE = 'SCRIPT_DATA_END_TAG_OPEN_STATE';
+const SCRIPT_DATA_END_TAG_NAME_STATE = 'SCRIPT_DATA_END_TAG_NAME_STATE';
+const SCRIPT_DATA_ESCAPE_START_STATE = 'SCRIPT_DATA_ESCAPE_START_STATE';
+const SCRIPT_DATA_ESCAPE_START_DASH_STATE = 'SCRIPT_DATA_ESCAPE_START_DASH_STATE';
+const SCRIPT_DATA_ESCAPED_STATE = 'SCRIPT_DATA_ESCAPED_STATE';
+const SCRIPT_DATA_ESCAPED_DASH_STATE = 'SCRIPT_DATA_ESCAPED_DASH_STATE';
+const SCRIPT_DATA_ESCAPED_DASH_DASH_STATE = 'SCRIPT_DATA_ESCAPED_DASH_DASH_STATE';
+const SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE';
+const SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE = 'SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE';
+const SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE = 'SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE';
+const SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE';
+const SCRIPT_DATA_DOUBLE_ESCAPED_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_STATE';
+const SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE';
+const SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE';
+const SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE';
+const SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE';
+const BEFORE_ATTRIBUTE_NAME_STATE = 'BEFORE_ATTRIBUTE_NAME_STATE';
+const ATTRIBUTE_NAME_STATE = 'ATTRIBUTE_NAME_STATE';
+const AFTER_ATTRIBUTE_NAME_STATE = 'AFTER_ATTRIBUTE_NAME_STATE';
+const BEFORE_ATTRIBUTE_VALUE_STATE = 'BEFORE_ATTRIBUTE_VALUE_STATE';
+const ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE = 'ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE';
+const ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE = 'ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE';
+const ATTRIBUTE_VALUE_UNQUOTED_STATE = 'ATTRIBUTE_VALUE_UNQUOTED_STATE';
+const AFTER_ATTRIBUTE_VALUE_QUOTED_STATE = 'AFTER_ATTRIBUTE_VALUE_QUOTED_STATE';
+const SELF_CLOSING_START_TAG_STATE = 'SELF_CLOSING_START_TAG_STATE';
+const BOGUS_COMMENT_STATE = 'BOGUS_COMMENT_STATE';
+const MARKUP_DECLARATION_OPEN_STATE = 'MARKUP_DECLARATION_OPEN_STATE';
+const COMMENT_START_STATE = 'COMMENT_START_STATE';
+const COMMENT_START_DASH_STATE = 'COMMENT_START_DASH_STATE';
+const COMMENT_STATE = 'COMMENT_STATE';
+const COMMENT_LESS_THAN_SIGN_STATE = 'COMMENT_LESS_THAN_SIGN_STATE';
+const COMMENT_LESS_THAN_SIGN_BANG_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_STATE';
+const COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE';
+const COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE';
+const COMMENT_END_DASH_STATE = 'COMMENT_END_DASH_STATE';
+const COMMENT_END_STATE = 'COMMENT_END_STATE';
+const COMMENT_END_BANG_STATE = 'COMMENT_END_BANG_STATE';
+const DOCTYPE_STATE = 'DOCTYPE_STATE';
+const BEFORE_DOCTYPE_NAME_STATE = 'BEFORE_DOCTYPE_NAME_STATE';
+const DOCTYPE_NAME_STATE = 'DOCTYPE_NAME_STATE';
+const AFTER_DOCTYPE_NAME_STATE = 'AFTER_DOCTYPE_NAME_STATE';
+const AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE = 'AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE';
+const BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE = 'BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE';
+const DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE = 'DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE';
+const DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE = 'DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE';
+const AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE = 'AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE';
+const BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE = 'BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE';
+const AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE = 'AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE';
+const BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE = 'BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE';
+const DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE = 'DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE';
+const DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE = 'DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE';
+const AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE = 'AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE';
+const BOGUS_DOCTYPE_STATE = 'BOGUS_DOCTYPE_STATE';
+const CDATA_SECTION_STATE = 'CDATA_SECTION_STATE';
+const CDATA_SECTION_BRACKET_STATE = 'CDATA_SECTION_BRACKET_STATE';
+const CDATA_SECTION_END_STATE = 'CDATA_SECTION_END_STATE';
+const CHARACTER_REFERENCE_STATE = 'CHARACTER_REFERENCE_STATE';
+const NAMED_CHARACTER_REFERENCE_STATE = 'NAMED_CHARACTER_REFERENCE_STATE';
+const AMBIGUOUS_AMPERSAND_STATE = 'AMBIGUOS_AMPERSAND_STATE';
+const NUMERIC_CHARACTER_REFERENCE_STATE = 'NUMERIC_CHARACTER_REFERENCE_STATE';
+const HEXADEMICAL_CHARACTER_REFERENCE_START_STATE = 'HEXADEMICAL_CHARACTER_REFERENCE_START_STATE';
+const DECIMAL_CHARACTER_REFERENCE_START_STATE = 'DECIMAL_CHARACTER_REFERENCE_START_STATE';
+const HEXADEMICAL_CHARACTER_REFERENCE_STATE = 'HEXADEMICAL_CHARACTER_REFERENCE_STATE';
+const DECIMAL_CHARACTER_REFERENCE_STATE = 'DECIMAL_CHARACTER_REFERENCE_STATE';
+const NUMERIC_CHARACTER_REFERENCE_END_STATE = 'NUMERIC_CHARACTER_REFERENCE_END_STATE';
 
 //Utils
 
@@ -120,13 +157,16 @@ function isAsciiAlphaNumeric(cp) {
     return isAsciiLetter(cp) || isAsciiDigit(cp);
 }
 
-function isDigit(cp, isHex) {
-    return isAsciiDigit(cp) || isHex && (cp >= $.LATIN_CAPITAL_A && cp <= $.LATIN_CAPITAL_F ||
-                                         cp >= $.LATIN_SMALL_A && cp <= $.LATIN_SMALL_F);
+function isAsciiUpperHexDigit(cp) {
+    return cp >= $.LATIN_CAPITAL_A && cp <= $.LATIN_CAPITAL_F;
+}
+
+function isAsciiLowerHexDigit(cp) {
+    return cp >= $.LATIN_SMALL_A && cp <= $.LATIN_SMALL_F;
 }
 
-function isReservedCodePoint(cp) {
-    return cp >= 0xD800 && cp <= 0xDFFF || cp > 0x10FFFF;
+function isAsciiHexDigit(cp) {
+    return isAsciiDigit(cp) || isAsciiUpperHexDigit(cp) || isAsciiLowerHexDigit(cp);
 }
 
 function toAsciiLowerCodePoint(cp) {
@@ -137,11 +177,12 @@ function toAsciiLowerCodePoint(cp) {
 //So, we need to workaround this manually.
 //(see: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/fromCharCode#Getting_it_to_work_with_higher_values)
 function toChar(cp) {
-    if (cp <= 0xFFFF)
+    if (cp <= 0xffff) {
         return String.fromCharCode(cp);
+    }
 
     cp -= 0x10000;
-    return String.fromCharCode(cp >>> 10 & 0x3FF | 0xD800) + String.fromCharCode(0xDC00 | cp & 0x3FF);
+    return String.fromCharCode(((cp >>> 10) & 0x3ff) | 0xd800) + String.fromCharCode(0xdc00 | (cp & 0x3ff));
 }
 
 function toAsciiLowerChar(cp) {
@@ -149,1996 +190,2007 @@ function toAsciiLowerChar(cp) {
 }
 
 function findNamedEntityTreeBranch(nodeIx, cp) {
-    var branchCount = neTree[++nodeIx],
-        lo = ++nodeIx,
-        hi = lo + branchCount - 1;
+    const branchCount = neTree[++nodeIx];
+    let lo = ++nodeIx;
+    let hi = lo + branchCount - 1;
 
     while (lo <= hi) {
-        var mid = lo + hi >>> 1,
-            midCp = neTree[mid];
+        const mid = (lo + hi) >>> 1;
+        const midCp = neTree[mid];
 
-        if (midCp < cp)
+        if (midCp < cp) {
             lo = mid + 1;
-
-        else if (midCp > cp)
+        } else if (midCp > cp) {
             hi = mid - 1;
-
-        else
+        } else {
             return neTree[mid + branchCount];
+        }
     }
 
     return -1;
 }
 
-
 //Tokenizer
-var Tokenizer = module.exports = function () {
-    this.preprocessor = new Preprocessor();
+class Tokenizer {
+    constructor() {
+        this.preprocessor = new Preprocessor();
 
-    this.tokenQueue = [];
+        this.tokenQueue = [];
 
-    this.allowCDATA = false;
+        this.allowCDATA = false;
 
-    this.state = DATA_STATE;
-    this.returnState = '';
-
-    this.tempBuff = [];
-    this.additionalAllowedCp = void 0;
-    this.lastStartTagName = '';
+        this.state = DATA_STATE;
+        this.returnState = '';
 
-    this.consumedAfterSnapshot = -1;
-    this.active = false;
+        this.charRefCode = -1;
+        this.tempBuff = [];
+        this.lastStartTagName = '';
 
-    this.currentCharacterToken = null;
-    this.currentToken = null;
-    this.currentAttr = null;
-};
+        this.consumedAfterSnapshot = -1;
+        this.active = false;
 
-//Token types
-Tokenizer.CHARACTER_TOKEN = 'CHARACTER_TOKEN';
-Tokenizer.NULL_CHARACTER_TOKEN = 'NULL_CHARACTER_TOKEN';
-Tokenizer.WHITESPACE_CHARACTER_TOKEN = 'WHITESPACE_CHARACTER_TOKEN';
-Tokenizer.START_TAG_TOKEN = 'START_TAG_TOKEN';
-Tokenizer.END_TAG_TOKEN = 'END_TAG_TOKEN';
-Tokenizer.COMMENT_TOKEN = 'COMMENT_TOKEN';
-Tokenizer.DOCTYPE_TOKEN = 'DOCTYPE_TOKEN';
-Tokenizer.EOF_TOKEN = 'EOF_TOKEN';
-Tokenizer.HIBERNATION_TOKEN = 'HIBERNATION_TOKEN';
+        this.currentCharacterToken = null;
+        this.currentToken = null;
+        this.currentAttr = null;
+    }
 
-//Tokenizer initial states for different modes
-Tokenizer.MODE = {
-    DATA: DATA_STATE,
-    RCDATA: RCDATA_STATE,
-    RAWTEXT: RAWTEXT_STATE,
-    SCRIPT_DATA: SCRIPT_DATA_STATE,
-    PLAINTEXT: PLAINTEXT_STATE
-};
+    //Errors
+    _err() {
+        // NOTE: err reporting is noop by default. Enabled by mixin.
+    }
 
-//Static
-Tokenizer.getTokenAttr = function (token, attrName) {
-    for (var i = token.attrs.length - 1; i >= 0; i--) {
-        if (token.attrs[i].name === attrName)
-            return token.attrs[i].value;
+    _errOnNextCodePoint(err) {
+        this._consume();
+        this._err(err);
+        this._unconsume();
     }
 
-    return null;
-};
+    //API
+    getNextToken() {
+        while (!this.tokenQueue.length && this.active) {
+            this.consumedAfterSnapshot = 0;
 
-//API
-Tokenizer.prototype.getNextToken = function () {
-    while (!this.tokenQueue.length && this.active) {
-        this._hibernationSnapshot();
+            const cp = this._consume();
 
-        var cp = this._consume();
+            if (!this._ensureHibernation()) {
+                this[this.state](cp);
+            }
+        }
 
-        if (!this._ensureHibernation())
-            this[this.state](cp);
+        return this.tokenQueue.shift();
     }
 
-    return this.tokenQueue.shift();
-};
-
-Tokenizer.prototype.write = function (chunk, isLastChunk) {
-    this.active = true;
-    this.preprocessor.write(chunk, isLastChunk);
-};
+    write(chunk, isLastChunk) {
+        this.active = true;
+        this.preprocessor.write(chunk, isLastChunk);
+    }
 
-Tokenizer.prototype.insertHtmlAtCurrentPos = function (chunk) {
-    this.active = true;
-    this.preprocessor.insertHtmlAtCurrentPos(chunk);
-};
+    insertHtmlAtCurrentPos(chunk) {
+        this.active = true;
+        this.preprocessor.insertHtmlAtCurrentPos(chunk);
+    }
 
-//Hibernation
-Tokenizer.prototype._hibernationSnapshot = function () {
-    this.consumedAfterSnapshot = 0;
-};
+    //Hibernation
+    _ensureHibernation() {
+        if (this.preprocessor.endOfChunkHit) {
+            for (; this.consumedAfterSnapshot > 0; this.consumedAfterSnapshot--) {
+                this.preprocessor.retreat();
+            }
 
-Tokenizer.prototype._ensureHibernation = function () {
-    if (this.preprocessor.endOfChunkHit) {
-        for (; this.consumedAfterSnapshot > 0; this.consumedAfterSnapshot--)
-            this.preprocessor.retreat();
+            this.active = false;
+            this.tokenQueue.push({ type: Tokenizer.HIBERNATION_TOKEN });
 
-        this.active = false;
-        this.tokenQueue.push({type: Tokenizer.HIBERNATION_TOKEN});
+            return true;
+        }
 
-        return true;
+        return false;
     }
 
-    return false;
-};
+    //Consumption
+    _consume() {
+        this.consumedAfterSnapshot++;
+        return this.preprocessor.advance();
+    }
 
+    _unconsume() {
+        this.consumedAfterSnapshot--;
+        this.preprocessor.retreat();
+    }
 
-//Consumption
-Tokenizer.prototype._consume = function () {
-    this.consumedAfterSnapshot++;
-    return this.preprocessor.advance();
-};
+    _reconsumeInState(state) {
+        this.state = state;
+        this._unconsume();
+    }
 
-Tokenizer.prototype._unconsume = function () {
-    this.consumedAfterSnapshot--;
-    this.preprocessor.retreat();
-};
+    _consumeSequenceIfMatch(pattern, startCp, caseSensitive) {
+        let consumedCount = 0;
+        let isMatch = true;
+        const patternLength = pattern.length;
+        let patternPos = 0;
+        let cp = startCp;
+        let patternCp = void 0;
 
-Tokenizer.prototype._unconsumeSeveral = function (count) {
-    while (count--)
-        this._unconsume();
-};
+        for (; patternPos < patternLength; patternPos++) {
+            if (patternPos > 0) {
+                cp = this._consume();
+                consumedCount++;
+            }
 
-Tokenizer.prototype._reconsumeInState = function (state) {
-    this.state = state;
-    this._unconsume();
-};
+            if (cp === $.EOF) {
+                isMatch = false;
+                break;
+            }
 
-Tokenizer.prototype._consumeSubsequentIfMatch = function (pattern, startCp, caseSensitive) {
-    var consumedCount = 0,
-        isMatch = true,
-        patternLength = pattern.length,
-        patternPos = 0,
-        cp = startCp,
-        patternCp = void 0;
+            patternCp = pattern[patternPos];
 
-    for (; patternPos < patternLength; patternPos++) {
-        if (patternPos > 0) {
-            cp = this._consume();
-            consumedCount++;
+            if (cp !== patternCp && (caseSensitive || cp !== toAsciiLowerCodePoint(patternCp))) {
+                isMatch = false;
+                break;
+            }
         }
 
-        if (cp === $.EOF) {
-            isMatch = false;
-            break;
+        if (!isMatch) {
+            while (consumedCount--) {
+                this._unconsume();
+            }
         }
 
-        patternCp = pattern[patternPos];
+        return isMatch;
+    }
 
-        if (cp !== patternCp && (caseSensitive || cp !== toAsciiLowerCodePoint(patternCp))) {
-            isMatch = false;
-            break;
+    //Temp buffer
+    _isTempBufferEqualToScriptString() {
+        if (this.tempBuff.length !== $$.SCRIPT_STRING.length) {
+            return false;
         }
-    }
 
-    if (!isMatch)
-        this._unconsumeSeveral(consumedCount);
+        for (let i = 0; i < this.tempBuff.length; i++) {
+            if (this.tempBuff[i] !== $$.SCRIPT_STRING[i]) {
+                return false;
+            }
+        }
 
-    return isMatch;
-};
+        return true;
+    }
 
-//Lookahead
-Tokenizer.prototype._lookahead = function () {
-    var cp = this._consume();
+    //Token creation
+    _createStartTagToken() {
+        this.currentToken = {
+            type: Tokenizer.START_TAG_TOKEN,
+            tagName: '',
+            selfClosing: false,
+            ackSelfClosing: false,
+            attrs: []
+        };
+    }
 
-    this._unconsume();
+    _createEndTagToken() {
+        this.currentToken = {
+            type: Tokenizer.END_TAG_TOKEN,
+            tagName: '',
+            selfClosing: false,
+            attrs: []
+        };
+    }
 
-    return cp;
-};
+    _createCommentToken() {
+        this.currentToken = {
+            type: Tokenizer.COMMENT_TOKEN,
+            data: ''
+        };
+    }
 
-//Temp buffer
-Tokenizer.prototype.isTempBufferEqualToScriptString = function () {
-    if (this.tempBuff.length !== $$.SCRIPT_STRING.length)
-        return false;
+    _createDoctypeToken(initialName) {
+        this.currentToken = {
+            type: Tokenizer.DOCTYPE_TOKEN,
+            name: initialName,
+            forceQuirks: false,
+            publicId: null,
+            systemId: null
+        };
+    }
 
-    for (var i = 0; i < this.tempBuff.length; i++) {
-        if (this.tempBuff[i] !== $$.SCRIPT_STRING[i])
-            return false;
+    _createCharacterToken(type, ch) {
+        this.currentCharacterToken = {
+            type: type,
+            chars: ch
+        };
     }
 
-    return true;
-};
+    _createEOFToken() {
+        this.currentToken = { type: Tokenizer.EOF_TOKEN };
+    }
 
-//Token creation
-Tokenizer.prototype._createStartTagToken = function () {
-    this.currentToken = {
-        type: Tokenizer.START_TAG_TOKEN,
-        tagName: '',
-        selfClosing: false,
-        attrs: []
-    };
-};
+    //Tag attributes
+    _createAttr(attrNameFirstCh) {
+        this.currentAttr = {
+            name: attrNameFirstCh,
+            value: ''
+        };
+    }
 
-Tokenizer.prototype._createEndTagToken = function () {
-    this.currentToken = {
-        type: Tokenizer.END_TAG_TOKEN,
-        tagName: '',
-        attrs: []
-    };
-};
+    _leaveAttrName(toState) {
+        if (Tokenizer.getTokenAttr(this.currentToken, this.currentAttr.name) === null) {
+            this.currentToken.attrs.push(this.currentAttr);
+        } else {
+            this._err(ERR.duplicateAttribute);
+        }
 
-Tokenizer.prototype._createCommentToken = function () {
-    this.currentToken = {
-        type: Tokenizer.COMMENT_TOKEN,
-        data: ''
-    };
-};
+        this.state = toState;
+    }
 
-Tokenizer.prototype._createDoctypeToken = function (initialName) {
-    this.currentToken = {
-        type: Tokenizer.DOCTYPE_TOKEN,
-        name: initialName,
-        forceQuirks: false,
-        publicId: null,
-        systemId: null
-    };
-};
+    _leaveAttrValue(toState) {
+        this.state = toState;
+    }
 
-Tokenizer.prototype._createCharacterToken = function (type, ch) {
-    this.currentCharacterToken = {
-        type: type,
-        chars: ch
-    };
-};
+    //Token emission
+    _emitCurrentToken() {
+        this._emitCurrentCharacterToken();
 
-//Tag attributes
-Tokenizer.prototype._createAttr = function (attrNameFirstCh) {
-    this.currentAttr = {
-        name: attrNameFirstCh,
-        value: ''
-    };
-};
+        const ct = this.currentToken;
 
-Tokenizer.prototype._isDuplicateAttr = function () {
-    return Tokenizer.getTokenAttr(this.currentToken, this.currentAttr.name) !== null;
-};
+        this.currentToken = null;
 
-Tokenizer.prototype._leaveAttrName = function (toState) {
-    this.state = toState;
+        //NOTE: store emited start tag's tagName to determine is the following end tag token is appropriate.
+        if (ct.type === Tokenizer.START_TAG_TOKEN) {
+            this.lastStartTagName = ct.tagName;
+        } else if (ct.type === Tokenizer.END_TAG_TOKEN) {
+            if (ct.attrs.length > 0) {
+                this._err(ERR.endTagWithAttributes);
+            }
 
-    if (!this._isDuplicateAttr())
-        this.currentToken.attrs.push(this.currentAttr);
-};
+            if (ct.selfClosing) {
+                this._err(ERR.endTagWithTrailingSolidus);
+            }
+        }
 
-Tokenizer.prototype._leaveAttrValue = function (toState) {
-    this.state = toState;
-};
+        this.tokenQueue.push(ct);
+    }
 
-//Appropriate end tag token
-//(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#appropriate-end-tag-token)
-Tokenizer.prototype._isAppropriateEndTagToken = function () {
-    return this.lastStartTagName === this.currentToken.tagName;
-};
+    _emitCurrentCharacterToken() {
+        if (this.currentCharacterToken) {
+            this.tokenQueue.push(this.currentCharacterToken);
+            this.currentCharacterToken = null;
+        }
+    }
 
-//Token emission
-Tokenizer.prototype._emitCurrentToken = function () {
-    this._emitCurrentCharacterToken();
+    _emitEOFToken() {
+        this._createEOFToken();
+        this._emitCurrentToken();
+    }
 
-    //NOTE: store emited start tag's tagName to determine is the following end tag token is appropriate.
-    if (this.currentToken.type === Tokenizer.START_TAG_TOKEN)
-        this.lastStartTagName = this.currentToken.tagName;
+    //Characters emission
 
-    this.tokenQueue.push(this.currentToken);
-    this.currentToken = null;
-};
+    //OPTIMIZATION: specification uses only one type of character tokens (one token per character).
+    //This causes a huge memory overhead and a lot of unnecessary parser loops. parse5 uses 3 groups of characters.
+    //If we have a sequence of characters that belong to the same group, parser can process it
+    //as a single solid character token.
+    //So, there are 3 types of character tokens in parse5:
+    //1)NULL_CHARACTER_TOKEN - \u0000-character sequences (e.g. '\u0000\u0000\u0000')
+    //2)WHITESPACE_CHARACTER_TOKEN - any whitespace/new-line character sequences (e.g. '\n  \r\t   \f')
+    //3)CHARACTER_TOKEN - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^')
+    _appendCharToCurrentCharacterToken(type, ch) {
+        if (this.currentCharacterToken && this.currentCharacterToken.type !== type) {
+            this._emitCurrentCharacterToken();
+        }
 
-Tokenizer.prototype._emitCurrentCharacterToken = function () {
-    if (this.currentCharacterToken) {
-        this.tokenQueue.push(this.currentCharacterToken);
-        this.currentCharacterToken = null;
+        if (this.currentCharacterToken) {
+            this.currentCharacterToken.chars += ch;
+        } else {
+            this._createCharacterToken(type, ch);
+        }
     }
-};
 
-Tokenizer.prototype._emitEOFToken = function () {
-    this._emitCurrentCharacterToken();
-    this.tokenQueue.push({type: Tokenizer.EOF_TOKEN});
-};
+    _emitCodePoint(cp) {
+        let type = Tokenizer.CHARACTER_TOKEN;
 
-//Characters emission
-
-//OPTIMIZATION: specification uses only one type of character tokens (one token per character).
-//This causes a huge memory overhead and a lot of unnecessary parser loops. parse5 uses 3 groups of characters.
-//If we have a sequence of characters that belong to the same group, parser can process it
-//as a single solid character token.
-//So, there are 3 types of character tokens in parse5:
-//1)NULL_CHARACTER_TOKEN - \u0000-character sequences (e.g. '\u0000\u0000\u0000')
-//2)WHITESPACE_CHARACTER_TOKEN - any whitespace/new-line character sequences (e.g. '\n  \r\t   \f')
-//3)CHARACTER_TOKEN - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^')
-Tokenizer.prototype._appendCharToCurrentCharacterToken = function (type, ch) {
-    if (this.currentCharacterToken && this.currentCharacterToken.type !== type)
-        this._emitCurrentCharacterToken();
+        if (isWhitespace(cp)) {
+            type = Tokenizer.WHITESPACE_CHARACTER_TOKEN;
+        } else if (cp === $.NULL) {
+            type = Tokenizer.NULL_CHARACTER_TOKEN;
+        }
 
-    if (this.currentCharacterToken)
-        this.currentCharacterToken.chars += ch;
+        this._appendCharToCurrentCharacterToken(type, toChar(cp));
+    }
 
-    else
-        this._createCharacterToken(type, ch);
-};
+    _emitSeveralCodePoints(codePoints) {
+        for (let i = 0; i < codePoints.length; i++) {
+            this._emitCodePoint(codePoints[i]);
+        }
+    }
 
-Tokenizer.prototype._emitCodePoint = function (cp) {
-    var type = Tokenizer.CHARACTER_TOKEN;
+    //NOTE: used then we emit character explicitly. This is always a non-whitespace and a non-null character.
+    //So we can avoid additional checks here.
+    _emitChars(ch) {
+        this._appendCharToCurrentCharacterToken(Tokenizer.CHARACTER_TOKEN, ch);
+    }
 
-    if (isWhitespace(cp))
-        type = Tokenizer.WHITESPACE_CHARACTER_TOKEN;
+    // Character reference helpers
+    _matchNamedCharacterReference(startCp) {
+        let result = null;
+        let excess = 1;
+        let i = findNamedEntityTreeBranch(0, startCp);
 
-    else if (cp === $.NULL)
-        type = Tokenizer.NULL_CHARACTER_TOKEN;
+        this.tempBuff.push(startCp);
 
-    this._appendCharToCurrentCharacterToken(type, toChar(cp));
-};
+        while (i > -1) {
+            const current = neTree[i];
+            const inNode = current < MAX_BRANCH_MARKER_VALUE;
+            const nodeWithData = inNode && current & HAS_DATA_FLAG;
 
-Tokenizer.prototype._emitSeveralCodePoints = function (codePoints) {
-    for (var i = 0; i < codePoints.length; i++)
-        this._emitCodePoint(codePoints[i]);
-};
+            if (nodeWithData) {
+                //NOTE: we use greedy search, so we continue lookup at this point
+                result = current & DATA_DUPLET_FLAG ? [neTree[++i], neTree[++i]] : [neTree[++i]];
+                excess = 0;
+            }
 
-//NOTE: used then we emit character explicitly. This is always a non-whitespace and a non-null character.
-//So we can avoid additional checks here.
-Tokenizer.prototype._emitChar = function (ch) {
-    this._appendCharToCurrentCharacterToken(Tokenizer.CHARACTER_TOKEN, ch);
-};
+            const cp = this._consume();
 
-//Character reference tokenization
-Tokenizer.prototype._consumeNumericEntity = function (isHex) {
-    var digits = '',
-        nextCp = void 0;
+            this.tempBuff.push(cp);
+            excess++;
 
-    do {
-        digits += toChar(this._consume());
-        nextCp = this._lookahead();
-    } while (nextCp !== $.EOF && isDigit(nextCp, isHex));
+            if (cp === $.EOF) {
+                break;
+            }
 
-    if (this._lookahead() === $.SEMICOLON)
-        this._consume();
+            if (inNode) {
+                i = current & HAS_BRANCHES_FLAG ? findNamedEntityTreeBranch(i, cp) : -1;
+            } else {
+                i = cp === current ? ++i : -1;
+            }
+        }
 
-    var referencedCp = parseInt(digits, isHex ? 16 : 10),
-        replacement = NUMERIC_ENTITY_REPLACEMENTS[referencedCp];
+        while (excess--) {
+            this.tempBuff.pop();
+            this._unconsume();
+        }
 
-    if (replacement)
-        return replacement;
+        return result;
+    }
 
-    if (isReservedCodePoint(referencedCp))
-        return $.REPLACEMENT_CHARACTER;
+    _isCharacterReferenceInAttribute() {
+        return (
+            this.returnState === ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE ||
+            this.returnState === ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE ||
+            this.returnState === ATTRIBUTE_VALUE_UNQUOTED_STATE
+        );
+    }
 
-    return referencedCp;
-};
+    _isCharacterReferenceAttributeQuirk(withSemicolon) {
+        if (!withSemicolon && this._isCharacterReferenceInAttribute()) {
+            const nextCp = this._consume();
 
-// NOTE: for the details on this algorithm see
-// https://github.com/inikulin/parse5/tree/master/scripts/generate_named_entity_data/README.md
-Tokenizer.prototype._consumeNamedEntity = function (inAttr) {
-    var referencedCodePoints = null,
-        referenceSize = 0,
-        cp = null,
-        consumedCount = 0,
-        semicolonTerminated = false;
+            this._unconsume();
 
-    for (var i = 0; i > -1;) {
-        var current = neTree[i],
-            inNode = current < MAX_BRANCH_MARKER_VALUE,
-            nodeWithData = inNode && current & HAS_DATA_FLAG;
+            return nextCp === $.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp);
+        }
 
-        if (nodeWithData) {
-            referencedCodePoints = current & DATA_DUPLET_FLAG ? [neTree[++i], neTree[++i]] : [neTree[++i]];
-            referenceSize = consumedCount;
+        return false;
+    }
 
-            if (cp === $.SEMICOLON) {
-                semicolonTerminated = true;
-                break;
+    _flushCodePointsConsumedAsCharacterReference() {
+        if (this._isCharacterReferenceInAttribute()) {
+            for (let i = 0; i < this.tempBuff.length; i++) {
+                this.currentAttr.value += toChar(this.tempBuff[i]);
             }
+        } else {
+            this._emitSeveralCodePoints(this.tempBuff);
         }
 
-        cp = this._consume();
-        consumedCount++;
+        this.tempBuff = [];
+    }
 
-        if (cp === $.EOF)
-            break;
+    // State machine
 
-        if (inNode)
-            i = current & HAS_BRANCHES_FLAG ? findNamedEntityTreeBranch(i, cp) : -1;
+    // Data state
+    //------------------------------------------------------------------
+    [DATA_STATE](cp) {
+        this.preprocessor.dropParsedChunk();
 
-        else
-            i = cp === current ? ++i : -1;
+        if (cp === $.LESS_THAN_SIGN) {
+            this.state = TAG_OPEN_STATE;
+        } else if (cp === $.AMPERSAND) {
+            this.returnState = DATA_STATE;
+            this.state = CHARACTER_REFERENCE_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this._emitCodePoint(cp);
+        } else if (cp === $.EOF) {
+            this._emitEOFToken();
+        } else {
+            this._emitCodePoint(cp);
+        }
     }
 
+    //  RCDATA state
+    //------------------------------------------------------------------
+    [RCDATA_STATE](cp) {
+        this.preprocessor.dropParsedChunk();
+
+        if (cp === $.AMPERSAND) {
+            this.returnState = RCDATA_STATE;
+            this.state = CHARACTER_REFERENCE_STATE;
+        } else if (cp === $.LESS_THAN_SIGN) {
+            this.state = RCDATA_LESS_THAN_SIGN_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this._emitChars(unicode.REPLACEMENT_CHARACTER);
+        } else if (cp === $.EOF) {
+            this._emitEOFToken();
+        } else {
+            this._emitCodePoint(cp);
+        }
+    }
 
-    if (referencedCodePoints) {
-        if (!semicolonTerminated) {
-            //NOTE: unconsume excess (e.g. 'it' in '&notit')
-            this._unconsumeSeveral(consumedCount - referenceSize);
-
-            //NOTE: If the character reference is being consumed as part of an attribute and the next character
-            //is either a U+003D EQUALS SIGN character (=) or an alphanumeric ASCII character, then, for historical
-            //reasons, all the characters that were matched after the U+0026 AMPERSAND character (&) must be
-            //unconsumed, and nothing is returned.
-            //However, if this next character is in fact a U+003D EQUALS SIGN character (=), then this is a
-            //parse error, because some legacy user agents will misinterpret the markup in those cases.
-            //(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#tokenizing-character-references)
-            if (inAttr) {
-                var nextCp = this._lookahead();
+    // RAWTEXT state
+    //------------------------------------------------------------------
+    [RAWTEXT_STATE](cp) {
+        this.preprocessor.dropParsedChunk();
 
-                if (nextCp === $.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp)) {
-                    this._unconsumeSeveral(referenceSize);
-                    return null;
-                }
-            }
+        if (cp === $.LESS_THAN_SIGN) {
+            this.state = RAWTEXT_LESS_THAN_SIGN_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this._emitChars(unicode.REPLACEMENT_CHARACTER);
+        } else if (cp === $.EOF) {
+            this._emitEOFToken();
+        } else {
+            this._emitCodePoint(cp);
         }
-
-        return referencedCodePoints;
     }
 
-    this._unconsumeSeveral(consumedCount);
-
-    return null;
-};
+    // Script data state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_STATE](cp) {
+        this.preprocessor.dropParsedChunk();
 
-Tokenizer.prototype._consumeCharacterReference = function (startCp, inAttr) {
-    if (isWhitespace(startCp) || startCp === $.GREATER_THAN_SIGN ||
-        startCp === $.AMPERSAND || startCp === this.additionalAllowedCp || startCp === $.EOF) {
-        //NOTE: not a character reference. No characters are consumed, and nothing is returned.
-        this._unconsume();
-        return null;
+        if (cp === $.LESS_THAN_SIGN) {
+            this.state = SCRIPT_DATA_LESS_THAN_SIGN_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this._emitChars(unicode.REPLACEMENT_CHARACTER);
+        } else if (cp === $.EOF) {
+            this._emitEOFToken();
+        } else {
+            this._emitCodePoint(cp);
+        }
     }
 
-    if (startCp === $.NUMBER_SIGN) {
-        //NOTE: we have a numeric entity candidate, now we should determine if it's hex or decimal
-        var isHex = false,
-            nextCp = this._lookahead();
+    // PLAINTEXT state
+    //------------------------------------------------------------------
+    [PLAINTEXT_STATE](cp) {
+        this.preprocessor.dropParsedChunk();
 
-        if (nextCp === $.LATIN_SMALL_X || nextCp === $.LATIN_CAPITAL_X) {
-            this._consume();
-            isHex = true;
+        if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this._emitChars(unicode.REPLACEMENT_CHARACTER);
+        } else if (cp === $.EOF) {
+            this._emitEOFToken();
+        } else {
+            this._emitCodePoint(cp);
         }
+    }
 
-        nextCp = this._lookahead();
-
-        //NOTE: if we have at least one digit this is a numeric entity for sure, so we consume it
-        if (nextCp !== $.EOF && isDigit(nextCp, isHex))
-            return [this._consumeNumericEntity(isHex)];
+    // Tag open state
+    //------------------------------------------------------------------
+    [TAG_OPEN_STATE](cp) {
+        if (cp === $.EXCLAMATION_MARK) {
+            this.state = MARKUP_DECLARATION_OPEN_STATE;
+        } else if (cp === $.SOLIDUS) {
+            this.state = END_TAG_OPEN_STATE;
+        } else if (isAsciiLetter(cp)) {
+            this._createStartTagToken();
+            this._reconsumeInState(TAG_NAME_STATE);
+        } else if (cp === $.QUESTION_MARK) {
+            this._err(ERR.unexpectedQuestionMarkInsteadOfTagName);
+            this._createCommentToken();
+            this._reconsumeInState(BOGUS_COMMENT_STATE);
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofBeforeTagName);
+            this._emitChars('<');
+            this._emitEOFToken();
+        } else {
+            this._err(ERR.invalidFirstCharacterOfTagName);
+            this._emitChars('<');
+            this._reconsumeInState(DATA_STATE);
+        }
+    }
 
-        //NOTE: otherwise this is a bogus number entity and a parse error. Unconsume the number sign
-        //and the 'x'-character if appropriate.
-        this._unconsumeSeveral(isHex ? 2 : 1);
-        return null;
+    // End tag open state
+    //------------------------------------------------------------------
+    [END_TAG_OPEN_STATE](cp) {
+        if (isAsciiLetter(cp)) {
+            this._createEndTagToken();
+            this._reconsumeInState(TAG_NAME_STATE);
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._err(ERR.missingEndTagName);
+            this.state = DATA_STATE;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofBeforeTagName);
+            this._emitChars('</');
+            this._emitEOFToken();
+        } else {
+            this._err(ERR.invalidFirstCharacterOfTagName);
+            this._createCommentToken();
+            this._reconsumeInState(BOGUS_COMMENT_STATE);
+        }
     }
 
-    this._unconsume();
+    // Tag name state
+    //------------------------------------------------------------------
+    [TAG_NAME_STATE](cp) {
+        if (isWhitespace(cp)) {
+            this.state = BEFORE_ATTRIBUTE_NAME_STATE;
+        } else if (cp === $.SOLIDUS) {
+            this.state = SELF_CLOSING_START_TAG_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else if (isAsciiUpper(cp)) {
+            this.currentToken.tagName += toAsciiLowerChar(cp);
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.currentToken.tagName += unicode.REPLACEMENT_CHARACTER;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInTag);
+            this._emitEOFToken();
+        } else {
+            this.currentToken.tagName += toChar(cp);
+        }
+    }
 
-    return this._consumeNamedEntity(inAttr);
-};
+    // RCDATA less-than sign state
+    //------------------------------------------------------------------
+    [RCDATA_LESS_THAN_SIGN_STATE](cp) {
+        if (cp === $.SOLIDUS) {
+            this.tempBuff = [];
+            this.state = RCDATA_END_TAG_OPEN_STATE;
+        } else {
+            this._emitChars('<');
+            this._reconsumeInState(RCDATA_STATE);
+        }
+    }
 
-//State machine
-var _ = Tokenizer.prototype;
+    // RCDATA end tag open state
+    //------------------------------------------------------------------
+    [RCDATA_END_TAG_OPEN_STATE](cp) {
+        if (isAsciiLetter(cp)) {
+            this._createEndTagToken();
+            this._reconsumeInState(RCDATA_END_TAG_NAME_STATE);
+        } else {
+            this._emitChars('</');
+            this._reconsumeInState(RCDATA_STATE);
+        }
+    }
 
-//12.2.4.1 Data state
-//------------------------------------------------------------------
-_[DATA_STATE] = function dataState(cp) {
-    this.preprocessor.dropParsedChunk();
+    // RCDATA end tag name state
+    //------------------------------------------------------------------
+    [RCDATA_END_TAG_NAME_STATE](cp) {
+        if (isAsciiUpper(cp)) {
+            this.currentToken.tagName += toAsciiLowerChar(cp);
+            this.tempBuff.push(cp);
+        } else if (isAsciiLower(cp)) {
+            this.currentToken.tagName += toChar(cp);
+            this.tempBuff.push(cp);
+        } else {
+            if (this.lastStartTagName === this.currentToken.tagName) {
+                if (isWhitespace(cp)) {
+                    this.state = BEFORE_ATTRIBUTE_NAME_STATE;
+                    return;
+                }
 
-    if (cp === $.AMPERSAND)
-        this.state = CHARACTER_REFERENCE_IN_DATA_STATE;
+                if (cp === $.SOLIDUS) {
+                    this.state = SELF_CLOSING_START_TAG_STATE;
+                    return;
+                }
 
-    else if (cp === $.LESS_THAN_SIGN)
-        this.state = TAG_OPEN_STATE;
+                if (cp === $.GREATER_THAN_SIGN) {
+                    this.state = DATA_STATE;
+                    this._emitCurrentToken();
+                    return;
+                }
+            }
 
-    else if (cp === $.NULL)
-        this._emitCodePoint(cp);
+            this._emitChars('</');
+            this._emitSeveralCodePoints(this.tempBuff);
+            this._reconsumeInState(RCDATA_STATE);
+        }
+    }
 
-    else if (cp === $.EOF)
-        this._emitEOFToken();
+    // RAWTEXT less-than sign state
+    //------------------------------------------------------------------
+    [RAWTEXT_LESS_THAN_SIGN_STATE](cp) {
+        if (cp === $.SOLIDUS) {
+            this.tempBuff = [];
+            this.state = RAWTEXT_END_TAG_OPEN_STATE;
+        } else {
+            this._emitChars('<');
+            this._reconsumeInState(RAWTEXT_STATE);
+        }
+    }
 
-    else
-        this._emitCodePoint(cp);
-};
+    // RAWTEXT end tag open state
+    //------------------------------------------------------------------
+    [RAWTEXT_END_TAG_OPEN_STATE](cp) {
+        if (isAsciiLetter(cp)) {
+            this._createEndTagToken();
+            this._reconsumeInState(RAWTEXT_END_TAG_NAME_STATE);
+        } else {
+            this._emitChars('</');
+            this._reconsumeInState(RAWTEXT_STATE);
+        }
+    }
 
+    // RAWTEXT end tag name state
+    //------------------------------------------------------------------
+    [RAWTEXT_END_TAG_NAME_STATE](cp) {
+        if (isAsciiUpper(cp)) {
+            this.currentToken.tagName += toAsciiLowerChar(cp);
+            this.tempBuff.push(cp);
+        } else if (isAsciiLower(cp)) {
+            this.currentToken.tagName += toChar(cp);
+            this.tempBuff.push(cp);
+        } else {
+            if (this.lastStartTagName === this.currentToken.tagName) {
+                if (isWhitespace(cp)) {
+                    this.state = BEFORE_ATTRIBUTE_NAME_STATE;
+                    return;
+                }
 
-//12.2.4.2 Character reference in data state
-//------------------------------------------------------------------
-_[CHARACTER_REFERENCE_IN_DATA_STATE] = function characterReferenceInDataState(cp) {
-    this.additionalAllowedCp = void 0;
+                if (cp === $.SOLIDUS) {
+                    this.state = SELF_CLOSING_START_TAG_STATE;
+                    return;
+                }
 
-    var referencedCodePoints = this._consumeCharacterReference(cp, false);
+                if (cp === $.GREATER_THAN_SIGN) {
+                    this._emitCurrentToken();
+                    this.state = DATA_STATE;
+                    return;
+                }
+            }
 
-    if (!this._ensureHibernation()) {
-        if (referencedCodePoints)
-            this._emitSeveralCodePoints(referencedCodePoints);
+            this._emitChars('</');
+            this._emitSeveralCodePoints(this.tempBuff);
+            this._reconsumeInState(RAWTEXT_STATE);
+        }
+    }
 
-        else
-            this._emitChar('&');
+    // Script data less-than sign state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_LESS_THAN_SIGN_STATE](cp) {
+        if (cp === $.SOLIDUS) {
+            this.tempBuff = [];
+            this.state = SCRIPT_DATA_END_TAG_OPEN_STATE;
+        } else if (cp === $.EXCLAMATION_MARK) {
+            this.state = SCRIPT_DATA_ESCAPE_START_STATE;
+            this._emitChars('<!');
+        } else {
+            this._emitChars('<');
+            this._reconsumeInState(SCRIPT_DATA_STATE);
+        }
+    }
 
-        this.state = DATA_STATE;
+    // Script data end tag open state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_END_TAG_OPEN_STATE](cp) {
+        if (isAsciiLetter(cp)) {
+            this._createEndTagToken();
+            this._reconsumeInState(SCRIPT_DATA_END_TAG_NAME_STATE);
+        } else {
+            this._emitChars('</');
+            this._reconsumeInState(SCRIPT_DATA_STATE);
+        }
     }
-};
 
+    // Script data end tag name state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_END_TAG_NAME_STATE](cp) {
+        if (isAsciiUpper(cp)) {
+            this.currentToken.tagName += toAsciiLowerChar(cp);
+            this.tempBuff.push(cp);
+        } else if (isAsciiLower(cp)) {
+            this.currentToken.tagName += toChar(cp);
+            this.tempBuff.push(cp);
+        } else {
+            if (this.lastStartTagName === this.currentToken.tagName) {
+                if (isWhitespace(cp)) {
+                    this.state = BEFORE_ATTRIBUTE_NAME_STATE;
+                    return;
+                } else if (cp === $.SOLIDUS) {
+                    this.state = SELF_CLOSING_START_TAG_STATE;
+                    return;
+                } else if (cp === $.GREATER_THAN_SIGN) {
+                    this._emitCurrentToken();
+                    this.state = DATA_STATE;
+                    return;
+                }
+            }
 
-//12.2.4.3 RCDATA state
-//------------------------------------------------------------------
-_[RCDATA_STATE] = function rcdataState(cp) {
-    this.preprocessor.dropParsedChunk();
+            this._emitChars('</');
+            this._emitSeveralCodePoints(this.tempBuff);
+            this._reconsumeInState(SCRIPT_DATA_STATE);
+        }
+    }
 
-    if (cp === $.AMPERSAND)
-        this.state = CHARACTER_REFERENCE_IN_RCDATA_STATE;
+    // Script data escape start state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_ESCAPE_START_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this.state = SCRIPT_DATA_ESCAPE_START_DASH_STATE;
+            this._emitChars('-');
+        } else {
+            this._reconsumeInState(SCRIPT_DATA_STATE);
+        }
+    }
 
-    else if (cp === $.LESS_THAN_SIGN)
-        this.state = RCDATA_LESS_THAN_SIGN_STATE;
+    // Script data escape start dash state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_ESCAPE_START_DASH_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE;
+            this._emitChars('-');
+        } else {
+            this._reconsumeInState(SCRIPT_DATA_STATE);
+        }
+    }
 
-    else if (cp === $.NULL)
-        this._emitChar(UNICODE.REPLACEMENT_CHARACTER);
+    // Script data escaped state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_ESCAPED_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this.state = SCRIPT_DATA_ESCAPED_DASH_STATE;
+            this._emitChars('-');
+        } else if (cp === $.LESS_THAN_SIGN) {
+            this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this._emitChars(unicode.REPLACEMENT_CHARACTER);
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInScriptHtmlCommentLikeText);
+            this._emitEOFToken();
+        } else {
+            this._emitCodePoint(cp);
+        }
+    }
 
-    else if (cp === $.EOF)
-        this._emitEOFToken();
+    // Script data escaped dash state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_ESCAPED_DASH_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE;
+            this._emitChars('-');
+        } else if (cp === $.LESS_THAN_SIGN) {
+            this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.state = SCRIPT_DATA_ESCAPED_STATE;
+            this._emitChars(unicode.REPLACEMENT_CHARACTER);
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInScriptHtmlCommentLikeText);
+            this._emitEOFToken();
+        } else {
+            this.state = SCRIPT_DATA_ESCAPED_STATE;
+            this._emitCodePoint(cp);
+        }
+    }
 
-    else
-        this._emitCodePoint(cp);
-};
+    // Script data escaped dash dash state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_ESCAPED_DASH_DASH_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this._emitChars('-');
+        } else if (cp === $.LESS_THAN_SIGN) {
+            this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this.state = SCRIPT_DATA_STATE;
+            this._emitChars('>');
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.state = SCRIPT_DATA_ESCAPED_STATE;
+            this._emitChars(unicode.REPLACEMENT_CHARACTER);
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInScriptHtmlCommentLikeText);
+            this._emitEOFToken();
+        } else {
+            this.state = SCRIPT_DATA_ESCAPED_STATE;
+            this._emitCodePoint(cp);
+        }
+    }
 
+    // Script data escaped less-than sign state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE](cp) {
+        if (cp === $.SOLIDUS) {
+            this.tempBuff = [];
+            this.state = SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE;
+        } else if (isAsciiLetter(cp)) {
+            this.tempBuff = [];
+            this._emitChars('<');
+            this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE);
+        } else {
+            this._emitChars('<');
+            this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
+        }
+    }
 
-//12.2.4.4 Character reference in RCDATA state
-//------------------------------------------------------------------
-_[CHARACTER_REFERENCE_IN_RCDATA_STATE] = function characterReferenceInRcdataState(cp) {
-    this.additionalAllowedCp = void 0;
+    // Script data escaped end tag open state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE](cp) {
+        if (isAsciiLetter(cp)) {
+            this._createEndTagToken();
+            this._reconsumeInState(SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE);
+        } else {
+            this._emitChars('</');
+            this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
+        }
+    }
 
-    var referencedCodePoints = this._consumeCharacterReference(cp, false);
+    // Script data escaped end tag name state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE](cp) {
+        if (isAsciiUpper(cp)) {
+            this.currentToken.tagName += toAsciiLowerChar(cp);
+            this.tempBuff.push(cp);
+        } else if (isAsciiLower(cp)) {
+            this.currentToken.tagName += toChar(cp);
+            this.tempBuff.push(cp);
+        } else {
+            if (this.lastStartTagName === this.currentToken.tagName) {
+                if (isWhitespace(cp)) {
+                    this.state = BEFORE_ATTRIBUTE_NAME_STATE;
+                    return;
+                }
 
-    if (!this._ensureHibernation()) {
-        if (referencedCodePoints)
-            this._emitSeveralCodePoints(referencedCodePoints);
+                if (cp === $.SOLIDUS) {
+                    this.state = SELF_CLOSING_START_TAG_STATE;
+                    return;
+                }
 
-        else
-            this._emitChar('&');
+                if (cp === $.GREATER_THAN_SIGN) {
+                    this._emitCurrentToken();
+                    this.state = DATA_STATE;
+                    return;
+                }
+            }
 
-        this.state = RCDATA_STATE;
+            this._emitChars('</');
+            this._emitSeveralCodePoints(this.tempBuff);
+            this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
+        }
     }
-};
 
+    // Script data double escape start state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE](cp) {
+        if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN) {
+            this.state = this._isTempBufferEqualToScriptString()
+                ? SCRIPT_DATA_DOUBLE_ESCAPED_STATE
+                : SCRIPT_DATA_ESCAPED_STATE;
+            this._emitCodePoint(cp);
+        } else if (isAsciiUpper(cp)) {
+            this.tempBuff.push(toAsciiLowerCodePoint(cp));
+            this._emitCodePoint(cp);
+        } else if (isAsciiLower(cp)) {
+            this.tempBuff.push(cp);
+            this._emitCodePoint(cp);
+        } else {
+            this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
+        }
+    }
 
-//12.2.4.5 RAWTEXT state
-//------------------------------------------------------------------
-_[RAWTEXT_STATE] = function rawtextState(cp) {
-    this.preprocessor.dropParsedChunk();
-
-    if (cp === $.LESS_THAN_SIGN)
-        this.state = RAWTEXT_LESS_THAN_SIGN_STATE;
+    // Script data double escaped state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_DOUBLE_ESCAPED_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE;
+            this._emitChars('-');
+        } else if (cp === $.LESS_THAN_SIGN) {
+            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
+            this._emitChars('<');
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this._emitChars(unicode.REPLACEMENT_CHARACTER);
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInScriptHtmlCommentLikeText);
+            this._emitEOFToken();
+        } else {
+            this._emitCodePoint(cp);
+        }
+    }
 
-    else if (cp === $.NULL)
-        this._emitChar(UNICODE.REPLACEMENT_CHARACTER);
+    // Script data double escaped dash state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE;
+            this._emitChars('-');
+        } else if (cp === $.LESS_THAN_SIGN) {
+            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
+            this._emitChars('<');
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
+            this._emitChars(unicode.REPLACEMENT_CHARACTER);
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInScriptHtmlCommentLikeText);
+            this._emitEOFToken();
+        } else {
+            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
+            this._emitCodePoint(cp);
+        }
+    }
 
-    else if (cp === $.EOF)
-        this._emitEOFToken();
+    // Script data double escaped dash dash state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this._emitChars('-');
+        } else if (cp === $.LESS_THAN_SIGN) {
+            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
+            this._emitChars('<');
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this.state = SCRIPT_DATA_STATE;
+            this._emitChars('>');
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
+            this._emitChars(unicode.REPLACEMENT_CHARACTER);
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInScriptHtmlCommentLikeText);
+            this._emitEOFToken();
+        } else {
+            this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
+            this._emitCodePoint(cp);
+        }
+    }
 
-    else
-        this._emitCodePoint(cp);
-};
+    // Script data double escaped less-than sign state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE](cp) {
+        if (cp === $.SOLIDUS) {
+            this.tempBuff = [];
+            this.state = SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE;
+            this._emitChars('/');
+        } else {
+            this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE);
+        }
+    }
 
+    // Script data double escape end state
+    //------------------------------------------------------------------
+    [SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE](cp) {
+        if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN) {
+            this.state = this._isTempBufferEqualToScriptString()
+                ? SCRIPT_DATA_ESCAPED_STATE
+                : SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
 
-//12.2.4.6 Script data state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_STATE] = function scriptDataState(cp) {
-    this.preprocessor.dropParsedChunk();
+            this._emitCodePoint(cp);
+        } else if (isAsciiUpper(cp)) {
+            this.tempBuff.push(toAsciiLowerCodePoint(cp));
+            this._emitCodePoint(cp);
+        } else if (isAsciiLower(cp)) {
+            this.tempBuff.push(cp);
+            this._emitCodePoint(cp);
+        } else {
+            this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE);
+        }
+    }
 
-    if (cp === $.LESS_THAN_SIGN)
-        this.state = SCRIPT_DATA_LESS_THAN_SIGN_STATE;
+    // Before attribute name state
+    //------------------------------------------------------------------
+    [BEFORE_ATTRIBUTE_NAME_STATE](cp) {
+        if (isWhitespace(cp)) {
+            return;
+        }
 
-    else if (cp === $.NULL)
-        this._emitChar(UNICODE.REPLACEMENT_CHARACTER);
+        if (cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN || cp === $.EOF) {
+            this._reconsumeInState(AFTER_ATTRIBUTE_NAME_STATE);
+        } else if (cp === $.EQUALS_SIGN) {
+            this._err(ERR.unexpectedEqualsSignBeforeAttributeName);
+            this._createAttr('=');
+            this.state = ATTRIBUTE_NAME_STATE;
+        } else {
+            this._createAttr('');
+            this._reconsumeInState(ATTRIBUTE_NAME_STATE);
+        }
+    }
 
-    else if (cp === $.EOF)
-        this._emitEOFToken();
-
-    else
-        this._emitCodePoint(cp);
-};
-
-
-//12.2.4.7 PLAINTEXT state
-//------------------------------------------------------------------
-_[PLAINTEXT_STATE] = function plaintextState(cp) {
-    this.preprocessor.dropParsedChunk();
-
-    if (cp === $.NULL)
-        this._emitChar(UNICODE.REPLACEMENT_CHARACTER);
-
-    else if (cp === $.EOF)
-        this._emitEOFToken();
-
-    else
-        this._emitCodePoint(cp);
-};
-
-
-//12.2.4.8 Tag open state
-//------------------------------------------------------------------
-_[TAG_OPEN_STATE] = function tagOpenState(cp) {
-    if (cp === $.EXCLAMATION_MARK)
-        this.state = MARKUP_DECLARATION_OPEN_STATE;
-
-    else if (cp === $.SOLIDUS)
-        this.state = END_TAG_OPEN_STATE;
-
-    else if (isAsciiLetter(cp)) {
-        this._createStartTagToken();
-        this._reconsumeInState(TAG_NAME_STATE);
-    }
-
-    else if (cp === $.QUESTION_MARK)
-        this._reconsumeInState(BOGUS_COMMENT_STATE);
-
-    else {
-        this._emitChar('<');
-        this._reconsumeInState(DATA_STATE);
-    }
-};
-
-
-//12.2.4.9 End tag open state
-//------------------------------------------------------------------
-_[END_TAG_OPEN_STATE] = function endTagOpenState(cp) {
-    if (isAsciiLetter(cp)) {
-        this._createEndTagToken();
-        this._reconsumeInState(TAG_NAME_STATE);
+    // Attribute name state
+    //------------------------------------------------------------------
+    [ATTRIBUTE_NAME_STATE](cp) {
+        if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN || cp === $.EOF) {
+            this._leaveAttrName(AFTER_ATTRIBUTE_NAME_STATE);
+            this._unconsume();
+        } else if (cp === $.EQUALS_SIGN) {
+            this._leaveAttrName(BEFORE_ATTRIBUTE_VALUE_STATE);
+        } else if (isAsciiUpper(cp)) {
+            this.currentAttr.name += toAsciiLowerChar(cp);
+        } else if (cp === $.QUOTATION_MARK || cp === $.APOSTROPHE || cp === $.LESS_THAN_SIGN) {
+            this._err(ERR.unexpectedCharacterInAttributeName);
+            this.currentAttr.name += toChar(cp);
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.currentAttr.name += unicode.REPLACEMENT_CHARACTER;
+        } else {
+            this.currentAttr.name += toChar(cp);
+        }
     }
 
-    else if (cp === $.GREATER_THAN_SIGN)
-        this.state = DATA_STATE;
+    // After attribute name state
+    //------------------------------------------------------------------
+    [AFTER_ATTRIBUTE_NAME_STATE](cp) {
+        if (isWhitespace(cp)) {
+            return;
+        }
 
-    else if (cp === $.EOF) {
-        this._reconsumeInState(DATA_STATE);
-        this._emitChar('<');
-        this._emitChar('/');
+        if (cp === $.SOLIDUS) {
+            this.state = SELF_CLOSING_START_TAG_STATE;
+        } else if (cp === $.EQUALS_SIGN) {
+            this.state = BEFORE_ATTRIBUTE_VALUE_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInTag);
+            this._emitEOFToken();
+        } else {
+            this._createAttr('');
+            this._reconsumeInState(ATTRIBUTE_NAME_STATE);
+        }
     }
 
-    else
-        this._reconsumeInState(BOGUS_COMMENT_STATE);
-};
-
-
-//12.2.4.10 Tag name state
-//------------------------------------------------------------------
-_[TAG_NAME_STATE] = function tagNameState(cp) {
-    if (isWhitespace(cp))
-        this.state = BEFORE_ATTRIBUTE_NAME_STATE;
-
-    else if (cp === $.SOLIDUS)
-        this.state = SELF_CLOSING_START_TAG_STATE;
+    // Before attribute value state
+    //------------------------------------------------------------------
+    [BEFORE_ATTRIBUTE_VALUE_STATE](cp) {
+        if (isWhitespace(cp)) {
+            return;
+        }
 
-    else if (cp === $.GREATER_THAN_SIGN) {
-        this.state = DATA_STATE;
-        this._emitCurrentToken();
+        if (cp === $.QUOTATION_MARK) {
+            this.state = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
+        } else if (cp === $.APOSTROPHE) {
+            this.state = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._err(ERR.missingAttributeValue);
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else {
+            this._reconsumeInState(ATTRIBUTE_VALUE_UNQUOTED_STATE);
+        }
     }
 
-    else if (isAsciiUpper(cp))
-        this.currentToken.tagName += toAsciiLowerChar(cp);
-
-    else if (cp === $.NULL)
-        this.currentToken.tagName += UNICODE.REPLACEMENT_CHARACTER;
-
-    else if (cp === $.EOF)
-        this._reconsumeInState(DATA_STATE);
-
-    else
-        this.currentToken.tagName += toChar(cp);
-};
-
-
-//12.2.4.11 RCDATA less-than sign state
-//------------------------------------------------------------------
-_[RCDATA_LESS_THAN_SIGN_STATE] = function rcdataLessThanSignState(cp) {
-    if (cp === $.SOLIDUS) {
-        this.tempBuff = [];
-        this.state = RCDATA_END_TAG_OPEN_STATE;
+    // Attribute value (double-quoted) state
+    //------------------------------------------------------------------
+    [ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE](cp) {
+        if (cp === $.QUOTATION_MARK) {
+            this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
+        } else if (cp === $.AMPERSAND) {
+            this.returnState = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
+            this.state = CHARACTER_REFERENCE_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.currentAttr.value += unicode.REPLACEMENT_CHARACTER;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInTag);
+            this._emitEOFToken();
+        } else {
+            this.currentAttr.value += toChar(cp);
+        }
     }
 
-    else {
-        this._emitChar('<');
-        this._reconsumeInState(RCDATA_STATE);
+    // Attribute value (single-quoted) state
+    //------------------------------------------------------------------
+    [ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE](cp) {
+        if (cp === $.APOSTROPHE) {
+            this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
+        } else if (cp === $.AMPERSAND) {
+            this.returnState = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
+            this.state = CHARACTER_REFERENCE_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.currentAttr.value += unicode.REPLACEMENT_CHARACTER;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInTag);
+            this._emitEOFToken();
+        } else {
+            this.currentAttr.value += toChar(cp);
+        }
     }
-};
-
 
-//12.2.4.12 RCDATA end tag open state
-//------------------------------------------------------------------
-_[RCDATA_END_TAG_OPEN_STATE] = function rcdataEndTagOpenState(cp) {
-    if (isAsciiLetter(cp)) {
-        this._createEndTagToken();
-        this._reconsumeInState(RCDATA_END_TAG_NAME_STATE);
+    // Attribute value (unquoted) state
+    //------------------------------------------------------------------
+    [ATTRIBUTE_VALUE_UNQUOTED_STATE](cp) {
+        if (isWhitespace(cp)) {
+            this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE);
+        } else if (cp === $.AMPERSAND) {
+            this.returnState = ATTRIBUTE_VALUE_UNQUOTED_STATE;
+            this.state = CHARACTER_REFERENCE_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._leaveAttrValue(DATA_STATE);
+            this._emitCurrentToken();
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.currentAttr.value += unicode.REPLACEMENT_CHARACTER;
+        } else if (
+            cp === $.QUOTATION_MARK ||
+            cp === $.APOSTROPHE ||
+            cp === $.LESS_THAN_SIGN ||
+            cp === $.EQUALS_SIGN ||
+            cp === $.GRAVE_ACCENT
+        ) {
+            this._err(ERR.unexpectedCharacterInUnquotedAttributeValue);
+            this.currentAttr.value += toChar(cp);
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInTag);
+            this._emitEOFToken();
+        } else {
+            this.currentAttr.value += toChar(cp);
+        }
     }
 
-    else {
-        this._emitChar('<');
-        this._emitChar('/');
-        this._reconsumeInState(RCDATA_STATE);
+    // After attribute value (quoted) state
+    //------------------------------------------------------------------
+    [AFTER_ATTRIBUTE_VALUE_QUOTED_STATE](cp) {
+        if (isWhitespace(cp)) {
+            this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE);
+        } else if (cp === $.SOLIDUS) {
+            this._leaveAttrValue(SELF_CLOSING_START_TAG_STATE);
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._leaveAttrValue(DATA_STATE);
+            this._emitCurrentToken();
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInTag);
+            this._emitEOFToken();
+        } else {
+            this._err(ERR.missingWhitespaceBetweenAttributes);
+            this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE);
+        }
     }
-};
-
 
-//12.2.4.13 RCDATA end tag name state
-//------------------------------------------------------------------
-_[RCDATA_END_TAG_NAME_STATE] = function rcdataEndTagNameState(cp) {
-    if (isAsciiUpper(cp)) {
-        this.currentToken.tagName += toAsciiLowerChar(cp);
-        this.tempBuff.push(cp);
+    // Self-closing start tag state
+    //------------------------------------------------------------------
+    [SELF_CLOSING_START_TAG_STATE](cp) {
+        if (cp === $.GREATER_THAN_SIGN) {
+            this.currentToken.selfClosing = true;
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInTag);
+            this._emitEOFToken();
+        } else {
+            this._err(ERR.unexpectedSolidusInTag);
+            this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE);
+        }
     }
 
-    else if (isAsciiLower(cp)) {
-        this.currentToken.tagName += toChar(cp);
-        this.tempBuff.push(cp);
+    // Bogus comment state
+    //------------------------------------------------------------------
+    [BOGUS_COMMENT_STATE](cp) {
+        if (cp === $.GREATER_THAN_SIGN) {
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else if (cp === $.EOF) {
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.currentToken.data += unicode.REPLACEMENT_CHARACTER;
+        } else {
+            this.currentToken.data += toChar(cp);
+        }
     }
 
-    else {
-        if (this._isAppropriateEndTagToken()) {
-            if (isWhitespace(cp)) {
-                this.state = BEFORE_ATTRIBUTE_NAME_STATE;
-                return;
-            }
-
-            if (cp === $.SOLIDUS) {
-                this.state = SELF_CLOSING_START_TAG_STATE;
-                return;
-            }
-
-            if (cp === $.GREATER_THAN_SIGN) {
-                this.state = DATA_STATE;
-                this._emitCurrentToken();
-                return;
+    // Markup declaration open state
+    //------------------------------------------------------------------
+    [MARKUP_DECLARATION_OPEN_STATE](cp) {
+        if (this._consumeSequenceIfMatch($$.DASH_DASH_STRING, cp, true)) {
+            this._createCommentToken();
+            this.state = COMMENT_START_STATE;
+        } else if (this._consumeSequenceIfMatch($$.DOCTYPE_STRING, cp, false)) {
+            this.state = DOCTYPE_STATE;
+        } else if (this._consumeSequenceIfMatch($$.CDATA_START_STRING, cp, true)) {
+            if (this.allowCDATA) {
+                this.state = CDATA_SECTION_STATE;
+            } else {
+                this._err(ERR.cdataInHtmlContent);
+                this._createCommentToken();
+                this.currentToken.data = '[CDATA[';
+                this.state = BOGUS_COMMENT_STATE;
             }
         }
 
-        this._emitChar('<');
-        this._emitChar('/');
-        this._emitSeveralCodePoints(this.tempBuff);
-        this._reconsumeInState(RCDATA_STATE);
-    }
-};
-
-
-//12.2.4.14 RAWTEXT less-than sign state
-//------------------------------------------------------------------
-_[RAWTEXT_LESS_THAN_SIGN_STATE] = function rawtextLessThanSignState(cp) {
-    if (cp === $.SOLIDUS) {
-        this.tempBuff = [];
-        this.state = RAWTEXT_END_TAG_OPEN_STATE;
-    }
-
-    else {
-        this._emitChar('<');
-        this._reconsumeInState(RAWTEXT_STATE);
-    }
-};
-
-
-//12.2.4.15 RAWTEXT end tag open state
-//------------------------------------------------------------------
-_[RAWTEXT_END_TAG_OPEN_STATE] = function rawtextEndTagOpenState(cp) {
-    if (isAsciiLetter(cp)) {
-        this._createEndTagToken();
-        this._reconsumeInState(RAWTEXT_END_TAG_NAME_STATE);
-    }
-
-    else {
-        this._emitChar('<');
-        this._emitChar('/');
-        this._reconsumeInState(RAWTEXT_STATE);
+        //NOTE: sequence lookup can be abrupted by hibernation. In that case lookup
+        //results are no longer valid and we will need to start over.
+        else if (!this._ensureHibernation()) {
+            this._err(ERR.incorrectlyOpenedComment);
+            this._createCommentToken();
+            this._reconsumeInState(BOGUS_COMMENT_STATE);
+        }
     }
-};
 
-
-//12.2.4.16 RAWTEXT end tag name state
-//------------------------------------------------------------------
-_[RAWTEXT_END_TAG_NAME_STATE] = function rawtextEndTagNameState(cp) {
-    if (isAsciiUpper(cp)) {
-        this.currentToken.tagName += toAsciiLowerChar(cp);
-        this.tempBuff.push(cp);
+    // Comment start state
+    //------------------------------------------------------------------
+    [COMMENT_START_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this.state = COMMENT_START_DASH_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._err(ERR.abruptClosingOfEmptyComment);
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else {
+            this._reconsumeInState(COMMENT_STATE);
+        }
     }
 
-    else if (isAsciiLower(cp)) {
-        this.currentToken.tagName += toChar(cp);
-        this.tempBuff.push(cp);
+    // Comment start dash state
+    //------------------------------------------------------------------
+    [COMMENT_START_DASH_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this.state = COMMENT_END_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._err(ERR.abruptClosingOfEmptyComment);
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInComment);
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this.currentToken.data += '-';
+            this._reconsumeInState(COMMENT_STATE);
+        }
     }
 
-    else {
-        if (this._isAppropriateEndTagToken()) {
-            if (isWhitespace(cp)) {
-                this.state = BEFORE_ATTRIBUTE_NAME_STATE;
-                return;
-            }
-
-            if (cp === $.SOLIDUS) {
-                this.state = SELF_CLOSING_START_TAG_STATE;
-                return;
-            }
-
-            if (cp === $.GREATER_THAN_SIGN) {
-                this._emitCurrentToken();
-                this.state = DATA_STATE;
-                return;
-            }
+    // Comment state
+    //------------------------------------------------------------------
+    [COMMENT_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this.state = COMMENT_END_DASH_STATE;
+        } else if (cp === $.LESS_THAN_SIGN) {
+            this.currentToken.data += '<';
+            this.state = COMMENT_LESS_THAN_SIGN_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.currentToken.data += unicode.REPLACEMENT_CHARACTER;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInComment);
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this.currentToken.data += toChar(cp);
         }
-
-        this._emitChar('<');
-        this._emitChar('/');
-        this._emitSeveralCodePoints(this.tempBuff);
-        this._reconsumeInState(RAWTEXT_STATE);
     }
-};
 
-
-//12.2.4.17 Script data less-than sign state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_LESS_THAN_SIGN_STATE] = function scriptDataLessThanSignState(cp) {
-    if (cp === $.SOLIDUS) {
-        this.tempBuff = [];
-        this.state = SCRIPT_DATA_END_TAG_OPEN_STATE;
+    // Comment less-than sign state
+    //------------------------------------------------------------------
+    [COMMENT_LESS_THAN_SIGN_STATE](cp) {
+        if (cp === $.EXCLAMATION_MARK) {
+            this.currentToken.data += '!';
+            this.state = COMMENT_LESS_THAN_SIGN_BANG_STATE;
+        } else if (cp === $.LESS_THAN_SIGN) {
+            this.currentToken.data += '!';
+        } else {
+            this._reconsumeInState(COMMENT_STATE);
+        }
     }
 
-    else if (cp === $.EXCLAMATION_MARK) {
-        this.state = SCRIPT_DATA_ESCAPE_START_STATE;
-        this._emitChar('<');
-        this._emitChar('!');
+    // Comment less-than sign bang state
+    //------------------------------------------------------------------
+    [COMMENT_LESS_THAN_SIGN_BANG_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this.state = COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE;
+        } else {
+            this._reconsumeInState(COMMENT_STATE);
+        }
     }
 
-    else {
-        this._emitChar('<');
-        this._reconsumeInState(SCRIPT_DATA_STATE);
+    // Comment less-than sign bang dash state
+    //------------------------------------------------------------------
+    [COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this.state = COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE;
+        } else {
+            this._reconsumeInState(COMMENT_END_DASH_STATE);
+        }
     }
-};
 
+    // Comment less-than sign bang dash dash state
+    //------------------------------------------------------------------
+    [COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE](cp) {
+        if (cp !== $.GREATER_THAN_SIGN && cp !== $.EOF) {
+            this._err(ERR.nestedComment);
+        }
 
-//12.2.4.18 Script data end tag open state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_END_TAG_OPEN_STATE] = function scriptDataEndTagOpenState(cp) {
-    if (isAsciiLetter(cp)) {
-        this._createEndTagToken();
-        this._reconsumeInState(SCRIPT_DATA_END_TAG_NAME_STATE);
-    }
-
-    else {
-        this._emitChar('<');
-        this._emitChar('/');
-        this._reconsumeInState(SCRIPT_DATA_STATE);
+        this._reconsumeInState(COMMENT_END_STATE);
+    }
+
+    // Comment end dash state
+    //------------------------------------------------------------------
+    [COMMENT_END_DASH_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this.state = COMMENT_END_STATE;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInComment);
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this.currentToken.data += '-';
+            this._reconsumeInState(COMMENT_STATE);
+        }
     }
-};
-
 
-//12.2.4.19 Script data end tag name state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_END_TAG_NAME_STATE] = function scriptDataEndTagNameState(cp) {
-    if (isAsciiUpper(cp)) {
-        this.currentToken.tagName += toAsciiLowerChar(cp);
-        this.tempBuff.push(cp);
+    // Comment end state
+    //------------------------------------------------------------------
+    [COMMENT_END_STATE](cp) {
+        if (cp === $.GREATER_THAN_SIGN) {
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else if (cp === $.EXCLAMATION_MARK) {
+            this.state = COMMENT_END_BANG_STATE;
+        } else if (cp === $.HYPHEN_MINUS) {
+            this.currentToken.data += '-';
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInComment);
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this.currentToken.data += '--';
+            this._reconsumeInState(COMMENT_STATE);
+        }
     }
 
-    else if (isAsciiLower(cp)) {
-        this.currentToken.tagName += toChar(cp);
-        this.tempBuff.push(cp);
+    // Comment end bang state
+    //------------------------------------------------------------------
+    [COMMENT_END_BANG_STATE](cp) {
+        if (cp === $.HYPHEN_MINUS) {
+            this.currentToken.data += '--!';
+            this.state = COMMENT_END_DASH_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._err(ERR.incorrectlyClosedComment);
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInComment);
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this.currentToken.data += '--!';
+            this._reconsumeInState(COMMENT_STATE);
+        }
     }
 
-    else {
-        if (this._isAppropriateEndTagToken()) {
-            if (isWhitespace(cp)) {
-                this.state = BEFORE_ATTRIBUTE_NAME_STATE;
-                return;
-            }
-
-            else if (cp === $.SOLIDUS) {
-                this.state = SELF_CLOSING_START_TAG_STATE;
-                return;
-            }
-
-            else if (cp === $.GREATER_THAN_SIGN) {
-                this._emitCurrentToken();
-                this.state = DATA_STATE;
-                return;
-            }
+    // DOCTYPE state
+    //------------------------------------------------------------------
+    [DOCTYPE_STATE](cp) {
+        if (isWhitespace(cp)) {
+            this.state = BEFORE_DOCTYPE_NAME_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._reconsumeInState(BEFORE_DOCTYPE_NAME_STATE);
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this._createDoctypeToken(null);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this._err(ERR.missingWhitespaceBeforeDoctypeName);
+            this._reconsumeInState(BEFORE_DOCTYPE_NAME_STATE);
         }
-
-        this._emitChar('<');
-        this._emitChar('/');
-        this._emitSeveralCodePoints(this.tempBuff);
-        this._reconsumeInState(SCRIPT_DATA_STATE);
     }
-};
 
+    // Before DOCTYPE name state
+    //------------------------------------------------------------------
+    [BEFORE_DOCTYPE_NAME_STATE](cp) {
+        if (isWhitespace(cp)) {
+            return;
+        }
 
-//12.2.4.20 Script data escape start state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_ESCAPE_START_STATE] = function scriptDataEscapeStartState(cp) {
-    if (cp === $.HYPHEN_MINUS) {
-        this.state = SCRIPT_DATA_ESCAPE_START_DASH_STATE;
-        this._emitChar('-');
+        if (isAsciiUpper(cp)) {
+            this._createDoctypeToken(toAsciiLowerChar(cp));
+            this.state = DOCTYPE_NAME_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this._createDoctypeToken(unicode.REPLACEMENT_CHARACTER);
+            this.state = DOCTYPE_NAME_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._err(ERR.missingDoctypeName);
+            this._createDoctypeToken(null);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this.state = DATA_STATE;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this._createDoctypeToken(null);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this._createDoctypeToken(toChar(cp));
+            this.state = DOCTYPE_NAME_STATE;
+        }
     }
 
-    else
-        this._reconsumeInState(SCRIPT_DATA_STATE);
-};
-
-
-//12.2.4.21 Script data escape start dash state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_ESCAPE_START_DASH_STATE] = function scriptDataEscapeStartDashState(cp) {
-    if (cp === $.HYPHEN_MINUS) {
-        this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE;
-        this._emitChar('-');
+    // DOCTYPE name state
+    //------------------------------------------------------------------
+    [DOCTYPE_NAME_STATE](cp) {
+        if (isWhitespace(cp)) {
+            this.state = AFTER_DOCTYPE_NAME_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else if (isAsciiUpper(cp)) {
+            this.currentToken.name += toAsciiLowerChar(cp);
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.currentToken.name += unicode.REPLACEMENT_CHARACTER;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this.currentToken.name += toChar(cp);
+        }
     }
 
-    else
-        this._reconsumeInState(SCRIPT_DATA_STATE);
-};
-
+    // After DOCTYPE name state
+    //------------------------------------------------------------------
+    [AFTER_DOCTYPE_NAME_STATE](cp) {
+        if (isWhitespace(cp)) {
+            return;
+        }
 
-//12.2.4.22 Script data escaped state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_ESCAPED_STATE] = function scriptDataEscapedState(cp) {
-    if (cp === $.HYPHEN_MINUS) {
-        this.state = SCRIPT_DATA_ESCAPED_DASH_STATE;
-        this._emitChar('-');
+        if (cp === $.GREATER_THAN_SIGN) {
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else if (this._consumeSequenceIfMatch($$.PUBLIC_STRING, cp, false)) {
+            this.state = AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE;
+        } else if (this._consumeSequenceIfMatch($$.SYSTEM_STRING, cp, false)) {
+            this.state = AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE;
+        }
+        //NOTE: sequence lookup can be abrupted by hibernation. In that case lookup
+        //results are no longer valid and we will need to start over.
+        else if (!this._ensureHibernation()) {
+            this._err(ERR.invalidCharacterSequenceAfterDoctypeName);
+            this.currentToken.forceQuirks = true;
+            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
+        }
     }
 
-    else if (cp === $.LESS_THAN_SIGN)
-        this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
-
-    else if (cp === $.NULL)
-        this._emitChar(UNICODE.REPLACEMENT_CHARACTER);
-
-    else if (cp === $.EOF)
-        this._reconsumeInState(DATA_STATE);
-
-    else
-        this._emitCodePoint(cp);
-};
-
-
-//12.2.4.23 Script data escaped dash state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_ESCAPED_DASH_STATE] = function scriptDataEscapedDashState(cp) {
-    if (cp === $.HYPHEN_MINUS) {
-        this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE;
-        this._emitChar('-');
+    // After DOCTYPE public keyword state
+    //------------------------------------------------------------------
+    [AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE](cp) {
+        if (isWhitespace(cp)) {
+            this.state = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
+        } else if (cp === $.QUOTATION_MARK) {
+            this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);
+            this.currentToken.publicId = '';
+            this.state = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE;
+        } else if (cp === $.APOSTROPHE) {
+            this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);
+            this.currentToken.publicId = '';
+            this.state = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._err(ERR.missingDoctypePublicIdentifier);
+            this.currentToken.forceQuirks = true;
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
+            this.currentToken.forceQuirks = true;
+            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
+        }
     }
 
-    else if (cp === $.LESS_THAN_SIGN)
-        this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
+    // Before DOCTYPE public identifier state
+    //------------------------------------------------------------------
+    [BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE](cp) {
+        if (isWhitespace(cp)) {
+            return;
+        }
 
-    else if (cp === $.NULL) {
-        this.state = SCRIPT_DATA_ESCAPED_STATE;
-        this._emitChar(UNICODE.REPLACEMENT_CHARACTER);
+        if (cp === $.QUOTATION_MARK) {
+            this.currentToken.publicId = '';
+            this.state = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE;
+        } else if (cp === $.APOSTROPHE) {
+            this.currentToken.publicId = '';
+            this.state = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._err(ERR.missingDoctypePublicIdentifier);
+            this.currentToken.forceQuirks = true;
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
+            this.currentToken.forceQuirks = true;
+            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
+        }
     }
 
-    else if (cp === $.EOF)
-        this._reconsumeInState(DATA_STATE);
-
-    else {
-        this.state = SCRIPT_DATA_ESCAPED_STATE;
-        this._emitCodePoint(cp);
+    // DOCTYPE public identifier (double-quoted) state
+    //------------------------------------------------------------------
+    [DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE](cp) {
+        if (cp === $.QUOTATION_MARK) {
+            this.state = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.currentToken.publicId += unicode.REPLACEMENT_CHARACTER;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._err(ERR.abruptDoctypePublicIdentifier);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this.state = DATA_STATE;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this.currentToken.publicId += toChar(cp);
+        }
     }
-};
 
-
-//12.2.4.24 Script data escaped dash dash state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_ESCAPED_DASH_DASH_STATE] = function scriptDataEscapedDashDashState(cp) {
-    if (cp === $.HYPHEN_MINUS)
-        this._emitChar('-');
-
-    else if (cp === $.LESS_THAN_SIGN)
-        this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
-
-    else if (cp === $.GREATER_THAN_SIGN) {
-        this.state = SCRIPT_DATA_STATE;
-        this._emitChar('>');
+    // DOCTYPE public identifier (single-quoted) state
+    //------------------------------------------------------------------
+    [DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE](cp) {
+        if (cp === $.APOSTROPHE) {
+            this.state = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.currentToken.publicId += unicode.REPLACEMENT_CHARACTER;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._err(ERR.abruptDoctypePublicIdentifier);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this.state = DATA_STATE;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this.currentToken.publicId += toChar(cp);
+        }
     }
 
-    else if (cp === $.NULL) {
-        this.state = SCRIPT_DATA_ESCAPED_STATE;
-        this._emitChar(UNICODE.REPLACEMENT_CHARACTER);
+    // After DOCTYPE public identifier state
+    //------------------------------------------------------------------
+    [AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE](cp) {
+        if (isWhitespace(cp)) {
+            this.state = BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else if (cp === $.QUOTATION_MARK) {
+            this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);
+            this.currentToken.systemId = '';
+            this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
+        } else if (cp === $.APOSTROPHE) {
+            this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);
+            this.currentToken.systemId = '';
+            this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
+            this.currentToken.forceQuirks = true;
+            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
+        }
     }
 
-    else if (cp === $.EOF)
-        this._reconsumeInState(DATA_STATE);
+    // Between DOCTYPE public and system identifiers state
+    //------------------------------------------------------------------
+    [BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE](cp) {
+        if (isWhitespace(cp)) {
+            return;
+        }
 
-    else {
-        this.state = SCRIPT_DATA_ESCAPED_STATE;
-        this._emitCodePoint(cp);
+        if (cp === $.GREATER_THAN_SIGN) {
+            this._emitCurrentToken();
+            this.state = DATA_STATE;
+        } else if (cp === $.QUOTATION_MARK) {
+            this.currentToken.systemId = '';
+            this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
+        } else if (cp === $.APOSTROPHE) {
+            this.currentToken.systemId = '';
+            this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
+            this.currentToken.forceQuirks = true;
+            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
+        }
     }
-};
 
-
-//12.2.4.25 Script data escaped less-than sign state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE] = function scriptDataEscapedLessThanSignState(cp) {
-    if (cp === $.SOLIDUS) {
-        this.tempBuff = [];
-        this.state = SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE;
+    // After DOCTYPE system keyword state
+    //------------------------------------------------------------------
+    [AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE](cp) {
+        if (isWhitespace(cp)) {
+            this.state = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
+        } else if (cp === $.QUOTATION_MARK) {
+            this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);
+            this.currentToken.systemId = '';
+            this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
+        } else if (cp === $.APOSTROPHE) {
+            this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);
+            this.currentToken.systemId = '';
+            this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._err(ERR.missingDoctypeSystemIdentifier);
+            this.currentToken.forceQuirks = true;
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
+            this.currentToken.forceQuirks = true;
+            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
+        }
     }
 
-    else if (isAsciiLetter(cp)) {
-        this.tempBuff = [];
-        this._emitChar('<');
-        this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE);
-    }
+    // Before DOCTYPE system identifier state
+    //------------------------------------------------------------------
+    [BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE](cp) {
+        if (isWhitespace(cp)) {
+            return;
+        }
 
-    else {
-        this._emitChar('<');
-        this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
+        if (cp === $.QUOTATION_MARK) {
+            this.currentToken.systemId = '';
+            this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
+        } else if (cp === $.APOSTROPHE) {
+            this.currentToken.systemId = '';
+            this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._err(ERR.missingDoctypeSystemIdentifier);
+            this.currentToken.forceQuirks = true;
+            this.state = DATA_STATE;
+            this._emitCurrentToken();
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
+            this.currentToken.forceQuirks = true;
+            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
+        }
     }
-};
 
-
-//12.2.4.26 Script data escaped end tag open state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE] = function scriptDataEscapedEndTagOpenState(cp) {
-    if (isAsciiLetter(cp)) {
-        this._createEndTagToken();
-        this._reconsumeInState(SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE);
+    // DOCTYPE system identifier (double-quoted) state
+    //------------------------------------------------------------------
+    [DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE](cp) {
+        if (cp === $.QUOTATION_MARK) {
+            this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.currentToken.systemId += unicode.REPLACEMENT_CHARACTER;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._err(ERR.abruptDoctypeSystemIdentifier);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this.state = DATA_STATE;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this.currentToken.systemId += toChar(cp);
+        }
     }
 
-    else {
-        this._emitChar('<');
-        this._emitChar('/');
-        this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
+    // DOCTYPE system identifier (single-quoted) state
+    //------------------------------------------------------------------
+    [DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE](cp) {
+        if (cp === $.APOSTROPHE) {
+            this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+            this.currentToken.systemId += unicode.REPLACEMENT_CHARACTER;
+        } else if (cp === $.GREATER_THAN_SIGN) {
+            this._err(ERR.abruptDoctypeSystemIdentifier);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this.state = DATA_STATE;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this.currentToken.systemId += toChar(cp);
+        }
     }
-};
 
+    // After DOCTYPE system identifier state
+    //------------------------------------------------------------------
+    [AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE](cp) {
+        if (isWhitespace(cp)) {
+            return;
+        }
 
-//12.2.4.27 Script data escaped end tag name state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE] = function scriptDataEscapedEndTagNameState(cp) {
-    if (isAsciiUpper(cp)) {
-        this.currentToken.tagName += toAsciiLowerChar(cp);
-        this.tempBuff.push(cp);
-    }
-
-    else if (isAsciiLower(cp)) {
-        this.currentToken.tagName += toChar(cp);
-        this.tempBuff.push(cp);
+        if (cp === $.GREATER_THAN_SIGN) {
+            this._emitCurrentToken();
+            this.state = DATA_STATE;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInDoctype);
+            this.currentToken.forceQuirks = true;
+            this._emitCurrentToken();
+            this._emitEOFToken();
+        } else {
+            this._err(ERR.unexpectedCharacterAfterDoctypeSystemIdentifier);
+            this._reconsumeInState(BOGUS_DOCTYPE_STATE);
+        }
     }
 
-    else {
-        if (this._isAppropriateEndTagToken()) {
-            if (isWhitespace(cp)) {
-                this.state = BEFORE_ATTRIBUTE_NAME_STATE;
-                return;
-            }
-
-            if (cp === $.SOLIDUS) {
-                this.state = SELF_CLOSING_START_TAG_STATE;
-                return;
-            }
-
-            if (cp === $.GREATER_THAN_SIGN) {
-                this._emitCurrentToken();
-                this.state = DATA_STATE;
-                return;
-            }
+    // Bogus DOCTYPE state
+    //------------------------------------------------------------------
+    [BOGUS_DOCTYPE_STATE](cp) {
+        if (cp === $.GREATER_THAN_SIGN) {
+            this._emitCurrentToken();
+            this.state = DATA_STATE;
+        } else if (cp === $.NULL) {
+            this._err(ERR.unexpectedNullCharacter);
+        } else if (cp === $.EOF) {
+            this._emitCurrentToken();
+            this._emitEOFToken();
         }
-
-        this._emitChar('<');
-        this._emitChar('/');
-        this._emitSeveralCodePoints(this.tempBuff);
-        this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
     }
-};
-
 
-//12.2.4.28 Script data double escape start state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE] = function scriptDataDoubleEscapeStartState(cp) {
-    if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN) {
-        this.state = this.isTempBufferEqualToScriptString() ? SCRIPT_DATA_DOUBLE_ESCAPED_STATE : SCRIPT_DATA_ESCAPED_STATE;
-        this._emitCodePoint(cp);
+    // CDATA section state
+    //------------------------------------------------------------------
+    [CDATA_SECTION_STATE](cp) {
+        if (cp === $.RIGHT_SQUARE_BRACKET) {
+            this.state = CDATA_SECTION_BRACKET_STATE;
+        } else if (cp === $.EOF) {
+            this._err(ERR.eofInCdata);
+            this._emitEOFToken();
+        } else {
+            this._emitCodePoint(cp);
+        }
     }
 
-    else if (isAsciiUpper(cp)) {
-        this.tempBuff.push(toAsciiLowerCodePoint(cp));
-        this._emitCodePoint(cp);
+    // CDATA section bracket state
+    //------------------------------------------------------------------
+    [CDATA_SECTION_BRACKET_STATE](cp) {
+        if (cp === $.RIGHT_SQUARE_BRACKET) {
+            this.state = CDATA_SECTION_END_STATE;
+        } else {
+            this._emitChars(']');
+            this._reconsumeInState(CDATA_SECTION_STATE);
+        }
     }
 
-    else if (isAsciiLower(cp)) {
-        this.tempBuff.push(cp);
-        this._emitCodePoint(cp);
+    // CDATA section end state
+    //------------------------------------------------------------------
+    [CDATA_SECTION_END_STATE](cp) {
+        if (cp === $.GREATER_THAN_SIGN) {
+            this.state = DATA_STATE;
+        } else if (cp === $.RIGHT_SQUARE_BRACKET) {
+            this._emitChars(']');
+        } else {
+            this._emitChars(']]');
+            this._reconsumeInState(CDATA_SECTION_STATE);
+        }
     }
 
-    else
-        this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
-};
-
+    // Character reference state
+    //------------------------------------------------------------------
+    [CHARACTER_REFERENCE_STATE](cp) {
+        this.tempBuff = [$.AMPERSAND];
 
-//12.2.4.29 Script data double escaped state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_DOUBLE_ESCAPED_STATE] = function scriptDataDoubleEscapedState(cp) {
-    if (cp === $.HYPHEN_MINUS) {
-        this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE;
-        this._emitChar('-');
-    }
-
-    else if (cp === $.LESS_THAN_SIGN) {
-        this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
-        this._emitChar('<');
+        if (cp === $.NUMBER_SIGN) {
+            this.tempBuff.push(cp);
+            this.state = NUMERIC_CHARACTER_REFERENCE_STATE;
+        } else if (isAsciiAlphaNumeric(cp)) {
+            this._reconsumeInState(NAMED_CHARACTER_REFERENCE_STATE);
+        } else {
+            this._flushCodePointsConsumedAsCharacterReference();
+            this._reconsumeInState(this.returnState);
+        }
     }
 
-    else if (cp === $.NULL)
-        this._emitChar(UNICODE.REPLACEMENT_CHARACTER);
-
-    else if (cp === $.EOF)
-        this._reconsumeInState(DATA_STATE);
-
-    else
-        this._emitCodePoint(cp);
-};
+    // Named character reference state
+    //------------------------------------------------------------------
+    [NAMED_CHARACTER_REFERENCE_STATE](cp) {
+        const matchResult = this._matchNamedCharacterReference(cp);
 
+        //NOTE: matching can be abrupted by hibernation. In that case match
+        //results are no longer valid and we will need to start over.
+        if (this._ensureHibernation()) {
+            this.tempBuff = [$.AMPERSAND];
+        } else if (matchResult) {
+            const withSemicolon = this.tempBuff[this.tempBuff.length - 1] === $.SEMICOLON;
 
-//12.2.4.30 Script data double escaped dash state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE] = function scriptDataDoubleEscapedDashState(cp) {
-    if (cp === $.HYPHEN_MINUS) {
-        this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE;
-        this._emitChar('-');
-    }
+            if (!this._isCharacterReferenceAttributeQuirk(withSemicolon)) {
+                if (!withSemicolon) {
+                    this._errOnNextCodePoint(ERR.missingSemicolonAfterCharacterReference);
+                }
 
-    else if (cp === $.LESS_THAN_SIGN) {
-        this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
-        this._emitChar('<');
-    }
+                this.tempBuff = matchResult;
+            }
 
-    else if (cp === $.NULL) {
-        this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
-        this._emitChar(UNICODE.REPLACEMENT_CHARACTER);
+            this._flushCodePointsConsumedAsCharacterReference();
+            this.state = this.returnState;
+        } else {
+            this._flushCodePointsConsumedAsCharacterReference();
+            this.state = AMBIGUOUS_AMPERSAND_STATE;
+        }
     }
 
-    else if (cp === $.EOF)
-        this._reconsumeInState(DATA_STATE);
+    // Ambiguos ampersand state
+    //------------------------------------------------------------------
+    [AMBIGUOUS_AMPERSAND_STATE](cp) {
+        if (isAsciiAlphaNumeric(cp)) {
+            if (this._isCharacterReferenceInAttribute()) {
+                this.currentAttr.value += toChar(cp);
+            } else {
+                this._emitCodePoint(cp);
+            }
+        } else {
+            if (cp === $.SEMICOLON) {
+                this._err(ERR.unknownNamedCharacterReference);
+            }
 
-    else {
-        this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
-        this._emitCodePoint(cp);
+            this._reconsumeInState(this.returnState);
+        }
     }
-};
 
+    // Numeric character reference state
+    //------------------------------------------------------------------
+    [NUMERIC_CHARACTER_REFERENCE_STATE](cp) {
+        this.charRefCode = 0;
 
-//12.2.4.31 Script data double escaped dash dash state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE] = function scriptDataDoubleEscapedDashDashState(cp) {
-    if (cp === $.HYPHEN_MINUS)
-        this._emitChar('-');
-
-    else if (cp === $.LESS_THAN_SIGN) {
-        this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
-        this._emitChar('<');
+        if (cp === $.LATIN_SMALL_X || cp === $.LATIN_CAPITAL_X) {
+            this.tempBuff.push(cp);
+            this.state = HEXADEMICAL_CHARACTER_REFERENCE_START_STATE;
+        } else {
+            this._reconsumeInState(DECIMAL_CHARACTER_REFERENCE_START_STATE);
+        }
     }
 
-    else if (cp === $.GREATER_THAN_SIGN) {
-        this.state = SCRIPT_DATA_STATE;
-        this._emitChar('>');
+    // Hexademical character reference start state
+    //------------------------------------------------------------------
+    [HEXADEMICAL_CHARACTER_REFERENCE_START_STATE](cp) {
+        if (isAsciiHexDigit(cp)) {
+            this._reconsumeInState(HEXADEMICAL_CHARACTER_REFERENCE_STATE);
+        } else {
+            this._err(ERR.absenceOfDigitsInNumericCharacterReference);
+            this._flushCodePointsConsumedAsCharacterReference();
+            this._reconsumeInState(this.returnState);
+        }
     }
 
-    else if (cp === $.NULL) {
-        this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
-        this._emitChar(UNICODE.REPLACEMENT_CHARACTER);
+    // Decimal character reference start state
+    //------------------------------------------------------------------
+    [DECIMAL_CHARACTER_REFERENCE_START_STATE](cp) {
+        if (isAsciiDigit(cp)) {
+            this._reconsumeInState(DECIMAL_CHARACTER_REFERENCE_STATE);
+        } else {
+            this._err(ERR.absenceOfDigitsInNumericCharacterReference);
+            this._flushCodePointsConsumedAsCharacterReference();
+            this._reconsumeInState(this.returnState);
+        }
     }
 
-    else if (cp === $.EOF)
-        this._reconsumeInState(DATA_STATE);
-
-    else {
-        this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
-        this._emitCodePoint(cp);
+    // Hexademical character reference state
+    //------------------------------------------------------------------
+    [HEXADEMICAL_CHARACTER_REFERENCE_STATE](cp) {
+        if (isAsciiUpperHexDigit(cp)) {
+            this.charRefCode = this.charRefCode * 16 + cp - 0x37;
+        } else if (isAsciiLowerHexDigit(cp)) {
+            this.charRefCode = this.charRefCode * 16 + cp - 0x57;
+        } else if (isAsciiDigit(cp)) {
+            this.charRefCode = this.charRefCode * 16 + cp - 0x30;
+        } else if (cp === $.SEMICOLON) {
+            this.state = NUMERIC_CHARACTER_REFERENCE_END_STATE;
+        } else {
+            this._err(ERR.missingSemicolonAfterCharacterReference);
+            this._reconsumeInState(NUMERIC_CHARACTER_REFERENCE_END_STATE);
+        }
     }
-};
-
 
-//12.2.4.32 Script data double escaped less-than sign state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE] = function scriptDataDoubleEscapedLessThanSignState(cp) {
-    if (cp === $.SOLIDUS) {
-        this.tempBuff = [];
-        this.state = SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE;
-        this._emitChar('/');
+    // Decimal character reference state
+    //------------------------------------------------------------------
+    [DECIMAL_CHARACTER_REFERENCE_STATE](cp) {
+        if (isAsciiDigit(cp)) {
+            this.charRefCode = this.charRefCode * 10 + cp - 0x30;
+        } else if (cp === $.SEMICOLON) {
+            this.state = NUMERIC_CHARACTER_REFERENCE_END_STATE;
+        } else {
+            this._err(ERR.missingSemicolonAfterCharacterReference);
+            this._reconsumeInState(NUMERIC_CHARACTER_REFERENCE_END_STATE);
+        }
     }
 
-    else
-        this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE);
-};
-
-
-//12.2.4.33 Script data double escape end state
-//------------------------------------------------------------------
-_[SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE] = function scriptDataDoubleEscapeEndState(cp) {
-    if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN) {
-        this.state = this.isTempBufferEqualToScriptString() ? SCRIPT_DATA_ESCAPED_STATE : SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
+    // Numeric character reference end state
+    //------------------------------------------------------------------
+    [NUMERIC_CHARACTER_REFERENCE_END_STATE]() {
+        if (this.charRefCode === $.NULL) {
+            this._err(ERR.nullCharacterReference);
+            this.charRefCode = $.REPLACEMENT_CHARACTER;
+        } else if (this.charRefCode > 0x10ffff) {
+            this._err(ERR.characterReferenceOutsideUnicodeRange);
+            this.charRefCode = $.REPLACEMENT_CHARACTER;
+        } else if (unicode.isSurrogate(this.charRefCode)) {
+            this._err(ERR.surrogateCharacterReference);
+            this.charRefCode = $.REPLACEMENT_CHARACTER;
+        } else if (unicode.isUndefinedCodePoint(this.charRefCode)) {
+            this._err(ERR.noncharacterCharacterReference);
+        } else if (unicode.isControlCodePoint(this.charRefCode) || this.charRefCode === $.CARRIAGE_RETURN) {
+            this._err(ERR.controlCharacterReference);
+
+            const replacement = C1_CONTROLS_REFERENCE_REPLACEMENTS[this.charRefCode];
+
+            if (replacement) {
+                this.charRefCode = replacement;
+            }
+        }
 
-        this._emitCodePoint(cp);
-    }
+        this.tempBuff = [this.charRefCode];
 
-    else if (isAsciiUpper(cp)) {
-        this.tempBuff.push(toAsciiLowerCodePoint(cp));
-        this._emitCodePoint(cp);
+        this._flushCodePointsConsumedAsCharacterReference();
+        this._reconsumeInState(this.returnState);
     }
+}
 
-    else if (isAsciiLower(cp)) {
-        this.tempBuff.push(cp);
-        this._emitCodePoint(cp);
-    }
+//Token types
+Tokenizer.CHARACTER_TOKEN = 'CHARACTER_TOKEN';
+Tokenizer.NULL_CHARACTER_TOKEN = 'NULL_CHARACTER_TOKEN';
+Tokenizer.WHITESPACE_CHARACTER_TOKEN = 'WHITESPACE_CHARACTER_TOKEN';
+Tokenizer.START_TAG_TOKEN = 'START_TAG_TOKEN';
+Tokenizer.END_TAG_TOKEN = 'END_TAG_TOKEN';
+Tokenizer.COMMENT_TOKEN = 'COMMENT_TOKEN';
+Tokenizer.DOCTYPE_TOKEN = 'DOCTYPE_TOKEN';
+Tokenizer.EOF_TOKEN = 'EOF_TOKEN';
+Tokenizer.HIBERNATION_TOKEN = 'HIBERNATION_TOKEN';
 
-    else
-        this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE);
+//Tokenizer initial states for different modes
+Tokenizer.MODE = {
+    DATA: DATA_STATE,
+    RCDATA: RCDATA_STATE,
+    RAWTEXT: RAWTEXT_STATE,
+    SCRIPT_DATA: SCRIPT_DATA_STATE,
+    PLAINTEXT: PLAINTEXT_STATE
 };
 
-
-//12.2.4.34 Before attribute name state
-//------------------------------------------------------------------
-_[BEFORE_ATTRIBUTE_NAME_STATE] = function beforeAttributeNameState(cp) {
-    if (isWhitespace(cp))
-        return;
-
-    if (cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN || cp === $.EOF)
-        this._reconsumeInState(AFTER_ATTRIBUTE_NAME_STATE);
-
-    else if (cp === $.EQUALS_SIGN) {
-        this._createAttr('=');
-        this.state = ATTRIBUTE_NAME_STATE;
+//Static
+Tokenizer.getTokenAttr = function(token, attrName) {
+    for (let i = token.attrs.length - 1; i >= 0; i--) {
+        if (token.attrs[i].name === attrName) {
+            return token.attrs[i].value;
+        }
     }
 
-    else {
-        this._createAttr('');
-        this._reconsumeInState(ATTRIBUTE_NAME_STATE);
-    }
+    return null;
 };
 
-
-//12.2.4.35 Attribute name state
-//------------------------------------------------------------------
-_[ATTRIBUTE_NAME_STATE] = function attributeNameState(cp) {
-    if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN || cp === $.EOF) {
-        this._leaveAttrName(AFTER_ATTRIBUTE_NAME_STATE);
-        this._unconsume();
-    }
-
-    else if (cp === $.EQUALS_SIGN)
-        this._leaveAttrName(BEFORE_ATTRIBUTE_VALUE_STATE);
-
-    else if (isAsciiUpper(cp))
-        this.currentAttr.name += toAsciiLowerChar(cp);
-
-    else if (cp === $.QUOTATION_MARK || cp === $.APOSTROPHE || cp === $.LESS_THAN_SIGN)
-        this.currentAttr.name += toChar(cp);
-
-    else if (cp === $.NULL)
-        this.currentAttr.name += UNICODE.REPLACEMENT_CHARACTER;
-
-    else
-        this.currentAttr.name += toChar(cp);
-};
-
-
-//12.2.4.36 After attribute name state
-//------------------------------------------------------------------
-_[AFTER_ATTRIBUTE_NAME_STATE] = function afterAttributeNameState(cp) {
-    if (isWhitespace(cp))
-        return;
-
-    if (cp === $.SOLIDUS)
-        this.state = SELF_CLOSING_START_TAG_STATE;
-
-    else if (cp === $.EQUALS_SIGN)
-        this.state = BEFORE_ATTRIBUTE_VALUE_STATE;
-
-    else if (cp === $.GREATER_THAN_SIGN) {
-        this.state = DATA_STATE;
-        this._emitCurrentToken();
-    }
-
-    else if (cp === $.EOF)
-        this._reconsumeInState(DATA_STATE);
-
-    else {
-        this._createAttr('');
-        this._reconsumeInState(ATTRIBUTE_NAME_STATE);
-    }
-};
-
-
-//12.2.4.37 Before attribute value state
-//------------------------------------------------------------------
-_[BEFORE_ATTRIBUTE_VALUE_STATE] = function beforeAttributeValueState(cp) {
-    if (isWhitespace(cp))
-        return;
-
-    if (cp === $.QUOTATION_MARK)
-        this.state = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
-
-    else if (cp === $.APOSTROPHE)
-        this.state = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
-
-    else
-        this._reconsumeInState(ATTRIBUTE_VALUE_UNQUOTED_STATE);
-};
-
-
-//12.2.4.38 Attribute value (double-quoted) state
-//------------------------------------------------------------------
-_[ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE] = function attributeValueDoubleQuotedState(cp) {
-    if (cp === $.QUOTATION_MARK)
-        this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
-
-    else if (cp === $.AMPERSAND) {
-        this.additionalAllowedCp = $.QUOTATION_MARK;
-        this.returnState = this.state;
-        this.state = CHARACTER_REFERENCE_IN_ATTRIBUTE_VALUE_STATE;
-    }
-
-    else if (cp === $.NULL)
-        this.currentAttr.value += UNICODE.REPLACEMENT_CHARACTER;
-
-    else if (cp === $.EOF)
-        this._reconsumeInState(DATA_STATE);
-
-    else
-        this.currentAttr.value += toChar(cp);
-};
-
-
-//12.2.4.39 Attribute value (single-quoted) state
-//------------------------------------------------------------------
-_[ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE] = function attributeValueSingleQuotedState(cp) {
-    if (cp === $.APOSTROPHE)
-        this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
-
-    else if (cp === $.AMPERSAND) {
-        this.additionalAllowedCp = $.APOSTROPHE;
-        this.returnState = this.state;
-        this.state = CHARACTER_REFERENCE_IN_ATTRIBUTE_VALUE_STATE;
-    }
-
-    else if (cp === $.NULL)
-        this.currentAttr.value += UNICODE.REPLACEMENT_CHARACTER;
-
-    else if (cp === $.EOF)
-        this._reconsumeInState(DATA_STATE);
-
-    else
-        this.currentAttr.value += toChar(cp);
-};
-
-
-//12.2.4.40 Attribute value (unquoted) state
-//------------------------------------------------------------------
-_[ATTRIBUTE_VALUE_UNQUOTED_STATE] = function attributeValueUnquotedState(cp) {
-    if (isWhitespace(cp))
-        this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE);
-
-    else if (cp === $.AMPERSAND) {
-        this.additionalAllowedCp = $.GREATER_THAN_SIGN;
-        this.returnState = this.state;
-        this.state = CHARACTER_REFERENCE_IN_ATTRIBUTE_VALUE_STATE;
-    }
-
-    else if (cp === $.GREATER_THAN_SIGN) {
-        this._leaveAttrValue(DATA_STATE);
-        this._emitCurrentToken();
-    }
-
-    else if (cp === $.NULL)
-        this.currentAttr.value += UNICODE.REPLACEMENT_CHARACTER;
-
-    else if (cp === $.QUOTATION_MARK || cp === $.APOSTROPHE || cp === $.LESS_THAN_SIGN ||
-             cp === $.EQUALS_SIGN || cp === $.GRAVE_ACCENT)
-        this.currentAttr.value += toChar(cp);
-
-    else if (cp === $.EOF)
-        this._reconsumeInState(DATA_STATE);
-
-    else
-        this.currentAttr.value += toChar(cp);
-};
-
-
-//12.2.4.41 Character reference in attribute value state
-//------------------------------------------------------------------
-_[CHARACTER_REFERENCE_IN_ATTRIBUTE_VALUE_STATE] = function characterReferenceInAttributeValueState(cp) {
-    var referencedCodePoints = this._consumeCharacterReference(cp, true);
-
-    if (!this._ensureHibernation()) {
-        if (referencedCodePoints) {
-            for (var i = 0; i < referencedCodePoints.length; i++)
-                this.currentAttr.value += toChar(referencedCodePoints[i]);
-        }
-        else
-            this.currentAttr.value += '&';
-
-        this.state = this.returnState;
-    }
-};
-
-
-//12.2.4.42 After attribute value (quoted) state
-//------------------------------------------------------------------
-_[AFTER_ATTRIBUTE_VALUE_QUOTED_STATE] = function afterAttributeValueQuotedState(cp) {
-    if (isWhitespace(cp))
-        this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE);
-
-    else if (cp === $.SOLIDUS)
-        this._leaveAttrValue(SELF_CLOSING_START_TAG_STATE);
-
-    else if (cp === $.GREATER_THAN_SIGN) {
-        this._leaveAttrValue(DATA_STATE);
-        this._emitCurrentToken();
-    }
-
-    else if (cp === $.EOF)
-        this._reconsumeInState(DATA_STATE);
-
-    else
-        this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE);
-};
-
-
-//12.2.4.43 Self-closing start tag state
-//------------------------------------------------------------------
-_[SELF_CLOSING_START_TAG_STATE] = function selfClosingStartTagState(cp) {
-    if (cp === $.GREATER_THAN_SIGN) {
-        this.currentToken.selfClosing = true;
-        this.state = DATA_STATE;
-        this._emitCurrentToken();
-    }
-
-    else if (cp === $.EOF)
-        this._reconsumeInState(DATA_STATE);
-
-    else
-        this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE);
-};
-
-
-//12.2.4.44 Bogus comment state
-//------------------------------------------------------------------
-_[BOGUS_COMMENT_STATE] = function bogusCommentState() {
-    this._createCommentToken();
-    this._reconsumeInState(BOGUS_COMMENT_STATE_CONTINUATION);
-};
-
-//HACK: to support streaming and make BOGUS_COMMENT_STATE reentrant we've
-//introduced BOGUS_COMMENT_STATE_CONTINUATION state which will not produce
-//comment token on each call.
-_[BOGUS_COMMENT_STATE_CONTINUATION] = function bogusCommentStateContinuation(cp) {
-    while (true) {
-        if (cp === $.GREATER_THAN_SIGN) {
-            this.state = DATA_STATE;
-            break;
-        }
-
-        else if (cp === $.EOF) {
-            this._reconsumeInState(DATA_STATE);
-            break;
-        }
-
-        else {
-            this.currentToken.data += cp === $.NULL ? UNICODE.REPLACEMENT_CHARACTER : toChar(cp);
-
-            this._hibernationSnapshot();
-            cp = this._consume();
-
-            if (this._ensureHibernation())
-                return;
-        }
-    }
-
-    this._emitCurrentToken();
-};
-
-//12.2.4.45 Markup declaration open state
-//------------------------------------------------------------------
-_[MARKUP_DECLARATION_OPEN_STATE] = function markupDeclarationOpenState(cp) {
-    var dashDashMatch = this._consumeSubsequentIfMatch($$.DASH_DASH_STRING, cp, true),
-        doctypeMatch = !dashDashMatch && this._consumeSubsequentIfMatch($$.DOCTYPE_STRING, cp, false),
-        cdataMatch = !dashDashMatch && !doctypeMatch &&
-                     this.allowCDATA &&
-                     this._consumeSubsequentIfMatch($$.CDATA_START_STRING, cp, true);
-
-    if (!this._ensureHibernation()) {
-        if (dashDashMatch) {
-            this._createCommentToken();
-            this.state = COMMENT_START_STATE;
-        }
-
-        else if (doctypeMatch)
-            this.state = DOCTYPE_STATE;
-
-        else if (cdataMatch)
-            this.state = CDATA_SECTION_STATE;
-
-        else
-            this._reconsumeInState(BOGUS_COMMENT_STATE);
-    }
-};
-
-
-//12.2.4.46 Comment start state
-//------------------------------------------------------------------
-_[COMMENT_START_STATE] = function commentStartState(cp) {
-    if (cp === $.HYPHEN_MINUS)
-        this.state = COMMENT_START_DASH_STATE;
-
-    else if (cp === $.NULL) {
-        this.currentToken.data += UNICODE.REPLACEMENT_CHARACTER;
-        this.state = COMMENT_STATE;
-    }
-
-    else if (cp === $.GREATER_THAN_SIGN) {
-        this.state = DATA_STATE;
-        this._emitCurrentToken();
-    }
-
-    else if (cp === $.EOF) {
-        this._emitCurrentToken();
-        this._reconsumeInState(DATA_STATE);
-    }
-
-    else {
-        this.currentToken.data += toChar(cp);
-        this.state = COMMENT_STATE;
-    }
-};
-
-
-//12.2.4.47 Comment start dash state
-//------------------------------------------------------------------
-_[COMMENT_START_DASH_STATE] = function commentStartDashState(cp) {
-    if (cp === $.HYPHEN_MINUS)
-        this.state = COMMENT_END_STATE;
-
-    else if (cp === $.NULL) {
-        this.currentToken.data += '-';
-        this.currentToken.data += UNICODE.REPLACEMENT_CHARACTER;
-        this.state = COMMENT_STATE;
-    }
-
-    else if (cp === $.GREATER_THAN_SIGN) {
-        this.state = DATA_STATE;
-        this._emitCurrentToken();
-    }
-
-    else if (cp === $.EOF) {
-        this._emitCurrentToken();
-        this._reconsumeInState(DATA_STATE);
-    }
-
-    else {
-        this.currentToken.data += '-';
-        this.currentToken.data += toChar(cp);
-        this.state = COMMENT_STATE;
-    }
-};
-
-
-//12.2.4.48 Comment state
-//------------------------------------------------------------------
-_[COMMENT_STATE] = function commentState(cp) {
-    if (cp === $.HYPHEN_MINUS)
-        this.state = COMMENT_END_DASH_STATE;
-
-    else if (cp === $.NULL)
-        this.currentToken.data += UNICODE.REPLACEMENT_CHARACTER;
-
-    else if (cp === $.EOF) {
-        this._emitCurrentToken();
-        this._reconsumeInState(DATA_STATE);
-    }
-
-    else
-        this.currentToken.data += toChar(cp);
-};
-
-
-//12.2.4.49 Comment end dash state
-//------------------------------------------------------------------
-_[COMMENT_END_DASH_STATE] = function commentEndDashState(cp) {
-    if (cp === $.HYPHEN_MINUS)
-        this.state = COMMENT_END_STATE;
-
-    else if (cp === $.NULL) {
-        this.currentToken.data += '-';
-        this.currentToken.data += UNICODE.REPLACEMENT_CHARACTER;
-        this.state = COMMENT_STATE;
-    }
-
-    else if (cp === $.EOF) {
-        this._emitCurrentToken();
-        this._reconsumeInState(DATA_STATE);
-    }
-
-    else {
-        this.currentToken.data += '-';
-        this.currentToken.data += toChar(cp);
-        this.state = COMMENT_STATE;
-    }
-};
-
-
-//12.2.4.50 Comment end state
-//------------------------------------------------------------------
-_[COMMENT_END_STATE] = function commentEndState(cp) {
-    if (cp === $.GREATER_THAN_SIGN) {
-        this.state = DATA_STATE;
-        this._emitCurrentToken();
-    }
-
-    else if (cp === $.EXCLAMATION_MARK)
-        this.state = COMMENT_END_BANG_STATE;
-
-    else if (cp === $.HYPHEN_MINUS)
-        this.currentToken.data += '-';
-
-    else if (cp === $.NULL) {
-        this.currentToken.data += '--';
-        this.currentToken.data += UNICODE.REPLACEMENT_CHARACTER;
-        this.state = COMMENT_STATE;
-    }
-
-    else if (cp === $.EOF) {
-        this._reconsumeInState(DATA_STATE);
-        this._emitCurrentToken();
-    }
-
-    else {
-        this.currentToken.data += '--';
-        this.currentToken.data += toChar(cp);
-        this.state = COMMENT_STATE;
-    }
-};
-
-
-//12.2.4.51 Comment end bang state
-//------------------------------------------------------------------
-_[COMMENT_END_BANG_STATE] = function commentEndBangState(cp) {
-    if (cp === $.HYPHEN_MINUS) {
-        this.currentToken.data += '--!';
-        this.state = COMMENT_END_DASH_STATE;
-    }
-
-    else if (cp === $.GREATER_THAN_SIGN) {
-        this.state = DATA_STATE;
-        this._emitCurrentToken();
-    }
-
-    else if (cp === $.NULL) {
-        this.currentToken.data += '--!';
-        this.currentToken.data += UNICODE.REPLACEMENT_CHARACTER;
-        this.state = COMMENT_STATE;
-    }
-
-    else if (cp === $.EOF) {
-        this._emitCurrentToken();
-        this._reconsumeInState(DATA_STATE);
-    }
-
-    else {
-        this.currentToken.data += '--!';
-        this.currentToken.data += toChar(cp);
-        this.state = COMMENT_STATE;
-    }
-};
-
-
-//12.2.4.52 DOCTYPE state
-//------------------------------------------------------------------
-_[DOCTYPE_STATE] = function doctypeState(cp) {
-    if (isWhitespace(cp))
-        return;
-
-    else if (cp === $.GREATER_THAN_SIGN) {
-        this._createDoctypeToken(null);
-        this.currentToken.forceQuirks = true;
-        this._emitCurrentToken();
-        this.state = DATA_STATE;
-    }
-
-    else if (cp === $.EOF) {
-        this._createDoctypeToken(null);
-        this.currentToken.forceQuirks = true;
-        this._emitCurrentToken();
-        this._reconsumeInState(DATA_STATE);
-    }
-    else {
-        this._createDoctypeToken('');
-        this._reconsumeInState(DOCTYPE_NAME_STATE);
-    }
-};
-
-
-//12.2.4.54 DOCTYPE name state
-//------------------------------------------------------------------
-_[DOCTYPE_NAME_STATE] = function doctypeNameState(cp) {
-    if (isWhitespace(cp) || cp === $.GREATER_THAN_SIGN || cp === $.EOF)
-        this._reconsumeInState(AFTER_DOCTYPE_NAME_STATE);
-
-    else if (isAsciiUpper(cp))
-        this.currentToken.name += toAsciiLowerChar(cp);
-
-    else if (cp === $.NULL)
-        this.currentToken.name += UNICODE.REPLACEMENT_CHARACTER;
-
-    else
-        this.currentToken.name += toChar(cp);
-};
-
-
-//12.2.4.55 After DOCTYPE name state
-//------------------------------------------------------------------
-_[AFTER_DOCTYPE_NAME_STATE] = function afterDoctypeNameState(cp) {
-    if (isWhitespace(cp))
-        return;
-
-    if (cp === $.GREATER_THAN_SIGN) {
-        this.state = DATA_STATE;
-        this._emitCurrentToken();
-    }
-
-    else {
-        var publicMatch = this._consumeSubsequentIfMatch($$.PUBLIC_STRING, cp, false),
-            systemMatch = !publicMatch && this._consumeSubsequentIfMatch($$.SYSTEM_STRING, cp, false);
-
-        if (!this._ensureHibernation()) {
-            if (publicMatch)
-                this.state = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
-
-            else if (systemMatch)
-                this.state = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
-
-            else {
-                this.currentToken.forceQuirks = true;
-                this.state = BOGUS_DOCTYPE_STATE;
-            }
-        }
-    }
-};
-
-
-//12.2.4.57 Before DOCTYPE public identifier state
-//------------------------------------------------------------------
-_[BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE] = function beforeDoctypePublicIdentifierState(cp) {
-    if (isWhitespace(cp))
-        return;
-
-    if (cp === $.QUOTATION_MARK) {
-        this.currentToken.publicId = '';
-        this.state = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE;
-    }
-
-    else if (cp === $.APOSTROPHE) {
-        this.currentToken.publicId = '';
-        this.state = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE;
-    }
-
-    else {
-        this.currentToken.forceQuirks = true;
-        this._reconsumeInState(BOGUS_DOCTYPE_STATE);
-    }
-};
-
-
-//12.2.4.58 DOCTYPE public identifier (double-quoted) state
-//------------------------------------------------------------------
-_[DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE] = function doctypePublicIdentifierDoubleQuotedState(cp) {
-    if (cp === $.QUOTATION_MARK)
-        this.state = BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE;
-
-    else if (cp === $.NULL)
-        this.currentToken.publicId += UNICODE.REPLACEMENT_CHARACTER;
-
-    else if (cp === $.GREATER_THAN_SIGN) {
-        this.currentToken.forceQuirks = true;
-        this._emitCurrentToken();
-        this.state = DATA_STATE;
-    }
-
-    else if (cp === $.EOF) {
-        this.currentToken.forceQuirks = true;
-        this._emitCurrentToken();
-        this._reconsumeInState(DATA_STATE);
-    }
-
-    else
-        this.currentToken.publicId += toChar(cp);
-};
-
-
-//12.2.4.59 DOCTYPE public identifier (single-quoted) state
-//------------------------------------------------------------------
-_[DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE] = function doctypePublicIdentifierSingleQuotedState(cp) {
-    if (cp === $.APOSTROPHE)
-        this.state = BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE;
-
-    else if (cp === $.NULL)
-        this.currentToken.publicId += UNICODE.REPLACEMENT_CHARACTER;
-
-    else if (cp === $.GREATER_THAN_SIGN) {
-        this.currentToken.forceQuirks = true;
-        this._emitCurrentToken();
-        this.state = DATA_STATE;
-    }
-
-    else if (cp === $.EOF) {
-        this.currentToken.forceQuirks = true;
-        this._emitCurrentToken();
-        this._reconsumeInState(DATA_STATE);
-    }
-
-    else
-        this.currentToken.publicId += toChar(cp);
-};
-
-
-//12.2.4.61 Between DOCTYPE public and system identifiers state
-//------------------------------------------------------------------
-_[BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE] = function betweenDoctypePublicAndSystemIdentifiersState(cp) {
-    if (isWhitespace(cp))
-        return;
-
-    if (cp === $.GREATER_THAN_SIGN) {
-        this._emitCurrentToken();
-        this.state = DATA_STATE;
-    }
-
-    else if (cp === $.QUOTATION_MARK) {
-        this.currentToken.systemId = '';
-        this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
-    }
-
-
-    else if (cp === $.APOSTROPHE) {
-        this.currentToken.systemId = '';
-        this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
-    }
-
-    else {
-        this.currentToken.forceQuirks = true;
-        this._reconsumeInState(BOGUS_DOCTYPE_STATE);
-    }
-};
-
-
-//12.2.4.63 Before DOCTYPE system identifier state
-//------------------------------------------------------------------
-_[BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE] = function beforeDoctypeSystemIdentifierState(cp) {
-    if (isWhitespace(cp))
-        return;
-
-    if (cp === $.QUOTATION_MARK) {
-        this.currentToken.systemId = '';
-        this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
-    }
-
-    else if (cp === $.APOSTROPHE) {
-        this.currentToken.systemId = '';
-        this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
-    }
-
-    else {
-        this.currentToken.forceQuirks = true;
-        this._reconsumeInState(BOGUS_DOCTYPE_STATE);
-    }
-};
-
-
-//12.2.4.64 DOCTYPE system identifier (double-quoted) state
-//------------------------------------------------------------------
-_[DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE] = function doctypeSystemIdentifierDoubleQuotedState(cp) {
-    if (cp === $.QUOTATION_MARK)
-        this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
-
-    else if (cp === $.GREATER_THAN_SIGN) {
-        this.currentToken.forceQuirks = true;
-        this._emitCurrentToken();
-        this.state = DATA_STATE;
-    }
-
-    else if (cp === $.NULL)
-        this.currentToken.systemId += UNICODE.REPLACEMENT_CHARACTER;
-
-    else if (cp === $.EOF) {
-        this.currentToken.forceQuirks = true;
-        this._emitCurrentToken();
-        this._reconsumeInState(DATA_STATE);
-    }
-
-    else
-        this.currentToken.systemId += toChar(cp);
-};
-
-
-//12.2.4.65 DOCTYPE system identifier (single-quoted) state
-//------------------------------------------------------------------
-_[DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE] = function doctypeSystemIdentifierSingleQuotedState(cp) {
-    if (cp === $.APOSTROPHE)
-        this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
-
-    else if (cp === $.GREATER_THAN_SIGN) {
-        this.currentToken.forceQuirks = true;
-        this._emitCurrentToken();
-        this.state = DATA_STATE;
-    }
-
-    else if (cp === $.NULL)
-        this.currentToken.systemId += UNICODE.REPLACEMENT_CHARACTER;
-
-    else if (cp === $.EOF) {
-        this.currentToken.forceQuirks = true;
-        this._emitCurrentToken();
-        this._reconsumeInState(DATA_STATE);
-    }
-
-    else
-        this.currentToken.systemId += toChar(cp);
-};
-
-
-//12.2.4.66 After DOCTYPE system identifier state
-//------------------------------------------------------------------
-_[AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE] = function afterDoctypeSystemIdentifierState(cp) {
-    if (isWhitespace(cp))
-        return;
-
-    if (cp === $.GREATER_THAN_SIGN) {
-        this._emitCurrentToken();
-        this.state = DATA_STATE;
-    }
-
-    else if (cp === $.EOF) {
-        this.currentToken.forceQuirks = true;
-        this._emitCurrentToken();
-        this._reconsumeInState(DATA_STATE);
-    }
-
-    else
-        this.state = BOGUS_DOCTYPE_STATE;
-};
-
-
-//12.2.4.67 Bogus DOCTYPE state
-//------------------------------------------------------------------
-_[BOGUS_DOCTYPE_STATE] = function bogusDoctypeState(cp) {
-    if (cp === $.GREATER_THAN_SIGN) {
-        this._emitCurrentToken();
-        this.state = DATA_STATE;
-    }
-
-    else if (cp === $.EOF) {
-        this._emitCurrentToken();
-        this._reconsumeInState(DATA_STATE);
-    }
-};
-
-
-//12.2.4.68 CDATA section state
-//------------------------------------------------------------------
-_[CDATA_SECTION_STATE] = function cdataSectionState(cp) {
-    while (true) {
-        if (cp === $.EOF) {
-            this._reconsumeInState(DATA_STATE);
-            break;
-        }
-
-        else {
-            var cdataEndMatch = this._consumeSubsequentIfMatch($$.CDATA_END_STRING, cp, true);
-
-            if (this._ensureHibernation())
-                break;
-
-            if (cdataEndMatch) {
-                this.state = DATA_STATE;
-                break;
-            }
-
-            this._emitCodePoint(cp);
-
-            this._hibernationSnapshot();
-            cp = this._consume();
-
-            if (this._ensureHibernation())
-                break;
-        }
-    }
-};
+module.exports = Tokenizer;