Initial

resources/app/node_modules/parse5/dist/cjs/parser/formatting-element-list.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormattingElementList = exports.EntryType = void 0;
+//Const
+const NOAH_ARK_CAPACITY = 3;
+var EntryType;
+(function (EntryType) {
+    EntryType[EntryType["Marker"] = 0] = "Marker";
+    EntryType[EntryType["Element"] = 1] = "Element";
+})(EntryType = exports.EntryType || (exports.EntryType = {}));
+const MARKER = { type: EntryType.Marker };
+//List of formatting elements
+class FormattingElementList {
+    constructor(treeAdapter) {
+        this.treeAdapter = treeAdapter;
+        this.entries = [];
+        this.bookmark = null;
+    }
+    //Noah Ark's condition
+    //OPTIMIZATION: at first we try to find possible candidates for exclusion using
+    //lightweight heuristics without thorough attributes check.
+    _getNoahArkConditionCandidates(newElement, neAttrs) {
+        const candidates = [];
+        const neAttrsLength = neAttrs.length;
+        const neTagName = this.treeAdapter.getTagName(newElement);
+        const neNamespaceURI = this.treeAdapter.getNamespaceURI(newElement);
+        for (let i = 0; i < this.entries.length; i++) {
+            const entry = this.entries[i];
+            if (entry.type === EntryType.Marker) {
+                break;
+            }
+            const { element } = entry;
+            if (this.treeAdapter.getTagName(element) === neTagName &&
+                this.treeAdapter.getNamespaceURI(element) === neNamespaceURI) {
+                const elementAttrs = this.treeAdapter.getAttrList(element);
+                if (elementAttrs.length === neAttrsLength) {
+                    candidates.push({ idx: i, attrs: elementAttrs });
+                }
+            }
+        }
+        return candidates;
+    }
+    _ensureNoahArkCondition(newElement) {
+        if (this.entries.length < NOAH_ARK_CAPACITY)
+            return;
+        const neAttrs = this.treeAdapter.getAttrList(newElement);
+        const candidates = this._getNoahArkConditionCandidates(newElement, neAttrs);
+        if (candidates.length < NOAH_ARK_CAPACITY)
+            return;
+        //NOTE: build attrs map for the new element, so we can perform fast lookups
+        const neAttrsMap = new Map(neAttrs.map((neAttr) => [neAttr.name, neAttr.value]));
+        let validCandidates = 0;
+        //NOTE: remove bottommost candidates, until Noah's Ark condition will not be met
+        for (let i = 0; i < candidates.length; i++) {
+            const candidate = candidates[i];
+            // We know that `candidate.attrs.length === neAttrs.length`
+            if (candidate.attrs.every((cAttr) => neAttrsMap.get(cAttr.name) === cAttr.value)) {
+                validCandidates += 1;
+                if (validCandidates >= NOAH_ARK_CAPACITY) {
+                    this.entries.splice(candidate.idx, 1);
+                }
+            }
+        }
+    }
+    //Mutations
+    insertMarker() {
+        this.entries.unshift(MARKER);
+    }
+    pushElement(element, token) {
+        this._ensureNoahArkCondition(element);
+        this.entries.unshift({
+            type: EntryType.Element,
+            element,
+            token,
+        });
+    }
+    insertElementAfterBookmark(element, token) {
+        const bookmarkIdx = this.entries.indexOf(this.bookmark);
+        this.entries.splice(bookmarkIdx, 0, {
+            type: EntryType.Element,
+            element,
+            token,
+        });
+    }
+    removeEntry(entry) {
+        const entryIndex = this.entries.indexOf(entry);
+        if (entryIndex >= 0) {
+            this.entries.splice(entryIndex, 1);
+        }
+    }
+    /**
+     * Clears the list of formatting elements up to the last marker.
+     *
+     * @see https://html.spec.whatwg.org/multipage/parsing.html#clear-the-list-of-active-formatting-elements-up-to-the-last-marker
+     */
+    clearToLastMarker() {
+        const markerIdx = this.entries.indexOf(MARKER);
+        if (markerIdx >= 0) {
+            this.entries.splice(0, markerIdx + 1);
+        }
+        else {
+            this.entries.length = 0;
+        }
+    }
+    //Search
+    getElementEntryInScopeWithTagName(tagName) {
+        const entry = this.entries.find((entry) => entry.type === EntryType.Marker || this.treeAdapter.getTagName(entry.element) === tagName);
+        return entry && entry.type === EntryType.Element ? entry : null;
+    }
+    getElementEntry(element) {
+        return this.entries.find((entry) => entry.type === EntryType.Element && entry.element === element);
+    }
+}
+exports.FormattingElementList = FormattingElementList;
+//# sourceMappingURL=formatting-element-list.js.map

resources/app/node_modules/parse5/dist/cjs/parser/open-element-stack.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenElementStack = void 0;
+const html_js_1 = require("../common/html.js");
+//Element utils
+const IMPLICIT_END_TAG_REQUIRED = new Set([html_js_1.TAG_ID.DD, html_js_1.TAG_ID.DT, html_js_1.TAG_ID.LI, html_js_1.TAG_ID.OPTGROUP, html_js_1.TAG_ID.OPTION, html_js_1.TAG_ID.P, html_js_1.TAG_ID.RB, html_js_1.TAG_ID.RP, html_js_1.TAG_ID.RT, html_js_1.TAG_ID.RTC]);
+const IMPLICIT_END_TAG_REQUIRED_THOROUGHLY = new Set([
+    ...IMPLICIT_END_TAG_REQUIRED,
+    html_js_1.TAG_ID.CAPTION,
+    html_js_1.TAG_ID.COLGROUP,
+    html_js_1.TAG_ID.TBODY,
+    html_js_1.TAG_ID.TD,
+    html_js_1.TAG_ID.TFOOT,
+    html_js_1.TAG_ID.TH,
+    html_js_1.TAG_ID.THEAD,
+    html_js_1.TAG_ID.TR,
+]);
+const SCOPING_ELEMENT_NS = new Map([
+    [html_js_1.TAG_ID.APPLET, html_js_1.NS.HTML],
+    [html_js_1.TAG_ID.CAPTION, html_js_1.NS.HTML],
+    [html_js_1.TAG_ID.HTML, html_js_1.NS.HTML],
+    [html_js_1.TAG_ID.MARQUEE, html_js_1.NS.HTML],
+    [html_js_1.TAG_ID.OBJECT, html_js_1.NS.HTML],
+    [html_js_1.TAG_ID.TABLE, html_js_1.NS.HTML],
+    [html_js_1.TAG_ID.TD, html_js_1.NS.HTML],
+    [html_js_1.TAG_ID.TEMPLATE, html_js_1.NS.HTML],
+    [html_js_1.TAG_ID.TH, html_js_1.NS.HTML],
+    [html_js_1.TAG_ID.ANNOTATION_XML, html_js_1.NS.MATHML],
+    [html_js_1.TAG_ID.MI, html_js_1.NS.MATHML],
+    [html_js_1.TAG_ID.MN, html_js_1.NS.MATHML],
+    [html_js_1.TAG_ID.MO, html_js_1.NS.MATHML],
+    [html_js_1.TAG_ID.MS, html_js_1.NS.MATHML],
+    [html_js_1.TAG_ID.MTEXT, html_js_1.NS.MATHML],
+    [html_js_1.TAG_ID.DESC, html_js_1.NS.SVG],
+    [html_js_1.TAG_ID.FOREIGN_OBJECT, html_js_1.NS.SVG],
+    [html_js_1.TAG_ID.TITLE, html_js_1.NS.SVG],
+]);
+const NAMED_HEADERS = [html_js_1.TAG_ID.H1, html_js_1.TAG_ID.H2, html_js_1.TAG_ID.H3, html_js_1.TAG_ID.H4, html_js_1.TAG_ID.H5, html_js_1.TAG_ID.H6];
+const TABLE_ROW_CONTEXT = [html_js_1.TAG_ID.TR, html_js_1.TAG_ID.TEMPLATE, html_js_1.TAG_ID.HTML];
+const TABLE_BODY_CONTEXT = [html_js_1.TAG_ID.TBODY, html_js_1.TAG_ID.TFOOT, html_js_1.TAG_ID.THEAD, html_js_1.TAG_ID.TEMPLATE, html_js_1.TAG_ID.HTML];
+const TABLE_CONTEXT = [html_js_1.TAG_ID.TABLE, html_js_1.TAG_ID.TEMPLATE, html_js_1.TAG_ID.HTML];
+const TABLE_CELLS = [html_js_1.TAG_ID.TD, html_js_1.TAG_ID.TH];
+//Stack of open elements
+class OpenElementStack {
+    get currentTmplContentOrNode() {
+        return this._isInTemplate() ? this.treeAdapter.getTemplateContent(this.current) : this.current;
+    }
+    constructor(document, treeAdapter, handler) {
+        this.treeAdapter = treeAdapter;
+        this.handler = handler;
+        this.items = [];
+        this.tagIDs = [];
+        this.stackTop = -1;
+        this.tmplCount = 0;
+        this.currentTagId = html_js_1.TAG_ID.UNKNOWN;
+        this.current = document;
+    }
+    //Index of element
+    _indexOf(element) {
+        return this.items.lastIndexOf(element, this.stackTop);
+    }
+    //Update current element
+    _isInTemplate() {
+        return this.currentTagId === html_js_1.TAG_ID.TEMPLATE && this.treeAdapter.getNamespaceURI(this.current) === html_js_1.NS.HTML;
+    }
+    _updateCurrentElement() {
+        this.current = this.items[this.stackTop];
+        this.currentTagId = this.tagIDs[this.stackTop];
+    }
+    //Mutations
+    push(element, tagID) {
+        this.stackTop++;
+        this.items[this.stackTop] = element;
+        this.current = element;
+        this.tagIDs[this.stackTop] = tagID;
+        this.currentTagId = tagID;
+        if (this._isInTemplate()) {
+            this.tmplCount++;
+        }
+        this.handler.onItemPush(element, tagID, true);
+    }
+    pop() {
+        const popped = this.current;
+        if (this.tmplCount > 0 && this._isInTemplate()) {
+            this.tmplCount--;
+        }
+        this.stackTop--;
+        this._updateCurrentElement();
+        this.handler.onItemPop(popped, true);
+    }
+    replace(oldElement, newElement) {
+        const idx = this._indexOf(oldElement);
+        this.items[idx] = newElement;
+        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();
+        }
+        this.handler.onItemPush(this.current, this.currentTagId, insertionIdx === this.stackTop);
+    }
+    popUntilTagNamePopped(tagName) {
+        let targetIdx = this.stackTop + 1;
+        do {
+            targetIdx = this.tagIDs.lastIndexOf(tagName, targetIdx - 1);
+        } while (targetIdx > 0 && this.treeAdapter.getNamespaceURI(this.items[targetIdx]) !== html_js_1.NS.HTML);
+        this.shortenToLength(targetIdx < 0 ? 0 : targetIdx);
+    }
+    shortenToLength(idx) {
+        while (this.stackTop >= idx) {
+            const popped = this.current;
+            if (this.tmplCount > 0 && this._isInTemplate()) {
+                this.tmplCount -= 1;
+            }
+            this.stackTop--;
+            this._updateCurrentElement();
+            this.handler.onItemPop(popped, this.stackTop < idx);
+        }
+    }
+    popUntilElementPopped(element) {
+        const idx = this._indexOf(element);
+        this.shortenToLength(idx < 0 ? 0 : idx);
+    }
+    popUntilPopped(tagNames, targetNS) {
+        const idx = this._indexOfTagNames(tagNames, targetNS);
+        this.shortenToLength(idx < 0 ? 0 : idx);
+    }
+    popUntilNumberedHeaderPopped() {
+        this.popUntilPopped(NAMED_HEADERS, html_js_1.NS.HTML);
+    }
+    popUntilTableCellPopped() {
+        this.popUntilPopped(TABLE_CELLS, html_js_1.NS.HTML);
+    }
+    popAllUpToHtmlElement() {
+        //NOTE: here we assume that the root <html> element is always first in the open element stack, so
+        //we perform this fast stack clean up.
+        this.tmplCount = 0;
+        this.shortenToLength(1);
+    }
+    _indexOfTagNames(tagNames, namespace) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            if (tagNames.includes(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, html_js_1.NS.HTML);
+    }
+    clearBackToTableBodyContext() {
+        this.clearBackTo(TABLE_BODY_CONTEXT, html_js_1.NS.HTML);
+    }
+    clearBackToTableRowContext() {
+        this.clearBackTo(TABLE_ROW_CONTEXT, html_js_1.NS.HTML);
+    }
+    remove(element) {
+        const idx = this._indexOf(element);
+        if (idx >= 0) {
+            if (idx === this.stackTop) {
+                this.pop();
+            }
+            else {
+                this.items.splice(idx, 1);
+                this.tagIDs.splice(idx, 1);
+                this.stackTop--;
+                this._updateCurrentElement();
+                this.handler.onItemPop(element, false);
+            }
+        }
+    }
+    //Search
+    tryPeekProperlyNestedBodyElement() {
+        //Properly nested <body> element (should be second element in stack).
+        return this.stackTop >= 1 && this.tagIDs[1] === html_js_1.TAG_ID.BODY ? this.items[1] : null;
+    }
+    contains(element) {
+        return this._indexOf(element) > -1;
+    }
+    getCommonAncestor(element) {
+        const elementIdx = this._indexOf(element) - 1;
+        return elementIdx >= 0 ? this.items[elementIdx] : null;
+    }
+    isRootHtmlElementCurrent() {
+        return this.stackTop === 0 && this.tagIDs[0] === html_js_1.TAG_ID.HTML;
+    }
+    //Element in scope
+    hasInScope(tagName) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
+            if (tn === tagName && ns === html_js_1.NS.HTML) {
+                return true;
+            }
+            if (SCOPING_ELEMENT_NS.get(tn) === ns) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasNumberedHeaderInScope() {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
+            if ((0, html_js_1.isNumberedHeader)(tn) && ns === html_js_1.NS.HTML) {
+                return true;
+            }
+            if (SCOPING_ELEMENT_NS.get(tn) === ns) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasInListItemScope(tagName) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
+            if (tn === tagName && ns === html_js_1.NS.HTML) {
+                return true;
+            }
+            if (((tn === html_js_1.TAG_ID.UL || tn === html_js_1.TAG_ID.OL) && ns === html_js_1.NS.HTML) || SCOPING_ELEMENT_NS.get(tn) === ns) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasInButtonScope(tagName) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
+            if (tn === tagName && ns === html_js_1.NS.HTML) {
+                return true;
+            }
+            if ((tn === html_js_1.TAG_ID.BUTTON && ns === html_js_1.NS.HTML) || SCOPING_ELEMENT_NS.get(tn) === ns) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasInTableScope(tagName) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
+            if (ns !== html_js_1.NS.HTML) {
+                continue;
+            }
+            if (tn === tagName) {
+                return true;
+            }
+            if (tn === html_js_1.TAG_ID.TABLE || tn === html_js_1.TAG_ID.TEMPLATE || tn === html_js_1.TAG_ID.HTML) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasTableBodyContextInTableScope() {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
+            if (ns !== html_js_1.NS.HTML) {
+                continue;
+            }
+            if (tn === html_js_1.TAG_ID.TBODY || tn === html_js_1.TAG_ID.THEAD || tn === html_js_1.TAG_ID.TFOOT) {
+                return true;
+            }
+            if (tn === html_js_1.TAG_ID.TABLE || tn === html_js_1.TAG_ID.HTML) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasInSelectScope(tagName) {
+        for (let i = this.stackTop; i >= 0; i--) {
+            const tn = this.tagIDs[i];
+            const ns = this.treeAdapter.getNamespaceURI(this.items[i]);
+            if (ns !== html_js_1.NS.HTML) {
+                continue;
+            }
+            if (tn === tagName) {
+                return true;
+            }
+            if (tn !== html_js_1.TAG_ID.OPTION && tn !== html_js_1.TAG_ID.OPTGROUP) {
+                return false;
+            }
+        }
+        return true;
+    }
+    //Implied end tags
+    generateImpliedEndTags() {
+        while (IMPLICIT_END_TAG_REQUIRED.has(this.currentTagId)) {
+            this.pop();
+        }
+    }
+    generateImpliedEndTagsThoroughly() {
+        while (IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) {
+            this.pop();
+        }
+    }
+    generateImpliedEndTagsWithExclusion(exclusionId) {
+        while (this.currentTagId !== exclusionId && IMPLICIT_END_TAG_REQUIRED_THOROUGHLY.has(this.currentTagId)) {
+            this.pop();
+        }
+    }
+}
+exports.OpenElementStack = OpenElementStack;
+//# sourceMappingURL=open-element-stack.js.map