@m2c2kit/build-helpers 0.3.3 → 0.3.5

package/dist/index.js

@@ -51,6 +51,7 @@ var xmlDecodeTree = new Uint16Array(
 var _a;
 const decodeMap = new Map([
     [0, 65533],
+    // C1 Unicode control character reference replacements
     [128, 8364],
     [130, 8218],
     [131, 402],
@@ -79,6 +80,9 @@ const decodeMap = new Map([
     [158, 382],
     [159, 376],
 ]);
+/**
+ * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.
+ */
 const fromCodePoint = 
 // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, node/no-unsupported-features/es-builtins
 (_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function (codePoint) {
@@ -91,6 +95,11 @@ const fromCodePoint =
     output += String.fromCharCode(codePoint);
     return output;
 };
+/**
+ * Replace the given code point with a replacement character if it is a
+ * surrogate or is outside the valid range. Otherwise return the code
+ * point unchanged.
+ */
 function replaceCodePoint(codePoint) {
     var _a;
     if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
@@ -103,20 +112,419 @@ var CharCodes$1;
 (function (CharCodes) {
     CharCodes[CharCodes["NUM"] = 35] = "NUM";
     CharCodes[CharCodes["SEMI"] = 59] = "SEMI";
+    CharCodes[CharCodes["EQUALS"] = 61] = "EQUALS";
     CharCodes[CharCodes["ZERO"] = 48] = "ZERO";
     CharCodes[CharCodes["NINE"] = 57] = "NINE";
     CharCodes[CharCodes["LOWER_A"] = 97] = "LOWER_A";
     CharCodes[CharCodes["LOWER_F"] = 102] = "LOWER_F";
     CharCodes[CharCodes["LOWER_X"] = 120] = "LOWER_X";
-    /** Bit that needs to be set to convert an upper case ASCII character to lower case */
-    CharCodes[CharCodes["To_LOWER_BIT"] = 32] = "To_LOWER_BIT";
+    CharCodes[CharCodes["LOWER_Z"] = 122] = "LOWER_Z";
+    CharCodes[CharCodes["UPPER_A"] = 65] = "UPPER_A";
+    CharCodes[CharCodes["UPPER_F"] = 70] = "UPPER_F";
+    CharCodes[CharCodes["UPPER_Z"] = 90] = "UPPER_Z";
 })(CharCodes$1 || (CharCodes$1 = {}));
+/** Bit that needs to be set to convert an upper case ASCII character to lower case */
+const TO_LOWER_BIT = 0b100000;
 var BinTrieFlags;
 (function (BinTrieFlags) {
     BinTrieFlags[BinTrieFlags["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
     BinTrieFlags[BinTrieFlags["BRANCH_LENGTH"] = 16256] = "BRANCH_LENGTH";
     BinTrieFlags[BinTrieFlags["JUMP_TABLE"] = 127] = "JUMP_TABLE";
 })(BinTrieFlags || (BinTrieFlags = {}));
+function isNumber(code) {
+    return code >= CharCodes$1.ZERO && code <= CharCodes$1.NINE;
+}
+function isHexadecimalCharacter(code) {
+    return ((code >= CharCodes$1.UPPER_A && code <= CharCodes$1.UPPER_F) ||
+        (code >= CharCodes$1.LOWER_A && code <= CharCodes$1.LOWER_F));
+}
+function isAsciiAlphaNumeric(code) {
+    return ((code >= CharCodes$1.UPPER_A && code <= CharCodes$1.UPPER_Z) ||
+        (code >= CharCodes$1.LOWER_A && code <= CharCodes$1.LOWER_Z) ||
+        isNumber(code));
+}
+/**
+ * Checks if the given character is a valid end character for an entity in an attribute.
+ *
+ * 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
+ */
+function isEntityInAttributeInvalidEnd(code) {
+    return code === CharCodes$1.EQUALS || isAsciiAlphaNumeric(code);
+}
+var EntityDecoderState;
+(function (EntityDecoderState) {
+    EntityDecoderState[EntityDecoderState["EntityStart"] = 0] = "EntityStart";
+    EntityDecoderState[EntityDecoderState["NumericStart"] = 1] = "NumericStart";
+    EntityDecoderState[EntityDecoderState["NumericDecimal"] = 2] = "NumericDecimal";
+    EntityDecoderState[EntityDecoderState["NumericHex"] = 3] = "NumericHex";
+    EntityDecoderState[EntityDecoderState["NamedEntity"] = 4] = "NamedEntity";
+})(EntityDecoderState || (EntityDecoderState = {}));
+var DecodingMode;
+(function (DecodingMode) {
+    /** Entities in text nodes that can end with any character. */
+    DecodingMode[DecodingMode["Legacy"] = 0] = "Legacy";
+    /** Only allow entities terminated with a semicolon. */
+    DecodingMode[DecodingMode["Strict"] = 1] = "Strict";
+    /** Entities in attributes have limitations on ending characters. */
+    DecodingMode[DecodingMode["Attribute"] = 2] = "Attribute";
+})(DecodingMode || (DecodingMode = {}));
+/**
+ * Token decoder with support of writing partial entities.
+ */
+class EntityDecoder {
+    constructor(
+    /** The tree used to decode entities. */
+    decodeTree, 
+    /**
+     * The function that is called when a codepoint is decoded.
+     *
+     * For multi-byte named entities, this will be called multiple times,
+     * with the second codepoint, and the same `consumed` value.
+     *
+     * @param codepoint The decoded codepoint.
+     * @param consumed The number of bytes consumed by the decoder.
+     */
+    emitCodePoint, 
+    /** An object that is used to produce errors. */
+    errors) {
+        this.decodeTree = decodeTree;
+        this.emitCodePoint = emitCodePoint;
+        this.errors = errors;
+        /** The current state of the decoder. */
+        this.state = EntityDecoderState.EntityStart;
+        /** Characters that were consumed while parsing an entity. */
+        this.consumed = 1;
+        /**
+         * The result of the entity.
+         *
+         * Either the result index of a numeric entity, or the codepoint of a
+         * numeric entity.
+         */
+        this.result = 0;
+        /** The current index in the decode tree. */
+        this.treeIndex = 0;
+        /** The number of characters that were consumed in excess. */
+        this.excess = 1;
+        /** The mode in which the decoder is operating. */
+        this.decodeMode = DecodingMode.Strict;
+    }
+    /** Resets the instance to make it reusable. */
+    startEntity(decodeMode) {
+        this.decodeMode = decodeMode;
+        this.state = EntityDecoderState.EntityStart;
+        this.result = 0;
+        this.treeIndex = 0;
+        this.excess = 1;
+        this.consumed = 1;
+    }
+    /**
+     * Write an entity to the decoder. This can be called multiple times with partial entities.
+     * If the entity is incomplete, the decoder will return -1.
+     *
+     * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the
+     * entity is incomplete, and resume when the next string is written.
+     *
+     * @param string The string containing the entity (or a continuation of the entity).
+     * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    write(str, offset) {
+        switch (this.state) {
+            case EntityDecoderState.EntityStart: {
+                if (str.charCodeAt(offset) === CharCodes$1.NUM) {
+                    this.state = EntityDecoderState.NumericStart;
+                    this.consumed += 1;
+                    return this.stateNumericStart(str, offset + 1);
+                }
+                this.state = EntityDecoderState.NamedEntity;
+                return this.stateNamedEntity(str, offset);
+            }
+            case EntityDecoderState.NumericStart: {
+                return this.stateNumericStart(str, offset);
+            }
+            case EntityDecoderState.NumericDecimal: {
+                return this.stateNumericDecimal(str, offset);
+            }
+            case EntityDecoderState.NumericHex: {
+                return this.stateNumericHex(str, offset);
+            }
+            case EntityDecoderState.NamedEntity: {
+                return this.stateNamedEntity(str, offset);
+            }
+        }
+    }
+    /**
+     * Switches between the numeric decimal and hexadecimal states.
+     *
+     * Equivalent to the `Numeric character reference state` in the HTML spec.
+     *
+     * @param str The string containing the entity (or a continuation of the entity).
+     * @param offset The current offset.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    stateNumericStart(str, offset) {
+        if (offset >= str.length) {
+            return -1;
+        }
+        if ((str.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes$1.LOWER_X) {
+            this.state = EntityDecoderState.NumericHex;
+            this.consumed += 1;
+            return this.stateNumericHex(str, offset + 1);
+        }
+        this.state = EntityDecoderState.NumericDecimal;
+        return this.stateNumericDecimal(str, offset);
+    }
+    addToNumericResult(str, start, end, base) {
+        if (start !== end) {
+            const digitCount = end - start;
+            this.result =
+                this.result * Math.pow(base, digitCount) +
+                    parseInt(str.substr(start, digitCount), base);
+            this.consumed += digitCount;
+        }
+    }
+    /**
+     * Parses a hexadecimal numeric entity.
+     *
+     * Equivalent to the `Hexademical character reference state` in the HTML spec.
+     *
+     * @param str The string containing the entity (or a continuation of the entity).
+     * @param offset The current offset.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    stateNumericHex(str, offset) {
+        const startIdx = offset;
+        while (offset < str.length) {
+            const char = str.charCodeAt(offset);
+            if (isNumber(char) || isHexadecimalCharacter(char)) {
+                offset += 1;
+            }
+            else {
+                this.addToNumericResult(str, startIdx, offset, 16);
+                return this.emitNumericEntity(char, 3);
+            }
+        }
+        this.addToNumericResult(str, startIdx, offset, 16);
+        return -1;
+    }
+    /**
+     * Parses a decimal numeric entity.
+     *
+     * Equivalent to the `Decimal character reference state` in the HTML spec.
+     *
+     * @param str The string containing the entity (or a continuation of the entity).
+     * @param offset The current offset.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    stateNumericDecimal(str, offset) {
+        const startIdx = offset;
+        while (offset < str.length) {
+            const char = str.charCodeAt(offset);
+            if (isNumber(char)) {
+                offset += 1;
+            }
+            else {
+                this.addToNumericResult(str, startIdx, offset, 10);
+                return this.emitNumericEntity(char, 2);
+            }
+        }
+        this.addToNumericResult(str, startIdx, offset, 10);
+        return -1;
+    }
+    /**
+     * Validate and emit a numeric entity.
+     *
+     * Implements the logic from the `Hexademical character reference start
+     * state` and `Numeric character reference end state` in the HTML spec.
+     *
+     * @param lastCp The last code point of the entity. Used to see if the
+     *               entity was terminated with a semicolon.
+     * @param expectedLength The minimum number of characters that should be
+     *                       consumed. Used to validate that at least one digit
+     *                       was consumed.
+     * @returns The number of characters that were consumed.
+     */
+    emitNumericEntity(lastCp, expectedLength) {
+        var _a;
+        // Ensure we consumed at least one digit.
+        if (this.consumed <= expectedLength) {
+            (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);
+            return 0;
+        }
+        // Figure out if this is a legit end of the entity
+        if (lastCp === CharCodes$1.SEMI) {
+            this.consumed += 1;
+        }
+        else if (this.decodeMode === DecodingMode.Strict) {
+            return 0;
+        }
+        this.emitCodePoint(replaceCodePoint(this.result), this.consumed);
+        if (this.errors) {
+            if (lastCp !== CharCodes$1.SEMI) {
+                this.errors.missingSemicolonAfterCharacterReference();
+            }
+            this.errors.validateNumericCharacterReference(this.result);
+        }
+        return this.consumed;
+    }
+    /**
+     * Parses a named entity.
+     *
+     * Equivalent to the `Named character reference state` in the HTML spec.
+     *
+     * @param str The string containing the entity (or a continuation of the entity).
+     * @param offset The current offset.
+     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
+     */
+    stateNamedEntity(str, offset) {
+        const { decodeTree } = this;
+        let current = decodeTree[this.treeIndex];
+        // The mask is the number of bytes of the value, including the current byte.
+        let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+        for (; offset < str.length; offset++, this.excess++) {
+            const char = str.charCodeAt(offset);
+            this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);
+            if (this.treeIndex < 0) {
+                return this.result === 0 ||
+                    // If we are parsing an attribute
+                    (this.decodeMode === DecodingMode.Attribute &&
+                        // We shouldn't have consumed any characters after the entity,
+                        (valueLength === 0 ||
+                            // And there should be no invalid characters.
+                            isEntityInAttributeInvalidEnd(char)))
+                    ? 0
+                    : this.emitNotTerminatedNamedEntity();
+            }
+            current = decodeTree[this.treeIndex];
+            valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
+            // If the branch is a value, store it and continue
+            if (valueLength !== 0) {
+                // If the entity is terminated by a semicolon, we are done.
+                if (char === CharCodes$1.SEMI) {
+                    return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);
+                }
+                // If we encounter a non-terminated (legacy) entity while parsing strictly, then ignore it.
+                if (this.decodeMode !== DecodingMode.Strict) {
+                    this.result = this.treeIndex;
+                    this.consumed += this.excess;
+                    this.excess = 0;
+                }
+            }
+        }
+        return -1;
+    }
+    /**
+     * Emit a named entity that was not terminated with a semicolon.
+     *
+     * @returns The number of characters consumed.
+     */
+    emitNotTerminatedNamedEntity() {
+        var _a;
+        const { result, decodeTree } = this;
+        const valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;
+        this.emitNamedEntityData(result, valueLength, this.consumed);
+        (_a = this.errors) === null || _a === void 0 ? void 0 : _a.missingSemicolonAfterCharacterReference();
+        return this.consumed;
+    }
+    /**
+     * Emit a named entity.
+     *
+     * @param result The index of the entity in the decode tree.
+     * @param valueLength The number of bytes in the entity.
+     * @param consumed The number of characters consumed.
+     *
+     * @returns The number of characters consumed.
+     */
+    emitNamedEntityData(result, valueLength, consumed) {
+        const { decodeTree } = this;
+        this.emitCodePoint(valueLength === 1
+            ? decodeTree[result] & ~BinTrieFlags.VALUE_LENGTH
+            : decodeTree[result + 1], consumed);
+        if (valueLength === 3) {
+            // For multi-byte values, we need to emit the second byte.
+            this.emitCodePoint(decodeTree[result + 2], consumed);
+        }
+        return consumed;
+    }
+    /**
+     * Signal to the parser that the end of the input was reached.
+     *
+     * Remaining data will be emitted and relevant errors will be produced.
+     *
+     * @returns The number of characters consumed.
+     */
+    end() {
+        var _a;
+        switch (this.state) {
+            case EntityDecoderState.NamedEntity: {
+                // Emit a named entity if we have one.
+                return this.result !== 0 &&
+                    (this.decodeMode !== DecodingMode.Attribute ||
+                        this.result === this.treeIndex)
+                    ? this.emitNotTerminatedNamedEntity()
+                    : 0;
+            }
+            // Otherwise, emit a numeric entity if we have one.
+            case EntityDecoderState.NumericDecimal: {
+                return this.emitNumericEntity(0, 2);
+            }
+            case EntityDecoderState.NumericHex: {
+                return this.emitNumericEntity(0, 3);
+            }
+            case EntityDecoderState.NumericStart: {
+                (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);
+                return 0;
+            }
+            case EntityDecoderState.EntityStart: {
+                // Return 0 if we have no entity.
+                return 0;
+            }
+        }
+    }
+}
+/**
+ * Creates a function that decodes entities in a string.
+ *
+ * @param decodeTree The decode tree.
+ * @returns A function that decodes entities in a string.
+ */
+function getDecoder(decodeTree) {
+    let ret = "";
+    const decoder = new EntityDecoder(decodeTree, (str) => (ret += fromCodePoint(str)));
+    return function decodeWithTrie(str, decodeMode) {
+        let lastIndex = 0;
+        let offset = 0;
+        while ((offset = str.indexOf("&", offset)) >= 0) {
+            ret += str.slice(lastIndex, offset);
+            decoder.startEntity(decodeMode);
+            const len = decoder.write(str, 
+            // Skip the "&"
+            offset + 1);
+            if (len < 0) {
+                lastIndex = offset + decoder.end();
+                break;
+            }
+            lastIndex = offset + len;
+            // If `len` is 0, skip the current `&` and continue.
+            offset = len === 0 ? lastIndex + 1 : lastIndex;
+        }
+        const result = ret + str.slice(lastIndex);
+        // Make sure we don't keep a reference to the final string.
+        ret = "";
+        return result;
+    };
+}
+/**
+ * Determines the branch of the current node that is taken given the current
+ * character. This function is used to traverse the trie.
+ *
+ * @param decodeTree The trie.
+ * @param current The current node.
+ * @param nodeIdx The index right after the current node and its value.
+ * @param char The current character.
+ * @returns The index of the next node, or -1 if no branch is taken.
+ */
 function determineBranch(decodeTree, current, nodeIdx, char) {
     const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
     const jumpOffset = current & BinTrieFlags.JUMP_TABLE;
@@ -150,6 +558,8 @@ function determineBranch(decodeTree, current, nodeIdx, char) {
     }
     return -1;
 }
+getDecoder(htmlDecodeTree);
+getDecoder(xmlDecodeTree);
 
 var CharCodes;
 (function (CharCodes) {
@@ -213,11 +623,7 @@ var State$1;
     State[State["BeforeSpecialS"] = 22] = "BeforeSpecialS";
     State[State["SpecialStartSequence"] = 23] = "SpecialStartSequence";
     State[State["InSpecialTag"] = 24] = "InSpecialTag";
-    State[State["BeforeEntity"] = 25] = "BeforeEntity";
-    State[State["BeforeNumericEntity"] = 26] = "BeforeNumericEntity";
-    State[State["InNamedEntity"] = 27] = "InNamedEntity";
-    State[State["InNumericEntity"] = 28] = "InNumericEntity";
-    State[State["InHexEntity"] = 29] = "InHexEntity";
+    State[State["InEntity"] = 25] = "InEntity";
 })(State$1 || (State$1 = {}));
 function isWhitespace$1(c) {
     return (c === CharCodes.Space ||
@@ -229,17 +635,10 @@ function isWhitespace$1(c) {
 function isEndOfTagSection(c) {
     return c === CharCodes.Slash || c === CharCodes.Gt || isWhitespace$1(c);
 }
-function isNumber(c) {
-    return c >= CharCodes.Zero && c <= CharCodes.Nine;
-}
 function isASCIIAlpha(c) {
     return ((c >= CharCodes.LowerA && c <= CharCodes.LowerZ) ||
         (c >= CharCodes.UpperA && c <= CharCodes.UpperZ));
 }
-function isHexDigit$1(c) {
-    return ((c >= CharCodes.UpperA && c <= CharCodes.UpperF) ||
-        (c >= CharCodes.LowerA && c <= CharCodes.LowerF));
-}
 var QuoteType;
 (function (QuoteType) {
     QuoteType[QuoteType["NoValue"] = 0] = "NoValue";
@@ -272,6 +671,8 @@ class Tokenizer {
         this.sectionStart = 0;
         /** The index within the buffer that we are currently looking at. */
         this.index = 0;
+        /** The start of the last entity. */
+        this.entityStart = 0;
         /** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */
         this.baseState = State$1.Text;
         /** For special parsing behavior inside of script and style tags. */
@@ -282,14 +683,9 @@ class Tokenizer {
         this.offset = 0;
         this.currentSequence = undefined;
         this.sequenceIndex = 0;
-        this.trieIndex = 0;
-        this.trieCurrent = 0;
-        /** For named entities, the index of the value. For numeric entities, the code point. */
-        this.entityResult = 0;
-        this.entityExcess = 0;
         this.xmlMode = xmlMode;
         this.decodeEntities = decodeEntities;
-        this.entityTrie = xmlMode ? xmlDecodeTree : htmlDecodeTree;
+        this.entityDecoder = new EntityDecoder(xmlMode ? xmlDecodeTree : htmlDecodeTree, (cp, consumed) => this.emitCodePoint(cp, consumed));
     }
     reset() {
         this.state = State$1.Text;
@@ -319,18 +715,6 @@ class Tokenizer {
             this.parse();
         }
     }
-    /**
-     * The current index within all of the written data.
-     */
-    getIndex() {
-        return this.index;
-    }
-    /**
-     * The start of the current section.
-     */
-    getSectionStart() {
-        return this.sectionStart;
-    }
     stateText(c) {
         if (c === CharCodes.Lt ||
             (!this.decodeEntities && this.fastForwardTo(CharCodes.Lt))) {
@@ -341,7 +725,7 @@ class Tokenizer {
             this.sectionStart = this.index;
         }
         else if (this.decodeEntities && c === CharCodes.Amp) {
-            this.state = State$1.BeforeEntity;
+            this.startEntity();
         }
     }
     stateSpecialStartSequence(c) {
@@ -388,7 +772,7 @@ class Tokenizer {
             if (this.currentSequence === Sequences.TitleEnd) {
                 // We have to parse entities in <title> tags.
                 if (this.decodeEntities && c === CharCodes.Amp) {
-                    this.state = State$1.BeforeEntity;
+                    this.startEntity();
                 }
             }
             else if (this.fastForwardTo(CharCodes.Lt)) {
@@ -547,7 +931,6 @@ class Tokenizer {
         // Skip everything until ">"
         if (c === CharCodes.Gt || this.fastForwardTo(CharCodes.Gt)) {
             this.state = State$1.Text;
-            this.baseState = State$1.Text;
             this.sectionStart = this.index + 1;
         }
     }
@@ -561,7 +944,6 @@ class Tokenizer {
             else {
                 this.state = State$1.Text;
             }
-            this.baseState = this.state;
             this.sectionStart = this.index + 1;
         }
         else if (c === CharCodes.Slash) {
@@ -576,7 +958,6 @@ class Tokenizer {
         if (c === CharCodes.Gt) {
             this.cbs.onselfclosingtag(this.index);
             this.state = State$1.Text;
-            this.baseState = State$1.Text;
             this.sectionStart = this.index + 1;
             this.isSpecial = false; // Reset special state, in case of self-closing special tags
         }
@@ -634,8 +1015,7 @@ class Tokenizer {
             this.state = State$1.BeforeAttributeName;
         }
         else if (this.decodeEntities && c === CharCodes.Amp) {
-            this.baseState = this.state;
-            this.state = State$1.BeforeEntity;
+            this.startEntity();
         }
     }
     stateInAttributeValueDoubleQuotes(c) {
@@ -653,8 +1033,7 @@ class Tokenizer {
             this.stateBeforeAttributeName(c);
         }
         else if (this.decodeEntities && c === CharCodes.Amp) {
-            this.baseState = this.state;
-            this.state = State$1.BeforeEntity;
+            this.startEntity();
         }
     }
     stateBeforeDeclaration(c) {
@@ -715,147 +1094,30 @@ class Tokenizer {
             this.stateInTagName(c); // Consume the token again
         }
     }
-    stateBeforeEntity(c) {
-        // Start excess with 1 to include the '&'
-        this.entityExcess = 1;
-        this.entityResult = 0;
-        if (c === CharCodes.Number) {
-            this.state = State$1.BeforeNumericEntity;
-        }
-        else if (c === CharCodes.Amp) ;
-        else {
-            this.trieIndex = 0;
-            this.trieCurrent = this.entityTrie[0];
-            this.state = State$1.InNamedEntity;
-            this.stateInNamedEntity(c);
-        }
-    }
-    stateInNamedEntity(c) {
-        this.entityExcess += 1;
-        this.trieIndex = determineBranch(this.entityTrie, this.trieCurrent, this.trieIndex + 1, c);
-        if (this.trieIndex < 0) {
-            this.emitNamedEntity();
-            this.index--;
-            return;
-        }
-        this.trieCurrent = this.entityTrie[this.trieIndex];
-        const masked = this.trieCurrent & 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;
-            // If we have a legacy entity while parsing strictly, just skip the number of bytes
-            if (!this.allowLegacyEntity() && c !== CharCodes.Semi) {
-                this.trieIndex += valueLength;
-            }
-            else {
-                // Add 1 as we have already incremented the excess
-                const entityStart = this.index - this.entityExcess + 1;
-                if (entityStart > this.sectionStart) {
-                    this.emitPartial(this.sectionStart, entityStart);
-                }
-                // If this is a surrogate pair, consume the next two bytes
-                this.entityResult = this.trieIndex;
-                this.trieIndex += valueLength;
-                this.entityExcess = 0;
-                this.sectionStart = this.index + 1;
-                if (valueLength === 0) {
-                    this.emitNamedEntity();
-                }
+    startEntity() {
+        this.baseState = this.state;
+        this.state = State$1.InEntity;
+        this.entityStart = this.index;
+        this.entityDecoder.startEntity(this.xmlMode
+            ? DecodingMode.Strict
+            : this.baseState === State$1.Text ||
+                this.baseState === State$1.InSpecialTag
+                ? DecodingMode.Legacy
+                : DecodingMode.Attribute);
+    }
+    stateInEntity() {
+        const length = this.entityDecoder.write(this.buffer, this.index - this.offset);
+        // If `length` is positive, we are done with the entity.
+        if (length >= 0) {
+            this.state = this.baseState;
+            if (length === 0) {
+                this.index = this.entityStart;
             }
         }
-    }
-    emitNamedEntity() {
-        this.state = this.baseState;
-        if (this.entityResult === 0) {
-            return;
-        }
-        const valueLength = (this.entityTrie[this.entityResult] & BinTrieFlags.VALUE_LENGTH) >>
-            14;
-        switch (valueLength) {
-            case 1: {
-                this.emitCodePoint(this.entityTrie[this.entityResult] &
-                    ~BinTrieFlags.VALUE_LENGTH);
-                break;
-            }
-            case 2: {
-                this.emitCodePoint(this.entityTrie[this.entityResult + 1]);
-                break;
-            }
-            case 3: {
-                this.emitCodePoint(this.entityTrie[this.entityResult + 1]);
-                this.emitCodePoint(this.entityTrie[this.entityResult + 2]);
-            }
-        }
-    }
-    stateBeforeNumericEntity(c) {
-        if ((c | 0x20) === CharCodes.LowerX) {
-            this.entityExcess++;
-            this.state = State$1.InHexEntity;
-        }
         else {
-            this.state = State$1.InNumericEntity;
-            this.stateInNumericEntity(c);
-        }
-    }
-    emitNumericEntity(strict) {
-        const entityStart = this.index - this.entityExcess - 1;
-        const numberStart = entityStart + 2 + Number(this.state === State$1.InHexEntity);
-        if (numberStart !== this.index) {
-            // Emit leading data if any
-            if (entityStart > this.sectionStart) {
-                this.emitPartial(this.sectionStart, entityStart);
-            }
-            this.sectionStart = this.index + Number(strict);
-            this.emitCodePoint(replaceCodePoint(this.entityResult));
+            // Mark buffer as consumed.
+            this.index = this.offset + this.buffer.length - 1;
         }
-        this.state = this.baseState;
-    }
-    stateInNumericEntity(c) {
-        if (c === CharCodes.Semi) {
-            this.emitNumericEntity(true);
-        }
-        else if (isNumber(c)) {
-            this.entityResult = this.entityResult * 10 + (c - CharCodes.Zero);
-            this.entityExcess++;
-        }
-        else {
-            if (this.allowLegacyEntity()) {
-                this.emitNumericEntity(false);
-            }
-            else {
-                this.state = this.baseState;
-            }
-            this.index--;
-        }
-    }
-    stateInHexEntity(c) {
-        if (c === CharCodes.Semi) {
-            this.emitNumericEntity(true);
-        }
-        else if (isNumber(c)) {
-            this.entityResult = this.entityResult * 16 + (c - CharCodes.Zero);
-            this.entityExcess++;
-        }
-        else if (isHexDigit$1(c)) {
-            this.entityResult =
-                this.entityResult * 16 + ((c | 0x20) - CharCodes.LowerA + 10);
-            this.entityExcess++;
-        }
-        else {
-            if (this.allowLegacyEntity()) {
-                this.emitNumericEntity(false);
-            }
-            else {
-                this.state = this.baseState;
-            }
-            this.index--;
-        }
-    }
-    allowLegacyEntity() {
-        return (!this.xmlMode &&
-            (this.baseState === State$1.Text ||
-                this.baseState === State$1.InSpecialTag));
     }
     /**
      * Remove data that has already been consumed from the buffer.
@@ -984,44 +1246,30 @@ class Tokenizer {
                     this.stateInProcessingInstruction(c);
                     break;
                 }
-                case State$1.InNamedEntity: {
-                    this.stateInNamedEntity(c);
-                    break;
-                }
-                case State$1.BeforeEntity: {
-                    this.stateBeforeEntity(c);
+                case State$1.InEntity: {
+                    this.stateInEntity();
                     break;
                 }
-                case State$1.InHexEntity: {
-                    this.stateInHexEntity(c);
-                    break;
-                }
-                case State$1.InNumericEntity: {
-                    this.stateInNumericEntity(c);
-                    break;
-                }
-                default: {
-                    // `this._state === State.BeforeNumericEntity`
-                    this.stateBeforeNumericEntity(c);
-                }
             }
             this.index++;
         }
         this.cleanup();
     }
     finish() {
-        if (this.state === State$1.InNamedEntity) {
-            this.emitNamedEntity();
-        }
-        // If there is remaining data, emit it in a reasonable way
-        if (this.sectionStart < this.index) {
-            this.handleTrailingData();
+        if (this.state === State$1.InEntity) {
+            this.entityDecoder.end();
+            this.state = this.baseState;
         }
+        this.handleTrailingData();
         this.cbs.onend();
     }
     /** Handle any trailing data. */
     handleTrailingData() {
         const endIndex = this.buffer.length + this.offset;
+        // If there is no remaining data, we are done.
+        if (this.sectionStart >= endIndex) {
+            return;
+        }
         if (this.state === State$1.InCommentLike) {
             if (this.currentSequence === Sequences.CdataEnd) {
                 this.cbs.oncdata(this.sectionStart, endIndex, 0);
@@ -1030,16 +1278,6 @@ class Tokenizer {
                 this.cbs.oncomment(this.sectionStart, endIndex, 0);
             }
         }
-        else if (this.state === State$1.InNumericEntity &&
-            this.allowLegacyEntity()) {
-            this.emitNumericEntity(false);
-            // All trailing data will have been consumed
-        }
-        else if (this.state === State$1.InHexEntity &&
-            this.allowLegacyEntity()) {
-            this.emitNumericEntity(false);
-            // All trailing data will have been consumed
-        }
         else if (this.state === State$1.InTagName ||
             this.state === State$1.BeforeAttributeName ||
             this.state === State$1.BeforeAttributeValue ||
@@ -1053,22 +1291,23 @@ class Tokenizer {
             this.cbs.ontext(this.sectionStart, endIndex);
         }
     }
-    emitPartial(start, endIndex) {
-        if (this.baseState !== State$1.Text &&
-            this.baseState !== State$1.InSpecialTag) {
-            this.cbs.onattribdata(start, endIndex);
-        }
-        else {
-            this.cbs.ontext(start, endIndex);
-        }
-    }
-    emitCodePoint(cp) {
+    emitCodePoint(cp, consumed) {
         if (this.baseState !== State$1.Text &&
             this.baseState !== State$1.InSpecialTag) {
+            if (this.sectionStart < this.entityStart) {
+                this.cbs.onattribdata(this.sectionStart, this.entityStart);
+            }
+            this.sectionStart = this.entityStart + consumed;
+            this.index = this.sectionStart - 1;
             this.cbs.onattribentity(cp);
         }
         else {
-            this.cbs.ontextentity(cp);
+            if (this.sectionStart < this.entityStart) {
+                this.cbs.ontext(this.sectionStart, this.entityStart);
+            }
+            this.sectionStart = this.entityStart + consumed;
+            this.index = this.sectionStart - 1;
+            this.cbs.ontextentity(cp, this.sectionStart);
         }
     }
 }
@@ -1187,7 +1426,6 @@ let Parser$1 = class Parser {
         this.attribvalue = "";
         this.attribs = null;
         this.stack = [];
-        this.foreignContext = [];
         this.buffers = [];
         this.bufferOffset = 0;
         /** The index of the last written buffer. Used when resuming after a `pause()`. */
@@ -1195,10 +1433,12 @@ let Parser$1 = class Parser {
         /** Indicates whether the parser has finished running / `.end` has been called. */
         this.ended = false;
         this.cbs = cbs !== null && cbs !== void 0 ? cbs : {};
-        this.lowerCaseTagNames = (_a = options.lowerCaseTags) !== null && _a !== void 0 ? _a : !options.xmlMode;
+        this.htmlMode = !this.options.xmlMode;
+        this.lowerCaseTagNames = (_a = options.lowerCaseTags) !== null && _a !== void 0 ? _a : this.htmlMode;
         this.lowerCaseAttributeNames =
-            (_b = options.lowerCaseAttributeNames) !== null && _b !== void 0 ? _b : !options.xmlMode;
+            (_b = options.lowerCaseAttributeNames) !== null && _b !== void 0 ? _b : this.htmlMode;
         this.tokenizer = new ((_c = options.Tokenizer) !== null && _c !== void 0 ? _c : Tokenizer)(this.options, this);
+        this.foreignContext = [!this.htmlMode];
         (_e = (_d = this.cbs).onparserinit) === null || _e === void 0 ? void 0 : _e.call(_d, this);
     }
     // Tokenizer event handlers
@@ -1211,19 +1451,18 @@ let Parser$1 = class Parser {
         this.startIndex = endIndex;
     }
     /** @internal */
-    ontextentity(cp) {
+    ontextentity(cp, endIndex) {
         var _a, _b;
-        /*
-         * Entities can be emitted on the character, or directly after.
-         * We use the section start here to get accurate indices.
-         */
-        const index = this.tokenizer.getSectionStart();
-        this.endIndex = index - 1;
+        this.endIndex = endIndex - 1;
         (_b = (_a = this.cbs).ontext) === null || _b === void 0 ? void 0 : _b.call(_a, fromCodePoint(cp));
-        this.startIndex = index;
+        this.startIndex = endIndex;
     }
+    /**
+     * Checks if the current tag is a void element. Override this if you want
+     * to specify your own additional void elements.
+     */
     isVoidElement(name) {
-        return !this.options.xmlMode && voidElements.has(name);
+        return this.htmlMode && voidElements.has(name);
     }
     /** @internal */
     onopentagname(start, endIndex) {
@@ -1238,21 +1477,22 @@ let Parser$1 = class Parser {
         var _a, _b, _c, _d;
         this.openTagStart = this.startIndex;
         this.tagname = name;
-        const impliesClose = !this.options.xmlMode && openImpliesClose.get(name);
+        const impliesClose = this.htmlMode && openImpliesClose.get(name);
         if (impliesClose) {
-            while (this.stack.length > 0 &&
-                impliesClose.has(this.stack[this.stack.length - 1])) {
-                const element = this.stack.pop();
+            while (this.stack.length > 0 && impliesClose.has(this.stack[0])) {
+                const element = this.stack.shift();
                 (_b = (_a = this.cbs).onclosetag) === null || _b === void 0 ? void 0 : _b.call(_a, element, true);
             }
         }
         if (!this.isVoidElement(name)) {
-            this.stack.push(name);
-            if (foreignContextElements.has(name)) {
-                this.foreignContext.push(true);
-            }
-            else if (htmlIntegrationElements.has(name)) {
-                this.foreignContext.push(false);
+            this.stack.unshift(name);
+            if (this.htmlMode) {
+                if (foreignContextElements.has(name)) {
+                    this.foreignContext.unshift(true);
+                }
+                else if (htmlIntegrationElements.has(name)) {
+                    this.foreignContext.unshift(false);
+                }
             }
         }
         (_d = (_c = this.cbs).onopentagname) === null || _d === void 0 ? void 0 : _d.call(_c, name);
@@ -1280,40 +1520,37 @@ let Parser$1 = class Parser {
     }
     /** @internal */
     onclosetag(start, endIndex) {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         this.endIndex = endIndex;
         let name = this.getSlice(start, endIndex);
         if (this.lowerCaseTagNames) {
             name = name.toLowerCase();
         }
-        if (foreignContextElements.has(name) ||
-            htmlIntegrationElements.has(name)) {
-            this.foreignContext.pop();
+        if (this.htmlMode &&
+            (foreignContextElements.has(name) ||
+                htmlIntegrationElements.has(name))) {
+            this.foreignContext.shift();
         }
         if (!this.isVoidElement(name)) {
-            const pos = this.stack.lastIndexOf(name);
+            const pos = this.stack.indexOf(name);
             if (pos !== -1) {
-                if (this.cbs.onclosetag) {
-                    let count = this.stack.length - pos;
-                    while (count--) {
-                        // We know the stack has sufficient elements.
-                        this.cbs.onclosetag(this.stack.pop(), count !== 0);
-                    }
+                for (let index = 0; index <= pos; index++) {
+                    const element = this.stack.shift();
+                    // We know the stack has sufficient elements.
+                    (_b = (_a = this.cbs).onclosetag) === null || _b === void 0 ? void 0 : _b.call(_a, element, index !== pos);
                 }
-                else
-                    this.stack.length = pos;
             }
-            else if (!this.options.xmlMode && name === "p") {
+            else if (this.htmlMode && name === "p") {
                 // Implicit open before close
                 this.emitOpenTag("p");
                 this.closeCurrentTag(true);
             }
         }
-        else if (!this.options.xmlMode && name === "br") {
+        else if (this.htmlMode && name === "br") {
             // We can't use `emitOpenTag` for implicit open, as `br` would be implicitly closed.
-            (_b = (_a = this.cbs).onopentagname) === null || _b === void 0 ? void 0 : _b.call(_a, "br");
-            (_d = (_c = this.cbs).onopentag) === null || _d === void 0 ? void 0 : _d.call(_c, "br", {}, true);
-            (_f = (_e = this.cbs).onclosetag) === null || _f === void 0 ? void 0 : _f.call(_e, "br", false);
+            (_d = (_c = this.cbs).onopentagname) === null || _d === void 0 ? void 0 : _d.call(_c, "br");
+            (_f = (_e = this.cbs).onopentag) === null || _f === void 0 ? void 0 : _f.call(_e, "br", {}, true);
+            (_h = (_g = this.cbs).onclosetag) === null || _h === void 0 ? void 0 : _h.call(_g, "br", false);
         }
         // Set `startIndex` for next node
         this.startIndex = endIndex + 1;
@@ -1321,9 +1558,7 @@ let Parser$1 = class Parser {
     /** @internal */
     onselfclosingtag(endIndex) {
         this.endIndex = endIndex;
-        if (this.options.xmlMode ||
-            this.options.recognizeSelfClosing ||
-            this.foreignContext[this.foreignContext.length - 1]) {
+        if (this.options.recognizeSelfClosing || this.foreignContext[0]) {
             this.closeCurrentTag(false);
             // Set `startIndex` for next node
             this.startIndex = endIndex + 1;
@@ -1338,10 +1573,10 @@ let Parser$1 = class Parser {
         const name = this.tagname;
         this.endOpenTag(isOpenImplied);
         // Self-closing tags will be on the top of the stack
-        if (this.stack[this.stack.length - 1] === name) {
+        if (this.stack[0] === name) {
             // If the opening tag isn't implied, the closing tag has to be implied.
             (_b = (_a = this.cbs).onclosetag) === null || _b === void 0 ? void 0 : _b.call(_a, name, !isOpenImplied);
-            this.stack.pop();
+            this.stack.shift();
         }
     }
     /** @internal */
@@ -1421,7 +1656,7 @@ let Parser$1 = class Parser {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         this.endIndex = endIndex;
         const value = this.getSlice(start, endIndex - offset);
-        if (this.options.xmlMode || this.options.recognizeCDATA) {
+        if (!this.htmlMode || this.options.recognizeCDATA) {
             (_b = (_a = this.cbs).oncdatastart) === null || _b === void 0 ? void 0 : _b.call(_a);
             (_d = (_c = this.cbs).ontext) === null || _d === void 0 ? void 0 : _d.call(_c, value);
             (_f = (_e = this.cbs).oncdataend) === null || _f === void 0 ? void 0 : _f.call(_e);
@@ -1439,8 +1674,9 @@ let Parser$1 = class Parser {
         if (this.cbs.onclosetag) {
             // Set the end index for all remaining tags
             this.endIndex = this.startIndex;
-            for (let index = this.stack.length; index > 0; this.cbs.onclosetag(this.stack[--index], true))
-                ;
+            for (let index = 0; index < this.stack.length; index++) {
+                this.cbs.onclosetag(this.stack[index], true);
+            }
         }
         (_b = (_a = this.cbs).onend) === null || _b === void 0 ? void 0 : _b.call(_a);
     }
@@ -1459,6 +1695,8 @@ let Parser$1 = class Parser {
         this.endIndex = 0;
         (_d = (_c = this.cbs).onparserinit) === null || _d === void 0 ? void 0 : _d.call(_c, this);
         this.buffers.length = 0;
+        this.foreignContext.length = 0;
+        this.foreignContext.unshift(!this.htmlMode);
         this.bufferOffset = 0;
         this.writeIndex = 0;
         this.ended = false;
@@ -2140,6 +2378,16 @@ function encodeXML(str) {
     }
     return ret + str.substr(lastIdx);
 }
+/**
+ * Creates a function that escapes all characters matched by the given regular
+ * expression using the given map of characters to escape to their entities.
+ *
+ * @param regex Regular expression to match characters to escape.
+ * @param map Map of characters to escape to their entities.
+ *
+ * @returns Function that escapes all characters matched by the given regular
+ * expression using the given map of characters to escape to their entities.
+ */
 function getEscaper(regex, map) {
     return function escape(data) {
         let match;
@@ -2149,7 +2397,7 @@ function getEscaper(regex, map) {
             if (lastIdx !== match.index) {
                 result += data.substring(lastIdx, match.index);
             }
-            // We know that this chararcter will be in the map.
+            // We know that this character will be in the map.
             result += map.get(match[0].charCodeAt(0));
             // Every match will be of length 1
             lastIdx = match.index + 1;
@@ -2486,7 +2734,7 @@ function getInnerHTML(node, options) {
         : "";
 }
 /**
- * Get a node's inner text. Same as `textContent`, but inserts newlines for `<br>` tags.
+ * Get a node's inner text. Same as `textContent`, but inserts newlines for `<br>` tags. Ignores comments.
  *
  * @category Stringify
  * @deprecated Use `textContent` instead.
@@ -2505,7 +2753,7 @@ function getText(node) {
     return "";
 }
 /**
- * Get a node's text content.
+ * Get a node's text content. Ignores comments.
  *
  * @category Stringify
  * @param node Node to get the text content of.
@@ -2523,7 +2771,7 @@ function textContent(node) {
     return "";
 }
 /**
- * Get a node's inner text.
+ * Get a node's inner text, ignoring `<script>` and `<style>` tags. Ignores comments.
  *
  * @category Stringify
  * @param node Node to get the inner text of.
@@ -2556,7 +2804,7 @@ function getChildren(elem) {
  *
  * @category Traversal
  * @param elem Node to get the parent of.
- * @returns `elem`'s parent node.
+ * @returns `elem`'s parent node, or `null` if `elem` is a root node.
  */
 function getParent(elem) {
     return elem.parent || null;
@@ -2570,7 +2818,7 @@ function getParent(elem) {
  *
  * @category Traversal
  * @param elem Element to get the siblings of.
- * @returns `elem`'s siblings.
+ * @returns `elem`'s siblings, including `elem`.
  */
 function getSiblings(elem) {
     const parent = getParent(elem);
@@ -2628,7 +2876,8 @@ function getName(elem) {
  *
  * @category Traversal
  * @param elem The element to get the next sibling of.
- * @returns `elem`'s next sibling that is a tag.
+ * @returns `elem`'s next sibling that is a tag, or `null` if there is no next
+ * sibling.
  */
 function nextElementSibling(elem) {
     let { next } = elem;
@@ -2641,7 +2890,8 @@ function nextElementSibling(elem) {
  *
  * @category Traversal
  * @param elem The element to get the previous sibling of.
- * @returns `elem`'s previous sibling that is a tag.
+ * @returns `elem`'s previous sibling that is a tag, or `null` if there is no
+ * previous sibling.
  */
 function prevElementSibling(elem) {
     let { prev } = elem;
@@ -2663,8 +2913,14 @@ function removeElement(elem) {
         elem.next.prev = elem.prev;
     if (elem.parent) {
         const childs = elem.parent.children;
-        childs.splice(childs.lastIndexOf(elem), 1);
+        const childsIndex = childs.lastIndexOf(elem);
+        if (childsIndex >= 0) {
+            childs.splice(childsIndex, 1);
+        }
     }
+    elem.next = null;
+    elem.prev = null;
+    elem.parent = null;
 }
 /**
  * Replace an element in the dom
@@ -2693,15 +2949,15 @@ function replaceElement(elem, replacement) {
  * Append a child to an element.
  *
  * @category Manipulation
- * @param elem The element to append to.
+ * @param parent The element to append to.
  * @param child The element to be added as a child.
  */
-function appendChild(elem, child) {
+function appendChild(parent, child) {
     removeElement(child);
     child.next = null;
-    child.parent = elem;
-    if (elem.children.push(child) > 1) {
-        const sibling = elem.children[elem.children.length - 2];
+    child.parent = parent;
+    if (parent.children.push(child) > 1) {
+        const sibling = parent.children[parent.children.length - 2];
         sibling.next = child;
         child.prev = sibling;
     }
@@ -2739,15 +2995,15 @@ function append(elem, next) {
  * Prepend a child to an element.
  *
  * @category Manipulation
- * @param elem The element to prepend before.
+ * @param parent The element to prepend before.
  * @param child The element to be added as a child.
  */
-function prependChild(elem, child) {
+function prependChild(parent, child) {
     removeElement(child);
-    child.parent = elem;
+    child.parent = parent;
     child.prev = null;
-    if (elem.children.unshift(child) !== 1) {
-        const sibling = elem.children[1];
+    if (parent.children.unshift(child) !== 1) {
+        const sibling = parent.children[1];
         sibling.prev = child;
         child.next = sibling;
     }
@@ -2779,7 +3035,7 @@ function prepend(elem, prev) {
 }
 
 /**
- * Search a node and its children for nodes passing a test function.
+ * Search a node and its children for nodes passing a test function. If `node` is not an array, it will be wrapped in one.
  *
  * @category Querying
  * @param test Function to test nodes on.
@@ -2789,12 +3045,10 @@ function prepend(elem, prev) {
  * @returns All nodes passing `test`.
  */
 function filter(test, node, recurse = true, limit = Infinity) {
-    if (!Array.isArray(node))
-        node = [node];
-    return find(test, node, recurse, limit);
+    return find(test, Array.isArray(node) ? node : [node], recurse, limit);
 }
 /**
- * Search an array of node and its children for nodes passing a test function.
+ * Search an array of nodes and their children for nodes passing a test function.
  *
  * @category Querying
  * @param test Function to test nodes on.
@@ -2805,24 +3059,41 @@ function filter(test, node, recurse = true, limit = Infinity) {
  */
 function find(test, nodes, recurse, limit) {
     const result = [];
-    for (const elem of nodes) {
+    /** Stack of the arrays we are looking at. */
+    const nodeStack = [nodes];
+    /** Stack of the indices within the arrays. */
+    const indexStack = [0];
+    for (;;) {
+        // First, check if the current array has any more elements to look at.
+        if (indexStack[0] >= nodeStack[0].length) {
+            // If we have no more arrays to look at, we are done.
+            if (indexStack.length === 1) {
+                return result;
+            }
+            // Otherwise, remove the current array from the stack.
+            nodeStack.shift();
+            indexStack.shift();
+            // Loop back to the start to continue with the next array.
+            continue;
+        }
+        const elem = nodeStack[0][indexStack[0]++];
         if (test(elem)) {
             result.push(elem);
             if (--limit <= 0)
-                break;
+                return result;
         }
         if (recurse && hasChildren(elem) && elem.children.length > 0) {
-            const children = find(test, elem.children, recurse, limit);
-            result.push(...children);
-            limit -= children.length;
-            if (limit <= 0)
-                break;
+            /*
+             * Add the children to the stack. We are depth-first, so this is
+             * the next array we look at.
+             */
+            indexStack.unshift(0);
+            nodeStack.unshift(elem.children);
         }
     }
-    return result;
 }
 /**
- * Finds the first element inside of an array that matches a test function.
+ * Finds the first element inside of an array that matches a test function. This is an alias for `Array.prototype.find`.
  *
  * @category Querying
  * @param test Function to test nodes on.
@@ -2838,27 +3109,29 @@ function findOneChild(test, nodes) {
  *
  * @category Querying
  * @param test Function to test nodes on.
- * @param nodes Array of nodes to search.
+ * @param nodes Node or array of nodes to search.
  * @param recurse Also consider child nodes.
- * @returns The first child node that passes `test`.
+ * @returns The first node that passes `test`.
  */
 function findOne(test, nodes, recurse = true) {
     let elem = null;
     for (let i = 0; i < nodes.length && !elem; i++) {
-        const checked = nodes[i];
-        if (!isTag(checked)) {
+        const node = nodes[i];
+        if (!isTag(node)) {
             continue;
         }
-        else if (test(checked)) {
-            elem = checked;
+        else if (test(node)) {
+            elem = node;
         }
-        else if (recurse && checked.children.length > 0) {
-            elem = findOne(test, checked.children, true);
+        else if (recurse && node.children.length > 0) {
+            elem = findOne(test, node.children, true);
         }
     }
     return elem;
 }
 /**
+ * Checks if a tree of nodes contains at least one node passing a test.
+ *
  * @category Querying
  * @param test Function to test nodes on.
  * @param nodes Array of nodes to search.
@@ -2866,12 +3139,10 @@ function findOne(test, nodes, recurse = true) {
  */
 function existsOne(test, nodes) {
     return nodes.some((checked) => isTag(checked) &&
-        (test(checked) ||
-            (checked.children.length > 0 &&
-                existsOne(test, checked.children))));
+        (test(checked) || existsOne(test, checked.children)));
 }
 /**
- * Search and array of nodes and its children for elements passing a test function.
+ * Search an array of nodes and their children for elements passing a test function.
  *
  * Same as `find`, but limited to elements and with less options, leading to reduced complexity.
  *
@@ -2881,21 +3152,35 @@ function existsOne(test, nodes) {
  * @returns All nodes passing `test`.
  */
 function findAll(test, nodes) {
-    var _a;
     const result = [];
-    const stack = nodes.filter(isTag);
-    let elem;
-    while ((elem = stack.shift())) {
-        const children = (_a = elem.children) === null || _a === void 0 ? void 0 : _a.filter(isTag);
-        if (children && children.length > 0) {
-            stack.unshift(...children);
+    const nodeStack = [nodes];
+    const indexStack = [0];
+    for (;;) {
+        if (indexStack[0] >= nodeStack[0].length) {
+            if (nodeStack.length === 1) {
+                return result;
+            }
+            // Otherwise, remove the current array from the stack.
+            nodeStack.shift();
+            indexStack.shift();
+            // Loop back to the start to continue with the next array.
+            continue;
         }
+        const elem = nodeStack[0][indexStack[0]++];
+        if (!isTag(elem))
+            continue;
         if (test(elem))
             result.push(elem);
+        if (elem.children.length > 0) {
+            indexStack.unshift(0);
+            nodeStack.unshift(elem.children);
+        }
     }
-    return result;
 }
 
+/**
+ * A map of functions to check nodes against.
+ */
 const Checks = {
     tag_name(name) {
         if (typeof name === "function") {
@@ -2920,6 +3205,9 @@ const Checks = {
     },
 };
 /**
+ * Returns a function to check whether a node has an attribute with a particular
+ * value.
+ *
  * @param attrib Attribute to check.
  * @param value Attribute value to look for.
  * @returns A function to check whether the a node has an attribute with a
@@ -2932,6 +3220,9 @@ function getAttribCheck(attrib, value) {
     return (elem) => isTag(elem) && elem.attribs[attrib] === value;
 }
 /**
+ * Returns a function that returns `true` if either of the input functions
+ * returns `true` for a node.
+ *
  * @param a First function to combine.
  * @param b Second function to combine.
  * @returns A function taking a node and returning `true` if either of the input
@@ -2941,9 +3232,12 @@ function combineFuncs(a, b) {
     return (elem) => a(elem) || b(elem);
 }
 /**
+ * Returns a function that executes all checks in `options` and returns `true`
+ * if any of them match a node.
+ *
  * @param options An object describing nodes to look for.
- * @returns A function executing all checks in `options` and returning `true` if
- *   any of them match a node.
+ * @returns A function that executes all checks in `options` and returns `true`
+ *   if any of them match a node.
  */
 function compileTest(options) {
     const funcs = Object.keys(options).map((key) => {
@@ -2955,6 +3249,8 @@ function compileTest(options) {
     return funcs.length === 0 ? null : funcs.reduce(combineFuncs);
 }
 /**
+ * Checks whether a node matches the description in `options`.
+ *
  * @category Legacy Query Functions
  * @param options An object describing nodes to look for.
  * @param node The element to test.
@@ -2965,6 +3261,8 @@ function testElement(options, node) {
     return test ? test(node) : true;
 }
 /**
+ * Returns all nodes that match `options`.
+ *
  * @category Legacy Query Functions
  * @param options An object describing nodes to look for.
  * @param nodes Nodes to search through.
@@ -2977,6 +3275,8 @@ function getElements(options, nodes, recurse, limit = Infinity) {
     return test ? filter(test, nodes, recurse, limit) : [];
 }
 /**
+ * Returns the node with the supplied ID.
+ *
  * @category Legacy Query Functions
  * @param id The unique ID attribute value to look for.
  * @param nodes Nodes to search through.
@@ -2989,6 +3289,8 @@ function getElementById(id, nodes, recurse = true) {
     return findOne(getAttribCheck("id", id), nodes, recurse);
 }
 /**
+ * Returns all nodes with the supplied `tagName`.
+ *
  * @category Legacy Query Functions
  * @param tagName Tag name to search for.
  * @param nodes Nodes to search through.
@@ -3000,6 +3302,8 @@ function getElementsByTagName(tagName, nodes, recurse = true, limit = Infinity)
     return filter(Checks["tag_name"](tagName), nodes, recurse, limit);
 }
 /**
+ * Returns all nodes with the supplied `type`.
+ *
  * @category Legacy Query Functions
  * @param type Element type to look for.
  * @param nodes Nodes to search through.
@@ -3012,11 +3316,12 @@ function getElementsByTagType(type, nodes, recurse = true, limit = Infinity) {
 }
 
 /**
- * Given an array of nodes, remove any member that is contained by another.
+ * Given an array of nodes, remove any member that is contained by another
+ * member.
  *
  * @category Helpers
  * @param nodes Nodes to filter.
- * @returns Remaining nodes that aren't subtrees of each other.
+ * @returns Remaining nodes that aren't contained by other nodes.
  */
 function removeSubsets(nodes) {
     let idx = nodes.length;
@@ -3057,8 +3362,8 @@ var DocumentPosition;
     DocumentPosition[DocumentPosition["CONTAINED_BY"] = 16] = "CONTAINED_BY";
 })(DocumentPosition || (DocumentPosition = {}));
 /**
- * Compare the position of one node against another node in any other document.
- * The return value is a bitmask with the values from {@link DocumentPosition}.
+ * Compare the position of one node against another node in any other document,
+ * returning a bitmask with the values from {@link DocumentPosition}.
  *
  * Document order:
  * > There is an ordering, document order, defined on all the nodes in the
@@ -3122,9 +3427,9 @@ function compareDocumentPosition(nodeA, nodeB) {
     return DocumentPosition.PRECEDING;
 }
 /**
- * Sort an array of nodes based on their relative position in the document and
- * remove any duplicate nodes. If the array contains nodes that do not belong to
- * the same document, sort order is unspecified.
+ * Sort an array of nodes based on their relative position in the document,
+ * removing any duplicate nodes. If the array contains nodes that do not belong
+ * to the same document, sort order is unspecified.
  *
  * @category Helpers
  * @param nodes Array of DOM nodes.
@@ -3225,7 +3530,7 @@ function getRssFeed(feedRoot) {
             addConditionally(entry, "title", "title", children);
             addConditionally(entry, "link", "link", children);
             addConditionally(entry, "description", "description", children);
-            const pubDate = fetch("pubDate", children);
+            const pubDate = fetch("pubDate", children) || fetch("dc:date", children);
             if (pubDate)
                 entry.pubDate = new Date(pubDate);
             return entry;
@@ -3376,7 +3681,7 @@ var DomUtils = /*#__PURE__*/Object.freeze({
  * Parses the data, returns the resulting document.
  *
  * @param data The data that should be parsed.
- * @param options Optional options for the parser and DOM builder.
+ * @param options Optional options for the parser and DOM handler.
  */
 function parseDocument(data, options) {
     const handler = new DomHandler(undefined, options);
@@ -12020,13 +12325,14 @@ const HASH_CHARACTER_LENGTH = 16;
  * finding the asset urls in the AST assumes that there will be no
  * user code with the same structure as the asset urls. In other words:
  * Don't use a define a property named "canvasKitWasmUrl" that refers to
- * a string literal, don't define a property named "fontUrls" that refers
- * to an array expression of string literals, and don't define a property
- * called "images" that refers to an array expression of object expressions
- * with properties named "imageName", "height", "width", and "url". Otherwise,
- * this plugin may alter your code in unexpected ways (although most likely
- * it will simply give warnings, because it's unlikely there will be valid
- * file assets that will be found and hashed).
+ * a string literal, don't define a property named "fonts" that that refers
+ * to an array expression of object expressions with properties named
+ * "fontName" and "url", and don't define a property called "images" that
+ * refers to an array expression of object expressions with properties named
+ * "imageName", "height", "width", and "url". Otherwise, this plugin may alter
+ * your code in unexpected ways (although most likely it will simply give
+ * warnings, because it's unlikely there will be valid file assets that will
+ * be found and hashed).
  *
  * @param rootDir - root directory of build, usually "dist" because you
  * usually hash only production builds
@@ -12071,10 +12377,16 @@ function hashM2c2kitAssets(rootDir) {
                                         const literal = node;
                                         const originalUrlValue = literal.value;
                                         try {
-                                            const hashedUrlValue = addHashToUrl(originalUrlValue, rootDir);
+                                            const hashedUrlValue = addHashToUrl(originalUrlValue, 
+                                            /**
+                                             * by our convention, the wasm file will be served from
+                                             * the assets directory, so the location is
+                                             * `assets/${canvasKitWasmUrl}` not `${canvasKitWasmUrl}`
+                                             */
+                                            `${rootDir}/assets`);
                                             literal.value = literal.value.replace(originalUrlValue, hashedUrlValue);
                                             literal.raw = literal.raw.replace(originalUrlValue, hashedUrlValue);
-                                            addFileToFilesToBeRenamed(rootDir, originalUrlValue, hashedUrlValue, fileRenames);
+                                            addFileToFilesToBeRenamed(`${rootDir}/assets`, originalUrlValue, hashedUrlValue, fileRenames);
                                         }
                                         catch (_a) {
                                             console.log(`warning: could not hash canvaskit.wasm resource because it was not found at ${originalUrlValue}`);
@@ -12082,25 +12394,48 @@ function hashM2c2kitAssets(rootDir) {
                                     }
                                 }
                             }
-                            if (ancestors.length >= 3) {
-                                const maybeArrayExpression = ancestors.slice(-2)[0];
-                                if (maybeArrayExpression.type === "ArrayExpression") {
-                                    const maybeProperty = ancestors.slice(-3)[0];
-                                    if (maybeProperty.type === "Property") {
-                                        const property = maybeProperty;
-                                        if (property.key.type === "Identifier" &&
-                                            property.key.name == "fontUrls") {
-                                            // property is fontUrls
-                                            const literal = node;
-                                            const originalUrlValue = literal.value;
-                                            try {
-                                                const hashedUrlValue = addHashToUrl(originalUrlValue, rootDir);
-                                                literal.value = literal.value.replace(originalUrlValue, hashedUrlValue);
-                                                literal.raw = literal.raw.replace(originalUrlValue, hashedUrlValue);
-                                                addFileToFilesToBeRenamed(rootDir, originalUrlValue, hashedUrlValue, fileRenames);
-                                            }
-                                            catch (_b) {
-                                                console.log(`warning: could not hash a font url resource because it was not found at ${originalUrlValue}`);
+                            // we'll be looking back 5 levels
+                            if (ancestors.length >= 5) {
+                                const maybeProperty = ancestors.slice(-2)[0];
+                                if (maybeProperty.type === "Property") {
+                                    const property = maybeProperty;
+                                    if (property.key.type === "Identifier" &&
+                                        property.key.name == "url") {
+                                        // property is url
+                                        const maybeObjExpression = ancestors.slice(-3)[0];
+                                        if (maybeObjExpression.type === "ObjectExpression") {
+                                            const objExpression = maybeObjExpression;
+                                            const properties = objExpression.properties
+                                                .filter((p) => p.type === "Property")
+                                                .map((p) => p);
+                                            const identifiers = properties
+                                                .filter((p) => p.key.type === "Identifier")
+                                                .map((p) => p.key.name);
+                                            const urlFontAssetProperties = ["fontName", "url"];
+                                            const propCount = identifiers.filter((i) => urlFontAssetProperties.indexOf(i) !== -1).length;
+                                            if (propCount === 2) {
+                                                // the object expression has the 2 properties
+                                                const maybeArrayExpression = ancestors.slice(-4)[0];
+                                                if (maybeArrayExpression.type === "ArrayExpression") {
+                                                    const maybeProperty = ancestors.slice(-5)[0];
+                                                    if (maybeProperty.type === "Property") {
+                                                        const property = maybeProperty;
+                                                        if (property.key.type === "Identifier" &&
+                                                            property.key.name == "fonts") {
+                                                            // property is fonts
+                                                            const literal = node;
+                                                            const originalUrlValue = literal.value;
+                                                            try {
+                                                                const hashedUrlValue = addHashToUrl(originalUrlValue, rootDir);
+                                                                literal.value = literal.value.replace(originalUrlValue, hashedUrlValue);
+                                                                literal.raw = literal.raw.replace(originalUrlValue, hashedUrlValue);
+                                                                addFileToFilesToBeRenamed(rootDir, originalUrlValue, hashedUrlValue, fileRenames);
+                                                            }
+                                                            catch (_b) {
+                                                            }
+                                                        }
+                                                    }
+                                                }
                                             }
                                         }
                                     }