diff options
Diffstat (limited to 'bin/wiki/ImportarDesdeURL/node_modules/parse5/lib/tokenizer/index.js')
-rw-r--r-- | bin/wiki/ImportarDesdeURL/node_modules/parse5/lib/tokenizer/index.js | 2144 |
1 files changed, 2144 insertions, 0 deletions
diff --git a/bin/wiki/ImportarDesdeURL/node_modules/parse5/lib/tokenizer/index.js b/bin/wiki/ImportarDesdeURL/node_modules/parse5/lib/tokenizer/index.js new file mode 100644 index 00000000..05475614 --- /dev/null +++ b/bin/wiki/ImportarDesdeURL/node_modules/parse5/lib/tokenizer/index.js @@ -0,0 +1,2144 @@ +'use strict'; + +var Preprocessor = require('./preprocessor'), + UNICODE = require('../common/unicode'), + neTree = require('./named_entity_data'); + +//Aliases +var $ = UNICODE.CODE_POINTS, + $$ = UNICODE.CODE_POINT_SEQUENCES; + +//Replacement code points for numeric entities +var NUMERIC_ENTITY_REPLACEMENTS = { + 0x00: 0xFFFD, 0x0D: 0x000D, 0x80: 0x20AC, 0x81: 0x0081, 0x82: 0x201A, 0x83: 0x0192, 0x84: 0x201E, + 0x85: 0x2026, 0x86: 0x2020, 0x87: 0x2021, 0x88: 0x02C6, 0x89: 0x2030, 0x8A: 0x0160, 0x8B: 0x2039, + 0x8C: 0x0152, 0x8D: 0x008D, 0x8E: 0x017D, 0x8F: 0x008F, 0x90: 0x0090, 0x91: 0x2018, 0x92: 0x2019, + 0x93: 0x201C, 0x94: 0x201D, 0x95: 0x2022, 0x96: 0x2013, 0x97: 0x2014, 0x98: 0x02DC, 0x99: 0x2122, + 0x9A: 0x0161, 0x9B: 0x203A, 0x9C: 0x0153, 0x9D: 0x009D, 0x9E: 0x017E, 0x9F: 0x0178 +}; + +// Named entity tree flags +var HAS_DATA_FLAG = 1 << 0; +var DATA_DUPLET_FLAG = 1 << 1; +var HAS_BRANCHES_FLAG = 1 << 2; +var MAX_BRANCH_MARKER_VALUE = HAS_DATA_FLAG | DATA_DUPLET_FLAG | HAS_BRANCHES_FLAG; + + +//States +var DATA_STATE = 'DATA_STATE', + CHARACTER_REFERENCE_IN_DATA_STATE = 'CHARACTER_REFERENCE_IN_DATA_STATE', + RCDATA_STATE = 'RCDATA_STATE', + CHARACTER_REFERENCE_IN_RCDATA_STATE = 'CHARACTER_REFERENCE_IN_RCDATA_STATE', + RAWTEXT_STATE = 'RAWTEXT_STATE', + SCRIPT_DATA_STATE = 'SCRIPT_DATA_STATE', + PLAINTEXT_STATE = 'PLAINTEXT_STATE', + TAG_OPEN_STATE = 'TAG_OPEN_STATE', + END_TAG_OPEN_STATE = 'END_TAG_OPEN_STATE', + TAG_NAME_STATE = 'TAG_NAME_STATE', + RCDATA_LESS_THAN_SIGN_STATE = 'RCDATA_LESS_THAN_SIGN_STATE', + RCDATA_END_TAG_OPEN_STATE = 'RCDATA_END_TAG_OPEN_STATE', + RCDATA_END_TAG_NAME_STATE = 'RCDATA_END_TAG_NAME_STATE', + RAWTEXT_LESS_THAN_SIGN_STATE = 'RAWTEXT_LESS_THAN_SIGN_STATE', + RAWTEXT_END_TAG_OPEN_STATE = 'RAWTEXT_END_TAG_OPEN_STATE', + RAWTEXT_END_TAG_NAME_STATE = 'RAWTEXT_END_TAG_NAME_STATE', + SCRIPT_DATA_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_LESS_THAN_SIGN_STATE', + SCRIPT_DATA_END_TAG_OPEN_STATE = 'SCRIPT_DATA_END_TAG_OPEN_STATE', + SCRIPT_DATA_END_TAG_NAME_STATE = 'SCRIPT_DATA_END_TAG_NAME_STATE', + SCRIPT_DATA_ESCAPE_START_STATE = 'SCRIPT_DATA_ESCAPE_START_STATE', + SCRIPT_DATA_ESCAPE_START_DASH_STATE = 'SCRIPT_DATA_ESCAPE_START_DASH_STATE', + SCRIPT_DATA_ESCAPED_STATE = 'SCRIPT_DATA_ESCAPED_STATE', + SCRIPT_DATA_ESCAPED_DASH_STATE = 'SCRIPT_DATA_ESCAPED_DASH_STATE', + SCRIPT_DATA_ESCAPED_DASH_DASH_STATE = 'SCRIPT_DATA_ESCAPED_DASH_DASH_STATE', + SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE', + SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE = 'SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE', + SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE = 'SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE', + SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE', + SCRIPT_DATA_DOUBLE_ESCAPED_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_STATE', + SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE', + SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE', + SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE', + SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE = 'SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE', + BEFORE_ATTRIBUTE_NAME_STATE = 'BEFORE_ATTRIBUTE_NAME_STATE', + ATTRIBUTE_NAME_STATE = 'ATTRIBUTE_NAME_STATE', + AFTER_ATTRIBUTE_NAME_STATE = 'AFTER_ATTRIBUTE_NAME_STATE', + BEFORE_ATTRIBUTE_VALUE_STATE = 'BEFORE_ATTRIBUTE_VALUE_STATE', + ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE = 'ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE', + ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE = 'ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE', + ATTRIBUTE_VALUE_UNQUOTED_STATE = 'ATTRIBUTE_VALUE_UNQUOTED_STATE', + CHARACTER_REFERENCE_IN_ATTRIBUTE_VALUE_STATE = 'CHARACTER_REFERENCE_IN_ATTRIBUTE_VALUE_STATE', + AFTER_ATTRIBUTE_VALUE_QUOTED_STATE = 'AFTER_ATTRIBUTE_VALUE_QUOTED_STATE', + SELF_CLOSING_START_TAG_STATE = 'SELF_CLOSING_START_TAG_STATE', + BOGUS_COMMENT_STATE = 'BOGUS_COMMENT_STATE', + BOGUS_COMMENT_STATE_CONTINUATION = 'BOGUS_COMMENT_STATE_CONTINUATION', + MARKUP_DECLARATION_OPEN_STATE = 'MARKUP_DECLARATION_OPEN_STATE', + COMMENT_START_STATE = 'COMMENT_START_STATE', + COMMENT_START_DASH_STATE = 'COMMENT_START_DASH_STATE', + COMMENT_STATE = 'COMMENT_STATE', + COMMENT_END_DASH_STATE = 'COMMENT_END_DASH_STATE', + COMMENT_END_STATE = 'COMMENT_END_STATE', + COMMENT_END_BANG_STATE = 'COMMENT_END_BANG_STATE', + DOCTYPE_STATE = 'DOCTYPE_STATE', + DOCTYPE_NAME_STATE = 'DOCTYPE_NAME_STATE', + AFTER_DOCTYPE_NAME_STATE = 'AFTER_DOCTYPE_NAME_STATE', + BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE = 'BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE', + DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE = 'DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE', + DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE = 'DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE', + BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE = 'BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE', + BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE = 'BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE', + DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE = 'DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE', + DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE = 'DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE', + AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE = 'AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE', + BOGUS_DOCTYPE_STATE = 'BOGUS_DOCTYPE_STATE', + CDATA_SECTION_STATE = 'CDATA_SECTION_STATE'; + +//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 isDigit(cp, isHex) { + return isAsciiDigit(cp) || isHex && (cp >= $.LATIN_CAPITAL_A && cp <= $.LATIN_CAPITAL_F || + cp >= $.LATIN_SMALL_A && cp <= $.LATIN_SMALL_F); +} + +function isReservedCodePoint(cp) { + return cp >= 0xD800 && cp <= 0xDFFF || cp > 0x10FFFF; +} + +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) { + var branchCount = neTree[++nodeIx], + lo = ++nodeIx, + hi = lo + branchCount - 1; + + while (lo <= hi) { + var mid = lo + hi >>> 1, + midCp = neTree[mid]; + + if (midCp < cp) + lo = mid + 1; + + else if (midCp > cp) + hi = mid - 1; + + else + return neTree[mid + branchCount]; + } + + return -1; +} + + +//Tokenizer +var Tokenizer = module.exports = function () { + this.preprocessor = new Preprocessor(); + + this.tokenQueue = []; + + this.allowCDATA = false; + + this.state = DATA_STATE; + this.returnState = ''; + + this.tempBuff = []; + this.additionalAllowedCp = void 0; + this.lastStartTagName = ''; + + this.consumedAfterSnapshot = -1; + this.active = false; + + this.currentCharacterToken = null; + this.currentToken = null; + this.currentAttr = null; +}; + +//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 (var i = token.attrs.length - 1; i >= 0; i--) { + if (token.attrs[i].name === attrName) + return token.attrs[i].value; + } + + return null; +}; + +//API +Tokenizer.prototype.getNextToken = function () { + while (!this.tokenQueue.length && this.active) { + this._hibernationSnapshot(); + + var cp = this._consume(); + + if (!this._ensureHibernation()) + this[this.state](cp); + } + + return this.tokenQueue.shift(); +}; + +Tokenizer.prototype.write = function (chunk, isLastChunk) { + this.active = true; + this.preprocessor.write(chunk, isLastChunk); +}; + +Tokenizer.prototype.insertHtmlAtCurrentPos = function (chunk) { + this.active = true; + this.preprocessor.insertHtmlAtCurrentPos(chunk); +}; + +//Hibernation +Tokenizer.prototype._hibernationSnapshot = function () { + this.consumedAfterSnapshot = 0; +}; + +Tokenizer.prototype._ensureHibernation = function () { + if (this.preprocessor.endOfChunkHit) { + for (; this.consumedAfterSnapshot > 0; this.consumedAfterSnapshot--) + this.preprocessor.retreat(); + + this.active = false; + this.tokenQueue.push({type: Tokenizer.HIBERNATION_TOKEN}); + + return true; + } + + return false; +}; + + +//Consumption +Tokenizer.prototype._consume = function () { + this.consumedAfterSnapshot++; + return this.preprocessor.advance(); +}; + +Tokenizer.prototype._unconsume = function () { + this.consumedAfterSnapshot--; + this.preprocessor.retreat(); +}; + +Tokenizer.prototype._unconsumeSeveral = function (count) { + while (count--) + this._unconsume(); +}; + +Tokenizer.prototype._reconsumeInState = function (state) { + this.state = state; + this._unconsume(); +}; + +Tokenizer.prototype._consumeSubsequentIfMatch = function (pattern, startCp, caseSensitive) { + var consumedCount = 0, + isMatch = true, + patternLength = pattern.length, + patternPos = 0, + cp = startCp, + 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) + this._unconsumeSeveral(consumedCount); + + return isMatch; +}; + +//Lookahead +Tokenizer.prototype._lookahead = function () { + var cp = this._consume(); + + this._unconsume(); + + return cp; +}; + +//Temp buffer +Tokenizer.prototype.isTempBufferEqualToScriptString = function () { + if (this.tempBuff.length !== $$.SCRIPT_STRING.length) + return false; + + for (var i = 0; i < this.tempBuff.length; i++) { + if (this.tempBuff[i] !== $$.SCRIPT_STRING[i]) + return false; + } + + return true; +}; + +//Token creation +Tokenizer.prototype._createStartTagToken = function () { + this.currentToken = { + type: Tokenizer.START_TAG_TOKEN, + tagName: '', + selfClosing: false, + attrs: [] + }; +}; + +Tokenizer.prototype._createEndTagToken = function () { + this.currentToken = { + type: Tokenizer.END_TAG_TOKEN, + tagName: '', + attrs: [] + }; +}; + +Tokenizer.prototype._createCommentToken = function () { + this.currentToken = { + type: Tokenizer.COMMENT_TOKEN, + data: '' + }; +}; + +Tokenizer.prototype._createDoctypeToken = function (initialName) { + this.currentToken = { + type: Tokenizer.DOCTYPE_TOKEN, + name: initialName, + forceQuirks: false, + publicId: null, + systemId: null + }; +}; + +Tokenizer.prototype._createCharacterToken = function (type, ch) { + this.currentCharacterToken = { + type: type, + chars: ch + }; +}; + +//Tag attributes +Tokenizer.prototype._createAttr = function (attrNameFirstCh) { + this.currentAttr = { + name: attrNameFirstCh, + value: '' + }; +}; + +Tokenizer.prototype._isDuplicateAttr = function () { + return Tokenizer.getTokenAttr(this.currentToken, this.currentAttr.name) !== null; +}; + +Tokenizer.prototype._leaveAttrName = function (toState) { + this.state = toState; + + if (!this._isDuplicateAttr()) + this.currentToken.attrs.push(this.currentAttr); +}; + +Tokenizer.prototype._leaveAttrValue = function (toState) { + this.state = toState; +}; + +//Appropriate end tag token +//(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#appropriate-end-tag-token) +Tokenizer.prototype._isAppropriateEndTagToken = function () { + return this.lastStartTagName === this.currentToken.tagName; +}; + +//Token emission +Tokenizer.prototype._emitCurrentToken = function () { + this._emitCurrentCharacterToken(); + + //NOTE: store emited start tag's tagName to determine is the following end tag token is appropriate. + if (this.currentToken.type === Tokenizer.START_TAG_TOKEN) + this.lastStartTagName = this.currentToken.tagName; + + this.tokenQueue.push(this.currentToken); + this.currentToken = null; +}; + +Tokenizer.prototype._emitCurrentCharacterToken = function () { + if (this.currentCharacterToken) { + this.tokenQueue.push(this.currentCharacterToken); + this.currentCharacterToken = null; + } +}; + +Tokenizer.prototype._emitEOFToken = function () { + this._emitCurrentCharacterToken(); + this.tokenQueue.push({type: Tokenizer.EOF_TOKEN}); +}; + +//Characters emission + +//OPTIMIZATION: specification uses only one type of character tokens (one token per character). +//This causes a huge memory overhead and a lot of unnecessary parser loops. parse5 uses 3 groups of characters. +//If we have a sequence of characters that belong to the same group, parser can process it +//as a single solid character token. +//So, there are 3 types of character tokens in parse5: +//1)NULL_CHARACTER_TOKEN - \u0000-character sequences (e.g. '\u0000\u0000\u0000') +//2)WHITESPACE_CHARACTER_TOKEN - any whitespace/new-line character sequences (e.g. '\n \r\t \f') +//3)CHARACTER_TOKEN - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^') +Tokenizer.prototype._appendCharToCurrentCharacterToken = function (type, ch) { + if (this.currentCharacterToken && this.currentCharacterToken.type !== type) + this._emitCurrentCharacterToken(); + + if (this.currentCharacterToken) + this.currentCharacterToken.chars += ch; + + else + this._createCharacterToken(type, ch); +}; + +Tokenizer.prototype._emitCodePoint = function (cp) { + var 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)); +}; + +Tokenizer.prototype._emitSeveralCodePoints = function (codePoints) { + for (var 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. +Tokenizer.prototype._emitChar = function (ch) { + this._appendCharToCurrentCharacterToken(Tokenizer.CHARACTER_TOKEN, ch); +}; + +//Character reference tokenization +Tokenizer.prototype._consumeNumericEntity = function (isHex) { + var digits = '', + nextCp = void 0; + + do { + digits += toChar(this._consume()); + nextCp = this._lookahead(); + } while (nextCp !== $.EOF && isDigit(nextCp, isHex)); + + if (this._lookahead() === $.SEMICOLON) + this._consume(); + + var referencedCp = parseInt(digits, isHex ? 16 : 10), + replacement = NUMERIC_ENTITY_REPLACEMENTS[referencedCp]; + + if (replacement) + return replacement; + + if (isReservedCodePoint(referencedCp)) + return $.REPLACEMENT_CHARACTER; + + return referencedCp; +}; + +// NOTE: for the details on this algorithm see +// https://github.com/inikulin/parse5/tree/master/scripts/generate_named_entity_data/README.md +Tokenizer.prototype._consumeNamedEntity = function (inAttr) { + var referencedCodePoints = null, + referenceSize = 0, + cp = null, + consumedCount = 0, + semicolonTerminated = false; + + for (var i = 0; i > -1;) { + var current = neTree[i], + inNode = current < MAX_BRANCH_MARKER_VALUE, + nodeWithData = inNode && current & HAS_DATA_FLAG; + + if (nodeWithData) { + referencedCodePoints = current & DATA_DUPLET_FLAG ? [neTree[++i], neTree[++i]] : [neTree[++i]]; + referenceSize = consumedCount; + + if (cp === $.SEMICOLON) { + semicolonTerminated = true; + break; + } + } + + cp = this._consume(); + consumedCount++; + + if (cp === $.EOF) + break; + + if (inNode) + i = current & HAS_BRANCHES_FLAG ? findNamedEntityTreeBranch(i, cp) : -1; + + else + i = cp === current ? ++i : -1; + } + + + if (referencedCodePoints) { + if (!semicolonTerminated) { + //NOTE: unconsume excess (e.g. 'it' in '¬it') + this._unconsumeSeveral(consumedCount - referenceSize); + + //NOTE: If the character reference is being consumed as part of an attribute and the next character + //is either a U+003D EQUALS SIGN character (=) or an alphanumeric ASCII character, then, for historical + //reasons, all the characters that were matched after the U+0026 AMPERSAND character (&) must be + //unconsumed, and nothing is returned. + //However, if this next character is in fact a U+003D EQUALS SIGN character (=), then this is a + //parse error, because some legacy user agents will misinterpret the markup in those cases. + //(see: http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#tokenizing-character-references) + if (inAttr) { + var nextCp = this._lookahead(); + + if (nextCp === $.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp)) { + this._unconsumeSeveral(referenceSize); + return null; + } + } + } + + return referencedCodePoints; + } + + this._unconsumeSeveral(consumedCount); + + return null; +}; + +Tokenizer.prototype._consumeCharacterReference = function (startCp, inAttr) { + if (isWhitespace(startCp) || startCp === $.GREATER_THAN_SIGN || + startCp === $.AMPERSAND || startCp === this.additionalAllowedCp || startCp === $.EOF) { + //NOTE: not a character reference. No characters are consumed, and nothing is returned. + this._unconsume(); + return null; + } + + if (startCp === $.NUMBER_SIGN) { + //NOTE: we have a numeric entity candidate, now we should determine if it's hex or decimal + var isHex = false, + nextCp = this._lookahead(); + + if (nextCp === $.LATIN_SMALL_X || nextCp === $.LATIN_CAPITAL_X) { + this._consume(); + isHex = true; + } + + nextCp = this._lookahead(); + + //NOTE: if we have at least one digit this is a numeric entity for sure, so we consume it + if (nextCp !== $.EOF && isDigit(nextCp, isHex)) + return [this._consumeNumericEntity(isHex)]; + + //NOTE: otherwise this is a bogus number entity and a parse error. Unconsume the number sign + //and the 'x'-character if appropriate. + this._unconsumeSeveral(isHex ? 2 : 1); + return null; + } + + this._unconsume(); + + return this._consumeNamedEntity(inAttr); +}; + +//State machine +var _ = Tokenizer.prototype; + +//12.2.4.1 Data state +//------------------------------------------------------------------ +_[DATA_STATE] = function dataState(cp) { + this.preprocessor.dropParsedChunk(); + + if (cp === $.AMPERSAND) + this.state = CHARACTER_REFERENCE_IN_DATA_STATE; + + else if (cp === $.LESS_THAN_SIGN) + this.state = TAG_OPEN_STATE; + + else if (cp === $.NULL) + this._emitCodePoint(cp); + + else if (cp === $.EOF) + this._emitEOFToken(); + + else + this._emitCodePoint(cp); +}; + + +//12.2.4.2 Character reference in data state +//------------------------------------------------------------------ +_[CHARACTER_REFERENCE_IN_DATA_STATE] = function characterReferenceInDataState(cp) { + this.additionalAllowedCp = void 0; + + var referencedCodePoints = this._consumeCharacterReference(cp, false); + + if (!this._ensureHibernation()) { + if (referencedCodePoints) + this._emitSeveralCodePoints(referencedCodePoints); + + else + this._emitChar('&'); + + this.state = DATA_STATE; + } +}; + + +//12.2.4.3 RCDATA state +//------------------------------------------------------------------ +_[RCDATA_STATE] = function rcdataState(cp) { + this.preprocessor.dropParsedChunk(); + + if (cp === $.AMPERSAND) + this.state = CHARACTER_REFERENCE_IN_RCDATA_STATE; + + else if (cp === $.LESS_THAN_SIGN) + this.state = RCDATA_LESS_THAN_SIGN_STATE; + + else if (cp === $.NULL) + this._emitChar(UNICODE.REPLACEMENT_CHARACTER); + + else if (cp === $.EOF) + this._emitEOFToken(); + + else + this._emitCodePoint(cp); +}; + + +//12.2.4.4 Character reference in RCDATA state +//------------------------------------------------------------------ +_[CHARACTER_REFERENCE_IN_RCDATA_STATE] = function characterReferenceInRcdataState(cp) { + this.additionalAllowedCp = void 0; + + var referencedCodePoints = this._consumeCharacterReference(cp, false); + + if (!this._ensureHibernation()) { + if (referencedCodePoints) + this._emitSeveralCodePoints(referencedCodePoints); + + else + this._emitChar('&'); + + this.state = RCDATA_STATE; + } +}; + + +//12.2.4.5 RAWTEXT state +//------------------------------------------------------------------ +_[RAWTEXT_STATE] = function rawtextState(cp) { + this.preprocessor.dropParsedChunk(); + + if (cp === $.LESS_THAN_SIGN) + this.state = RAWTEXT_LESS_THAN_SIGN_STATE; + + else if (cp === $.NULL) + this._emitChar(UNICODE.REPLACEMENT_CHARACTER); + + else if (cp === $.EOF) + this._emitEOFToken(); + + else + this._emitCodePoint(cp); +}; + + +//12.2.4.6 Script data state +//------------------------------------------------------------------ +_[SCRIPT_DATA_STATE] = function scriptDataState(cp) { + this.preprocessor.dropParsedChunk(); + + if (cp === $.LESS_THAN_SIGN) + this.state = SCRIPT_DATA_LESS_THAN_SIGN_STATE; + + else if (cp === $.NULL) + this._emitChar(UNICODE.REPLACEMENT_CHARACTER); + + else if (cp === $.EOF) + this._emitEOFToken(); + + else + this._emitCodePoint(cp); +}; + + +//12.2.4.7 PLAINTEXT state +//------------------------------------------------------------------ +_[PLAINTEXT_STATE] = function plaintextState(cp) { + this.preprocessor.dropParsedChunk(); + + if (cp === $.NULL) + this._emitChar(UNICODE.REPLACEMENT_CHARACTER); + + else if (cp === $.EOF) + this._emitEOFToken(); + + else + this._emitCodePoint(cp); +}; + + +//12.2.4.8 Tag open state +//------------------------------------------------------------------ +_[TAG_OPEN_STATE] = function tagOpenState(cp) { + if (cp === $.EXCLAMATION_MARK) + this.state = MARKUP_DECLARATION_OPEN_STATE; + + else if (cp === $.SOLIDUS) + this.state = END_TAG_OPEN_STATE; + + else if (isAsciiLetter(cp)) { + this._createStartTagToken(); + this._reconsumeInState(TAG_NAME_STATE); + } + + else if (cp === $.QUESTION_MARK) + this._reconsumeInState(BOGUS_COMMENT_STATE); + + else { + this._emitChar('<'); + this._reconsumeInState(DATA_STATE); + } +}; + + +//12.2.4.9 End tag open state +//------------------------------------------------------------------ +_[END_TAG_OPEN_STATE] = function endTagOpenState(cp) { + if (isAsciiLetter(cp)) { + this._createEndTagToken(); + this._reconsumeInState(TAG_NAME_STATE); + } + + else if (cp === $.GREATER_THAN_SIGN) + this.state = DATA_STATE; + + else if (cp === $.EOF) { + this._reconsumeInState(DATA_STATE); + this._emitChar('<'); + this._emitChar('/'); + } + + else + this._reconsumeInState(BOGUS_COMMENT_STATE); +}; + + +//12.2.4.10 Tag name state +//------------------------------------------------------------------ +_[TAG_NAME_STATE] = function tagNameState(cp) { + if (isWhitespace(cp)) + this.state = BEFORE_ATTRIBUTE_NAME_STATE; + + else if (cp === $.SOLIDUS) + this.state = SELF_CLOSING_START_TAG_STATE; + + 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.currentToken.tagName += UNICODE.REPLACEMENT_CHARACTER; + + else if (cp === $.EOF) + this._reconsumeInState(DATA_STATE); + + else + this.currentToken.tagName += toChar(cp); +}; + + +//12.2.4.11 RCDATA less-than sign state +//------------------------------------------------------------------ +_[RCDATA_LESS_THAN_SIGN_STATE] = function rcdataLessThanSignState(cp) { + if (cp === $.SOLIDUS) { + this.tempBuff = []; + this.state = RCDATA_END_TAG_OPEN_STATE; + } + + else { + this._emitChar('<'); + this._reconsumeInState(RCDATA_STATE); + } +}; + + +//12.2.4.12 RCDATA end tag open state +//------------------------------------------------------------------ +_[RCDATA_END_TAG_OPEN_STATE] = function rcdataEndTagOpenState(cp) { + if (isAsciiLetter(cp)) { + this._createEndTagToken(); + this._reconsumeInState(RCDATA_END_TAG_NAME_STATE); + } + + else { + this._emitChar('<'); + this._emitChar('/'); + this._reconsumeInState(RCDATA_STATE); + } +}; + + +//12.2.4.13 RCDATA end tag name state +//------------------------------------------------------------------ +_[RCDATA_END_TAG_NAME_STATE] = function rcdataEndTagNameState(cp) { + if (isAsciiUpper(cp)) { + this.currentToken.tagName += toAsciiLowerChar(cp); + this.tempBuff.push(cp); + } + + else if (isAsciiLower(cp)) { + this.currentToken.tagName += toChar(cp); + this.tempBuff.push(cp); + } + + else { + if (this._isAppropriateEndTagToken()) { + if (isWhitespace(cp)) { + this.state = BEFORE_ATTRIBUTE_NAME_STATE; + return; + } + + if (cp === $.SOLIDUS) { + this.state = SELF_CLOSING_START_TAG_STATE; + return; + } + + if (cp === $.GREATER_THAN_SIGN) { + this.state = DATA_STATE; + this._emitCurrentToken(); + return; + } + } + + this._emitChar('<'); + this._emitChar('/'); + this._emitSeveralCodePoints(this.tempBuff); + this._reconsumeInState(RCDATA_STATE); + } +}; + + +//12.2.4.14 RAWTEXT less-than sign state +//------------------------------------------------------------------ +_[RAWTEXT_LESS_THAN_SIGN_STATE] = function rawtextLessThanSignState(cp) { + if (cp === $.SOLIDUS) { + this.tempBuff = []; + this.state = RAWTEXT_END_TAG_OPEN_STATE; + } + + else { + this._emitChar('<'); + this._reconsumeInState(RAWTEXT_STATE); + } +}; + + +//12.2.4.15 RAWTEXT end tag open state +//------------------------------------------------------------------ +_[RAWTEXT_END_TAG_OPEN_STATE] = function rawtextEndTagOpenState(cp) { + if (isAsciiLetter(cp)) { + this._createEndTagToken(); + this._reconsumeInState(RAWTEXT_END_TAG_NAME_STATE); + } + + else { + this._emitChar('<'); + this._emitChar('/'); + this._reconsumeInState(RAWTEXT_STATE); + } +}; + + +//12.2.4.16 RAWTEXT end tag name state +//------------------------------------------------------------------ +_[RAWTEXT_END_TAG_NAME_STATE] = function rawtextEndTagNameState(cp) { + if (isAsciiUpper(cp)) { + this.currentToken.tagName += toAsciiLowerChar(cp); + this.tempBuff.push(cp); + } + + else if (isAsciiLower(cp)) { + this.currentToken.tagName += toChar(cp); + this.tempBuff.push(cp); + } + + else { + if (this._isAppropriateEndTagToken()) { + if (isWhitespace(cp)) { + this.state = BEFORE_ATTRIBUTE_NAME_STATE; + return; + } + + if (cp === $.SOLIDUS) { + this.state = SELF_CLOSING_START_TAG_STATE; + return; + } + + if (cp === $.GREATER_THAN_SIGN) { + this._emitCurrentToken(); + this.state = DATA_STATE; + return; + } + } + + this._emitChar('<'); + this._emitChar('/'); + this._emitSeveralCodePoints(this.tempBuff); + this._reconsumeInState(RAWTEXT_STATE); + } +}; + + +//12.2.4.17 Script data less-than sign state +//------------------------------------------------------------------ +_[SCRIPT_DATA_LESS_THAN_SIGN_STATE] = function scriptDataLessThanSignState(cp) { + if (cp === $.SOLIDUS) { + this.tempBuff = []; + this.state = SCRIPT_DATA_END_TAG_OPEN_STATE; + } + + else if (cp === $.EXCLAMATION_MARK) { + this.state = SCRIPT_DATA_ESCAPE_START_STATE; + this._emitChar('<'); + this._emitChar('!'); + } + + else { + this._emitChar('<'); + this._reconsumeInState(SCRIPT_DATA_STATE); + } +}; + + +//12.2.4.18 Script data end tag open state +//------------------------------------------------------------------ +_[SCRIPT_DATA_END_TAG_OPEN_STATE] = function scriptDataEndTagOpenState(cp) { + if (isAsciiLetter(cp)) { + this._createEndTagToken(); + this._reconsumeInState(SCRIPT_DATA_END_TAG_NAME_STATE); + } + + else { + this._emitChar('<'); + this._emitChar('/'); + this._reconsumeInState(SCRIPT_DATA_STATE); + } +}; + + +//12.2.4.19 Script data end tag name state +//------------------------------------------------------------------ +_[SCRIPT_DATA_END_TAG_NAME_STATE] = function scriptDataEndTagNameState(cp) { + if (isAsciiUpper(cp)) { + this.currentToken.tagName += toAsciiLowerChar(cp); + this.tempBuff.push(cp); + } + + else if (isAsciiLower(cp)) { + this.currentToken.tagName += toChar(cp); + this.tempBuff.push(cp); + } + + else { + if (this._isAppropriateEndTagToken()) { + if (isWhitespace(cp)) { + this.state = BEFORE_ATTRIBUTE_NAME_STATE; + return; + } + + else if (cp === $.SOLIDUS) { + this.state = SELF_CLOSING_START_TAG_STATE; + return; + } + + else if (cp === $.GREATER_THAN_SIGN) { + this._emitCurrentToken(); + this.state = DATA_STATE; + return; + } + } + + this._emitChar('<'); + this._emitChar('/'); + this._emitSeveralCodePoints(this.tempBuff); + this._reconsumeInState(SCRIPT_DATA_STATE); + } +}; + + +//12.2.4.20 Script data escape start state +//------------------------------------------------------------------ +_[SCRIPT_DATA_ESCAPE_START_STATE] = function scriptDataEscapeStartState(cp) { + if (cp === $.HYPHEN_MINUS) { + this.state = SCRIPT_DATA_ESCAPE_START_DASH_STATE; + this._emitChar('-'); + } + + else + this._reconsumeInState(SCRIPT_DATA_STATE); +}; + + +//12.2.4.21 Script data escape start dash state +//------------------------------------------------------------------ +_[SCRIPT_DATA_ESCAPE_START_DASH_STATE] = function scriptDataEscapeStartDashState(cp) { + if (cp === $.HYPHEN_MINUS) { + this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE; + this._emitChar('-'); + } + + else + this._reconsumeInState(SCRIPT_DATA_STATE); +}; + + +//12.2.4.22 Script data escaped state +//------------------------------------------------------------------ +_[SCRIPT_DATA_ESCAPED_STATE] = function scriptDataEscapedState(cp) { + if (cp === $.HYPHEN_MINUS) { + this.state = SCRIPT_DATA_ESCAPED_DASH_STATE; + this._emitChar('-'); + } + + else if (cp === $.LESS_THAN_SIGN) + this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE; + + else if (cp === $.NULL) + this._emitChar(UNICODE.REPLACEMENT_CHARACTER); + + else if (cp === $.EOF) + this._reconsumeInState(DATA_STATE); + + else + this._emitCodePoint(cp); +}; + + +//12.2.4.23 Script data escaped dash state +//------------------------------------------------------------------ +_[SCRIPT_DATA_ESCAPED_DASH_STATE] = function scriptDataEscapedDashState(cp) { + if (cp === $.HYPHEN_MINUS) { + this.state = SCRIPT_DATA_ESCAPED_DASH_DASH_STATE; + this._emitChar('-'); + } + + else if (cp === $.LESS_THAN_SIGN) + this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE; + + else if (cp === $.NULL) { + this.state = SCRIPT_DATA_ESCAPED_STATE; + this._emitChar(UNICODE.REPLACEMENT_CHARACTER); + } + + else if (cp === $.EOF) + this._reconsumeInState(DATA_STATE); + + else { + this.state = SCRIPT_DATA_ESCAPED_STATE; + this._emitCodePoint(cp); + } +}; + + +//12.2.4.24 Script data escaped dash dash state +//------------------------------------------------------------------ +_[SCRIPT_DATA_ESCAPED_DASH_DASH_STATE] = function scriptDataEscapedDashDashState(cp) { + if (cp === $.HYPHEN_MINUS) + this._emitChar('-'); + + else if (cp === $.LESS_THAN_SIGN) + this.state = SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE; + + else if (cp === $.GREATER_THAN_SIGN) { + this.state = SCRIPT_DATA_STATE; + this._emitChar('>'); + } + + else if (cp === $.NULL) { + this.state = SCRIPT_DATA_ESCAPED_STATE; + this._emitChar(UNICODE.REPLACEMENT_CHARACTER); + } + + else if (cp === $.EOF) + this._reconsumeInState(DATA_STATE); + + else { + this.state = SCRIPT_DATA_ESCAPED_STATE; + this._emitCodePoint(cp); + } +}; + + +//12.2.4.25 Script data escaped less-than sign state +//------------------------------------------------------------------ +_[SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN_STATE] = function scriptDataEscapedLessThanSignState(cp) { + if (cp === $.SOLIDUS) { + this.tempBuff = []; + this.state = SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE; + } + + else if (isAsciiLetter(cp)) { + this.tempBuff = []; + this._emitChar('<'); + this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE); + } + + else { + this._emitChar('<'); + this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE); + } +}; + + +//12.2.4.26 Script data escaped end tag open state +//------------------------------------------------------------------ +_[SCRIPT_DATA_ESCAPED_END_TAG_OPEN_STATE] = function scriptDataEscapedEndTagOpenState(cp) { + if (isAsciiLetter(cp)) { + this._createEndTagToken(); + this._reconsumeInState(SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE); + } + + else { + this._emitChar('<'); + this._emitChar('/'); + this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE); + } +}; + + +//12.2.4.27 Script data escaped end tag name state +//------------------------------------------------------------------ +_[SCRIPT_DATA_ESCAPED_END_TAG_NAME_STATE] = function scriptDataEscapedEndTagNameState(cp) { + if (isAsciiUpper(cp)) { + this.currentToken.tagName += toAsciiLowerChar(cp); + this.tempBuff.push(cp); + } + + else if (isAsciiLower(cp)) { + this.currentToken.tagName += toChar(cp); + this.tempBuff.push(cp); + } + + else { + if (this._isAppropriateEndTagToken()) { + if (isWhitespace(cp)) { + this.state = BEFORE_ATTRIBUTE_NAME_STATE; + return; + } + + if (cp === $.SOLIDUS) { + this.state = SELF_CLOSING_START_TAG_STATE; + return; + } + + if (cp === $.GREATER_THAN_SIGN) { + this._emitCurrentToken(); + this.state = DATA_STATE; + return; + } + } + + this._emitChar('<'); + this._emitChar('/'); + this._emitSeveralCodePoints(this.tempBuff); + this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE); + } +}; + + +//12.2.4.28 Script data double escape start state +//------------------------------------------------------------------ +_[SCRIPT_DATA_DOUBLE_ESCAPE_START_STATE] = function scriptDataDoubleEscapeStartState(cp) { + if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN) { + this.state = this.isTempBufferEqualToScriptString() ? SCRIPT_DATA_DOUBLE_ESCAPED_STATE : SCRIPT_DATA_ESCAPED_STATE; + this._emitCodePoint(cp); + } + + else if (isAsciiUpper(cp)) { + this.tempBuff.push(toAsciiLowerCodePoint(cp)); + this._emitCodePoint(cp); + } + + else if (isAsciiLower(cp)) { + this.tempBuff.push(cp); + this._emitCodePoint(cp); + } + + else + this._reconsumeInState(SCRIPT_DATA_ESCAPED_STATE); +}; + + +//12.2.4.29 Script data double escaped state +//------------------------------------------------------------------ +_[SCRIPT_DATA_DOUBLE_ESCAPED_STATE] = function scriptDataDoubleEscapedState(cp) { + if (cp === $.HYPHEN_MINUS) { + this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE; + this._emitChar('-'); + } + + else if (cp === $.LESS_THAN_SIGN) { + this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE; + this._emitChar('<'); + } + + else if (cp === $.NULL) + this._emitChar(UNICODE.REPLACEMENT_CHARACTER); + + else if (cp === $.EOF) + this._reconsumeInState(DATA_STATE); + + else + this._emitCodePoint(cp); +}; + + +//12.2.4.30 Script data double escaped dash state +//------------------------------------------------------------------ +_[SCRIPT_DATA_DOUBLE_ESCAPED_DASH_STATE] = function scriptDataDoubleEscapedDashState(cp) { + if (cp === $.HYPHEN_MINUS) { + this.state = SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE; + this._emitChar('-'); + } + + else if (cp === $.LESS_THAN_SIGN) { + this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE; + this._emitChar('<'); + } + + else if (cp === $.NULL) { + this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE; + this._emitChar(UNICODE.REPLACEMENT_CHARACTER); + } + + else if (cp === $.EOF) + this._reconsumeInState(DATA_STATE); + + else { + this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE; + this._emitCodePoint(cp); + } +}; + + +//12.2.4.31 Script data double escaped dash dash state +//------------------------------------------------------------------ +_[SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH_STATE] = function scriptDataDoubleEscapedDashDashState(cp) { + if (cp === $.HYPHEN_MINUS) + this._emitChar('-'); + + else if (cp === $.LESS_THAN_SIGN) { + this.state = SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE; + this._emitChar('<'); + } + + else if (cp === $.GREATER_THAN_SIGN) { + this.state = SCRIPT_DATA_STATE; + this._emitChar('>'); + } + + else if (cp === $.NULL) { + this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE; + this._emitChar(UNICODE.REPLACEMENT_CHARACTER); + } + + else if (cp === $.EOF) + this._reconsumeInState(DATA_STATE); + + else { + this.state = SCRIPT_DATA_DOUBLE_ESCAPED_STATE; + this._emitCodePoint(cp); + } +}; + + +//12.2.4.32 Script data double escaped less-than sign state +//------------------------------------------------------------------ +_[SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN_STATE] = function scriptDataDoubleEscapedLessThanSignState(cp) { + if (cp === $.SOLIDUS) { + this.tempBuff = []; + this.state = SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE; + this._emitChar('/'); + } + + else + this._reconsumeInState(SCRIPT_DATA_DOUBLE_ESCAPED_STATE); +}; + + +//12.2.4.33 Script data double escape end state +//------------------------------------------------------------------ +_[SCRIPT_DATA_DOUBLE_ESCAPE_END_STATE] = function scriptDataDoubleEscapeEndState(cp) { + if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN) { + this.state = this.isTempBufferEqualToScriptString() ? SCRIPT_DATA_ESCAPED_STATE : SCRIPT_DATA_DOUBLE_ESCAPED_STATE; + + 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); +}; + + +//12.2.4.34 Before attribute name state +//------------------------------------------------------------------ +_[BEFORE_ATTRIBUTE_NAME_STATE] = function beforeAttributeNameState(cp) { + if (isWhitespace(cp)) + return; + + if (cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN || cp === $.EOF) + this._reconsumeInState(AFTER_ATTRIBUTE_NAME_STATE); + + else if (cp === $.EQUALS_SIGN) { + this._createAttr('='); + this.state = ATTRIBUTE_NAME_STATE; + } + + else { + this._createAttr(''); + this._reconsumeInState(ATTRIBUTE_NAME_STATE); + } +}; + + +//12.2.4.35 Attribute name state +//------------------------------------------------------------------ +_[ATTRIBUTE_NAME_STATE] = function attributeNameState(cp) { + if (isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN || cp === $.EOF) { + this._leaveAttrName(AFTER_ATTRIBUTE_NAME_STATE); + this._unconsume(); + } + + else if (cp === $.EQUALS_SIGN) + this._leaveAttrName(BEFORE_ATTRIBUTE_VALUE_STATE); + + else if (isAsciiUpper(cp)) + this.currentAttr.name += toAsciiLowerChar(cp); + + else if (cp === $.QUOTATION_MARK || cp === $.APOSTROPHE || cp === $.LESS_THAN_SIGN) + this.currentAttr.name += toChar(cp); + + else if (cp === $.NULL) + this.currentAttr.name += UNICODE.REPLACEMENT_CHARACTER; + + else + this.currentAttr.name += toChar(cp); +}; + + +//12.2.4.36 After attribute name state +//------------------------------------------------------------------ +_[AFTER_ATTRIBUTE_NAME_STATE] = function afterAttributeNameState(cp) { + if (isWhitespace(cp)) + return; + + if (cp === $.SOLIDUS) + this.state = SELF_CLOSING_START_TAG_STATE; + + else if (cp === $.EQUALS_SIGN) + this.state = BEFORE_ATTRIBUTE_VALUE_STATE; + + else if (cp === $.GREATER_THAN_SIGN) { + this.state = DATA_STATE; + this._emitCurrentToken(); + } + + else if (cp === $.EOF) + this._reconsumeInState(DATA_STATE); + + else { + this._createAttr(''); + this._reconsumeInState(ATTRIBUTE_NAME_STATE); + } +}; + + +//12.2.4.37 Before attribute value state +//------------------------------------------------------------------ +_[BEFORE_ATTRIBUTE_VALUE_STATE] = function beforeAttributeValueState(cp) { + if (isWhitespace(cp)) + return; + + if (cp === $.QUOTATION_MARK) + this.state = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE; + + else if (cp === $.APOSTROPHE) + this.state = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE; + + else + this._reconsumeInState(ATTRIBUTE_VALUE_UNQUOTED_STATE); +}; + + +//12.2.4.38 Attribute value (double-quoted) state +//------------------------------------------------------------------ +_[ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE] = function attributeValueDoubleQuotedState(cp) { + if (cp === $.QUOTATION_MARK) + this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE; + + else if (cp === $.AMPERSAND) { + this.additionalAllowedCp = $.QUOTATION_MARK; + this.returnState = this.state; + this.state = CHARACTER_REFERENCE_IN_ATTRIBUTE_VALUE_STATE; + } + + else if (cp === $.NULL) + this.currentAttr.value += UNICODE.REPLACEMENT_CHARACTER; + + else if (cp === $.EOF) + this._reconsumeInState(DATA_STATE); + + else + this.currentAttr.value += toChar(cp); +}; + + +//12.2.4.39 Attribute value (single-quoted) state +//------------------------------------------------------------------ +_[ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE] = function attributeValueSingleQuotedState(cp) { + if (cp === $.APOSTROPHE) + this.state = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE; + + else if (cp === $.AMPERSAND) { + this.additionalAllowedCp = $.APOSTROPHE; + this.returnState = this.state; + this.state = CHARACTER_REFERENCE_IN_ATTRIBUTE_VALUE_STATE; + } + + else if (cp === $.NULL) + this.currentAttr.value += UNICODE.REPLACEMENT_CHARACTER; + + else if (cp === $.EOF) + this._reconsumeInState(DATA_STATE); + + else + this.currentAttr.value += toChar(cp); +}; + + +//12.2.4.40 Attribute value (unquoted) state +//------------------------------------------------------------------ +_[ATTRIBUTE_VALUE_UNQUOTED_STATE] = function attributeValueUnquotedState(cp) { + if (isWhitespace(cp)) + this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE); + + else if (cp === $.AMPERSAND) { + this.additionalAllowedCp = $.GREATER_THAN_SIGN; + this.returnState = this.state; + this.state = CHARACTER_REFERENCE_IN_ATTRIBUTE_VALUE_STATE; + } + + else if (cp === $.GREATER_THAN_SIGN) { + this._leaveAttrValue(DATA_STATE); + this._emitCurrentToken(); + } + + else if (cp === $.NULL) + this.currentAttr.value += UNICODE.REPLACEMENT_CHARACTER; + + else if (cp === $.QUOTATION_MARK || cp === $.APOSTROPHE || cp === $.LESS_THAN_SIGN || + cp === $.EQUALS_SIGN || cp === $.GRAVE_ACCENT) + this.currentAttr.value += toChar(cp); + + else if (cp === $.EOF) + this._reconsumeInState(DATA_STATE); + + else + this.currentAttr.value += toChar(cp); +}; + + +//12.2.4.41 Character reference in attribute value state +//------------------------------------------------------------------ +_[CHARACTER_REFERENCE_IN_ATTRIBUTE_VALUE_STATE] = function characterReferenceInAttributeValueState(cp) { + var referencedCodePoints = this._consumeCharacterReference(cp, true); + + if (!this._ensureHibernation()) { + if (referencedCodePoints) { + for (var i = 0; i < referencedCodePoints.length; i++) + this.currentAttr.value += toChar(referencedCodePoints[i]); + } + else + this.currentAttr.value += '&'; + + this.state = this.returnState; + } +}; + + +//12.2.4.42 After attribute value (quoted) state +//------------------------------------------------------------------ +_[AFTER_ATTRIBUTE_VALUE_QUOTED_STATE] = function afterAttributeValueQuotedState(cp) { + if (isWhitespace(cp)) + this._leaveAttrValue(BEFORE_ATTRIBUTE_NAME_STATE); + + else if (cp === $.SOLIDUS) + this._leaveAttrValue(SELF_CLOSING_START_TAG_STATE); + + else if (cp === $.GREATER_THAN_SIGN) { + this._leaveAttrValue(DATA_STATE); + this._emitCurrentToken(); + } + + else if (cp === $.EOF) + this._reconsumeInState(DATA_STATE); + + else + this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE); +}; + + +//12.2.4.43 Self-closing start tag state +//------------------------------------------------------------------ +_[SELF_CLOSING_START_TAG_STATE] = function selfClosingStartTagState(cp) { + if (cp === $.GREATER_THAN_SIGN) { + this.currentToken.selfClosing = true; + this.state = DATA_STATE; + this._emitCurrentToken(); + } + + else if (cp === $.EOF) + this._reconsumeInState(DATA_STATE); + + else + this._reconsumeInState(BEFORE_ATTRIBUTE_NAME_STATE); +}; + + +//12.2.4.44 Bogus comment state +//------------------------------------------------------------------ +_[BOGUS_COMMENT_STATE] = function bogusCommentState() { + this._createCommentToken(); + this._reconsumeInState(BOGUS_COMMENT_STATE_CONTINUATION); +}; + +//HACK: to support streaming and make BOGUS_COMMENT_STATE reentrant we've +//introduced BOGUS_COMMENT_STATE_CONTINUATION state which will not produce +//comment token on each call. +_[BOGUS_COMMENT_STATE_CONTINUATION] = function bogusCommentStateContinuation(cp) { + while (true) { + if (cp === $.GREATER_THAN_SIGN) { + this.state = DATA_STATE; + break; + } + + else if (cp === $.EOF) { + this._reconsumeInState(DATA_STATE); + break; + } + + else { + this.currentToken.data += cp === $.NULL ? UNICODE.REPLACEMENT_CHARACTER : toChar(cp); + + this._hibernationSnapshot(); + cp = this._consume(); + + if (this._ensureHibernation()) + return; + } + } + + this._emitCurrentToken(); +}; + +//12.2.4.45 Markup declaration open state +//------------------------------------------------------------------ +_[MARKUP_DECLARATION_OPEN_STATE] = function markupDeclarationOpenState(cp) { + var dashDashMatch = this._consumeSubsequentIfMatch($$.DASH_DASH_STRING, cp, true), + doctypeMatch = !dashDashMatch && this._consumeSubsequentIfMatch($$.DOCTYPE_STRING, cp, false), + cdataMatch = !dashDashMatch && !doctypeMatch && + this.allowCDATA && + this._consumeSubsequentIfMatch($$.CDATA_START_STRING, cp, true); + + if (!this._ensureHibernation()) { + if (dashDashMatch) { + this._createCommentToken(); + this.state = COMMENT_START_STATE; + } + + else if (doctypeMatch) + this.state = DOCTYPE_STATE; + + else if (cdataMatch) + this.state = CDATA_SECTION_STATE; + + else + this._reconsumeInState(BOGUS_COMMENT_STATE); + } +}; + + +//12.2.4.46 Comment start state +//------------------------------------------------------------------ +_[COMMENT_START_STATE] = function commentStartState(cp) { + if (cp === $.HYPHEN_MINUS) + this.state = COMMENT_START_DASH_STATE; + + else if (cp === $.NULL) { + this.currentToken.data += UNICODE.REPLACEMENT_CHARACTER; + this.state = COMMENT_STATE; + } + + else if (cp === $.GREATER_THAN_SIGN) { + this.state = DATA_STATE; + this._emitCurrentToken(); + } + + else if (cp === $.EOF) { + this._emitCurrentToken(); + this._reconsumeInState(DATA_STATE); + } + + else { + this.currentToken.data += toChar(cp); + this.state = COMMENT_STATE; + } +}; + + +//12.2.4.47 Comment start dash state +//------------------------------------------------------------------ +_[COMMENT_START_DASH_STATE] = function commentStartDashState(cp) { + if (cp === $.HYPHEN_MINUS) + this.state = COMMENT_END_STATE; + + else if (cp === $.NULL) { + this.currentToken.data += '-'; + this.currentToken.data += UNICODE.REPLACEMENT_CHARACTER; + this.state = COMMENT_STATE; + } + + else if (cp === $.GREATER_THAN_SIGN) { + this.state = DATA_STATE; + this._emitCurrentToken(); + } + + else if (cp === $.EOF) { + this._emitCurrentToken(); + this._reconsumeInState(DATA_STATE); + } + + else { + this.currentToken.data += '-'; + this.currentToken.data += toChar(cp); + this.state = COMMENT_STATE; + } +}; + + +//12.2.4.48 Comment state +//------------------------------------------------------------------ +_[COMMENT_STATE] = function commentState(cp) { + if (cp === $.HYPHEN_MINUS) + this.state = COMMENT_END_DASH_STATE; + + else if (cp === $.NULL) + this.currentToken.data += UNICODE.REPLACEMENT_CHARACTER; + + else if (cp === $.EOF) { + this._emitCurrentToken(); + this._reconsumeInState(DATA_STATE); + } + + else + this.currentToken.data += toChar(cp); +}; + + +//12.2.4.49 Comment end dash state +//------------------------------------------------------------------ +_[COMMENT_END_DASH_STATE] = function commentEndDashState(cp) { + if (cp === $.HYPHEN_MINUS) + this.state = COMMENT_END_STATE; + + else if (cp === $.NULL) { + this.currentToken.data += '-'; + this.currentToken.data += UNICODE.REPLACEMENT_CHARACTER; + this.state = COMMENT_STATE; + } + + else if (cp === $.EOF) { + this._emitCurrentToken(); + this._reconsumeInState(DATA_STATE); + } + + else { + this.currentToken.data += '-'; + this.currentToken.data += toChar(cp); + this.state = COMMENT_STATE; + } +}; + + +//12.2.4.50 Comment end state +//------------------------------------------------------------------ +_[COMMENT_END_STATE] = function commentEndState(cp) { + if (cp === $.GREATER_THAN_SIGN) { + this.state = DATA_STATE; + this._emitCurrentToken(); + } + + else if (cp === $.EXCLAMATION_MARK) + this.state = COMMENT_END_BANG_STATE; + + else if (cp === $.HYPHEN_MINUS) + this.currentToken.data += '-'; + + else if (cp === $.NULL) { + this.currentToken.data += '--'; + this.currentToken.data += UNICODE.REPLACEMENT_CHARACTER; + this.state = COMMENT_STATE; + } + + else if (cp === $.EOF) { + this._reconsumeInState(DATA_STATE); + this._emitCurrentToken(); + } + + else { + this.currentToken.data += '--'; + this.currentToken.data += toChar(cp); + this.state = COMMENT_STATE; + } +}; + + +//12.2.4.51 Comment end bang state +//------------------------------------------------------------------ +_[COMMENT_END_BANG_STATE] = function commentEndBangState(cp) { + if (cp === $.HYPHEN_MINUS) { + this.currentToken.data += '--!'; + this.state = COMMENT_END_DASH_STATE; + } + + else if (cp === $.GREATER_THAN_SIGN) { + this.state = DATA_STATE; + this._emitCurrentToken(); + } + + else if (cp === $.NULL) { + this.currentToken.data += '--!'; + this.currentToken.data += UNICODE.REPLACEMENT_CHARACTER; + this.state = COMMENT_STATE; + } + + else if (cp === $.EOF) { + this._emitCurrentToken(); + this._reconsumeInState(DATA_STATE); + } + + else { + this.currentToken.data += '--!'; + this.currentToken.data += toChar(cp); + this.state = COMMENT_STATE; + } +}; + + +//12.2.4.52 DOCTYPE state +//------------------------------------------------------------------ +_[DOCTYPE_STATE] = function doctypeState(cp) { + if (isWhitespace(cp)) + return; + + else if (cp === $.GREATER_THAN_SIGN) { + this._createDoctypeToken(null); + this.currentToken.forceQuirks = true; + this._emitCurrentToken(); + this.state = DATA_STATE; + } + + else if (cp === $.EOF) { + this._createDoctypeToken(null); + this.currentToken.forceQuirks = true; + this._emitCurrentToken(); + this._reconsumeInState(DATA_STATE); + } + else { + this._createDoctypeToken(''); + this._reconsumeInState(DOCTYPE_NAME_STATE); + } +}; + + +//12.2.4.54 DOCTYPE name state +//------------------------------------------------------------------ +_[DOCTYPE_NAME_STATE] = function doctypeNameState(cp) { + if (isWhitespace(cp) || cp === $.GREATER_THAN_SIGN || cp === $.EOF) + this._reconsumeInState(AFTER_DOCTYPE_NAME_STATE); + + else if (isAsciiUpper(cp)) + this.currentToken.name += toAsciiLowerChar(cp); + + else if (cp === $.NULL) + this.currentToken.name += UNICODE.REPLACEMENT_CHARACTER; + + else + this.currentToken.name += toChar(cp); +}; + + +//12.2.4.55 After DOCTYPE name state +//------------------------------------------------------------------ +_[AFTER_DOCTYPE_NAME_STATE] = function afterDoctypeNameState(cp) { + if (isWhitespace(cp)) + return; + + if (cp === $.GREATER_THAN_SIGN) { + this.state = DATA_STATE; + this._emitCurrentToken(); + } + + else { + var publicMatch = this._consumeSubsequentIfMatch($$.PUBLIC_STRING, cp, false), + systemMatch = !publicMatch && this._consumeSubsequentIfMatch($$.SYSTEM_STRING, cp, false); + + if (!this._ensureHibernation()) { + if (publicMatch) + this.state = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE; + + else if (systemMatch) + this.state = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE; + + else { + this.currentToken.forceQuirks = true; + this.state = BOGUS_DOCTYPE_STATE; + } + } + } +}; + + +//12.2.4.57 Before DOCTYPE public identifier state +//------------------------------------------------------------------ +_[BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE] = function beforeDoctypePublicIdentifierState(cp) { + if (isWhitespace(cp)) + return; + + if (cp === $.QUOTATION_MARK) { + this.currentToken.publicId = ''; + this.state = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE; + } + + else if (cp === $.APOSTROPHE) { + this.currentToken.publicId = ''; + this.state = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE; + } + + else { + this.currentToken.forceQuirks = true; + this._reconsumeInState(BOGUS_DOCTYPE_STATE); + } +}; + + +//12.2.4.58 DOCTYPE public identifier (double-quoted) state +//------------------------------------------------------------------ +_[DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE] = function doctypePublicIdentifierDoubleQuotedState(cp) { + if (cp === $.QUOTATION_MARK) + this.state = BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE; + + else if (cp === $.NULL) + this.currentToken.publicId += UNICODE.REPLACEMENT_CHARACTER; + + else if (cp === $.GREATER_THAN_SIGN) { + this.currentToken.forceQuirks = true; + this._emitCurrentToken(); + this.state = DATA_STATE; + } + + else if (cp === $.EOF) { + this.currentToken.forceQuirks = true; + this._emitCurrentToken(); + this._reconsumeInState(DATA_STATE); + } + + else + this.currentToken.publicId += toChar(cp); +}; + + +//12.2.4.59 DOCTYPE public identifier (single-quoted) state +//------------------------------------------------------------------ +_[DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE] = function doctypePublicIdentifierSingleQuotedState(cp) { + if (cp === $.APOSTROPHE) + this.state = BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE; + + else if (cp === $.NULL) + this.currentToken.publicId += UNICODE.REPLACEMENT_CHARACTER; + + else if (cp === $.GREATER_THAN_SIGN) { + this.currentToken.forceQuirks = true; + this._emitCurrentToken(); + this.state = DATA_STATE; + } + + else if (cp === $.EOF) { + this.currentToken.forceQuirks = true; + this._emitCurrentToken(); + this._reconsumeInState(DATA_STATE); + } + + else + this.currentToken.publicId += toChar(cp); +}; + + +//12.2.4.61 Between DOCTYPE public and system identifiers state +//------------------------------------------------------------------ +_[BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS_STATE] = function betweenDoctypePublicAndSystemIdentifiersState(cp) { + if (isWhitespace(cp)) + return; + + if (cp === $.GREATER_THAN_SIGN) { + this._emitCurrentToken(); + this.state = DATA_STATE; + } + + else if (cp === $.QUOTATION_MARK) { + this.currentToken.systemId = ''; + this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE; + } + + + else if (cp === $.APOSTROPHE) { + this.currentToken.systemId = ''; + this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE; + } + + else { + this.currentToken.forceQuirks = true; + this._reconsumeInState(BOGUS_DOCTYPE_STATE); + } +}; + + +//12.2.4.63 Before DOCTYPE system identifier state +//------------------------------------------------------------------ +_[BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE] = function beforeDoctypeSystemIdentifierState(cp) { + if (isWhitespace(cp)) + return; + + if (cp === $.QUOTATION_MARK) { + this.currentToken.systemId = ''; + this.state = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE; + } + + else if (cp === $.APOSTROPHE) { + this.currentToken.systemId = ''; + this.state = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE; + } + + else { + this.currentToken.forceQuirks = true; + this._reconsumeInState(BOGUS_DOCTYPE_STATE); + } +}; + + +//12.2.4.64 DOCTYPE system identifier (double-quoted) state +//------------------------------------------------------------------ +_[DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE] = function doctypeSystemIdentifierDoubleQuotedState(cp) { + if (cp === $.QUOTATION_MARK) + this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE; + + else if (cp === $.GREATER_THAN_SIGN) { + this.currentToken.forceQuirks = true; + this._emitCurrentToken(); + this.state = DATA_STATE; + } + + else if (cp === $.NULL) + this.currentToken.systemId += UNICODE.REPLACEMENT_CHARACTER; + + else if (cp === $.EOF) { + this.currentToken.forceQuirks = true; + this._emitCurrentToken(); + this._reconsumeInState(DATA_STATE); + } + + else + this.currentToken.systemId += toChar(cp); +}; + + +//12.2.4.65 DOCTYPE system identifier (single-quoted) state +//------------------------------------------------------------------ +_[DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE] = function doctypeSystemIdentifierSingleQuotedState(cp) { + if (cp === $.APOSTROPHE) + this.state = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE; + + else if (cp === $.GREATER_THAN_SIGN) { + this.currentToken.forceQuirks = true; + this._emitCurrentToken(); + this.state = DATA_STATE; + } + + else if (cp === $.NULL) + this.currentToken.systemId += UNICODE.REPLACEMENT_CHARACTER; + + else if (cp === $.EOF) { + this.currentToken.forceQuirks = true; + this._emitCurrentToken(); + this._reconsumeInState(DATA_STATE); + } + + else + this.currentToken.systemId += toChar(cp); +}; + + +//12.2.4.66 After DOCTYPE system identifier state +//------------------------------------------------------------------ +_[AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE] = function afterDoctypeSystemIdentifierState(cp) { + if (isWhitespace(cp)) + return; + + if (cp === $.GREATER_THAN_SIGN) { + this._emitCurrentToken(); + this.state = DATA_STATE; + } + + else if (cp === $.EOF) { + this.currentToken.forceQuirks = true; + this._emitCurrentToken(); + this._reconsumeInState(DATA_STATE); + } + + else + this.state = BOGUS_DOCTYPE_STATE; +}; + + +//12.2.4.67 Bogus DOCTYPE state +//------------------------------------------------------------------ +_[BOGUS_DOCTYPE_STATE] = function bogusDoctypeState(cp) { + if (cp === $.GREATER_THAN_SIGN) { + this._emitCurrentToken(); + this.state = DATA_STATE; + } + + else if (cp === $.EOF) { + this._emitCurrentToken(); + this._reconsumeInState(DATA_STATE); + } +}; + + +//12.2.4.68 CDATA section state +//------------------------------------------------------------------ +_[CDATA_SECTION_STATE] = function cdataSectionState(cp) { + while (true) { + if (cp === $.EOF) { + this._reconsumeInState(DATA_STATE); + break; + } + + else { + var cdataEndMatch = this._consumeSubsequentIfMatch($$.CDATA_END_STRING, cp, true); + + if (this._ensureHibernation()) + break; + + if (cdataEndMatch) { + this.state = DATA_STATE; + break; + } + + this._emitCodePoint(cp); + + this._hibernationSnapshot(); + cp = this._consume(); + + if (this._ensureHibernation()) + break; + } + } +}; |