recker 1.0.43 → 1.0.44

package/dist/scrape/parser/nodes/html.js

@@ -0,0 +1,978 @@
+import { selectAll, selectOne } from 'css-select';
+import he from 'he';
+import arr_back from '../back.js';
+import Matcher from '../matcher.js';
+import VoidTag from '../void-tag.js';
+import CommentNode from './comment.js';
+import Node from './node.js';
+import TextNode from './text.js';
+import NodeType from './type.js';
+function decode(val) {
+    return JSON.parse(JSON.stringify(he.decode(val)));
+}
+const Htags = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hgroup'];
+const Dtags = ['details', 'dialog', 'dd', 'div', 'dt'];
+const Ftags = ['fieldset', 'figcaption', 'figure', 'footer', 'form'];
+const tableTags = ['table', 'td', 'tr'];
+const htmlTags = [
+    'address',
+    'article',
+    'aside',
+    'blockquote',
+    'br',
+    'hr',
+    'li',
+    'main',
+    'nav',
+    'ol',
+    'p',
+    'pre',
+    'section',
+    'ul',
+];
+const kBlockElements = new Set();
+function addToKBlockElement(...args) {
+    const addToSet = (array) => {
+        for (let index = 0; index < array.length; index++) {
+            const element = array[index];
+            kBlockElements.add(element);
+            kBlockElements.add(element.toUpperCase());
+        }
+    };
+    for (const arg of args)
+        addToSet(arg);
+}
+addToKBlockElement(Htags, Dtags, Ftags, tableTags, htmlTags);
+class DOMTokenList {
+    _set;
+    _afterUpdate;
+    _validate(c) {
+        if (/\s/.test(c)) {
+            throw new Error(`DOMException in DOMTokenList.add: The token '${c}' contains HTML space characters, which are not valid in tokens.`);
+        }
+    }
+    constructor(valuesInit = [], afterUpdate = () => null) {
+        this._set = new Set(valuesInit);
+        this._afterUpdate = afterUpdate;
+    }
+    add(c) {
+        this._validate(c);
+        this._set.add(c);
+        this._afterUpdate(this);
+    }
+    replace(c1, c2) {
+        this._validate(c2);
+        this._set.delete(c1);
+        this._set.add(c2);
+        this._afterUpdate(this);
+    }
+    remove(c) {
+        this._set.delete(c) && this._afterUpdate(this);
+    }
+    toggle(c) {
+        this._validate(c);
+        if (this._set.has(c))
+            this._set.delete(c);
+        else
+            this._set.add(c);
+        this._afterUpdate(this);
+    }
+    contains(c) {
+        return this._set.has(c);
+    }
+    get length() {
+        return this._set.size;
+    }
+    values() {
+        return this._set.values();
+    }
+    get value() {
+        return Array.from(this._set.values());
+    }
+    toString() {
+        return Array.from(this._set.values()).join(' ');
+    }
+}
+export default class HTMLElement extends Node {
+    rawAttrs;
+    voidTag;
+    _attrs;
+    _rawAttrs;
+    _parseOptions;
+    rawTagName;
+    id;
+    classList;
+    nodeType = NodeType.ELEMENT_NODE;
+    quoteAttribute(attr) {
+        if (attr == null) {
+            return 'null';
+        }
+        return JSON.stringify(attr.replace(/"/g, '&quot;'))
+            .replace(/\\t/g, '\t')
+            .replace(/\\n/g, '\n')
+            .replace(/\\r/g, '\r')
+            .replace(/\\/g, '');
+    }
+    constructor(tagName, keyAttrs, rawAttrs = '', parentNode = null, range, voidTag = new VoidTag(), _parseOptions = {}) {
+        super(parentNode, range);
+        this.rawAttrs = rawAttrs;
+        this.voidTag = voidTag;
+        this.rawTagName = tagName;
+        this.rawAttrs = rawAttrs || '';
+        this.id = keyAttrs.id || '';
+        this.childNodes = [];
+        this._parseOptions = _parseOptions;
+        this.classList = new DOMTokenList(keyAttrs.class ? keyAttrs.class.split(/\s+/) : [], (classList) => this.setAttribute('class', classList.toString()));
+        if (keyAttrs.id) {
+            if (!rawAttrs) {
+                this.rawAttrs = `id="${keyAttrs.id}"`;
+            }
+        }
+        if (keyAttrs.class) {
+            if (!rawAttrs) {
+                const cls = `class="${this.classList.toString()}"`;
+                if (this.rawAttrs) {
+                    this.rawAttrs += ` ${cls}`;
+                }
+                else {
+                    this.rawAttrs = cls;
+                }
+            }
+        }
+    }
+    removeChild(node) {
+        this.childNodes = this.childNodes.filter((child) => {
+            return child !== node;
+        });
+        return this;
+    }
+    exchangeChild(oldNode, newNode) {
+        const children = this.childNodes;
+        this.childNodes = children.map((child) => {
+            if (child === oldNode) {
+                return newNode;
+            }
+            return child;
+        });
+        return this;
+    }
+    get tagName() {
+        return this.rawTagName ? this.rawTagName.toUpperCase() : this.rawTagName;
+    }
+    set tagName(newname) {
+        this.rawTagName = newname.toLowerCase();
+    }
+    get localName() {
+        return this.rawTagName.toLowerCase();
+    }
+    get isVoidElement() {
+        return this.voidTag.isVoidElement(this.localName);
+    }
+    get rawText() {
+        if (/^br$/i.test(this.rawTagName)) {
+            return '\n';
+        }
+        return this.childNodes.reduce((pre, cur) => {
+            return (pre += cur.rawText);
+        }, '');
+    }
+    get textContent() {
+        return decode(this.rawText);
+    }
+    set textContent(val) {
+        const content = [new TextNode(val, this)];
+        this.childNodes = content;
+    }
+    get text() {
+        return decode(this.rawText);
+    }
+    get structuredText() {
+        let currentBlock = [];
+        const blocks = [currentBlock];
+        function dfs(node) {
+            if (node.nodeType === NodeType.ELEMENT_NODE) {
+                if (kBlockElements.has(node.rawTagName)) {
+                    if (currentBlock.length > 0) {
+                        blocks.push((currentBlock = []));
+                    }
+                    node.childNodes.forEach(dfs);
+                    if (currentBlock.length > 0) {
+                        blocks.push((currentBlock = []));
+                    }
+                }
+                else {
+                    node.childNodes.forEach(dfs);
+                }
+            }
+            else if (node.nodeType === NodeType.TEXT_NODE) {
+                if (node.isWhitespace) {
+                    currentBlock.prependWhitespace = true;
+                }
+                else {
+                    let text = node.trimmedText;
+                    if (currentBlock.prependWhitespace) {
+                        text = ` ${text}`;
+                        currentBlock.prependWhitespace = false;
+                    }
+                    currentBlock.push(text);
+                }
+            }
+        }
+        dfs(this);
+        return blocks
+            .map((block) => {
+            return block.join('').replace(/\s{2,}/g, ' ');
+        })
+            .join('\n')
+            .replace(/\s+$/, '');
+    }
+    toString() {
+        const tag = this.rawTagName;
+        if (tag) {
+            const attrs = this.rawAttrs ? ` ${this.rawAttrs}` : '';
+            return this.voidTag.formatNode(tag, attrs, this.innerHTML);
+        }
+        return this.innerHTML;
+    }
+    get innerHTML() {
+        return this.childNodes
+            .map((child) => {
+            return child.toString();
+        })
+            .join('');
+    }
+    set innerHTML(content) {
+        const r = parse(content, this._parseOptions);
+        const nodes = r.childNodes.length
+            ? r.childNodes
+            : [new TextNode(content, this)];
+        resetParent(nodes, this);
+        resetParent(this.childNodes, null);
+        this.childNodes = nodes;
+    }
+    set_content(content, options = {}) {
+        if (content instanceof Node) {
+            content = [content];
+        }
+        else if (typeof content == 'string') {
+            options = { ...this._parseOptions, ...options };
+            const r = parse(content, options);
+            content = r.childNodes.length
+                ? r.childNodes
+                : [new TextNode(r.innerHTML, this)];
+        }
+        resetParent(this.childNodes, null);
+        resetParent(content, this);
+        this.childNodes = content;
+        return this;
+    }
+    replaceWith(...nodes) {
+        const parent = this.parentNode;
+        if (!parent)
+            return this;
+        const content = nodes
+            .map((node) => {
+            if (node instanceof Node) {
+                return [node];
+            }
+            else if (typeof node == 'string') {
+                const r = parse(node, this._parseOptions);
+                return r.childNodes.length
+                    ? r.childNodes
+                    : [new TextNode(node, this)];
+            }
+            return [];
+        })
+            .flat();
+        const idx = parent.childNodes.findIndex((child) => {
+            return child === this;
+        });
+        resetParent([this], null);
+        parent.childNodes = [
+            ...parent.childNodes.slice(0, idx),
+            ...resetParent(content, parent),
+            ...parent.childNodes.slice(idx + 1),
+        ];
+        return this;
+    }
+    get outerHTML() {
+        return this.toString();
+    }
+    trimRight(pattern) {
+        for (let i = 0; i < this.childNodes.length; i++) {
+            const childNode = this.childNodes[i];
+            if (childNode.nodeType === NodeType.ELEMENT_NODE) {
+                childNode.trimRight(pattern);
+            }
+            else {
+                const index = childNode.rawText.search(pattern);
+                if (index > -1) {
+                    childNode.rawText = childNode.rawText.substr(0, index);
+                    this.childNodes.length = i + 1;
+                }
+            }
+        }
+        return this;
+    }
+    get structure() {
+        const res = [];
+        let indention = 0;
+        function write(str) {
+            res.push('  '.repeat(indention) + str);
+        }
+        function dfs(node) {
+            const idStr = node.id ? `#${node.id}` : '';
+            const classStr = node.classList.length
+                ? `.${node.classList.value.join('.')}`
+                : '';
+            write(`${node.rawTagName}${idStr}${classStr}`);
+            indention++;
+            node.childNodes.forEach((childNode) => {
+                if (childNode.nodeType === NodeType.ELEMENT_NODE) {
+                    dfs(childNode);
+                }
+                else if (childNode.nodeType === NodeType.TEXT_NODE) {
+                    if (!childNode.isWhitespace) {
+                        write('#text');
+                    }
+                }
+            });
+            indention--;
+        }
+        dfs(this);
+        return res.join('\n');
+    }
+    removeWhitespace() {
+        let o = 0;
+        this.childNodes.forEach((node) => {
+            if (node.nodeType === NodeType.TEXT_NODE) {
+                if (node.isWhitespace) {
+                    return;
+                }
+                node.rawText = node.trimmedRawText;
+            }
+            else if (node.nodeType === NodeType.ELEMENT_NODE) {
+                node.removeWhitespace();
+            }
+            this.childNodes[o++] = node;
+        });
+        this.childNodes.length = o;
+        const attrs = Object.keys(this.rawAttributes)
+            .map((key) => {
+            const val = this.rawAttributes[key];
+            return `${key}=${JSON.stringify(val)}`;
+        })
+            .join(' ');
+        this.rawAttrs = attrs;
+        delete this._rawAttrs;
+        return this;
+    }
+    querySelectorAll(selector) {
+        return selectAll(selector, this, {
+            xmlMode: false,
+            adapter: Matcher,
+        });
+    }
+    querySelector(selector) {
+        return selectOne(selector, this, {
+            xmlMode: false,
+            adapter: Matcher,
+        });
+    }
+    getElementsByTagName(tagName) {
+        const upperCasedTagName = tagName.toUpperCase();
+        const re = [];
+        const stack = [];
+        let currentNodeReference = this;
+        let index = 0;
+        while (index !== undefined && currentNodeReference) {
+            let child;
+            do {
+                child = currentNodeReference.childNodes[index++];
+            } while (index < currentNodeReference.childNodes.length &&
+                child === undefined);
+            if (child === undefined) {
+                currentNodeReference = currentNodeReference.parentNode;
+                index = stack.pop();
+                continue;
+            }
+            if (child.nodeType === NodeType.ELEMENT_NODE) {
+                if (tagName === '*' || child.tagName === upperCasedTagName)
+                    re.push(child);
+                if (child.childNodes.length > 0) {
+                    stack.push(index);
+                    currentNodeReference = child;
+                    index = 0;
+                }
+            }
+        }
+        return re;
+    }
+    getElementById(id) {
+        const stack = [];
+        let currentNodeReference = this;
+        let index = 0;
+        while (index !== undefined && currentNodeReference) {
+            let child;
+            do {
+                child = currentNodeReference.childNodes[index++];
+            } while (index < currentNodeReference.childNodes.length &&
+                child === undefined);
+            if (child === undefined) {
+                currentNodeReference = currentNodeReference.parentNode;
+                index = stack.pop();
+                continue;
+            }
+            if (child.nodeType === NodeType.ELEMENT_NODE) {
+                if (child.id === id) {
+                    return child;
+                }
+                if (child.childNodes.length > 0) {
+                    stack.push(index);
+                    currentNodeReference = child;
+                    index = 0;
+                }
+            }
+        }
+        return null;
+    }
+    closest(selector) {
+        const mapChild = new Map();
+        let el = this;
+        let old = null;
+        function findOne(test, elems) {
+            let elem = null;
+            for (let i = 0, l = elems.length; i < l && !elem; i++) {
+                const el = elems[i];
+                if (test(el)) {
+                    elem = el;
+                }
+                else {
+                    const child = mapChild.get(el);
+                    if (child) {
+                        elem = findOne(test, [child]);
+                    }
+                }
+            }
+            return elem;
+        }
+        while (el) {
+            if (old)
+                mapChild.set(el, old);
+            old = el;
+            el = el.parentNode;
+        }
+        el = this;
+        while (el) {
+            const e = selectOne(selector, el, {
+                xmlMode: true,
+                adapter: {
+                    ...Matcher,
+                    getChildren(node) {
+                        const child = mapChild.get(node);
+                        return child ? [child] : [];
+                    },
+                    getSiblings(node) {
+                        return [node];
+                    },
+                },
+            });
+            if (e) {
+                return e;
+            }
+            el = el.parentNode;
+        }
+        return null;
+    }
+    appendChild(node) {
+        this.append(node);
+        return node;
+    }
+    get attrs() {
+        if (this._attrs) {
+            return this._attrs;
+        }
+        this._attrs = {};
+        const attrs = this.rawAttributes;
+        for (const key in attrs) {
+            const val = attrs[key] || '';
+            this._attrs[key.toLowerCase()] = decode(val);
+        }
+        return this._attrs;
+    }
+    get attributes() {
+        const ret_attrs = {};
+        const attrs = this.rawAttributes;
+        for (const key in attrs) {
+            const val = attrs[key] || '';
+            ret_attrs[key] = decode(val);
+        }
+        return ret_attrs;
+    }
+    get rawAttributes() {
+        if (this._rawAttrs) {
+            return this._rawAttrs;
+        }
+        const attrs = {};
+        if (this.rawAttrs) {
+            const re = /([a-zA-Z()[\]#@$.?:][a-zA-Z0-9-._:()[\]#]*)(?:\s*=\s*((?:'[^']*')|(?:"[^"]*")|\S+))?/g;
+            let match;
+            while ((match = re.exec(this.rawAttrs))) {
+                const key = match[1];
+                let val = match[2] || null;
+                if (val && (val[0] === `'` || val[0] === `"`))
+                    val = val.slice(1, val.length - 1);
+                attrs[key] = attrs[key] || val || '';
+            }
+        }
+        this._rawAttrs = attrs;
+        return attrs;
+    }
+    removeAttribute(key) {
+        const attrs = this.rawAttributes;
+        delete attrs[key];
+        if (this._attrs) {
+            delete this._attrs[key];
+        }
+        this.rawAttrs = Object.keys(attrs)
+            .map((name) => {
+            const val = this.quoteAttribute(attrs[name]);
+            if (val === 'null' || val === '""')
+                return name;
+            return `${name}=${val}`;
+        })
+            .join(' ');
+        if (key === 'id') {
+            this.id = '';
+        }
+        return this;
+    }
+    hasAttribute(key) {
+        return key.toLowerCase() in this.attrs;
+    }
+    getAttribute(key) {
+        return this.attrs[key.toLowerCase()];
+    }
+    setAttribute(key, value) {
+        if (arguments.length < 2) {
+            throw new Error("Failed to execute 'setAttribute' on 'Element'");
+        }
+        const k2 = key.toLowerCase();
+        const attrs = this.rawAttributes;
+        for (const k in attrs) {
+            if (k.toLowerCase() === k2) {
+                key = k;
+                break;
+            }
+        }
+        attrs[key] = String(value);
+        if (this._attrs) {
+            this._attrs[k2] = decode(attrs[key]);
+        }
+        this.rawAttrs = Object.keys(attrs)
+            .map((name) => {
+            const val = this.quoteAttribute(attrs[name]);
+            if (val === 'null' || val === '""')
+                return name;
+            return `${name}=${val}`;
+        })
+            .join(' ');
+        if (key === 'id') {
+            this.id = value;
+        }
+        return this;
+    }
+    setAttributes(attributes) {
+        if (this._attrs) {
+            delete this._attrs;
+        }
+        if (this._rawAttrs) {
+            delete this._rawAttrs;
+        }
+        this.rawAttrs = Object.keys(attributes)
+            .map((name) => {
+            const val = attributes[name];
+            if (val === 'null' || val === '""')
+                return name;
+            return `${name}=${this.quoteAttribute(String(val))}`;
+        })
+            .join(' ');
+        return this;
+    }
+    insertAdjacentHTML(where, html) {
+        if (arguments.length < 2) {
+            throw new Error('2 arguments required');
+        }
+        const p = parse(html, this._parseOptions);
+        if (where === 'afterend') {
+            this.after(...p.childNodes);
+        }
+        else if (where === 'afterbegin') {
+            this.prepend(...p.childNodes);
+        }
+        else if (where === 'beforeend') {
+            this.append(...p.childNodes);
+        }
+        else if (where === 'beforebegin') {
+            this.before(...p.childNodes);
+        }
+        else {
+            throw new Error(`The value provided ('${where}') is not one of 'beforebegin', 'afterbegin', 'beforeend', or 'afterend'`);
+        }
+        return this;
+    }
+    prepend(...insertable) {
+        const nodes = resolveInsertable(insertable, this._parseOptions);
+        resetParent(nodes, this);
+        this.childNodes.unshift(...nodes);
+    }
+    append(...insertable) {
+        const nodes = resolveInsertable(insertable, this._parseOptions);
+        resetParent(nodes, this);
+        this.childNodes.push(...nodes);
+    }
+    before(...insertable) {
+        if (!this.parentNode)
+            return;
+        const nodes = resolveInsertable(insertable, this.parentNode._parseOptions);
+        const siblings = this.parentNode.childNodes;
+        resetParent(nodes, this.parentNode);
+        siblings.splice(siblings.indexOf(this), 0, ...nodes);
+    }
+    after(...insertable) {
+        if (!this.parentNode)
+            return;
+        const nodes = resolveInsertable(insertable, this.parentNode._parseOptions);
+        const siblings = this.parentNode.childNodes;
+        resetParent(nodes, this.parentNode);
+        siblings.splice(siblings.indexOf(this) + 1, 0, ...nodes);
+    }
+    get nextSibling() {
+        if (this.parentNode) {
+            const children = this.parentNode.childNodes;
+            let i = 0;
+            while (i < children.length) {
+                const child = children[i++];
+                if (this === child)
+                    return children[i] || null;
+            }
+        }
+        return null;
+    }
+    get nextElementSibling() {
+        if (this.parentNode) {
+            const children = this.parentNode.childNodes;
+            let i = 0;
+            let find = false;
+            while (i < children.length) {
+                const child = children[i++];
+                if (find) {
+                    if (child instanceof HTMLElement) {
+                        return child || null;
+                    }
+                }
+                else if (this === child) {
+                    find = true;
+                }
+            }
+        }
+        return null;
+    }
+    get previousSibling() {
+        if (this.parentNode) {
+            const children = this.parentNode.childNodes;
+            let i = children.length;
+            while (i > 0) {
+                const child = children[--i];
+                if (this === child)
+                    return children[i - 1] || null;
+            }
+        }
+        return null;
+    }
+    get previousElementSibling() {
+        if (this.parentNode) {
+            const children = this.parentNode.childNodes;
+            let i = children.length;
+            let find = false;
+            while (i > 0) {
+                const child = children[--i];
+                if (find) {
+                    if (child instanceof HTMLElement) {
+                        return child || null;
+                    }
+                }
+                else if (this === child) {
+                    find = true;
+                }
+            }
+        }
+        return null;
+    }
+    get children() {
+        const children = [];
+        for (const childNode of this.childNodes) {
+            if (childNode instanceof HTMLElement) {
+                children.push(childNode);
+            }
+        }
+        return children;
+    }
+    get firstChild() {
+        return this.childNodes[0];
+    }
+    get firstElementChild() {
+        return this.children[0];
+    }
+    get lastChild() {
+        return arr_back(this.childNodes);
+    }
+    get lastElementChild() {
+        return this.children[this.children.length - 1];
+    }
+    get childElementCount() {
+        return this.children.length;
+    }
+    get classNames() {
+        return this.classList.toString();
+    }
+    clone() {
+        return parse(this.toString(), this._parseOptions).firstChild;
+    }
+}
+const kMarkupPattern = /<!--[\s\S]*?-->|<(\/?)([a-zA-Z][-.:0-9_a-zA-Z@\xB7\xC0-\xD6\xD8-\xF6\u00F8-\u03A1\u03A3-\u03D9\u03DB-\u03EF\u03F7-\u03FF\u0400-\u04FF\u0500-\u052F\u1D00-\u1D2B\u1D6B-\u1D77\u1D79-\u1D9A\u1E00-\u1E9B\u1F00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2126\u212A-\u212B\u2132\u214E\u2160-\u2188\u2C60-\u2C7F\uA722-\uA787\uA78B-\uA78E\uA790-\uA7AD\uA7B0-\uA7B7\uA7F7-\uA7FF\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64-\uAB65\uFB00-\uFB06\uFB13-\uFB17\uFF21-\uFF3A\uFF41-\uFF5A\x37F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]*)((?:\s+[^>]*?(?:(?:'[^']*')|(?:"[^"]*"))?)*)\s*(\/?)>/gu;
+const kAttributePattern = /(?:^|\s)(id|class)\s*=\s*((?:'[^']*')|(?:"[^"]*")|\S+)/gi;
+const kElementsClosedByOpening = {
+    li: { li: true, LI: true },
+    LI: { li: true, LI: true },
+    p: { p: true, div: true, P: true, DIV: true },
+    P: { p: true, div: true, P: true, DIV: true },
+    b: { div: true, DIV: true },
+    B: { div: true, DIV: true },
+    td: { td: true, th: true, TD: true, TH: true },
+    TD: { td: true, th: true, TD: true, TH: true },
+    th: { td: true, th: true, TD: true, TH: true },
+    TH: { td: true, th: true, TD: true, TH: true },
+    h1: { h1: true, H1: true },
+    H1: { h1: true, H1: true },
+    h2: { h2: true, H2: true },
+    H2: { h2: true, H2: true },
+    h3: { h3: true, H3: true },
+    H3: { h3: true, H3: true },
+    h4: { h4: true, H4: true },
+    H4: { h4: true, H4: true },
+    h5: { h5: true, H5: true },
+    H5: { h5: true, H5: true },
+    h6: { h6: true, H6: true },
+    H6: { h6: true, H6: true },
+};
+const kElementsClosedByClosing = {
+    li: { ul: true, ol: true, UL: true, OL: true },
+    LI: { ul: true, ol: true, UL: true, OL: true },
+    a: { div: true, DIV: true },
+    A: { div: true, DIV: true },
+    b: { div: true, DIV: true },
+    B: { div: true, DIV: true },
+    i: { div: true, DIV: true },
+    I: { div: true, DIV: true },
+    p: { div: true, DIV: true },
+    P: { div: true, DIV: true },
+    td: { tr: true, table: true, TR: true, TABLE: true },
+    TD: { tr: true, table: true, TR: true, TABLE: true },
+    th: { tr: true, table: true, TR: true, TABLE: true },
+    TH: { tr: true, table: true, TR: true, TABLE: true },
+};
+const frameflag = 'documentfragmentcontainer';
+export function base_parse(data, options = {}) {
+    const voidTag = new VoidTag(options?.voidTag?.closingSlash, options?.voidTag?.tags);
+    const elements = options.blockTextElements || {
+        script: true,
+        noscript: true,
+        style: true,
+        pre: true,
+    };
+    const element_names = Object.keys(elements);
+    const kBlockTextElements = element_names.map((it) => new RegExp(`^${it}$`, 'i'));
+    const kIgnoreElements = element_names
+        .filter((it) => Boolean(elements[it]))
+        .map((it) => new RegExp(`^${it}$`, 'i'));
+    function element_should_be_ignore(tag) {
+        return kIgnoreElements.some((it) => it.test(tag));
+    }
+    function is_block_text_element(tag) {
+        return kBlockTextElements.some((it) => it.test(tag));
+    }
+    const createRange = (startPos, endPos) => [
+        startPos - frameFlagOffset,
+        endPos - frameFlagOffset,
+    ];
+    const root = new HTMLElement('', {}, '', null, [0, data.length], voidTag, options);
+    let currentParent = root;
+    const stack = [root];
+    let lastTextPos = -1;
+    let noNestedTagIndex = undefined;
+    let match;
+    data = `<${frameflag}>${data}</${frameflag}>`;
+    const { lowerCaseTagName, fixNestedATags } = options;
+    const dataEndPos = data.length - (frameflag.length + 2);
+    const frameFlagOffset = frameflag.length + 2;
+    while ((match = kMarkupPattern.exec(data))) {
+        let { 0: matchText, 1: leadingSlash, 2: tagName, 3: attributes, 4: closingSlash, } = match;
+        const matchLength = matchText.length;
+        const tagStartPos = kMarkupPattern.lastIndex - matchLength;
+        const tagEndPos = kMarkupPattern.lastIndex;
+        if (lastTextPos > -1) {
+            if (lastTextPos + matchLength < tagEndPos) {
+                const text = data.substring(lastTextPos, tagStartPos);
+                currentParent.appendChild(new TextNode(text, currentParent, createRange(lastTextPos, tagStartPos)));
+            }
+        }
+        lastTextPos = kMarkupPattern.lastIndex;
+        if (tagName === frameflag)
+            continue;
+        if (matchText[1] === '!') {
+            if (options.comment) {
+                const text = data.substring(tagStartPos + 4, tagEndPos - 3);
+                currentParent.appendChild(new CommentNode(text, currentParent, createRange(tagStartPos, tagEndPos)));
+            }
+            continue;
+        }
+        if (lowerCaseTagName)
+            tagName = tagName.toLowerCase();
+        if (!leadingSlash) {
+            const attrs = {};
+            for (let attMatch; (attMatch = kAttributePattern.exec(attributes));) {
+                const { 1: key, 2: val } = attMatch;
+                const isQuoted = val[0] === `'` || val[0] === `"`;
+                attrs[key.toLowerCase()] = isQuoted
+                    ? val.slice(1, val.length - 1)
+                    : val;
+            }
+            const parentTagName = currentParent.rawTagName;
+            if (!closingSlash && kElementsClosedByOpening[parentTagName]) {
+                if (kElementsClosedByOpening[parentTagName][tagName]) {
+                    stack.pop();
+                    currentParent = arr_back(stack);
+                }
+            }
+            if (fixNestedATags && (tagName === 'a' || tagName === 'A')) {
+                if (noNestedTagIndex !== undefined) {
+                    stack.splice(noNestedTagIndex);
+                    currentParent = arr_back(stack);
+                }
+                noNestedTagIndex = stack.length;
+            }
+            const tagEndPos = kMarkupPattern.lastIndex;
+            const tagStartPos = tagEndPos - matchLength;
+            currentParent = currentParent.appendChild(new HTMLElement(tagName, attrs, attributes.slice(1), null, createRange(tagStartPos, tagEndPos), voidTag, options));
+            stack.push(currentParent);
+            if (is_block_text_element(tagName)) {
+                const closeMarkup = `</${tagName}>`;
+                const closeIndex = lowerCaseTagName
+                    ? data.toLocaleLowerCase().indexOf(closeMarkup, kMarkupPattern.lastIndex)
+                    : data.indexOf(closeMarkup, kMarkupPattern.lastIndex);
+                const textEndPos = closeIndex === -1 ? dataEndPos : closeIndex;
+                if (element_should_be_ignore(tagName)) {
+                    const text = data.substring(tagEndPos, textEndPos);
+                    if (text.length > 0 && /\S/.test(text)) {
+                        currentParent.appendChild(new TextNode(text, currentParent, createRange(tagEndPos, textEndPos)));
+                    }
+                }
+                if (closeIndex === -1) {
+                    lastTextPos = kMarkupPattern.lastIndex = data.length + 1;
+                }
+                else {
+                    lastTextPos = kMarkupPattern.lastIndex =
+                        closeIndex + closeMarkup.length;
+                    leadingSlash = '/';
+                }
+            }
+        }
+        if (leadingSlash || closingSlash || voidTag.isVoidElement(tagName)) {
+            while (true) {
+                if (noNestedTagIndex != null && (tagName === 'a' || tagName === 'A'))
+                    noNestedTagIndex = undefined;
+                if (currentParent.rawTagName === tagName) {
+                    currentParent.range[1] = createRange(-1, Math.max(lastTextPos, tagEndPos))[1];
+                    stack.pop();
+                    currentParent = arr_back(stack);
+                    break;
+                }
+                else {
+                    const parentTagName = currentParent.tagName;
+                    if (kElementsClosedByClosing[parentTagName]) {
+                        if (kElementsClosedByClosing[parentTagName][tagName]) {
+                            stack.pop();
+                            currentParent = arr_back(stack);
+                            continue;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    return stack;
+}
+export function parse(data, options = {}) {
+    const stack = base_parse(data, options);
+    const [root] = stack;
+    while (stack.length > 1) {
+        const last = stack.pop();
+        const oneBefore = arr_back(stack);
+        if (last && last.parentNode && last.parentNode.parentNode) {
+            if (last.parentNode === oneBefore && last.tagName === oneBefore.tagName) {
+                if (options.parseNoneClosedTags !== true) {
+                    oneBefore.removeChild(last);
+                    last.childNodes.forEach((child) => {
+                        if (oneBefore.parentNode)
+                            oneBefore.parentNode.appendChild(child);
+                    });
+                    stack.pop();
+                }
+            }
+            else {
+                if (options.parseNoneClosedTags !== true) {
+                    oneBefore.removeChild(last);
+                    last.childNodes.forEach((child) => {
+                        oneBefore.appendChild(child);
+                    });
+                }
+            }
+        }
+        else {
+        }
+    }
+    return root;
+}
+function resolveInsertable(insertable, options) {
+    const result = [];
+    for (const val of insertable) {
+        if (typeof val === 'string') {
+            if (/<[a-zA-Z!]/.test(val)) {
+                const stack = base_parse(val, options || {});
+                const root = stack[0];
+                if (root && root.childNodes) {
+                    for (const child of root.childNodes) {
+                        child.parentNode = null;
+                        result.push(child);
+                    }
+                }
+            }
+            else {
+                result.push(new TextNode(val));
+            }
+        }
+        else {
+            val.remove();
+            result.push(val);
+        }
+    }
+    return result;
+}
+function resetParent(nodes, parent) {
+    return nodes.map((node) => {
+        node.parentNode = parent;
+        return node;
+    });
+}