parse5 7.1.1 → 7.2.0

package/dist/tokenizer/index.js

@@ -1,39 +1,9 @@
 import { Preprocessor } from './preprocessor.js';
 import { CODE_POINTS as $, SEQUENCES as $$, REPLACEMENT_CHARACTER, isSurrogate, isUndefinedCodePoint, isControlCodePoint, } from '../common/unicode.js';
 import { TokenType, getTokenAttr, } from '../common/token.js';
-import { htmlDecodeTree, BinTrieFlags, determineBranch } from 'entities/lib/decode.js';
+import { htmlDecodeTree, EntityDecoder, DecodingMode } from 'entities/lib/decode.js';
 import { ERR } from '../common/error-codes.js';
 import { TAG_ID, getTagID } from '../common/html.js';
-//C1 Unicode control character reference replacements
-const C1_CONTROLS_REFERENCE_REPLACEMENTS = new Map([
-    [0x80, 8364],
-    [0x82, 8218],
-    [0x83, 402],
-    [0x84, 8222],
-    [0x85, 8230],
-    [0x86, 8224],
-    [0x87, 8225],
-    [0x88, 710],
-    [0x89, 8240],
-    [0x8a, 352],
-    [0x8b, 8249],
-    [0x8c, 338],
-    [0x8e, 381],
-    [0x91, 8216],
-    [0x92, 8217],
-    [0x93, 8220],
-    [0x94, 8221],
-    [0x95, 8226],
-    [0x96, 8211],
-    [0x97, 8212],
-    [0x98, 732],
-    [0x99, 8482],
-    [0x9a, 353],
-    [0x9b, 8250],
-    [0x9c, 339],
-    [0x9e, 382],
-    [0x9f, 376],
-]);
 //States
 var State;
 (function (State) {
@@ -109,13 +79,7 @@ var State;
     State[State["CDATA_SECTION_BRACKET"] = 69] = "CDATA_SECTION_BRACKET";
     State[State["CDATA_SECTION_END"] = 70] = "CDATA_SECTION_END";
     State[State["CHARACTER_REFERENCE"] = 71] = "CHARACTER_REFERENCE";
-    State[State["NAMED_CHARACTER_REFERENCE"] = 72] = "NAMED_CHARACTER_REFERENCE";
-    State[State["AMBIGUOUS_AMPERSAND"] = 73] = "AMBIGUOUS_AMPERSAND";
-    State[State["NUMERIC_CHARACTER_REFERENCE"] = 74] = "NUMERIC_CHARACTER_REFERENCE";
-    State[State["HEXADEMICAL_CHARACTER_REFERENCE_START"] = 75] = "HEXADEMICAL_CHARACTER_REFERENCE_START";
-    State[State["HEXADEMICAL_CHARACTER_REFERENCE"] = 76] = "HEXADEMICAL_CHARACTER_REFERENCE";
-    State[State["DECIMAL_CHARACTER_REFERENCE"] = 77] = "DECIMAL_CHARACTER_REFERENCE";
-    State[State["NUMERIC_CHARACTER_REFERENCE_END"] = 78] = "NUMERIC_CHARACTER_REFERENCE_END";
+    State[State["AMBIGUOUS_AMPERSAND"] = 72] = "AMBIGUOUS_AMPERSAND";
 })(State || (State = {}));
 //Tokenizer initial states for different modes
 export const TokenizerMode = {
@@ -145,27 +109,33 @@ function isAsciiLetter(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 toAsciiLower(cp) {
     return cp + 32;
 }
 function isWhitespace(cp) {
     return cp === $.SPACE || cp === $.LINE_FEED || cp === $.TABULATION || cp === $.FORM_FEED;
 }
-function isEntityInAttributeInvalidEnd(nextCp) {
-    return nextCp === $.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp);
-}
 function isScriptDataDoubleEscapeSequenceEnd(cp) {
     return isWhitespace(cp) || cp === $.SOLIDUS || cp === $.GREATER_THAN_SIGN;
 }
+function getErrorForNumericCharacterReference(code) {
+    if (code === $.NULL) {
+        return ERR.nullCharacterReference;
+    }
+    else if (code > 1114111) {
+        return ERR.characterReferenceOutsideUnicodeRange;
+    }
+    else if (isSurrogate(code)) {
+        return ERR.surrogateCharacterReference;
+    }
+    else if (isUndefinedCodePoint(code)) {
+        return ERR.noncharacterCharacterReference;
+    }
+    else if (isControlCodePoint(code) || code === $.CARRIAGE_RETURN) {
+        return ERR.controlCharacterReference;
+    }
+    return null;
+}
 //Tokenizer
 export class Tokenizer {
     constructor(options, handler) {
@@ -185,18 +155,38 @@ export class Tokenizer {
         this.active = false;
         this.state = State.DATA;
         this.returnState = State.DATA;
-        this.charRefCode = -1;
+        this.entityStartPos = 0;
         this.consumedAfterSnapshot = -1;
         this.currentCharacterToken = null;
         this.currentToken = null;
         this.currentAttr = { name: '', value: '' };
         this.preprocessor = new Preprocessor(handler);
         this.currentLocation = this.getCurrentLocation(-1);
+        this.entityDecoder = new EntityDecoder(htmlDecodeTree, (cp, consumed) => {
+            // Note: Set `pos` _before_ flushing, as flushing might drop
+            // the current chunk and invalidate `entityStartPos`.
+            this.preprocessor.pos = this.entityStartPos + consumed - 1;
+            this._flushCodePointConsumedAsCharacterReference(cp);
+        }, handler.onParseError
+            ? {
+                missingSemicolonAfterCharacterReference: () => {
+                    this._err(ERR.missingSemicolonAfterCharacterReference, 1);
+                },
+                absenceOfDigitsInNumericCharacterReference: (consumed) => {
+                    this._err(ERR.absenceOfDigitsInNumericCharacterReference, this.entityStartPos - this.preprocessor.pos + consumed);
+                },
+                validateNumericCharacterReference: (code) => {
+                    const error = getErrorForNumericCharacterReference(code);
+                    if (error)
+                        this._err(error, 1);
+                },
+            }
+            : undefined);
     }
     //Errors
-    _err(code) {
+    _err(code, cpOffset = 0) {
         var _a, _b;
-        (_b = (_a = this.handler).onParseError) === null || _b === void 0 ? void 0 : _b.call(_a, this.preprocessor.getError(code));
+        (_b = (_a = this.handler).onParseError) === null || _b === void 0 ? void 0 : _b.call(_a, this.preprocessor.getError(code, cpOffset));
     }
     // NOTE: `offset` may never run across line boundaries.
     getCurrentLocation(offset) {
@@ -258,7 +248,8 @@ export class Tokenizer {
     //Hibernation
     _ensureHibernation() {
         if (this.preprocessor.endOfChunkHit) {
-            this._unconsume(this.consumedAfterSnapshot);
+            this.preprocessor.retreat(this.consumedAfterSnapshot);
+            this.consumedAfterSnapshot = 0;
             this.active = false;
             return true;
         }
@@ -269,14 +260,6 @@ export class Tokenizer {
         this.consumedAfterSnapshot++;
         return this.preprocessor.advance();
     }
-    _unconsume(count) {
-        this.consumedAfterSnapshot -= count;
-        this.preprocessor.retreat(count);
-    }
-    _reconsumeInState(state, cp) {
-        this.state = state;
-        this._callState(cp);
-    }
     _advanceBy(count) {
         this.consumedAfterSnapshot += count;
         for (let i = 0; i < count; i++) {
@@ -448,7 +431,7 @@ export class Tokenizer {
         this.active = false;
     }
     //Characters emission
-    //OPTIMIZATION: specification uses only one type of character tokens (one token per character).
+    //OPTIMIZATION: The specification uses only one type of character token (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, the parser can process it
     //as a single solid character token.
@@ -458,15 +441,15 @@ export class Tokenizer {
     //3)TokenType.CHARACTER - any character sequence which don't belong to groups 1 and 2 (e.g. 'abcdef1234@@#$%^')
     _appendCharToCurrentCharacterToken(type, ch) {
         if (this.currentCharacterToken) {
-            if (this.currentCharacterToken.type !== type) {
+            if (this.currentCharacterToken.type === type) {
+                this.currentCharacterToken.chars += ch;
+                return;
+            }
+            else {
                 this.currentLocation = this.getCurrentLocation(0);
                 this._emitCurrentCharacterToken(this.currentLocation);
                 this.preprocessor.dropParsedChunk();
             }
-            else {
-                this.currentCharacterToken.chars += ch;
-                return;
-            }
         }
         this._createCharacterToken(type, ch);
     }
@@ -484,59 +467,11 @@ export class Tokenizer {
         this._appendCharToCurrentCharacterToken(TokenType.CHARACTER, ch);
     }
     // Character reference helpers
-    _matchNamedCharacterReference(cp) {
-        let result = null;
-        let excess = 0;
-        let withoutSemicolon = false;
-        for (let i = 0, current = htmlDecodeTree[0]; i >= 0; cp = this._consume()) {
-            i = determineBranch(htmlDecodeTree, current, i + 1, cp);
-            if (i < 0)
-                break;
-            excess += 1;
-            current = htmlDecodeTree[i];
-            const masked = current & BinTrieFlags.VALUE_LENGTH;
-            // If the branch is a value, store it and continue
-            if (masked) {
-                // The mask is the number of bytes of the value, including the current byte.
-                const valueLength = (masked >> 14) - 1;
-                // Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.
-                // See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state
-                if (cp !== $.SEMICOLON &&
-                    this._isCharacterReferenceInAttribute() &&
-                    isEntityInAttributeInvalidEnd(this.preprocessor.peek(1))) {
-                    //NOTE: we don't flush all consumed code points here, and instead switch back to the original state after
-                    //emitting an ampersand. This is fine, as alphanumeric characters won't be parsed differently in attributes.
-                    result = [$.AMPERSAND];
-                    // Skip over the value.
-                    i += valueLength;
-                }
-                else {
-                    // If this is a surrogate pair, consume the next two bytes.
-                    result =
-                        valueLength === 0
-                            ? [htmlDecodeTree[i] & ~BinTrieFlags.VALUE_LENGTH]
-                            : valueLength === 1
-                                ? [htmlDecodeTree[++i]]
-                                : [htmlDecodeTree[++i], htmlDecodeTree[++i]];
-                    excess = 0;
-                    withoutSemicolon = cp !== $.SEMICOLON;
-                }
-                if (valueLength === 0) {
-                    // If the value is zero-length, we're done.
-                    this._consume();
-                    break;
-                }
-            }
-        }
-        this._unconsume(excess);
-        if (withoutSemicolon && !this.preprocessor.endOfChunkHit) {
-            this._err(ERR.missingSemicolonAfterCharacterReference);
-        }
-        // We want to emit the error above on the code point after the entity.
-        // We always consume one code point too many in the loop, and we wait to
-        // unconsume it until after the error is emitted.
-        this._unconsume(1);
-        return result;
+    _startCharacterReference() {
+        this.returnState = this.state;
+        this.state = State.CHARACTER_REFERENCE;
+        this.entityStartPos = this.preprocessor.pos;
+        this.entityDecoder.startEntity(this._isCharacterReferenceInAttribute() ? DecodingMode.Attribute : DecodingMode.Legacy);
     }
     _isCharacterReferenceInAttribute() {
         return (this.returnState === State.ATTRIBUTE_VALUE_DOUBLE_QUOTED ||
@@ -839,37 +774,13 @@ export class Tokenizer {
                 break;
             }
             case State.CHARACTER_REFERENCE: {
-                this._stateCharacterReference(cp);
-                break;
-            }
-            case State.NAMED_CHARACTER_REFERENCE: {
-                this._stateNamedCharacterReference(cp);
+                this._stateCharacterReference();
                 break;
             }
             case State.AMBIGUOUS_AMPERSAND: {
                 this._stateAmbiguousAmpersand(cp);
                 break;
             }
-            case State.NUMERIC_CHARACTER_REFERENCE: {
-                this._stateNumericCharacterReference(cp);
-                break;
-            }
-            case State.HEXADEMICAL_CHARACTER_REFERENCE_START: {
-                this._stateHexademicalCharacterReferenceStart(cp);
-                break;
-            }
-            case State.HEXADEMICAL_CHARACTER_REFERENCE: {
-                this._stateHexademicalCharacterReference(cp);
-                break;
-            }
-            case State.DECIMAL_CHARACTER_REFERENCE: {
-                this._stateDecimalCharacterReference(cp);
-                break;
-            }
-            case State.NUMERIC_CHARACTER_REFERENCE_END: {
-                this._stateNumericCharacterReferenceEnd(cp);
-                break;
-            }
             default: {
                 throw new Error('Unknown state');
             }
@@ -885,8 +796,7 @@ export class Tokenizer {
                 break;
             }
             case $.AMPERSAND: {
-                this.returnState = State.DATA;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case $.NULL: {
@@ -908,8 +818,7 @@ export class Tokenizer {
     _stateRcdata(cp) {
         switch (cp) {
             case $.AMPERSAND: {
-                this.returnState = State.RCDATA;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case $.LESS_THAN_SIGN: {
@@ -1678,8 +1587,7 @@ export class Tokenizer {
                 break;
             }
             case $.AMPERSAND: {
-                this.returnState = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case $.NULL: {
@@ -1706,8 +1614,7 @@ export class Tokenizer {
                 break;
             }
             case $.AMPERSAND: {
-                this.returnState = State.ATTRIBUTE_VALUE_SINGLE_QUOTED;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case $.NULL: {
@@ -1738,8 +1645,7 @@ export class Tokenizer {
                 break;
             }
             case $.AMPERSAND: {
-                this.returnState = State.ATTRIBUTE_VALUE_UNQUOTED;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case $.GREATER_THAN_SIGN: {
@@ -2235,7 +2141,7 @@ export class Tokenizer {
                 this._emitEOFToken();
                 break;
             }
-            default:
+            default: {
                 if (this._consumeSequenceIfMatch($$.PUBLIC, false)) {
                     this.state = State.AFTER_DOCTYPE_PUBLIC_KEYWORD;
                 }
@@ -2250,6 +2156,7 @@ export class Tokenizer {
                     this.state = State.BOGUS_DOCTYPE;
                     this._stateBogusDoctype(cp);
                 }
+            }
         }
     }
     // After DOCTYPE public keyword state
@@ -2755,37 +2662,35 @@ export class Tokenizer {
     }
     // Character reference state
     //------------------------------------------------------------------
-    _stateCharacterReference(cp) {
-        if (cp === $.NUMBER_SIGN) {
-            this.state = State.NUMERIC_CHARACTER_REFERENCE;
-        }
-        else if (isAsciiAlphaNumeric(cp)) {
-            this.state = State.NAMED_CHARACTER_REFERENCE;
-            this._stateNamedCharacterReference(cp);
+    _stateCharacterReference() {
+        let length = this.entityDecoder.write(this.preprocessor.html, this.preprocessor.pos);
+        if (length < 0) {
+            if (this.preprocessor.lastChunkWritten) {
+                length = this.entityDecoder.end();
+            }
+            else {
+                // Wait for the rest of the entity.
+                this.active = false;
+                // Mark the entire buffer as read.
+                this.preprocessor.pos = this.preprocessor.html.length - 1;
+                this.consumedAfterSnapshot = 0;
+                this.preprocessor.endOfChunkHit = true;
+                return;
+            }
         }
-        else {
+        if (length === 0) {
+            // This was not a valid entity. Go back to the beginning, and
+            // figure out what to do.
+            this.preprocessor.pos = this.entityStartPos;
             this._flushCodePointConsumedAsCharacterReference($.AMPERSAND);
-            this._reconsumeInState(this.returnState, cp);
-        }
-    }
-    // Named character reference state
-    //------------------------------------------------------------------
-    _stateNamedCharacterReference(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()) {
-            // Stay in the state, try again.
-        }
-        else if (matchResult) {
-            for (let i = 0; i < matchResult.length; i++) {
-                this._flushCodePointConsumedAsCharacterReference(matchResult[i]);
-            }
-            this.state = this.returnState;
+            this.state =
+                !this._isCharacterReferenceInAttribute() && isAsciiAlphaNumeric(this.preprocessor.peek(1))
+                    ? State.AMBIGUOUS_AMPERSAND
+                    : this.returnState;
         }
         else {
-            this._flushCodePointConsumedAsCharacterReference($.AMPERSAND);
-            this.state = State.AMBIGUOUS_AMPERSAND;
+            // We successfully parsed an entity. Switch to the return state.
+            this.state = this.returnState;
         }
     }
     // Ambiguos ampersand state
@@ -2798,106 +2703,8 @@ export class Tokenizer {
             if (cp === $.SEMICOLON) {
                 this._err(ERR.unknownNamedCharacterReference);
             }
-            this._reconsumeInState(this.returnState, cp);
-        }
-    }
-    // Numeric character reference state
-    //------------------------------------------------------------------
-    _stateNumericCharacterReference(cp) {
-        this.charRefCode = 0;
-        if (cp === $.LATIN_SMALL_X || cp === $.LATIN_CAPITAL_X) {
-            this.state = State.HEXADEMICAL_CHARACTER_REFERENCE_START;
-        }
-        // Inlined decimal character reference start state
-        else if (isAsciiDigit(cp)) {
-            this.state = State.DECIMAL_CHARACTER_REFERENCE;
-            this._stateDecimalCharacterReference(cp);
-        }
-        else {
-            this._err(ERR.absenceOfDigitsInNumericCharacterReference);
-            this._flushCodePointConsumedAsCharacterReference($.AMPERSAND);
-            this._flushCodePointConsumedAsCharacterReference($.NUMBER_SIGN);
-            this._reconsumeInState(this.returnState, cp);
-        }
-    }
-    // Hexademical character reference start state
-    //------------------------------------------------------------------
-    _stateHexademicalCharacterReferenceStart(cp) {
-        if (isAsciiHexDigit(cp)) {
-            this.state = State.HEXADEMICAL_CHARACTER_REFERENCE;
-            this._stateHexademicalCharacterReference(cp);
-        }
-        else {
-            this._err(ERR.absenceOfDigitsInNumericCharacterReference);
-            this._flushCodePointConsumedAsCharacterReference($.AMPERSAND);
-            this._flushCodePointConsumedAsCharacterReference($.NUMBER_SIGN);
-            this._unconsume(2);
             this.state = this.returnState;
+            this._callState(cp);
         }
     }
-    // Hexademical character reference state
-    //------------------------------------------------------------------
-    _stateHexademicalCharacterReference(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 = State.NUMERIC_CHARACTER_REFERENCE_END;
-        }
-        else {
-            this._err(ERR.missingSemicolonAfterCharacterReference);
-            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;
-            this._stateNumericCharacterReferenceEnd(cp);
-        }
-    }
-    // Decimal character reference state
-    //------------------------------------------------------------------
-    _stateDecimalCharacterReference(cp) {
-        if (isAsciiDigit(cp)) {
-            this.charRefCode = this.charRefCode * 10 + cp - 0x30;
-        }
-        else if (cp === $.SEMICOLON) {
-            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;
-        }
-        else {
-            this._err(ERR.missingSemicolonAfterCharacterReference);
-            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;
-            this._stateNumericCharacterReferenceEnd(cp);
-        }
-    }
-    // Numeric character reference end state
-    //------------------------------------------------------------------
-    _stateNumericCharacterReferenceEnd(cp) {
-        if (this.charRefCode === $.NULL) {
-            this._err(ERR.nullCharacterReference);
-            this.charRefCode = $.REPLACEMENT_CHARACTER;
-        }
-        else if (this.charRefCode > 1114111) {
-            this._err(ERR.characterReferenceOutsideUnicodeRange);
-            this.charRefCode = $.REPLACEMENT_CHARACTER;
-        }
-        else if (isSurrogate(this.charRefCode)) {
-            this._err(ERR.surrogateCharacterReference);
-            this.charRefCode = $.REPLACEMENT_CHARACTER;
-        }
-        else if (isUndefinedCodePoint(this.charRefCode)) {
-            this._err(ERR.noncharacterCharacterReference);
-        }
-        else if (isControlCodePoint(this.charRefCode) || this.charRefCode === $.CARRIAGE_RETURN) {
-            this._err(ERR.controlCharacterReference);
-            const replacement = C1_CONTROLS_REFERENCE_REPLACEMENTS.get(this.charRefCode);
-            if (replacement !== undefined) {
-                this.charRefCode = replacement;
-            }
-        }
-        this._flushCodePointConsumedAsCharacterReference(this.charRefCode);
-        this._reconsumeInState(this.returnState, cp);
-    }
 }
-//# sourceMappingURL=index.js.map

package/dist/tokenizer/preprocessor.d.ts

@@ -2,11 +2,11 @@ import { ERR, type ParserError, type ParserErrorHandler } from '../common/error-
 export declare class Preprocessor {
     private handler;
     html: string;
-    private pos;
+    pos: number;
     private lastGapPos;
     private gapStack;
     private skipNextNewLine;
-    private lastChunkWritten;
+    lastChunkWritten: boolean;
     endOfChunkHit: boolean;
     bufferWaterline: number;
     private isEol;
@@ -19,7 +19,7 @@ export declare class Preprocessor {
     /** The column on the current line. If we just saw a gap (eg. a surrogate pair), return the index before. */
     get col(): number;
     get offset(): number;
-    getError(code: ERR): ParserError;
+    getError(code: ERR, cpOffset: number): ParserError;
     private lastErrOffset;
     private _err;
     private _addGap;
@@ -34,4 +34,3 @@ export declare class Preprocessor {
     private _checkForProblematicCharacters;
     retreat(count: number): void;
 }
-//# sourceMappingURL=preprocessor.d.ts.map

package/dist/tokenizer/preprocessor.js

@@ -31,22 +31,24 @@ export class Preprocessor {
     get offset() {
         return this.droppedBufferSize + this.pos;
     }
-    getError(code) {
+    getError(code, cpOffset) {
         const { line, col, offset } = this;
+        const startCol = col + cpOffset;
+        const startOffset = offset + cpOffset;
         return {
             code,
             startLine: line,
             endLine: line,
-            startCol: col,
-            endCol: col,
-            startOffset: offset,
-            endOffset: offset,
+            startCol,
+            endCol: startCol,
+            startOffset,
+            endOffset: startOffset,
         };
     }
     _err(code) {
         if (this.handler.onParseError && this.lastErrOffset !== this.offset) {
             this.lastErrOffset = this.offset;
-            this.handler.onParseError(this.getError(code));
+            this.handler.onParseError(this.getError(code, 0));
         }
     }
     _addGap() {
@@ -124,7 +126,8 @@ export class Preprocessor {
             this.endOfChunkHit = !this.lastChunkWritten;
             return $.EOF;
         }
-        return this.html.charCodeAt(pos);
+        const code = this.html.charCodeAt(pos);
+        return code === $.CARRIAGE_RETURN ? $.LINE_FEED : code;
     }
     advance() {
         this.pos++;
@@ -191,4 +194,3 @@ export class Preprocessor {
         this.isEol = false;
     }
 }
-//# sourceMappingURL=preprocessor.js.map

package/dist/tree-adapters/default.d.ts

@@ -77,9 +77,8 @@ export interface DocumentType {
     /** Comment source code location info. Available if location info is enabled. */
     sourceCodeLocation?: Location | null;
 }
-export declare type ParentNode = Document | DocumentFragment | Element | Template;
-export declare type ChildNode = Element | Template | CommentNode | TextNode | DocumentType;
-export declare type Node = ParentNode | ChildNode;
-export declare type DefaultTreeAdapterMap = TreeAdapterTypeMap<Node, ParentNode, ChildNode, Document, DocumentFragment, Element, CommentNode, TextNode, Template, DocumentType>;
+export type ParentNode = Document | DocumentFragment | Element | Template;
+export type ChildNode = Element | Template | CommentNode | TextNode | DocumentType;
+export type Node = ParentNode | ChildNode;
+export type DefaultTreeAdapterMap = TreeAdapterTypeMap<Node, ParentNode, ChildNode, Document, DocumentFragment, Element, CommentNode, TextNode, Template, DocumentType>;
 export declare const defaultTreeAdapter: TreeAdapter<DefaultTreeAdapterMap>;
-//# sourceMappingURL=default.d.ts.map

package/dist/tree-adapters/default.js

@@ -1,11 +1,4 @@
 import { DOCUMENT_MODE } from '../common/html.js';
-function createTextNode(value) {
-    return {
-        nodeName: '#text',
-        value,
-        parentNode: null,
-    };
-}
 export const defaultTreeAdapter = {
     //Node construction
     createDocument() {
@@ -38,6 +31,13 @@ export const defaultTreeAdapter = {
             parentNode: null,
         };
     },
+    createTextNode(value) {
+        return {
+            nodeName: '#text',
+            value,
+            parentNode: null,
+        };
+    },
     //Tree mutation
     appendChild(parentNode, newNode) {
         parentNode.childNodes.push(newNode);
@@ -93,7 +93,7 @@ export const defaultTreeAdapter = {
                 return;
             }
         }
-        defaultTreeAdapter.appendChild(parentNode, createTextNode(text));
+        defaultTreeAdapter.appendChild(parentNode, defaultTreeAdapter.createTextNode(text));
     },
     insertTextBefore(parentNode, text, referenceNode) {
         const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1];
@@ -101,7 +101,7 @@ export const defaultTreeAdapter = {
             prevNode.value += text;
         }
         else {
-            defaultTreeAdapter.insertBefore(parentNode, createTextNode(text), referenceNode);
+            defaultTreeAdapter.insertBefore(parentNode, defaultTreeAdapter.createTextNode(text), referenceNode);
         }
     },
     adoptAttributes(recipient, attrs) {
@@ -171,4 +171,3 @@ export const defaultTreeAdapter = {
         node.sourceCodeLocation = { ...node.sourceCodeLocation, ...endLocation };
     },
 };
-//# sourceMappingURL=default.js.map