text: 'use strict';
  
  const Preprocessor = require('./preprocessor');
  const unicode = require('../common/unicode');
  const neTree = require('./named-entity-data');
  const ERR = require('../common/error-codes');
  
  //Aliases
  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
  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
  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
  
  //OPTIMIZATION: these utility functions should not be moved out of this module. V8 Crankshaft will not inline
  //this functions if they will be situated in another module due to context switch.
  //Always perform inlining check before modifying this functions ('node --trace-inlining').
  function isWhitespace(cp) {
      return cp === $.SPACE || cp === $.LINE_FEED || cp === $.TABULATION || cp === $.FORM_FEED;
  }
  
  function isAsciiDigit(cp) {
      return cp >= $.DIGIT_0 && cp <= $.DIGIT_9;
  }
  
  function isAsciiUpper(cp) {
      return cp >= $.LATIN_CAPITAL_A && cp <= $.LATIN_CAPITAL_Z;
  }
  
  function isAsciiLower(cp) {
      return cp >= $.LATIN_SMALL_A && cp <= $.LATIN_SMALL_Z;
  }
  
  function isAsciiLetter(cp) {
      return isAsciiLower(cp) || isAsciiUpper(cp);
  }
  
  function isAsciiAlphaNumeric(cp) {
      return isAsciiLetter(cp) || isAsciiDigit(cp);
  }
  
  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 isAsciiHexDigit(cp) {
      return isAsciiDigit(cp) || isAsciiUpperHexDigit(cp) || isAsciiLowerHexDigit(cp);
  }
  
  function toAsciiLowerCodePoint(cp) {
      return cp + 0x0020;
  }
  
  //NOTE: String.fromCharCode() function can handle only characters from BMP subset.
  //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) {
          return String.fromCharCode(cp);
      }
  
      cp -= 0x10000;
      return String.fromCharCode(((cp >>> 10) & 0x3ff) | 0xd800) + String.fromCharCode(0xdc00 | (cp & 0x3ff));
  }
  
  function toAsciiLowerChar(cp) {
      return String.fromCharCode(toAsciiLowerCodePoint(cp));
  }
  
  function findNamedEntityTreeBranch(nodeIx, cp) {
      const branchCount = neTree[++nodeIx];
      let lo = ++nodeIx;
      let hi = lo + branchCount - 1;
  
      while (lo <= hi) {
          const mid = (lo + hi) >>> 1;
          const midCp = neTree[mid];
  
          if (midCp < cp) {
              lo = mid + 1;
          } else if (midCp > cp) {
              hi = mid - 1;
          } else {
              return neTree[mid + branchCount];
          }
      }
  
      return -1;
  }
  
  //Tokenizer
  class Tokenizer {
      constructor() {
          this.preprocessor = new Preprocessor();
  
          this.tokenQueue = [];
  
          this.allowCDATA = false;
  
          this.state = DATA_STATE;
          this.returnState = '';
  
          this.charRefCode = -1;
          this.tempBuff = [];
          this.lastStartTagName = '';
  
          this.consumedAfterSnapshot = -1;
          this.active = false;
  
          this.currentCharacterToken = null;
          this.currentToken = null;
          this.currentAttr = null;
      }
  
      //Errors
      _err() {
          // NOTE: err reporting is noop by default. Enabled by mixin.
      }
  
      _errOnNextCodePoint(err) {
          this._consume();
          this._err(err);
          this._unconsume();
      }
  
      //API
      getNextToken() {
          while (!this.tokenQueue.length && this.active) {
              this.consumedAfterSnapshot = 0;
  
              const cp = this._consume();
  
              if (!this._ensureHibernation()) {
                  this[this.state](cp);
              }
          }
  
          return this.tokenQueue.shift();
      }
  
      write(chunk, isLastChunk) {
          this.active = true;
          this.preprocessor.write(chunk, isLastChunk);
      }
  
      insertHtmlAtCurrentPos(chunk) {
          this.active = true;
          this.preprocessor.insertHtmlAtCurrentPos(chunk);
      }
  
      //Hibernation
      _ensureHibernation() {
          if (this.preprocessor.endOfChunkHit) {
              for (; this.consumedAfterSnapshot > 0; this.consumedAfterSnapshot--) {
                  this.preprocessor.retreat();
              }
  
              this.active = false;
              this.tokenQueue.push({ type: Tokenizer.HIBERNATION_TOKEN });
  
              return true;
          }
  
          return false;
      }
  
      //Consumption
      _consume() {
          this.consumedAfterSnapshot++;
          return this.preprocessor.advance();
      }
  
      _unconsume() {
          this.consumedAfterSnapshot--;
          this.preprocessor.retreat();
      }
  
      _reconsumeInState(state) {
          this.state = state;
          this._unconsume();
      }
  
      _consumeSequenceIfMatch(pattern, startCp, caseSensitive) {
          let consumedCount = 0;
          let isMatch = true;
          const patternLength = pattern.length;
          let patternPos = 0;
          let cp = startCp;
          let patternCp = void 0;
  
          for (; patternPos < patternLength; patternPos++) {
              if (patternPos > 0) {
                  cp = this._consume();
                  consumedCount++;
              }
  
              if (cp === $.EOF) {
                  isMatch = false;
                  break;
              }
  
              patternCp = pattern[patternPos];
  
              if (cp !== patternCp && (caseSensitive || cp !== toAsciiLowerCodePoint(patternCp))) {
                  isMatch = false;
                  break;
              }
          }
  
          if (!isMatch) {
              while (consumedCount--) {
                  this._unconsume();
              }
          }
  
          return isMatch;
      }
  
      //Temp buffer
      _isTempBufferEqualToScriptString() {
          if (this.tempBuff.length !== $$.SCRIPT_STRING.length) {
              return false;
          }
  
          for (let i = 0; i < this.tempBuff.length; i++) {
              if (this.tempBuff[i] !== $$.SCRIPT_STRING[i]) {
                  return false;
              }
          }
  
          return true;
      }
  
      //Token creation
      _createStartTagToken() {
          this.currentToken = {
              type: Tokenizer.START_TAG_TOKEN,
              tagName: '',
              selfClosing: false,
              ackSelfClosing: false,
              attrs: []
          };
      }
  
      _createEndTagToken() {
          this.currentToken = {
              type: Tokenizer.END_TAG_TOKEN,
              tagName: '',
              selfClosing: false,
              attrs: []
          };
      }
  
      _createCommentToken() {
          this.currentToken = {
              type: Tokenizer.COMMENT_TOKEN,
              data: ''
          };
      }
  
      _createDoctypeToken(initialName) {
          this.currentToken = {
              type: Tokenizer.DOCTYPE_TOKEN,
              name: initialName,
              forceQuirks: false,
              publicId: null,
              systemId: null
          };
      }
  
      _createCharacterToken(type, ch) {
          this.currentCharacterToken = {
              type: type,
              chars: ch
          };
      }
  
      _createEOFToken() {
          this.currentToken = { type: Tokenizer.EOF_TOKEN };
      }
  
      //Tag attributes
      _createAttr(attrNameFirstCh) {
          this.currentAttr = {
              name: attrNameFirstCh,
              value: ''
          };
      }
  
      _leaveAttrName(toState) {
          if (Tokenizer.getTokenAttr(this.currentToken, this.currentAttr.name) === null) {
              this.currentToken.attrs.push(this.currentAttr);
          } else {
              this._err(ERR.duplicateAttribute);
          }
  
          this.state = toState;
      }
  
      _leaveAttrValue(toState) {
          this.state = toState;
      }
  
      //Token emission
      _emitCurrentToken() {
          this._emitCurrentCharacterToken();
  
          const ct = this.currentToken;
  
          this.currentToken = null;
  
          //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 (ct.selfClosing) {
                  this._err(ERR.endTagWithTrailingSolidus);
              }
          }
  
          this.tokenQueue.push(ct);
      }
  
      _emitCurrentCharacterToken() {
          if (this.currentCharacterToken) {
              this.tokenQueue.push(this.currentCharacterToken);
              this.currentCharacterToken = null;
          }
      }
  
      _emitEOFToken() {
          this._createEOFToken();
          this._emitCurrentToken();
      }
  
      //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@@#$%^')
      _appendCharToCurrentCharacterToken(type, ch) {
          if (this.currentCharacterToken && this.currentCharacterToken.type !== type) {
              this._emitCurrentCharacterToken();
          }
  
          if (this.currentCharacterToken) {
              this.currentCharacterToken.chars += ch;
          } else {
              this._createCharacterToken(type, ch);
          }
      }
  
      _emitCodePoint(cp) {
          let type = Tokenizer.CHARACTER_TOKEN;
  
          if (isWhitespace(cp)) {
              type = Tokenizer.WHITESPACE_CHARACTER_TOKEN;
          } else if (cp === $.NULL) {
              type = Tokenizer.NULL_CHARACTER_TOKEN;
          }
  
          this._appendCharToCurrentCharacterToken(type, toChar(cp));
      }
  
      _emitSeveralCodePoints(codePoints) {
          for (let i = 0; i < codePoints.length; i++) {
              this._emitCodePoint(codePoints[i]);
          }
      }
  
      //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);
      }
  
      // Character reference helpers
      _matchNamedCharacterReference(startCp) {
          let result = null;
          let excess = 1;
          let i = findNamedEntityTreeBranch(0, startCp);
  
          this.tempBuff.push(startCp);
  
          while (i > -1) {
              const current = neTree[i];
              const inNode = current < MAX_BRANCH_MARKER_VALUE;
              const nodeWithData = inNode && current & HAS_DATA_FLAG;
  
              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;
              }
  
              const cp = this._consume();
  
              this.tempBuff.push(cp);
              excess++;
  
              if (cp === $.EOF) {
                  break;
              }
  
              if (inNode) {
                  i = current & HAS_BRANCHES_FLAG ? findNamedEntityTreeBranch(i, cp) : -1;
              } else {
                  i = cp === current ? ++i : -1;
              }
          }
  
          while (excess--) {
              this.tempBuff.pop();
              this._unconsume();
          }
  
          return result;
      }
  
      _isCharacterReferenceInAttribute() {
          return (
              this.returnState === ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE ||
              this.returnState === ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE ||
              this.returnState === ATTRIBUTE_VALUE_UNQUOTED_STATE
          );
      }
  
      _isCharacterReferenceAttributeQuirk(withSemicolon) {
          if (!withSemicolon && this._isCharacterReferenceInAttribute()) {
              const nextCp = this._consume();
  
              this._unconsume();
  
              return nextCp === $.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp);
          }
  
          return false;
      }
  
      _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);
          }
  
          this.tempBuff = [];
      }
  
      // State machine
  
      // Data state
      //------------------------------------------------------------------
      [DATA_STATE](cp) {
          this.preprocessor.dropParsedChunk();
  
          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);
          }
      }
  
      // RAWTEXT state
      //------------------------------------------------------------------
      [RAWTEXT_STATE](cp) {
          this.preprocessor.dropParsedChunk();
  
          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);
          }
      }
  
      // Script data state
      //------------------------------------------------------------------
      [SCRIPT_DATA_STATE](cp) {
          this.preprocessor.dropParsedChunk();
  
          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);
          }
      }
  
      // PLAINTEXT state
      //------------------------------------------------------------------
      [PLAINTEXT_STATE](cp) {
          this.preprocessor.dropParsedChunk();
  
          if (cp === $.NULL) {
              this._err(ERR.unexpectedNullCharacter);
              this._emitChars(unicode.REPLACEMENT_CHARACTER);
          } else if (cp === $.EOF) {
              this._emitEOFToken();
          } else {
              this._emitCodePoint(cp);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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 === $.SOLIDUS) {
                      this.state = SELF_CLOSING_START_TAG_STATE;
                      return;
                  }
  
                  if (cp === $.GREATER_THAN_SIGN) {
                      this.state = DATA_STATE;
                      this._emitCurrentToken();
                      return;
                  }
              }
  
              this._emitChars('</');
              this._emitSeveralCodePoints(this.tempBuff);
              this._reconsumeInState(RCDATA_STATE);
          }
      }
  
      // 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);
          }
      }
  
      // 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;
                  }
  
                  if (cp === $.SOLIDUS) {
                      this.state = SELF_CLOSING_START_TAG_STATE;
                      return;
                  }
  
                  if (cp === $.GREATER_THAN_SIGN) {
                      this._emitCurrentToken();
                      this.state = DATA_STATE;
                      return;
                  }
              }
  
              this._emitChars('</');
              this._emitSeveralCodePoints(this.tempBuff);
              this._reconsumeInState(RAWTEXT_STATE);
          }
      }
  
      // 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);
          }
      }
  
      // 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;
                  }
              }
  
              this._emitChars('</');
              this._emitSeveralCodePoints(this.tempBuff);
              this._reconsumeInState(SCRIPT_DATA_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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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 (cp === $.SOLIDUS) {
                      this.state = SELF_CLOSING_START_TAG_STATE;
                      return;
                  }
  
                  if (cp === $.GREATER_THAN_SIGN) {
                      this._emitCurrentToken();
                      this.state = DATA_STATE;
                      return;
                  }
              }
  
              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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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;
  
              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);
          }
      }
  
      // Before attribute name state
      //------------------------------------------------------------------
      [BEFORE_ATTRIBUTE_NAME_STATE](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._err(ERR.unexpectedEqualsSignBeforeAttributeName);
              this._createAttr('=');
              this.state = ATTRIBUTE_NAME_STATE;
          } else {
              this._createAttr('');
              this._reconsumeInState(ATTRIBUTE_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);
          }
      }
  
      // After attribute name state
      //------------------------------------------------------------------
      [AFTER_ATTRIBUTE_NAME_STATE](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._err(ERR.eofInTag);
              this._emitEOFToken();
          } else {
              this._createAttr('');
              this._reconsumeInState(ATTRIBUTE_NAME_STATE);
          }
      }
  
      // Before attribute value state
      //------------------------------------------------------------------
      [BEFORE_ATTRIBUTE_VALUE_STATE](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 if (cp === $.GREATER_THAN_SIGN) {
              this._err(ERR.missingAttributeValue);
              this.state = DATA_STATE;
              this._emitCurrentToken();
          } else {
              this._reconsumeInState(ATTRIBUTE_VALUE_UNQUOTED_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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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;
              }
          }
  
          //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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
  
          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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // Before DOCTYPE name state
      //------------------------------------------------------------------
      [BEFORE_DOCTYPE_NAME_STATE](cp) {
          if (isWhitespace(cp)) {
              return;
          }
  
          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;
          }
      }
  
      // 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);
          }
      }
  
      // After DOCTYPE name state
      //------------------------------------------------------------------
      [AFTER_DOCTYPE_NAME_STATE](cp) {
          if (isWhitespace(cp)) {
              return;
          }
  
          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);
          }
      }
  
      // 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);
          }
      }
  
      // Before DOCTYPE public identifier state
      //------------------------------------------------------------------
      [BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE](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 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // Between DOCTYPE public and system identifiers state
      //------------------------------------------------------------------
      [BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE](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 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);
          }
      }
  
      // 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);
          }
      }
  
      // Before DOCTYPE system identifier state
      //------------------------------------------------------------------
      [BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE](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 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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;
          }
  
          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);
          }
      }
  
      // 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();
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // Character reference state
      //------------------------------------------------------------------
      [CHARACTER_REFERENCE_STATE](cp) {
          this.tempBuff = [$.AMPERSAND];
  
          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);
          }
      }
  
      // 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;
  
              if (!this._isCharacterReferenceAttributeQuirk(withSemicolon)) {
                  if (!withSemicolon) {
                      this._errOnNextCodePoint(ERR.missingSemicolonAfterCharacterReference);
                  }
  
                  this.tempBuff = matchResult;
              }
  
              this._flushCodePointsConsumedAsCharacterReference();
              this.state = this.returnState;
          } else {
              this._flushCodePointsConsumedAsCharacterReference();
              this.state = AMBIGUOUS_AMPERSAND_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);
              }
  
              this._reconsumeInState(this.returnState);
          }
      }
  
      // Numeric character reference state
      //------------------------------------------------------------------
      [NUMERIC_CHARACTER_REFERENCE_STATE](cp) {
          this.charRefCode = 0;
  
          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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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);
          }
      }
  
      // 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.tempBuff = [this.charRefCode];
  
          this._flushCodePointsConsumedAsCharacterReference();
          this._reconsumeInState(this.returnState);
      }
  }
  
  //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';
  
  //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
  };
  
  //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;
          }
      }
  
      return null;
  };
  
  module.exports = Tokenizer;
  