cloudstructs 0.9.19 → 0.9.21

package/node_modules/parse5/dist/cjs/tokenizer/index.js

@@ -7,36 +7,6 @@ const token_js_1 = require("../common/token.js");
 const decode_js_1 = require("entities/lib/decode.js");
 const error_codes_js_1 = require("../common/error-codes.js");
 const html_js_1 = require("../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) {
@@ -112,13 +82,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
 exports.TokenizerMode = {
@@ -148,27 +112,33 @@ function isAsciiLetter(cp) {
 function isAsciiAlphaNumeric(cp) {
     return isAsciiLetter(cp) || isAsciiDigit(cp);
 }
-function isAsciiUpperHexDigit(cp) {
-    return cp >= unicode_js_1.CODE_POINTS.LATIN_CAPITAL_A && cp <= unicode_js_1.CODE_POINTS.LATIN_CAPITAL_F;
-}
-function isAsciiLowerHexDigit(cp) {
-    return cp >= unicode_js_1.CODE_POINTS.LATIN_SMALL_A && cp <= unicode_js_1.CODE_POINTS.LATIN_SMALL_F;
-}
-function isAsciiHexDigit(cp) {
-    return isAsciiDigit(cp) || isAsciiUpperHexDigit(cp) || isAsciiLowerHexDigit(cp);
-}
 function toAsciiLower(cp) {
     return cp + 32;
 }
 function isWhitespace(cp) {
     return cp === unicode_js_1.CODE_POINTS.SPACE || cp === unicode_js_1.CODE_POINTS.LINE_FEED || cp === unicode_js_1.CODE_POINTS.TABULATION || cp === unicode_js_1.CODE_POINTS.FORM_FEED;
 }
-function isEntityInAttributeInvalidEnd(nextCp) {
-    return nextCp === unicode_js_1.CODE_POINTS.EQUALS_SIGN || isAsciiAlphaNumeric(nextCp);
-}
 function isScriptDataDoubleEscapeSequenceEnd(cp) {
     return isWhitespace(cp) || cp === unicode_js_1.CODE_POINTS.SOLIDUS || cp === unicode_js_1.CODE_POINTS.GREATER_THAN_SIGN;
 }
+function getErrorForNumericCharacterReference(code) {
+    if (code === unicode_js_1.CODE_POINTS.NULL) {
+        return error_codes_js_1.ERR.nullCharacterReference;
+    }
+    else if (code > 1114111) {
+        return error_codes_js_1.ERR.characterReferenceOutsideUnicodeRange;
+    }
+    else if ((0, unicode_js_1.isSurrogate)(code)) {
+        return error_codes_js_1.ERR.surrogateCharacterReference;
+    }
+    else if ((0, unicode_js_1.isUndefinedCodePoint)(code)) {
+        return error_codes_js_1.ERR.noncharacterCharacterReference;
+    }
+    else if ((0, unicode_js_1.isControlCodePoint)(code) || code === unicode_js_1.CODE_POINTS.CARRIAGE_RETURN) {
+        return error_codes_js_1.ERR.controlCharacterReference;
+    }
+    return null;
+}
 //Tokenizer
 class Tokenizer {
     constructor(options, handler) {
@@ -188,18 +158,38 @@ 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_js_1.Preprocessor(handler);
         this.currentLocation = this.getCurrentLocation(-1);
+        this.entityDecoder = new decode_js_1.EntityDecoder(decode_js_1.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(error_codes_js_1.ERR.missingSemicolonAfterCharacterReference, 1);
+                },
+                absenceOfDigitsInNumericCharacterReference: (consumed) => {
+                    this._err(error_codes_js_1.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) {
@@ -261,7 +251,8 @@ 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;
         }
@@ -272,14 +263,6 @@ 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++) {
@@ -451,7 +434,7 @@ 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.
@@ -461,15 +444,15 @@ 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);
     }
@@ -487,59 +470,11 @@ class Tokenizer {
         this._appendCharToCurrentCharacterToken(token_js_1.TokenType.CHARACTER, ch);
     }
     // Character reference helpers
-    _matchNamedCharacterReference(cp) {
-        let result = null;
-        let excess = 0;
-        let withoutSemicolon = false;
-        for (let i = 0, current = decode_js_1.htmlDecodeTree[0]; i >= 0; cp = this._consume()) {
-            i = (0, decode_js_1.determineBranch)(decode_js_1.htmlDecodeTree, current, i + 1, cp);
-            if (i < 0)
-                break;
-            excess += 1;
-            current = decode_js_1.htmlDecodeTree[i];
-            const masked = current & decode_js_1.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 !== unicode_js_1.CODE_POINTS.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 = [unicode_js_1.CODE_POINTS.AMPERSAND];
-                    // Skip over the value.
-                    i += valueLength;
-                }
-                else {
-                    // If this is a surrogate pair, consume the next two bytes.
-                    result =
-                        valueLength === 0
-                            ? [decode_js_1.htmlDecodeTree[i] & ~decode_js_1.BinTrieFlags.VALUE_LENGTH]
-                            : valueLength === 1
-                                ? [decode_js_1.htmlDecodeTree[++i]]
-                                : [decode_js_1.htmlDecodeTree[++i], decode_js_1.htmlDecodeTree[++i]];
-                    excess = 0;
-                    withoutSemicolon = cp !== unicode_js_1.CODE_POINTS.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(error_codes_js_1.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() ? decode_js_1.DecodingMode.Attribute : decode_js_1.DecodingMode.Legacy);
     }
     _isCharacterReferenceInAttribute() {
         return (this.returnState === State.ATTRIBUTE_VALUE_DOUBLE_QUOTED ||
@@ -842,37 +777,13 @@ 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');
             }
@@ -888,8 +799,7 @@ class Tokenizer {
                 break;
             }
             case unicode_js_1.CODE_POINTS.AMPERSAND: {
-                this.returnState = State.DATA;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case unicode_js_1.CODE_POINTS.NULL: {
@@ -911,8 +821,7 @@ class Tokenizer {
     _stateRcdata(cp) {
         switch (cp) {
             case unicode_js_1.CODE_POINTS.AMPERSAND: {
-                this.returnState = State.RCDATA;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case unicode_js_1.CODE_POINTS.LESS_THAN_SIGN: {
@@ -1681,8 +1590,7 @@ class Tokenizer {
                 break;
             }
             case unicode_js_1.CODE_POINTS.AMPERSAND: {
-                this.returnState = State.ATTRIBUTE_VALUE_DOUBLE_QUOTED;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case unicode_js_1.CODE_POINTS.NULL: {
@@ -1709,8 +1617,7 @@ class Tokenizer {
                 break;
             }
             case unicode_js_1.CODE_POINTS.AMPERSAND: {
-                this.returnState = State.ATTRIBUTE_VALUE_SINGLE_QUOTED;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case unicode_js_1.CODE_POINTS.NULL: {
@@ -1741,8 +1648,7 @@ class Tokenizer {
                 break;
             }
             case unicode_js_1.CODE_POINTS.AMPERSAND: {
-                this.returnState = State.ATTRIBUTE_VALUE_UNQUOTED;
-                this.state = State.CHARACTER_REFERENCE;
+                this._startCharacterReference();
                 break;
             }
             case unicode_js_1.CODE_POINTS.GREATER_THAN_SIGN: {
@@ -2759,37 +2665,35 @@ class Tokenizer {
     }
     // Character reference state
     //------------------------------------------------------------------
-    _stateCharacterReference(cp) {
-        if (cp === unicode_js_1.CODE_POINTS.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(unicode_js_1.CODE_POINTS.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(unicode_js_1.CODE_POINTS.AMPERSAND);
-            this.state = State.AMBIGUOUS_AMPERSAND;
+            // We successfully parsed an entity. Switch to the return state.
+            this.state = this.returnState;
         }
     }
     // Ambiguos ampersand state
@@ -2802,107 +2706,9 @@ class Tokenizer {
             if (cp === unicode_js_1.CODE_POINTS.SEMICOLON) {
                 this._err(error_codes_js_1.ERR.unknownNamedCharacterReference);
             }
-            this._reconsumeInState(this.returnState, cp);
-        }
-    }
-    // Numeric character reference state
-    //------------------------------------------------------------------
-    _stateNumericCharacterReference(cp) {
-        this.charRefCode = 0;
-        if (cp === unicode_js_1.CODE_POINTS.LATIN_SMALL_X || cp === unicode_js_1.CODE_POINTS.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(error_codes_js_1.ERR.absenceOfDigitsInNumericCharacterReference);
-            this._flushCodePointConsumedAsCharacterReference(unicode_js_1.CODE_POINTS.AMPERSAND);
-            this._flushCodePointConsumedAsCharacterReference(unicode_js_1.CODE_POINTS.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(error_codes_js_1.ERR.absenceOfDigitsInNumericCharacterReference);
-            this._flushCodePointConsumedAsCharacterReference(unicode_js_1.CODE_POINTS.AMPERSAND);
-            this._flushCodePointConsumedAsCharacterReference(unicode_js_1.CODE_POINTS.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 === unicode_js_1.CODE_POINTS.SEMICOLON) {
-            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;
-        }
-        else {
-            this._err(error_codes_js_1.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 === unicode_js_1.CODE_POINTS.SEMICOLON) {
-            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;
-        }
-        else {
-            this._err(error_codes_js_1.ERR.missingSemicolonAfterCharacterReference);
-            this.state = State.NUMERIC_CHARACTER_REFERENCE_END;
-            this._stateNumericCharacterReferenceEnd(cp);
-        }
-    }
-    // Numeric character reference end state
-    //------------------------------------------------------------------
-    _stateNumericCharacterReferenceEnd(cp) {
-        if (this.charRefCode === unicode_js_1.CODE_POINTS.NULL) {
-            this._err(error_codes_js_1.ERR.nullCharacterReference);
-            this.charRefCode = unicode_js_1.CODE_POINTS.REPLACEMENT_CHARACTER;
-        }
-        else if (this.charRefCode > 1114111) {
-            this._err(error_codes_js_1.ERR.characterReferenceOutsideUnicodeRange);
-            this.charRefCode = unicode_js_1.CODE_POINTS.REPLACEMENT_CHARACTER;
-        }
-        else if ((0, unicode_js_1.isSurrogate)(this.charRefCode)) {
-            this._err(error_codes_js_1.ERR.surrogateCharacterReference);
-            this.charRefCode = unicode_js_1.CODE_POINTS.REPLACEMENT_CHARACTER;
-        }
-        else if ((0, unicode_js_1.isUndefinedCodePoint)(this.charRefCode)) {
-            this._err(error_codes_js_1.ERR.noncharacterCharacterReference);
-        }
-        else if ((0, unicode_js_1.isControlCodePoint)(this.charRefCode) || this.charRefCode === unicode_js_1.CODE_POINTS.CARRIAGE_RETURN) {
-            this._err(error_codes_js_1.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);
-    }
 }
 exports.Tokenizer = Tokenizer;
-//# sourceMappingURL=index.js.map

package/node_modules/parse5/dist/cjs/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/node_modules/parse5/dist/cjs/tokenizer/preprocessor.js

@@ -34,22 +34,24 @@ 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() {
@@ -196,4 +198,3 @@ class Preprocessor {
     }
 }
 exports.Preprocessor = Preprocessor;
-//# sourceMappingURL=preprocessor.js.map

package/node_modules/parse5/dist/cjs/tree-adapters/default.d.ts

@@ -82,4 +82,3 @@ export type ChildNode = Element | Template | CommentNode | TextNode | DocumentTy
 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/node_modules/parse5/dist/cjs/tree-adapters/default.js

@@ -2,13 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultTreeAdapter = void 0;
 const html_js_1 = require("../common/html.js");
-function createTextNode(value) {
-    return {
-        nodeName: '#text',
-        value,
-        parentNode: null,
-    };
-}
 exports.defaultTreeAdapter = {
     //Node construction
     createDocument() {
@@ -41,6 +34,13 @@ exports.defaultTreeAdapter = {
             parentNode: null,
         };
     },
+    createTextNode(value) {
+        return {
+            nodeName: '#text',
+            value,
+            parentNode: null,
+        };
+    },
     //Tree mutation
     appendChild(parentNode, newNode) {
         parentNode.childNodes.push(newNode);
@@ -96,7 +96,7 @@ exports.defaultTreeAdapter = {
                 return;
             }
         }
-        exports.defaultTreeAdapter.appendChild(parentNode, createTextNode(text));
+        exports.defaultTreeAdapter.appendChild(parentNode, exports.defaultTreeAdapter.createTextNode(text));
     },
     insertTextBefore(parentNode, text, referenceNode) {
         const prevNode = parentNode.childNodes[parentNode.childNodes.indexOf(referenceNode) - 1];
@@ -104,7 +104,7 @@ exports.defaultTreeAdapter = {
             prevNode.value += text;
         }
         else {
-            exports.defaultTreeAdapter.insertBefore(parentNode, createTextNode(text), referenceNode);
+            exports.defaultTreeAdapter.insertBefore(parentNode, exports.defaultTreeAdapter.createTextNode(text), referenceNode);
         }
     },
     adoptAttributes(recipient, attrs) {
@@ -174,4 +174,3 @@ exports.defaultTreeAdapter = {
         node.sourceCodeLocation = Object.assign(Object.assign({}, node.sourceCodeLocation), endLocation);
     },
 };
-//# sourceMappingURL=default.js.map

package/node_modules/parse5/dist/cjs/tree-adapters/interface.d.ts

@@ -17,7 +17,7 @@ export interface TreeAdapterTypeMap<Node = unknown, ParentNode = unknown, ChildN
  * Note that `TreeAdapter` is not designed to be a general purpose AST manipulation library. You can build such library
  * on top of existing `TreeAdapter` or use one of the existing libraries from npm.
  *
- * @see The default implementation {@link parse5.treeAdapters.default}
+ * @see Have a look at the default tree adapter for reference.
  */
 export interface TreeAdapter<T extends TreeAdapterTypeMap = TreeAdapterTypeMap> {
     /**
@@ -40,6 +40,12 @@ export interface TreeAdapter<T extends TreeAdapterTypeMap = TreeAdapterTypeMap>
      * @param data - Comment text.
      */
     createCommentNode(data: string): T['commentNode'];
+    /**
+     * Creates a text node.
+     *
+     * @param value - Text.
+     */
+    createTextNode(value: string): T['textNode'];
     /**
      * Creates a document node.
      */
@@ -247,4 +253,3 @@ export interface TreeAdapter<T extends TreeAdapterTypeMap = TreeAdapterTypeMap>
      */
     onItemPop?: (item: T['element'], newTop: T['parentNode']) => void;
 }
-//# sourceMappingURL=interface.d.ts.map

package/node_modules/parse5/dist/cjs/tree-adapters/interface.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=interface.js.map

package/node_modules/parse5/dist/common/doctype.d.ts

@@ -2,4 +2,3 @@ import { DOCUMENT_MODE } from './html.js';
 import type { DoctypeToken } from './token.js';
 export declare function isConforming(token: DoctypeToken): boolean;
 export declare function getDocumentMode(token: DoctypeToken): DOCUMENT_MODE;
-//# sourceMappingURL=doctype.d.ts.map

package/node_modules/parse5/dist/common/doctype.js

@@ -112,4 +112,3 @@ export function getDocumentMode(token) {
     }
     return DOCUMENT_MODE.NO_QUIRKS;
 }
-//# sourceMappingURL=doctype.js.map