Google Git
Sign in
chromium/devtools/devtools-frontend/refs/heads/main/./node_modules/parse5/dist/parser/index.js
blob: fdd25628c47a7e83715b3635ccaa48d538b5be30 [file] [edit]
import { Tokenizer, TokenizerMode } from '../tokenizer/index.js';
import { OpenElementStack } from './open-element-stack.js';
import { FormattingElementList, EntryType } from './formatting-element-list.js';
import { defaultTreeAdapter } from '../tree-adapters/default.js';
import * as doctype from '../common/doctype.js';
import * as foreignContent from '../common/foreign-content.js';
import { ERR } from '../common/error-codes.js';
import * as unicode from '../common/unicode.js';
import { TAG_ID as $, TAG_NAMES as TN, NS, ATTRS, SPECIAL_ELEMENTS, DOCUMENT_MODE, NUMBERED_HEADERS, getTagID, } from '../common/html.js';
import { TokenType, getTokenAttr, } from '../common/token.js';
//Misc constants
const HIDDEN_INPUT_TYPE = 'hidden';
//Adoption agency loops iteration count
const AA_OUTER_LOOP_ITER = 8;
const AA_INNER_LOOP_ITER = 3;
//Insertion modes
var InsertionMode;
(function (InsertionMode) {
InsertionMode[InsertionMode["INITIAL"] = 0] = "INITIAL";
InsertionMode[InsertionMode["BEFORE_HTML"] = 1] = "BEFORE_HTML";
InsertionMode[InsertionMode["BEFORE_HEAD"] = 2] = "BEFORE_HEAD";
InsertionMode[InsertionMode["IN_HEAD"] = 3] = "IN_HEAD";
InsertionMode[InsertionMode["IN_HEAD_NO_SCRIPT"] = 4] = "IN_HEAD_NO_SCRIPT";
InsertionMode[InsertionMode["AFTER_HEAD"] = 5] = "AFTER_HEAD";
InsertionMode[InsertionMode["IN_BODY"] = 6] = "IN_BODY";
InsertionMode[InsertionMode["TEXT"] = 7] = "TEXT";
InsertionMode[InsertionMode["IN_TABLE"] = 8] = "IN_TABLE";
InsertionMode[InsertionMode["IN_TABLE_TEXT"] = 9] = "IN_TABLE_TEXT";
InsertionMode[InsertionMode["IN_CAPTION"] = 10] = "IN_CAPTION";
InsertionMode[InsertionMode["IN_COLUMN_GROUP"] = 11] = "IN_COLUMN_GROUP";
InsertionMode[InsertionMode["IN_TABLE_BODY"] = 12] = "IN_TABLE_BODY";
InsertionMode[InsertionMode["IN_ROW"] = 13] = "IN_ROW";
InsertionMode[InsertionMode["IN_CELL"] = 14] = "IN_CELL";
InsertionMode[InsertionMode["IN_SELECT"] = 15] = "IN_SELECT";
InsertionMode[InsertionMode["IN_SELECT_IN_TABLE"] = 16] = "IN_SELECT_IN_TABLE";
InsertionMode[InsertionMode["IN_TEMPLATE"] = 17] = "IN_TEMPLATE";
InsertionMode[InsertionMode["AFTER_BODY"] = 18] = "AFTER_BODY";
InsertionMode[InsertionMode["IN_FRAMESET"] = 19] = "IN_FRAMESET";
InsertionMode[InsertionMode["AFTER_FRAMESET"] = 20] = "AFTER_FRAMESET";
InsertionMode[InsertionMode["AFTER_AFTER_BODY"] = 21] = "AFTER_AFTER_BODY";
InsertionMode[InsertionMode["AFTER_AFTER_FRAMESET"] = 22] = "AFTER_AFTER_FRAMESET";
})(InsertionMode || (InsertionMode = {}));
const BASE_LOC = {
startLine: -1,
startCol: -1,
startOffset: -1,
endLine: -1,
endCol: -1,
endOffset: -1,
};
const TABLE_STRUCTURE_TAGS = new Set([$.TABLE, $.TBODY, $.TFOOT, $.THEAD, $.TR]);
const defaultParserOptions = {
scriptingEnabled: true,
sourceCodeLocationInfo: false,
treeAdapter: defaultTreeAdapter,
onParseError: null,
};
//Parser
export class Parser {
constructor(options, document,
/** @internal */
fragmentContext = null,
/** @internal */
scriptHandler = null) {
this.fragmentContext = fragmentContext;
this.scriptHandler = scriptHandler;
this.currentToken = null;
this.stopped = false;
/** @internal */
this.insertionMode = InsertionMode.INITIAL;
/** @internal */
this.originalInsertionMode = InsertionMode.INITIAL;
/** @internal */
this.headElement = null;
/** @internal */
this.formElement = null;
/** Indicates that the current node is not an element in the HTML namespace */
this.currentNotInHTML = false;
/**
* The template insertion mode stack is maintained from the left.
* Ie. the topmost element will always have index 0.
*
* @internal
*/
this.tmplInsertionModeStack = [];
/** @internal */
this.pendingCharacterTokens = [];
/** @internal */
this.hasNonWhitespacePendingCharacterToken = false;
/** @internal */
this.framesetOk = true;
/** @internal */
this.skipNextNewLine = false;
/** @internal */
this.fosterParentingEnabled = false;
this.options = {
...defaultParserOptions,
...options,
};
this.treeAdapter = this.options.treeAdapter;
this.onParseError = this.options.onParseError;
// Always enable location info if we report parse errors.
if (this.onParseError) {
this.options.sourceCodeLocationInfo = true;
}
this.document = document !== null && document !== void 0 ? document : this.treeAdapter.createDocument();
this.tokenizer = new Tokenizer(this.options, this);
this.activeFormattingElements = new FormattingElementList(this.treeAdapter);
this.fragmentContextID = fragmentContext ? getTagID(this.treeAdapter.getTagName(fragmentContext)) : $.UNKNOWN;
this._setContextModes(fragmentContext !== null && fragmentContext !== void 0 ? fragmentContext : this.document, this.fragmentContextID);
this.openElements = new OpenElementStack(this.document, this.treeAdapter, this);
}
// API
static parse(html, options) {
const parser = new this(options);
parser.tokenizer.write(html, true);
return parser.document;
}
static getFragmentParser(fragmentContext, options) {
const opts = {
...defaultParserOptions,
...options,
};
//NOTE: use a <template> element as the fragment context if no context element was provided,
//so we will parse in a "forgiving" manner
fragmentContext !== null && fragmentContext !== void 0 ? fragmentContext : (fragmentContext = opts.treeAdapter.createElement(TN.TEMPLATE, NS.HTML, []));
//NOTE: create a fake element which will be used as the `document` for fragment parsing.
//This is important for jsdom, where a new `document` cannot be created. This led to
//fragment parsing messing with the main `document`.
const documentMock = opts.treeAdapter.createElement('documentmock', NS.HTML, []);
const parser = new this(opts, documentMock, fragmentContext);
if (parser.fragmentContextID === $.TEMPLATE) {
parser.tmplInsertionModeStack.unshift(InsertionMode.IN_TEMPLATE);
}
parser._initTokenizerForFragmentParsing();
parser._insertFakeRootElement();
parser._resetInsertionMode();
parser._findFormInFragmentContext();
return parser;
}
getFragment() {
const rootElement = this.treeAdapter.getFirstChild(this.document);
const fragment = this.treeAdapter.createDocumentFragment();
this._adoptNodes(rootElement, fragment);
return fragment;
}
//Errors
/** @internal */
_err(token, code, beforeToken) {
var _a;
if (!this.onParseError)
return;
const loc = (_a = token.location) !== null && _a !== void 0 ? _a : BASE_LOC;
const err = {
code,
startLine: loc.startLine,
startCol: loc.startCol,
startOffset: loc.startOffset,
endLine: beforeToken ? loc.startLine : loc.endLine,
endCol: beforeToken ? loc.startCol : loc.endCol,
endOffset: beforeToken ? loc.startOffset : loc.endOffset,
};
this.onParseError(err);
}
//Stack events
/** @internal */
onItemPush(node, tid, isTop) {
var _a, _b;
(_b = (_a = this.treeAdapter).onItemPush) === null || _b === void 0 ? void 0 : _b.call(_a, node);
if (isTop && this.openElements.stackTop > 0)
this._setContextModes(node, tid);
}
/** @internal */
onItemPop(node, isTop) {
var _a, _b;
if (this.options.sourceCodeLocationInfo) {
this._setEndLocation(node, this.currentToken);
}
(_b = (_a = this.treeAdapter).onItemPop) === null || _b === void 0 ? void 0 : _b.call(_a, node, this.openElements.current);
if (isTop) {
let current;
let currentTagId;
if (this.openElements.stackTop === 0 && this.fragmentContext) {
current = this.fragmentContext;
currentTagId = this.fragmentContextID;
}
else {
({ current, currentTagId } = this.openElements);
}
this._setContextModes(current, currentTagId);
}
}
_setContextModes(current, tid) {
const isHTML = current === this.document || (current && this.treeAdapter.getNamespaceURI(current) === NS.HTML);
this.currentNotInHTML = !isHTML;
this.tokenizer.inForeignNode =
!isHTML && current !== undefined && tid !== undefined && !this._isIntegrationPoint(tid, current);
}
/** @protected */
_switchToTextParsing(currentToken, nextTokenizerState) {
this._insertElement(currentToken, NS.HTML);
this.tokenizer.state = nextTokenizerState;
this.originalInsertionMode = this.insertionMode;
this.insertionMode = InsertionMode.TEXT;
}
switchToPlaintextParsing() {
this.insertionMode = InsertionMode.TEXT;
this.originalInsertionMode = InsertionMode.IN_BODY;
this.tokenizer.state = TokenizerMode.PLAINTEXT;
}
//Fragment parsing
/** @protected */
_getAdjustedCurrentElement() {
return this.openElements.stackTop === 0 && this.fragmentContext
? this.fragmentContext
: this.openElements.current;
}
/** @protected */
_findFormInFragmentContext() {
let node = this.fragmentContext;
while (node) {
if (this.treeAdapter.getTagName(node) === TN.FORM) {
this.formElement = node;
break;
}
node = this.treeAdapter.getParentNode(node);
}
}
_initTokenizerForFragmentParsing() {
if (!this.fragmentContext || this.treeAdapter.getNamespaceURI(this.fragmentContext) !== NS.HTML) {
return;
}
switch (this.fragmentContextID) {
case $.TITLE:
case $.TEXTAREA: {
this.tokenizer.state = TokenizerMode.RCDATA;
break;
}
case $.STYLE:
case $.XMP:
case $.IFRAME:
case $.NOEMBED:
case $.NOFRAMES:
case $.NOSCRIPT: {
this.tokenizer.state = TokenizerMode.RAWTEXT;
break;
}
case $.SCRIPT: {
this.tokenizer.state = TokenizerMode.SCRIPT_DATA;
break;
}
case $.PLAINTEXT: {
this.tokenizer.state = TokenizerMode.PLAINTEXT;
break;
}
default:
// Do nothing
}
}
//Tree mutation
/** @protected */
_setDocumentType(token) {
const name = token.name || '';
const publicId = token.publicId || '';
const systemId = token.systemId || '';
this.treeAdapter.setDocumentType(this.document, name, publicId, systemId);
if (token.location) {
const documentChildren = this.treeAdapter.getChildNodes(this.document);
const docTypeNode = documentChildren.find((node) => this.treeAdapter.isDocumentTypeNode(node));
if (docTypeNode) {
this.treeAdapter.setNodeSourceCodeLocation(docTypeNode, token.location);
}
}
}
/** @protected */
_attachElementToTree(element, location) {
if (this.options.sourceCodeLocationInfo) {
const loc = location && {
...location,
startTag: location,
};
this.treeAdapter.setNodeSourceCodeLocation(element, loc);
}
if (this._shouldFosterParentOnInsertion()) {
this._fosterParentElement(element);
}
else {
const parent = this.openElements.currentTmplContentOrNode;
this.treeAdapter.appendChild(parent !== null && parent !== void 0 ? parent : this.document, element);
}
}
/**
* For self-closing tags. Add an element to the tree, but skip adding it
* to the stack.
*/
/** @protected */
_appendElement(token, namespaceURI) {
const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
this._attachElementToTree(element, token.location);
}
/** @protected */
_insertElement(token, namespaceURI) {
const element = this.treeAdapter.createElement(token.tagName, namespaceURI, token.attrs);
this._attachElementToTree(element, token.location);
this.openElements.push(element, token.tagID);
}
/** @protected */
_insertFakeElement(tagName, tagID) {
const element = this.treeAdapter.createElement(tagName, NS.HTML, []);
this._attachElementToTree(element, null);
this.openElements.push(element, tagID);
}
/** @protected */
_insertTemplate(token) {
const tmpl = this.treeAdapter.createElement(token.tagName, NS.HTML, token.attrs);
const content = this.treeAdapter.createDocumentFragment();
this.treeAdapter.setTemplateContent(tmpl, content);
this._attachElementToTree(tmpl, token.location);
this.openElements.push(tmpl, token.tagID);
if (this.options.sourceCodeLocationInfo)
this.treeAdapter.setNodeSourceCodeLocation(content, null);
}
/** @protected */
_insertFakeRootElement() {
const element = this.treeAdapter.createElement(TN.HTML, NS.HTML, []);
if (this.options.sourceCodeLocationInfo)
this.treeAdapter.setNodeSourceCodeLocation(element, null);
this.treeAdapter.appendChild(this.openElements.current, element);
this.openElements.push(element, $.HTML);
}
/** @protected */
_appendCommentNode(token, parent) {
const commentNode = this.treeAdapter.createCommentNode(token.data);
this.treeAdapter.appendChild(parent, commentNode);
if (this.options.sourceCodeLocationInfo) {
this.treeAdapter.setNodeSourceCodeLocation(commentNode, token.location);
}
}
/** @protected */
_insertCharacters(token) {
let parent;
let beforeElement;
if (this._shouldFosterParentOnInsertion()) {
({ parent, beforeElement } = this._findFosterParentingLocation());
if (beforeElement) {
this.treeAdapter.insertTextBefore(parent, token.chars, beforeElement);
}
else {
this.treeAdapter.insertText(parent, token.chars);
}
}
else {
parent = this.openElements.currentTmplContentOrNode;
this.treeAdapter.insertText(parent, token.chars);
}
if (!token.location)
return;
const siblings = this.treeAdapter.getChildNodes(parent);
const textNodeIdx = beforeElement ? siblings.lastIndexOf(beforeElement) : siblings.length;
const textNode = siblings[textNodeIdx - 1];
//NOTE: if we have a location assigned by another token, then just update the end position
const tnLoc = this.treeAdapter.getNodeSourceCodeLocation(textNode);
if (tnLoc) {
const { endLine, endCol, endOffset } = token.location;
this.treeAdapter.updateNodeSourceCodeLocation(textNode, { endLine, endCol, endOffset });
}
else if (this.options.sourceCodeLocationInfo) {
this.treeAdapter.setNodeSourceCodeLocation(textNode, token.location);
}
}
/** @protected */
_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);
}
}
/** @protected */
_setEndLocation(element, closingToken) {
if (this.treeAdapter.getNodeSourceCodeLocation(element) && closingToken.location) {
const ctLoc = closingToken.location;
const tn = this.treeAdapter.getTagName(element);
const endLoc =
// NOTE: For cases like <p> <p> </p> - First 'p' closes without a closing
// tag and for cases like <td> <p> </td> - 'p' closes without a closing tag.
closingToken.type === TokenType.END_TAG && tn === closingToken.tagName
? {
endTag: { ...ctLoc },
endLine: ctLoc.endLine,
endCol: ctLoc.endCol,
endOffset: ctLoc.endOffset,
}
: {
endLine: ctLoc.startLine,
endCol: ctLoc.startCol,
endOffset: ctLoc.startOffset,
};
this.treeAdapter.updateNodeSourceCodeLocation(element, endLoc);
}
}
//Token processing
shouldProcessStartTagTokenInForeignContent(token) {
// Check that neither current === document, or ns === NS.HTML
if (!this.currentNotInHTML)
return false;
let current;
let currentTagId;
if (this.openElements.stackTop === 0 && this.fragmentContext) {
current = this.fragmentContext;
currentTagId = this.fragmentContextID;
}
else {
({ current, currentTagId } = this.openElements);
}
if (token.tagID === $.SVG &&
this.treeAdapter.getTagName(current) === TN.ANNOTATION_XML &&
this.treeAdapter.getNamespaceURI(current) === NS.MATHML) {
return false;
}
return (
// Check that `current` is not an integration point for HTML or MathML elements.
this.tokenizer.inForeignNode ||
// If it _is_ an integration point, then we might have to check that it is not an HTML
// integration point.
((token.tagID === $.MGLYPH || token.tagID === $.MALIGNMARK) &&
currentTagId !== undefined &&
!this._isIntegrationPoint(currentTagId, current, NS.HTML)));
}
/** @protected */
_processToken(token) {
switch (token.type) {
case TokenType.CHARACTER: {
this.onCharacter(token);
break;
}
case TokenType.NULL_CHARACTER: {
this.onNullCharacter(token);
break;
}
case TokenType.COMMENT: {
this.onComment(token);
break;
}
case TokenType.DOCTYPE: {
this.onDoctype(token);
break;
}
case TokenType.START_TAG: {
this._processStartTag(token);
break;
}
case TokenType.END_TAG: {
this.onEndTag(token);
break;
}
case TokenType.EOF: {
this.onEof(token);
break;
}
case TokenType.WHITESPACE_CHARACTER: {
this.onWhitespaceCharacter(token);
break;
}
}
}
//Integration points
/** @protected */
_isIntegrationPoint(tid, element, foreignNS) {
const ns = this.treeAdapter.getNamespaceURI(element);
const attrs = this.treeAdapter.getAttrList(element);
return foreignContent.isIntegrationPoint(tid, ns, attrs, foreignNS);
}
//Active formatting elements reconstruction
/** @protected */
_reconstructActiveFormattingElements() {
const listLength = this.activeFormattingElements.entries.length;
if (listLength) {
const endIndex = this.activeFormattingElements.entries.findIndex((entry) => entry.type === EntryType.Marker || this.openElements.contains(entry.element));
const unopenIdx = endIndex === -1 ? listLength - 1 : endIndex - 1;
for (let i = unopenIdx; i >= 0; i--) {
const entry = this.activeFormattingElements.entries[i];
this._insertElement(entry.token, this.treeAdapter.getNamespaceURI(entry.element));
entry.element = this.openElements.current;
}
}
}
//Close elements
/** @protected */
_closeTableCell() {
this.openElements.generateImpliedEndTags();
this.openElements.popUntilTableCellPopped();
this.activeFormattingElements.clearToLastMarker();
this.insertionMode = InsertionMode.IN_ROW;
}
/** @protected */
_closePElement() {
this.openElements.generateImpliedEndTagsWithExclusion($.P);
this.openElements.popUntilTagNamePopped($.P);
}
//Insertion modes
/** @protected */
_resetInsertionMode() {
for (let i = this.openElements.stackTop; i >= 0; i--) {
//Insertion mode reset map
switch (i === 0 && this.fragmentContext ? this.fragmentContextID : this.openElements.tagIDs[i]) {
case $.TR: {
this.insertionMode = InsertionMode.IN_ROW;
return;
}
case $.TBODY:
case $.THEAD:
case $.TFOOT: {
this.insertionMode = InsertionMode.IN_TABLE_BODY;
return;
}
case $.CAPTION: {
this.insertionMode = InsertionMode.IN_CAPTION;
return;
}
case $.COLGROUP: {
this.insertionMode = InsertionMode.IN_COLUMN_GROUP;
return;
}
case $.TABLE: {
this.insertionMode = InsertionMode.IN_TABLE;
return;
}
case $.BODY: {
this.insertionMode = InsertionMode.IN_BODY;
return;
}
case $.FRAMESET: {
this.insertionMode = InsertionMode.IN_FRAMESET;
return;
}
case $.SELECT: {
this._resetInsertionModeForSelect(i);
return;
}
case $.TEMPLATE: {
this.insertionMode = this.tmplInsertionModeStack[0];
return;
}
case $.HTML: {
this.insertionMode = this.headElement ? InsertionMode.AFTER_HEAD : InsertionMode.BEFORE_HEAD;
return;
}
case $.TD:
case $.TH: {
if (i > 0) {
this.insertionMode = InsertionMode.IN_CELL;
return;
}
break;
}
case $.HEAD: {
if (i > 0) {
this.insertionMode = InsertionMode.IN_HEAD;
return;
}
break;
}
}
}
this.insertionMode = InsertionMode.IN_BODY;
}
/** @protected */
_resetInsertionModeForSelect(selectIdx) {
if (selectIdx > 0) {
for (let i = selectIdx - 1; i > 0; i--) {
const tn = this.openElements.tagIDs[i];
if (tn === $.TEMPLATE) {
break;
}
else if (tn === $.TABLE) {
this.insertionMode = InsertionMode.IN_SELECT_IN_TABLE;
return;
}
}
}
this.insertionMode = InsertionMode.IN_SELECT;
}
//Foster parenting
/** @protected */
_isElementCausesFosterParenting(tn) {
return TABLE_STRUCTURE_TAGS.has(tn);
}
/** @protected */
_shouldFosterParentOnInsertion() {
return (this.fosterParentingEnabled &&
this.openElements.currentTagId !== undefined &&
this._isElementCausesFosterParenting(this.openElements.currentTagId));
}
/** @protected */
_findFosterParentingLocation() {
for (let i = this.openElements.stackTop; i >= 0; i--) {
const openElement = this.openElements.items[i];
switch (this.openElements.tagIDs[i]) {
case $.TEMPLATE: {
if (this.treeAdapter.getNamespaceURI(openElement) === NS.HTML) {
return { parent: this.treeAdapter.getTemplateContent(openElement), beforeElement: null };
}
break;
}
case $.TABLE: {
const parent = this.treeAdapter.getParentNode(openElement);
if (parent) {
return { parent, beforeElement: openElement };
}
return { parent: this.openElements.items[i - 1], beforeElement: null };
}
default:
// Do nothing
}
}
return { parent: this.openElements.items[0], beforeElement: null };
}
/** @protected */
_fosterParentElement(element) {
const location = this._findFosterParentingLocation();
if (location.beforeElement) {
this.treeAdapter.insertBefore(location.parent, element, location.beforeElement);
}
else {
this.treeAdapter.appendChild(location.parent, element);
}
}
//Special elements
/** @protected */
_isSpecialElement(element, id) {
const ns = this.treeAdapter.getNamespaceURI(element);
return SPECIAL_ELEMENTS[ns].has(id);
}
/** @internal */
onCharacter(token) {
this.skipNextNewLine = false;
if (this.tokenizer.inForeignNode) {
characterInForeignContent(this, token);
return;
}
switch (this.insertionMode) {
case InsertionMode.INITIAL: {
tokenInInitialMode(this, token);
break;
}
case InsertionMode.BEFORE_HTML: {
tokenBeforeHtml(this, token);
break;
}
case InsertionMode.BEFORE_HEAD: {
tokenBeforeHead(this, token);
break;
}
case InsertionMode.IN_HEAD: {
tokenInHead(this, token);
break;
}
case InsertionMode.IN_HEAD_NO_SCRIPT: {
tokenInHeadNoScript(this, token);
break;
}
case InsertionMode.AFTER_HEAD: {
tokenAfterHead(this, token);
break;
}
case InsertionMode.IN_BODY:
case InsertionMode.IN_CAPTION:
case InsertionMode.IN_CELL:
case InsertionMode.IN_TEMPLATE: {
characterInBody(this, token);
break;
}
case InsertionMode.TEXT:
case InsertionMode.IN_SELECT:
case InsertionMode.IN_SELECT_IN_TABLE: {
this._insertCharacters(token);
break;
}
case InsertionMode.IN_TABLE:
case InsertionMode.IN_TABLE_BODY:
case InsertionMode.IN_ROW: {
characterInTable(this, token);
break;
}
case InsertionMode.IN_TABLE_TEXT: {
characterInTableText(this, token);
break;
}
case InsertionMode.IN_COLUMN_GROUP: {
tokenInColumnGroup(this, token);
break;
}
case InsertionMode.AFTER_BODY: {
tokenAfterBody(this, token);
break;
}
case InsertionMode.AFTER_AFTER_BODY: {
tokenAfterAfterBody(this, token);
break;
}
default:
// Do nothing
}
}
/** @internal */
onNullCharacter(token) {
this.skipNextNewLine = false;
if (this.tokenizer.inForeignNode) {
nullCharacterInForeignContent(this, token);
return;
}
switch (this.insertionMode) {
case InsertionMode.INITIAL: {
tokenInInitialMode(this, token);
break;
}
case InsertionMode.BEFORE_HTML: {
tokenBeforeHtml(this, token);
break;
}
case InsertionMode.BEFORE_HEAD: {
tokenBeforeHead(this, token);
break;
}
case InsertionMode.IN_HEAD: {
tokenInHead(this, token);
break;
}
case InsertionMode.IN_HEAD_NO_SCRIPT: {
tokenInHeadNoScript(this, token);
break;
}
case InsertionMode.AFTER_HEAD: {
tokenAfterHead(this, token);
break;
}
case InsertionMode.TEXT: {
this._insertCharacters(token);
break;
}
case InsertionMode.IN_TABLE:
case InsertionMode.IN_TABLE_BODY:
case InsertionMode.IN_ROW: {
characterInTable(this, token);
break;
}
case InsertionMode.IN_COLUMN_GROUP: {
tokenInColumnGroup(this, token);
break;
}
case InsertionMode.AFTER_BODY: {
tokenAfterBody(this, token);
break;
}
case InsertionMode.AFTER_AFTER_BODY: {
tokenAfterAfterBody(this, token);
break;
}
default:
// Do nothing
}
}
/** @internal */
onComment(token) {
this.skipNextNewLine = false;
if (this.currentNotInHTML) {
appendComment(this, token);
return;
}
switch (this.insertionMode) {
case InsertionMode.INITIAL:
case InsertionMode.BEFORE_HTML:
case InsertionMode.BEFORE_HEAD:
case InsertionMode.IN_HEAD:
case InsertionMode.IN_HEAD_NO_SCRIPT:
case InsertionMode.AFTER_HEAD:
case InsertionMode.IN_BODY:
case InsertionMode.IN_TABLE:
case InsertionMode.IN_CAPTION:
case InsertionMode.IN_COLUMN_GROUP:
case InsertionMode.IN_TABLE_BODY:
case InsertionMode.IN_ROW:
case InsertionMode.IN_CELL:
case InsertionMode.IN_SELECT:
case InsertionMode.IN_SELECT_IN_TABLE:
case InsertionMode.IN_TEMPLATE:
case InsertionMode.IN_FRAMESET:
case InsertionMode.AFTER_FRAMESET: {
appendComment(this, token);
break;
}
case InsertionMode.IN_TABLE_TEXT: {
tokenInTableText(this, token);
break;
}
case InsertionMode.AFTER_BODY: {
appendCommentToRootHtmlElement(this, token);
break;
}
case InsertionMode.AFTER_AFTER_BODY:
case InsertionMode.AFTER_AFTER_FRAMESET: {
appendCommentToDocument(this, token);
break;
}
default:
// Do nothing
}
}
/** @internal */
onDoctype(token) {
this.skipNextNewLine = false;
switch (this.insertionMode) {
case InsertionMode.INITIAL: {
doctypeInInitialMode(this, token);
break;
}
case InsertionMode.BEFORE_HEAD:
case InsertionMode.IN_HEAD:
case InsertionMode.IN_HEAD_NO_SCRIPT:
case InsertionMode.AFTER_HEAD: {
this._err(token, ERR.misplacedDoctype);
break;
}
case InsertionMode.IN_TABLE_TEXT: {
tokenInTableText(this, token);
break;
}
default:
// Do nothing
}
}
/** @internal */
onStartTag(token) {
this.skipNextNewLine = false;
this.currentToken = token;
this._processStartTag(token);
if (token.selfClosing && !token.ackSelfClosing) {
this._err(token, ERR.nonVoidHtmlElementStartTagWithTrailingSolidus);
}
}
/**
* Processes a given start tag.
*
* `onStartTag` checks if a self-closing tag was recognized. When a token
* is moved inbetween multiple insertion modes, this check for self-closing
* could lead to false positives. To avoid this, `_processStartTag` is used
* for nested calls.
*
* @param token The token to process.
* @protected
*/
_processStartTag(token) {
if (this.shouldProcessStartTagTokenInForeignContent(token)) {
startTagInForeignContent(this, token);
}
else {
this._startTagOutsideForeignContent(token);
}
}
/** @protected */
_startTagOutsideForeignContent(token) {
switch (this.insertionMode) {
case InsertionMode.INITIAL: {
tokenInInitialMode(this, token);
break;
}
case InsertionMode.BEFORE_HTML: {
startTagBeforeHtml(this, token);
break;
}
case InsertionMode.BEFORE_HEAD: {
startTagBeforeHead(this, token);
break;
}
case InsertionMode.IN_HEAD: {
startTagInHead(this, token);
break;
}
case InsertionMode.IN_HEAD_NO_SCRIPT: {
startTagInHeadNoScript(this, token);
break;
}
case InsertionMode.AFTER_HEAD: {
startTagAfterHead(this, token);
break;
}
case InsertionMode.IN_BODY: {
startTagInBody(this, token);
break;
}
case InsertionMode.IN_TABLE: {
startTagInTable(this, token);
break;
}
case InsertionMode.IN_TABLE_TEXT: {
tokenInTableText(this, token);
break;
}
case InsertionMode.IN_CAPTION: {
startTagInCaption(this, token);
break;
}
case InsertionMode.IN_COLUMN_GROUP: {
startTagInColumnGroup(this, token);
break;
}
case InsertionMode.IN_TABLE_BODY: {
startTagInTableBody(this, token);
break;
}
case InsertionMode.IN_ROW: {
startTagInRow(this, token);
break;
}
case InsertionMode.IN_CELL: {
startTagInCell(this, token);
break;
}
case InsertionMode.IN_SELECT: {
startTagInSelect(this, token);
break;
}
case InsertionMode.IN_SELECT_IN_TABLE: {
startTagInSelectInTable(this, token);
break;
}
case InsertionMode.IN_TEMPLATE: {
startTagInTemplate(this, token);
break;
}
case InsertionMode.AFTER_BODY: {
startTagAfterBody(this, token);
break;
}
case InsertionMode.IN_FRAMESET: {
startTagInFrameset(this, token);
break;
}
case InsertionMode.AFTER_FRAMESET: {
startTagAfterFrameset(this, token);
break;
}
case InsertionMode.AFTER_AFTER_BODY: {
startTagAfterAfterBody(this, token);
break;
}
case InsertionMode.AFTER_AFTER_FRAMESET: {
startTagAfterAfterFrameset(this, token);
break;
}
default:
// Do nothing
}
}
/** @internal */
onEndTag(token) {
this.skipNextNewLine = false;
this.currentToken = token;
if (this.currentNotInHTML) {
endTagInForeignContent(this, token);
}
else {
this._endTagOutsideForeignContent(token);
}
}
/** @protected */
_endTagOutsideForeignContent(token) {
switch (this.insertionMode) {
case InsertionMode.INITIAL: {
tokenInInitialMode(this, token);
break;
}
case InsertionMode.BEFORE_HTML: {
endTagBeforeHtml(this, token);
break;
}
case InsertionMode.BEFORE_HEAD: {
endTagBeforeHead(this, token);
break;
}
case InsertionMode.IN_HEAD: {
endTagInHead(this, token);
break;
}
case InsertionMode.IN_HEAD_NO_SCRIPT: {
endTagInHeadNoScript(this, token);
break;
}
case InsertionMode.AFTER_HEAD: {
endTagAfterHead(this, token);
break;
}
case InsertionMode.IN_BODY: {
endTagInBody(this, token);
break;
}
case InsertionMode.TEXT: {
endTagInText(this, token);
break;
}
case InsertionMode.IN_TABLE: {
endTagInTable(this, token);
break;
}
case InsertionMode.IN_TABLE_TEXT: {
tokenInTableText(this, token);
break;
}
case InsertionMode.IN_CAPTION: {
endTagInCaption(this, token);
break;
}
case InsertionMode.IN_COLUMN_GROUP: {
endTagInColumnGroup(this, token);
break;
}
case InsertionMode.IN_TABLE_BODY: {
endTagInTableBody(this, token);
break;
}
case InsertionMode.IN_ROW: {
endTagInRow(this, token);
break;
}
case InsertionMode.IN_CELL: {
endTagInCell(this, token);
break;
}
case InsertionMode.IN_SELECT: {
endTagInSelect(this, token);
break;
}
case InsertionMode.IN_SELECT_IN_TABLE: {
endTagInSelectInTable(this, token);
break;
}
case InsertionMode.IN_TEMPLATE: {
endTagInTemplate(this, token);
break;
}
case InsertionMode.AFTER_BODY: {
endTagAfterBody(this, token);
break;
}
case InsertionMode.IN_FRAMESET: {
endTagInFrameset(this, token);
break;
}
case InsertionMode.AFTER_FRAMESET: {
endTagAfterFrameset(this, token);
break;
}
case InsertionMode.AFTER_AFTER_BODY: {
tokenAfterAfterBody(this, token);
break;
}
default:
// Do nothing
}
}
/** @internal */
onEof(token) {
switch (this.insertionMode) {
case InsertionMode.INITIAL: {
tokenInInitialMode(this, token);
break;
}
case InsertionMode.BEFORE_HTML: {
tokenBeforeHtml(this, token);
break;
}
case InsertionMode.BEFORE_HEAD: {
tokenBeforeHead(this, token);
break;
}
case InsertionMode.IN_HEAD: {
tokenInHead(this, token);
break;
}
case InsertionMode.IN_HEAD_NO_SCRIPT: {
tokenInHeadNoScript(this, token);
break;
}
case InsertionMode.AFTER_HEAD: {
tokenAfterHead(this, token);
break;
}
case InsertionMode.IN_BODY:
case InsertionMode.IN_TABLE:
case InsertionMode.IN_CAPTION:
case InsertionMode.IN_COLUMN_GROUP:
case InsertionMode.IN_TABLE_BODY:
case InsertionMode.IN_ROW:
case InsertionMode.IN_CELL:
case InsertionMode.IN_SELECT:
case InsertionMode.IN_SELECT_IN_TABLE: {
eofInBody(this, token);
break;
}
case InsertionMode.TEXT: {
eofInText(this, token);
break;
}
case InsertionMode.IN_TABLE_TEXT: {
tokenInTableText(this, token);
break;
}
case InsertionMode.IN_TEMPLATE: {
eofInTemplate(this, token);
break;
}
case InsertionMode.AFTER_BODY:
case InsertionMode.IN_FRAMESET:
case InsertionMode.AFTER_FRAMESET:
case InsertionMode.AFTER_AFTER_BODY:
case InsertionMode.AFTER_AFTER_FRAMESET: {
stopParsing(this, token);
break;
}
default:
// Do nothing
}
}
/** @internal */
onWhitespaceCharacter(token) {
if (this.skipNextNewLine) {
this.skipNextNewLine = false;
if (token.chars.charCodeAt(0) === unicode.CODE_POINTS.LINE_FEED) {
if (token.chars.length === 1) {
return;
}
token.chars = token.chars.substr(1);
}
}
if (this.tokenizer.inForeignNode) {
this._insertCharacters(token);
return;
}
switch (this.insertionMode) {
case InsertionMode.IN_HEAD:
case InsertionMode.IN_HEAD_NO_SCRIPT:
case InsertionMode.AFTER_HEAD:
case InsertionMode.TEXT:
case InsertionMode.IN_COLUMN_GROUP:
case InsertionMode.IN_SELECT:
case InsertionMode.IN_SELECT_IN_TABLE:
case InsertionMode.IN_FRAMESET:
case InsertionMode.AFTER_FRAMESET: {
this._insertCharacters(token);
break;
}
case InsertionMode.IN_BODY:
case InsertionMode.IN_CAPTION:
case InsertionMode.IN_CELL:
case InsertionMode.IN_TEMPLATE:
case InsertionMode.AFTER_BODY:
case InsertionMode.AFTER_AFTER_BODY:
case InsertionMode.AFTER_AFTER_FRAMESET: {
whitespaceCharacterInBody(this, token);
break;
}
case InsertionMode.IN_TABLE:
case InsertionMode.IN_TABLE_BODY:
case InsertionMode.IN_ROW: {
characterInTable(this, token);
break;
}
case InsertionMode.IN_TABLE_TEXT: {
whitespaceCharacterInTableText(this, token);
break;
}
default:
// Do nothing
}
}
}
//Adoption agency algorithm
//(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/tree-construction.html#adoptionAgency)
//------------------------------------------------------------------
//Steps 5-8 of the algorithm
function aaObtainFormattingElementEntry(p, token) {
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.tagID)) {
formattingElementEntry = null;
}
}
else {
genericEndTagInBody(p, token);
}
return formattingElementEntry;
}
//Steps 9 and 10 of the algorithm
function aaObtainFurthestBlock(p, formattingElementEntry) {
let furthestBlock = null;
let idx = p.openElements.stackTop;
for (; idx >= 0; idx--) {
const element = p.openElements.items[idx];
if (element === formattingElementEntry.element) {
break;
}
if (p._isSpecialElement(element, p.openElements.tagIDs[idx])) {
furthestBlock = element;
}
}
if (!furthestBlock) {
p.openElements.shortenToLength(Math.max(idx, 0));
p.activeFormattingElements.removeEntry(formattingElementEntry);
}
return furthestBlock;
}
//Step 13 of the algorithm
function aaInnerLoop(p, furthestBlock, formattingElement) {
let lastElement = furthestBlock;
let nextElement = p.openElements.getCommonAncestor(furthestBlock);
for (let i = 0, element = nextElement; element !== formattingElement; i++, element = nextElement) {
//NOTE: store the next element for the next loop iteration (it may be deleted from the stack by step 9.5)
nextElement = p.openElements.getCommonAncestor(element);
const elementEntry = p.activeFormattingElements.getElementEntry(element);
const counterOverflow = elementEntry && i >= AA_INNER_LOOP_ITER;
const shouldRemoveFromOpenElements = !elementEntry || counterOverflow;
if (shouldRemoveFromOpenElements) {
if (counterOverflow) {
p.activeFormattingElements.removeEntry(elementEntry);
}
p.openElements.remove(element);
}
else {
element = aaRecreateElementFromEntry(p, elementEntry);
if (lastElement === furthestBlock) {
p.activeFormattingElements.bookmark = elementEntry;
}
p.treeAdapter.detachNode(lastElement);
p.treeAdapter.appendChild(element, lastElement);
lastElement = element;
}
}
return lastElement;
}
//Step 13.7 of the algorithm
function aaRecreateElementFromEntry(p, elementEntry) {
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;
return newElement;
}
//Step 14 of the algorithm
function aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement) {
const tn = p.treeAdapter.getTagName(commonAncestor);
const tid = getTagID(tn);
if (p._isElementCausesFosterParenting(tid)) {
p._fosterParentElement(lastElement);
}
else {
const ns = p.treeAdapter.getNamespaceURI(commonAncestor);
if (tid === $.TEMPLATE && ns === NS.HTML) {
commonAncestor = p.treeAdapter.getTemplateContent(commonAncestor);
}
p.treeAdapter.appendChild(commonAncestor, lastElement);
}
}
//Steps 15-19 of the algorithm
function aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry) {
const ns = p.treeAdapter.getNamespaceURI(formattingElementEntry.element);
const { token } = formattingElementEntry;
const newElement = p.treeAdapter.createElement(token.tagName, ns, token.attrs);
p._adoptNodes(furthestBlock, newElement);
p.treeAdapter.appendChild(furthestBlock, newElement);
p.activeFormattingElements.insertElementAfterBookmark(newElement, token);
p.activeFormattingElements.removeEntry(formattingElementEntry);
p.openElements.remove(formattingElementEntry.element);
p.openElements.insertAfter(furthestBlock, newElement, token.tagID);
}
//Algorithm entry point
function callAdoptionAgency(p, token) {
for (let i = 0; i < AA_OUTER_LOOP_ITER; i++) {
const formattingElementEntry = aaObtainFormattingElementEntry(p, token);
if (!formattingElementEntry) {
break;
}
const furthestBlock = aaObtainFurthestBlock(p, formattingElementEntry);
if (!furthestBlock) {
break;
}
p.activeFormattingElements.bookmark = formattingElementEntry;
const lastElement = aaInnerLoop(p, furthestBlock, formattingElementEntry.element);
const commonAncestor = p.openElements.getCommonAncestor(formattingElementEntry.element);
p.treeAdapter.detachNode(lastElement);
if (commonAncestor)
aaInsertLastNodeInCommonAncestor(p, commonAncestor, lastElement);
aaReplaceFormattingElement(p, furthestBlock, formattingElementEntry);
}
}
//Generic token handlers
//------------------------------------------------------------------
function appendComment(p, token) {
p._appendCommentNode(token, p.openElements.currentTmplContentOrNode);
}
function appendCommentToRootHtmlElement(p, token) {
p._appendCommentNode(token, p.openElements.items[0]);
}
function appendCommentToDocument(p, token) {
p._appendCommentNode(token, p.document);
}
function stopParsing(p, token) {
p.stopped = true;
// NOTE: Set end locations for elements that remain on the open element stack.
if (token.location) {
// NOTE: If we are not in a fragment, `html` and `body` will stay on the stack.
// This is a problem, as we might overwrite their end position here.
const target = p.fragmentContext ? 0 : 2;
for (let i = p.openElements.stackTop; i >= target; i--) {
p._setEndLocation(p.openElements.items[i], token);
}
// Handle `html` and `body`
if (!p.fragmentContext && p.openElements.stackTop >= 0) {
const htmlElement = p.openElements.items[0];
const htmlLocation = p.treeAdapter.getNodeSourceCodeLocation(htmlElement);
if (htmlLocation && !htmlLocation.endTag) {
p._setEndLocation(htmlElement, token);
if (p.openElements.stackTop >= 1) {
const bodyElement = p.openElements.items[1];
const bodyLocation = p.treeAdapter.getNodeSourceCodeLocation(bodyElement);
if (bodyLocation && !bodyLocation.endTag) {
p._setEndLocation(bodyElement, token);
}
}
}
}
}
}
// The "initial" insertion mode
//------------------------------------------------------------------
function doctypeInInitialMode(p, token) {
p._setDocumentType(token);
const mode = token.forceQuirks ? DOCUMENT_MODE.QUIRKS : doctype.getDocumentMode(token);
if (!doctype.isConforming(token)) {
p._err(token, ERR.nonConformingDoctype);
}
p.treeAdapter.setDocumentMode(p.document, mode);
p.insertionMode = InsertionMode.BEFORE_HTML;
}
function tokenInInitialMode(p, token) {
p._err(token, ERR.missingDoctype, true);
p.treeAdapter.setDocumentMode(p.document, DOCUMENT_MODE.QUIRKS);
p.insertionMode = InsertionMode.BEFORE_HTML;
p._processToken(token);
}
// The "before html" insertion mode
//------------------------------------------------------------------
function startTagBeforeHtml(p, token) {
if (token.tagID === $.HTML) {
p._insertElement(token, NS.HTML);
p.insertionMode = InsertionMode.BEFORE_HEAD;
}
else {
tokenBeforeHtml(p, token);
}
}
function endTagBeforeHtml(p, token) {
const tn = token.tagID;
if (tn === $.HTML || tn === $.HEAD || tn === $.BODY || tn === $.BR) {
tokenBeforeHtml(p, token);
}
}
function tokenBeforeHtml(p, token) {
p._insertFakeRootElement();
p.insertionMode = InsertionMode.BEFORE_HEAD;
p._processToken(token);
}
// The "before head" insertion mode
//------------------------------------------------------------------
function startTagBeforeHead(p, token) {
switch (token.tagID) {
case $.HTML: {
startTagInBody(p, token);
break;
}
case $.HEAD: {
p._insertElement(token, NS.HTML);
p.headElement = p.openElements.current;
p.insertionMode = InsertionMode.IN_HEAD;
break;
}
default: {
tokenBeforeHead(p, token);
}
}
}
function endTagBeforeHead(p, token) {
const tn = token.tagID;
if (tn === $.HEAD || tn === $.BODY || tn === $.HTML || tn === $.BR) {
tokenBeforeHead(p, token);
}
else {
p._err(token, ERR.endTagWithoutMatchingOpenElement);
}
}
function tokenBeforeHead(p, token) {
p._insertFakeElement(TN.HEAD, $.HEAD);
p.headElement = p.openElements.current;
p.insertionMode = InsertionMode.IN_HEAD;
p._processToken(token);
}
// The "in head" insertion mode
//------------------------------------------------------------------
function startTagInHead(p, token) {
switch (token.tagID) {
case $.HTML: {
startTagInBody(p, token);
break;
}
case $.BASE:
case $.BASEFONT:
case $.BGSOUND:
case $.LINK:
case $.META: {
p._appendElement(token, NS.HTML);
token.ackSelfClosing = true;
break;
}
case $.TITLE: {
p._switchToTextParsing(token, TokenizerMode.RCDATA);
break;
}
case $.NOSCRIPT: {
if (p.options.scriptingEnabled) {
p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
}
else {
p._insertElement(token, NS.HTML);
p.insertionMode = InsertionMode.IN_HEAD_NO_SCRIPT;
}
break;
}
case $.NOFRAMES:
case $.STYLE: {
p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
break;
}
case $.SCRIPT: {
p._switchToTextParsing(token, TokenizerMode.SCRIPT_DATA);
break;
}
case $.TEMPLATE: {
p._insertTemplate(token);
p.activeFormattingElements.insertMarker();
p.framesetOk = false;
p.insertionMode = InsertionMode.IN_TEMPLATE;
p.tmplInsertionModeStack.unshift(InsertionMode.IN_TEMPLATE);
break;
}
case $.HEAD: {
p._err(token, ERR.misplacedStartTagForHeadElement);
break;
}
default: {
tokenInHead(p, token);
}
}
}
function endTagInHead(p, token) {
switch (token.tagID) {
case $.HEAD: {
p.openElements.pop();
p.insertionMode = InsertionMode.AFTER_HEAD;
break;
}
case $.BODY:
case $.BR:
case $.HTML: {
tokenInHead(p, token);
break;
}
case $.TEMPLATE: {
templateEndTagInHead(p, token);
break;
}
default: {
p._err(token, ERR.endTagWithoutMatchingOpenElement);
}
}
}
function templateEndTagInHead(p, token) {
if (p.openElements.tmplCount > 0) {
p.openElements.generateImpliedEndTagsThoroughly();
if (p.openElements.currentTagId !== $.TEMPLATE) {
p._err(token, ERR.closingOfElementWithOpenChildElements);
}
p.openElements.popUntilTagNamePopped($.TEMPLATE);
p.activeFormattingElements.clearToLastMarker();
p.tmplInsertionModeStack.shift();
p._resetInsertionMode();
}
else {
p._err(token, ERR.endTagWithoutMatchingOpenElement);
}
}
function tokenInHead(p, token) {
p.openElements.pop();
p.insertionMode = InsertionMode.AFTER_HEAD;
p._processToken(token);
}
// The "in head no script" insertion mode
//------------------------------------------------------------------
function startTagInHeadNoScript(p, token) {
switch (token.tagID) {
case $.HTML: {
startTagInBody(p, token);
break;
}
case $.BASEFONT:
case $.BGSOUND:
case $.HEAD:
case $.LINK:
case $.META:
case $.NOFRAMES:
case $.STYLE: {
startTagInHead(p, token);
break;
}
case $.NOSCRIPT: {
p._err(token, ERR.nestedNoscriptInHead);
break;
}
default: {
tokenInHeadNoScript(p, token);
}
}
}
function endTagInHeadNoScript(p, token) {
switch (token.tagID) {
case $.NOSCRIPT: {
p.openElements.pop();
p.insertionMode = InsertionMode.IN_HEAD;
break;
}
case $.BR: {
tokenInHeadNoScript(p, token);
break;
}
default: {
p._err(token, ERR.endTagWithoutMatchingOpenElement);
}
}
}
function tokenInHeadNoScript(p, token) {
const errCode = token.type === TokenType.EOF ? ERR.openElementsLeftAfterEof : ERR.disallowedContentInNoscriptInHead;
p._err(token, errCode);
p.openElements.pop();
p.insertionMode = InsertionMode.IN_HEAD;
p._processToken(token);
}
// The "after head" insertion mode
//------------------------------------------------------------------
function startTagAfterHead(p, token) {
switch (token.tagID) {
case $.HTML: {
startTagInBody(p, token);
break;
}
case $.BODY: {
p._insertElement(token, NS.HTML);
p.framesetOk = false;
p.insertionMode = InsertionMode.IN_BODY;
break;
}
case $.FRAMESET: {
p._insertElement(token, NS.HTML);
p.insertionMode = InsertionMode.IN_FRAMESET;
break;
}
case $.BASE:
case $.BASEFONT:
case $.BGSOUND:
case $.LINK:
case $.META:
case $.NOFRAMES:
case $.SCRIPT:
case $.STYLE:
case $.TEMPLATE:
case $.TITLE: {
p._err(token, ERR.abandonedHeadElementChild);
p.openElements.push(p.headElement, $.HEAD);
startTagInHead(p, token);
p.openElements.remove(p.headElement);
break;
}
case $.HEAD: {
p._err(token, ERR.misplacedStartTagForHeadElement);
break;
}
default: {
tokenAfterHead(p, token);
}
}
}
function endTagAfterHead(p, token) {
switch (token.tagID) {
case $.BODY:
case $.HTML:
case $.BR: {
tokenAfterHead(p, token);
break;
}
case $.TEMPLATE: {
templateEndTagInHead(p, token);
break;
}
default: {
p._err(token, ERR.endTagWithoutMatchingOpenElement);
}
}
}
function tokenAfterHead(p, token) {
p._insertFakeElement(TN.BODY, $.BODY);
p.insertionMode = InsertionMode.IN_BODY;
modeInBody(p, token);
}
// The "in body" insertion mode
//------------------------------------------------------------------
function modeInBody(p, token) {
switch (token.type) {
case TokenType.CHARACTER: {
characterInBody(p, token);
break;
}
case TokenType.WHITESPACE_CHARACTER: {
whitespaceCharacterInBody(p, token);
break;
}
case TokenType.COMMENT: {
appendComment(p, token);
break;
}
case TokenType.START_TAG: {
startTagInBody(p, token);
break;
}
case TokenType.END_TAG: {
endTagInBody(p, token);
break;
}
case TokenType.EOF: {
eofInBody(p, token);
break;
}
default:
// Do nothing
}
}
function whitespaceCharacterInBody(p, token) {
p._reconstructActiveFormattingElements();
p._insertCharacters(token);
}
function characterInBody(p, token) {
p._reconstructActiveFormattingElements();
p._insertCharacters(token);
p.framesetOk = false;
}
function htmlStartTagInBody(p, token) {
if (p.openElements.tmplCount === 0) {
p.treeAdapter.adoptAttributes(p.openElements.items[0], token.attrs);
}
}
function bodyStartTagInBody(p, token) {
const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
if (bodyElement && p.openElements.tmplCount === 0) {
p.framesetOk = false;
p.treeAdapter.adoptAttributes(bodyElement, token.attrs);
}
}
function framesetStartTagInBody(p, token) {
const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
if (p.framesetOk && bodyElement) {
p.treeAdapter.detachNode(bodyElement);
p.openElements.popAllUpToHtmlElement();
p._insertElement(token, NS.HTML);
p.insertionMode = InsertionMode.IN_FRAMESET;
}
}
function addressStartTagInBody(p, token) {
if (p.openElements.hasInButtonScope($.P)) {
p._closePElement();
}
p._insertElement(token, NS.HTML);
}
function numberedHeaderStartTagInBody(p, token) {
if (p.openElements.hasInButtonScope($.P)) {
p._closePElement();
}
if (p.openElements.currentTagId !== undefined && NUMBERED_HEADERS.has(p.openElements.currentTagId)) {
p.openElements.pop();
}
p._insertElement(token, NS.HTML);
}
function preStartTagInBody(p, token) {
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
//on to the next one. (Newlines at the start of pre blocks are ignored as an authoring convenience.)
p.skipNextNewLine = true;
p.framesetOk = false;
}
function formStartTagInBody(p, token) {
const inTemplate = p.openElements.tmplCount > 0;
if (!p.formElement || inTemplate) {
if (p.openElements.hasInButtonScope($.P)) {
p._closePElement();
}
p._insertElement(token, NS.HTML);
if (!inTemplate) {
p.formElement = p.openElements.current;
}
}
}
function listItemStartTagInBody(p, token) {
p.framesetOk = false;
const tn = token.tagID;
for (let i = p.openElements.stackTop; i >= 0; i--) {
const elementId = p.openElements.tagIDs[i];
if ((tn === $.LI && elementId === $.LI) ||
((tn === $.DD || tn === $.DT) && (elementId === $.DD || elementId === $.DT))) {
p.openElements.generateImpliedEndTagsWithExclusion(elementId);
p.openElements.popUntilTagNamePopped(elementId);
break;
}
if (elementId !== $.ADDRESS &&
elementId !== $.DIV &&
elementId !== $.P &&
p._isSpecialElement(p.openElements.items[i], elementId)) {
break;
}
}
if (p.openElements.hasInButtonScope($.P)) {
p._closePElement();
}
p._insertElement(token, NS.HTML);
}
function plaintextStartTagInBody(p, token) {
if (p.openElements.hasInButtonScope($.P)) {
p._closePElement();
}
p._insertElement(token, NS.HTML);
p.tokenizer.state = TokenizerMode.PLAINTEXT;
}
function buttonStartTagInBody(p, token) {
if (p.openElements.hasInScope($.BUTTON)) {
p.openElements.generateImpliedEndTags();
p.openElements.popUntilTagNamePopped($.BUTTON);
}
p._reconstructActiveFormattingElements();
p._insertElement(token, NS.HTML);
p.framesetOk = false;
}
function aStartTagInBody(p, token) {
const activeElementEntry = p.activeFormattingElements.getElementEntryInScopeWithTagName(TN.A);
if (activeElementEntry) {
callAdoptionAgency(p, token);
p.openElements.remove(activeElementEntry.element);
p.activeFormattingElements.removeEntry(activeElementEntry);
}
p._reconstructActiveFormattingElements();
p._insertElement(token, NS.HTML);
p.activeFormattingElements.pushElement(p.openElements.current, token);
}
function bStartTagInBody(p, token) {
p._reconstructActiveFormattingElements();
p._insertElement(token, NS.HTML);
p.activeFormattingElements.pushElement(p.openElements.current, token);
}
function nobrStartTagInBody(p, token) {
p._reconstructActiveFormattingElements();
if (p.openElements.hasInScope($.NOBR)) {
callAdoptionAgency(p, token);
p._reconstructActiveFormattingElements();
}
p._insertElement(token, NS.HTML);
p.activeFormattingElements.pushElement(p.openElements.current, token);
}
function appletStartTagInBody(p, token) {
p._reconstructActiveFormattingElements();
p._insertElement(token, NS.HTML);
p.activeFormattingElements.insertMarker();
p.framesetOk = false;
}
function tableStartTagInBody(p, token) {
if (p.treeAdapter.getDocumentMode(p.document) !== DOCUMENT_MODE.QUIRKS && p.openElements.hasInButtonScope($.P)) {
p._closePElement();
}
p._insertElement(token, NS.HTML);
p.framesetOk = false;
p.insertionMode = InsertionMode.IN_TABLE;
}
function areaStartTagInBody(p, token) {
p._reconstructActiveFormattingElements();
p._appendElement(token, NS.HTML);
p.framesetOk = false;
token.ackSelfClosing = true;
}
function isHiddenInput(token) {
const inputType = getTokenAttr(token, ATTRS.TYPE);
return inputType != null && inputType.toLowerCase() === HIDDEN_INPUT_TYPE;
}
function inputStartTagInBody(p, token) {
p._reconstructActiveFormattingElements();
p._appendElement(token, NS.HTML);
if (!isHiddenInput(token)) {
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)) {
p._closePElement();
}
p._appendElement(token, NS.HTML);
p.framesetOk = false;
token.ackSelfClosing = true;
}
function imageStartTagInBody(p, token) {
token.tagName = TN.IMG;
token.tagID = $.IMG;
areaStartTagInBody(p, token);
}
function textareaStartTagInBody(p, token) {
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
//on to the next one. (Newlines at the start of textarea elements are ignored as an authoring convenience.)
p.skipNextNewLine = true;
p.tokenizer.state = TokenizerMode.RCDATA;
p.originalInsertionMode = p.insertionMode;
p.framesetOk = false;
p.insertionMode = InsertionMode.TEXT;
}
function xmpStartTagInBody(p, token) {
if (p.openElements.hasInButtonScope($.P)) {
p._closePElement();
}
p._reconstructActiveFormattingElements();
p.framesetOk = false;
p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
}
function iframeStartTagInBody(p, token) {
p.framesetOk = false;
p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
}
//NOTE: here we assume that we always act as a user agent with enabled plugins/frames, so we parse
//<noembed>/<noframes> as rawtext.
function rawTextStartTagInBody(p, token) {
p._switchToTextParsing(token, TokenizerMode.RAWTEXT);
}
function selectStartTagInBody(p, token) {
p._reconstructActiveFormattingElements();
p._insertElement(token, NS.HTML);
p.framesetOk = false;
p.insertionMode =
p.insertionMode === InsertionMode.IN_TABLE ||
p.insertionMode === InsertionMode.IN_CAPTION ||
p.insertionMode === InsertionMode.IN_TABLE_BODY ||
p.insertionMode === InsertionMode.IN_ROW ||
p.insertionMode === InsertionMode.IN_CELL
? InsertionMode.IN_SELECT_IN_TABLE
: InsertionMode.IN_SELECT;
}
function optgroupStartTagInBody(p, token) {
if (p.openElements.currentTagId === $.OPTION) {
p.openElements.pop();
}
p._reconstructActiveFormattingElements();
p._insertElement(token, NS.HTML);
}
function rbStartTagInBody(p, token) {
if (p.openElements.hasInScope($.RUBY)) {
p.openElements.generateImpliedEndTags();
}
p._insertElement(token, NS.HTML);
}
function rtStartTagInBody(p, token) {
if (p.openElements.hasInScope($.RUBY)) {
p.openElements.generateImpliedEndTagsWithExclusion($.RTC);
}
p._insertElement(token, NS.HTML);
}
function mathStartTagInBody(p, token) {
p._reconstructActiveFormattingElements();
foreignContent.adjustTokenMathMLAttrs(token);
foreignContent.adjustTokenXMLAttrs(token);
if (token.selfClosing) {
p._appendElement(token, NS.MATHML);
}
else {
p._insertElement(token, NS.MATHML);
}
token.ackSelfClosing = true;
}
function svgStartTagInBody(p, token) {
p._reconstructActiveFormattingElements();
foreignContent.adjustTokenSVGAttrs(token);
foreignContent.adjustTokenXMLAttrs(token);
if (token.selfClosing) {
p._appendElement(token, NS.SVG);
}
else {
p._insertElement(token, NS.SVG);
}
token.ackSelfClosing = true;
}
function genericStartTagInBody(p, token) {
p._reconstructActiveFormattingElements();
p._insertElement(token, NS.HTML);
}
function startTagInBody(p, token) {
switch (token.tagID) {
case $.I:
case $.S:
case $.B:
case $.U:
case $.EM:
case $.TT:
case $.BIG:
case $.CODE:
case $.FONT:
case $.SMALL:
case $.STRIKE:
case $.STRONG: {
bStartTagInBody(p, token);
break;
}
case $.A: {
aStartTagInBody(p, token);
break;
}
case $.H1:
case $.H2:
case $.H3:
case $.H4:
case $.H5:
case $.H6: {
numberedHeaderStartTagInBody(p, token);
break;
}
case $.P:
case $.DL:
case $.OL:
case $.UL:
case $.DIV:
case $.DIR:
case $.NAV:
case $.MAIN:
case $.MENU:
case $.ASIDE:
case $.CENTER:
case $.FIGURE:
case $.FOOTER:
case $.HEADER:
case $.HGROUP:
case $.DIALOG:
case $.DETAILS:
case $.ADDRESS:
case $.ARTICLE:
case $.SEARCH:
case $.SECTION:
case $.SUMMARY:
case $.FIELDSET:
case $.BLOCKQUOTE:
case $.FIGCAPTION: {
addressStartTagInBody(p, token);
break;
}
case $.LI:
case $.DD:
case $.DT: {
listItemStartTagInBody(p, token);
break;
}
case $.BR:
case $.IMG:
case $.WBR:
case $.AREA:
case $.EMBED:
case $.KEYGEN: {
areaStartTagInBody(p, token);
break;
}
case $.HR: {
hrStartTagInBody(p, token);
break;
}
case $.RB:
case $.RTC: {
rbStartTagInBody(p, token);
break;
}
case $.RT:
case $.RP: {
rtStartTagInBody(p, token);
break;
}
case $.PRE:
case $.LISTING: {
preStartTagInBody(p, token);
break;
}
case $.XMP: {
xmpStartTagInBody(p, token);
break;
}
case $.SVG: {
svgStartTagInBody(p, token);
break;
}
case $.HTML: {
htmlStartTagInBody(p, token);
break;
}
case $.BASE:
case $.LINK:
case $.META:
case $.STYLE:
case $.TITLE:
case $.SCRIPT:
case $.BGSOUND:
case $.BASEFONT:
case $.TEMPLATE: {
startTagInHead(p, token);
break;
}
case $.BODY: {
bodyStartTagInBody(p, token);
break;
}
case $.FORM: {
formStartTagInBody(p, token);
break;
}
case $.NOBR: {
nobrStartTagInBody(p, token);
break;
}
case $.MATH: {
mathStartTagInBody(p, token);
break;
}
case $.TABLE: {
tableStartTagInBody(p, token);
break;
}
case $.INPUT: {
inputStartTagInBody(p, token);
break;
}
case $.PARAM:
case $.TRACK:
case $.SOURCE: {
paramStartTagInBody(p, token);
break;
}
case $.IMAGE: {
imageStartTagInBody(p, token);
break;
}
case $.BUTTON: {
buttonStartTagInBody(p, token);
break;
}
case $.APPLET:
case $.OBJECT:
case $.MARQUEE: {
appletStartTagInBody(p, token);
break;
}
case $.IFRAME: {
iframeStartTagInBody(p, token);
break;
}
case $.SELECT: {
selectStartTagInBody(p, token);
break;
}
case $.OPTION:
case $.OPTGROUP: {
optgroupStartTagInBody(p, token);
break;
}
case $.NOEMBED:
case $.NOFRAMES: {
rawTextStartTagInBody(p, token);
break;
}
case $.FRAMESET: {
framesetStartTagInBody(p, token);
break;
}
case $.TEXTAREA: {
textareaStartTagInBody(p, token);
break;
}
case $.NOSCRIPT: {
if (p.options.scriptingEnabled) {
rawTextStartTagInBody(p, token);
}
else {
genericStartTagInBody(p, token);
}
break;
}
case $.PLAINTEXT: {
plaintextStartTagInBody(p, token);
break;
}
case $.COL:
case $.TH:
case $.TD:
case $.TR:
case $.HEAD:
case $.FRAME:
case $.TBODY:
case $.TFOOT:
case $.THEAD:
case $.CAPTION:
case $.COLGROUP: {
// Ignore token
break;
}
default: {
genericStartTagInBody(p, token);
}
}
}
function bodyEndTagInBody(p, token) {
if (p.openElements.hasInScope($.BODY)) {
p.insertionMode = InsertionMode.AFTER_BODY;
//NOTE: <body> is never popped from the stack, so we need to updated
//the end location explicitly.
if (p.options.sourceCodeLocationInfo) {
const bodyElement = p.openElements.tryPeekProperlyNestedBodyElement();
if (bodyElement) {
p._setEndLocation(bodyElement, token);
}
}
}
}
function htmlEndTagInBody(p, token) {
if (p.openElements.hasInScope($.BODY)) {
p.insertionMode = InsertionMode.AFTER_BODY;
endTagAfterBody(p, token);
}
}
function addressEndTagInBody(p, token) {
const tn = token.tagID;
if (p.openElements.hasInScope(tn)) {
p.openElements.generateImpliedEndTags();
p.openElements.popUntilTagNamePopped(tn);
}
}
function formEndTagInBody(p) {
const inTemplate = p.openElements.tmplCount > 0;
const { formElement } = p;
if (!inTemplate) {
p.formElement = null;
}
if ((formElement || inTemplate) && p.openElements.hasInScope($.FORM)) {
p.openElements.generateImpliedEndTags();
if (inTemplate) {
p.openElements.popUntilTagNamePopped($.FORM);
}
else if (formElement) {
p.openElements.remove(formElement);
}
}
}
function pEndTagInBody(p) {
if (!p.openElements.hasInButtonScope($.P)) {
p._insertFakeElement(TN.P, $.P);
}
p._closePElement();
}
function liEndTagInBody(p) {
if (p.openElements.hasInListItemScope($.LI)) {
p.openElements.generateImpliedEndTagsWithExclusion($.LI);
p.openElements.popUntilTagNamePopped($.LI);
}
}
function ddEndTagInBody(p, token) {
const tn = token.tagID;
if (p.openElements.hasInScope(tn)) {
p.openElements.generateImpliedEndTagsWithExclusion(tn);
p.openElements.popUntilTagNamePopped(tn);
}
}
function numberedHeaderEndTagInBody(p) {
if (p.openElements.hasNumberedHeaderInScope()) {
p.openElements.generateImpliedEndTags();
p.openElements.popUntilNumberedHeaderPopped();
}
}
function appletEndTagInBody(p, token) {
const tn = token.tagID;
if (p.openElements.hasInScope(tn)) {
p.openElements.generateImpliedEndTags();
p.openElements.popUntilTagNamePopped(tn);
p.activeFormattingElements.clearToLastMarker();
}
}
function brEndTagInBody(p) {
p._reconstructActiveFormattingElements();
p._insertFakeElement(TN.BR, $.BR);
p.openElements.pop();
p.framesetOk = false;
}
function genericEndTagInBody(p, token) {
const tn = token.tagName;
const tid = token.tagID;
for (let i = p.openElements.stackTop; i > 0; i--) {
const element = p.openElements.items[i];
const elementId = p.openElements.tagIDs[i];
// Compare the tag name here, as the tag might not be a known tag with an ID.
if (tid === elementId && (tid !== $.UNKNOWN || p.treeAdapter.getTagName(element) === tn)) {
p.openElements.generateImpliedEndTagsWithExclusion(tid);
if (p.openElements.stackTop >= i)
p.openElements.shortenToLength(i);
break;
}
if (p._isSpecialElement(element, elementId)) {
break;
}
}
}
function endTagInBody(p, token) {
switch (token.tagID) {
case $.A:
case $.B:
case $.I:
case $.S:
case $.U:
case $.EM:
case $.TT:
case $.BIG:
case $.CODE:
case $.FONT:
case $.NOBR:
case $.SMALL:
case $.STRIKE:
case $.STRONG: {
callAdoptionAgency(p, token);
break;
}
case $.P: {
pEndTagInBody(p);
break;
}
case $.DL:
case $.UL:
case $.OL:
case $.DIR:
case $.DIV:
case $.NAV:
case $.PRE:
case $.MAIN:
case $.MENU:
case $.ASIDE:
case $.BUTTON:
case $.CENTER:
case $.FIGURE:
case $.FOOTER:
case $.HEADER:
case $.HGROUP:
case $.DIALOG:
case $.ADDRESS:
case $.ARTICLE:
case $.DETAILS:
case $.SEARCH:
case $.SECTION:
case $.SUMMARY:
case $.LISTING:
case $.FIELDSET:
case $.BLOCKQUOTE:
case $.FIGCAPTION: {
addressEndTagInBody(p, token);
break;
}
case $.LI: {
liEndTagInBody(p);
break;
}
case $.DD:
case $.DT: {
ddEndTagInBody(p, token);
break;
}
case $.H1:
case $.H2:
case $.H3:
case $.H4:
case $.H5:
case $.H6: {
numberedHeaderEndTagInBody(p);
break;
}
case $.BR: {
brEndTagInBody(p);
break;
}
case $.BODY: {
bodyEndTagInBody(p, token);
break;
}
case $.HTML: {
htmlEndTagInBody(p, token);
break;
}
case $.FORM: {
formEndTagInBody(p);
break;
}
case $.APPLET:
case $.OBJECT:
case $.MARQUEE: {
appletEndTagInBody(p, token);
break;
}
case $.TEMPLATE: {
templateEndTagInHead(p, token);
break;
}
default: {
genericEndTagInBody(p, token);
}
}
}
function eofInBody(p, token) {
if (p.tmplInsertionModeStack.length > 0) {
eofInTemplate(p, token);
}
else {
stopParsing(p, token);
}
}
// The "text" insertion mode
//------------------------------------------------------------------
function endTagInText(p, token) {
var _a;
if (token.tagID === $.SCRIPT) {
(_a = p.scriptHandler) === null || _a === void 0 ? void 0 : _a.call(p, p.openElements.current);
}
p.openElements.pop();
p.insertionMode = p.originalInsertionMode;
}
function eofInText(p, token) {
p._err(token, ERR.eofInElementThatCanContainOnlyText);
p.openElements.pop();
p.insertionMode = p.originalInsertionMode;
p.onEof(token);
}
// The "in table" insertion mode
//------------------------------------------------------------------
function characterInTable(p, token) {
if (p.openElements.currentTagId !== undefined && TABLE_STRUCTURE_TAGS.has(p.openElements.currentTagId)) {
p.pendingCharacterTokens.length = 0;
p.hasNonWhitespacePendingCharacterToken = false;
p.originalInsertionMode = p.insertionMode;
p.insertionMode = InsertionMode.IN_TABLE_TEXT;
switch (token.type) {
case TokenType.CHARACTER: {
characterInTableText(p, token);
break;
}
case TokenType.WHITESPACE_CHARACTER: {
whitespaceCharacterInTableText(p, token);
break;
}
// Ignore null
}
}
else {
tokenInTable(p, token);
}
}
function captionStartTagInTable(p, token) {
p.openElements.clearBackToTableContext();
p.activeFormattingElements.insertMarker();
p._insertElement(token, NS.HTML);
p.insertionMode = InsertionMode.IN_CAPTION;
}
function colgroupStartTagInTable(p, token) {
p.openElements.clearBackToTableContext();
p._insertElement(token, NS.HTML);
p.insertionMode = InsertionMode.IN_COLUMN_GROUP;
}
function colStartTagInTable(p, token) {
p.openElements.clearBackToTableContext();
p._insertFakeElement(TN.COLGROUP, $.COLGROUP);
p.insertionMode = InsertionMode.IN_COLUMN_GROUP;
startTagInColumnGroup(p, token);
}
function tbodyStartTagInTable(p, token) {
p.openElements.clearBackToTableContext();
p._insertElement(token, NS.HTML);
p.insertionMode = InsertionMode.IN_TABLE_BODY;
}
function tdStartTagInTable(p, token) {
p.openElements.clearBackToTableContext();
p._insertFakeElement(TN.TBODY, $.TBODY);
p.insertionMode = InsertionMode.IN_TABLE_BODY;
startTagInTableBody(p, token);
}
function tableStartTagInTable(p, token) {
if (p.openElements.hasInTableScope($.TABLE)) {
p.openElements.popUntilTagNamePopped($.TABLE);
p._resetInsertionMode();
p._processStartTag(token);
}
}
function inputStartTagInTable(p, token) {
if (isHiddenInput(token)) {
p._appendElement(token, NS.HTML);
}
else {
tokenInTable(p, token);
}
token.ackSelfClosing = true;
}
function formStartTagInTable(p, token) {
if (!p.formElement && p.openElements.tmplCount === 0) {
p._insertElement(token, NS.HTML);
p.formElement = p.openElements.current;
p.openElements.pop();
}
}
function startTagInTable(p, token) {
switch (token.tagID) {
case $.TD:
case $.TH:
case $.TR: {
tdStartTagInTable(p, token);
break;
}
case $.STYLE:
case $.SCRIPT:
case $.TEMPLATE: {
startTagInHead(p, token);
break;
}
case $.COL: {
colStartTagInTable(p, token);
break;
}
case $.FORM: {
formStartTagInTable(p, token);
break;
}
case $.TABLE: {
tableStartTagInTable(p, token);
break;
}
case $.TBODY:
case $.TFOOT:
case $.THEAD: {
tbodyStartTagInTable(p, token);
break;
}
case $.INPUT: {
inputStartTagInTable(p, token);
break;
}
case $.CAPTION: {
captionStartTagInTable(p, token);
break;
}
case $.COLGROUP: {
colgroupStartTagInTable(p, token);
break;
}
default: {
tokenInTable(p, token);
}
}
}
function endTagInTable(p, token) {
switch (token.tagID) {
case $.TABLE: {
if (p.openElements.hasInTableScope($.TABLE)) {
p.openElements.popUntilTagNamePopped($.TABLE);
p._resetInsertionMode();
}
break;
}
case $.TEMPLATE: {
templateEndTagInHead(p, token);
break;
}
case $.BODY:
case $.CAPTION:
case $.COL:
case $.COLGROUP:
case $.HTML:
case $.TBODY:
case $.TD:
case $.TFOOT:
case $.TH:
case $.THEAD:
case $.TR: {
// Ignore token
break;
}
default: {
tokenInTable(p, token);
}
}
}
function tokenInTable(p, token) {
const savedFosterParentingState = p.fosterParentingEnabled;
p.fosterParentingEnabled = true;
// Process token in `In Body` mode
modeInBody(p, token);
p.fosterParentingEnabled = savedFosterParentingState;
}
// The "in table text" insertion mode
//------------------------------------------------------------------
function whitespaceCharacterInTableText(p, token) {
p.pendingCharacterTokens.push(token);
}
function characterInTableText(p, token) {
p.pendingCharacterTokens.push(token);
p.hasNonWhitespacePendingCharacterToken = true;
}
function tokenInTableText(p, token) {
let i = 0;
if (p.hasNonWhitespacePendingCharacterToken) {
for (; i < p.pendingCharacterTokens.length; i++) {
tokenInTable(p, p.pendingCharacterTokens[i]);
}
}
else {
for (; i < p.pendingCharacterTokens.length; i++) {
p._insertCharacters(p.pendingCharacterTokens[i]);
}
}
p.insertionMode = p.originalInsertionMode;
p._processToken(token);
}
// The "in caption" insertion mode
//------------------------------------------------------------------
const TABLE_VOID_ELEMENTS = new Set([$.CAPTION, $.COL, $.COLGROUP, $.TBODY, $.TD, $.TFOOT, $.TH, $.THEAD, $.TR]);
function startTagInCaption(p, token) {
const tn = token.tagID;
if (TABLE_VOID_ELEMENTS.has(tn)) {
if (p.openElements.hasInTableScope($.CAPTION)) {
p.openElements.generateImpliedEndTags();
p.openElements.popUntilTagNamePopped($.CAPTION);
p.activeFormattingElements.clearToLastMarker();
p.insertionMode = InsertionMode.IN_TABLE;
startTagInTable(p, token);
}
}
else {
startTagInBody(p, token);
}
}
function endTagInCaption(p, token) {
const tn = token.tagID;
switch (tn) {
case $.CAPTION:
case $.TABLE: {
if (p.openElements.hasInTableScope($.CAPTION)) {
p.openElements.generateImpliedEndTags();
p.openElements.popUntilTagNamePopped($.CAPTION);
p.activeFormattingElements.clearToLastMarker();
p.insertionMode = InsertionMode.IN_TABLE;
if (tn === $.TABLE) {
endTagInTable(p, token);
}
}
break;
}
case $.BODY:
case $.COL:
case $.COLGROUP:
case $.HTML:
case $.TBODY:
case $.TD:
case $.TFOOT:
case $.TH:
case $.THEAD:
case $.TR: {
// Ignore token
break;
}
default: {
endTagInBody(p, token);
}
}
}
// The "in column group" insertion mode
//------------------------------------------------------------------
function startTagInColumnGroup(p, token) {
switch (token.tagID) {
case $.HTML: {
startTagInBody(p, token);
break;
}
case $.COL: {
p._appendElement(token, NS.HTML);
token.ackSelfClosing = true;
break;
}
case $.TEMPLATE: {
startTagInHead(p, token);
break;
}
default: {
tokenInColumnGroup(p, token);
}
}
}
function endTagInColumnGroup(p, token) {
switch (token.tagID) {
case $.COLGROUP: {
if (p.openElements.currentTagId === $.COLGROUP) {
p.openElements.pop();
p.insertionMode = InsertionMode.IN_TABLE;
}
break;
}
case $.TEMPLATE: {
templateEndTagInHead(p, token);
break;
}
case $.COL: {
// Ignore token
break;
}
default: {
tokenInColumnGroup(p, token);
}
}
}
function tokenInColumnGroup(p, token) {
if (p.openElements.currentTagId === $.COLGROUP) {
p.openElements.pop();
p.insertionMode = InsertionMode.IN_TABLE;
p._processToken(token);
}
}
// The "in table body" insertion mode
//------------------------------------------------------------------
function startTagInTableBody(p, token) {
switch (token.tagID) {
case $.TR: {
p.openElements.clearBackToTableBodyContext();
p._insertElement(token, NS.HTML);
p.insertionMode = InsertionMode.IN_ROW;
break;
}
case $.TH:
case $.TD: {
p.openElements.clearBackToTableBodyContext();
p._insertFakeElement(TN.TR, $.TR);
p.insertionMode = InsertionMode.IN_ROW;
startTagInRow(p, token);
break;
}
case $.CAPTION:
case $.COL:
case $.COLGROUP:
case $.TBODY:
case $.TFOOT:
case $.THEAD: {
if (p.openElements.hasTableBodyContextInTableScope()) {
p.openElements.clearBackToTableBodyContext();
p.openElements.pop();
p.insertionMode = InsertionMode.IN_TABLE;
startTagInTable(p, token);
}
break;
}
default: {
startTagInTable(p, token);
}
}
}
function endTagInTableBody(p, token) {
const tn = token.tagID;
switch (token.tagID) {
case $.TBODY:
case $.TFOOT:
case $.THEAD: {
if (p.openElements.hasInTableScope(tn)) {
p.openElements.clearBackToTableBodyContext();
p.openElements.pop();
p.insertionMode = InsertionMode.IN_TABLE;
}
break;
}
case $.TABLE: {
if (p.openElements.hasTableBodyContextInTableScope()) {
p.openElements.clearBackToTableBodyContext();
p.openElements.pop();
p.insertionMode = InsertionMode.IN_TABLE;
endTagInTable(p, token);
}
break;
}
case $.BODY:
case $.CAPTION:
case $.COL:
case $.COLGROUP:
case $.HTML:
case $.TD:
case $.TH:
case $.TR: {
// Ignore token
break;
}
default: {
endTagInTable(p, token);
}
}
}
// The "in row" insertion mode
//------------------------------------------------------------------
function startTagInRow(p, token) {
switch (token.tagID) {
case $.TH:
case $.TD: {
p.openElements.clearBackToTableRowContext();
p._insertElement(token, NS.HTML);
p.insertionMode = InsertionMode.IN_CELL;
p.activeFormattingElements.insertMarker();
break;
}
case $.CAPTION:
case $.COL:
case $.COLGROUP:
case $.TBODY:
case $.TFOOT:
case $.THEAD:
case $.TR: {
if (p.openElements.hasInTableScope($.TR)) {
p.openElements.clearBackToTableRowContext();
p.openElements.pop();
p.insertionMode = InsertionMode.IN_TABLE_BODY;
startTagInTableBody(p, token);
}
break;
}
default: {
startTagInTable(p, token);
}
}
}
function endTagInRow(p, token) {
switch (token.tagID) {
case $.TR: {
if (p.openElements.hasInTableScope($.TR)) {
p.openElements.clearBackToTableRowContext();
p.openElements.pop();
p.insertionMode = InsertionMode.IN_TABLE_BODY;
}
break;
}
case $.TABLE: {
if (p.openElements.hasInTableScope($.TR)) {
p.openElements.clearBackToTableRowContext();
p.openElements.pop();
p.insertionMode = InsertionMode.IN_TABLE_BODY;
endTagInTableBody(p, token);
}
break;
}
case $.TBODY:
case $.TFOOT:
case $.THEAD: {
if (p.openElements.hasInTableScope(token.tagID) || p.openElements.hasInTableScope($.TR)) {
p.openElements.clearBackToTableRowContext();
p.openElements.pop();
p.insertionMode = InsertionMode.IN_TABLE_BODY;
endTagInTableBody(p, token);
}
break;
}
case $.BODY:
case $.CAPTION:
case $.COL:
case $.COLGROUP:
case $.HTML:
case $.TD:
case $.TH: {
// Ignore end tag
break;
}
default: {
endTagInTable(p, token);
}
}
}
// The "in cell" insertion mode
//------------------------------------------------------------------
function startTagInCell(p, token) {
const tn = token.tagID;
if (TABLE_VOID_ELEMENTS.has(tn)) {
if (p.openElements.hasInTableScope($.TD) || p.openElements.hasInTableScope($.TH)) {
p._closeTableCell();
startTagInRow(p, token);
}
}
else {
startTagInBody(p, token);
}
}
function endTagInCell(p, token) {
const tn = token.tagID;
switch (tn) {
case $.TD:
case $.TH: {
if (p.openElements.hasInTableScope(tn)) {
p.openElements.generateImpliedEndTags();
p.openElements.popUntilTagNamePopped(tn);
p.activeFormattingElements.clearToLastMarker();
p.insertionMode = InsertionMode.IN_ROW;
}
break;
}
case $.TABLE:
case $.TBODY:
case $.TFOOT:
case $.THEAD:
case $.TR: {
if (p.openElements.hasInTableScope(tn)) {
p._closeTableCell();
endTagInRow(p, token);
}
break;
}
case $.BODY:
case $.CAPTION:
case $.COL:
case $.COLGROUP:
case $.HTML: {
// Ignore token
break;
}
default: {
endTagInBody(p, token);
}
}
}
// The "in select" insertion mode
//------------------------------------------------------------------
function startTagInSelect(p, token) {
switch (token.tagID) {
case $.HTML: {
startTagInBody(p, token);
break;
}
case $.OPTION: {
if (p.openElements.currentTagId === $.OPTION) {
p.openElements.pop();
}
p._insertElement(token, NS.HTML);
break;
}
case $.OPTGROUP: {
if (p.openElements.currentTagId === $.OPTION) {
p.openElements.pop();
}
if (p.openElements.currentTagId === $.OPTGROUP) {
p.openElements.pop();
}
p._insertElement(token, NS.HTML);
break;
}
case $.HR: {
if (p.openElements.currentTagId === $.OPTION) {
p.openElements.pop();
}
if (p.openElements.currentTagId === $.OPTGROUP) {
p.openElements.pop();
}
p._appendElement(token, NS.HTML);
token.ackSelfClosing = true;
break;
}
case $.INPUT:
case $.KEYGEN:
case $.TEXTAREA:
case $.SELECT: {
if (p.openElements.hasInSelectScope($.SELECT)) {
p.openElements.popUntilTagNamePopped($.SELECT);
p._resetInsertionMode();
if (token.tagID !== $.SELECT) {
p._processStartTag(token);
}
}
break;
}
case $.SCRIPT:
case $.TEMPLATE: {
startTagInHead(p, token);
break;
}
default:
// Do nothing
}
}
function endTagInSelect(p, token) {
switch (token.tagID) {
case $.OPTGROUP: {
if (p.openElements.stackTop > 0 &&
p.openElements.currentTagId === $.OPTION &&
p.openElements.tagIDs[p.openElements.stackTop - 1] === $.OPTGROUP) {
p.openElements.pop();
}
if (p.openElements.currentTagId === $.OPTGROUP) {
p.openElements.pop();
}
break;
}
case $.OPTION: {
if (p.openElements.currentTagId === $.OPTION) {
p.openElements.pop();
}
break;
}
case $.SELECT: {
if (p.openElements.hasInSelectScope($.SELECT)) {
p.openElements.popUntilTagNamePopped($.SELECT);
p._resetInsertionMode();
}
break;
}
case $.TEMPLATE: {
templateEndTagInHead(p, token);
break;
}
default:
// Do nothing
}
}
// The "in select in table" insertion mode
//------------------------------------------------------------------
function startTagInSelectInTable(p, token) {
const tn = token.tagID;
if (tn === $.CAPTION ||
tn === $.TABLE ||
tn === $.TBODY ||
tn === $.TFOOT ||
tn === $.THEAD ||
tn === $.TR ||
tn === $.TD ||
tn === $.TH) {
p.openElements.popUntilTagNamePopped($.SELECT);
p._resetInsertionMode();
p._processStartTag(token);
}
else {
startTagInSelect(p, token);
}
}
function endTagInSelectInTable(p, token) {
const tn = token.tagID;
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.onEndTag(token);
}
}
else {
endTagInSelect(p, token);
}
}
// The "in template" insertion mode
//------------------------------------------------------------------
function startTagInTemplate(p, token) {
switch (token.tagID) {
// First, handle tags that can start without a mode change
case $.BASE:
case $.BASEFONT:
case $.BGSOUND:
case $.LINK:
case $.META:
case $.NOFRAMES:
case $.SCRIPT:
case $.STYLE:
case $.TEMPLATE:
case $.TITLE: {
startTagInHead(p, token);
break;
}
// Re-process the token in the appropriate mode
case $.CAPTION:
case $.COLGROUP:
case $.TBODY:
case $.TFOOT:
case $.THEAD: {
p.tmplInsertionModeStack[0] = InsertionMode.IN_TABLE;
p.insertionMode = InsertionMode.IN_TABLE;
startTagInTable(p, token);
break;
}
case $.COL: {
p.tmplInsertionModeStack[0] = InsertionMode.IN_COLUMN_GROUP;
p.insertionMode = InsertionMode.IN_COLUMN_GROUP;
startTagInColumnGroup(p, token);
break;
}
case $.TR: {
p.tmplInsertionModeStack[0] = InsertionMode.IN_TABLE_BODY;
p.insertionMode = InsertionMode.IN_TABLE_BODY;
startTagInTableBody(p, token);
break;
}
case $.TD:
case $.TH: {
p.tmplInsertionModeStack[0] = InsertionMode.IN_ROW;
p.insertionMode = InsertionMode.IN_ROW;
startTagInRow(p, token);
break;
}
default: {
p.tmplInsertionModeStack[0] = InsertionMode.IN_BODY;
p.insertionMode = InsertionMode.IN_BODY;
startTagInBody(p, token);
}
}
}
function endTagInTemplate(p, token) {
if (token.tagID === $.TEMPLATE) {
templateEndTagInHead(p, token);
}
}
function eofInTemplate(p, token) {
if (p.openElements.tmplCount > 0) {
p.openElements.popUntilTagNamePopped($.TEMPLATE);
p.activeFormattingElements.clearToLastMarker();
p.tmplInsertionModeStack.shift();
p._resetInsertionMode();
p.onEof(token);
}
else {
stopParsing(p, token);
}
}
// The "after body" insertion mode
//------------------------------------------------------------------
function startTagAfterBody(p, token) {
if (token.tagID === $.HTML) {
startTagInBody(p, token);
}
else {
tokenAfterBody(p, token);
}
}
function endTagAfterBody(p, token) {
var _a;
if (token.tagID === $.HTML) {
if (!p.fragmentContext) {
p.insertionMode = InsertionMode.AFTER_AFTER_BODY;
}
//NOTE: <html> is never popped from the stack, so we need to updated
//the end location explicitly.
if (p.options.sourceCodeLocationInfo && p.openElements.tagIDs[0] === $.HTML) {
p._setEndLocation(p.openElements.items[0], token);
// Update the body element, if it doesn't have an end tag
const bodyElement = p.openElements.items[1];
if (bodyElement && !((_a = p.treeAdapter.getNodeSourceCodeLocation(bodyElement)) === null || _a === void 0 ? void 0 : _a.endTag)) {
p._setEndLocation(bodyElement, token);
}
}
}
else {
tokenAfterBody(p, token);
}
}
function tokenAfterBody(p, token) {
p.insertionMode = InsertionMode.IN_BODY;
modeInBody(p, token);
}
// The "in frameset" insertion mode
//------------------------------------------------------------------
function startTagInFrameset(p, token) {
switch (token.tagID) {
case $.HTML: {
startTagInBody(p, token);
break;
}
case $.FRAMESET: {
p._insertElement(token, NS.HTML);
break;
}
case $.FRAME: {
p._appendElement(token, NS.HTML);
token.ackSelfClosing = true;
break;
}
case $.NOFRAMES: {
startTagInHead(p, token);
break;
}
default:
// Do nothing
}
}
function endTagInFrameset(p, token) {
if (token.tagID === $.FRAMESET && !p.openElements.isRootHtmlElementCurrent()) {
p.openElements.pop();
if (!p.fragmentContext && p.openElements.currentTagId !== $.FRAMESET) {
p.insertionMode = InsertionMode.AFTER_FRAMESET;
}
}
}
// The "after frameset" insertion mode
//------------------------------------------------------------------
function startTagAfterFrameset(p, token) {
switch (token.tagID) {
case $.HTML: {
startTagInBody(p, token);
break;
}
case $.NOFRAMES: {
startTagInHead(p, token);
break;
}
default:
// Do nothing
}
}
function endTagAfterFrameset(p, token) {
if (token.tagID === $.HTML) {
p.insertionMode = InsertionMode.AFTER_AFTER_FRAMESET;
}
}
// The "after after body" insertion mode
//------------------------------------------------------------------
function startTagAfterAfterBody(p, token) {
if (token.tagID === $.HTML) {
startTagInBody(p, token);
}
else {
tokenAfterAfterBody(p, token);
}
}
function tokenAfterAfterBody(p, token) {
p.insertionMode = InsertionMode.IN_BODY;
modeInBody(p, token);
}
// The "after after frameset" insertion mode
//------------------------------------------------------------------
function startTagAfterAfterFrameset(p, token) {
switch (token.tagID) {
case $.HTML: {
startTagInBody(p, token);
break;
}
case $.NOFRAMES: {
startTagInHead(p, token);
break;
}
default:
// Do nothing
}
}
// The rules for parsing tokens in foreign content
//------------------------------------------------------------------
function nullCharacterInForeignContent(p, token) {
token.chars = unicode.REPLACEMENT_CHARACTER;
p._insertCharacters(token);
}
function characterInForeignContent(p, token) {
p._insertCharacters(token);
p.framesetOk = false;
}
function popUntilHtmlOrIntegrationPoint(p) {
while (p.treeAdapter.getNamespaceURI(p.openElements.current) !== NS.HTML &&
p.openElements.currentTagId !== undefined &&
!p._isIntegrationPoint(p.openElements.currentTagId, p.openElements.current)) {
p.openElements.pop();
}
}
function startTagInForeignContent(p, token) {
if (foreignContent.causesExit(token)) {
popUntilHtmlOrIntegrationPoint(p);
p._startTagOutsideForeignContent(token);
}
else {
const current = p._getAdjustedCurrentElement();
const currentNs = p.treeAdapter.getNamespaceURI(current);
if (currentNs === NS.MATHML) {
foreignContent.adjustTokenMathMLAttrs(token);
}
else if (currentNs === NS.SVG) {
foreignContent.adjustTokenSVGTagName(token);
foreignContent.adjustTokenSVGAttrs(token);
}
foreignContent.adjustTokenXMLAttrs(token);
if (token.selfClosing) {
p._appendElement(token, currentNs);
}
else {
p._insertElement(token, currentNs);
}
token.ackSelfClosing = true;
}
}
function endTagInForeignContent(p, token) {
if (token.tagID === $.P || token.tagID === $.BR) {
popUntilHtmlOrIntegrationPoint(p);
p._endTagOutsideForeignContent(token);
return;
}
for (let i = p.openElements.stackTop; i > 0; i--) {
const element = p.openElements.items[i];
if (p.treeAdapter.getNamespaceURI(element) === NS.HTML) {
p._endTagOutsideForeignContent(token);
break;
}
const tagName = p.treeAdapter.getTagName(element);
if (tagName.toLowerCase() === token.tagName) {
//NOTE: update the token tag name for `_setEndLocation`.
token.tagName = tagName;
p.openElements.shortenToLength(i);
break;
}
}
}