parse5 8.0.1 → 8.1.1

package/dist/parser/open-element-stack.js

@@ -1,4 +1,4 @@
-import { TAG_ID as $, NS, NUMBERED_HEADERS } from '../common/html.js';
+import { TAG_ID as $, NS, SPECIAL_ELEMENTS, getTagID } from '../common/html.js';
 //Element utils
 const IMPLICIT_END_TAG_REQUIRED = new Set([$.DD, $.DT, $.LI, $.OPTGROUP, $.OPTION, $.P, $.RB, $.RP, $.RT, $.RTC]);
 const IMPLICIT_END_TAG_REQUIRED_THOROUGHLY = new Set([
@@ -12,7 +12,42 @@ const IMPLICIT_END_TAG_REQUIRED_THOROUGHLY = new Set([
     $.THEAD,
     $.TR,
 ]);
-const SCOPING_ELEMENTS_HTML = new Set([
+/** A stack this deep starts to index its elements; a shallower one is cheaper to scan than to index. */
+const INDEX_DEPTH = 64;
+/*
+ * Every open element has a key: an HTML element its tag ID, an SVG or MathML element its tag ID plus the offsets below,
+ * and any other element (an unknown tag, or another namespace) a key from `NAME_KEYS` up, assigned per stack by
+ * namespace and tag name.
+ */
+const SVG_KEYS = 256;
+const MATHML_KEYS = 512;
+const NAME_KEYS = 768;
+const NUMBERED_HEADERS = [$.H1, $.H2, $.H3, $.H4, $.H5, $.H6];
+const TABLE_BODIES = [$.TBODY, $.TFOOT, $.THEAD];
+const TABLE_ROW_CONTEXT = [$.TR, $.TEMPLATE, $.HTML];
+const TABLE_BODY_CONTEXT = [...TABLE_BODIES, $.TEMPLATE, $.HTML];
+const TABLE_CONTEXT = [$.TABLE, $.TEMPLATE, $.HTML];
+const TABLE_CELLS = [$.TD, $.TH];
+// Classes of keys: special elements, the special elements that end the search for a list item to close (all but
+// HTML `address`, `div` and `p`), and the elements that bound each kind of scope.
+const SPECIAL = 1;
+const LIST_ITEM_BOUNDARY = 2;
+const SCOPE = 4;
+const LIST_ITEM_SCOPE = 8;
+const BUTTON_SCOPE = 16;
+const TABLE_SCOPE = 32;
+const KEY_CLASSES = new Uint8Array(NAME_KEYS);
+for (const [ns, offset] of [
+    [NS.HTML, 0],
+    [NS.SVG, SVG_KEYS],
+    [NS.MATHML, MATHML_KEYS],
+]) {
+    for (const tn of SPECIAL_ELEMENTS[ns]) {
+        KEY_CLASSES[offset + tn] =
+            ns === NS.HTML && (tn === $.ADDRESS || tn === $.DIV || tn === $.P) ? SPECIAL : SPECIAL | LIST_ITEM_BOUNDARY;
+    }
+}
+for (const key of [
     $.APPLET,
     $.CAPTION,
     $.HTML,
@@ -22,16 +57,55 @@ const SCOPING_ELEMENTS_HTML = new Set([
     $.TD,
     $.TEMPLATE,
     $.TH,
-]);
-const SCOPING_ELEMENTS_HTML_LIST = new Set([...SCOPING_ELEMENTS_HTML, $.OL, $.UL]);
-const SCOPING_ELEMENTS_HTML_BUTTON = new Set([...SCOPING_ELEMENTS_HTML, $.BUTTON]);
-const SCOPING_ELEMENTS_MATHML = new Set([$.ANNOTATION_XML, $.MI, $.MN, $.MO, $.MS, $.MTEXT]);
-const SCOPING_ELEMENTS_SVG = new Set([$.DESC, $.FOREIGN_OBJECT, $.TITLE]);
-const TABLE_ROW_CONTEXT = new Set([$.TR, $.TEMPLATE, $.HTML]);
-const TABLE_BODY_CONTEXT = new Set([$.TBODY, $.TFOOT, $.THEAD, $.TEMPLATE, $.HTML]);
-const TABLE_CONTEXT = new Set([$.TABLE, $.TEMPLATE, $.HTML]);
-const TABLE_CELLS = new Set([$.TD, $.TH]);
-//Stack of open elements
+    SVG_KEYS + $.DESC,
+    SVG_KEYS + $.FOREIGN_OBJECT,
+    SVG_KEYS + $.TITLE,
+    MATHML_KEYS + $.ANNOTATION_XML,
+    MATHML_KEYS + $.MI,
+    MATHML_KEYS + $.MN,
+    MATHML_KEYS + $.MO,
+    MATHML_KEYS + $.MS,
+    MATHML_KEYS + $.MTEXT,
+]) {
+    KEY_CLASSES[key] |= SCOPE | LIST_ITEM_SCOPE | BUTTON_SCOPE;
+}
+KEY_CLASSES[$.OL] |= LIST_ITEM_SCOPE;
+KEY_CLASSES[$.UL] |= LIST_ITEM_SCOPE;
+KEY_CLASSES[$.BUTTON] |= BUTTON_SCOPE;
+KEY_CLASSES[$.TABLE] |= TABLE_SCOPE;
+KEY_CLASSES[$.HTML] |= TABLE_SCOPE;
+// The adoption agency and the reconstruction look up formatting elements by element.
+const FORMATTING_TAGS = new Uint8Array(NAME_KEYS);
+for (const tn of [$.A, $.B, $.BIG, $.CODE, $.EM, $.FONT, $.I, $.NOBR, $.S, $.SMALL, $.STRIKE, $.STRONG, $.TT, $.U]) {
+    FORMATTING_TAGS[tn] = 1;
+}
+/** The key of an element with a tag ID in HTML, SVG or MathML, or -1 for an element keyed by its name. */
+function tagKey(ns, tagID) {
+    if (tagID === $.UNKNOWN)
+        return -1;
+    switch (ns) {
+        case NS.HTML: {
+            return tagID;
+        }
+        case NS.SVG: {
+            return SVG_KEYS + tagID;
+        }
+        case NS.MATHML: {
+            return MATHML_KEYS + tagID;
+        }
+        default: {
+            return -1;
+        }
+    }
+}
+/**
+ * The stack of open elements. Each element has a slot in `items` and `tagIDs`. Once the stack is `INDEX_DEPTH` deep, it
+ * indexes its elements so that the searches the parser repeats per token take constant time: it chains the elements
+ * with each key, so that the topmost one is found without a scan, and counts per slot the special elements and scope
+ * boundaries at or below it, which tell whether one lies between two slots. Removing an element from the middle then
+ * leaves its slot free instead of moving the elements above it; `slotBelow` and `slotAbove` step over free slots, and
+ * `depth` counts the open elements.
+ */
 export class OpenElementStack {
     get currentTmplContentOrNode() {
         return this._isInTemplate() ? this.treeAdapter.getTemplateContent(this.current) : this.current;
@@ -41,15 +115,53 @@ export class OpenElementStack {
         this.handler = handler;
         this.items = [];
         this.tagIDs = [];
+        /** The slot of the current element. */
         this.stackTop = -1;
+        /** The number of open elements. */
+        this.depth = 0;
         this.tmplCount = 0;
         this.currentTagId = $.UNKNOWN;
+        this.indexed = false;
+        /** The slot of the open element below, and above, each open element's slot; -1 for none. */
+        this.below = [];
+        this.above = [];
+        this.keys = [];
+        /** The slot of the next lower, and higher, open element with the same key; -1 for none. */
+        this.keyPrev = [];
+        this.keyNext = [];
+        /** The slot of the topmost open element with each key, -1 for none. */
+        this.keyTops = new Int32Array(0);
+        /** Per slot, the open special elements, list item boundaries and scope boundaries at or below it. */
+        this.specials = [];
+        this.listItemBoundaries = [];
+        this.scopeBoundaries = [];
+        /** Per slot, the slot of the topmost open HTML element at or below it, or -1. */
+        this.htmlSlots = [];
+        this.formattingSlots = new Map();
         this.current = document;
     }
-    //Index of element
+    /** The slot of an open element, or -1. */
     _indexOf(element) {
+        if (this.indexed) {
+            const idx = this.formattingSlots.get(element);
+            if (idx !== undefined)
+                return idx;
+            // A formatting element is in `formattingSlots` while it is open.
+            if (FORMATTING_TAGS[getTagID(this.treeAdapter.getTagName(element))])
+                return -1;
+        }
         return this.items.lastIndexOf(element, this.stackTop);
     }
+    /** The slot of the open element below the one at `idx`, or -1. */
+    slotBelow(idx) {
+        return this.indexed ? this.below[idx] : idx - 1;
+    }
+    /** The slot of the open element above the one at `idx`, or -1. */
+    slotAbove(idx) {
+        if (this.indexed)
+            return this.above[idx];
+        return idx === this.stackTop ? -1 : idx + 1;
+    }
     //Update current element
     _isInTemplate() {
         return this.currentTagId === $.TEMPLATE && this.treeAdapter.getNamespaceURI(this.current) === NS.HTML;
@@ -58,61 +170,303 @@ export class OpenElementStack {
         this.current = this.items[this.stackTop];
         this.currentTagId = this.tagIDs[this.stackTop];
     }
+    //Index
+    _nameKey(ns, tagName, create) {
+        var _a, _b;
+        const name = `${ns} ${tagName}`;
+        let key = (_a = this.nameKeys) === null || _a === void 0 ? void 0 : _a.get(name);
+        if (key === undefined && create) {
+            (_b = this.nameKeys) !== null && _b !== void 0 ? _b : (this.nameKeys = new Map());
+            key = NAME_KEYS + this.nameKeys.size;
+            this.nameKeys.set(name, key);
+            if (key === this.keyTops.length) {
+                const keyTops = new Int32Array(2 * key).fill(-1);
+                keyTops.set(this.keyTops);
+                this.keyTops = keyTops;
+            }
+        }
+        return key !== null && key !== void 0 ? key : -1;
+    }
+    /** Indexes the open elements once the stack is `INDEX_DEPTH` deep. */
+    _indexAll() {
+        this.indexed = true;
+        this.keyTops = new Int32Array(NAME_KEYS).fill(-1);
+        for (let i = 0; i <= this.stackTop; i++)
+            this._index(i, i - 1);
+    }
+    /** Indexes the element at `slot`, above the open element at `belowIdx`. */
+    _index(slot, belowIdx) {
+        const element = this.items[slot];
+        const tagID = this.tagIDs[slot];
+        const ns = this.treeAdapter.getNamespaceURI(element);
+        let key = tagKey(ns, tagID);
+        if (key === -1)
+            key = this._nameKey(ns, this.treeAdapter.getTagName(element), true);
+        const keyPrev = this.keyTops[key];
+        this.keys[slot] = key;
+        this.keyPrev[slot] = keyPrev;
+        this.keyNext[slot] = -1;
+        if (keyPrev !== -1)
+            this.keyNext[keyPrev] = slot;
+        this.keyTops[key] = slot;
+        this.above[slot] = -1;
+        this._link(slot, belowIdx, ns === NS.HTML);
+        if (FORMATTING_TAGS[tagID])
+            this.formattingSlots.set(element, slot);
+    }
+    /** Puts the indexed element at `slot` above the one at `belowIdx`, and counts the elements of each class. */
+    _link(slot, belowIdx, isHtml) {
+        const key = this.keys[slot];
+        const classes = key < NAME_KEYS ? KEY_CLASSES[key] : 0;
+        this.below[slot] = belowIdx;
+        if (belowIdx === -1) {
+            this.specials[slot] = classes & SPECIAL;
+            this.listItemBoundaries[slot] = (classes & LIST_ITEM_BOUNDARY) >> 1;
+            this.scopeBoundaries[slot] = (classes & SCOPE) >> 2;
+            this.htmlSlots[slot] = isHtml ? slot : -1;
+        }
+        else {
+            this.above[belowIdx] = slot;
+            this.specials[slot] = this.specials[belowIdx] + (classes & SPECIAL);
+            this.listItemBoundaries[slot] = this.listItemBoundaries[belowIdx] + ((classes & LIST_ITEM_BOUNDARY) >> 1);
+            this.scopeBoundaries[slot] = this.scopeBoundaries[belowIdx] + ((classes & SCOPE) >> 2);
+            this.htmlSlots[slot] = isHtml ? slot : this.htmlSlots[belowIdx];
+        }
+    }
+    /** Takes the element at `slot` out of the index, except for the links between slots. */
+    _unindex(slot) {
+        const key = this.keys[slot];
+        const keyPrev = this.keyPrev[slot];
+        const keyNext = this.keyNext[slot];
+        if (keyPrev !== -1)
+            this.keyNext[keyPrev] = keyNext;
+        if (keyNext === -1)
+            this.keyTops[key] = keyPrev;
+        else
+            this.keyPrev[keyNext] = keyPrev;
+        if (FORMATTING_TAGS[this.tagIDs[slot]])
+            this.formattingSlots.delete(this.items[slot]);
+    }
+    /** Moves the indexed element at `from` down to the free slot `to`, keeping its key chain in order. */
+    _move(from, to) {
+        const element = this.items[from];
+        const key = this.keys[from];
+        const keyPrev = this.keyPrev[from];
+        const keyNext = this.keyNext[from];
+        this.items[to] = element;
+        this.tagIDs[to] = this.tagIDs[from];
+        this.keys[to] = key;
+        this.keyPrev[to] = keyPrev;
+        this.keyNext[to] = keyNext;
+        if (keyPrev !== -1)
+            this.keyNext[keyPrev] = to;
+        if (keyNext === -1)
+            this.keyTops[key] = to;
+        else
+            this.keyPrev[keyNext] = to;
+        if (FORMATTING_TAGS[this.tagIDs[to]])
+            this.formattingSlots.set(element, to);
+    }
+    //Search by tag
+    /** The slot of the topmost open HTML element with this tag, or -1. */
+    indexOfTopmost(tagID) {
+        if (this.indexed)
+            return this.keyTops[tagID];
+        for (let i = this.stackTop; i >= 0; i--) {
+            if (this.tagIDs[i] === tagID && this.treeAdapter.getNamespaceURI(this.items[i]) === NS.HTML)
+                return i;
+        }
+        return -1;
+    }
+    /** The slot of the topmost open HTML element with any of these tags, or -1. */
+    indexOfTopmostOf(tagIDs) {
+        if (this.indexed) {
+            let top = -1;
+            for (const tagID of tagIDs) {
+                if (this.keyTops[tagID] > top)
+                    top = this.keyTops[tagID];
+            }
+            return top;
+        }
+        for (let i = this.stackTop; i >= 0; i--) {
+            if (tagIDs.includes(this.tagIDs[i]) && this.treeAdapter.getNamespaceURI(this.items[i]) === NS.HTML)
+                return i;
+        }
+        return -1;
+    }
+    /** The slot of the topmost open element in this namespace with this tag name, or -1. */
+    indexOfTopmostByName(ns, tagName) {
+        if (this.indexed) {
+            let key = tagKey(ns, getTagID(tagName));
+            if (key === -1)
+                key = this._nameKey(ns, tagName, false);
+            return key === -1 ? -1 : this.keyTops[key];
+        }
+        for (let i = this.stackTop; i >= 0; i--) {
+            const element = this.items[i];
+            if (this.treeAdapter.getTagName(element) === tagName && this.treeAdapter.getNamespaceURI(element) === ns) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    /** The slot of the topmost open HTML element, or -1. */
+    indexOfTopmostHtmlElement() {
+        if (this.indexed)
+            return this.stackTop === -1 ? -1 : this.htmlSlots[this.stackTop];
+        let i = this.stackTop;
+        while (i >= 0 && this.treeAdapter.getNamespaceURI(this.items[i]) !== NS.HTML)
+            i--;
+        return i;
+    }
+    /** Whether an element of the classes is open above the slot `idx`, on a stack that is not indexed. */
+    _hasAbove(idx, classes) {
+        for (let i = this.stackTop; i > idx; i--) {
+            const key = tagKey(this.treeAdapter.getNamespaceURI(this.items[i]), this.tagIDs[i]);
+            if (key !== -1 && KEY_CLASSES[key] & classes)
+                return true;
+        }
+        return false;
+    }
+    /** Whether a special element is open above the slot `idx`. */
+    hasSpecialElementAbove(idx) {
+        return this.indexed ? this.specials[this.stackTop] !== this.specials[idx] : this._hasAbove(idx, SPECIAL);
+    }
+    /** Whether a special element other than HTML `address`, `div` and `p` is open above the slot `idx`. */
+    hasListItemBoundaryAbove(idx) {
+        return this.indexed
+            ? this.listItemBoundaries[this.stackTop] !== this.listItemBoundaries[idx]
+            : this._hasAbove(idx, LIST_ITEM_BOUNDARY);
+    }
     //Mutations
     push(element, tagID) {
+        const belowIdx = this.stackTop;
         this.stackTop++;
+        this.depth++;
         this.items[this.stackTop] = element;
         this.current = element;
         this.tagIDs[this.stackTop] = tagID;
         this.currentTagId = tagID;
+        if (this.indexed)
+            this._index(this.stackTop, belowIdx);
+        else if (this.depth === INDEX_DEPTH)
+            this._indexAll();
         if (this._isInTemplate()) {
             this.tmplCount++;
         }
         this.handler.onItemPush(element, tagID, true);
     }
-    pop() {
-        const popped = this.current;
+    /** Pops the current element without calling the handler. */
+    _popCurrent() {
         if (this.tmplCount > 0 && this._isInTemplate()) {
             this.tmplCount--;
         }
-        this.stackTop--;
+        if (this.indexed) {
+            this._unindex(this.stackTop);
+            this.stackTop = this.below[this.stackTop];
+            if (this.stackTop !== -1)
+                this.above[this.stackTop] = -1;
+        }
+        else {
+            this.stackTop--;
+        }
+        this.depth--;
         this._updateCurrentElement();
+    }
+    pop() {
+        const popped = this.current;
+        this._popCurrent();
         this.handler.onItemPop(popped, true);
     }
     replace(oldElement, newElement) {
         const idx = this._indexOf(oldElement);
         this.items[idx] = newElement;
+        if (this.indexed && FORMATTING_TAGS[this.tagIDs[idx]]) {
+            this.formattingSlots.delete(oldElement);
+            this.formattingSlots.set(newElement, idx);
+        }
         if (idx === this.stackTop) {
             this.current = newElement;
         }
     }
-    insertAfter(referenceElement, newElement, newElementID) {
-        const insertionIdx = this._indexOf(referenceElement) + 1;
-        this.items.splice(insertionIdx, 0, newElement);
-        this.tagIDs.splice(insertionIdx, 0, newElementID);
-        this.stackTop++;
-        if (insertionIdx === this.stackTop) {
-            this._updateCurrentElement();
+    /**
+     * The adoption agency's last stack step: removes the formatting element at `formattingIdx` and opens `element`
+     * directly above the furthest block at `furthestBlockIdx`. On an indexed stack, only formatting elements the agency
+     * kept are still open between them; the furthest block, with those directly below it, moves down by one slot, and
+     * `element` takes the furthest block's slot. No open element above the furthest block moves, and as all these
+     * elements are HTML elements and only the furthest block is special, the counts above it stay the same.
+     */
+    replaceFormattingElement(formattingIdx, furthestBlockIdx, element, tagID) {
+        const formattingElement = this.items[formattingIdx];
+        if (!this.indexed) {
+            this.items.splice(formattingIdx, 1);
+            this.tagIDs.splice(formattingIdx, 1);
+            this.handler.onItemPop(formattingElement, false);
+            this.items.splice(furthestBlockIdx, 0, element);
+            this.tagIDs.splice(furthestBlockIdx, 0, tagID);
+            if (furthestBlockIdx === this.stackTop)
+                this._updateCurrentElement();
+            if (this.current && this.currentTagId !== undefined) {
+                this.handler.onItemPush(this.current, this.currentTagId, furthestBlockIdx === this.stackTop);
+            }
+            return;
+        }
+        const key = this.keys[formattingIdx];
+        const belowIdx = this.below[formattingIdx];
+        const aboveIdx = this.above[furthestBlockIdx];
+        const kept = [];
+        for (let i = this.above[formattingIdx]; i !== furthestBlockIdx; i = this.above[i])
+            kept.push(i);
+        // The list keeps open formatting elements in stack order, so a kept element with the formatting element's tag
+        // would have been the formatting element: the next element with its key is above the furthest block.
+        const keyNext = this.keyNext[formattingIdx];
+        this._unindex(formattingIdx);
+        this.items[formattingIdx] = undefined;
+        this.handler.onItemPop(formattingElement, false);
+        let free = furthestBlockIdx - 1;
+        while (kept.length > 0 && kept[kept.length - 1] === free) {
+            kept.pop();
+            free--;
+        }
+        for (let i = free + 1; i <= furthestBlockIdx; i++)
+            this._move(i, i - 1);
+        const keyPrev = keyNext === -1 ? this.keyTops[key] : this.keyPrev[keyNext];
+        this.items[furthestBlockIdx] = element;
+        this.tagIDs[furthestBlockIdx] = tagID;
+        this.keys[furthestBlockIdx] = key;
+        this.keyPrev[furthestBlockIdx] = keyPrev;
+        this.keyNext[furthestBlockIdx] = keyNext;
+        if (keyPrev !== -1)
+            this.keyNext[keyPrev] = furthestBlockIdx;
+        if (keyNext === -1)
+            this.keyTops[key] = furthestBlockIdx;
+        else
+            this.keyPrev[keyNext] = furthestBlockIdx;
+        if (FORMATTING_TAGS[tagID])
+            this.formattingSlots.set(element, furthestBlockIdx);
+        let prev = belowIdx;
+        for (const i of kept) {
+            this._link(i, prev, true);
+            prev = i;
         }
+        for (let i = free; i < furthestBlockIdx; i++) {
+            this._link(i, prev, true);
+            prev = i;
+        }
+        this._link(furthestBlockIdx, prev, true);
+        if (aboveIdx === -1)
+            this._updateCurrentElement();
         if (this.current && this.currentTagId !== undefined) {
-            this.handler.onItemPush(this.current, this.currentTagId, insertionIdx === this.stackTop);
+            this.handler.onItemPush(this.current, this.currentTagId, aboveIdx === -1);
         }
     }
     popUntilTagNamePopped(tagName) {
-        let targetIdx = this.stackTop + 1;
-        do {
-            targetIdx = this.tagIDs.lastIndexOf(tagName, targetIdx - 1);
-        } while (targetIdx > 0 && this.treeAdapter.getNamespaceURI(this.items[targetIdx]) !== NS.HTML);
-        this.shortenToLength(Math.max(targetIdx, 0));
+        this.shortenToLength(Math.max(this.indexOfTopmost(tagName), 0));
     }
     shortenToLength(idx) {
         while (this.stackTop >= idx) {
             const popped = this.current;
-            if (this.tmplCount > 0 && this._isInTemplate()) {
-                this.tmplCount -= 1;
-            }
-            this.stackTop--;
-            this._updateCurrentElement();
+            this._popCurrent();
             this.handler.onItemPop(popped, this.stackTop < idx);
         }
     }
@@ -120,15 +474,11 @@ export class OpenElementStack {
         const idx = this._indexOf(element);
         this.shortenToLength(Math.max(idx, 0));
     }
-    popUntilPopped(tagNames, targetNS) {
-        const idx = this._indexOfTagNames(tagNames, targetNS);
-        this.shortenToLength(Math.max(idx, 0));
-    }
     popUntilNumberedHeaderPopped() {
-        this.popUntilPopped(NUMBERED_HEADERS, NS.HTML);
+        this.shortenToLength(Math.max(this.indexOfTopmostOf(NUMBERED_HEADERS), 0));
     }
     popUntilTableCellPopped() {
-        this.popUntilPopped(TABLE_CELLS, NS.HTML);
+        this.shortenToLength(Math.max(this.indexOfTopmostOf(TABLE_CELLS), 0));
     }
     popAllUpToHtmlElement() {
         //NOTE: here we assume that the root <html> element is always first in the open element stack, so
@@ -136,41 +486,57 @@ export class OpenElementStack {
         this.tmplCount = 0;
         this.shortenToLength(1);
     }
-    _indexOfTagNames(tagNames, namespace) {
-        for (let i = this.stackTop; i >= 0; i--) {
-            if (tagNames.has(this.tagIDs[i]) && this.treeAdapter.getNamespaceURI(this.items[i]) === namespace) {
-                return i;
-            }
-        }
-        return -1;
-    }
-    clearBackTo(tagNames, targetNS) {
-        const idx = this._indexOfTagNames(tagNames, targetNS);
-        this.shortenToLength(idx + 1);
-    }
     clearBackToTableContext() {
-        this.clearBackTo(TABLE_CONTEXT, NS.HTML);
+        this.shortenToLength(this.indexOfTopmostOf(TABLE_CONTEXT) + 1);
     }
     clearBackToTableBodyContext() {
-        this.clearBackTo(TABLE_BODY_CONTEXT, NS.HTML);
+        this.shortenToLength(this.indexOfTopmostOf(TABLE_BODY_CONTEXT) + 1);
     }
     clearBackToTableRowContext() {
-        this.clearBackTo(TABLE_ROW_CONTEXT, NS.HTML);
+        this.shortenToLength(this.indexOfTopmostOf(TABLE_ROW_CONTEXT) + 1);
     }
     remove(element) {
         const idx = this._indexOf(element);
-        if (idx >= 0) {
-            if (idx === this.stackTop) {
-                this.pop();
+        if (idx !== -1)
+            this.removeAt(idx);
+    }
+    /** Removes the open element at the slot `idx`; on an indexed stack, the elements above it keep their slots. */
+    removeAt(idx) {
+        if (idx === this.stackTop) {
+            this.pop();
+            return;
+        }
+        const element = this.items[idx];
+        this.depth--;
+        if (this.indexed) {
+            const classes = this.keys[idx] < NAME_KEYS ? KEY_CLASSES[this.keys[idx]] : 0;
+            const belowIdx = this.below[idx];
+            const aboveIdx = this.above[idx];
+            this._unindex(idx);
+            this.items[idx] = undefined;
+            this.below[aboveIdx] = belowIdx;
+            if (belowIdx !== -1)
+                this.above[belowIdx] = aboveIdx;
+            if (classes !== 0) {
+                for (let i = aboveIdx; i !== -1; i = this.above[i]) {
+                    this.specials[i] -= classes & SPECIAL;
+                    this.listItemBoundaries[i] -= (classes & LIST_ITEM_BOUNDARY) >> 1;
+                    this.scopeBoundaries[i] -= (classes & SCOPE) >> 2;
+                }
             }
-            else {
-                this.items.splice(idx, 1);
-                this.tagIDs.splice(idx, 1);
-                this.stackTop--;
-                this._updateCurrentElement();
-                this.handler.onItemPop(element, false);
+            // Foreign elements directly above an HTML element refer to it as the topmost HTML element below them.
+            const html = belowIdx === -1 ? -1 : this.htmlSlots[belowIdx];
+            for (let i = aboveIdx; i !== -1 && this.htmlSlots[i] === idx; i = this.above[i]) {
+                this.htmlSlots[i] = html;
             }
         }
+        else {
+            this.items.splice(idx, 1);
+            this.tagIDs.splice(idx, 1);
+            this.stackTop--;
+            this._updateCurrentElement();
+        }
+        this.handler.onItemPop(element, false);
     }
     //Search
     tryPeekProperlyNestedBodyElement() {
@@ -181,110 +547,89 @@ export class OpenElementStack {
         return this._indexOf(element) > -1;
     }
     getCommonAncestor(element) {
-        const elementIdx = this._indexOf(element) - 1;
-        return elementIdx >= 0 ? this.items[elementIdx] : null;
+        const idx = this._indexOf(element);
+        const belowIdx = idx === -1 ? -1 : this.slotBelow(idx);
+        return belowIdx === -1 ? null : this.items[belowIdx];
     }
     isRootHtmlElementCurrent() {
         return this.stackTop === 0 && this.tagIDs[0] === $.HTML;
     }
     //Element in scope
-    hasInDynamicScope(tagName, htmlScope) {
-        for (let i = this.stackTop; i >= 0; i--) {
-            const tn = this.tagIDs[i];
-            switch (this.treeAdapter.getNamespaceURI(this.items[i])) {
-                case NS.HTML: {
-                    if (tn === tagName)
-                        return true;
-                    if (htmlScope.has(tn))
-                        return false;
-                    break;
-                }
-                case NS.SVG: {
-                    if (SCOPING_ELEMENTS_SVG.has(tn))
-                        return false;
-                    break;
-                }
-                case NS.MATHML: {
-                    if (SCOPING_ELEMENTS_MATHML.has(tn))
-                        return false;
-                    break;
-                }
+    /**
+     * On an indexed stack: whether no element of the `scope` class is open above the slot `target`. A target that is not
+     * open is in scope only on a stack without such an element, as a scan from the top would end there.
+     */
+    _isInScope(target, scope) {
+        let boundary = -1;
+        switch (scope) {
+            case LIST_ITEM_SCOPE: {
+                boundary = Math.max(this.keyTops[$.OL], this.keyTops[$.UL]);
+                break;
+            }
+            case BUTTON_SCOPE: {
+                boundary = this.keyTops[$.BUTTON];
+                break;
+            }
+            case TABLE_SCOPE: {
+                boundary = Math.max(this.keyTops[$.TABLE], this.keyTops[$.HTML]);
+                return target === -1 ? boundary === -1 : target >= boundary;
             }
+            default:
+            // Only the scope boundaries
+        }
+        return target === -1
+            ? boundary === -1 && (this.stackTop === -1 || this.scopeBoundaries[this.stackTop] === 0)
+            : target >= boundary && this.scopeBoundaries[this.stackTop] === this.scopeBoundaries[target];
+    }
+    /**
+     * On a stack that is not indexed: whether an HTML element with the tag, or one of the tags, and if passed the element
+     * itself, is open above every element of the `scope` class; true if neither is open.
+     */
+    _scanScope(tagID, tagIDs, scope, element) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const key = tagKey(this.treeAdapter.getNamespaceURI(this.items[i]), this.tagIDs[i]);
+            if (key === -1)
+                continue;
+            if ((tagIDs ? tagIDs.includes(key) : key === tagID) && (!element || this.items[i] === element))
+                return true;
+            if (KEY_CLASSES[key] & scope)
+                return false;
         }
         return true;
     }
-    hasInScope(tagName) {
-        return this.hasInDynamicScope(tagName, SCOPING_ELEMENTS_HTML);
+    /** If `element` is passed, only that element (which has to be a `tagName` element) is looked for. */
+    hasInScope(tagName, element) {
+        if (!this.indexed)
+            return this._scanScope(tagName, null, SCOPE, element);
+        return this._isInScope(element ? this._indexOf(element) : this.keyTops[tagName], SCOPE);
     }
     hasInListItemScope(tagName) {
-        return this.hasInDynamicScope(tagName, SCOPING_ELEMENTS_HTML_LIST);
+        return this.indexed
+            ? this._isInScope(this.keyTops[tagName], LIST_ITEM_SCOPE)
+            : this._scanScope(tagName, null, LIST_ITEM_SCOPE);
     }
     hasInButtonScope(tagName) {
-        return this.hasInDynamicScope(tagName, SCOPING_ELEMENTS_HTML_BUTTON);
+        return this.indexed
+            ? this._isInScope(this.keyTops[tagName], BUTTON_SCOPE)
+            : this._scanScope(tagName, null, BUTTON_SCOPE);
     }
     hasNumberedHeaderInScope() {
-        for (let i = this.stackTop; i >= 0; i--) {
-            const tn = this.tagIDs[i];
-            switch (this.treeAdapter.getNamespaceURI(this.items[i])) {
-                case NS.HTML: {
-                    if (NUMBERED_HEADERS.has(tn))
-                        return true;
-                    if (SCOPING_ELEMENTS_HTML.has(tn))
-                        return false;
-                    break;
-                }
-                case NS.SVG: {
-                    if (SCOPING_ELEMENTS_SVG.has(tn))
-                        return false;
-                    break;
-                }
-                case NS.MATHML: {
-                    if (SCOPING_ELEMENTS_MATHML.has(tn))
-                        return false;
-                    break;
-                }
-            }
-        }
-        return true;
+        return this.indexed
+            ? this._isInScope(this.indexOfTopmostOf(NUMBERED_HEADERS), SCOPE)
+            : this._scanScope($.UNKNOWN, NUMBERED_HEADERS, SCOPE);
     }
     hasInTableScope(tagName) {
-        for (let i = this.stackTop; i >= 0; i--) {
-            if (this.treeAdapter.getNamespaceURI(this.items[i]) !== NS.HTML) {
-                continue;
-            }
-            switch (this.tagIDs[i]) {
-                case tagName: {
-                    return true;
-                }
-                case $.TABLE:
-                case $.HTML: {
-                    return false;
-                }
-            }
-        }
-        return true;
+        return this.indexed
+            ? this._isInScope(this.keyTops[tagName], TABLE_SCOPE)
+            : this._scanScope(tagName, null, TABLE_SCOPE);
     }
     hasTableBodyContextInTableScope() {
-        for (let i = this.stackTop; i >= 0; i--) {
-            if (this.treeAdapter.getNamespaceURI(this.items[i]) !== NS.HTML) {
-                continue;
-            }
-            switch (this.tagIDs[i]) {
-                case $.TBODY:
-                case $.THEAD:
-                case $.TFOOT: {
-                    return true;
-                }
-                case $.TABLE:
-                case $.HTML: {
-                    return false;
-                }
-            }
-        }
-        return true;
+        return this.indexed
+            ? this._isInScope(this.indexOfTopmostOf(TABLE_BODIES), TABLE_SCOPE)
+            : this._scanScope($.UNKNOWN, TABLE_BODIES, TABLE_SCOPE);
     }
     hasInSelectScope(tagName) {
-        for (let i = this.stackTop; i >= 0; i--) {
+        for (let i = this.stackTop; i >= 0; i = this.slotBelow(i)) {
             if (this.treeAdapter.getNamespaceURI(this.items[i]) !== NS.HTML) {
                 continue;
             }
@@ -305,19 +650,24 @@ export class OpenElementStack {
     }
     //Implied end tags
     generateImpliedEndTags() {
-        while (this.currentTagId !== undefined && IMPLICIT_END_TAG_REQUIRED.has(this.currentTagId)) {
+        while (this.currentTagId !== undefined &&
+            IMPLICIT_END_TAG_REQUIRED.has(this.currentTagId) &&
+            this.treeAdapter.getNamespaceURI(this.current) === NS.HTML) {
             this.pop();
         }
     }
     generateImpliedEndTagsThoroughly() {
-        while (this.currentTagId !== undefined && IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) {
+        while (this.currentTagId !== undefined &&
+            IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId) &&
+            this.treeAdapter.getNamespaceURI(this.current) === NS.HTML) {
             this.pop();
         }
     }
     generateImpliedEndTagsWithExclusion(exclusionId) {
         while (this.currentTagId !== undefined &&
             this.currentTagId !== exclusionId &&
-            IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) {
+            IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId) &&
+            this.treeAdapter.getNamespaceURI(this.current) === NS.HTML) {
             this.pop();
         }
     }