parse5 3.0.3 → 5.1.0

package/lib/parser/index.js

@@ -1,845 +1,888 @@
 'use strict';
 
-var Tokenizer = require('../tokenizer'),
-    OpenElementStack = require('./open_element_stack'),
-    FormattingElementList = require('./formatting_element_list'),
-    LocationInfoParserMixin = require('../extensions/location_info/parser_mixin'),
-    defaultTreeAdapter = require('../tree_adapters/default'),
-    mergeOptions = require('../utils/merge_options'),
-    doctype = require('../common/doctype'),
-    foreignContent = require('../common/foreign_content'),
-    UNICODE = require('../common/unicode'),
-    HTML = require('../common/html');
+const Tokenizer = require('../tokenizer');
+const OpenElementStack = require('./open-element-stack');
+const FormattingElementList = require('./formatting-element-list');
+const LocationInfoParserMixin = require('../extensions/location-info/parser-mixin');
+const ErrorReportingParserMixin = require('../extensions/error-reporting/parser-mixin');
+const Mixin = require('../utils/mixin');
+const defaultTreeAdapter = require('../tree-adapters/default');
+const mergeOptions = require('../utils/merge-options');
+const doctype = require('../common/doctype');
+const foreignContent = require('../common/foreign-content');
+const ERR = require('../common/error-codes');
+const unicode = require('../common/unicode');
+const HTML = require('../common/html');
 
 //Aliases
-var $ = HTML.TAG_NAMES,
-    NS = HTML.NAMESPACES,
-    ATTRS = HTML.ATTRS;
-
-var DEFAULT_OPTIONS = {
-    locationInfo: false,
+const $ = HTML.TAG_NAMES;
+const NS = HTML.NAMESPACES;
+const ATTRS = HTML.ATTRS;
+
+const DEFAULT_OPTIONS = {
+    scriptingEnabled: true,
+    sourceCodeLocationInfo: false,
+    onParseError: null,
     treeAdapter: defaultTreeAdapter
 };
 
 //Misc constants
-var HIDDEN_INPUT_TYPE = 'hidden';
+const HIDDEN_INPUT_TYPE = 'hidden';
 
 //Adoption agency loops iteration count
-var AA_OUTER_LOOP_ITER = 8,
-    AA_INNER_LOOP_ITER = 3;
+const AA_OUTER_LOOP_ITER = 8;
+const AA_INNER_LOOP_ITER = 3;
 
 //Insertion modes
-var INITIAL_MODE = 'INITIAL_MODE',
-    BEFORE_HTML_MODE = 'BEFORE_HTML_MODE',
-    BEFORE_HEAD_MODE = 'BEFORE_HEAD_MODE',
-    IN_HEAD_MODE = 'IN_HEAD_MODE',
-    AFTER_HEAD_MODE = 'AFTER_HEAD_MODE',
-    IN_BODY_MODE = 'IN_BODY_MODE',
-    TEXT_MODE = 'TEXT_MODE',
-    IN_TABLE_MODE = 'IN_TABLE_MODE',
-    IN_TABLE_TEXT_MODE = 'IN_TABLE_TEXT_MODE',
-    IN_CAPTION_MODE = 'IN_CAPTION_MODE',
-    IN_COLUMN_GROUP_MODE = 'IN_COLUMN_GROUP_MODE',
-    IN_TABLE_BODY_MODE = 'IN_TABLE_BODY_MODE',
-    IN_ROW_MODE = 'IN_ROW_MODE',
-    IN_CELL_MODE = 'IN_CELL_MODE',
-    IN_SELECT_MODE = 'IN_SELECT_MODE',
-    IN_SELECT_IN_TABLE_MODE = 'IN_SELECT_IN_TABLE_MODE',
-    IN_TEMPLATE_MODE = 'IN_TEMPLATE_MODE',
-    AFTER_BODY_MODE = 'AFTER_BODY_MODE',
-    IN_FRAMESET_MODE = 'IN_FRAMESET_MODE',
-    AFTER_FRAMESET_MODE = 'AFTER_FRAMESET_MODE',
-    AFTER_AFTER_BODY_MODE = 'AFTER_AFTER_BODY_MODE',
-    AFTER_AFTER_FRAMESET_MODE = 'AFTER_AFTER_FRAMESET_MODE';
+const INITIAL_MODE = 'INITIAL_MODE';
+const BEFORE_HTML_MODE = 'BEFORE_HTML_MODE';
+const BEFORE_HEAD_MODE = 'BEFORE_HEAD_MODE';
+const IN_HEAD_MODE = 'IN_HEAD_MODE';
+const IN_HEAD_NO_SCRIPT_MODE = 'IN_HEAD_NO_SCRIPT_MODE';
+const AFTER_HEAD_MODE = 'AFTER_HEAD_MODE';
+const IN_BODY_MODE = 'IN_BODY_MODE';
+const TEXT_MODE = 'TEXT_MODE';
+const IN_TABLE_MODE = 'IN_TABLE_MODE';
+const IN_TABLE_TEXT_MODE = 'IN_TABLE_TEXT_MODE';
+const IN_CAPTION_MODE = 'IN_CAPTION_MODE';
+const IN_COLUMN_GROUP_MODE = 'IN_COLUMN_GROUP_MODE';
+const IN_TABLE_BODY_MODE = 'IN_TABLE_BODY_MODE';
+const IN_ROW_MODE = 'IN_ROW_MODE';
+const IN_CELL_MODE = 'IN_CELL_MODE';
+const IN_SELECT_MODE = 'IN_SELECT_MODE';
+const IN_SELECT_IN_TABLE_MODE = 'IN_SELECT_IN_TABLE_MODE';
+const IN_TEMPLATE_MODE = 'IN_TEMPLATE_MODE';
+const AFTER_BODY_MODE = 'AFTER_BODY_MODE';
+const IN_FRAMESET_MODE = 'IN_FRAMESET_MODE';
+const AFTER_FRAMESET_MODE = 'AFTER_FRAMESET_MODE';
+const AFTER_AFTER_BODY_MODE = 'AFTER_AFTER_BODY_MODE';
+const AFTER_AFTER_FRAMESET_MODE = 'AFTER_AFTER_FRAMESET_MODE';
 
 //Insertion mode reset map
-var INSERTION_MODE_RESET_MAP = Object.create(null);
-
-INSERTION_MODE_RESET_MAP[$.TR] = IN_ROW_MODE;
-INSERTION_MODE_RESET_MAP[$.TBODY] =
-INSERTION_MODE_RESET_MAP[$.THEAD] =
-INSERTION_MODE_RESET_MAP[$.TFOOT] = IN_TABLE_BODY_MODE;
-INSERTION_MODE_RESET_MAP[$.CAPTION] = IN_CAPTION_MODE;
-INSERTION_MODE_RESET_MAP[$.COLGROUP] = IN_COLUMN_GROUP_MODE;
-INSERTION_MODE_RESET_MAP[$.TABLE] = IN_TABLE_MODE;
-INSERTION_MODE_RESET_MAP[$.BODY] = IN_BODY_MODE;
-INSERTION_MODE_RESET_MAP[$.FRAMESET] = IN_FRAMESET_MODE;
+const INSERTION_MODE_RESET_MAP = {
+    [$.TR]: IN_ROW_MODE,
+    [$.TBODY]: IN_TABLE_BODY_MODE,
+    [$.THEAD]: IN_TABLE_BODY_MODE,
+    [$.TFOOT]: IN_TABLE_BODY_MODE,
+    [$.CAPTION]: IN_CAPTION_MODE,
+    [$.COLGROUP]: IN_COLUMN_GROUP_MODE,
+    [$.TABLE]: IN_TABLE_MODE,
+    [$.BODY]: IN_BODY_MODE,
+    [$.FRAMESET]: IN_FRAMESET_MODE
+};
 
 //Template insertion mode switch map
-var TEMPLATE_INSERTION_MODE_SWITCH_MAP = Object.create(null);
-
-TEMPLATE_INSERTION_MODE_SWITCH_MAP[$.CAPTION] =
-TEMPLATE_INSERTION_MODE_SWITCH_MAP[$.COLGROUP] =
-TEMPLATE_INSERTION_MODE_SWITCH_MAP[$.TBODY] =
-TEMPLATE_INSERTION_MODE_SWITCH_MAP[$.TFOOT] =
-TEMPLATE_INSERTION_MODE_SWITCH_MAP[$.THEAD] = IN_TABLE_MODE;
-TEMPLATE_INSERTION_MODE_SWITCH_MAP[$.COL] = IN_COLUMN_GROUP_MODE;
-TEMPLATE_INSERTION_MODE_SWITCH_MAP[$.TR] = IN_TABLE_BODY_MODE;
-TEMPLATE_INSERTION_MODE_SWITCH_MAP[$.TD] =
-TEMPLATE_INSERTION_MODE_SWITCH_MAP[$.TH] = IN_ROW_MODE;
+const TEMPLATE_INSERTION_MODE_SWITCH_MAP = {
+    [$.CAPTION]: IN_TABLE_MODE,
+    [$.COLGROUP]: IN_TABLE_MODE,
+    [$.TBODY]: IN_TABLE_MODE,
+    [$.TFOOT]: IN_TABLE_MODE,
+    [$.THEAD]: IN_TABLE_MODE,
+    [$.COL]: IN_COLUMN_GROUP_MODE,
+    [$.TR]: IN_TABLE_BODY_MODE,
+    [$.TD]: IN_ROW_MODE,
+    [$.TH]: IN_ROW_MODE
+};
 
 //Token handlers map for insertion modes
-var _ = Object.create(null);
-
-_[INITIAL_MODE] = Object.create(null);
-_[INITIAL_MODE][Tokenizer.CHARACTER_TOKEN] =
-_[INITIAL_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = tokenInInitialMode;
-_[INITIAL_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = ignoreToken;
-_[INITIAL_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[INITIAL_MODE][Tokenizer.DOCTYPE_TOKEN] = doctypeInInitialMode;
-_[INITIAL_MODE][Tokenizer.START_TAG_TOKEN] =
-_[INITIAL_MODE][Tokenizer.END_TAG_TOKEN] =
-_[INITIAL_MODE][Tokenizer.EOF_TOKEN] = tokenInInitialMode;
-
-_[BEFORE_HTML_MODE] = Object.create(null);
-_[BEFORE_HTML_MODE][Tokenizer.CHARACTER_TOKEN] =
-_[BEFORE_HTML_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = tokenBeforeHtml;
-_[BEFORE_HTML_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = ignoreToken;
-_[BEFORE_HTML_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[BEFORE_HTML_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[BEFORE_HTML_MODE][Tokenizer.START_TAG_TOKEN] = startTagBeforeHtml;
-_[BEFORE_HTML_MODE][Tokenizer.END_TAG_TOKEN] = endTagBeforeHtml;
-_[BEFORE_HTML_MODE][Tokenizer.EOF_TOKEN] = tokenBeforeHtml;
-
-_[BEFORE_HEAD_MODE] = Object.create(null);
-_[BEFORE_HEAD_MODE][Tokenizer.CHARACTER_TOKEN] =
-_[BEFORE_HEAD_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = tokenBeforeHead;
-_[BEFORE_HEAD_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = ignoreToken;
-_[BEFORE_HEAD_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[BEFORE_HEAD_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[BEFORE_HEAD_MODE][Tokenizer.START_TAG_TOKEN] = startTagBeforeHead;
-_[BEFORE_HEAD_MODE][Tokenizer.END_TAG_TOKEN] = endTagBeforeHead;
-_[BEFORE_HEAD_MODE][Tokenizer.EOF_TOKEN] = tokenBeforeHead;
-
-_[IN_HEAD_MODE] = Object.create(null);
-_[IN_HEAD_MODE][Tokenizer.CHARACTER_TOKEN] =
-_[IN_HEAD_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = tokenInHead;
-_[IN_HEAD_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = insertCharacters;
-_[IN_HEAD_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[IN_HEAD_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[IN_HEAD_MODE][Tokenizer.START_TAG_TOKEN] = startTagInHead;
-_[IN_HEAD_MODE][Tokenizer.END_TAG_TOKEN] = endTagInHead;
-_[IN_HEAD_MODE][Tokenizer.EOF_TOKEN] = tokenInHead;
-
-_[AFTER_HEAD_MODE] = Object.create(null);
-_[AFTER_HEAD_MODE][Tokenizer.CHARACTER_TOKEN] =
-_[AFTER_HEAD_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = tokenAfterHead;
-_[AFTER_HEAD_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = insertCharacters;
-_[AFTER_HEAD_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[AFTER_HEAD_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[AFTER_HEAD_MODE][Tokenizer.START_TAG_TOKEN] = startTagAfterHead;
-_[AFTER_HEAD_MODE][Tokenizer.END_TAG_TOKEN] = endTagAfterHead;
-_[AFTER_HEAD_MODE][Tokenizer.EOF_TOKEN] = tokenAfterHead;
-
-_[IN_BODY_MODE] = Object.create(null);
-_[IN_BODY_MODE][Tokenizer.CHARACTER_TOKEN] = characterInBody;
-_[IN_BODY_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = ignoreToken;
-_[IN_BODY_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = whitespaceCharacterInBody;
-_[IN_BODY_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[IN_BODY_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[IN_BODY_MODE][Tokenizer.START_TAG_TOKEN] = startTagInBody;
-_[IN_BODY_MODE][Tokenizer.END_TAG_TOKEN] = endTagInBody;
-_[IN_BODY_MODE][Tokenizer.EOF_TOKEN] = eofInBody;
-
-_[TEXT_MODE] = Object.create(null);
-_[TEXT_MODE][Tokenizer.CHARACTER_TOKEN] =
-_[TEXT_MODE][Tokenizer.NULL_CHARACTER_TOKEN] =
-_[TEXT_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = insertCharacters;
-_[TEXT_MODE][Tokenizer.COMMENT_TOKEN] =
-_[TEXT_MODE][Tokenizer.DOCTYPE_TOKEN] =
-_[TEXT_MODE][Tokenizer.START_TAG_TOKEN] = ignoreToken;
-_[TEXT_MODE][Tokenizer.END_TAG_TOKEN] = endTagInText;
-_[TEXT_MODE][Tokenizer.EOF_TOKEN] = eofInText;
-
-_[IN_TABLE_MODE] = Object.create(null);
-_[IN_TABLE_MODE][Tokenizer.CHARACTER_TOKEN] =
-_[IN_TABLE_MODE][Tokenizer.NULL_CHARACTER_TOKEN] =
-_[IN_TABLE_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = characterInTable;
-_[IN_TABLE_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[IN_TABLE_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[IN_TABLE_MODE][Tokenizer.START_TAG_TOKEN] = startTagInTable;
-_[IN_TABLE_MODE][Tokenizer.END_TAG_TOKEN] = endTagInTable;
-_[IN_TABLE_MODE][Tokenizer.EOF_TOKEN] = eofInBody;
-
-_[IN_TABLE_TEXT_MODE] = Object.create(null);
-_[IN_TABLE_TEXT_MODE][Tokenizer.CHARACTER_TOKEN] = characterInTableText;
-_[IN_TABLE_TEXT_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = ignoreToken;
-_[IN_TABLE_TEXT_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = whitespaceCharacterInTableText;
-_[IN_TABLE_TEXT_MODE][Tokenizer.COMMENT_TOKEN] =
-_[IN_TABLE_TEXT_MODE][Tokenizer.DOCTYPE_TOKEN] =
-_[IN_TABLE_TEXT_MODE][Tokenizer.START_TAG_TOKEN] =
-_[IN_TABLE_TEXT_MODE][Tokenizer.END_TAG_TOKEN] =
-_[IN_TABLE_TEXT_MODE][Tokenizer.EOF_TOKEN] = tokenInTableText;
-
-_[IN_CAPTION_MODE] = Object.create(null);
-_[IN_CAPTION_MODE][Tokenizer.CHARACTER_TOKEN] = characterInBody;
-_[IN_CAPTION_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = ignoreToken;
-_[IN_CAPTION_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = whitespaceCharacterInBody;
-_[IN_CAPTION_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[IN_CAPTION_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[IN_CAPTION_MODE][Tokenizer.START_TAG_TOKEN] = startTagInCaption;
-_[IN_CAPTION_MODE][Tokenizer.END_TAG_TOKEN] = endTagInCaption;
-_[IN_CAPTION_MODE][Tokenizer.EOF_TOKEN] = eofInBody;
-
-_[IN_COLUMN_GROUP_MODE] = Object.create(null);
-_[IN_COLUMN_GROUP_MODE][Tokenizer.CHARACTER_TOKEN] =
-_[IN_COLUMN_GROUP_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = tokenInColumnGroup;
-_[IN_COLUMN_GROUP_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = insertCharacters;
-_[IN_COLUMN_GROUP_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[IN_COLUMN_GROUP_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[IN_COLUMN_GROUP_MODE][Tokenizer.START_TAG_TOKEN] = startTagInColumnGroup;
-_[IN_COLUMN_GROUP_MODE][Tokenizer.END_TAG_TOKEN] = endTagInColumnGroup;
-_[IN_COLUMN_GROUP_MODE][Tokenizer.EOF_TOKEN] = eofInBody;
-
-_[IN_TABLE_BODY_MODE] = Object.create(null);
-_[IN_TABLE_BODY_MODE][Tokenizer.CHARACTER_TOKEN] =
-_[IN_TABLE_BODY_MODE][Tokenizer.NULL_CHARACTER_TOKEN] =
-_[IN_TABLE_BODY_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = characterInTable;
-_[IN_TABLE_BODY_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[IN_TABLE_BODY_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[IN_TABLE_BODY_MODE][Tokenizer.START_TAG_TOKEN] = startTagInTableBody;
-_[IN_TABLE_BODY_MODE][Tokenizer.END_TAG_TOKEN] = endTagInTableBody;
-_[IN_TABLE_BODY_MODE][Tokenizer.EOF_TOKEN] = eofInBody;
-
-_[IN_ROW_MODE] = Object.create(null);
-_[IN_ROW_MODE][Tokenizer.CHARACTER_TOKEN] =
-_[IN_ROW_MODE][Tokenizer.NULL_CHARACTER_TOKEN] =
-_[IN_ROW_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = characterInTable;
-_[IN_ROW_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[IN_ROW_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[IN_ROW_MODE][Tokenizer.START_TAG_TOKEN] = startTagInRow;
-_[IN_ROW_MODE][Tokenizer.END_TAG_TOKEN] = endTagInRow;
-_[IN_ROW_MODE][Tokenizer.EOF_TOKEN] = eofInBody;
-
-_[IN_CELL_MODE] = Object.create(null);
-_[IN_CELL_MODE][Tokenizer.CHARACTER_TOKEN] = characterInBody;
-_[IN_CELL_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = ignoreToken;
-_[IN_CELL_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = whitespaceCharacterInBody;
-_[IN_CELL_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[IN_CELL_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[IN_CELL_MODE][Tokenizer.START_TAG_TOKEN] = startTagInCell;
-_[IN_CELL_MODE][Tokenizer.END_TAG_TOKEN] = endTagInCell;
-_[IN_CELL_MODE][Tokenizer.EOF_TOKEN] = eofInBody;
-
-_[IN_SELECT_MODE] = Object.create(null);
-_[IN_SELECT_MODE][Tokenizer.CHARACTER_TOKEN] = insertCharacters;
-_[IN_SELECT_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = ignoreToken;
-_[IN_SELECT_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = insertCharacters;
-_[IN_SELECT_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[IN_SELECT_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[IN_SELECT_MODE][Tokenizer.START_TAG_TOKEN] = startTagInSelect;
-_[IN_SELECT_MODE][Tokenizer.END_TAG_TOKEN] = endTagInSelect;
-_[IN_SELECT_MODE][Tokenizer.EOF_TOKEN] = eofInBody;
-
-_[IN_SELECT_IN_TABLE_MODE] = Object.create(null);
-_[IN_SELECT_IN_TABLE_MODE][Tokenizer.CHARACTER_TOKEN] = insertCharacters;
-_[IN_SELECT_IN_TABLE_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = ignoreToken;
-_[IN_SELECT_IN_TABLE_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = insertCharacters;
-_[IN_SELECT_IN_TABLE_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[IN_SELECT_IN_TABLE_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[IN_SELECT_IN_TABLE_MODE][Tokenizer.START_TAG_TOKEN] = startTagInSelectInTable;
-_[IN_SELECT_IN_TABLE_MODE][Tokenizer.END_TAG_TOKEN] = endTagInSelectInTable;
-_[IN_SELECT_IN_TABLE_MODE][Tokenizer.EOF_TOKEN] = eofInBody;
-
-_[IN_TEMPLATE_MODE] = Object.create(null);
-_[IN_TEMPLATE_MODE][Tokenizer.CHARACTER_TOKEN] = characterInBody;
-_[IN_TEMPLATE_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = ignoreToken;
-_[IN_TEMPLATE_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = whitespaceCharacterInBody;
-_[IN_TEMPLATE_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[IN_TEMPLATE_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[IN_TEMPLATE_MODE][Tokenizer.START_TAG_TOKEN] = startTagInTemplate;
-_[IN_TEMPLATE_MODE][Tokenizer.END_TAG_TOKEN] = endTagInTemplate;
-_[IN_TEMPLATE_MODE][Tokenizer.EOF_TOKEN] = eofInTemplate;
-
-_[AFTER_BODY_MODE] = Object.create(null);
-_[AFTER_BODY_MODE][Tokenizer.CHARACTER_TOKEN] =
-_[AFTER_BODY_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = tokenAfterBody;
-_[AFTER_BODY_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = whitespaceCharacterInBody;
-_[AFTER_BODY_MODE][Tokenizer.COMMENT_TOKEN] = appendCommentToRootHtmlElement;
-_[AFTER_BODY_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[AFTER_BODY_MODE][Tokenizer.START_TAG_TOKEN] = startTagAfterBody;
-_[AFTER_BODY_MODE][Tokenizer.END_TAG_TOKEN] = endTagAfterBody;
-_[AFTER_BODY_MODE][Tokenizer.EOF_TOKEN] = stopParsing;
-
-_[IN_FRAMESET_MODE] = Object.create(null);
-_[IN_FRAMESET_MODE][Tokenizer.CHARACTER_TOKEN] =
-_[IN_FRAMESET_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = ignoreToken;
-_[IN_FRAMESET_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = insertCharacters;
-_[IN_FRAMESET_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[IN_FRAMESET_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[IN_FRAMESET_MODE][Tokenizer.START_TAG_TOKEN] = startTagInFrameset;
-_[IN_FRAMESET_MODE][Tokenizer.END_TAG_TOKEN] = endTagInFrameset;
-_[IN_FRAMESET_MODE][Tokenizer.EOF_TOKEN] = stopParsing;
-
-_[AFTER_FRAMESET_MODE] = Object.create(null);
-_[AFTER_FRAMESET_MODE][Tokenizer.CHARACTER_TOKEN] =
-_[AFTER_FRAMESET_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = ignoreToken;
-_[AFTER_FRAMESET_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = insertCharacters;
-_[AFTER_FRAMESET_MODE][Tokenizer.COMMENT_TOKEN] = appendComment;
-_[AFTER_FRAMESET_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[AFTER_FRAMESET_MODE][Tokenizer.START_TAG_TOKEN] = startTagAfterFrameset;
-_[AFTER_FRAMESET_MODE][Tokenizer.END_TAG_TOKEN] = endTagAfterFrameset;
-_[AFTER_FRAMESET_MODE][Tokenizer.EOF_TOKEN] = stopParsing;
-
-_[AFTER_AFTER_BODY_MODE] = Object.create(null);
-_[AFTER_AFTER_BODY_MODE][Tokenizer.CHARACTER_TOKEN] = tokenAfterAfterBody;
-_[AFTER_AFTER_BODY_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = tokenAfterAfterBody;
-_[AFTER_AFTER_BODY_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = whitespaceCharacterInBody;
-_[AFTER_AFTER_BODY_MODE][Tokenizer.COMMENT_TOKEN] = appendCommentToDocument;
-_[AFTER_AFTER_BODY_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[AFTER_AFTER_BODY_MODE][Tokenizer.START_TAG_TOKEN] = startTagAfterAfterBody;
-_[AFTER_AFTER_BODY_MODE][Tokenizer.END_TAG_TOKEN] = tokenAfterAfterBody;
-_[AFTER_AFTER_BODY_MODE][Tokenizer.EOF_TOKEN] = stopParsing;
-
-_[AFTER_AFTER_FRAMESET_MODE] = Object.create(null);
-_[AFTER_AFTER_FRAMESET_MODE][Tokenizer.CHARACTER_TOKEN] =
-_[AFTER_AFTER_FRAMESET_MODE][Tokenizer.NULL_CHARACTER_TOKEN] = ignoreToken;
-_[AFTER_AFTER_FRAMESET_MODE][Tokenizer.WHITESPACE_CHARACTER_TOKEN] = whitespaceCharacterInBody;
-_[AFTER_AFTER_FRAMESET_MODE][Tokenizer.COMMENT_TOKEN] = appendCommentToDocument;
-_[AFTER_AFTER_FRAMESET_MODE][Tokenizer.DOCTYPE_TOKEN] = ignoreToken;
-_[AFTER_AFTER_FRAMESET_MODE][Tokenizer.START_TAG_TOKEN] = startTagAfterAfterFrameset;
-_[AFTER_AFTER_FRAMESET_MODE][Tokenizer.END_TAG_TOKEN] = ignoreToken;
-_[AFTER_AFTER_FRAMESET_MODE][Tokenizer.EOF_TOKEN] = stopParsing;
-
+const TOKEN_HANDLERS = {
+    [INITIAL_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: tokenInInitialMode,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInInitialMode,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: doctypeInInitialMode,
+        [Tokenizer.START_TAG_TOKEN]: tokenInInitialMode,
+        [Tokenizer.END_TAG_TOKEN]: tokenInInitialMode,
+        [Tokenizer.EOF_TOKEN]: tokenInInitialMode
+    },
+    [BEFORE_HTML_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: tokenBeforeHtml,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenBeforeHtml,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagBeforeHtml,
+        [Tokenizer.END_TAG_TOKEN]: endTagBeforeHtml,
+        [Tokenizer.EOF_TOKEN]: tokenBeforeHtml
+    },
+    [BEFORE_HEAD_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: tokenBeforeHead,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenBeforeHead,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,
+        [Tokenizer.START_TAG_TOKEN]: startTagBeforeHead,
+        [Tokenizer.END_TAG_TOKEN]: endTagBeforeHead,
+        [Tokenizer.EOF_TOKEN]: tokenBeforeHead
+    },
+    [IN_HEAD_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: tokenInHead,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInHead,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,
+        [Tokenizer.START_TAG_TOKEN]: startTagInHead,
+        [Tokenizer.END_TAG_TOKEN]: endTagInHead,
+        [Tokenizer.EOF_TOKEN]: tokenInHead
+    },
+    [IN_HEAD_NO_SCRIPT_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: tokenInHeadNoScript,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInHeadNoScript,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,
+        [Tokenizer.START_TAG_TOKEN]: startTagInHeadNoScript,
+        [Tokenizer.END_TAG_TOKEN]: endTagInHeadNoScript,
+        [Tokenizer.EOF_TOKEN]: tokenInHeadNoScript
+    },
+    [AFTER_HEAD_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: tokenAfterHead,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterHead,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: misplacedDoctype,
+        [Tokenizer.START_TAG_TOKEN]: startTagAfterHead,
+        [Tokenizer.END_TAG_TOKEN]: endTagAfterHead,
+        [Tokenizer.EOF_TOKEN]: tokenAfterHead
+    },
+    [IN_BODY_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: characterInBody,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagInBody,
+        [Tokenizer.END_TAG_TOKEN]: endTagInBody,
+        [Tokenizer.EOF_TOKEN]: eofInBody
+    },
+    [TEXT_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: insertCharacters,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: insertCharacters,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
+        [Tokenizer.COMMENT_TOKEN]: ignoreToken,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: ignoreToken,
+        [Tokenizer.END_TAG_TOKEN]: endTagInText,
+        [Tokenizer.EOF_TOKEN]: eofInText
+    },
+    [IN_TABLE_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: characterInTable,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagInTable,
+        [Tokenizer.END_TAG_TOKEN]: endTagInTable,
+        [Tokenizer.EOF_TOKEN]: eofInBody
+    },
+    [IN_TABLE_TEXT_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: characterInTableText,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInTableText,
+        [Tokenizer.COMMENT_TOKEN]: tokenInTableText,
+        [Tokenizer.DOCTYPE_TOKEN]: tokenInTableText,
+        [Tokenizer.START_TAG_TOKEN]: tokenInTableText,
+        [Tokenizer.END_TAG_TOKEN]: tokenInTableText,
+        [Tokenizer.EOF_TOKEN]: tokenInTableText
+    },
+    [IN_CAPTION_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: characterInBody,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagInCaption,
+        [Tokenizer.END_TAG_TOKEN]: endTagInCaption,
+        [Tokenizer.EOF_TOKEN]: eofInBody
+    },
+    [IN_COLUMN_GROUP_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: tokenInColumnGroup,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenInColumnGroup,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagInColumnGroup,
+        [Tokenizer.END_TAG_TOKEN]: endTagInColumnGroup,
+        [Tokenizer.EOF_TOKEN]: eofInBody
+    },
+    [IN_TABLE_BODY_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: characterInTable,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagInTableBody,
+        [Tokenizer.END_TAG_TOKEN]: endTagInTableBody,
+        [Tokenizer.EOF_TOKEN]: eofInBody
+    },
+    [IN_ROW_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: characterInTable,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: characterInTable,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: characterInTable,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagInRow,
+        [Tokenizer.END_TAG_TOKEN]: endTagInRow,
+        [Tokenizer.EOF_TOKEN]: eofInBody
+    },
+    [IN_CELL_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: characterInBody,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagInCell,
+        [Tokenizer.END_TAG_TOKEN]: endTagInCell,
+        [Tokenizer.EOF_TOKEN]: eofInBody
+    },
+    [IN_SELECT_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: insertCharacters,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagInSelect,
+        [Tokenizer.END_TAG_TOKEN]: endTagInSelect,
+        [Tokenizer.EOF_TOKEN]: eofInBody
+    },
+    [IN_SELECT_IN_TABLE_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: insertCharacters,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagInSelectInTable,
+        [Tokenizer.END_TAG_TOKEN]: endTagInSelectInTable,
+        [Tokenizer.EOF_TOKEN]: eofInBody
+    },
+    [IN_TEMPLATE_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: characterInBody,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagInTemplate,
+        [Tokenizer.END_TAG_TOKEN]: endTagInTemplate,
+        [Tokenizer.EOF_TOKEN]: eofInTemplate
+    },
+    [AFTER_BODY_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: tokenAfterBody,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterBody,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
+        [Tokenizer.COMMENT_TOKEN]: appendCommentToRootHtmlElement,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagAfterBody,
+        [Tokenizer.END_TAG_TOKEN]: endTagAfterBody,
+        [Tokenizer.EOF_TOKEN]: stopParsing
+    },
+    [IN_FRAMESET_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagInFrameset,
+        [Tokenizer.END_TAG_TOKEN]: endTagInFrameset,
+        [Tokenizer.EOF_TOKEN]: stopParsing
+    },
+    [AFTER_FRAMESET_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: insertCharacters,
+        [Tokenizer.COMMENT_TOKEN]: appendComment,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagAfterFrameset,
+        [Tokenizer.END_TAG_TOKEN]: endTagAfterFrameset,
+        [Tokenizer.EOF_TOKEN]: stopParsing
+    },
+    [AFTER_AFTER_BODY_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: tokenAfterAfterBody,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: tokenAfterAfterBody,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
+        [Tokenizer.COMMENT_TOKEN]: appendCommentToDocument,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagAfterAfterBody,
+        [Tokenizer.END_TAG_TOKEN]: tokenAfterAfterBody,
+        [Tokenizer.EOF_TOKEN]: stopParsing
+    },
+    [AFTER_AFTER_FRAMESET_MODE]: {
+        [Tokenizer.CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.NULL_CHARACTER_TOKEN]: ignoreToken,
+        [Tokenizer.WHITESPACE_CHARACTER_TOKEN]: whitespaceCharacterInBody,
+        [Tokenizer.COMMENT_TOKEN]: appendCommentToDocument,
+        [Tokenizer.DOCTYPE_TOKEN]: ignoreToken,
+        [Tokenizer.START_TAG_TOKEN]: startTagAfterAfterFrameset,
+        [Tokenizer.END_TAG_TOKEN]: ignoreToken,
+        [Tokenizer.EOF_TOKEN]: stopParsing
+    }
+};
 
 //Parser
-var Parser = module.exports = function (options) {
-    this.options = mergeOptions(DEFAULT_OPTIONS, options);
-
-    this.treeAdapter = this.options.treeAdapter;
-    this.pendingScript = null;
+class Parser {
+    constructor(options) {
+        this.options = mergeOptions(DEFAULT_OPTIONS, options);
 
-    if (this.options.locationInfo)
-        new LocationInfoParserMixin(this);
-};
+        this.treeAdapter = this.options.treeAdapter;
+        this.pendingScript = null;
 
-// API
-Parser.prototype.parse = function (html) {
-    var document = this.treeAdapter.createDocument();
+        if (this.options.sourceCodeLocationInfo) {
+            Mixin.install(this, LocationInfoParserMixin);
+        }
 
-    this._bootstrap(document, null);
-    this.tokenizer.write(html, true);
-    this._runParsingLoop(null);
+        if (this.options.onParseError) {
+            Mixin.install(this, ErrorReportingParserMixin, { onParseError: this.options.onParseError });
+        }
+    }
 
-    return document;
-};
+    // API
+    parse(html) {
+        const document = this.treeAdapter.createDocument();
 
-Parser.prototype.parseFragment = function (html, fragmentContext) {
-    //NOTE: use <template> element as a fragment context if context element was not provided,
-    //so we will parse in "forgiving" manner
-    if (!fragmentContext)
-        fragmentContext = this.treeAdapter.createElement($.TEMPLATE, NS.HTML, []);
+        this._bootstrap(document, null);
+        this.tokenizer.write(html, true);
+        this._runParsingLoop(null);
 
-    //NOTE: create fake element which will be used as 'document' for fragment parsing.
-    //This is important for jsdom there 'document' can't be recreated, therefore
-    //fragment parsing causes messing of the main `document`.
-    var documentMock = this.treeAdapter.createElement('documentmock', NS.HTML, []);
+        return document;
+    }
 
-    this._bootstrap(documentMock, fragmentContext);
+    parseFragment(html, fragmentContext) {
+        //NOTE: use <template> element as a fragment context if context element was not provided,
+        //so we will parse in "forgiving" manner
+        if (!fragmentContext) {
+            fragmentContext = this.treeAdapter.createElement($.TEMPLATE, NS.HTML, []);
+        }
 
-    if (this.treeAdapter.getTagName(fragmentContext) === $.TEMPLATE)
-        this._pushTmplInsertionMode(IN_TEMPLATE_MODE);
+        //NOTE: create fake element which will be used as 'document' for fragment parsing.
+        //This is important for jsdom there 'document' can't be recreated, therefore
+        //fragment parsing causes messing of the main `document`.
+        const documentMock = this.treeAdapter.createElement('documentmock', NS.HTML, []);
 
-    this._initTokenizerForFragmentParsing();
-    this._insertFakeRootElement();
-    this._resetInsertionMode();
-    this._findFormInFragmentContext();
-    this.tokenizer.write(html, true);
-    this._runParsingLoop(null);
+        this._bootstrap(documentMock, fragmentContext);
 
-    var rootElement = this.treeAdapter.getFirstChild(documentMock),
-        fragment = this.treeAdapter.createDocumentFragment();
+        if (this.treeAdapter.getTagName(fragmentContext) === $.TEMPLATE) {
+            this._pushTmplInsertionMode(IN_TEMPLATE_MODE);
+        }
 
-    this._adoptNodes(rootElement, fragment);
+        this._initTokenizerForFragmentParsing();
+        this._insertFakeRootElement();
+        this._resetInsertionMode();
+        this._findFormInFragmentContext();
+        this.tokenizer.write(html, true);
+        this._runParsingLoop(null);
 
-    return fragment;
-};
+        const rootElement = this.treeAdapter.getFirstChild(documentMock);
+        const fragment = this.treeAdapter.createDocumentFragment();
 
-//Bootstrap parser
-Parser.prototype._bootstrap = function (document, fragmentContext) {
-    this.tokenizer = new Tokenizer(this.options);
+        this._adoptNodes(rootElement, fragment);
 
-    this.stopped = false;
+        return fragment;
+    }
 
-    this.insertionMode = INITIAL_MODE;
-    this.originalInsertionMode = '';
+    //Bootstrap parser
+    _bootstrap(document, fragmentContext) {
+        this.tokenizer = new Tokenizer(this.options);
 
-    this.document = document;
-    this.fragmentContext = fragmentContext;
+        this.stopped = false;
 
-    this.headElement = null;
-    this.formElement = null;
+        this.insertionMode = INITIAL_MODE;
+        this.originalInsertionMode = '';
 
-    this.openElements = new OpenElementStack(this.document, this.treeAdapter);
-    this.activeFormattingElements = new FormattingElementList(this.treeAdapter);
+        this.document = document;
+        this.fragmentContext = fragmentContext;
 
-    this.tmplInsertionModeStack = [];
-    this.tmplInsertionModeStackTop = -1;
-    this.currentTmplInsertionMode = null;
+        this.headElement = null;
+        this.formElement = null;
 
-    this.pendingCharacterTokens = [];
-    this.hasNonWhitespacePendingCharacterToken = false;
+        this.openElements = new OpenElementStack(this.document, this.treeAdapter);
+        this.activeFormattingElements = new FormattingElementList(this.treeAdapter);
 
-    this.framesetOk = true;
-    this.skipNextNewLine = false;
-    this.fosterParentingEnabled = false;
-};
+        this.tmplInsertionModeStack = [];
+        this.tmplInsertionModeStackTop = -1;
+        this.currentTmplInsertionMode = null;
 
-//Parsing loop
-Parser.prototype._runParsingLoop  = function (scriptHandler) {
-    while (!this.stopped) {
-        this._setupTokenizerCDATAMode();
+        this.pendingCharacterTokens = [];
+        this.hasNonWhitespacePendingCharacterToken = false;
 
-        var token = this.tokenizer.getNextToken();
+        this.framesetOk = true;
+        this.skipNextNewLine = false;
+        this.fosterParentingEnabled = false;
+    }
 
-        if (token.type === Tokenizer.HIBERNATION_TOKEN)
-            break;
+    //Errors
+    _err() {
+        // NOTE: err reporting is noop by default. Enabled by mixin.
+    }
 
-        if (this.skipNextNewLine) {
-            this.skipNextNewLine = false;
+    //Parsing loop
+    _runParsingLoop(scriptHandler) {
+        while (!this.stopped) {
+            this._setupTokenizerCDATAMode();
 
-            if (token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN && token.chars[0] === '\n') {
-                if (token.chars.length === 1)
-                    continue;
+            const token = this.tokenizer.getNextToken();
 
-                token.chars = token.chars.substr(1);
+            if (token.type === Tokenizer.HIBERNATION_TOKEN) {
+                break;
             }
-        }
-
-        this._processInputToken(token);
 
-        if (scriptHandler && this.pendingScript)
-            break;
-    }
-};
+            if (this.skipNextNewLine) {
+                this.skipNextNewLine = false;
 
-Parser.prototype.runParsingLoopForCurrentChunk = function (writeCallback, scriptHandler) {
-    this._runParsingLoop(scriptHandler);
+                if (token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN && token.chars[0] === '\n') {
+                    if (token.chars.length === 1) {
+                        continue;
+                    }
 
-    if (scriptHandler && this.pendingScript) {
-        var script = this.pendingScript;
-
-        this.pendingScript = null;
+                    token.chars = token.chars.substr(1);
+                }
+            }
 
-        scriptHandler(script);
+            this._processInputToken(token);
 
-        return;
+            if (scriptHandler && this.pendingScript) {
+                break;
+            }
+        }
     }
 
-    if (writeCallback)
-        writeCallback();
-};
+    runParsingLoopForCurrentChunk(writeCallback, scriptHandler) {
+        this._runParsingLoop(scriptHandler);
 
-//Text parsing
-Parser.prototype._setupTokenizerCDATAMode = function () {
-    var current = this._getAdjustedCurrentElement();
+        if (scriptHandler && this.pendingScript) {
+            const script = this.pendingScript;
 
-    this.tokenizer.allowCDATA = current && current !== this.document &&
-                                this.treeAdapter.getNamespaceURI(current) !== NS.HTML && !this._isIntegrationPoint(current);
-};
-
-Parser.prototype._switchToTextParsing = function (currentToken, nextTokenizerState) {
-    this._insertElement(currentToken, NS.HTML);
-    this.tokenizer.state = nextTokenizerState;
-    this.originalInsertionMode = this.insertionMode;
-    this.insertionMode = TEXT_MODE;
-};
+            this.pendingScript = null;
 
-Parser.prototype.switchToPlaintextParsing = function () {
-    this.insertionMode = TEXT_MODE;
-    this.originalInsertionMode = IN_BODY_MODE;
-    this.tokenizer.state = Tokenizer.MODE.PLAINTEXT;
-};
+            scriptHandler(script);
 
-//Fragment parsing
-Parser.prototype._getAdjustedCurrentElement = function () {
-    return this.openElements.stackTop === 0 && this.fragmentContext ?
-        this.fragmentContext :
-        this.openElements.current;
-};
-
-Parser.prototype._findFormInFragmentContext = function () {
-    var node = this.fragmentContext;
-
-    do {
-        if (this.treeAdapter.getTagName(node) === $.FORM) {
-            this.formElement = node;
-            break;
+            return;
         }
 
-        node = this.treeAdapter.getParentNode(node);
-    } while (node);
-};
-
-Parser.prototype._initTokenizerForFragmentParsing = function () {
-    if (this.treeAdapter.getNamespaceURI(this.fragmentContext) === NS.HTML) {
-        var tn = this.treeAdapter.getTagName(this.fragmentContext);
+        if (writeCallback) {
+            writeCallback();
+        }
+    }
 
-        if (tn === $.TITLE || tn === $.TEXTAREA)
-            this.tokenizer.state = Tokenizer.MODE.RCDATA;
+    //Text parsing
+    _setupTokenizerCDATAMode() {
+        const current = this._getAdjustedCurrentElement();
 
-        else if (tn === $.STYLE || tn === $.XMP || tn === $.IFRAME ||
-                 tn === $.NOEMBED || tn === $.NOFRAMES || tn === $.NOSCRIPT)
-            this.tokenizer.state = Tokenizer.MODE.RAWTEXT;
+        this.tokenizer.allowCDATA =
+            current &&
+            current !== this.document &&
+            this.treeAdapter.getNamespaceURI(current) !== NS.HTML &&
+            !this._isIntegrationPoint(current);
+    }
 
-        else if (tn === $.SCRIPT)
-            this.tokenizer.state = Tokenizer.MODE.SCRIPT_DATA;
+    _switchToTextParsing(currentToken, nextTokenizerState) {
+        this._insertElement(currentToken, NS.HTML);
+        this.tokenizer.state = nextTokenizerState;
+        this.originalInsertionMode = this.insertionMode;
+        this.insertionMode = TEXT_MODE;
+    }
 
-        else if (tn === $.PLAINTEXT)
-            this.tokenizer.state = Tokenizer.MODE.PLAINTEXT;
+    switchToPlaintextParsing() {
+        this.insertionMode = TEXT_MODE;
+        this.originalInsertionMode = IN_BODY_MODE;
+        this.tokenizer.state = Tokenizer.MODE.PLAINTEXT;
     }
-};
 
-//Tree mutation
-Parser.prototype._setDocumentType = function (token) {
-    this.treeAdapter.setDocumentType(this.document, token.name, token.publicId, token.systemId);
-};
+    //Fragment parsing
+    _getAdjustedCurrentElement() {
+        return this.openElements.stackTop === 0 && this.fragmentContext
+            ? this.fragmentContext
+            : this.openElements.current;
+    }
 
-Parser.prototype._attachElementToTree = function (element) {
-    if (this._shouldFosterParentOnInsertion())
-        this._fosterParentElement(element);
+    _findFormInFragmentContext() {
+        let node = this.fragmentContext;
 
-    else {
-        var parent = this.openElements.currentTmplContent || this.openElements.current;
+        do {
+            if (this.treeAdapter.getTagName(node) === $.FORM) {
+                this.formElement = node;
+                break;
+            }
 
-        this.treeAdapter.appendChild(parent, element);
+            node = this.treeAdapter.getParentNode(node);
+        } while (node);
+    }
+
+    _initTokenizerForFragmentParsing() {
+        if (this.treeAdapter.getNamespaceURI(this.fragmentContext) === NS.HTML) {
+            const tn = this.treeAdapter.getTagName(this.fragmentContext);
+
+            if (tn === $.TITLE || tn === $.TEXTAREA) {
+                this.tokenizer.state = Tokenizer.MODE.RCDATA;
+            } else if (
+                tn === $.STYLE ||
+                tn === $.XMP ||
+                tn === $.IFRAME ||
+                tn === $.NOEMBED ||
+                tn === $.NOFRAMES ||
+                tn === $.NOSCRIPT
+            ) {
+                this.tokenizer.state = Tokenizer.MODE.RAWTEXT;
+            } else if (tn === $.SCRIPT) {
+                this.tokenizer.state = Tokenizer.MODE.SCRIPT_DATA;
+            } else if (tn === $.PLAINTEXT) {
+                this.tokenizer.state = Tokenizer.MODE.PLAINTEXT;
+            }
+        }
     }
-};
 
-Parser.prototype._appendElement = function (token, namespaceURI) {
-    var element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
+    //Tree mutation
+    _setDocumentType(token) {
+        const name = token.name || '';
+        const publicId = token.publicId || '';
+        const systemId = token.systemId || '';
 
-    this._attachElementToTree(element);
-};
+        this.treeAdapter.setDocumentType(this.document, name, publicId, systemId);
+    }
 
-Parser.prototype._insertElement = function (token, namespaceURI) {
-    var element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
+    _attachElementToTree(element) {
+        if (this._shouldFosterParentOnInsertion()) {
+            this._fosterParentElement(element);
+        } else {
+            const parent = this.openElements.currentTmplContent || this.openElements.current;
 
-    this._attachElementToTree(element);
-    this.openElements.push(element);
-};
+            this.treeAdapter.appendChild(parent, element);
+        }
+    }
 
-Parser.prototype._insertFakeElement = function (tagName) {
-    var element = this.treeAdapter.createElement(tagName, NS.HTML, []);
+    _appendElement(token, namespaceURI) {
+        const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
 
-    this._attachElementToTree(element);
-    this.openElements.push(element);
-};
+        this._attachElementToTree(element);
+    }
 
-Parser.prototype._insertTemplate = function (token) {
-    var tmpl = this.treeAdapter.createElement(token.tagName, NS.HTML, token.attrs),
-        content = this.treeAdapter.createDocumentFragment();
+    _insertElement(token, namespaceURI) {
+        const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
 
-    this.treeAdapter.setTemplateContent(tmpl, content);
-    this._attachElementToTree(tmpl);
-    this.openElements.push(tmpl);
-};
+        this._attachElementToTree(element);
+        this.openElements.push(element);
+    }
 
-Parser.prototype._insertFakeRootElement = function () {
-    var element = this.treeAdapter.createElement($.HTML, NS.HTML, []);
+    _insertFakeElement(tagName) {
+        const element = this.treeAdapter.createElement(tagName, NS.HTML, []);
 
-    this.treeAdapter.appendChild(this.openElements.current, element);
-    this.openElements.push(element);
-};
-
-Parser.prototype._appendCommentNode = function (token, parent) {
-    var commentNode = this.treeAdapter.createCommentNode(token.data);
+        this._attachElementToTree(element);
+        this.openElements.push(element);
+    }
 
-    this.treeAdapter.appendChild(parent, commentNode);
-};
+    _insertTemplate(token) {
+        const tmpl = this.treeAdapter.createElement(token.tagName, NS.HTML, token.attrs);
+        const content = this.treeAdapter.createDocumentFragment();
 
-Parser.prototype._insertCharacters = function (token) {
-    if (this._shouldFosterParentOnInsertion())
-        this._fosterParentText(token.chars);
+        this.treeAdapter.setTemplateContent(tmpl, content);
+        this._attachElementToTree(tmpl);
+        this.openElements.push(tmpl);
+    }
 
-    else {
-        var parent = this.openElements.currentTmplContent || this.openElements.current;
+    _insertFakeRootElement() {
+        const element = this.treeAdapter.createElement($.HTML, NS.HTML, []);
 
-        this.treeAdapter.insertText(parent, token.chars);
+        this.treeAdapter.appendChild(this.openElements.current, element);
+        this.openElements.push(element);
     }
-};
 
-Parser.prototype._adoptNodes = function (donor, recipient) {
-    while (true) {
-        var child = this.treeAdapter.getFirstChild(donor);
+    _appendCommentNode(token, parent) {
+        const commentNode = this.treeAdapter.createCommentNode(token.data);
 
-        if (!child)
-            break;
-
-        this.treeAdapter.detachNode(child);
-        this.treeAdapter.appendChild(recipient, child);
+        this.treeAdapter.appendChild(parent, commentNode);
     }
-};
 
-//Token processing
-Parser.prototype._shouldProcessTokenInForeignContent = function (token) {
-    var current = this._getAdjustedCurrentElement();
+    _insertCharacters(token) {
+        if (this._shouldFosterParentOnInsertion()) {
+            this._fosterParentText(token.chars);
+        } else {
+            const parent = this.openElements.currentTmplContent || this.openElements.current;
 
-    if (!current || current === this.document)
-        return false;
+            this.treeAdapter.insertText(parent, token.chars);
+        }
+    }
 
-    var ns = this.treeAdapter.getNamespaceURI(current);
+    _adoptNodes(donor, recipient) {
+        for (let child = this.treeAdapter.getFirstChild(donor); child; child = this.treeAdapter.getFirstChild(donor)) {
+            this.treeAdapter.detachNode(child);
+            this.treeAdapter.appendChild(recipient, child);
+        }
+    }
 
-    if (ns === NS.HTML)
-        return false;
+    //Token processing
+    _shouldProcessTokenInForeignContent(token) {
+        const current = this._getAdjustedCurrentElement();
 
-    if (this.treeAdapter.getTagName(current) === $.ANNOTATION_XML && ns === NS.MATHML &&
-        token.type === Tokenizer.START_TAG_TOKEN && token.tagName === $.SVG)
-        return false;
+        if (!current || current === this.document) {
+            return false;
+        }
 
-    var isCharacterToken = token.type === Tokenizer.CHARACTER_TOKEN ||
-                           token.type === Tokenizer.NULL_CHARACTER_TOKEN ||
-                           token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN,
-        isMathMLTextStartTag = token.type === Tokenizer.START_TAG_TOKEN &&
-                               token.tagName !== $.MGLYPH &&
-                               token.tagName !== $.MALIGNMARK;
+        const ns = this.treeAdapter.getNamespaceURI(current);
 
-    if ((isMathMLTextStartTag || isCharacterToken) && this._isIntegrationPoint(current, NS.MATHML))
-        return false;
+        if (ns === NS.HTML) {
+            return false;
+        }
 
-    if ((token.type === Tokenizer.START_TAG_TOKEN || isCharacterToken) && this._isIntegrationPoint(current, NS.HTML))
-        return false;
+        if (
+            this.treeAdapter.getTagName(current) === $.ANNOTATION_XML &&
+            ns === NS.MATHML &&
+            token.type === Tokenizer.START_TAG_TOKEN &&
+            token.tagName === $.SVG
+        ) {
+            return false;
+        }
 
-    return token.type !== Tokenizer.EOF_TOKEN;
-};
+        const isCharacterToken =
+            token.type === Tokenizer.CHARACTER_TOKEN ||
+            token.type === Tokenizer.NULL_CHARACTER_TOKEN ||
+            token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN;
 
-Parser.prototype._processToken = function (token) {
-    _[this.insertionMode][token.type](this, token);
-};
+        const isMathMLTextStartTag =
+            token.type === Tokenizer.START_TAG_TOKEN && token.tagName !== $.MGLYPH && token.tagName !== $.MALIGNMARK;
 
-Parser.prototype._processTokenInBodyMode = function (token) {
-    _[IN_BODY_MODE][token.type](this, token);
-};
+        if ((isMathMLTextStartTag || isCharacterToken) && this._isIntegrationPoint(current, NS.MATHML)) {
+            return false;
+        }
 
-Parser.prototype._processTokenInForeignContent = function (token) {
-    if (token.type === Tokenizer.CHARACTER_TOKEN)
-        characterInForeignContent(this, token);
+        if (
+            (token.type === Tokenizer.START_TAG_TOKEN || isCharacterToken) &&
+            this._isIntegrationPoint(current, NS.HTML)
+        ) {
+            return false;
+        }
 
-    else if (token.type === Tokenizer.NULL_CHARACTER_TOKEN)
-        nullCharacterInForeignContent(this, token);
+        return token.type !== Tokenizer.EOF_TOKEN;
+    }
 
-    else if (token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN)
-        insertCharacters(this, token);
+    _processToken(token) {
+        TOKEN_HANDLERS[this.insertionMode][token.type](this, token);
+    }
 
-    else if (token.type === Tokenizer.COMMENT_TOKEN)
-        appendComment(this, token);
+    _processTokenInBodyMode(token) {
+        TOKEN_HANDLERS[IN_BODY_MODE][token.type](this, token);
+    }
 
-    else if (token.type === Tokenizer.START_TAG_TOKEN)
-        startTagInForeignContent(this, token);
+    _processTokenInForeignContent(token) {
+        if (token.type === Tokenizer.CHARACTER_TOKEN) {
+            characterInForeignContent(this, token);
+        } else if (token.type === Tokenizer.NULL_CHARACTER_TOKEN) {
+            nullCharacterInForeignContent(this, token);
+        } else if (token.type === Tokenizer.WHITESPACE_CHARACTER_TOKEN) {
+            insertCharacters(this, token);
+        } else if (token.type === Tokenizer.COMMENT_TOKEN) {
+            appendComment(this, token);
+        } else if (token.type === Tokenizer.START_TAG_TOKEN) {
+            startTagInForeignContent(this, token);
+        } else if (token.type === Tokenizer.END_TAG_TOKEN) {
+            endTagInForeignContent(this, token);
+        }
+    }
 
-    else if (token.type === Tokenizer.END_TAG_TOKEN)
-        endTagInForeignContent(this, token);
-};
+    _processInputToken(token) {
+        if (this._shouldProcessTokenInForeignContent(token)) {
+            this._processTokenInForeignContent(token);
+        } else {
+            this._processToken(token);
+        }
 
-Parser.prototype._processInputToken = function (token) {
-    if (this._shouldProcessTokenInForeignContent(token))
-        this._processTokenInForeignContent(token);
+        if (token.type === Tokenizer.START_TAG_TOKEN && token.selfClosing && !token.ackSelfClosing) {
+            this._err(ERR.nonVoidHtmlElementStartTagWithTrailingSolidus);
+        }
+    }
 
-    else
-        this._processToken(token);
-};
+    //Integration points
+    _isIntegrationPoint(element, foreignNS) {
+        const tn = this.treeAdapter.getTagName(element);
+        const ns = this.treeAdapter.getNamespaceURI(element);
+        const attrs = this.treeAdapter.getAttrList(element);
 
-//Integration points
-Parser.prototype._isIntegrationPoint = function (element, foreignNS) {
-    var tn = this.treeAdapter.getTagName(element),
-        ns = this.treeAdapter.getNamespaceURI(element),
-        attrs = this.treeAdapter.getAttrList(element);
+        return foreignContent.isIntegrationPoint(tn, ns, attrs, foreignNS);
+    }
 
-    return foreignContent.isIntegrationPoint(tn, ns, attrs, foreignNS);
-};
+    //Active formatting elements reconstruction
+    _reconstructActiveFormattingElements() {
+        const listLength = this.activeFormattingElements.length;
 
-//Active formatting elements reconstruction
-Parser.prototype._reconstructActiveFormattingElements = function () {
-    var listLength = this.activeFormattingElements.length;
+        if (listLength) {
+            let unopenIdx = listLength;
+            let entry = null;
 
-    if (listLength) {
-        var unopenIdx = listLength,
-            entry = null;
+            do {
+                unopenIdx--;
+                entry = this.activeFormattingElements.entries[unopenIdx];
 
-        do {
-            unopenIdx--;
-            entry = this.activeFormattingElements.entries[unopenIdx];
+                if (entry.type === FormattingElementList.MARKER_ENTRY || this.openElements.contains(entry.element)) {
+                    unopenIdx++;
+                    break;
+                }
+            } while (unopenIdx > 0);
 
-            if (entry.type === FormattingElementList.MARKER_ENTRY || this.openElements.contains(entry.element)) {
-                unopenIdx++;
-                break;
+            for (let i = unopenIdx; i < listLength; i++) {
+                entry = this.activeFormattingElements.entries[i];
+                this._insertElement(entry.token, this.treeAdapter.getNamespaceURI(entry.element));
+                entry.element = this.openElements.current;
             }
-        } while (unopenIdx > 0);
-
-        for (var i = unopenIdx; i < listLength; i++) {
-            entry = this.activeFormattingElements.entries[i];
-            this._insertElement(entry.token, this.treeAdapter.getNamespaceURI(entry.element));
-            entry.element = this.openElements.current;
         }
     }
-};
-
-//Close elements
-Parser.prototype._closeTableCell = function () {
-    this.openElements.generateImpliedEndTags();
-    this.openElements.popUntilTableCellPopped();
-    this.activeFormattingElements.clearToLastMarker();
-    this.insertionMode = IN_ROW_MODE;
-};
 
-Parser.prototype._closePElement = function () {
-    this.openElements.generateImpliedEndTagsWithExclusion($.P);
-    this.openElements.popUntilTagNamePopped($.P);
-};
-
-//Insertion modes
-Parser.prototype._resetInsertionMode = function () {
-    for (var i = this.openElements.stackTop, last = false; i >= 0; i--) {
-        var element = this.openElements.items[i];
-
-        if (i === 0) {
-            last = true;
+    //Close elements
+    _closeTableCell() {
+        this.openElements.generateImpliedEndTags();
+        this.openElements.popUntilTableCellPopped();
+        this.activeFormattingElements.clearToLastMarker();
+        this.insertionMode = IN_ROW_MODE;
+    }
 
-            if (this.fragmentContext)
-                element = this.fragmentContext;
-        }
+    _closePElement() {
+        this.openElements.generateImpliedEndTagsWithExclusion($.P);
+        this.openElements.popUntilTagNamePopped($.P);
+    }
 
-        var tn = this.treeAdapter.getTagName(element),
-            newInsertionMode = INSERTION_MODE_RESET_MAP[tn];
+    //Insertion modes
+    _resetInsertionMode() {
+        for (let i = this.openElements.stackTop, last = false; i >= 0; i--) {
+            let element = this.openElements.items[i];
 
-        if (newInsertionMode) {
-            this.insertionMode = newInsertionMode;
-            break;
-        }
+            if (i === 0) {
+                last = true;
 
-        else if (!last && (tn === $.TD || tn === $.TH)) {
-            this.insertionMode = IN_CELL_MODE;
-            break;
-        }
+                if (this.fragmentContext) {
+                    element = this.fragmentContext;
+                }
+            }
 
-        else if (!last && tn === $.HEAD) {
-            this.insertionMode = IN_HEAD_MODE;
-            break;
-        }
+            const tn = this.treeAdapter.getTagName(element);
+            const newInsertionMode = INSERTION_MODE_RESET_MAP[tn];
 
-        else if (tn === $.SELECT) {
-            this._resetInsertionModeForSelect(i);
-            break;
+            if (newInsertionMode) {
+                this.insertionMode = newInsertionMode;
+                break;
+            } else if (!last && (tn === $.TD || tn === $.TH)) {
+                this.insertionMode = IN_CELL_MODE;
+                break;
+            } else if (!last && tn === $.HEAD) {
+                this.insertionMode = IN_HEAD_MODE;
+                break;
+            } else if (tn === $.SELECT) {
+                this._resetInsertionModeForSelect(i);
+                break;
+            } else if (tn === $.TEMPLATE) {
+                this.insertionMode = this.currentTmplInsertionMode;
+                break;
+            } else if (tn === $.HTML) {
+                this.insertionMode = this.headElement ? AFTER_HEAD_MODE : BEFORE_HEAD_MODE;
+                break;
+            } else if (last) {
+                this.insertionMode = IN_BODY_MODE;
+                break;
+            }
         }
+    }
 
-        else if (tn === $.TEMPLATE) {
-            this.insertionMode = this.currentTmplInsertionMode;
-            break;
-        }
+    _resetInsertionModeForSelect(selectIdx) {
+        if (selectIdx > 0) {
+            for (let i = selectIdx - 1; i > 0; i--) {
+                const ancestor = this.openElements.items[i];
+                const tn = this.treeAdapter.getTagName(ancestor);
 
-        else if (tn === $.HTML) {
-            this.insertionMode = this.headElement ? AFTER_HEAD_MODE : BEFORE_HEAD_MODE;
-            break;
+                if (tn === $.TEMPLATE) {
+                    break;
+                } else if (tn === $.TABLE) {
+                    this.insertionMode = IN_SELECT_IN_TABLE_MODE;
+                    return;
+                }
+            }
         }
 
-        else if (last) {
-            this.insertionMode = IN_BODY_MODE;
-            break;
-        }
+        this.insertionMode = IN_SELECT_MODE;
     }
-};
 
-Parser.prototype._resetInsertionModeForSelect = function (selectIdx) {
-    if (selectIdx > 0) {
-        for (var i = selectIdx - 1; i > 0; i--) {
-            var ancestor = this.openElements.items[i],
-                tn = this.treeAdapter.getTagName(ancestor);
-
-            if (tn === $.TEMPLATE)
-                break;
+    _pushTmplInsertionMode(mode) {
+        this.tmplInsertionModeStack.push(mode);
+        this.tmplInsertionModeStackTop++;
+        this.currentTmplInsertionMode = mode;
+    }
 
-            else if (tn === $.TABLE) {
-                this.insertionMode = IN_SELECT_IN_TABLE_MODE;
-                return;
-            }
-        }
+    _popTmplInsertionMode() {
+        this.tmplInsertionModeStack.pop();
+        this.tmplInsertionModeStackTop--;
+        this.currentTmplInsertionMode = this.tmplInsertionModeStack[this.tmplInsertionModeStackTop];
     }
 
-    this.insertionMode = IN_SELECT_MODE;
-};
+    //Foster parenting
+    _isElementCausesFosterParenting(element) {
+        const tn = this.treeAdapter.getTagName(element);
 
-Parser.prototype._pushTmplInsertionMode = function (mode) {
-    this.tmplInsertionModeStack.push(mode);
-    this.tmplInsertionModeStackTop++;
-    this.currentTmplInsertionMode = mode;
-};
+        return tn === $.TABLE || tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD || tn === $.TR;
+    }
 
-Parser.prototype._popTmplInsertionMode = function () {
-    this.tmplInsertionModeStack.pop();
-    this.tmplInsertionModeStackTop--;
-    this.currentTmplInsertionMode = this.tmplInsertionModeStack[this.tmplInsertionModeStackTop];
-};
+    _shouldFosterParentOnInsertion() {
+        return this.fosterParentingEnabled && this._isElementCausesFosterParenting(this.openElements.current);
+    }
 
-//Foster parenting
-Parser.prototype._isElementCausesFosterParenting = function (element) {
-    var tn = this.treeAdapter.getTagName(element);
+    _findFosterParentingLocation() {
+        const location = {
+            parent: null,
+            beforeElement: null
+        };
 
-    return tn === $.TABLE || tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD || tn === $.TR;
-};
+        for (let i = this.openElements.stackTop; i >= 0; i--) {
+            const openElement = this.openElements.items[i];
+            const tn = this.treeAdapter.getTagName(openElement);
+            const ns = this.treeAdapter.getNamespaceURI(openElement);
 
-Parser.prototype._shouldFosterParentOnInsertion = function () {
-    return this.fosterParentingEnabled && this._isElementCausesFosterParenting(this.openElements.current);
-};
+            if (tn === $.TEMPLATE && ns === NS.HTML) {
+                location.parent = this.treeAdapter.getTemplateContent(openElement);
+                break;
+            } else if (tn === $.TABLE) {
+                location.parent = this.treeAdapter.getParentNode(openElement);
 
-Parser.prototype._findFosterParentingLocation = function () {
-    var location = {
-        parent: null,
-        beforeElement: null
-    };
+                if (location.parent) {
+                    location.beforeElement = openElement;
+                } else {
+                    location.parent = this.openElements.items[i - 1];
+                }
 
-    for (var i = this.openElements.stackTop; i >= 0; i--) {
-        var openElement = this.openElements.items[i],
-            tn = this.treeAdapter.getTagName(openElement),
-            ns = this.treeAdapter.getNamespaceURI(openElement);
+                break;
+            }
+        }
 
-        if (tn === $.TEMPLATE && ns === NS.HTML) {
-            location.parent = this.treeAdapter.getTemplateContent(openElement);
-            break;
+        if (!location.parent) {
+            location.parent = this.openElements.items[0];
         }
 
-        else if (tn === $.TABLE) {
-            location.parent = this.treeAdapter.getParentNode(openElement);
+        return location;
+    }
 
-            if (location.parent)
-                location.beforeElement = openElement;
-            else
-                location.parent = this.openElements.items[i - 1];
+    _fosterParentElement(element) {
+        const location = this._findFosterParentingLocation();
 
-            break;
+        if (location.beforeElement) {
+            this.treeAdapter.insertBefore(location.parent, element, location.beforeElement);
+        } else {
+            this.treeAdapter.appendChild(location.parent, element);
         }
     }
 
-    if (!location.parent)
-        location.parent = this.openElements.items[0];
-
-    return location;
-};
-
-Parser.prototype._fosterParentElement = function (element) {
-    var location = this._findFosterParentingLocation();
+    _fosterParentText(chars) {
+        const location = this._findFosterParentingLocation();
 
-    if (location.beforeElement)
-        this.treeAdapter.insertBefore(location.parent, element, location.beforeElement);
-    else
-        this.treeAdapter.appendChild(location.parent, element);
-};
-
-Parser.prototype._fosterParentText = function (chars) {
-    var location = this._findFosterParentingLocation();
+        if (location.beforeElement) {
+            this.treeAdapter.insertTextBefore(location.parent, chars, location.beforeElement);
+        } else {
+            this.treeAdapter.insertText(location.parent, chars);
+        }
+    }
 
-    if (location.beforeElement)
-        this.treeAdapter.insertTextBefore(location.parent, chars, location.beforeElement);
-    else
-        this.treeAdapter.insertText(location.parent, chars);
-};
+    //Special elements
+    _isSpecialElement(element) {
+        const tn = this.treeAdapter.getTagName(element);
+        const ns = this.treeAdapter.getNamespaceURI(element);
 
-//Special elements
-Parser.prototype._isSpecialElement = function (element) {
-    var tn = this.treeAdapter.getTagName(element),
-        ns = this.treeAdapter.getNamespaceURI(element);
+        return HTML.SPECIAL_ELEMENTS[ns][tn];
+    }
+}
 
-    return HTML.SPECIAL_ELEMENTS[ns][tn];
-};
+module.exports = Parser;
 
 //Adoption agency algorithm
 //(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#adoptionAgency)
@@ -847,36 +890,36 @@ Parser.prototype._isSpecialElement = function (element) {
 
 //Steps 5-8 of the algorithm
 function aaObtainFormattingElementEntry(p, token) {
-    var formattingElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(token.tagName);
+    let formattingElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(token.tagName);
 
     if (formattingElementEntry) {
         if (!p.openElements.contains(formattingElementEntry.element)) {
             p.activeFormattingElements.removeEntry(formattingElementEntry);
             formattingElementEntry = null;
-        }
-
-        else if (!p.openElements.hasInScope(token.tagName))
+        } else if (!p.openElements.hasInScope(token.tagName)) {
             formattingElementEntry = null;
-    }
-
-    else
+        }
+    } else {
         genericEndTagInBody(p, token);
+    }
 
     return formattingElementEntry;
 }
 
 //Steps 9 and 10 of the algorithm
 function aaObtainFurthestBlock(p, formattingElementEntry) {
-    var furthestBlock = null;
+    let furthestBlock = null;
 
-    for (var i = p.openElements.stackTop; i >= 0; i--) {
-        var element = p.openElements.items[i];
+    for (let i = p.openElements.stackTop; i >= 0; i--) {
+        const element = p.openElements.items[i];
 
-        if (element === formattingElementEntry.element)
+        if (element === formattingElementEntry.element) {
             break;
+        }
 
-        if (p._isSpecialElement(element))
+        if (p._isSpecialElement(element)) {
             furthestBlock = element;
+        }
     }
 
     if (!furthestBlock) {
@@ -889,29 +932,29 @@ function aaObtainFurthestBlock(p, formattingElementEntry) {
 
 //Step 13 of the algorithm
 function aaInnerLoop(p, furthestBlock, formattingElement) {
-    var lastElement = furthestBlock,
-        nextElement = p.openElements.getCommonAncestor(furthestBlock);
+    let lastElement = furthestBlock;
+    let nextElement = p.openElements.getCommonAncestor(furthestBlock);
 
-    for (var i = 0, element = nextElement; element !== formattingElement; i++, element = nextElement) {
+    for (let i = 0, element = nextElement; element !== formattingElement; i++, element = nextElement) {
         //NOTE: store next element for the next loop iteration (it may be deleted from the stack by step 9.5)
         nextElement = p.openElements.getCommonAncestor(element);
 
-        var elementEntry = p.activeFormattingElements.getElementEntry(element),
-            counterOverflow = elementEntry && i >= AA_INNER_LOOP_ITER,
-            shouldRemoveFromOpenElements = !elementEntry || counterOverflow;
+        const elementEntry = p.activeFormattingElements.getElementEntry(element);
+        const counterOverflow = elementEntry && i >= AA_INNER_LOOP_ITER;
+        const shouldRemoveFromOpenElements = !elementEntry || counterOverflow;
 
         if (shouldRemoveFromOpenElements) {
-            if (counterOverflow)
+            if (counterOverflow) {
                 p.activeFormattingElements.removeEntry(elementEntry);
+            }
 
             p.openElements.remove(element);
-        }
-
-        else {
+        } else {
             element = aaRecreateElementFromEntry(p, elementEntry);
 
-            if (lastElement === furthestBlock)
+            if (lastElement === furthestBlock) {
                 p.activeFormattingElements.bookmark = elementEntry;
+            }
 
             p.treeAdapter.detachNode(lastElement);
             p.treeAdapter.appendChild(element, lastElement);
@@ -924,8 +967,8 @@ function aaInnerLoop(p, furthestBlock, formattingElement) {
 
 //Step 13.7 of the algorithm
 function aaRecreateElementFromEntry(p, elementEntry) {
-    var ns = p.treeAdapter.getNamespaceURI(elementEntry.element),
-        newElement = p.treeAdapter.createElement(elementEntry.token.tagName, ns, elementEntry.token.attrs);
+    const ns = p.treeAdapter.getNamespaceURI(elementEntry.element);
+    const newElement = p.treeAdapter.createElement(elementEntry.token.tagName, ns, elementEntry.token.attrs);
 
     p.openElements.replace(elementEntry.element, newElement);
     elementEntry.element = newElement;
@@ -935,15 +978,15 @@ function aaRecreateElementFromEntry(p, elementEntry) {
 
 //Step 14 of the algorithm
 function aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement) {
-    if (p._isElementCausesFosterParenting(commonAncestor))
+    if (p._isElementCausesFosterParenting(commonAncestor)) {
         p._fosterParentElement(lastElement);
+    } else {
+        const tn = p.treeAdapter.getTagName(commonAncestor);
+        const ns = p.treeAdapter.getNamespaceURI(commonAncestor);
 
-    else {
-        var tn = p.treeAdapter.getTagName(commonAncestor),
-            ns = p.treeAdapter.getNamespaceURI(commonAncestor);
-
-        if (tn === $.TEMPLATE && ns === NS.HTML)
+        if (tn === $.TEMPLATE && ns === NS.HTML) {
             commonAncestor = p.treeAdapter.getTemplateContent(commonAncestor);
+        }
 
         p.treeAdapter.appendChild(commonAncestor, lastElement);
     }
@@ -951,9 +994,9 @@ function aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement) {
 
 //Steps 15-19 of the algorithm
 function aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry) {
-    var ns = p.treeAdapter.getNamespaceURI(formattingElementEntry.element),
-        token = formattingElementEntry.token,
-        newElement = p.treeAdapter.createElement(token.tagName, ns, token.attrs);
+    const ns = p.treeAdapter.getNamespaceURI(formattingElementEntry.element);
+    const token = formattingElementEntry.token;
+    const newElement = p.treeAdapter.createElement(token.tagName, ns, token.attrs);
 
     p._adoptNodes(furthestBlock, newElement);
     p.treeAdapter.appendChild(furthestBlock, newElement);
@@ -967,23 +1010,25 @@ function aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry) {
 
 //Algorithm entry point
 function callAdoptionAgency(p, token) {
-    var formattingElementEntry;
+    let formattingElementEntry;
 
-    for (var i = 0; i < AA_OUTER_LOOP_ITER; i++) {
+    for (let i = 0; i < AA_OUTER_LOOP_ITER; i++) {
         formattingElementEntry = aaObtainFormattingElementEntry(p, token, formattingElementEntry);
 
-        if (!formattingElementEntry)
+        if (!formattingElementEntry) {
             break;
+        }
 
-        var furthestBlock = aaObtainFurthestBlock(p, formattingElementEntry);
+        const furthestBlock = aaObtainFurthestBlock(p, formattingElementEntry);
 
-        if (!furthestBlock)
+        if (!furthestBlock) {
             break;
+        }
 
         p.activeFormattingElements.bookmark = formattingElementEntry;
 
-        var lastElement = aaInnerLoop(p, furthestBlock, formattingElementEntry.element),
-            commonAncestor = p.openElements.getCommonAncestor(formattingElementEntry.element);
+        const lastElement = aaInnerLoop(p, furthestBlock, formattingElementEntry.element);
+        const commonAncestor = p.openElements.getCommonAncestor(formattingElementEntry.element);
 
         p.treeAdapter.detachNode(lastElement);
         aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement);
@@ -991,13 +1036,16 @@ function callAdoptionAgency(p, token) {
     }
 }
 
-
 //Generic token handlers
 //------------------------------------------------------------------
 function ignoreToken() {
     //NOTE: do nothing =)
 }
 
+function misplacedDoctype(p) {
+    p._err(ERR.misplacedDoctype);
+}
+
 function appendComment(p, token) {
     p._appendCommentNode(token, p.openElements.currentTmplContent || p.openElements.current);
 }
@@ -1018,14 +1066,16 @@ function stopParsing(p) {
     p.stopped = true;
 }
 
-//12.2.5.4.1 The "initial" insertion mode
+// The "initial" insertion mode
 //------------------------------------------------------------------
 function doctypeInInitialMode(p, token) {
     p._setDocumentType(token);
 
-    var mode = token.forceQuirks ?
-        HTML.DOCUMENT_MODE.QUIRKS :
-        doctype.getDocumentMode(token.name, token.publicId, token.systemId);
+    const mode = token.forceQuirks ? HTML.DOCUMENT_MODE.QUIRKS : doctype.getDocumentMode(token);
+
+    if (!doctype.isConforming(token)) {
+        p._err(ERR.nonConformingDoctype);
+    }
 
     p.treeAdapter.setDocumentMode(p.document, mode);
 
@@ -1033,29 +1083,29 @@ function doctypeInInitialMode(p, token) {
 }
 
 function tokenInInitialMode(p, token) {
+    p._err(ERR.missingDoctype, { beforeToken: true });
     p.treeAdapter.setDocumentMode(p.document, HTML.DOCUMENT_MODE.QUIRKS);
     p.insertionMode = BEFORE_HTML_MODE;
     p._processToken(token);
 }
 
-
-//12.2.5.4.2 The "before html" insertion mode
+// The "before html" insertion mode
 //------------------------------------------------------------------
 function startTagBeforeHtml(p, token) {
     if (token.tagName === $.HTML) {
         p._insertElement(token, NS.HTML);
         p.insertionMode = BEFORE_HEAD_MODE;
-    }
-
-    else
+    } else {
         tokenBeforeHtml(p, token);
+    }
 }
 
 function endTagBeforeHtml(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
-    if (tn === $.HTML || tn === $.HEAD || tn === $.BODY || tn === $.BR)
+    if (tn === $.HTML || tn === $.HEAD || tn === $.BODY || tn === $.BR) {
         tokenBeforeHtml(p, token);
+    }
 }
 
 function tokenBeforeHtml(p, token) {
@@ -1064,30 +1114,30 @@ function tokenBeforeHtml(p, token) {
     p._processToken(token);
 }
 
-
-//12.2.5.4.3 The "before head" insertion mode
+// The "before head" insertion mode
 //------------------------------------------------------------------
 function startTagBeforeHead(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
-    if (tn === $.HTML)
+    if (tn === $.HTML) {
         startTagInBody(p, token);
-
-    else if (tn === $.HEAD) {
+    } else if (tn === $.HEAD) {
         p._insertElement(token, NS.HTML);
         p.headElement = p.openElements.current;
         p.insertionMode = IN_HEAD_MODE;
-    }
-
-    else
+    } else {
         tokenBeforeHead(p, token);
+    }
 }
 
 function endTagBeforeHead(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
-    if (tn === $.HEAD || tn === $.BODY || tn === $.HTML || tn === $.BR)
+    if (tn === $.HEAD || tn === $.BODY || tn === $.HTML || tn === $.BR) {
         tokenBeforeHead(p, token);
+    } else {
+        p._err(ERR.endTagWithoutMatchingOpenElement);
+    }
 }
 
 function tokenBeforeHead(p, token) {
@@ -1097,58 +1147,67 @@ function tokenBeforeHead(p, token) {
     p._processToken(token);
 }
 
-
-//12.2.5.4.4 The "in head" insertion mode
+// The "in head" insertion mode
 //------------------------------------------------------------------
 function startTagInHead(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
-    if (tn === $.HTML)
+    if (tn === $.HTML) {
         startTagInBody(p, token);
-
-    else if (tn === $.BASE || tn === $.BASEFONT || tn === $.BGSOUND || tn === $.LINK || tn === $.META)
+    } else if (tn === $.BASE || tn === $.BASEFONT || tn === $.BGSOUND || tn === $.LINK || tn === $.META) {
         p._appendElement(token, NS.HTML);
-
-    else if (tn === $.TITLE)
+        token.ackSelfClosing = true;
+    } else if (tn === $.TITLE) {
         p._switchToTextParsing(token, Tokenizer.MODE.RCDATA);
-
-    //NOTE: here we assume that we always act as an interactive user agent with enabled scripting, so we parse
-    //<noscript> as a rawtext.
-    else if (tn === $.NOSCRIPT || tn === $.NOFRAMES || tn === $.STYLE)
+    } else if (tn === $.NOSCRIPT) {
+        if (p.options.scriptingEnabled) {
+            p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);
+        } else {
+            p._insertElement(token, NS.HTML);
+            p.insertionMode = IN_HEAD_NO_SCRIPT_MODE;
+        }
+    } else if (tn === $.NOFRAMES || tn === $.STYLE) {
         p._switchToTextParsing(token, Tokenizer.MODE.RAWTEXT);
-
-    else if (tn === $.SCRIPT)
+    } else if (tn === $.SCRIPT) {
         p._switchToTextParsing(token, Tokenizer.MODE.SCRIPT_DATA);
-
-    else if (tn === $.TEMPLATE) {
+    } else if (tn === $.TEMPLATE) {
         p._insertTemplate(token, NS.HTML);
         p.activeFormattingElements.insertMarker();
         p.framesetOk = false;
         p.insertionMode = IN_TEMPLATE_MODE;
         p._pushTmplInsertionMode(IN_TEMPLATE_MODE);
-    }
-
-    else if (tn !== $.HEAD)
+    } else if (tn === $.HEAD) {
+        p._err(ERR.misplacedStartTagForHeadElement);
+    } else {
         tokenInHead(p, token);
+    }
 }
 
 function endTagInHead(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     if (tn === $.HEAD) {
         p.openElements.pop();
         p.insertionMode = AFTER_HEAD_MODE;
-    }
-
-    else if (tn === $.BODY || tn === $.BR || tn === $.HTML)
+    } else if (tn === $.BODY || tn === $.BR || tn === $.HTML) {
         tokenInHead(p, token);
+    } else if (tn === $.TEMPLATE) {
+        if (p.openElements.tmplCount > 0) {
+            p.openElements.generateImpliedEndTagsThoroughly();
 
-    else if (tn === $.TEMPLATE && p.openElements.tmplCount > 0) {
-        p.openElements.generateImpliedEndTags();
-        p.openElements.popUntilTagNamePopped($.TEMPLATE);
-        p.activeFormattingElements.clearToLastMarker();
-        p._popTmplInsertionMode();
-        p._resetInsertionMode();
+            if (p.openElements.currentTagName !== $.TEMPLATE) {
+                p._err(ERR.closingOfElementWithOpenChildElements);
+            }
+
+            p.openElements.popUntilTagNamePopped($.TEMPLATE);
+            p.activeFormattingElements.clearToLastMarker();
+            p._popTmplInsertionMode();
+            p._resetInsertionMode();
+        } else {
+            p._err(ERR.endTagWithoutMatchingOpenElement);
+        }
+    } else {
+        p._err(ERR.endTagWithoutMatchingOpenElement);
     }
 }
 
@@ -1158,45 +1217,100 @@ function tokenInHead(p, token) {
     p._processToken(token);
 }
 
+// The "in head no script" insertion mode
+//------------------------------------------------------------------
+function startTagInHeadNoScript(p, token) {
+    const tn = token.tagName;
+
+    if (tn === $.HTML) {
+        startTagInBody(p, token);
+    } else if (
+        tn === $.BASEFONT ||
+        tn === $.BGSOUND ||
+        tn === $.HEAD ||
+        tn === $.LINK ||
+        tn === $.META ||
+        tn === $.NOFRAMES ||
+        tn === $.STYLE
+    ) {
+        startTagInHead(p, token);
+    } else if (tn === $.NOSCRIPT) {
+        p._err(ERR.nestedNoscriptInHead);
+    } else {
+        tokenInHeadNoScript(p, token);
+    }
+}
+
+function endTagInHeadNoScript(p, token) {
+    const tn = token.tagName;
 
-//12.2.5.4.6 The "after head" insertion mode
+    if (tn === $.NOSCRIPT) {
+        p.openElements.pop();
+        p.insertionMode = IN_HEAD_MODE;
+    } else if (tn === $.BR) {
+        tokenInHeadNoScript(p, token);
+    } else {
+        p._err(ERR.endTagWithoutMatchingOpenElement);
+    }
+}
+
+function tokenInHeadNoScript(p, token) {
+    const errCode =
+        token.type === Tokenizer.EOF_TOKEN ? ERR.openElementsLeftAfterEof : ERR.disallowedContentInNoscriptInHead;
+
+    p._err(errCode);
+    p.openElements.pop();
+    p.insertionMode = IN_HEAD_MODE;
+    p._processToken(token);
+}
+
+// The "after head" insertion mode
 //------------------------------------------------------------------
 function startTagAfterHead(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
-    if (tn === $.HTML)
+    if (tn === $.HTML) {
         startTagInBody(p, token);
-
-    else if (tn === $.BODY) {
+    } else if (tn === $.BODY) {
         p._insertElement(token, NS.HTML);
         p.framesetOk = false;
         p.insertionMode = IN_BODY_MODE;
-    }
-
-    else if (tn === $.FRAMESET) {
+    } else if (tn === $.FRAMESET) {
         p._insertElement(token, NS.HTML);
         p.insertionMode = IN_FRAMESET_MODE;
-    }
-
-    else if (tn === $.BASE || tn === $.BASEFONT || tn === $.BGSOUND || tn === $.LINK || tn === $.META ||
-             tn === $.NOFRAMES || tn === $.SCRIPT || tn === $.STYLE || tn === $.TEMPLATE || tn === $.TITLE) {
+    } else if (
+        tn === $.BASE ||
+        tn === $.BASEFONT ||
+        tn === $.BGSOUND ||
+        tn === $.LINK ||
+        tn === $.META ||
+        tn === $.NOFRAMES ||
+        tn === $.SCRIPT ||
+        tn === $.STYLE ||
+        tn === $.TEMPLATE ||
+        tn === $.TITLE
+    ) {
+        p._err(ERR.abandonedHeadElementChild);
         p.openElements.push(p.headElement);
         startTagInHead(p, token);
         p.openElements.remove(p.headElement);
-    }
-
-    else if (tn !== $.HEAD)
+    } else if (tn === $.HEAD) {
+        p._err(ERR.misplacedStartTagForHeadElement);
+    } else {
         tokenAfterHead(p, token);
+    }
 }
 
 function endTagAfterHead(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
-    if (tn === $.BODY || tn === $.HTML || tn === $.BR)
+    if (tn === $.BODY || tn === $.HTML || tn === $.BR) {
         tokenAfterHead(p, token);
-
-    else if (tn === $.TEMPLATE)
+    } else if (tn === $.TEMPLATE) {
         endTagInHead(p, token);
+    } else {
+        p._err(ERR.endTagWithoutMatchingOpenElement);
+    }
 }
 
 function tokenAfterHead(p, token) {
@@ -1205,8 +1319,7 @@ function tokenAfterHead(p, token) {
     p._processToken(token);
 }
 
-
-//12.2.5.4.7 The "in body" insertion mode
+// The "in body" insertion mode
 //------------------------------------------------------------------
 function whitespaceCharacterInBody(p, token) {
     p._reconstructActiveFormattingElements();
@@ -1220,12 +1333,13 @@ function characterInBody(p, token) {
 }
 
 function htmlStartTagInBody(p, token) {
-    if (p.openElements.tmplCount === 0)
+    if (p.openElements.tmplCount === 0) {
         p.treeAdapter.adoptAttributes(p.openElements.items[0], token.attrs);
+    }
 }
 
 function bodyStartTagInBody(p, token) {
-    var bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
+    const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
 
     if (bodyElement && p.openElements.tmplCount === 0) {
         p.framesetOk = false;
@@ -1234,7 +1348,7 @@ function bodyStartTagInBody(p, token) {
 }
 
 function framesetStartTagInBody(p, token) {
-    var bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
+    const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
 
     if (p.framesetOk && bodyElement) {
         p.treeAdapter.detachNode(bodyElement);
@@ -1245,27 +1359,31 @@ function framesetStartTagInBody(p, token) {
 }
 
 function addressStartTagInBody(p, token) {
-    if (p.openElements.hasInButtonScope($.P))
+    if (p.openElements.hasInButtonScope($.P)) {
         p._closePElement();
+    }
 
     p._insertElement(token, NS.HTML);
 }
 
 function numberedHeaderStartTagInBody(p, token) {
-    if (p.openElements.hasInButtonScope($.P))
+    if (p.openElements.hasInButtonScope($.P)) {
         p._closePElement();
+    }
 
-    var tn = p.openElements.currentTagName;
+    const tn = p.openElements.currentTagName;
 
-    if (tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6)
+    if (tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6) {
         p.openElements.pop();
+    }
 
     p._insertElement(token, NS.HTML);
 }
 
 function preStartTagInBody(p, token) {
-    if (p.openElements.hasInButtonScope($.P))
+    if (p.openElements.hasInButtonScope($.P)) {
         p._closePElement();
+    }
 
     p._insertElement(token, NS.HTML);
     //NOTE: If the next token is a U+000A LINE FEED (LF) character token, then ignore that token and move
@@ -1275,34 +1393,36 @@ function preStartTagInBody(p, token) {
 }
 
 function formStartTagInBody(p, token) {
-    var inTemplate = p.openElements.tmplCount > 0;
+    const inTemplate = p.openElements.tmplCount > 0;
 
     if (!p.formElement || inTemplate) {
-        if (p.openElements.hasInButtonScope($.P))
+        if (p.openElements.hasInButtonScope($.P)) {
             p._closePElement();
+        }
 
         p._insertElement(token, NS.HTML);
 
-        if (!inTemplate)
+        if (!inTemplate) {
             p.formElement = p.openElements.current;
+        }
     }
 }
 
 function listItemStartTagInBody(p, token) {
     p.framesetOk = false;
 
-    var tn = token.tagName;
+    const tn = token.tagName;
 
-    for (var i = p.openElements.stackTop; i >= 0; i--) {
-        var element = p.openElements.items[i],
-            elementTn = p.treeAdapter.getTagName(element),
-            closeTn = null;
+    for (let i = p.openElements.stackTop; i >= 0; i--) {
+        const element = p.openElements.items[i];
+        const elementTn = p.treeAdapter.getTagName(element);
+        let closeTn = null;
 
-        if (tn === $.LI && elementTn === $.LI)
+        if (tn === $.LI && elementTn === $.LI) {
             closeTn = $.LI;
-
-        else if ((tn === $.DD || tn === $.DT) && (elementTn === $.DD || elementTn === $.DT))
+        } else if ((tn === $.DD || tn === $.DT) && (elementTn === $.DD || elementTn === $.DT)) {
             closeTn = elementTn;
+        }
 
         if (closeTn) {
             p.openElements.generateImpliedEndTagsWithExclusion(closeTn);
@@ -1310,19 +1430,22 @@ function listItemStartTagInBody(p, token) {
             break;
         }
 
-        if (elementTn !== $.ADDRESS && elementTn !== $.DIV && elementTn !== $.P && p._isSpecialElement(element))
+        if (elementTn !== $.ADDRESS && elementTn !== $.DIV && elementTn !== $.P && p._isSpecialElement(element)) {
             break;
+        }
     }
 
-    if (p.openElements.hasInButtonScope($.P))
+    if (p.openElements.hasInButtonScope($.P)) {
         p._closePElement();
+    }
 
     p._insertElement(token, NS.HTML);
 }
 
 function plaintextStartTagInBody(p, token) {
-    if (p.openElements.hasInButtonScope($.P))
+    if (p.openElements.hasInButtonScope($.P)) {
         p._closePElement();
+    }
 
     p._insertElement(token, NS.HTML);
     p.tokenizer.state = Tokenizer.MODE.PLAINTEXT;
@@ -1340,7 +1463,7 @@ function buttonStartTagInBody(p, token) {
 }
 
 function aStartTagInBody(p, token) {
-    var activeElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName($.A);
+    const activeElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName($.A);
 
     if (activeElementEntry) {
         callAdoptionAgency(p, token);
@@ -1379,8 +1502,12 @@ function appletStartTagInBody(p, token) {
 }
 
 function tableStartTagInBody(p, token) {
-    if (p.treeAdapter.getDocumentMode(p.document) !== HTML.DOCUMENT_MODE.QUIRKS && p.openElements.hasInButtonScope($.P))
+    if (
+        p.treeAdapter.getDocumentMode(p.document) !== HTML.DOCUMENT_MODE.QUIRKS &&
+        p.openElements.hasInButtonScope($.P)
+    ) {
         p._closePElement();
+    }
 
     p._insertElement(token, NS.HTML);
     p.framesetOk = false;
@@ -1391,32 +1518,35 @@ function areaStartTagInBody(p, token) {
     p._reconstructActiveFormattingElements();
     p._appendElement(token, NS.HTML);
     p.framesetOk = false;
+    token.ackSelfClosing = true;
 }
 
 function inputStartTagInBody(p, token) {
     p._reconstructActiveFormattingElements();
     p._appendElement(token, NS.HTML);
 
-    var inputType = Tokenizer.getTokenAttr(token, ATTRS.TYPE);
+    const inputType = Tokenizer.getTokenAttr(token, ATTRS.TYPE);
 
-    if (!inputType || inputType.toLowerCase() !== HIDDEN_INPUT_TYPE)
+    if (!inputType || inputType.toLowerCase() !== HIDDEN_INPUT_TYPE) {
         p.framesetOk = false;
+    }
 
+    token.ackSelfClosing = true;
 }
 
 function paramStartTagInBody(p, token) {
     p._appendElement(token, NS.HTML);
+    token.ackSelfClosing = true;
 }
 
 function hrStartTagInBody(p, token) {
-    if (p.openElements.hasInButtonScope($.P))
+    if (p.openElements.hasInButtonScope($.P)) {
         p._closePElement();
-
-    if (p.openElements.currentTagName === $.MENUITEM)
-        p.openElements.pop();
+    }
 
     p._appendElement(token, NS.HTML);
     p.framesetOk = false;
+    p.ackSelfClosing = true;
 }
 
 function imageStartTagInBody(p, token) {
@@ -1436,8 +1566,9 @@ function textareaStartTagInBody(p, token) {
 }
 
 function xmpStartTagInBody(p, token) {
-    if (p.openElements.hasInButtonScope($.P))
+    if (p.openElements.hasInButtonScope($.P)) {
         p._closePElement();
+    }
 
     p._reconstructActiveFormattingElements();
     p.framesetOk = false;
@@ -1460,56 +1591,48 @@ function selectStartTagInBody(p, token) {
     p._insertElement(token, NS.HTML);
     p.framesetOk = false;
 
-    if (p.insertionMode === IN_TABLE_MODE ||
+    if (
+        p.insertionMode === IN_TABLE_MODE ||
         p.insertionMode === IN_CAPTION_MODE ||
         p.insertionMode === IN_TABLE_BODY_MODE ||
         p.insertionMode === IN_ROW_MODE ||
-        p.insertionMode === IN_CELL_MODE)
-
+        p.insertionMode === IN_CELL_MODE
+    ) {
         p.insertionMode = IN_SELECT_IN_TABLE_MODE;
-
-    else
+    } else {
         p.insertionMode = IN_SELECT_MODE;
+    }
 }
 
 function optgroupStartTagInBody(p, token) {
-    if (p.openElements.currentTagName === $.OPTION)
+    if (p.openElements.currentTagName === $.OPTION) {
         p.openElements.pop();
+    }
 
     p._reconstructActiveFormattingElements();
     p._insertElement(token, NS.HTML);
 }
 
 function rbStartTagInBody(p, token) {
-    if (p.openElements.hasInScope($.RUBY))
+    if (p.openElements.hasInScope($.RUBY)) {
         p.openElements.generateImpliedEndTags();
+    }
 
     p._insertElement(token, NS.HTML);
 }
 
 function rtStartTagInBody(p, token) {
-    if (p.openElements.hasInScope($.RUBY))
+    if (p.openElements.hasInScope($.RUBY)) {
         p.openElements.generateImpliedEndTagsWithExclusion($.RTC);
-
-    p._insertElement(token, NS.HTML);
-}
-
-function menuitemStartTagInBody(p, token) {
-    if (p.openElements.currentTagName === $.MENUITEM)
-        p.openElements.pop();
-
-    // TODO needs clarification, see https://github.com/whatwg/html/pull/907/files#r73505877
-    p._reconstructActiveFormattingElements();
+    }
 
     p._insertElement(token, NS.HTML);
 }
 
 function menuStartTagInBody(p, token) {
-    if (p.openElements.hasInButtonScope($.P))
+    if (p.openElements.hasInButtonScope($.P)) {
         p._closePElement();
-
-    if (p.openElements.currentTagName === $.MENUITEM)
-        p.openElements.pop();
+    }
 
     p._insertElement(token, NS.HTML);
 }
@@ -1520,10 +1643,13 @@ function mathStartTagInBody(p, token) {
     foreignContent.adjustTokenMathMLAttrs(token);
     foreignContent.adjustTokenXMLAttrs(token);
 
-    if (token.selfClosing)
+    if (token.selfClosing) {
         p._appendElement(token, NS.MATHML);
-    else
+    } else {
         p._insertElement(token, NS.MATHML);
+    }
+
+    token.ackSelfClosing = true;
 }
 
 function svgStartTagInBody(p, token) {
@@ -1532,10 +1658,13 @@ function svgStartTagInBody(p, token) {
     foreignContent.adjustTokenSVGAttrs(token);
     foreignContent.adjustTokenXMLAttrs(token);
 
-    if (token.selfClosing)
+    if (token.selfClosing) {
         p._appendElement(token, NS.SVG);
-    else
+    } else {
         p._insertElement(token, NS.SVG);
+    }
+
+    token.ackSelfClosing = true;
 }
 
 function genericStartTagInBody(p, token) {
@@ -1546,249 +1675,213 @@ function genericStartTagInBody(p, token) {
 //OPTIMIZATION: Integer comparisons are low-cost, so we can use very fast tag name length filters here.
 //It's faster than using dictionary.
 function startTagInBody(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     switch (tn.length) {
         case 1:
-            if (tn === $.I || tn === $.S || tn === $.B || tn === $.U)
+            if (tn === $.I || tn === $.S || tn === $.B || tn === $.U) {
                 bStartTagInBody(p, token);
-
-            else if (tn === $.P)
+            } else if (tn === $.P) {
                 addressStartTagInBody(p, token);
-
-            else if (tn === $.A)
+            } else if (tn === $.A) {
                 aStartTagInBody(p, token);
-
-            else
+            } else {
                 genericStartTagInBody(p, token);
+            }
 
             break;
 
         case 2:
-            if (tn === $.DL || tn === $.OL || tn === $.UL)
+            if (tn === $.DL || tn === $.OL || tn === $.UL) {
                 addressStartTagInBody(p, token);
-
-            else if (tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6)
+            } else if (tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6) {
                 numberedHeaderStartTagInBody(p, token);
-
-            else if (tn === $.LI || tn === $.DD || tn === $.DT)
+            } else if (tn === $.LI || tn === $.DD || tn === $.DT) {
                 listItemStartTagInBody(p, token);
-
-            else if (tn === $.EM || tn === $.TT)
+            } else if (tn === $.EM || tn === $.TT) {
                 bStartTagInBody(p, token);
-
-            else if (tn === $.BR)
+            } else if (tn === $.BR) {
                 areaStartTagInBody(p, token);
-
-            else if (tn === $.HR)
+            } else if (tn === $.HR) {
                 hrStartTagInBody(p, token);
-
-            else if (tn === $.RB)
+            } else if (tn === $.RB) {
                 rbStartTagInBody(p, token);
-
-            else if (tn === $.RT || tn === $.RP)
+            } else if (tn === $.RT || tn === $.RP) {
                 rtStartTagInBody(p, token);
-
-            else if (tn !== $.TH && tn !== $.TD && tn !== $.TR)
+            } else if (tn !== $.TH && tn !== $.TD && tn !== $.TR) {
                 genericStartTagInBody(p, token);
+            }
 
             break;
 
         case 3:
-            if (tn === $.DIV || tn === $.DIR || tn === $.NAV)
+            if (tn === $.DIV || tn === $.DIR || tn === $.NAV) {
                 addressStartTagInBody(p, token);
-
-            else if (tn === $.PRE)
+            } else if (tn === $.PRE) {
                 preStartTagInBody(p, token);
-
-            else if (tn === $.BIG)
+            } else if (tn === $.BIG) {
                 bStartTagInBody(p, token);
-
-            else if (tn === $.IMG || tn === $.WBR)
+            } else if (tn === $.IMG || tn === $.WBR) {
                 areaStartTagInBody(p, token);
-
-            else if (tn === $.XMP)
+            } else if (tn === $.XMP) {
                 xmpStartTagInBody(p, token);
-
-            else if (tn === $.SVG)
+            } else if (tn === $.SVG) {
                 svgStartTagInBody(p, token);
-
-            else if (tn === $.RTC)
+            } else if (tn === $.RTC) {
                 rbStartTagInBody(p, token);
-
-            else if (tn !== $.COL)
+            } else if (tn !== $.COL) {
                 genericStartTagInBody(p, token);
+            }
 
             break;
 
         case 4:
-            if (tn === $.HTML)
+            if (tn === $.HTML) {
                 htmlStartTagInBody(p, token);
-
-            else if (tn === $.BASE || tn === $.LINK || tn === $.META)
+            } else if (tn === $.BASE || tn === $.LINK || tn === $.META) {
                 startTagInHead(p, token);
-
-            else if (tn === $.BODY)
+            } else if (tn === $.BODY) {
                 bodyStartTagInBody(p, token);
-
-            else if (tn === $.MAIN)
+            } else if (tn === $.MAIN || tn === $.MENU) {
                 addressStartTagInBody(p, token);
-
-            else if (tn === $.FORM)
+            } else if (tn === $.FORM) {
                 formStartTagInBody(p, token);
-
-            else if (tn === $.CODE || tn === $.FONT)
+            } else if (tn === $.CODE || tn === $.FONT) {
                 bStartTagInBody(p, token);
-
-            else if (tn === $.NOBR)
+            } else if (tn === $.NOBR) {
                 nobrStartTagInBody(p, token);
-
-            else if (tn === $.AREA)
+            } else if (tn === $.AREA) {
                 areaStartTagInBody(p, token);
-
-            else if (tn === $.MATH)
+            } else if (tn === $.MATH) {
                 mathStartTagInBody(p, token);
-
-            else if (tn === $.MENU)
+            } else if (tn === $.MENU) {
                 menuStartTagInBody(p, token);
-
-            else if (tn !== $.HEAD)
+            } else if (tn !== $.HEAD) {
                 genericStartTagInBody(p, token);
+            }
 
             break;
 
         case 5:
-            if (tn === $.STYLE || tn === $.TITLE)
+            if (tn === $.STYLE || tn === $.TITLE) {
                 startTagInHead(p, token);
-
-            else if (tn === $.ASIDE)
+            } else if (tn === $.ASIDE) {
                 addressStartTagInBody(p, token);
-
-            else if (tn === $.SMALL)
+            } else if (tn === $.SMALL) {
                 bStartTagInBody(p, token);
-
-            else if (tn === $.TABLE)
+            } else if (tn === $.TABLE) {
                 tableStartTagInBody(p, token);
-
-            else if (tn === $.EMBED)
+            } else if (tn === $.EMBED) {
                 areaStartTagInBody(p, token);
-
-            else if (tn === $.INPUT)
+            } else if (tn === $.INPUT) {
                 inputStartTagInBody(p, token);
-
-            else if (tn === $.PARAM || tn === $.TRACK)
+            } else if (tn === $.PARAM || tn === $.TRACK) {
                 paramStartTagInBody(p, token);
-
-            else if (tn === $.IMAGE)
+            } else if (tn === $.IMAGE) {
                 imageStartTagInBody(p, token);
-
-            else if (tn !== $.FRAME && tn !== $.TBODY && tn !== $.TFOOT && tn !== $.THEAD)
+            } else if (tn !== $.FRAME && tn !== $.TBODY && tn !== $.TFOOT && tn !== $.THEAD) {
                 genericStartTagInBody(p, token);
+            }
 
             break;
 
         case 6:
-            if (tn === $.SCRIPT)
+            if (tn === $.SCRIPT) {
                 startTagInHead(p, token);
-
-            else if (tn === $.CENTER || tn === $.FIGURE || tn === $.FOOTER || tn === $.HEADER || tn === $.HGROUP)
+            } else if (
+                tn === $.CENTER ||
+                tn === $.FIGURE ||
+                tn === $.FOOTER ||
+                tn === $.HEADER ||
+                tn === $.HGROUP ||
+                tn === $.DIALOG
+            ) {
                 addressStartTagInBody(p, token);
-
-            else if (tn === $.BUTTON)
+            } else if (tn === $.BUTTON) {
                 buttonStartTagInBody(p, token);
-
-            else if (tn === $.STRIKE || tn === $.STRONG)
+            } else if (tn === $.STRIKE || tn === $.STRONG) {
                 bStartTagInBody(p, token);
-
-            else if (tn === $.APPLET || tn === $.OBJECT)
+            } else if (tn === $.APPLET || tn === $.OBJECT) {
                 appletStartTagInBody(p, token);
-
-            else if (tn === $.KEYGEN)
+            } else if (tn === $.KEYGEN) {
                 areaStartTagInBody(p, token);
-
-            else if (tn === $.SOURCE)
+            } else if (tn === $.SOURCE) {
                 paramStartTagInBody(p, token);
-
-            else if (tn === $.IFRAME)
+            } else if (tn === $.IFRAME) {
                 iframeStartTagInBody(p, token);
-
-            else if (tn === $.SELECT)
+            } else if (tn === $.SELECT) {
                 selectStartTagInBody(p, token);
-
-            else if (tn === $.OPTION)
+            } else if (tn === $.OPTION) {
                 optgroupStartTagInBody(p, token);
-
-            else
+            } else {
                 genericStartTagInBody(p, token);
+            }
 
             break;
 
         case 7:
-            if (tn === $.BGSOUND)
+            if (tn === $.BGSOUND) {
                 startTagInHead(p, token);
-
-            else if (tn === $.DETAILS || tn === $.ADDRESS || tn === $.ARTICLE || tn === $.SECTION || tn === $.SUMMARY)
+            } else if (
+                tn === $.DETAILS ||
+                tn === $.ADDRESS ||
+                tn === $.ARTICLE ||
+                tn === $.SECTION ||
+                tn === $.SUMMARY
+            ) {
                 addressStartTagInBody(p, token);
-
-            else if (tn === $.LISTING)
+            } else if (tn === $.LISTING) {
                 preStartTagInBody(p, token);
-
-            else if (tn === $.MARQUEE)
+            } else if (tn === $.MARQUEE) {
                 appletStartTagInBody(p, token);
-
-            else if (tn === $.NOEMBED)
+            } else if (tn === $.NOEMBED) {
                 noembedStartTagInBody(p, token);
-
-            else if (tn !== $.CAPTION)
+            } else if (tn !== $.CAPTION) {
                 genericStartTagInBody(p, token);
+            }
 
             break;
 
         case 8:
-            if (tn === $.BASEFONT)
+            if (tn === $.BASEFONT) {
                 startTagInHead(p, token);
-
-            else if (tn === $.MENUITEM)
-                menuitemStartTagInBody(p, token);
-
-            else if (tn === $.FRAMESET)
+            } else if (tn === $.FRAMESET) {
                 framesetStartTagInBody(p, token);
-
-            else if (tn === $.FIELDSET)
+            } else if (tn === $.FIELDSET) {
                 addressStartTagInBody(p, token);
-
-            else if (tn === $.TEXTAREA)
+            } else if (tn === $.TEXTAREA) {
                 textareaStartTagInBody(p, token);
-
-            else if (tn === $.TEMPLATE)
+            } else if (tn === $.TEMPLATE) {
                 startTagInHead(p, token);
-
-            else if (tn === $.NOSCRIPT)
-                noembedStartTagInBody(p, token);
-
-            else if (tn === $.OPTGROUP)
+            } else if (tn === $.NOSCRIPT) {
+                if (p.options.scriptingEnabled) {
+                    noembedStartTagInBody(p, token);
+                } else {
+                    genericStartTagInBody(p, token);
+                }
+            } else if (tn === $.OPTGROUP) {
                 optgroupStartTagInBody(p, token);
-
-            else if (tn !== $.COLGROUP)
+            } else if (tn !== $.COLGROUP) {
                 genericStartTagInBody(p, token);
+            }
 
             break;
 
         case 9:
-            if (tn === $.PLAINTEXT)
+            if (tn === $.PLAINTEXT) {
                 plaintextStartTagInBody(p, token);
-
-            else
+            } else {
                 genericStartTagInBody(p, token);
+            }
 
             break;
 
         case 10:
-            if (tn === $.BLOCKQUOTE || tn === $.FIGCAPTION)
+            if (tn === $.BLOCKQUOTE || tn === $.FIGCAPTION) {
                 addressStartTagInBody(p, token);
-
-            else
+            } else {
                 genericStartTagInBody(p, token);
+            }
 
             break;
 
@@ -1798,8 +1891,9 @@ function startTagInBody(p, token) {
 }
 
 function bodyEndTagInBody(p) {
-    if (p.openElements.hasInScope($.BODY))
+    if (p.openElements.hasInScope($.BODY)) {
         p.insertionMode = AFTER_BODY_MODE;
+    }
 }
 
 function htmlEndTagInBody(p, token) {
@@ -1810,7 +1904,7 @@ function htmlEndTagInBody(p, token) {
 }
 
 function addressEndTagInBody(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     if (p.openElements.hasInScope(tn)) {
         p.openElements.generateImpliedEndTags();
@@ -1819,26 +1913,28 @@ function addressEndTagInBody(p, token) {
 }
 
 function formEndTagInBody(p) {
-    var inTemplate = p.openElements.tmplCount > 0,
-        formElement = p.formElement;
+    const inTemplate = p.openElements.tmplCount > 0;
+    const formElement = p.formElement;
 
-    if (!inTemplate)
+    if (!inTemplate) {
         p.formElement = null;
+    }
 
     if ((formElement || inTemplate) && p.openElements.hasInScope($.FORM)) {
         p.openElements.generateImpliedEndTags();
 
-        if (inTemplate)
+        if (inTemplate) {
             p.openElements.popUntilTagNamePopped($.FORM);
-
-        else
+        } else {
             p.openElements.remove(formElement);
+        }
     }
 }
 
 function pEndTagInBody(p) {
-    if (!p.openElements.hasInButtonScope($.P))
+    if (!p.openElements.hasInButtonScope($.P)) {
         p._insertFakeElement($.P);
+    }
 
     p._closePElement();
 }
@@ -1851,7 +1947,7 @@ function liEndTagInBody(p) {
 }
 
 function ddEndTagInBody(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     if (p.openElements.hasInScope(tn)) {
         p.openElements.generateImpliedEndTagsWithExclusion(tn);
@@ -1867,7 +1963,7 @@ function numberedHeaderEndTagInBody(p) {
 }
 
 function appletEndTagInBody(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     if (p.openElements.hasInScope(tn)) {
         p.openElements.generateImpliedEndTags();
@@ -1884,10 +1980,10 @@ function brEndTagInBody(p) {
 }
 
 function genericEndTagInBody(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
-    for (var i = p.openElements.stackTop; i > 0; i--) {
-        var element = p.openElements.items[i];
+    for (let i = p.openElements.stackTop; i > 0; i--) {
+        const element = p.openElements.items[i];
 
         if (p.treeAdapter.getTagName(element) === tn) {
             p.openElements.generateImpliedEndTagsWithExclusion(tn);
@@ -1895,181 +1991,180 @@ function genericEndTagInBody(p, token) {
             break;
         }
 
-        if (p._isSpecialElement(element))
+        if (p._isSpecialElement(element)) {
             break;
+        }
     }
 }
 
 //OPTIMIZATION: Integer comparisons are low-cost, so we can use very fast tag name length filters here.
 //It's faster than using dictionary.
 function endTagInBody(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     switch (tn.length) {
         case 1:
-            if (tn === $.A || tn === $.B || tn === $.I || tn === $.S || tn === $.U)
+            if (tn === $.A || tn === $.B || tn === $.I || tn === $.S || tn === $.U) {
                 callAdoptionAgency(p, token);
-
-            else if (tn === $.P)
+            } else if (tn === $.P) {
                 pEndTagInBody(p, token);
-
-            else
+            } else {
                 genericEndTagInBody(p, token);
+            }
 
             break;
 
         case 2:
-            if (tn === $.DL || tn === $.UL || tn === $.OL)
+            if (tn === $.DL || tn === $.UL || tn === $.OL) {
                 addressEndTagInBody(p, token);
-
-            else if (tn === $.LI)
+            } else if (tn === $.LI) {
                 liEndTagInBody(p, token);
-
-            else if (tn === $.DD || tn === $.DT)
+            } else if (tn === $.DD || tn === $.DT) {
                 ddEndTagInBody(p, token);
-
-            else if (tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6)
+            } else if (tn === $.H1 || tn === $.H2 || tn === $.H3 || tn === $.H4 || tn === $.H5 || tn === $.H6) {
                 numberedHeaderEndTagInBody(p, token);
-
-            else if (tn === $.BR)
+            } else if (tn === $.BR) {
                 brEndTagInBody(p, token);
-
-            else if (tn === $.EM || tn === $.TT)
+            } else if (tn === $.EM || tn === $.TT) {
                 callAdoptionAgency(p, token);
-
-            else
+            } else {
                 genericEndTagInBody(p, token);
+            }
 
             break;
 
         case 3:
-            if (tn === $.BIG)
+            if (tn === $.BIG) {
                 callAdoptionAgency(p, token);
-
-            else if (tn === $.DIR || tn === $.DIV || tn === $.NAV)
+            } else if (tn === $.DIR || tn === $.DIV || tn === $.NAV || tn === $.PRE) {
                 addressEndTagInBody(p, token);
-
-            else
+            } else {
                 genericEndTagInBody(p, token);
+            }
 
             break;
 
         case 4:
-            if (tn === $.BODY)
+            if (tn === $.BODY) {
                 bodyEndTagInBody(p, token);
-
-            else if (tn === $.HTML)
+            } else if (tn === $.HTML) {
                 htmlEndTagInBody(p, token);
-
-            else if (tn === $.FORM)
+            } else if (tn === $.FORM) {
                 formEndTagInBody(p, token);
-
-            else if (tn === $.CODE || tn === $.FONT || tn === $.NOBR)
+            } else if (tn === $.CODE || tn === $.FONT || tn === $.NOBR) {
                 callAdoptionAgency(p, token);
-
-            else if (tn === $.MAIN || tn === $.MENU)
+            } else if (tn === $.MAIN || tn === $.MENU) {
                 addressEndTagInBody(p, token);
-
-            else
+            } else {
                 genericEndTagInBody(p, token);
+            }
 
             break;
 
         case 5:
-            if (tn === $.ASIDE)
+            if (tn === $.ASIDE) {
                 addressEndTagInBody(p, token);
-
-            else if (tn === $.SMALL)
+            } else if (tn === $.SMALL) {
                 callAdoptionAgency(p, token);
-
-            else
+            } else {
                 genericEndTagInBody(p, token);
+            }
 
             break;
 
         case 6:
-            if (tn === $.CENTER || tn === $.FIGURE || tn === $.FOOTER || tn === $.HEADER || tn === $.HGROUP)
+            if (
+                tn === $.CENTER ||
+                tn === $.FIGURE ||
+                tn === $.FOOTER ||
+                tn === $.HEADER ||
+                tn === $.HGROUP ||
+                tn === $.DIALOG
+            ) {
                 addressEndTagInBody(p, token);
-
-            else if (tn === $.APPLET || tn === $.OBJECT)
+            } else if (tn === $.APPLET || tn === $.OBJECT) {
                 appletEndTagInBody(p, token);
-
-            else if (tn === $.STRIKE || tn === $.STRONG)
+            } else if (tn === $.STRIKE || tn === $.STRONG) {
                 callAdoptionAgency(p, token);
-
-            else
+            } else {
                 genericEndTagInBody(p, token);
+            }
 
             break;
 
         case 7:
-            if (tn === $.ADDRESS || tn === $.ARTICLE || tn === $.DETAILS || tn === $.SECTION || tn === $.SUMMARY)
+            if (
+                tn === $.ADDRESS ||
+                tn === $.ARTICLE ||
+                tn === $.DETAILS ||
+                tn === $.SECTION ||
+                tn === $.SUMMARY ||
+                tn === $.LISTING
+            ) {
                 addressEndTagInBody(p, token);
-
-            else if (tn === $.MARQUEE)
+            } else if (tn === $.MARQUEE) {
                 appletEndTagInBody(p, token);
-
-            else
+            } else {
                 genericEndTagInBody(p, token);
+            }
 
             break;
 
         case 8:
-            if (tn === $.FIELDSET)
+            if (tn === $.FIELDSET) {
                 addressEndTagInBody(p, token);
-
-            else if (tn === $.TEMPLATE)
+            } else if (tn === $.TEMPLATE) {
                 endTagInHead(p, token);
-
-            else
+            } else {
                 genericEndTagInBody(p, token);
+            }
 
             break;
 
         case 10:
-            if (tn === $.BLOCKQUOTE || tn === $.FIGCAPTION)
+            if (tn === $.BLOCKQUOTE || tn === $.FIGCAPTION) {
                 addressEndTagInBody(p, token);
-
-            else
+            } else {
                 genericEndTagInBody(p, token);
+            }
 
             break;
 
-        default :
+        default:
             genericEndTagInBody(p, token);
     }
 }
 
 function eofInBody(p, token) {
-    if (p.tmplInsertionModeStackTop > -1)
+    if (p.tmplInsertionModeStackTop > -1) {
         eofInTemplate(p, token);
-
-    else
+    } else {
         p.stopped = true;
+    }
 }
 
-//12.2.5.4.8 The "text" insertion mode
+// The "text" insertion mode
 //------------------------------------------------------------------
 function endTagInText(p, token) {
-    if (token.tagName === $.SCRIPT)
+    if (token.tagName === $.SCRIPT) {
         p.pendingScript = p.openElements.current;
+    }
 
     p.openElements.pop();
     p.insertionMode = p.originalInsertionMode;
 }
 
-
 function eofInText(p, token) {
+    p._err(ERR.eofInElementThatCanContainOnlyText);
     p.openElements.pop();
     p.insertionMode = p.originalInsertionMode;
     p._processToken(token);
 }
 
-
-//12.2.5.4.9 The "in table" insertion mode
+// The "in table" insertion mode
 //------------------------------------------------------------------
 function characterInTable(p, token) {
-    var curTn = p.openElements.currentTagName;
+    const curTn = p.openElements.currentTagName;
 
     if (curTn === $.TABLE || curTn === $.TBODY || curTn === $.TFOOT || curTn === $.THEAD || curTn === $.TR) {
         p.pendingCharacterTokens = [];
@@ -2077,10 +2172,9 @@ function characterInTable(p, token) {
         p.originalInsertionMode = p.insertionMode;
         p.insertionMode = IN_TABLE_TEXT_MODE;
         p._processToken(token);
-    }
-
-    else
+    } else {
         tokenInTable(p, token);
+    }
 }
 
 function captionStartTagInTable(p, token) {
@@ -2125,13 +2219,15 @@ function tableStartTagInTable(p, token) {
 }
 
 function inputStartTagInTable(p, token) {
-    var inputType = Tokenizer.getTokenAttr(token, ATTRS.TYPE);
+    const inputType = Tokenizer.getTokenAttr(token, ATTRS.TYPE);
 
-    if (inputType && inputType.toLowerCase() === HIDDEN_INPUT_TYPE)
+    if (inputType && inputType.toLowerCase() === HIDDEN_INPUT_TYPE) {
         p._appendElement(token, NS.HTML);
-
-    else
+    } else {
         tokenInTable(p, token);
+    }
+
+    token.ackSelfClosing = true;
 }
 
 function formStartTagInTable(p, token) {
@@ -2143,118 +2239,121 @@ function formStartTagInTable(p, token) {
 }
 
 function startTagInTable(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     switch (tn.length) {
         case 2:
-            if (tn === $.TD || tn === $.TH || tn === $.TR)
+            if (tn === $.TD || tn === $.TH || tn === $.TR) {
                 tdStartTagInTable(p, token);
-
-            else
+            } else {
                 tokenInTable(p, token);
+            }
 
             break;
 
         case 3:
-            if (tn === $.COL)
+            if (tn === $.COL) {
                 colStartTagInTable(p, token);
-
-            else
+            } else {
                 tokenInTable(p, token);
+            }
 
             break;
 
         case 4:
-            if (tn === $.FORM)
+            if (tn === $.FORM) {
                 formStartTagInTable(p, token);
-
-            else
+            } else {
                 tokenInTable(p, token);
+            }
 
             break;
 
         case 5:
-            if (tn === $.TABLE)
+            if (tn === $.TABLE) {
                 tableStartTagInTable(p, token);
-
-            else if (tn === $.STYLE)
+            } else if (tn === $.STYLE) {
                 startTagInHead(p, token);
-
-            else if (tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD)
+            } else if (tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD) {
                 tbodyStartTagInTable(p, token);
-
-            else if (tn === $.INPUT)
+            } else if (tn === $.INPUT) {
                 inputStartTagInTable(p, token);
-
-            else
+            } else {
                 tokenInTable(p, token);
+            }
 
             break;
 
         case 6:
-            if (tn === $.SCRIPT)
+            if (tn === $.SCRIPT) {
                 startTagInHead(p, token);
-
-            else
+            } else {
                 tokenInTable(p, token);
+            }
 
             break;
 
         case 7:
-            if (tn === $.CAPTION)
+            if (tn === $.CAPTION) {
                 captionStartTagInTable(p, token);
-
-            else
+            } else {
                 tokenInTable(p, token);
+            }
 
             break;
 
         case 8:
-            if (tn === $.COLGROUP)
+            if (tn === $.COLGROUP) {
                 colgroupStartTagInTable(p, token);
-
-            else if (tn === $.TEMPLATE)
+            } else if (tn === $.TEMPLATE) {
                 startTagInHead(p, token);
-
-            else
+            } else {
                 tokenInTable(p, token);
+            }
 
             break;
 
         default:
             tokenInTable(p, token);
     }
-
 }
 
 function endTagInTable(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     if (tn === $.TABLE) {
         if (p.openElements.hasInTableScope($.TABLE)) {
             p.openElements.popUntilTagNamePopped($.TABLE);
             p._resetInsertionMode();
         }
-    }
-
-    else if (tn === $.TEMPLATE)
+    } else if (tn === $.TEMPLATE) {
         endTagInHead(p, token);
-
-    else if (tn !== $.BODY && tn !== $.CAPTION && tn !== $.COL && tn !== $.COLGROUP && tn !== $.HTML &&
-             tn !== $.TBODY && tn !== $.TD && tn !== $.TFOOT && tn !== $.TH && tn !== $.THEAD && tn !== $.TR)
+    } else if (
+        tn !== $.BODY &&
+        tn !== $.CAPTION &&
+        tn !== $.COL &&
+        tn !== $.COLGROUP &&
+        tn !== $.HTML &&
+        tn !== $.TBODY &&
+        tn !== $.TD &&
+        tn !== $.TFOOT &&
+        tn !== $.TH &&
+        tn !== $.THEAD &&
+        tn !== $.TR
+    ) {
         tokenInTable(p, token);
+    }
 }
 
 function tokenInTable(p, token) {
-    var savedFosterParentingState = p.fosterParentingEnabled;
+    const savedFosterParentingState = p.fosterParentingEnabled;
 
     p.fosterParentingEnabled = true;
     p._processTokenInBodyMode(token);
     p.fosterParentingEnabled = savedFosterParentingState;
 }
 
-
-//12.2.5.4.10 The "in table text" insertion mode
+// The "in table text" insertion mode
 //------------------------------------------------------------------
 function whitespaceCharacterInTableText(p, token) {
     p.pendingCharacterTokens.push(token);
@@ -2266,30 +2365,38 @@ function characterInTableText(p, token) {
 }
 
 function tokenInTableText(p, token) {
-    var i = 0;
+    let i = 0;
 
     if (p.hasNonWhitespacePendingCharacterToken) {
-        for (; i < p.pendingCharacterTokens.length; i++)
+        for (; i < p.pendingCharacterTokens.length; i++) {
             tokenInTable(p, p.pendingCharacterTokens[i]);
-    }
-
-    else {
-        for (; i < p.pendingCharacterTokens.length; i++)
+        }
+    } else {
+        for (; i < p.pendingCharacterTokens.length; i++) {
             p._insertCharacters(p.pendingCharacterTokens[i]);
+        }
     }
 
     p.insertionMode = p.originalInsertionMode;
     p._processToken(token);
 }
 
-
-//12.2.5.4.11 The "in caption" insertion mode
+// The "in caption" insertion mode
 //------------------------------------------------------------------
 function startTagInCaption(p, token) {
-    var tn = token.tagName;
-
-    if (tn === $.CAPTION || tn === $.COL || tn === $.COLGROUP || tn === $.TBODY ||
-        tn === $.TD || tn === $.TFOOT || tn === $.TH || tn === $.THEAD || tn === $.TR) {
+    const tn = token.tagName;
+
+    if (
+        tn === $.CAPTION ||
+        tn === $.COL ||
+        tn === $.COLGROUP ||
+        tn === $.TBODY ||
+        tn === $.TD ||
+        tn === $.TFOOT ||
+        tn === $.TH ||
+        tn === $.THEAD ||
+        tn === $.TR
+    ) {
         if (p.openElements.hasInTableScope($.CAPTION)) {
             p.openElements.generateImpliedEndTags();
             p.openElements.popUntilTagNamePopped($.CAPTION);
@@ -2297,14 +2404,13 @@ function startTagInCaption(p, token) {
             p.insertionMode = IN_TABLE_MODE;
             p._processToken(token);
         }
-    }
-
-    else
+    } else {
         startTagInBody(p, token);
+    }
 }
 
 function endTagInCaption(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     if (tn === $.CAPTION || tn === $.TABLE) {
         if (p.openElements.hasInTableScope($.CAPTION)) {
@@ -2313,50 +2419,56 @@ function endTagInCaption(p, token) {
             p.activeFormattingElements.clearToLastMarker();
             p.insertionMode = IN_TABLE_MODE;
 
-            if (tn === $.TABLE)
+            if (tn === $.TABLE) {
                 p._processToken(token);
+            }
         }
-    }
-
-    else if (tn !== $.BODY && tn !== $.COL && tn !== $.COLGROUP && tn !== $.HTML && tn !== $.TBODY &&
-             tn !== $.TD && tn !== $.TFOOT && tn !== $.TH && tn !== $.THEAD && tn !== $.TR)
+    } else if (
+        tn !== $.BODY &&
+        tn !== $.COL &&
+        tn !== $.COLGROUP &&
+        tn !== $.HTML &&
+        tn !== $.TBODY &&
+        tn !== $.TD &&
+        tn !== $.TFOOT &&
+        tn !== $.TH &&
+        tn !== $.THEAD &&
+        tn !== $.TR
+    ) {
         endTagInBody(p, token);
+    }
 }
 
-
-//12.2.5.4.12 The "in column group" insertion mode
+// The "in column group" insertion mode
 //------------------------------------------------------------------
 function startTagInColumnGroup(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
-    if (tn === $.HTML)
+    if (tn === $.HTML) {
         startTagInBody(p, token);
-
-    else if (tn === $.COL)
+    } else if (tn === $.COL) {
         p._appendElement(token, NS.HTML);
-
-    else if (tn === $.TEMPLATE)
+        token.ackSelfClosing = true;
+    } else if (tn === $.TEMPLATE) {
         startTagInHead(p, token);
-
-    else
+    } else {
         tokenInColumnGroup(p, token);
+    }
 }
 
 function endTagInColumnGroup(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     if (tn === $.COLGROUP) {
         if (p.openElements.currentTagName === $.COLGROUP) {
             p.openElements.pop();
             p.insertionMode = IN_TABLE_MODE;
         }
-    }
-
-    else if (tn === $.TEMPLATE)
+    } else if (tn === $.TEMPLATE) {
         endTagInHead(p, token);
-
-    else if (tn !== $.COL)
+    } else if (tn !== $.COL) {
         tokenInColumnGroup(p, token);
+    }
 }
 
 function tokenInColumnGroup(p, token) {
@@ -2367,41 +2479,41 @@ function tokenInColumnGroup(p, token) {
     }
 }
 
-//12.2.5.4.13 The "in table body" insertion mode
+// The "in table body" insertion mode
 //------------------------------------------------------------------
 function startTagInTableBody(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     if (tn === $.TR) {
         p.openElements.clearBackToTableBodyContext();
         p._insertElement(token, NS.HTML);
         p.insertionMode = IN_ROW_MODE;
-    }
-
-    else if (tn === $.TH || tn === $.TD) {
+    } else if (tn === $.TH || tn === $.TD) {
         p.openElements.clearBackToTableBodyContext();
         p._insertFakeElement($.TR);
         p.insertionMode = IN_ROW_MODE;
         p._processToken(token);
-    }
-
-    else if (tn === $.CAPTION || tn === $.COL || tn === $.COLGROUP ||
-             tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD) {
-
+    } else if (
+        tn === $.CAPTION ||
+        tn === $.COL ||
+        tn === $.COLGROUP ||
+        tn === $.TBODY ||
+        tn === $.TFOOT ||
+        tn === $.THEAD
+    ) {
         if (p.openElements.hasTableBodyContextInTableScope()) {
             p.openElements.clearBackToTableBodyContext();
             p.openElements.pop();
             p.insertionMode = IN_TABLE_MODE;
             p._processToken(token);
         }
-    }
-
-    else
+    } else {
         startTagInTable(p, token);
+    }
 }
 
 function endTagInTableBody(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     if (tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD) {
         if (p.openElements.hasInTableScope(tn)) {
@@ -2409,50 +2521,53 @@ function endTagInTableBody(p, token) {
             p.openElements.pop();
             p.insertionMode = IN_TABLE_MODE;
         }
-    }
-
-    else if (tn === $.TABLE) {
+    } else if (tn === $.TABLE) {
         if (p.openElements.hasTableBodyContextInTableScope()) {
             p.openElements.clearBackToTableBodyContext();
             p.openElements.pop();
             p.insertionMode = IN_TABLE_MODE;
             p._processToken(token);
         }
-    }
-
-    else if (tn !== $.BODY && tn !== $.CAPTION && tn !== $.COL && tn !== $.COLGROUP ||
-             tn !== $.HTML && tn !== $.TD && tn !== $.TH && tn !== $.TR)
+    } else if (
+        (tn !== $.BODY && tn !== $.CAPTION && tn !== $.COL && tn !== $.COLGROUP) ||
+        (tn !== $.HTML && tn !== $.TD && tn !== $.TH && tn !== $.TR)
+    ) {
         endTagInTable(p, token);
+    }
 }
 
-//12.2.5.4.14 The "in row" insertion mode
+// The "in row" insertion mode
 //------------------------------------------------------------------
 function startTagInRow(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     if (tn === $.TH || tn === $.TD) {
         p.openElements.clearBackToTableRowContext();
         p._insertElement(token, NS.HTML);
         p.insertionMode = IN_CELL_MODE;
         p.activeFormattingElements.insertMarker();
-    }
-
-    else if (tn === $.CAPTION || tn === $.COL || tn === $.COLGROUP || tn === $.TBODY ||
-             tn === $.TFOOT || tn === $.THEAD || tn === $.TR) {
+    } else if (
+        tn === $.CAPTION ||
+        tn === $.COL ||
+        tn === $.COLGROUP ||
+        tn === $.TBODY ||
+        tn === $.TFOOT ||
+        tn === $.THEAD ||
+        tn === $.TR
+    ) {
         if (p.openElements.hasInTableScope($.TR)) {
             p.openElements.clearBackToTableRowContext();
             p.openElements.pop();
             p.insertionMode = IN_TABLE_BODY_MODE;
             p._processToken(token);
         }
-    }
-
-    else
+    } else {
         startTagInTable(p, token);
+    }
 }
 
 function endTagInRow(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     if (tn === $.TR) {
         if (p.openElements.hasInTableScope($.TR)) {
@@ -2460,52 +2575,55 @@ function endTagInRow(p, token) {
             p.openElements.pop();
             p.insertionMode = IN_TABLE_BODY_MODE;
         }
-    }
-
-    else if (tn === $.TABLE) {
+    } else if (tn === $.TABLE) {
         if (p.openElements.hasInTableScope($.TR)) {
             p.openElements.clearBackToTableRowContext();
             p.openElements.pop();
             p.insertionMode = IN_TABLE_BODY_MODE;
             p._processToken(token);
         }
-    }
-
-    else if (tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD) {
+    } else if (tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD) {
         if (p.openElements.hasInTableScope(tn) || p.openElements.hasInTableScope($.TR)) {
             p.openElements.clearBackToTableRowContext();
             p.openElements.pop();
             p.insertionMode = IN_TABLE_BODY_MODE;
             p._processToken(token);
         }
-    }
-
-    else if (tn !== $.BODY && tn !== $.CAPTION && tn !== $.COL && tn !== $.COLGROUP ||
-             tn !== $.HTML && tn !== $.TD && tn !== $.TH)
+    } else if (
+        (tn !== $.BODY && tn !== $.CAPTION && tn !== $.COL && tn !== $.COLGROUP) ||
+        (tn !== $.HTML && tn !== $.TD && tn !== $.TH)
+    ) {
         endTagInTable(p, token);
+    }
 }
 
-
-//12.2.5.4.15 The "in cell" insertion mode
+// The "in cell" insertion mode
 //------------------------------------------------------------------
 function startTagInCell(p, token) {
-    var tn = token.tagName;
-
-    if (tn === $.CAPTION || tn === $.COL || tn === $.COLGROUP || tn === $.TBODY ||
-        tn === $.TD || tn === $.TFOOT || tn === $.TH || tn === $.THEAD || tn === $.TR) {
-
+    const tn = token.tagName;
+
+    if (
+        tn === $.CAPTION ||
+        tn === $.COL ||
+        tn === $.COLGROUP ||
+        tn === $.TBODY ||
+        tn === $.TD ||
+        tn === $.TFOOT ||
+        tn === $.TH ||
+        tn === $.THEAD ||
+        tn === $.TR
+    ) {
         if (p.openElements.hasInTableScope($.TD) || p.openElements.hasInTableScope($.TH)) {
             p._closeTableCell();
             p._processToken(token);
         }
-    }
-
-    else
+    } else {
         startTagInBody(p, token);
+    }
 }
 
 function endTagInCell(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     if (tn === $.TD || tn === $.TH) {
         if (p.openElements.hasInTableScope(tn)) {
@@ -2514,129 +2632,145 @@ function endTagInCell(p, token) {
             p.activeFormattingElements.clearToLastMarker();
             p.insertionMode = IN_ROW_MODE;
         }
-    }
-
-    else if (tn === $.TABLE || tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD || tn === $.TR) {
+    } else if (tn === $.TABLE || tn === $.TBODY || tn === $.TFOOT || tn === $.THEAD || tn === $.TR) {
         if (p.openElements.hasInTableScope(tn)) {
             p._closeTableCell();
             p._processToken(token);
         }
-    }
-
-    else if (tn !== $.BODY && tn !== $.CAPTION && tn !== $.COL && tn !== $.COLGROUP && tn !== $.HTML)
+    } else if (tn !== $.BODY && tn !== $.CAPTION && tn !== $.COL && tn !== $.COLGROUP && tn !== $.HTML) {
         endTagInBody(p, token);
+    }
 }
 
-//12.2.5.4.16 The "in select" insertion mode
+// The "in select" insertion mode
 //------------------------------------------------------------------
 function startTagInSelect(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
-    if (tn === $.HTML)
+    if (tn === $.HTML) {
         startTagInBody(p, token);
-
-    else if (tn === $.OPTION) {
-        if (p.openElements.currentTagName === $.OPTION)
+    } else if (tn === $.OPTION) {
+        if (p.openElements.currentTagName === $.OPTION) {
             p.openElements.pop();
+        }
 
         p._insertElement(token, NS.HTML);
-    }
-
-    else if (tn === $.OPTGROUP) {
-        if (p.openElements.currentTagName === $.OPTION)
+    } else if (tn === $.OPTGROUP) {
+        if (p.openElements.currentTagName === $.OPTION) {
             p.openElements.pop();
+        }
 
-        if (p.openElements.currentTagName === $.OPTGROUP)
+        if (p.openElements.currentTagName === $.OPTGROUP) {
             p.openElements.pop();
+        }
 
         p._insertElement(token, NS.HTML);
-    }
-
-    else if (tn === $.INPUT || tn === $.KEYGEN || tn === $.TEXTAREA || tn === $.SELECT) {
+    } else if (tn === $.INPUT || tn === $.KEYGEN || tn === $.TEXTAREA || tn === $.SELECT) {
         if (p.openElements.hasInSelectScope($.SELECT)) {
             p.openElements.popUntilTagNamePopped($.SELECT);
             p._resetInsertionMode();
 
-            if (tn !== $.SELECT)
+            if (tn !== $.SELECT) {
                 p._processToken(token);
+            }
         }
-    }
-
-    else if (tn === $.SCRIPT || tn === $.TEMPLATE)
+    } else if (tn === $.SCRIPT || tn === $.TEMPLATE) {
         startTagInHead(p, token);
+    }
 }
 
 function endTagInSelect(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
     if (tn === $.OPTGROUP) {
-        var prevOpenElement = p.openElements.items[p.openElements.stackTop - 1],
-            prevOpenElementTn = prevOpenElement && p.treeAdapter.getTagName(prevOpenElement);
+        const prevOpenElement = p.openElements.items[p.openElements.stackTop - 1];
+        const prevOpenElementTn = prevOpenElement && p.treeAdapter.getTagName(prevOpenElement);
 
-        if (p.openElements.currentTagName === $.OPTION && prevOpenElementTn === $.OPTGROUP)
+        if (p.openElements.currentTagName === $.OPTION && prevOpenElementTn === $.OPTGROUP) {
             p.openElements.pop();
+        }
 
-        if (p.openElements.currentTagName === $.OPTGROUP)
+        if (p.openElements.currentTagName === $.OPTGROUP) {
             p.openElements.pop();
-    }
-
-    else if (tn === $.OPTION) {
-        if (p.openElements.currentTagName === $.OPTION)
+        }
+    } else if (tn === $.OPTION) {
+        if (p.openElements.currentTagName === $.OPTION) {
             p.openElements.pop();
-    }
-
-    else if (tn === $.SELECT && p.openElements.hasInSelectScope($.SELECT)) {
+        }
+    } else if (tn === $.SELECT && p.openElements.hasInSelectScope($.SELECT)) {
         p.openElements.popUntilTagNamePopped($.SELECT);
         p._resetInsertionMode();
-    }
-
-    else if (tn === $.TEMPLATE)
+    } else if (tn === $.TEMPLATE) {
         endTagInHead(p, token);
+    }
 }
 
 //12.2.5.4.17 The "in select in table" insertion mode
 //------------------------------------------------------------------
 function startTagInSelectInTable(p, token) {
-    var tn = token.tagName;
-
-    if (tn === $.CAPTION || tn === $.TABLE || tn === $.TBODY || tn === $.TFOOT ||
-        tn === $.THEAD || tn === $.TR || tn === $.TD || tn === $.TH) {
+    const tn = token.tagName;
+
+    if (
+        tn === $.CAPTION ||
+        tn === $.TABLE ||
+        tn === $.TBODY ||
+        tn === $.TFOOT ||
+        tn === $.THEAD ||
+        tn === $.TR ||
+        tn === $.TD ||
+        tn === $.TH
+    ) {
         p.openElements.popUntilTagNamePopped($.SELECT);
         p._resetInsertionMode();
         p._processToken(token);
-    }
-
-    else
+    } else {
         startTagInSelect(p, token);
+    }
 }
 
 function endTagInSelectInTable(p, token) {
-    var tn = token.tagName;
-
-    if (tn === $.CAPTION || tn === $.TABLE || tn === $.TBODY || tn === $.TFOOT ||
-        tn === $.THEAD || tn === $.TR || tn === $.TD || tn === $.TH) {
+    const tn = token.tagName;
+
+    if (
+        tn === $.CAPTION ||
+        tn === $.TABLE ||
+        tn === $.TBODY ||
+        tn === $.TFOOT ||
+        tn === $.THEAD ||
+        tn === $.TR ||
+        tn === $.TD ||
+        tn === $.TH
+    ) {
         if (p.openElements.hasInTableScope(tn)) {
             p.openElements.popUntilTagNamePopped($.SELECT);
             p._resetInsertionMode();
             p._processToken(token);
         }
-    }
-
-    else
+    } else {
         endTagInSelect(p, token);
+    }
 }
 
-//12.2.5.4.18 The "in template" insertion mode
+// The "in template" insertion mode
 //------------------------------------------------------------------
 function startTagInTemplate(p, token) {
-    var tn = token.tagName;
-
-    if (tn === $.BASE || tn === $.BASEFONT || tn === $.BGSOUND || tn === $.LINK || tn === $.META ||
-        tn === $.NOFRAMES || tn === $.SCRIPT || tn === $.STYLE || tn === $.TEMPLATE || tn === $.TITLE)
+    const tn = token.tagName;
+
+    if (
+        tn === $.BASE ||
+        tn === $.BASEFONT ||
+        tn === $.BGSOUND ||
+        tn === $.LINK ||
+        tn === $.META ||
+        tn === $.NOFRAMES ||
+        tn === $.SCRIPT ||
+        tn === $.STYLE ||
+        tn === $.TEMPLATE ||
+        tn === $.TITLE
+    ) {
         startTagInHead(p, token);
-
-    else {
-        var newInsertionMode = TEMPLATE_INSERTION_MODE_SWITCH_MAP[tn] || IN_BODY_MODE;
+    } else {
+        const newInsertionMode = TEMPLATE_INSERTION_MODE_SWITCH_MAP[tn] || IN_BODY_MODE;
 
         p._popTmplInsertionMode();
         p._pushTmplInsertionMode(newInsertionMode);
@@ -2646,8 +2780,9 @@ function startTagInTemplate(p, token) {
 }
 
 function endTagInTemplate(p, token) {
-    if (token.tagName === $.TEMPLATE)
+    if (token.tagName === $.TEMPLATE) {
         endTagInHead(p, token);
+    }
 }
 
 function eofInTemplate(p, token) {
@@ -2657,31 +2792,29 @@ function eofInTemplate(p, token) {
         p._popTmplInsertionMode();
         p._resetInsertionMode();
         p._processToken(token);
-    }
-
-    else
+    } else {
         p.stopped = true;
+    }
 }
 
-
-//12.2.5.4.19 The "after body" insertion mode
+// The "after body" insertion mode
 //------------------------------------------------------------------
 function startTagAfterBody(p, token) {
-    if (token.tagName === $.HTML)
+    if (token.tagName === $.HTML) {
         startTagInBody(p, token);
-
-    else
+    } else {
         tokenAfterBody(p, token);
+    }
 }
 
 function endTagAfterBody(p, token) {
     if (token.tagName === $.HTML) {
-        if (!p.fragmentContext)
+        if (!p.fragmentContext) {
             p.insertionMode = AFTER_AFTER_BODY_MODE;
-    }
-
-    else
+        }
+    } else {
         tokenAfterBody(p, token);
+    }
 }
 
 function tokenAfterBody(p, token) {
@@ -2689,58 +2822,59 @@ function tokenAfterBody(p, token) {
     p._processToken(token);
 }
 
-//12.2.5.4.20 The "in frameset" insertion mode
+// The "in frameset" insertion mode
 //------------------------------------------------------------------
 function startTagInFrameset(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
-    if (tn === $.HTML)
+    if (tn === $.HTML) {
         startTagInBody(p, token);
-
-    else if (tn === $.FRAMESET)
+    } else if (tn === $.FRAMESET) {
         p._insertElement(token, NS.HTML);
-
-    else if (tn === $.FRAME)
+    } else if (tn === $.FRAME) {
         p._appendElement(token, NS.HTML);
-
-    else if (tn === $.NOFRAMES)
+        token.ackSelfClosing = true;
+    } else if (tn === $.NOFRAMES) {
         startTagInHead(p, token);
+    }
 }
 
 function endTagInFrameset(p, token) {
     if (token.tagName === $.FRAMESET && !p.openElements.isRootHtmlElementCurrent()) {
         p.openElements.pop();
 
-        if (!p.fragmentContext && p.openElements.currentTagName !== $.FRAMESET)
+        if (!p.fragmentContext && p.openElements.currentTagName !== $.FRAMESET) {
             p.insertionMode = AFTER_FRAMESET_MODE;
+        }
     }
 }
 
-//12.2.5.4.21 The "after frameset" insertion mode
+// The "after frameset" insertion mode
 //------------------------------------------------------------------
 function startTagAfterFrameset(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
-    if (tn === $.HTML)
+    if (tn === $.HTML) {
         startTagInBody(p, token);
-
-    else if (tn === $.NOFRAMES)
+    } else if (tn === $.NOFRAMES) {
         startTagInHead(p, token);
+    }
 }
 
 function endTagAfterFrameset(p, token) {
-    if (token.tagName === $.HTML)
+    if (token.tagName === $.HTML) {
         p.insertionMode = AFTER_AFTER_FRAMESET_MODE;
+    }
 }
 
-//12.2.5.4.22 The "after after body" insertion mode
+// The "after after body" insertion mode
 //------------------------------------------------------------------
 function startTagAfterAfterBody(p, token) {
-    if (token.tagName === $.HTML)
+    if (token.tagName === $.HTML) {
         startTagInBody(p, token);
-
-    else
+    } else {
         tokenAfterAfterBody(p, token);
+    }
 }
 
 function tokenAfterAfterBody(p, token) {
@@ -2748,23 +2882,22 @@ function tokenAfterAfterBody(p, token) {
     p._processToken(token);
 }
 
-//12.2.5.4.23 The "after after frameset" insertion mode
+// The "after after frameset" insertion mode
 //------------------------------------------------------------------
 function startTagAfterAfterFrameset(p, token) {
-    var tn = token.tagName;
+    const tn = token.tagName;
 
-    if (tn === $.HTML)
+    if (tn === $.HTML) {
         startTagInBody(p, token);
-
-    else if (tn === $.NOFRAMES)
+    } else if (tn === $.NOFRAMES) {
         startTagInHead(p, token);
+    }
 }
 
-
-//12.2.5.5 The rules for parsing tokens in foreign content
+// The rules for parsing tokens in foreign content
 //------------------------------------------------------------------
 function nullCharacterInForeignContent(p, token) {
-    token.chars = UNICODE.REPLACEMENT_CHARACTER;
+    token.chars = unicode.REPLACEMENT_CHARACTER;
     p._insertCharacters(token);
 }
 
@@ -2775,36 +2908,40 @@ function characterInForeignContent(p, token) {
 
 function startTagInForeignContent(p, token) {
     if (foreignContent.causesExit(token) && !p.fragmentContext) {
-        while (p.treeAdapter.getNamespaceURI(p.openElements.current) !== NS.HTML && !p._isIntegrationPoint(p.openElements.current))
+        while (
+            p.treeAdapter.getNamespaceURI(p.openElements.current) !== NS.HTML &&
+            !p._isIntegrationPoint(p.openElements.current)
+        ) {
             p.openElements.pop();
+        }
 
         p._processToken(token);
-    }
+    } else {
+        const current = p._getAdjustedCurrentElement();
+        const currentNs = p.treeAdapter.getNamespaceURI(current);
 
-    else {
-        var current = p._getAdjustedCurrentElement(),
-            currentNs = p.treeAdapter.getNamespaceURI(current);
-
-        if (currentNs === NS.MATHML)
+        if (currentNs === NS.MATHML) {
             foreignContent.adjustTokenMathMLAttrs(token);
-
-        else if (currentNs === NS.SVG) {
+        } else if (currentNs === NS.SVG) {
             foreignContent.adjustTokenSVGTagName(token);
             foreignContent.adjustTokenSVGAttrs(token);
         }
 
         foreignContent.adjustTokenXMLAttrs(token);
 
-        if (token.selfClosing)
+        if (token.selfClosing) {
             p._appendElement(token, currentNs);
-        else
+        } else {
             p._insertElement(token, currentNs);
+        }
+
+        token.ackSelfClosing = true;
     }
 }
 
 function endTagInForeignContent(p, token) {
-    for (var i = p.openElements.stackTop; i > 0; i--) {
-        var element = p.openElements.items[i];
+    for (let i = p.openElements.stackTop; i > 0; i--) {
+        const element = p.openElements.items[i];
 
         if (p.treeAdapter.getNamespaceURI(element) === NS.HTML) {
             p._processToken(token);