pecfmfujl
/
parttimejob
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '442ec372a4'
${ noResults }
parttimejob/node_modules/parse5/lib/tokenizer/index.js

2197 lines
78 KiB
Raw Blame History

'use strict';
const Preprocessor = require('./preprocessor');
const unicode = require('../common/unicode');
const neTree = require('./named-entity-data');
const ERR = require('../common/error-codes');
//Aliases
const $ = unicode.CODE_POINTS;
const $$ = unicode.CODE_POINT_SEQUENCES;
//C1 Unicode control character reference replacements
const C1_CONTROLS_REFERENCE_REPLACEMENTS = {
0x80: 0x20ac,
0x82: 0x201a,
0x83: 0x0192,
0x84: 0x201e,
0x85: 0x2026,
0x86: 0x2020,
0x87: 0x2021,
0x88: 0x02c6,
0x89: 0x2030,
0x8a: 0x0160,
0x8b: 0x2039,
0x8c: 0x0152,
0x8e: 0x017d,
0x91: 0x2018,
0x92: 0x2019,
0x93: 0x201c,
0x94: 0x201d,
0x95: 0x2022,
0x96: 0x2013,
0x97: 0x2014,
0x98: 0x02dc,
0x99: 0x2122,
0x9a: 0x0161,
0x9b: 0x203a,
0x9c: 0x0153,
0x9e: 0x017e,
0x9f: 0x0178
};
// Named entity tree flags
const HAS_DATA_FLAG = 1 << 0;
const DATA_DUPLET_FLAG = 1 << 1;
const HAS_BRANCHES_FLAG = 1 << 2;
const MAX_BRANCH_MARKER_VALUE = HAS_DATA_FLAG | DATA_DUPLET_FLAG | HAS_BRANCHES_FLAG;
//States
const DATA_STATE = 'DATA_STATE';
const RCDATA_STATE = 'RCDATA_STATE';
const RAWTEXT_STATE = 'RAWTEXT_STATE';
const SCRIPT_DATA_STATE = 'SCRIPT_DATA_STATE';
const PLAINTEXT_STATE = 'PLAINTEXT_STATE';
const TAG_OPEN_STATE = 'TAG_OPEN_STATE';
const END_TAG_OPEN_STATE = 'END_TAG_OPEN_STATE';
const TAG_NAME_STATE = 'TAG_NAME_STATE';
const RCDATA_LESS_THAN_SIGN_STATE = 'RCDATA_LESS_THAN_SIGN_STATE';
const RCDATA_END_TAG_OPEN_STATE = 'RCDATA_END_TAG_OPEN_STATE';
const RCDATA_END_TAG_NAME_STATE = 'RCDATA_END_TAG_NAME_STATE';
const RAWTEXT_LESS_THAN_SIGN_STATE = 'RAWTEXT_LESS_THAN_SIGN_STATE';
const RAWTEXT_END_TAG_OPEN_STATE = 'RAWTEXT_END_TAG_OPEN_STATE';
const RAWTEXT_END_TAG_NAME_STATE = 'RAWTEXT_END_TAG_NAME_STATE';
const SCRIPT_DATA_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_LESS_THAN_SIGN_STATE';
const SCRIPT_DATA_END_TAG_OPEN_STATE = 'SCRIPT_DATA_END_TAG_OPEN_STATE';
const SCRIPT_DATA_END_TAG_NAME_STATE = 'SCRIPT_DATA_END_TAG_NAME_STATE';
const SCRIPT_DATA_ESCAPE_START_STATE = 'SCRIPT_DATA_ESCAPE_START_STATE';
const SCRIPT_DATA_ESCAPE_START_DASH_STATE = 'SCRIPT_DATA_ESCAPE_START_DASH_STATE';
const SCRIPT_DATA_ESCAPED_STATE = 'SCRIPT_DATA_ESCAPED_STATE';
const SCRIPT_DATA_ESCAPED_DASH_STATE = 'SCRIPT_DATA_ESCAPED_DASH_STATE';
const SCRIPT_DATA_ESCAPED_DASH_DASH_STATE = 'SCRIPT_DATA_ESCAPED_DASH_DASH_STATE';
const SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE';
const SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE = 'SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE';
const SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE = 'SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE';
const SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE';
const SCRIPT_DATA_DOUBLE_ESCAPED_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_STATE';
const SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE';
const SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE';
const SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE';
const SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE';
const BEFORE_ATTRIBUTE_NAME_STATE = 'BEFORE_ATTRIBUTE_NAME_STATE';
const ATTRIBUTE_NAME_STATE = 'ATTRIBUTE_NAME_STATE';
const AFTER_ATTRIBUTE_NAME_STATE = 'AFTER_ATTRIBUTE_NAME_STATE';
const BEFORE_ATTRIBUTE_VALUE_STATE = 'BEFORE_ATTRIBUTE_VALUE_STATE';
const ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE = 'ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE';
const ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE = 'ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE';
const ATTRIBUTE_VALUE_UNQUOTED_STATE = 'ATTRIBUTE_VALUE_UNQUOTED_STATE';
const AFTER_ATTRIBUTE_VALUE_QUOTED_STATE = 'AFTER_ATTRIBUTE_VALUE_QUOTED_STATE';
const SELF_CLOSING_START_TAG_STATE = 'SELF_CLOSING_START_TAG_STATE';
const BOGUS_COMMENT_STATE = 'BOGUS_COMMENT_STATE';
const MARKUP_DECLARATION_OPEN_STATE = 'MARKUP_DECLARATION_OPEN_STATE';
const COMMENT_START_STATE = 'COMMENT_START_STATE';
const COMMENT_START_DASH_STATE = 'COMMENT_START_DASH_STATE';
const COMMENT_STATE = 'COMMENT_STATE';
const COMMENT_LESS_THAN_SIGN_STATE = 'COMMENT_LESS_THAN_SIGN_STATE';
const COMMENT_LESS_THAN_SIGN_BANG_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_STATE';
const COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE';
const COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE = 'COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE';
const COMMENT_END_DASH_STATE = 'COMMENT_END_DASH_STATE';
const COMMENT_END_STATE = 'COMMENT_END_STATE';
const COMMENT_END_BANG_STATE = 'COMMENT_END_BANG_STATE';
const DOCTYPE_STATE = 'DOCTYPE_STATE';
const BEFORE_DOCTYPE_NAME_STATE = 'BEFORE_DOCTYPE_NAME_STATE';
const DOCTYPE_NAME_STATE = 'DOCTYPE_NAME_STATE';
const AFTER_DOCTYPE_NAME_STATE = 'AFTER_DOCTYPE_NAME_STATE';
const AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE = 'AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE';
const BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE = 'BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE';
const DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE = 'DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE';
const DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE = 'DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE';
const AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE = 'AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE';
const BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE = 'BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE';
const AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE = 'AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE';
const BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE = 'BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE';
const DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE = 'DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE';
const DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE = 'DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE';
const AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE = 'AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE';
const BOGUS_DOCTYPE_STATE = 'BOGUS_DOCTYPE_STATE';
const CDATA_SECTION_STATE = 'CDATA_SECTION_STATE';
const CDATA_SECTION_BRACKET_STATE = 'CDATA_SECTION_BRACKET_STATE';
const CDATA_SECTION_END_STATE = 'CDATA_SECTION_END_STATE';
const CHARACTER_REFERENCE_STATE = 'CHARACTER_REFERENCE_STATE';
const NAMED_CHARACTER_REFERENCE_STATE = 'NAMED_CHARACTER_REFERENCE_STATE';
const AMBIGUOUS_AMPERSAND_STATE = 'AMBIGUOS_AMPERSAND_STATE';
const NUMERIC_CHARACTER_REFERENCE_STATE = 'NUMERIC_CHARACTER_REFERENCE_STATE';
const HEXADEMICAL_CHARACTER_REFERENCE_START_STATE = 'HEXADEMICAL_CHARACTER_REFERENCE_START_STATE';
const DECIMAL_CHARACTER_REFERENCE_START_STATE = 'DECIMAL_CHARACTER_REFERENCE_START_STATE';
const HEXADEMICAL_CHARACTER_REFERENCE_STATE = 'HEXADEMICAL_CHARACTER_REFERENCE_STATE';
const DECIMAL_CHARACTER_REFERENCE_STATE = 'DECIMAL_CHARACTER_REFERENCE_STATE';
const NUMERIC_CHARACTER_REFERENCE_END_STATE = 'NUMERIC_CHARACTER_REFERENCE_END_STATE';
//Utils
//OPTIMIZATION: these utility functions should not be moved out of this module. V8 Crankshaft will not inline
//this functions if they will be situated in another module due to context switch.
//Always perform inlining check before modifying this functions ('node --trace-inlining').
function isWhitespace(cp) {
return cp === $.SPACE || cp === $.LINE_FEED || cp === $.TABULATION || cp === $.FORM_FEED;
}
function isAsciiDigit(cp) {
return cp >= $.DIGIT_0 && cp <= $.DIGIT_9;
}
function isAsciiUpper(cp) {
return cp >= $.LATIN_CAPITAL_A && cp <= $.LATIN_CAPITAL_Z;
}
function isAsciiLower(cp) {
return cp >= $.LATIN_SMALL_A && cp <= $.LATIN_SMALL_Z;
}
function isAsciiLetter(cp) {
return isAsciiLower(cp) || isAsciiUpper(cp);
}
function isAsciiAlphaNumeric(cp) {
return isAsciiLetter(cp) || isAsciiDigit(cp);
}
function isAsciiUpperHexDigit(cp) {
return cp >= $.LATIN_CAPITAL_A && cp <= $.LATIN_CAPITAL_F;
}
function isAsciiLowerHexDigit(cp) {
return cp >= $.LATIN_SMALL_A && cp <= $.LATIN_SMALL_F;
}
function isAsciiHexDigit(cp) {
return isAsciiDigit(cp) || isAsciiUpperHexDigit(cp) || isAsciiLowerHexDigit(cp);
}
function toAsciiLowerCodePoint(cp) {
return cp + 0x0020;
}
//NOTE: String.fromCharCode() function can handle only characters from BMP subset.
//So, we need to workaround this manually.
//(see: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/fromCharCode#Getting_it_to_work_with_higher_values)
function toChar(cp) {
if (cp <= 0xffff) {
return String.fromCharCode(cp);
}
cp -= 0x10000;
return String.fromCharCode(((cp >>> 10) & 0x3ff) | 0xd800) + String.fromCharCode(0xdc00 | (cp & 0x3ff));
}
function toAsciiLowerChar(cp) {
return String.fromCharCode(toAsciiLowerCodePoint(cp));
}
function findNamedEntityTreeBranch(nodeIx, cp) {
const branchCount = neTree[++nodeIx];
let lo = ++nodeIx;
let hi = lo + branchCount - 1;
while (lo <= hi) {
const mid = (lo + hi) >>> 1;
const midCp = neTree[mid];
if (midCp < cp) {
lo = mid + 1;
} else if (midCp > cp) {
hi = mid - 1;
} else {
return neTree[mid + branchCount];
}
}
return -1;
}
//Tokenizer
class Tokenizer {
constructor() {
this.preprocessor = new Preprocessor();
this.tokenQueue = [];
this.allowCDATA = false;
this.state = DATA_STATE;
this.returnState = '';
this.charRefCode = -1;
this.tempBuff = [];
this.lastStartTagName = '';
this.consumedAfterSnapshot = -1;
this.active = false;
this.currentCharacterToken = null;
this.currentToken = null;
this.currentAttr = null;
}
//Errors
_err() {
// NOTE: err reporting is noop by default. Enabled by mixin.
}
_errOnNextCodePoint(err) {
this._consume();
this._err(err);
this._unconsume();
}
//API
getNextToken() {
while (!this.tokenQueue.length && this.active) {
this.consumedAfterSnapshot = 0;
const cp = this._consume();
if (!this._ensureHibernation()) {
this[this.state](cp);
}
}
return this.tokenQueue.shift();
}
write(chunk, isLastChunk) {
this.active = true;
this.preprocessor.write(chunk, isLastChunk);
}
insertHtmlAtCurrentPos(chunk) {
this.active = true;
this.preprocessor.insertHtmlAtCurrentPos(chunk);
}
//Hibernation
_ensureHibernation() {
if (this.preprocessor.endOfChunkHit) {
for (; this.consumedAfterSnapshot > 0; this.consumedAfterSnapshot--) {
this.preprocessor.retreat();
}
this.active = false;
this.tokenQueue.push({ type: Tokenizer.HIBERNATION_TOKEN });
return true;
}
return false;
}
//Consumption
_consume() {
this.consumedAfterSnapshot++;
return this.preprocessor.advance();
}
_unconsume() {
this.consumedAfterSnapshot--;
this.preprocessor.retreat();
}
_reconsumeInState(state) {
this.state = state;
this._unconsume();
}
_consumeSequenceIfMatch(pattern, startCp, caseSensitive) {
let consumedCount = 0;
let isMatch = true;
const patternLength = pattern.length;
let patternPos = 0;
let cp = startCp;
let patternCp = void 0;
for (; patternPos < patternLength; patternPos++) {
if (patternPos > 0) {
cp = this._consume();
consumedCount++;
}
if (cp === $.EOF) {
isMatch = false;
break;
}
patternCp = pattern[patternPos];
if (cp !== patternCp && (caseSensitive || cp !== toAsciiLowerCodePoint(patternCp))) {
isMatch = false;
break;
}
}
if (!isMatch) {
while (consumedCount--) {
this._unconsume();
}
}
return isMatch;
}
//Temp buffer
_isTempBufferEqualToScriptString() {
if (this.tempBuff.length !== $$.SCRIPT_STRING.length) {
return false;
}
for (let i = 0; i < this.tempBuff.length; i++) {
if (this.tempBuff[i] !== $$.SCRIPT_STRING[i]) {
return false;
}
}
return true;
}
//Token creation
_createStartTagToken() {
this.currentToken = {
type: Tokenizer.START_TAG_TOKEN,
tagName: '',
selfClosing: false,
ackSelfClosing: false,
attrs: []
};
}
_createEndTagToken() {
this.currentToken = {
type: Tokenizer.END_TAG_TOKEN,
tagName: '',
selfClosing: false,
attrs: []
};
}
_createCommentToken() {
this.currentToken = {
type: Tokenizer.COMMENT_TOKEN,
data: ''
};
}
_createDoctypeToken(initialName) {
this.currentToken = {
type: Tokenizer.DOCTYPE_TOKEN,
name: initialName,
forceQuirks: false,
publicId: null,
systemId: null
};
}
_createCharacterToken(type, ch) {
this.currentCharacterToken = {
type: type,
chars: ch
};
}
_createEOFToken() {
this.currentToken = { type: Tokenizer.EOF_TOKEN };
}
//Tag attributes
_createAttr(attrNameFirstCh) {
this.currentAttr = {
name: attrNameFirstCh,
value: ''
};
}
_leaveAttrName(toState) {
if (Tokenizer.getTokenAttr(this.currentToken, this.currentAttr.name) === null) {
this.currentToken.attrs.push(this.currentAttr);
} else {
this._err(ERR.duplicateAttribute);
}
this.state = toState;
}
_leaveAttrValue(toState) {
this.state = toState;
}
//Token emission
_emitCurrentToken() {
this._emitCurrentCharacterToken();
const ct = this.currentToken;
this.currentToken = null;
//NOTE: store emited start tag's tagName to determine is the following end tag token is appropriate.
if (ct.type === Tokenizer.START_TAG_TOKEN) {
this.lastStartTagName = ct.tagName;
} else if (ct.type === Tokenizer.END_TAG_TOKEN) {
if (ct.attrs.length > 0) {
this._err(ERR.endTagWithAttributes);
}
if (ct.selfClosing) {
this._err(ERR.endTagWithTrailingSolidus);
}
}
this.tokenQueue.push(ct);
}
_emitCurrentCharacterToken() {
if (this.currentCharacterToken) {
this.tokenQueue.push(this.currentCharacterToken);
this.currentCharacterToken = null;
}
}
_emitEOFToken() {
this._createEOFToken();
this._emitCurrentToken();
}
//Characters emission
//OPTIMIZATION: specification uses only one type of character tokens (one token per character).
//This causes a huge memory overhead and a lot of unnecessary parser loops. parse5 uses 3 groups of characters.
//If we have a sequence of characters that belong to the same group, parser can process it
//as a single solid character token.
//So, there are 3 types of character tokens in parse5:
//1)NULL_CHARACTER_TOKEN - \u0000-character sequences (e.g. '\u0000\u0000\u0000')
//2)WHITESPACE_CHARACTER_TOKEN - any whitespace/new-line character sequences (e.g. '\n \r\t \f')
//3)CHARACTER_TOKEN - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^')
_appendCharToCurrentCharacterToken(type, ch) {
if (this.currentCharacterToken && this.currentCharacterToken.type !== type) {
this._emitCurrentCharacterToken();
}
if (this.currentCharacterToken) {
this.currentCharacterToken.chars += ch;
} else {
this._createCharacterToken(type, ch);
}
}
_emitCodePoint(cp) {
let type = Tokenizer.CHARACTER_TOKEN;
if (isWhitespace(cp)) {
type = Tokenizer.WHITESPACE_CHARACTER_TOKEN;
} else if (cp === $.NULL) {
type = Tokenizer.NULL_CHARACTER_TOKEN;
}
this._appendCharToCurrentCharacterToken(type, toChar(cp));
}
_emitSeveralCodePoints(codePoints) {
for (let i = 0; i < codePoints.length; i++) {
this._emitCodePoint(codePoints[i]);
}
}
//NOTE: used then we emit character explicitly. This is always a non-whitespace and a non-null character.
//So we can avoid additional checks here.
_emitChars(ch) {
this._appendCharToCurrentCharacterToken(Tokenizer.CHARACTER_TOKEN, ch);
}
// Character reference helpers
_matchNamedCharacterReference(startCp) {
let result = null;
let excess = 1;
let i = findNamedEntityTreeBranch(0, startCp);
this.tempBuff.push(startCp);
while (i > -1) {
const current = neTree[i];
const inNode = current < MAX_BRANCH_MARKER_VALUE;
const nodeWithData = inNode && current & HAS_DATA_FLAG;
if (nodeWithData) {
//NOTE: we use greedy search, so we continue lookup at this point
result = current & DATA_DUPLET_FLAG ? [neTree[++i], neTree[++i]] : [neTree[++i]];
excess = 0;
}
const cp = this._consume();
this.tempBuff.push(cp);
excess++;
if (cp === $.EOF) {
break;
}
if (inNode) {
i = current & HAS_BRANCHES_FLAG ? findNamedEntityTreeBranch(i, cp) : -1;
} else {
i = cp === current ? ++i : -1;
}
}
while (excess--) {
this.tempBuff.pop();
this._unconsume();
}
return result;
}
_isCharacterReferenceInAttribute() {
return (
this.returnState === ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE ||
this.returnState === ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE ||
this.returnState === ATTRIBUTE_VALUE_UNQUOTED_STATE
);
}
_isCharacterReferenceAttributeQuirk(withSemicolon) {
if (!withSemicolon && this._isCharacterReferenceInAttribute()) {
const nextCp = this._consume();
this._unconsume();
return nextCp === $.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp);
}
return false;
}
_flushCodePointsConsumedAsCharacterReference() {
if (this._isCharacterReferenceInAttribute()) {
for (let i = 0; i < this.tempBuff.length; i++) {
this.currentAttr.value += toChar(this.tempBuff[i]);
}
} else {
this._emitSeveralCodePoints(this.tempBuff);
}
this.tempBuff = [];
}
// State machine
// Data state
//------------------------------------------------------------------
[DATA_STATE](cp) {
this.preprocessor.dropParsedChunk();
if (cp === $.LESS_THAN_SIGN) {
this.state = TAG_OPEN_STATE;
} else if (cp === $.AMPERSAND) {
this.returnState = DATA_STATE;
this.state = CHARACTER_REFERENCE_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this._emitCodePoint(cp);
} else if (cp === $.EOF) {
this._emitEOFToken();
} else {
this._emitCodePoint(cp);
}
}
// RCDATA state
//------------------------------------------------------------------
[RCDATA_STATE](cp) {
this.preprocessor.dropParsedChunk();
if (cp === $.AMPERSAND) {
this.returnState = RCDATA_STATE;
this.state = CHARACTER_REFERENCE_STATE;
} else if (cp === $.LESS_THAN_SIGN) {
this.state = RCDATA_LESS_THAN_SIGN_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this._emitChars(unicode.REPLACEMENT_CHARACTER);
} else if (cp === $.EOF) {
this._emitEOFToken();
} else {
this._emitCodePoint(cp);
}
}
// RAWTEXT state
//------------------------------------------------------------------
[RAWTEXT_STATE](cp) {
this.preprocessor.dropParsedChunk();
if (cp === $.LESS_THAN_SIGN) {
this.state = RAWTEXT_LESS_THAN_SIGN_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this._emitChars(unicode.REPLACEMENT_CHARACTER);
} else if (cp === $.EOF) {
this._emitEOFToken();
} else {
this._emitCodePoint(cp);
}
}
// Script data state
//------------------------------------------------------------------
[SCRIPT_DATA_STATE](cp) {
this.preprocessor.dropParsedChunk();
if (cp === $.LESS_THAN_SIGN) {
this.state = SCRIPT_DATA_LESS_THAN_SIGN_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this._emitChars(unicode.REPLACEMENT_CHARACTER);
} else if (cp === $.EOF) {
this._emitEOFToken();
} else {
this._emitCodePoint(cp);
}
}
// PLAINTEXT state
//------------------------------------------------------------------
[PLAINTEXT_STATE](cp) {
this.preprocessor.dropParsedChunk();
if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this._emitChars(unicode.REPLACEMENT_CHARACTER);
} else if (cp === $.EOF) {
this._emitEOFToken();
} else {
this._emitCodePoint(cp);
}
}
// Tag open state
//------------------------------------------------------------------
[TAG_OPEN_STATE](cp) {
if (cp === $.EXCLAMATION_MARK) {
this.state = MARKUP_DECLARATION_OPEN_STATE;
} else if (cp === $.SOLIDUS) {
this.state = END_TAG_OPEN_STATE;
} else if (isAsciiLetter(cp)) {
this._createStartTagToken();
this._reconsumeInState(TAG_NAME_STATE);
} else if (cp === $.QUESTION_MARK) {
this._err(ERR.unexpectedQuestionMarkInsteadOfTagName);
this._createCommentToken();
this._reconsumeInState(BOGUS_COMMENT_STATE);
} else if (cp === $.EOF) {
this._err(ERR.eofBeforeTagName);
this._emitChars('<');
this._emitEOFToken();
} else {
this._err(ERR.invalidFirstCharacterOfTagName);
this._emitChars('<');
this._reconsumeInState(DATA_STATE);
}
}
// End tag open state
//------------------------------------------------------------------
[END_TAG_OPEN_STATE](cp) {
if (isAsciiLetter(cp)) {
this._createEndTagToken();
this._reconsumeInState(TAG_NAME_STATE);
} else if (cp === $.GREATER_THAN_SIGN) {
this._err(ERR.missingEndTagName);
this.state = DATA_STATE;
} else if (cp === $.EOF) {
this._err(ERR.eofBeforeTagName);
this._emitChars('</');
this._emitEOFToken();
} else {
this._err(ERR.invalidFirstCharacterOfTagName);
this._createCommentToken();
this._reconsumeInState(BOGUS_COMMENT_STATE);
}
}
// Tag name state
//------------------------------------------------------------------
[TAG_NAME_STATE](cp) {
if (isWhitespace(cp)) {
this.state = BEFORE_ATTRIBUTE_NAME_STATE;
} else if (cp === $.SOLIDUS) {
this.state = SELF_CLOSING_START_TAG_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this.state = DATA_STATE;
this._emitCurrentToken();
} else if (isAsciiUpper(cp)) {
this.currentToken.tagName += toAsciiLowerChar(cp);
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.currentToken.tagName += unicode.REPLACEMENT_CHARACTER;
} else if (cp === $.EOF) {
this._err(ERR.eofInTag);
this._emitEOFToken();
} else {
this.currentToken.tagName += toChar(cp);
}
}
// RCDATA less-than sign state
//------------------------------------------------------------------
[RCDATA_LESS_THAN_SIGN_STATE](cp) {
if (cp === $.SOLIDUS) {
this.tempBuff = [];
this.state = RCDATA_END_TAG_OPEN_STATE;
} else {
this._emitChars('<');
this._reconsumeInState(RCDATA_STATE);
}
}
// RCDATA end tag open state
//------------------------------------------------------------------
[RCDATA_END_TAG_OPEN_STATE](cp) {
if (isAsciiLetter(cp)) {
this._createEndTagToken();
this._reconsumeInState(RCDATA_END_TAG_NAME_STATE);
} else {
this._emitChars('</');
this._reconsumeInState(RCDATA_STATE);
}
}
// RCDATA end tag name state
//------------------------------------------------------------------
[RCDATA_END_TAG_NAME_STATE](cp) {
if (isAsciiUpper(cp)) {
this.currentToken.tagName += toAsciiLowerChar(cp);
this.tempBuff.push(cp);
} else if (isAsciiLower(cp)) {
this.currentToken.tagName += toChar(cp);
this.tempBuff.push(cp);
} else {
if (this.lastStartTagName === this.currentToken.tagName) {
if (isWhitespace(cp)) {
this.state = BEFORE_ATTRIBUTE_NAME_STATE;
return;
}
if (cp === $.SOLIDUS) {
this.state = SELF_CLOSING_START_TAG_STATE;
return;
}
if (cp === $.GREATER_THAN_SIGN) {
this.state = DATA_STATE;
this._emitCurrentToken();
return;
}
}
this._emitChars('</');
this._emitSeveralCodePoints(this.tempBuff);
this._reconsumeInState(RCDATA_STATE);
}
}
// RAWTEXT less-than sign state
//------------------------------------------------------------------
[RAWTEXT_LESS_THAN_SIGN_STATE](cp) {
if (cp === $.SOLIDUS) {
this.tempBuff = [];
this.state = RAWTEXT_END_TAG_OPEN_STATE;
} else {
this._emitChars('<');
this._reconsumeInState(RAWTEXT_STATE);
}
}
// RAWTEXT end tag open state
//------------------------------------------------------------------
[RAWTEXT_END_TAG_OPEN_STATE](cp) {
if (isAsciiLetter(cp)) {
this._createEndTagToken();
this._reconsumeInState(RAWTEXT_END_TAG_NAME_STATE);
} else {
this._emitChars('</');
this._reconsumeInState(RAWTEXT_STATE);
}
}
// RAWTEXT end tag name state
//------------------------------------------------------------------
[RAWTEXT_END_TAG_NAME_STATE](cp) {
if (isAsciiUpper(cp)) {
this.currentToken.tagName += toAsciiLowerChar(cp);
this.tempBuff.push(cp);
} else if (isAsciiLower(cp)) {
this.currentToken.tagName += toChar(cp);
this.tempBuff.push(cp);
} else {
if (this.lastStartTagName === this.currentToken.tagName) {
if (isWhitespace(cp)) {
this.state = BEFORE_ATTRIBUTE_NAME_STATE;
return;
}
if (cp === $.SOLIDUS) {
this.state = SELF_CLOSING_START_TAG_STATE;
return;
}
if (cp === $.GREATER_THAN_SIGN) {
this._emitCurrentToken();
this.state = DATA_STATE;
return;
}
}
this._emitChars('</');
this._emitSeveralCodePoints(this.tempBuff);
this._reconsumeInState(RAWTEXT_STATE);
}
}
// Script data less-than sign state
//------------------------------------------------------------------
[SCRIPT_DATA_LESS_THAN_SIGN_STATE](cp) {
if (cp === $.SOLIDUS) {
this.tempBuff = [];
this.state = SCRIPT_DATA_END_TAG_OPEN_STATE;
} else if (cp === $.EXCLAMATION_MARK) {
this.state = SCRIPT_DATA_ESCAPE_START_STATE;
this._emitChars('<!');
} else {
this._emitChars('<');
this._reconsumeInState(SCRIPT_DATA_STATE);
}
}
// Script data end tag open state
//------------------------------------------------------------------
[SCRIPT_DATA_END_TAG_OPEN_STATE](cp) {
if (isAsciiLetter(cp)) {
this._createEndTagToken();
this._reconsumeInState(SCRIPT_DATA_END_TAG_NAME_STATE);
} else {
this._emitChars('</');
this._reconsumeInState(SCRIPT_DATA_STATE);
}
}
// Script data end tag name state
//------------------------------------------------------------------
[SCRIPT_DATA_END_TAG_NAME_STATE](cp) {
if (isAsciiUpper(cp)) {
this.currentToken.tagName += toAsciiLowerChar(cp);
this.tempBuff.push(cp);
} else if (isAsciiLower(cp)) {
this.currentToken.tagName += toChar(cp);
this.tempBuff.push(cp);
} else {
if (this.lastStartTagName === this.currentToken.tagName) {
if (isWhitespace(cp)) {
this.state = BEFORE_ATTRIBUTE_NAME_STATE;
return;
} else if (cp === $.SOLIDUS) {
this.state = SELF_CLOSING_START_TAG_STATE;
return;
} else if (cp === $.GREATER_THAN_SIGN) {
this._emitCurrentToken();
this.state = DATA_STATE;
return;
}
}
this._emitChars('</');
this._emitSeveralCodePoints(this.tempBuff);
this._reconsumeInState(SCRIPT_DATA_STATE);
}
}
// Script data escape start state
//------------------------------------------------------------------
[SCRIPT_DATA_ESCAPE_START_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this.state = SCRIPT_DATA_ESCAPE_START_DASH_STATE;
this._emitChars('-');
} else {
this._reconsumeInState(SCRIPT_DATA_STATE);
}
}
// Script data escape start dash state
//------------------------------------------------------------------
[SCRIPT_DATA_ESCAPE_START_DASH_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE;
this._emitChars('-');
} else {
this._reconsumeInState(SCRIPT_DATA_STATE);
}
}
// Script data escaped state
//------------------------------------------------------------------
[SCRIPT_DATA_ESCAPED_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this.state = SCRIPT_DATA_ESCAPED_DASH_STATE;
this._emitChars('-');
} else if (cp === $.LESS_THAN_SIGN) {
this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this._emitChars(unicode.REPLACEMENT_CHARACTER);
} else if (cp === $.EOF) {
this._err(ERR.eofInScriptHtmlCommentLikeText);
this._emitEOFToken();
} else {
this._emitCodePoint(cp);
}
}
// Script data escaped dash state
//------------------------------------------------------------------
[SCRIPT_DATA_ESCAPED_DASH_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE;
this._emitChars('-');
} else if (cp === $.LESS_THAN_SIGN) {
this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.state = SCRIPT_DATA_ESCAPED_STATE;
this._emitChars(unicode.REPLACEMENT_CHARACTER);
} else if (cp === $.EOF) {
this._err(ERR.eofInScriptHtmlCommentLikeText);
this._emitEOFToken();
} else {
this.state = SCRIPT_DATA_ESCAPED_STATE;
this._emitCodePoint(cp);
}
}
// Script data escaped dash dash state
//------------------------------------------------------------------
[SCRIPT_DATA_ESCAPED_DASH_DASH_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this._emitChars('-');
} else if (cp === $.LESS_THAN_SIGN) {
this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this.state = SCRIPT_DATA_STATE;
this._emitChars('>');
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.state = SCRIPT_DATA_ESCAPED_STATE;
this._emitChars(unicode.REPLACEMENT_CHARACTER);
} else if (cp === $.EOF) {
this._err(ERR.eofInScriptHtmlCommentLikeText);
this._emitEOFToken();
} else {
this.state = SCRIPT_DATA_ESCAPED_STATE;
this._emitCodePoint(cp);
}
}
// Script data escaped less-than sign state
//------------------------------------------------------------------
[SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE](cp) {
if (cp === $.SOLIDUS) {
this.tempBuff = [];
this.state = SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE;
} else if (isAsciiLetter(cp)) {
this.tempBuff = [];
this._emitChars('<');
this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE);
} else {
this._emitChars('<');
this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
}
}
// Script data escaped end tag open state
//------------------------------------------------------------------
[SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE](cp) {
if (isAsciiLetter(cp)) {
this._createEndTagToken();
this._reconsumeInState(SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE);
} else {
this._emitChars('</');
this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
}
}
// Script data escaped end tag name state
//------------------------------------------------------------------
[SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE](cp) {
if (isAsciiUpper(cp)) {
this.currentToken.tagName += toAsciiLowerChar(cp);
this.tempBuff.push(cp);
} else if (isAsciiLower(cp)) {
this.currentToken.tagName += toChar(cp);
this.tempBuff.push(cp);
} else {
if (this.lastStartTagName === this.currentToken.tagName) {
if (isWhitespace(cp)) {
this.state = BEFORE_ATTRIBUTE_NAME_STATE;
return;
}
if (cp === $.SOLIDUS) {
this.state = SELF_CLOSING_START_TAG_STATE;
return;
}
if (cp === $.GREATER_THAN_SIGN) {
this._emitCurrentToken();
this.state = DATA_STATE;
return;
}
}
this._emitChars('</');
this._emitSeveralCodePoints(this.tempBuff);
this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
}
}
// Script data double escape start state
//------------------------------------------------------------------
[SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE](cp) {
if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN) {
this.state = this._isTempBufferEqualToScriptString()
? SCRIPT_DATA_DOUBLE_ESCAPED_STATE
: SCRIPT_DATA_ESCAPED_STATE;
this._emitCodePoint(cp);
} else if (isAsciiUpper(cp)) {
this.tempBuff.push(toAsciiLowerCodePoint(cp));
this._emitCodePoint(cp);
} else if (isAsciiLower(cp)) {
this.tempBuff.push(cp);
this._emitCodePoint(cp);
} else {
this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE);
}
}
// Script data double escaped state
//------------------------------------------------------------------
[SCRIPT_DATA_DOUBLE_ESCAPED_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE;
this._emitChars('-');
} else if (cp === $.LESS_THAN_SIGN) {
this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
this._emitChars('<');
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this._emitChars(unicode.REPLACEMENT_CHARACTER);
} else if (cp === $.EOF) {
this._err(ERR.eofInScriptHtmlCommentLikeText);
this._emitEOFToken();
} else {
this._emitCodePoint(cp);
}
}
// Script data double escaped dash state
//------------------------------------------------------------------
[SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE;
this._emitChars('-');
} else if (cp === $.LESS_THAN_SIGN) {
this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
this._emitChars('<');
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
this._emitChars(unicode.REPLACEMENT_CHARACTER);
} else if (cp === $.EOF) {
this._err(ERR.eofInScriptHtmlCommentLikeText);
this._emitEOFToken();
} else {
this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
this._emitCodePoint(cp);
}
}
// Script data double escaped dash dash state
//------------------------------------------------------------------
[SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this._emitChars('-');
} else if (cp === $.LESS_THAN_SIGN) {
this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE;
this._emitChars('<');
} else if (cp === $.GREATER_THAN_SIGN) {
this.state = SCRIPT_DATA_STATE;
this._emitChars('>');
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
this._emitChars(unicode.REPLACEMENT_CHARACTER);
} else if (cp === $.EOF) {
this._err(ERR.eofInScriptHtmlCommentLikeText);
this._emitEOFToken();
} else {
this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
this._emitCodePoint(cp);
}
}
// Script data double escaped less-than sign state
//------------------------------------------------------------------
[SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE](cp) {
if (cp === $.SOLIDUS) {
this.tempBuff = [];
this.state = SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE;
this._emitChars('/');
} else {
this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE);
}
}
// Script data double escape end state
//------------------------------------------------------------------
[SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE](cp) {
if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN) {
this.state = this._isTempBufferEqualToScriptString()
? SCRIPT_DATA_ESCAPED_STATE
: SCRIPT_DATA_DOUBLE_ESCAPED_STATE;
this._emitCodePoint(cp);
} else if (isAsciiUpper(cp)) {
this.tempBuff.push(toAsciiLowerCodePoint(cp));
this._emitCodePoint(cp);
} else if (isAsciiLower(cp)) {
this.tempBuff.push(cp);
this._emitCodePoint(cp);
} else {
this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE);
}
}
// Before attribute name state
//------------------------------------------------------------------
[BEFORE_ATTRIBUTE_NAME_STATE](cp) {
if (isWhitespace(cp)) {
return;
}
if (cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN || cp === $.EOF) {
this._reconsumeInState(AFTER_ATTRIBUTE_NAME_STATE);
} else if (cp === $.EQUALS_SIGN) {
this._err(ERR.unexpectedEqualsSignBeforeAttributeName);
this._createAttr('=');
this.state = ATTRIBUTE_NAME_STATE;
} else {
this._createAttr('');
this._reconsumeInState(ATTRIBUTE_NAME_STATE);
}
}
// Attribute name state
//------------------------------------------------------------------
[ATTRIBUTE_NAME_STATE](cp) {
if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN || cp === $.EOF) {
this._leaveAttrName(AFTER_ATTRIBUTE_NAME_STATE);
this._unconsume();
} else if (cp === $.EQUALS_SIGN) {
this._leaveAttrName(BEFORE_ATTRIBUTE_VALUE_STATE);
} else if (isAsciiUpper(cp)) {
this.currentAttr.name += toAsciiLowerChar(cp);
} else if (cp === $.QUOTATION_MARK || cp === $.APOSTROPHE || cp === $.LESS_THAN_SIGN) {
this._err(ERR.unexpectedCharacterInAttributeName);
this.currentAttr.name += toChar(cp);
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.currentAttr.name += unicode.REPLACEMENT_CHARACTER;
} else {
this.currentAttr.name += toChar(cp);
}
}
// After attribute name state
//------------------------------------------------------------------
[AFTER_ATTRIBUTE_NAME_STATE](cp) {
if (isWhitespace(cp)) {
return;
}
if (cp === $.SOLIDUS) {
this.state = SELF_CLOSING_START_TAG_STATE;
} else if (cp === $.EQUALS_SIGN) {
this.state = BEFORE_ATTRIBUTE_VALUE_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this.state = DATA_STATE;
this._emitCurrentToken();
} else if (cp === $.EOF) {
this._err(ERR.eofInTag);
this._emitEOFToken();
} else {
this._createAttr('');
this._reconsumeInState(ATTRIBUTE_NAME_STATE);
}
}
// Before attribute value state
//------------------------------------------------------------------
[BEFORE_ATTRIBUTE_VALUE_STATE](cp) {
if (isWhitespace(cp)) {
return;
}
if (cp === $.QUOTATION_MARK) {
this.state = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
} else if (cp === $.APOSTROPHE) {
this.state = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this._err(ERR.missingAttributeValue);
this.state = DATA_STATE;
this._emitCurrentToken();
} else {
this._reconsumeInState(ATTRIBUTE_VALUE_UNQUOTED_STATE);
}
}
// Attribute value (double-quoted) state
//------------------------------------------------------------------
[ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE](cp) {
if (cp === $.QUOTATION_MARK) {
this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
} else if (cp === $.AMPERSAND) {
this.returnState = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
this.state = CHARACTER_REFERENCE_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.currentAttr.value += unicode.REPLACEMENT_CHARACTER;
} else if (cp === $.EOF) {
this._err(ERR.eofInTag);
this._emitEOFToken();
} else {
this.currentAttr.value += toChar(cp);
}
}
// Attribute value (single-quoted) state
//------------------------------------------------------------------
[ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE](cp) {
if (cp === $.APOSTROPHE) {
this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
} else if (cp === $.AMPERSAND) {
this.returnState = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
this.state = CHARACTER_REFERENCE_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.currentAttr.value += unicode.REPLACEMENT_CHARACTER;
} else if (cp === $.EOF) {
this._err(ERR.eofInTag);
this._emitEOFToken();
} else {
this.currentAttr.value += toChar(cp);
}
}
// Attribute value (unquoted) state
//------------------------------------------------------------------
[ATTRIBUTE_VALUE_UNQUOTED_STATE](cp) {
if (isWhitespace(cp)) {
this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE);
} else if (cp === $.AMPERSAND) {
this.returnState = ATTRIBUTE_VALUE_UNQUOTED_STATE;
this.state = CHARACTER_REFERENCE_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this._leaveAttrValue(DATA_STATE);
this._emitCurrentToken();
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.currentAttr.value += unicode.REPLACEMENT_CHARACTER;
} else if (
cp === $.QUOTATION_MARK ||
cp === $.APOSTROPHE ||
cp === $.LESS_THAN_SIGN ||
cp === $.EQUALS_SIGN ||
cp === $.GRAVE_ACCENT
) {
this._err(ERR.unexpectedCharacterInUnquotedAttributeValue);
this.currentAttr.value += toChar(cp);
} else if (cp === $.EOF) {
this._err(ERR.eofInTag);
this._emitEOFToken();
} else {
this.currentAttr.value += toChar(cp);
}
}
// After attribute value (quoted) state
//------------------------------------------------------------------
[AFTER_ATTRIBUTE_VALUE_QUOTED_STATE](cp) {
if (isWhitespace(cp)) {
this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE);
} else if (cp === $.SOLIDUS) {
this._leaveAttrValue(SELF_CLOSING_START_TAG_STATE);
} else if (cp === $.GREATER_THAN_SIGN) {
this._leaveAttrValue(DATA_STATE);
this._emitCurrentToken();
} else if (cp === $.EOF) {
this._err(ERR.eofInTag);
this._emitEOFToken();
} else {
this._err(ERR.missingWhitespaceBetweenAttributes);
this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE);
}
}
// Self-closing start tag state
//------------------------------------------------------------------
[SELF_CLOSING_START_TAG_STATE](cp) {
if (cp === $.GREATER_THAN_SIGN) {
this.currentToken.selfClosing = true;
this.state = DATA_STATE;
this._emitCurrentToken();
} else if (cp === $.EOF) {
this._err(ERR.eofInTag);
this._emitEOFToken();
} else {
this._err(ERR.unexpectedSolidusInTag);
this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE);
}
}
// Bogus comment state
//------------------------------------------------------------------
[BOGUS_COMMENT_STATE](cp) {
if (cp === $.GREATER_THAN_SIGN) {
this.state = DATA_STATE;
this._emitCurrentToken();
} else if (cp === $.EOF) {
this._emitCurrentToken();
this._emitEOFToken();
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.currentToken.data += unicode.REPLACEMENT_CHARACTER;
} else {
this.currentToken.data += toChar(cp);
}
}
// Markup declaration open state
//------------------------------------------------------------------
[MARKUP_DECLARATION_OPEN_STATE](cp) {
if (this._consumeSequenceIfMatch($$.DASH_DASH_STRING, cp, true)) {
this._createCommentToken();
this.state = COMMENT_START_STATE;
} else if (this._consumeSequenceIfMatch($$.DOCTYPE_STRING, cp, false)) {
this.state = DOCTYPE_STATE;
} else if (this._consumeSequenceIfMatch($$.CDATA_START_STRING, cp, true)) {
if (this.allowCDATA) {
this.state = CDATA_SECTION_STATE;
} else {
this._err(ERR.cdataInHtmlContent);
this._createCommentToken();
this.currentToken.data = '[CDATA[';
this.state = BOGUS_COMMENT_STATE;
}
}
//NOTE: sequence lookup can be abrupted by hibernation. In that case lookup
//results are no longer valid and we will need to start over.
else if (!this._ensureHibernation()) {
this._err(ERR.incorrectlyOpenedComment);
this._createCommentToken();
this._reconsumeInState(BOGUS_COMMENT_STATE);
}
}
// Comment start state
//------------------------------------------------------------------
[COMMENT_START_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this.state = COMMENT_START_DASH_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this._err(ERR.abruptClosingOfEmptyComment);
this.state = DATA_STATE;
this._emitCurrentToken();
} else {
this._reconsumeInState(COMMENT_STATE);
}
}
// Comment start dash state
//------------------------------------------------------------------
[COMMENT_START_DASH_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this.state = COMMENT_END_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this._err(ERR.abruptClosingOfEmptyComment);
this.state = DATA_STATE;
this._emitCurrentToken();
} else if (cp === $.EOF) {
this._err(ERR.eofInComment);
this._emitCurrentToken();
this._emitEOFToken();
} else {
this.currentToken.data += '-';
this._reconsumeInState(COMMENT_STATE);
}
}
// Comment state
//------------------------------------------------------------------
[COMMENT_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this.state = COMMENT_END_DASH_STATE;
} else if (cp === $.LESS_THAN_SIGN) {
this.currentToken.data += '<';
this.state = COMMENT_LESS_THAN_SIGN_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.currentToken.data += unicode.REPLACEMENT_CHARACTER;
} else if (cp === $.EOF) {
this._err(ERR.eofInComment);
this._emitCurrentToken();
this._emitEOFToken();
} else {
this.currentToken.data += toChar(cp);
}
}
// Comment less-than sign state
//------------------------------------------------------------------
[COMMENT_LESS_THAN_SIGN_STATE](cp) {
if (cp === $.EXCLAMATION_MARK) {
this.currentToken.data += '!';
this.state = COMMENT_LESS_THAN_SIGN_BANG_STATE;
} else if (cp === $.LESS_THAN_SIGN) {
this.currentToken.data += '!';
} else {
this._reconsumeInState(COMMENT_STATE);
}
}
// Comment less-than sign bang state
//------------------------------------------------------------------
[COMMENT_LESS_THAN_SIGN_BANG_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this.state = COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE;
} else {
this._reconsumeInState(COMMENT_STATE);
}
}
// Comment less-than sign bang dash state
//------------------------------------------------------------------
[COMMENT_LESS_THAN_SIGN_BANG_DASH_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this.state = COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE;
} else {
this._reconsumeInState(COMMENT_END_DASH_STATE);
}
}
// Comment less-than sign bang dash dash state
//------------------------------------------------------------------
[COMMENT_LESS_THAN_SIGN_BANG_DASH_DASH_STATE](cp) {
if (cp !== $.GREATER_THAN_SIGN && cp !== $.EOF) {
this._err(ERR.nestedComment);
}
this._reconsumeInState(COMMENT_END_STATE);
}
// Comment end dash state
//------------------------------------------------------------------
[COMMENT_END_DASH_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this.state = COMMENT_END_STATE;
} else if (cp === $.EOF) {
this._err(ERR.eofInComment);
this._emitCurrentToken();
this._emitEOFToken();
} else {
this.currentToken.data += '-';
this._reconsumeInState(COMMENT_STATE);
}
}
// Comment end state
//------------------------------------------------------------------
[COMMENT_END_STATE](cp) {
if (cp === $.GREATER_THAN_SIGN) {
this.state = DATA_STATE;
this._emitCurrentToken();
} else if (cp === $.EXCLAMATION_MARK) {
this.state = COMMENT_END_BANG_STATE;
} else if (cp === $.HYPHEN_MINUS) {
this.currentToken.data += '-';
} else if (cp === $.EOF) {
this._err(ERR.eofInComment);
this._emitCurrentToken();
this._emitEOFToken();
} else {
this.currentToken.data += '--';
this._reconsumeInState(COMMENT_STATE);
}
}
// Comment end bang state
//------------------------------------------------------------------
[COMMENT_END_BANG_STATE](cp) {
if (cp === $.HYPHEN_MINUS) {
this.currentToken.data += '--!';
this.state = COMMENT_END_DASH_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this._err(ERR.incorrectlyClosedComment);
this.state = DATA_STATE;
this._emitCurrentToken();
} else if (cp === $.EOF) {
this._err(ERR.eofInComment);
this._emitCurrentToken();
this._emitEOFToken();
} else {
this.currentToken.data += '--!';
this._reconsumeInState(COMMENT_STATE);
}
}
// DOCTYPE state
//------------------------------------------------------------------
[DOCTYPE_STATE](cp) {
if (isWhitespace(cp)) {
this.state = BEFORE_DOCTYPE_NAME_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this._reconsumeInState(BEFORE_DOCTYPE_NAME_STATE);
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this._createDoctypeToken(null);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else {
this._err(ERR.missingWhitespaceBeforeDoctypeName);
this._reconsumeInState(BEFORE_DOCTYPE_NAME_STATE);
}
}
// Before DOCTYPE name state
//------------------------------------------------------------------
[BEFORE_DOCTYPE_NAME_STATE](cp) {
if (isWhitespace(cp)) {
return;
}
if (isAsciiUpper(cp)) {
this._createDoctypeToken(toAsciiLowerChar(cp));
this.state = DOCTYPE_NAME_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this._createDoctypeToken(unicode.REPLACEMENT_CHARACTER);
this.state = DOCTYPE_NAME_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this._err(ERR.missingDoctypeName);
this._createDoctypeToken(null);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this.state = DATA_STATE;
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this._createDoctypeToken(null);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else {
this._createDoctypeToken(toChar(cp));
this.state = DOCTYPE_NAME_STATE;
}
}
// DOCTYPE name state
//------------------------------------------------------------------
[DOCTYPE_NAME_STATE](cp) {
if (isWhitespace(cp)) {
this.state = AFTER_DOCTYPE_NAME_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this.state = DATA_STATE;
this._emitCurrentToken();
} else if (isAsciiUpper(cp)) {
this.currentToken.name += toAsciiLowerChar(cp);
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.currentToken.name += unicode.REPLACEMENT_CHARACTER;
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else {
this.currentToken.name += toChar(cp);
}
}
// After DOCTYPE name state
//------------------------------------------------------------------
[AFTER_DOCTYPE_NAME_STATE](cp) {
if (isWhitespace(cp)) {
return;
}
if (cp === $.GREATER_THAN_SIGN) {
this.state = DATA_STATE;
this._emitCurrentToken();
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else if (this._consumeSequenceIfMatch($$.PUBLIC_STRING, cp, false)) {
this.state = AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE;
} else if (this._consumeSequenceIfMatch($$.SYSTEM_STRING, cp, false)) {
this.state = AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE;
}
//NOTE: sequence lookup can be abrupted by hibernation. In that case lookup
//results are no longer valid and we will need to start over.
else if (!this._ensureHibernation()) {
this._err(ERR.invalidCharacterSequenceAfterDoctypeName);
this.currentToken.forceQuirks = true;
this._reconsumeInState(BOGUS_DOCTYPE_STATE);
}
}
// After DOCTYPE public keyword state
//------------------------------------------------------------------
[AFTER_DOCTYPE_PUBLIC_KEYWORD_STATE](cp) {
if (isWhitespace(cp)) {
this.state = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
} else if (cp === $.QUOTATION_MARK) {
this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);
this.currentToken.publicId = '';
this.state = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE;
} else if (cp === $.APOSTROPHE) {
this._err(ERR.missingWhitespaceAfterDoctypePublicKeyword);
this.currentToken.publicId = '';
this.state = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this._err(ERR.missingDoctypePublicIdentifier);
this.currentToken.forceQuirks = true;
this.state = DATA_STATE;
this._emitCurrentToken();
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else {
this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
this.currentToken.forceQuirks = true;
this._reconsumeInState(BOGUS_DOCTYPE_STATE);
}
}
// Before DOCTYPE public identifier state
//------------------------------------------------------------------
[BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE](cp) {
if (isWhitespace(cp)) {
return;
}
if (cp === $.QUOTATION_MARK) {
this.currentToken.publicId = '';
this.state = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE;
} else if (cp === $.APOSTROPHE) {
this.currentToken.publicId = '';
this.state = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this._err(ERR.missingDoctypePublicIdentifier);
this.currentToken.forceQuirks = true;
this.state = DATA_STATE;
this._emitCurrentToken();
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else {
this._err(ERR.missingQuoteBeforeDoctypePublicIdentifier);
this.currentToken.forceQuirks = true;
this._reconsumeInState(BOGUS_DOCTYPE_STATE);
}
}
// DOCTYPE public identifier (double-quoted) state
//------------------------------------------------------------------
[DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE](cp) {
if (cp === $.QUOTATION_MARK) {
this.state = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.currentToken.publicId += unicode.REPLACEMENT_CHARACTER;
} else if (cp === $.GREATER_THAN_SIGN) {
this._err(ERR.abruptDoctypePublicIdentifier);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this.state = DATA_STATE;
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else {
this.currentToken.publicId += toChar(cp);
}
}
// DOCTYPE public identifier (single-quoted) state
//------------------------------------------------------------------
[DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE](cp) {
if (cp === $.APOSTROPHE) {
this.state = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.currentToken.publicId += unicode.REPLACEMENT_CHARACTER;
} else if (cp === $.GREATER_THAN_SIGN) {
this._err(ERR.abruptDoctypePublicIdentifier);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this.state = DATA_STATE;
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else {
this.currentToken.publicId += toChar(cp);
}
}
// After DOCTYPE public identifier state
//------------------------------------------------------------------
[AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE](cp) {
if (isWhitespace(cp)) {
this.state = BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this.state = DATA_STATE;
this._emitCurrentToken();
} else if (cp === $.QUOTATION_MARK) {
this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);
this.currentToken.systemId = '';
this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
} else if (cp === $.APOSTROPHE) {
this._err(ERR.missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers);
this.currentToken.systemId = '';
this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else {
this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
this.currentToken.forceQuirks = true;
this._reconsumeInState(BOGUS_DOCTYPE_STATE);
}
}
// Between DOCTYPE public and system identifiers state
//------------------------------------------------------------------
[BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE](cp) {
if (isWhitespace(cp)) {
return;
}
if (cp === $.GREATER_THAN_SIGN) {
this._emitCurrentToken();
this.state = DATA_STATE;
} else if (cp === $.QUOTATION_MARK) {
this.currentToken.systemId = '';
this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
} else if (cp === $.APOSTROPHE) {
this.currentToken.systemId = '';
this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else {
this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
this.currentToken.forceQuirks = true;
this._reconsumeInState(BOGUS_DOCTYPE_STATE);
}
}
// After DOCTYPE system keyword state
//------------------------------------------------------------------
[AFTER_DOCTYPE_SYSTEM_KEYWORD_STATE](cp) {
if (isWhitespace(cp)) {
this.state = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
} else if (cp === $.QUOTATION_MARK) {
this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);
this.currentToken.systemId = '';
this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
} else if (cp === $.APOSTROPHE) {
this._err(ERR.missingWhitespaceAfterDoctypeSystemKeyword);
this.currentToken.systemId = '';
this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this._err(ERR.missingDoctypeSystemIdentifier);
this.currentToken.forceQuirks = true;
this.state = DATA_STATE;
this._emitCurrentToken();
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else {
this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
this.currentToken.forceQuirks = true;
this._reconsumeInState(BOGUS_DOCTYPE_STATE);
}
}
// Before DOCTYPE system identifier state
//------------------------------------------------------------------
[BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE](cp) {
if (isWhitespace(cp)) {
return;
}
if (cp === $.QUOTATION_MARK) {
this.currentToken.systemId = '';
this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
} else if (cp === $.APOSTROPHE) {
this.currentToken.systemId = '';
this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
} else if (cp === $.GREATER_THAN_SIGN) {
this._err(ERR.missingDoctypeSystemIdentifier);
this.currentToken.forceQuirks = true;
this.state = DATA_STATE;
this._emitCurrentToken();
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else {
this._err(ERR.missingQuoteBeforeDoctypeSystemIdentifier);
this.currentToken.forceQuirks = true;
this._reconsumeInState(BOGUS_DOCTYPE_STATE);
}
}
// DOCTYPE system identifier (double-quoted) state
//------------------------------------------------------------------
[DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE](cp) {
if (cp === $.QUOTATION_MARK) {
this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.currentToken.systemId += unicode.REPLACEMENT_CHARACTER;
} else if (cp === $.GREATER_THAN_SIGN) {
this._err(ERR.abruptDoctypeSystemIdentifier);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this.state = DATA_STATE;
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else {
this.currentToken.systemId += toChar(cp);
}
}
// DOCTYPE system identifier (single-quoted) state
//------------------------------------------------------------------
[DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE](cp) {
if (cp === $.APOSTROPHE) {
this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
this.currentToken.systemId += unicode.REPLACEMENT_CHARACTER;
} else if (cp === $.GREATER_THAN_SIGN) {
this._err(ERR.abruptDoctypeSystemIdentifier);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this.state = DATA_STATE;
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else {
this.currentToken.systemId += toChar(cp);
}
}
// After DOCTYPE system identifier state
//------------------------------------------------------------------
[AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE](cp) {
if (isWhitespace(cp)) {
return;
}
if (cp === $.GREATER_THAN_SIGN) {
this._emitCurrentToken();
this.state = DATA_STATE;
} else if (cp === $.EOF) {
this._err(ERR.eofInDoctype);
this.currentToken.forceQuirks = true;
this._emitCurrentToken();
this._emitEOFToken();
} else {
this._err(ERR.unexpectedCharacterAfterDoctypeSystemIdentifier);
this._reconsumeInState(BOGUS_DOCTYPE_STATE);
}
}
// Bogus DOCTYPE state
//------------------------------------------------------------------
[BOGUS_DOCTYPE_STATE](cp) {
if (cp === $.GREATER_THAN_SIGN) {
this._emitCurrentToken();
this.state = DATA_STATE;
} else if (cp === $.NULL) {
this._err(ERR.unexpectedNullCharacter);
} else if (cp === $.EOF) {
this._emitCurrentToken();
this._emitEOFToken();
}
}
// CDATA section state
//------------------------------------------------------------------
[CDATA_SECTION_STATE](cp) {
if (cp === $.RIGHT_SQUARE_BRACKET) {
this.state = CDATA_SECTION_BRACKET_STATE;
} else if (cp === $.EOF) {
this._err(ERR.eofInCdata);
this._emitEOFToken();
} else {
this._emitCodePoint(cp);
}
}
// CDATA section bracket state
//------------------------------------------------------------------
[CDATA_SECTION_BRACKET_STATE](cp) {
if (cp === $.RIGHT_SQUARE_BRACKET) {
this.state = CDATA_SECTION_END_STATE;
} else {
this._emitChars(']');
this._reconsumeInState(CDATA_SECTION_STATE);
}
}
// CDATA section end state
//------------------------------------------------------------------
[CDATA_SECTION_END_STATE](cp) {
if (cp === $.GREATER_THAN_SIGN) {
this.state = DATA_STATE;
} else if (cp === $.RIGHT_SQUARE_BRACKET) {
this._emitChars(']');
} else {
this._emitChars(']]');
this._reconsumeInState(CDATA_SECTION_STATE);
}
}
// Character reference state
//------------------------------------------------------------------
[CHARACTER_REFERENCE_STATE](cp) {
this.tempBuff = [$.AMPERSAND];
if (cp === $.NUMBER_SIGN) {
this.tempBuff.push(cp);
this.state = NUMERIC_CHARACTER_REFERENCE_STATE;
} else if (isAsciiAlphaNumeric(cp)) {
this._reconsumeInState(NAMED_CHARACTER_REFERENCE_STATE);
} else {
this._flushCodePointsConsumedAsCharacterReference();
this._reconsumeInState(this.returnState);
}
}
// Named character reference state
//------------------------------------------------------------------
[NAMED_CHARACTER_REFERENCE_STATE](cp) {
const matchResult = this._matchNamedCharacterReference(cp);
//NOTE: matching can be abrupted by hibernation. In that case match
//results are no longer valid and we will need to start over.
if (this._ensureHibernation()) {
this.tempBuff = [$.AMPERSAND];
} else if (matchResult) {
const withSemicolon = this.tempBuff[this.tempBuff.length - 1] === $.SEMICOLON;
if (!this._isCharacterReferenceAttributeQuirk(withSemicolon)) {
if (!withSemicolon) {
this._errOnNextCodePoint(ERR.missingSemicolonAfterCharacterReference);
}
this.tempBuff = matchResult;
}
this._flushCodePointsConsumedAsCharacterReference();
this.state = this.returnState;
} else {
this._flushCodePointsConsumedAsCharacterReference();
this.state = AMBIGUOUS_AMPERSAND_STATE;
}
}
// Ambiguos ampersand state
//------------------------------------------------------------------
[AMBIGUOUS_AMPERSAND_STATE](cp) {
if (isAsciiAlphaNumeric(cp)) {
if (this._isCharacterReferenceInAttribute()) {
this.currentAttr.value += toChar(cp);
} else {
this._emitCodePoint(cp);
}
} else {
if (cp === $.SEMICOLON) {
this._err(ERR.unknownNamedCharacterReference);
}
this._reconsumeInState(this.returnState);
}
}
// Numeric character reference state
//------------------------------------------------------------------
[NUMERIC_CHARACTER_REFERENCE_STATE](cp) {
this.charRefCode = 0;
if (cp === $.LATIN_SMALL_X || cp === $.LATIN_CAPITAL_X) {
this.tempBuff.push(cp);
this.state = HEXADEMICAL_CHARACTER_REFERENCE_START_STATE;
} else {
this._reconsumeInState(DECIMAL_CHARACTER_REFERENCE_START_STATE);
}
}
// Hexademical character reference start state
//------------------------------------------------------------------
[HEXADEMICAL_CHARACTER_REFERENCE_START_STATE](cp) {
if (isAsciiHexDigit(cp)) {
this._reconsumeInState(HEXADEMICAL_CHARACTER_REFERENCE_STATE);
} else {
this._err(ERR.absenceOfDigitsInNumericCharacterReference);
this._flushCodePointsConsumedAsCharacterReference();
this._reconsumeInState(this.returnState);
}
}
// Decimal character reference start state
//------------------------------------------------------------------
[DECIMAL_CHARACTER_REFERENCE_START_STATE](cp) {
if (isAsciiDigit(cp)) {
this._reconsumeInState(DECIMAL_CHARACTER_REFERENCE_STATE);
} else {
this._err(ERR.absenceOfDigitsInNumericCharacterReference);
this._flushCodePointsConsumedAsCharacterReference();
this._reconsumeInState(this.returnState);
}
}
// Hexademical character reference state
//------------------------------------------------------------------
[HEXADEMICAL_CHARACTER_REFERENCE_STATE](cp) {
if (isAsciiUpperHexDigit(cp)) {
this.charRefCode = this.charRefCode * 16 + cp - 0x37;
} else if (isAsciiLowerHexDigit(cp)) {
this.charRefCode = this.charRefCode * 16 + cp - 0x57;
} else if (isAsciiDigit(cp)) {
this.charRefCode = this.charRefCode * 16 + cp - 0x30;
} else if (cp === $.SEMICOLON) {
this.state = NUMERIC_CHARACTER_REFERENCE_END_STATE;
} else {
this._err(ERR.missingSemicolonAfterCharacterReference);
this._reconsumeInState(NUMERIC_CHARACTER_REFERENCE_END_STATE);
}
}
// Decimal character reference state
//------------------------------------------------------------------
[DECIMAL_CHARACTER_REFERENCE_STATE](cp) {
if (isAsciiDigit(cp)) {
this.charRefCode = this.charRefCode * 10 + cp - 0x30;
} else if (cp === $.SEMICOLON) {
this.state = NUMERIC_CHARACTER_REFERENCE_END_STATE;
} else {
this._err(ERR.missingSemicolonAfterCharacterReference);
this._reconsumeInState(NUMERIC_CHARACTER_REFERENCE_END_STATE);
}
}
// Numeric character reference end state
//------------------------------------------------------------------
[NUMERIC_CHARACTER_REFERENCE_END_STATE]() {
if (this.charRefCode === $.NULL) {
this._err(ERR.nullCharacterReference);
this.charRefCode = $.REPLACEMENT_CHARACTER;
} else if (this.charRefCode > 0x10ffff) {
this._err(ERR.characterReferenceOutsideUnicodeRange);
this.charRefCode = $.REPLACEMENT_CHARACTER;
} else if (unicode.isSurrogate(this.charRefCode)) {
this._err(ERR.surrogateCharacterReference);
this.charRefCode = $.REPLACEMENT_CHARACTER;
} else if (unicode.isUndefinedCodePoint(this.charRefCode)) {
this._err(ERR.noncharacterCharacterReference);
} else if (unicode.isControlCodePoint(this.charRefCode) || this.charRefCode === $.CARRIAGE_RETURN) {
this._err(ERR.controlCharacterReference);
const replacement = C1_CONTROLS_REFERENCE_REPLACEMENTS[this.charRefCode];
if (replacement) {
this.charRefCode = replacement;
}
}
this.tempBuff = [this.charRefCode];
this._flushCodePointsConsumedAsCharacterReference();
this._reconsumeInState(this.returnState);
}
}
//Token types
Tokenizer.CHARACTER_TOKEN = 'CHARACTER_TOKEN';
Tokenizer.NULL_CHARACTER_TOKEN = 'NULL_CHARACTER_TOKEN';
Tokenizer.WHITESPACE_CHARACTER_TOKEN = 'WHITESPACE_CHARACTER_TOKEN';
Tokenizer.START_TAG_TOKEN = 'START_TAG_TOKEN';
Tokenizer.END_TAG_TOKEN = 'END_TAG_TOKEN';
Tokenizer.COMMENT_TOKEN = 'COMMENT_TOKEN';
Tokenizer.DOCTYPE_TOKEN = 'DOCTYPE_TOKEN';
Tokenizer.EOF_TOKEN = 'EOF_TOKEN';
Tokenizer.HIBERNATION_TOKEN = 'HIBERNATION_TOKEN';
//Tokenizer initial states for different modes
Tokenizer.MODE = {
DATA: DATA_STATE,
RCDATA: RCDATA_STATE,
RAWTEXT: RAWTEXT_STATE,
SCRIPT_DATA: SCRIPT_DATA_STATE,
PLAINTEXT: PLAINTEXT_STATE
};
//Static
Tokenizer.getTokenAttr = function(token, attrName) {
for (let i = token.attrs.length - 1; i >= 0; i--) {
if (token.attrs[i].name === attrName) {
return token.attrs[i].value;
}
}
return null;
};
module.exports = Tokenizer;
Reference in new issue View Git Blame Copy Permalink