html-validate 8.0.3 → 8.0.5

package/dist/cjs/core.js

@@ -6,8 +6,8 @@ var elements = require('./elements.js');
 var fs = require('fs');
 var semver = require('semver');
 var kleur = require('kleur');
-var rulesHelper = require('./rules-helper.js');
 var betterAjvErrors = require('@sidvind/better-ajv-errors');
+var utils_naturalJoin = require('./utils/natural-join.js');
 var codeFrame = require('@babel/code-frame');
 var stylish$2 = require('@html-validate/stylish');
 
@@ -251,1593 +251,166 @@ var ajvSchemaDraft = {
 }
 };
 
+function stringify(value) {
+    if (typeof value === "string") {
+        return String(value);
+    }
+    else {
+        return JSON.stringify(value);
+    }
+}
 /**
+ * Represents an `Error` created from arbitrary values.
+ *
  * @public
  */
-class DynamicValue {
-    constructor(expr) {
-        this.expr = expr;
-    }
-    toString() {
-        return this.expr;
+class WrappedError extends Error {
+    constructor(message) {
+        super(stringify(message));
     }
 }
 
 /**
- * DOM Attribute.
+ * Ensures the value is an Error.
  *
- * Represents a HTML attribute. Can contain either a fixed static value or a
- * placeholder for dynamic values (e.g. interpolated).
+ * If the passed value is not an `Error` instance a [[WrappedError]] is
+ * constructed with the stringified value.
  *
+ * @internal
+ */
+function ensureError(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    else {
+        return new WrappedError(value);
+    }
+}
+
+/**
  * @public
  */
-class Attribute {
-    /**
-     * @param key - Attribute name.
-     * @param value - Attribute value. Set to `null` for boolean attributes.
-     * @param keyLocation - Source location of attribute name.
-     * @param valueLocation - Source location of attribute value.
-     * @param originalAttribute - If this attribute was dynamically added via a
-     * transformation (e.g. vuejs `:id` generating the `id` attribute) this
-     * parameter should be set to the attribute name of the source attribute (`:id`).
-     */
-    constructor(key, value, keyLocation, valueLocation, originalAttribute) {
-        this.key = key;
-        this.value = value;
-        this.keyLocation = keyLocation;
-        this.valueLocation = valueLocation;
-        this.originalAttribute = originalAttribute;
-        /* force undefined to null */
-        if (typeof this.value === "undefined") {
-            this.value = null;
+class NestedError extends Error {
+    constructor(message, nested) {
+        super(message);
+        Error.captureStackTrace(this, NestedError);
+        this.name = NestedError.name;
+        if (nested && nested.stack) {
+            this.stack += `\nCaused by: ${nested.stack}`;
         }
     }
-    /**
-     * Flag set to true if the attribute value is static.
-     */
-    get isStatic() {
-        return !this.isDynamic;
+}
+
+/**
+ * @public
+ */
+class UserError extends NestedError {
+    constructor(message, nested) {
+        super(message, nested);
+        Error.captureStackTrace(this, UserError);
+        this.name = UserError.name;
     }
     /**
-     * Flag set to true if the attribute value is dynamic.
+     * @public
      */
-    get isDynamic() {
-        return this.value instanceof DynamicValue;
-    }
-    valueMatches(pattern, dynamicMatches = true) {
-        if (this.value === null) {
-            return false;
-        }
-        /* dynamic values matches everything */
-        if (this.value instanceof DynamicValue) {
-            return dynamicMatches;
-        }
-        /* test against an array of keywords */
-        if (Array.isArray(pattern)) {
-            return pattern.includes(this.value);
-        }
-        /* test value against pattern */
-        if (pattern instanceof RegExp) {
-            return this.value.match(pattern) !== null;
-        }
-        else {
-            return this.value === pattern;
-        }
+    /* istanbul ignore next: default implementation */
+    prettyFormat() {
+        return undefined;
     }
 }
 
-function getCSSDeclarations(value) {
-    return value
-        .trim()
-        .split(";")
-        .filter(Boolean)
-        .map((it) => {
-        const [property, value] = it.split(":", 2);
-        return [property.trim(), value ? value.trim() : ""];
-    });
-}
 /**
  * @internal
  */
-function parseCssDeclaration(value) {
-    if (!value || value instanceof DynamicValue) {
-        return {};
+class InheritError extends UserError {
+    constructor({ tagName, inherit }) {
+        const message = `Element <${tagName}> cannot inherit from <${inherit}>: no such element`;
+        super(message);
+        Error.captureStackTrace(this, InheritError);
+        this.name = InheritError.name;
+        this.tagName = tagName;
+        this.inherit = inherit;
+        this.filename = null;
+    }
+    prettyFormat() {
+        const { message, tagName, inherit } = this;
+        const source = this.filename
+            ? ["", "This error occurred when loading element metadata from:", `"${this.filename}"`, ""]
+            : [""];
+        return [
+            message,
+            ...source,
+            "This usually occurs when the elements are defined in the wrong order, try one of the following:",
+            "",
+            `  - Ensure the spelling of "${inherit}" is correct.`,
+            `  - Ensure the file containing "${inherit}" is loaded before the file containing "${tagName}".`,
+            `  - Move the definition of "${inherit}" above the definition for "${tagName}".`,
+        ].join("\n");
     }
-    const pairs = getCSSDeclarations(value);
-    return Object.fromEntries(pairs);
 }
 
-function sliceSize(size, begin, end) {
-    if (typeof size !== "number") {
-        return size;
+function getSummary(schema, obj, errors) {
+    const output = betterAjvErrors__default.default(schema, obj, errors, {
+        format: "js",
+    });
+    // istanbul ignore next: for safety only
+    return output.length > 0 ? output[0].error : "unknown validation error";
+}
+/**
+ * @public
+ */
+class SchemaValidationError extends UserError {
+    constructor(filename, message, obj, schema, errors) {
+        const summary = getSummary(schema, obj, errors);
+        super(`${message}: ${summary}`);
+        this.filename = filename;
+        this.obj = obj;
+        this.schema = schema;
+        this.errors = errors;
     }
-    if (typeof end !== "number") {
-        return size - begin;
+    prettyError() {
+        const json = this.getRawJSON();
+        return betterAjvErrors__default.default(this.schema, this.obj, this.errors, {
+            format: "cli",
+            indent: 2,
+            json,
+        });
     }
-    if (end < 0) {
-        end = size + end;
+    getRawJSON() {
+        if (this.filename && fs__default.default.existsSync(this.filename)) {
+            return fs__default.default.readFileSync(this.filename, "utf-8");
+        }
+        else {
+            return null;
+        }
     }
-    return Math.min(size, end - begin);
 }
-function sliceLocation(location, begin, end, wrap) {
-    if (!location)
-        return null;
-    const size = sliceSize(location.size, begin, end);
-    const sliced = {
-        filename: location.filename,
-        offset: location.offset + begin,
-        line: location.line,
-        column: location.column + begin,
-        size,
-    };
-    /* if text content is provided try to find all newlines and modify line/column accordingly */
-    if (wrap) {
-        let index = -1;
-        const col = sliced.column;
-        do {
-            index = wrap.indexOf("\n", index + 1);
-            if (index >= 0 && index < begin) {
-                sliced.column = col - (index + 1);
-                sliced.line++;
-            }
-            else {
-                break;
-            }
-        } while (true); // eslint-disable-line no-constant-condition -- it will break out
+
+/**
+ * Computes hash for given string.
+ *
+ * @internal
+ */
+function cyrb53(str) {
+    const a = 2654435761;
+    const b = 1597334677;
+    const c = 2246822507;
+    const d = 3266489909;
+    const e = 4294967296;
+    const f = 2097151;
+    const seed = 0;
+    let h1 = 0xdeadbeef ^ seed;
+    let h2 = 0x41c6ce57 ^ seed;
+    for (let i = 0, ch; i < str.length; i++) {
+        ch = str.charCodeAt(i);
+        h1 = Math.imul(h1 ^ ch, a);
+        h2 = Math.imul(h2 ^ ch, b);
     }
-    return sliced;
+    h1 = Math.imul(h1 ^ (h1 >>> 16), c) ^ Math.imul(h2 ^ (h2 >>> 13), d);
+    h2 = Math.imul(h2 ^ (h2 >>> 16), c) ^ Math.imul(h1 ^ (h1 >>> 13), d);
+    return e * (f & h2) + (h1 >>> 0);
 }
-
-var State;
-(function (State) {
-    State[State["INITIAL"] = 1] = "INITIAL";
-    State[State["DOCTYPE"] = 2] = "DOCTYPE";
-    State[State["TEXT"] = 3] = "TEXT";
-    State[State["TAG"] = 4] = "TAG";
-    State[State["ATTR"] = 5] = "ATTR";
-    State[State["CDATA"] = 6] = "CDATA";
-    State[State["SCRIPT"] = 7] = "SCRIPT";
-    State[State["STYLE"] = 8] = "STYLE";
-})(State || (State = {}));
-
-var ContentModel;
-(function (ContentModel) {
-    ContentModel[ContentModel["TEXT"] = 1] = "TEXT";
-    ContentModel[ContentModel["SCRIPT"] = 2] = "SCRIPT";
-    ContentModel[ContentModel["STYLE"] = 3] = "STYLE";
-})(ContentModel || (ContentModel = {}));
-class Context {
-    constructor(source) {
-        var _a, _b, _c, _d;
-        this.state = State.INITIAL;
-        this.string = source.data;
-        this.filename = (_a = source.filename) !== null && _a !== void 0 ? _a : "";
-        this.offset = (_b = source.offset) !== null && _b !== void 0 ? _b : 0;
-        this.line = (_c = source.line) !== null && _c !== void 0 ? _c : 1;
-        this.column = (_d = source.column) !== null && _d !== void 0 ? _d : 1;
-        this.contentModel = ContentModel.TEXT;
-    }
-    getTruncatedLine(n = 13) {
-        return JSON.stringify(this.string.length > n ? `${this.string.slice(0, 10)}...` : this.string);
-    }
-    consume(n, state) {
-        /* if "n" is an regex match the first value is the full matched
-         * string so consume that many characters. */
-        if (typeof n !== "number") {
-            n = n[0].length; /* regex match */
-        }
-        /* poor mans line counter :( */
-        let consumed = this.string.slice(0, n);
-        let offset;
-        while ((offset = consumed.indexOf("\n")) >= 0) {
-            this.line++;
-            this.column = 1;
-            consumed = consumed.substr(offset + 1);
-        }
-        this.column += consumed.length;
-        this.offset += n;
-        /* remove N chars */
-        this.string = this.string.substr(n);
-        /* change state */
-        this.state = state;
-    }
-    getLocation(size) {
-        return {
-            filename: this.filename,
-            offset: this.offset,
-            line: this.line,
-            column: this.column,
-            size,
-        };
-    }
-}
-
-/**
- * @public
- */
-exports.TextContent = void 0;
-(function (TextContent) {
-    /* forbid node to have text content, inter-element whitespace is ignored */
-    TextContent["NONE"] = "none";
-    /* node can have text but not required too */
-    TextContent["DEFAULT"] = "default";
-    /* node requires text-nodes to be present (direct or by descendant) */
-    TextContent["REQUIRED"] = "required";
-    /* node requires accessible text (hidden text is ignored, tries to get text from accessibility tree) */
-    TextContent["ACCESSIBLE"] = "accessible";
-})(exports.TextContent || (exports.TextContent = {}));
-/**
- * Properties listed here can be copied (loaded) onto another element using
- * [[HtmlElement.loadMeta]].
- *
- * @public
- */
-const MetaCopyableProperty = [
-    "metadata",
-    "flow",
-    "sectioning",
-    "heading",
-    "phrasing",
-    "embedded",
-    "interactive",
-    "transparent",
-    "form",
-    "formAssociated",
-    "labelable",
-    "attributes",
-    "permittedContent",
-    "permittedDescendants",
-    "permittedOrder",
-    "permittedParent",
-    "requiredAncestors",
-    "requiredContent",
-];
-/**
- * @internal
- */
-function setMetaProperty(dst, key, value) {
-    dst[key] = value;
-}
-
-/**
- * @public
- */
-exports.NodeType = void 0;
-(function (NodeType) {
-    NodeType[NodeType["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
-    NodeType[NodeType["TEXT_NODE"] = 3] = "TEXT_NODE";
-    NodeType[NodeType["DOCUMENT_NODE"] = 9] = "DOCUMENT_NODE";
-})(exports.NodeType || (exports.NodeType = {}));
-
-const DOCUMENT_NODE_NAME = "#document";
-const TEXT_CONTENT = Symbol("textContent");
-let counter = 0;
-/**
- * @public
- */
-class DOMNode {
-    /**
-     * Create a new DOMNode.
-     *
-     * @param nodeType - What node type to create.
-     * @param nodeName - What node name to use. For `HtmlElement` this corresponds
-     * to the tagName but other node types have specific predefined values.
-     * @param location - Source code location of this node.
-     */
-    constructor(nodeType, nodeName, location) {
-        this.nodeType = nodeType;
-        this.nodeName = nodeName !== null && nodeName !== void 0 ? nodeName : DOCUMENT_NODE_NAME;
-        this.location = location;
-        this.disabledRules = new Set();
-        this.blockedRules = new Map();
-        this.childNodes = [];
-        this.unique = counter++;
-        this.cache = null;
-    }
-    /**
-     * Enable cache for this node.
-     *
-     * Should not be called before the node and all children are fully constructed.
-     *
-     * @internal
-     */
-    cacheEnable() {
-        this.cache = new Map();
-    }
-    cacheGet(key) {
-        if (this.cache) {
-            return this.cache.get(key);
-        }
-        else {
-            return undefined;
-        }
-    }
-    cacheSet(key, value) {
-        if (this.cache) {
-            this.cache.set(key, value);
-        }
-        return value;
-    }
-    cacheRemove(key) {
-        if (this.cache) {
-            return this.cache.delete(key);
-        }
-        else {
-            return false;
-        }
-    }
-    cacheExists(key) {
-        return Boolean(this.cache && this.cache.has(key));
-    }
-    /**
-     * Get the text (recursive) from all child nodes.
-     */
-    get textContent() {
-        const cached = this.cacheGet(TEXT_CONTENT);
-        if (cached) {
-            return cached;
-        }
-        const text = this.childNodes.map((node) => node.textContent).join("");
-        this.cacheSet(TEXT_CONTENT, text);
-        return text;
-    }
-    append(node) {
-        this.childNodes.push(node);
-    }
-    isRootElement() {
-        return this.nodeType === exports.NodeType.DOCUMENT_NODE;
-    }
-    /**
-     * Tests if two nodes are the same (references the same object).
-     *
-     * @since v4.11.0
-     */
-    isSameNode(otherNode) {
-        return this.unique === otherNode.unique;
-    }
-    /**
-     * Returns a DOMNode representing the first direct child node or `null` if the
-     * node has no children.
-     */
-    get firstChild() {
-        return this.childNodes[0] || null;
-    }
-    /**
-     * Returns a DOMNode representing the last direct child node or `null` if the
-     * node has no children.
-     */
-    get lastChild() {
-        return this.childNodes[this.childNodes.length - 1] || null;
-    }
-    /**
-     * Block a rule for this node.
-     *
-     * @internal
-     */
-    blockRule(ruleId, blocker) {
-        const current = this.blockedRules.get(ruleId);
-        if (current) {
-            current.push(blocker);
-        }
-        else {
-            this.blockedRules.set(ruleId, [blocker]);
-        }
-    }
-    /**
-     * Blocks multiple rules.
-     *
-     * @internal
-     */
-    blockRules(rules, blocker) {
-        for (const rule of rules) {
-            this.blockRule(rule, blocker);
-        }
-    }
-    /**
-     * Disable a rule for this node.
-     *
-     * @internal
-     */
-    disableRule(ruleId) {
-        this.disabledRules.add(ruleId);
-    }
-    /**
-     * Disables multiple rules.
-     *
-     * @internal
-     */
-    disableRules(rules) {
-        for (const rule of rules) {
-            this.disableRule(rule);
-        }
-    }
-    /**
-     * Enable a previously disabled rule for this node.
-     */
-    enableRule(ruleId) {
-        this.disabledRules.delete(ruleId);
-    }
-    /**
-     * Enables multiple rules.
-     */
-    enableRules(rules) {
-        for (const rule of rules) {
-            this.enableRule(rule);
-        }
-    }
-    /**
-     * Test if a rule is enabled for this node.
-     *
-     * @internal
-     */
-    ruleEnabled(ruleId) {
-        return !this.disabledRules.has(ruleId);
-    }
-    /**
-     * Test if a rule is blocked for this node.
-     *
-     * @internal
-     */
-    ruleBlockers(ruleId) {
-        var _a;
-        return (_a = this.blockedRules.get(ruleId)) !== null && _a !== void 0 ? _a : [];
-    }
-    generateSelector() {
-        return null;
-    }
-}
-
-function parse(text, baseLocation) {
-    const tokens = [];
-    const locations = baseLocation ? [] : null;
-    for (let begin = 0; begin < text.length;) {
-        let end = text.indexOf(" ", begin);
-        /* if the last space was found move the position to the last character
-         * in the string */
-        if (end === -1) {
-            end = text.length;
-        }
-        /* handle multiple spaces */
-        const size = end - begin;
-        if (size === 0) {
-            begin++;
-            continue;
-        }
-        /* extract token */
-        const token = text.substring(begin, end);
-        tokens.push(token);
-        /* extract location */
-        if (locations && baseLocation) {
-            const location = sliceLocation(baseLocation, begin, end);
-            locations.push(location);
-        }
-        /* advance position to the character after the current end position */
-        begin += size + 1;
-    }
-    return { tokens, locations };
-}
-/**
- * @public
- */
-class DOMTokenList extends Array {
-    constructor(value, location) {
-        if (value && typeof value === "string") {
-            /* replace all whitespace with a single space for easier parsing */
-            const normalized = value.replace(/[\t\r\n]/g, " ");
-            const { tokens, locations } = parse(normalized, location);
-            super(...tokens);
-            this.locations = locations;
-        }
-        else {
-            super(0);
-            this.locations = null;
-        }
-        if (value instanceof DynamicValue) {
-            this.value = value.expr;
-        }
-        else {
-            this.value = value || "";
-        }
-    }
-    item(n) {
-        return this[n];
-    }
-    location(n) {
-        if (this.locations) {
-            return this.locations[n];
-        }
-        else {
-            throw new Error("Trying to access DOMTokenList location when base location isn't set");
-        }
-    }
-    contains(token) {
-        return this.includes(token);
-    }
-    *iterator() {
-        for (let index = 0; index < this.length; index++) {
-            /* eslint-disable @typescript-eslint/no-non-null-assertion -- as we loop over length this should always be set */
-            const item = this.item(index);
-            const location = this.location(index);
-            /* eslint-enable @typescript-eslint/no-non-null-assertion */
-            yield { index, item, location };
-        }
-    }
-}
-
-var Combinator;
-(function (Combinator) {
-    Combinator[Combinator["DESCENDANT"] = 1] = "DESCENDANT";
-    Combinator[Combinator["CHILD"] = 2] = "CHILD";
-    Combinator[Combinator["ADJACENT_SIBLING"] = 3] = "ADJACENT_SIBLING";
-    Combinator[Combinator["GENERAL_SIBLING"] = 4] = "GENERAL_SIBLING";
-    /* special cases */
-    Combinator[Combinator["SCOPE"] = 5] = "SCOPE";
-})(Combinator || (Combinator = {}));
-function parseCombinator(combinator, pattern) {
-    /* special case, when pattern is :scope [[Selector]] will handle this
-     * "combinator" to match itself instead of descendants */
-    if (pattern === ":scope") {
-        return Combinator.SCOPE;
-    }
-    switch (combinator) {
-        case undefined:
-        case null:
-        case "":
-            return Combinator.DESCENDANT;
-        case ">":
-            return Combinator.CHILD;
-        case "+":
-            return Combinator.ADJACENT_SIBLING;
-        case "~":
-            return Combinator.GENERAL_SIBLING;
-        default:
-            throw new Error(`Unknown combinator "${combinator}"`);
-    }
-}
-
-function firstChild(node) {
-    return node.previousSibling === null;
-}
-
-function lastChild(node) {
-    return node.nextSibling === null;
-}
-
-const cache = {};
-function getNthChild(node) {
-    if (!node.parent) {
-        return -1;
-    }
-    if (!cache[node.unique]) {
-        const parent = node.parent;
-        const index = parent.childElements.findIndex((cur) => {
-            return cur.unique === node.unique;
-        });
-        cache[node.unique] = index + 1; /* nthChild starts at 1 */
-    }
-    return cache[node.unique];
-}
-function nthChild(node, args) {
-    if (!args) {
-        throw new Error("Missing argument to nth-child");
-    }
-    const n = parseInt(args.trim(), 10);
-    const cur = getNthChild(node);
-    return cur === n;
-}
-
-function scope(node) {
-    return node.isSameNode(this.scope);
-}
-
-const table = {
-    "first-child": firstChild,
-    "last-child": lastChild,
-    "nth-child": nthChild,
-    scope: scope,
-};
-function factory(name, context) {
-    const fn = table[name];
-    if (fn) {
-        return fn.bind(context);
-    }
-    else {
-        throw new Error(`Pseudo-class "${name}" is not implemented`);
-    }
-}
-
-/**
- * Homage to PHP: unescapes slashes.
- *
- * E.g. "foo\:bar" becomes "foo:bar"
- */
-function stripslashes(value) {
-    return value.replace(/\\(.)/g, "$1");
-}
-/**
- * @internal
- */
-function escapeSelectorComponent(text) {
-    return text.toString().replace(/([^a-z0-9_-])/gi, "\\$1");
-}
-/**
- * @internal
- */
-function generateIdSelector(id) {
-    const escaped = escapeSelectorComponent(id);
-    return escaped.match(/^\d/) ? `[id="${escaped}"]` : `#${escaped}`;
-}
-/**
- * Returns true if the character is a delimiter for different kinds of selectors:
- *
- * - `.` - begins a class selector
- * - `#` - begins an id selector
- * - `[` - begins an attribute selector
- * - `:` - begins a pseudo class or element selector
- */
-function isDelimiter(ch) {
-    return /[.#[:]/.test(ch);
-}
-/**
- * Returns true if the character is a quotation mark.
- */
-function isQuotationMark(ch) {
-    return /['"]/.test(ch);
-}
-function isPseudoElement(ch, buffer) {
-    return ch === ":" && buffer === ":";
-}
-/**
- * @internal
- */
-function* splitPattern(pattern) {
-    if (pattern === "") {
-        return;
-    }
-    const end = pattern.length;
-    let begin = 0;
-    let cur = 1;
-    let quoted = false;
-    while (cur < end) {
-        const ch = pattern[cur];
-        const buffer = pattern.slice(begin, cur);
-        /* escaped character, ignore whatever is next */
-        if (ch === "\\") {
-            cur += 2;
-            continue;
-        }
-        /* if inside quoted string we only look for the end quotation mark */
-        if (quoted) {
-            if (ch === quoted) {
-                quoted = false;
-            }
-            cur += 1;
-            continue;
-        }
-        /* if the character is a quotation mark we store the character and the above
-         * condition will look for a similar end quotation mark */
-        if (isQuotationMark(ch)) {
-            quoted = ch;
-            cur += 1;
-            continue;
-        }
-        /* special case when using :: pseudo element selector */
-        if (isPseudoElement(ch, buffer)) {
-            cur += 1;
-            continue;
-        }
-        /* if the character is a delimiter we yield the string and reset the
-         * position */
-        if (isDelimiter(ch)) {
-            begin = cur;
-            yield buffer;
-        }
-        cur += 1;
-    }
-    /* yield the rest of the string */
-    const tail = pattern.slice(begin, cur);
-    yield tail;
-}
-class Matcher {
-}
-class ClassMatcher extends Matcher {
-    constructor(classname) {
-        super();
-        this.classname = classname;
-    }
-    match(node) {
-        return node.classList.contains(this.classname);
-    }
-}
-class IdMatcher extends Matcher {
-    constructor(id) {
-        super();
-        this.id = stripslashes(id);
-    }
-    match(node) {
-        return node.id === this.id;
-    }
-}
-class AttrMatcher extends Matcher {
-    constructor(attr) {
-        super();
-        const [, key, op, value] = attr.match(/^(.+?)(?:([~^$*|]?=)"([^"]+?)")?$/);
-        this.key = key;
-        this.op = op;
-        this.value = value;
-    }
-    match(node) {
-        const attr = node.getAttribute(this.key, true) || [];
-        return attr.some((cur) => {
-            switch (this.op) {
-                case undefined:
-                    return true; /* attribute exists */
-                case "=":
-                    return cur.value === this.value;
-                default:
-                    throw new Error(`Attribute selector operator ${this.op} is not implemented yet`);
-            }
-        });
-    }
-}
-class PseudoClassMatcher extends Matcher {
-    constructor(pseudoclass, context) {
-        super();
-        const match = pseudoclass.match(/^([^(]+)(?:\((.*)\))?$/);
-        if (!match) {
-            throw new Error(`Missing pseudo-class after colon in selector pattern "${context}"`);
-        }
-        const [, name, args] = match;
-        this.name = name;
-        this.args = args;
-    }
-    match(node, context) {
-        const fn = factory(this.name, context);
-        return fn(node, this.args);
-    }
-}
-class Pattern {
-    constructor(pattern) {
-        const match = pattern.match(/^([~+\->]?)((?:[*]|[^.#[:]+)?)(.*)$/);
-        match.shift(); /* remove full matched string */
-        this.selector = pattern;
-        this.combinator = parseCombinator(match.shift(), pattern);
-        this.tagName = match.shift() || "*";
-        this.pattern = Array.from(splitPattern(match[0]), (it) => this.createMatcher(it));
-    }
-    match(node, context) {
-        return node.is(this.tagName) && this.pattern.every((cur) => cur.match(node, context));
-    }
-    createMatcher(pattern) {
-        switch (pattern[0]) {
-            case ".":
-                return new ClassMatcher(pattern.slice(1));
-            case "#":
-                return new IdMatcher(pattern.slice(1));
-            case "[":
-                return new AttrMatcher(pattern.slice(1, -1));
-            case ":":
-                return new PseudoClassMatcher(pattern.slice(1), this.selector);
-            default:
-                /* istanbul ignore next: fallback solution, the switch cases should cover
-                 * everything and there is no known way to trigger this fallback */
-                throw new Error(`Failed to create matcher for "${pattern}"`);
-        }
-    }
-}
-/**
- * DOM Selector.
- */
-class Selector {
-    constructor(selector) {
-        this.pattern = Selector.parse(selector);
-    }
-    /**
-     * Match this selector against a HtmlElement.
-     *
-     * @param root - Element to match against.
-     * @returns Iterator with matched elements.
-     */
-    *match(root) {
-        const context = { scope: root };
-        yield* this.matchInternal(root, 0, context);
-    }
-    *matchInternal(root, level, context) {
-        if (level >= this.pattern.length) {
-            yield root;
-            return;
-        }
-        const pattern = this.pattern[level];
-        const matches = Selector.findCandidates(root, pattern);
-        for (const node of matches) {
-            if (!pattern.match(node, context)) {
-                continue;
-            }
-            yield* this.matchInternal(node, level + 1, context);
-        }
-    }
-    static parse(selector) {
-        /* strip whitespace before combinators, "ul > li" becomes "ul >li", for
-         * easier parsing */
-        selector = selector.replace(/([+~>]) /g, "$1");
-        const pattern = selector.split(/(?:(?<!\\) )+/);
-        return pattern.map((part) => new Pattern(part));
-    }
-    static findCandidates(root, pattern) {
-        switch (pattern.combinator) {
-            case Combinator.DESCENDANT:
-                return root.getElementsByTagName(pattern.tagName);
-            case Combinator.CHILD:
-                return root.childElements.filter((node) => node.is(pattern.tagName));
-            case Combinator.ADJACENT_SIBLING:
-                return Selector.findAdjacentSibling(root);
-            case Combinator.GENERAL_SIBLING:
-                return Selector.findGeneralSibling(root);
-            case Combinator.SCOPE:
-                return [root];
-        }
-        /* istanbul ignore next: fallback solution, the switch cases should cover
-         * everything and there is no known way to trigger this fallback */
-        return [];
-    }
-    static findAdjacentSibling(node) {
-        let adjacent = false;
-        return node.siblings.filter((cur) => {
-            if (adjacent) {
-                adjacent = false;
-                return true;
-            }
-            if (cur === node) {
-                adjacent = true;
-            }
-            return false;
-        });
-    }
-    static findGeneralSibling(node) {
-        let after = false;
-        return node.siblings.filter((cur) => {
-            if (after) {
-                return true;
-            }
-            if (cur === node) {
-                after = true;
-            }
-            return false;
-        });
-    }
-}
-
-const TEXT_NODE_NAME = "#text";
-/**
- * Returns true if the node is a text node.
- *
- * @public
- */
-function isTextNode(node) {
-    return Boolean(node && node.nodeType === exports.NodeType.TEXT_NODE);
-}
-/**
- * Represents a text in the HTML document.
- *
- * Text nodes are appended as children of `HtmlElement` and cannot have childen
- * of its own.
- *
- * @public
- */
-class TextNode extends DOMNode {
-    /**
-     * @param text - Text to add. When a `DynamicValue` is used the expression is
-     * used as "text".
-     * @param location - Source code location of this node.
-     */
-    constructor(text, location) {
-        super(exports.NodeType.TEXT_NODE, TEXT_NODE_NAME, location);
-        this.text = text;
-    }
-    /**
-     * Get the text from node.
-     */
-    get textContent() {
-        return this.text.toString();
-    }
-    /**
-     * Flag set to true if the attribute value is static.
-     */
-    get isStatic() {
-        return !this.isDynamic;
-    }
-    /**
-     * Flag set to true if the attribute value is dynamic.
-     */
-    get isDynamic() {
-        return this.text instanceof DynamicValue;
-    }
-}
-
-/**
- * @public
- */
-exports.NodeClosed = void 0;
-(function (NodeClosed) {
-    NodeClosed[NodeClosed["Open"] = 0] = "Open";
-    NodeClosed[NodeClosed["EndTag"] = 1] = "EndTag";
-    NodeClosed[NodeClosed["VoidOmitted"] = 2] = "VoidOmitted";
-    NodeClosed[NodeClosed["VoidSelfClosed"] = 3] = "VoidSelfClosed";
-    NodeClosed[NodeClosed["ImplicitClosed"] = 4] = "ImplicitClosed";
-})(exports.NodeClosed || (exports.NodeClosed = {}));
-/**
- * Returns true if the node is an element node.
- *
- * @public
- */
-function isElementNode(node) {
-    return Boolean(node && node.nodeType === exports.NodeType.ELEMENT_NODE);
-}
-function isValidTagName(tagName) {
-    return Boolean(tagName !== "" && tagName !== "*");
-}
-/**
- * @public
- */
-class HtmlElement extends DOMNode {
-    constructor(tagName, parent, closed, meta, location) {
-        const nodeType = tagName ? exports.NodeType.ELEMENT_NODE : exports.NodeType.DOCUMENT_NODE;
-        super(nodeType, tagName, location);
-        if (!isValidTagName(tagName)) {
-            throw new Error(`The tag name provided ('${tagName || ""}') is not a valid name`);
-        }
-        this.tagName = tagName || "#document";
-        this.parent = parent !== null && parent !== void 0 ? parent : null;
-        this.attr = {};
-        this.metaElement = meta !== null && meta !== void 0 ? meta : null;
-        this.closed = closed;
-        this.voidElement = meta ? Boolean(meta.void) : false;
-        this.depth = 0;
-        this.annotation = null;
-        if (parent) {
-            parent.childNodes.push(this);
-            /* calculate depth in domtree */
-            let cur = parent;
-            while (cur.parent) {
-                this.depth++;
-                cur = cur.parent;
-            }
-        }
-    }
-    /**
-     * @internal
-     */
-    static rootNode(location) {
-        const root = new HtmlElement(undefined, null, exports.NodeClosed.EndTag, null, location);
-        root.setAnnotation("#document");
-        return root;
-    }
-    /**
-     * @internal
-     *
-     * @param namespace - If given it is appended to the tagName.
-     */
-    static fromTokens(startToken, endToken, parent, metaTable, namespace = "") {
-        const name = startToken.data[2];
-        const tagName = namespace ? `${namespace}:${name}` : name;
-        if (!name) {
-            throw new Error("tagName cannot be empty");
-        }
-        const meta = metaTable ? metaTable.getMetaFor(tagName) : null;
-        const open = startToken.data[1] !== "/";
-        const closed = isClosed(endToken, meta);
-        /* location contains position of '<' so strip it out */
-        const location = sliceLocation(startToken.location, 1);
-        return new HtmlElement(tagName, open ? parent : null, closed, meta, location);
-    }
-    /**
-     * Returns annotated name if set or defaults to `<tagName>`.
-     *
-     * E.g. `my-annotation` or `<div>`.
-     */
-    get annotatedName() {
-        if (this.annotation) {
-            return this.annotation;
-        }
-        else {
-            return `<${this.tagName}>`;
-        }
-    }
-    /**
-     * Get list of IDs referenced by `aria-labelledby`.
-     *
-     * If the attribute is unset or empty this getter returns null.
-     * If the attribute is dynamic the original {@link DynamicValue} is returned.
-     *
-     * @public
-     */
-    get ariaLabelledby() {
-        const attr = this.getAttribute("aria-labelledby");
-        if (!attr || !attr.value) {
-            return null;
-        }
-        if (attr.value instanceof DynamicValue) {
-            return attr.value;
-        }
-        const list = new DOMTokenList(attr.value, attr.valueLocation);
-        return list.length ? Array.from(list) : null;
-    }
-    /**
-     * Similar to childNodes but only elements.
-     */
-    get childElements() {
-        return this.childNodes.filter(isElementNode);
-    }
-    /**
-     * Find the first ancestor matching a selector.
-     *
-     * Implementation of DOM specification of Element.closest(selectors).
-     */
-    closest(selectors) {
-        /* eslint-disable-next-line @typescript-eslint/no-this-alias -- false positive*/
-        let node = this;
-        while (node) {
-            if (node.matches(selectors)) {
-                return node;
-            }
-            node = node.parent;
-        }
-        return null;
-    }
-    /**
-     * Generate a DOM selector for this element. The returned selector will be
-     * unique inside the current document.
-     */
-    generateSelector() {
-        /* root element cannot have a selector as it isn't a proper element */
-        if (this.isRootElement()) {
-            return null;
-        }
-        const parts = [];
-        let root;
-        /* eslint-disable-next-line @typescript-eslint/no-this-alias -- false positive */
-        for (root = this; root.parent; root = root.parent) {
-            /* .. */
-        }
-        // eslint-disable-next-line @typescript-eslint/no-this-alias -- false positive
-        for (let cur = this; cur.parent; cur = cur.parent) {
-            /* if a unique id is present, use it and short-circuit */
-            if (cur.id) {
-                const selector = generateIdSelector(cur.id);
-                const matches = root.querySelectorAll(selector);
-                if (matches.length === 1) {
-                    parts.push(selector);
-                    break;
-                }
-            }
-            const parent = cur.parent;
-            const child = parent.childElements;
-            const index = child.findIndex((it) => it.unique === cur.unique);
-            const numOfType = child.filter((it) => it.is(cur.tagName)).length;
-            const solo = numOfType === 1;
-            /* if this is the only tagName in this level of siblings nth-child isn't needed */
-            if (solo) {
-                parts.push(cur.tagName.toLowerCase());
-                continue;
-            }
-            /* this will generate the worst kind of selector but at least it will be accurate (optimizations welcome) */
-            parts.push(`${cur.tagName.toLowerCase()}:nth-child(${index + 1})`);
-        }
-        return parts.reverse().join(" > ");
-    }
-    /**
-     * Tests if this element has given tagname.
-     *
-     * If passing "*" this test will pass if any tagname is set.
-     */
-    is(tagName) {
-        return tagName === "*" || this.tagName.toLowerCase() === tagName.toLowerCase();
-    }
-    /**
-     * Load new element metadata onto this element.
-     *
-     * Do note that semantics such as `void` cannot be changed (as the element has
-     * already been created). In addition the element will still "be" the same
-     * element, i.e. even if loading meta for a `<p>` tag upon a `<div>` tag it
-     * will still be a `<div>` as far as the rest of the validator is concerned.
-     *
-     * In fact only certain properties will be copied onto the element:
-     *
-     * - content categories (flow, phrasing, etc)
-     * - required attributes
-     * - attribute allowed values
-     * - permitted/required elements
-     *
-     * Properties *not* loaded:
-     *
-     * - inherit
-     * - deprecated
-     * - foreign
-     * - void
-     * - implicitClosed
-     * - scriptSupporting
-     * - deprecatedAttributes
-     *
-     * Changes to element metadata will only be visible after `element:ready` (and
-     * the subsequent `dom:ready` event).
-     */
-    loadMeta(meta) {
-        if (!this.metaElement) {
-            this.metaElement = {};
-        }
-        for (const key of MetaCopyableProperty) {
-            const value = meta[key];
-            if (typeof value !== "undefined") {
-                setMetaProperty(this.metaElement, key, value);
-            }
-            else {
-                delete this.metaElement[key];
-            }
-        }
-    }
-    /**
-     * Match this element against given selectors. Returns true if any selector
-     * matches.
-     *
-     * Implementation of DOM specification of Element.matches(selectors).
-     */
-    matches(selector) {
-        /* find root element */
-        /* eslint-disable-next-line @typescript-eslint/no-this-alias -- false positive */
-        let root = this;
-        while (root.parent) {
-            root = root.parent;
-        }
-        /* a bit slow implementation as it finds all candidates for the selector and
-         * then tests if any of them are the current element. A better
-         * implementation would be to walk the selector right-to-left and test
-         * ancestors. */
-        for (const match of root.querySelectorAll(selector)) {
-            if (match.unique === this.unique) {
-                return true;
-            }
-        }
-        return false;
-    }
-    get meta() {
-        return this.metaElement;
-    }
-    /**
-     * Set annotation for this element.
-     */
-    setAnnotation(text) {
-        this.annotation = text;
-    }
-    /**
-     * Set attribute. Stores all attributes set even with the same name.
-     *
-     * @param key - Attribute name
-     * @param value - Attribute value. Use `null` if no value is present.
-     * @param keyLocation - Location of the attribute name.
-     * @param valueLocation - Location of the attribute value (excluding quotation)
-     * @param originalAttribute - If attribute is an alias for another attribute
-     * (dynamic attributes) set this to the original attribute name.
-     */
-    setAttribute(key, value, keyLocation, valueLocation, originalAttribute) {
-        key = key.toLowerCase();
-        if (!this.attr[key]) {
-            this.attr[key] = [];
-        }
-        this.attr[key].push(new Attribute(key, value, keyLocation, valueLocation, originalAttribute));
-    }
-    /**
-     * Get a list of all attributes on this node.
-     */
-    get attributes() {
-        return Object.values(this.attr).reduce((result, cur) => {
-            return result.concat(cur);
-        }, []);
-    }
-    hasAttribute(key) {
-        key = key.toLowerCase();
-        return key in this.attr;
-    }
-    getAttribute(key, all = false) {
-        key = key.toLowerCase();
-        if (key in this.attr) {
-            const matches = this.attr[key];
-            return all ? matches : matches[0];
-        }
-        else {
-            return null;
-        }
-    }
-    /**
-     * Get attribute value.
-     *
-     * Returns the attribute value if present.
-     *
-     * - Missing attributes return `null`.
-     * - Boolean attributes return `null`.
-     * - `DynamicValue` returns attribute expression.
-     *
-     * @param key - Attribute name
-     * @returns Attribute value or null.
-     */
-    getAttributeValue(key) {
-        const attr = this.getAttribute(key);
-        if (attr) {
-            return attr.value !== null ? attr.value.toString() : null;
-        }
-        else {
-            return null;
-        }
-    }
-    /**
-     * Add text as a child node to this element.
-     *
-     * @param text - Text to add.
-     * @param location - Source code location of this text.
-     */
-    appendText(text, location) {
-        this.childNodes.push(new TextNode(text, location));
-    }
-    /**
-     * Return a list of all known classes on the element. Dynamic values are
-     * ignored.
-     */
-    get classList() {
-        if (!this.hasAttribute("class")) {
-            return new DOMTokenList(null, null);
-        }
-        const classes = this.getAttribute("class", true)
-            .filter((attr) => attr.isStatic)
-            .map((attr) => attr.value)
-            .join(" ");
-        return new DOMTokenList(classes, null);
-    }
-    /**
-     * Get element ID if present.
-     */
-    get id() {
-        return this.getAttributeValue("id");
-    }
-    get style() {
-        const attr = this.getAttribute("style");
-        return parseCssDeclaration(attr === null || attr === void 0 ? void 0 : attr.value);
-    }
-    /**
-     * Returns the first child element or null if there are no child elements.
-     */
-    get firstElementChild() {
-        const children = this.childElements;
-        return children.length > 0 ? children[0] : null;
-    }
-    /**
-     * Returns the last child element or null if there are no child elements.
-     */
-    get lastElementChild() {
-        const children = this.childElements;
-        return children.length > 0 ? children[children.length - 1] : null;
-    }
-    get siblings() {
-        return this.parent ? this.parent.childElements : [this];
-    }
-    get previousSibling() {
-        const i = this.siblings.findIndex((node) => node.unique === this.unique);
-        return i >= 1 ? this.siblings[i - 1] : null;
-    }
-    get nextSibling() {
-        const i = this.siblings.findIndex((node) => node.unique === this.unique);
-        return i <= this.siblings.length - 2 ? this.siblings[i + 1] : null;
-    }
-    getElementsByTagName(tagName) {
-        return this.childElements.reduce((matches, node) => {
-            return matches.concat(node.is(tagName) ? [node] : [], node.getElementsByTagName(tagName));
-        }, []);
-    }
-    querySelector(selector) {
-        const it = this.querySelectorImpl(selector);
-        const next = it.next();
-        if (next.done) {
-            return null;
-        }
-        else {
-            return next.value;
-        }
-    }
-    querySelectorAll(selector) {
-        const it = this.querySelectorImpl(selector);
-        const unique = new Set(it);
-        return Array.from(unique.values());
-    }
-    *querySelectorImpl(selectorList) {
-        if (!selectorList) {
-            return;
-        }
-        for (const selector of selectorList.split(/,\s*/)) {
-            const pattern = new Selector(selector);
-            yield* pattern.match(this);
-        }
-    }
-    /**
-     * Visit all nodes from this node and down. Depth first.
-     *
-     * @internal
-     */
-    visitDepthFirst(callback) {
-        function visit(node) {
-            node.childElements.forEach(visit);
-            if (!node.isRootElement()) {
-                callback(node);
-            }
-        }
-        visit(this);
-    }
-    /**
-     * Evaluates callbackk on all descendants, returning true if any are true.
-     *
-     * @internal
-     */
-    someChildren(callback) {
-        return this.childElements.some(visit);
-        function visit(node) {
-            if (callback(node)) {
-                return true;
-            }
-            else {
-                return node.childElements.some(visit);
-            }
-        }
-    }
-    /**
-     * Evaluates callbackk on all descendants, returning true if all are true.
-     *
-     * @internal
-     */
-    everyChildren(callback) {
-        return this.childElements.every(visit);
-        function visit(node) {
-            if (!callback(node)) {
-                return false;
-            }
-            return node.childElements.every(visit);
-        }
-    }
-    /**
-     * Visit all nodes from this node and down. Breadth first.
-     *
-     * The first node for which the callback evaluates to true is returned.
-     *
-     * @internal
-     */
-    find(callback) {
-        function visit(node) {
-            if (callback(node)) {
-                return node;
-            }
-            for (const child of node.childElements) {
-                const match = child.find(callback);
-                if (match) {
-                    return match;
-                }
-            }
-            return null;
-        }
-        return visit(this);
-    }
-}
-function isClosed(endToken, meta) {
-    let closed = exports.NodeClosed.Open;
-    if (meta && meta.void) {
-        closed = exports.NodeClosed.VoidOmitted;
-    }
-    if (endToken.data[0] === "/>") {
-        closed = exports.NodeClosed.VoidSelfClosed;
-    }
-    return closed;
-}
-
-/**
- * @public
- */
-class DOMTree {
-    constructor(location) {
-        this.root = HtmlElement.rootNode(location);
-        this.active = this.root;
-        this.doctype = null;
-    }
-    pushActive(node) {
-        this.active = node;
-    }
-    popActive() {
-        if (this.active.isRootElement()) {
-            /* root element should never be popped, continue as if nothing happened */
-            return;
-        }
-        this.active = this.active.parent || this.root;
-    }
-    getActive() {
-        return this.active;
-    }
-    /**
-     * Resolve dynamic meta expressions.
-     */
-    resolveMeta(table) {
-        this.visitDepthFirst((node) => table.resolve(node));
-    }
-    getElementsByTagName(tagName) {
-        return this.root.getElementsByTagName(tagName);
-    }
-    visitDepthFirst(callback) {
-        this.root.visitDepthFirst(callback);
-    }
-    find(callback) {
-        return this.root.find(callback);
-    }
-    querySelector(selector) {
-        return this.root.querySelector(selector);
-    }
-    querySelectorAll(selector) {
-        return this.root.querySelectorAll(selector);
-    }
-}
-
-function stringify(value) {
-    if (typeof value === "string") {
-        return String(value);
-    }
-    else {
-        return JSON.stringify(value);
-    }
-}
-/**
- * Represents an `Error` created from arbitrary values.
- *
- * @public
- */
-class WrappedError extends Error {
-    constructor(message) {
-        super(stringify(message));
-    }
-}
-
-/**
- * Ensures the value is an Error.
- *
- * If the passed value is not an `Error` instance a [[WrappedError]] is
- * constructed with the stringified value.
- *
- * @internal
- */
-function ensureError(value) {
-    if (value instanceof Error) {
-        return value;
-    }
-    else {
-        return new WrappedError(value);
-    }
-}
-
-/**
- * @public
- */
-class NestedError extends Error {
-    constructor(message, nested) {
-        super(message);
-        Error.captureStackTrace(this, NestedError);
-        this.name = NestedError.name;
-        if (nested && nested.stack) {
-            this.stack += `\nCaused by: ${nested.stack}`;
-        }
-    }
-}
-
-/**
- * @public
- */
-class UserError extends NestedError {
-    constructor(message, nested) {
-        super(message, nested);
-        Error.captureStackTrace(this, UserError);
-        this.name = UserError.name;
-    }
-    /**
-     * @public
-     */
-    /* istanbul ignore next: default implementation */
-    prettyFormat() {
-        return undefined;
-    }
-}
-
-/**
- * @internal
- */
-class InheritError extends UserError {
-    constructor({ tagName, inherit }) {
-        const message = `Element <${tagName}> cannot inherit from <${inherit}>: no such element`;
-        super(message);
-        Error.captureStackTrace(this, InheritError);
-        this.name = InheritError.name;
-        this.tagName = tagName;
-        this.inherit = inherit;
-        this.filename = null;
-    }
-    prettyFormat() {
-        const { message, tagName, inherit } = this;
-        const source = this.filename
-            ? ["", "This error occurred when loading element metadata from:", `"${this.filename}"`, ""]
-            : [""];
-        return [
-            message,
-            ...source,
-            "This usually occurs when the elements are defined in the wrong order, try one of the following:",
-            "",
-            `  - Ensure the spelling of "${inherit}" is correct.`,
-            `  - Ensure the file containing "${inherit}" is loaded before the file containing "${tagName}".`,
-            `  - Move the definition of "${inherit}" above the definition for "${tagName}".`,
-        ].join("\n");
-    }
-}
-
-function getSummary(schema, obj, errors) {
-    const output = betterAjvErrors__default.default(schema, obj, errors, {
-        format: "js",
-    });
-    // istanbul ignore next: for safety only
-    return output.length > 0 ? output[0].error : "unknown validation error";
-}
-/**
- * @public
- */
-class SchemaValidationError extends UserError {
-    constructor(filename, message, obj, schema, errors) {
-        const summary = getSummary(schema, obj, errors);
-        super(`${message}: ${summary}`);
-        this.filename = filename;
-        this.obj = obj;
-        this.schema = schema;
-        this.errors = errors;
-    }
-    prettyError() {
-        const json = this.getRawJSON();
-        return betterAjvErrors__default.default(this.schema, this.obj, this.errors, {
-            format: "cli",
-            indent: 2,
-            json,
-        });
-    }
-    getRawJSON() {
-        if (this.filename && fs__default.default.existsSync(this.filename)) {
-            return fs__default.default.readFileSync(this.filename, "utf-8");
-        }
-        else {
-            return null;
-        }
-    }
-}
-
-/**
- * Computes hash for given string.
- *
- * @internal
- */
-function cyrb53(str) {
-    const a = 2654435761;
-    const b = 1597334677;
-    const c = 2246822507;
-    const d = 3266489909;
-    const e = 4294967296;
-    const f = 2097151;
-    const seed = 0;
-    let h1 = 0xdeadbeef ^ seed;
-    let h2 = 0x41c6ce57 ^ seed;
-    for (let i = 0, ch; i < str.length; i++) {
-        ch = str.charCodeAt(i);
-        h1 = Math.imul(h1 ^ ch, a);
-        h2 = Math.imul(h2 ^ ch, b);
-    }
-    h1 = Math.imul(h1 ^ (h1 >>> 16), c) ^ Math.imul(h2 ^ (h2 >>> 13), d);
-    h2 = Math.imul(h2 ^ (h2 >>> 16), c) ^ Math.imul(h1 ^ (h1 >>> 13), d);
-    return e * (f & h2) + (h1 >>> 0);
-}
-const computeHash = cyrb53;
+const computeHash = cyrb53;
 
 const $schema$1 = "http://json-schema.org/draft-06/schema#";
 const $id$1 = "https://html-validate.org/schemas/elements.json";
@@ -2235,487 +808,1914 @@ const definitions = {
 		}
 	}
 };
-var schema = {
-	$schema: $schema$1,
-	$id: $id$1,
-	type: type$1,
-	properties: properties$1,
-	patternProperties: patternProperties,
-	definitions: definitions
+var schema = {
+	$schema: $schema$1,
+	$id: $id$1,
+	type: type$1,
+	properties: properties$1,
+	patternProperties: patternProperties,
+	definitions: definitions
+};
+
+/**
+ * AJV keyword "regexp" to validate the type to be a regular expression.
+ * Injects errors with the "type" keyword to give the same output.
+ */
+/* istanbul ignore next: manual testing */
+const ajvRegexpValidate = function (data, dataCxt) {
+    const valid = data instanceof RegExp;
+    if (!valid) {
+        ajvRegexpValidate.errors = [
+            {
+                instancePath: dataCxt === null || dataCxt === void 0 ? void 0 : dataCxt.instancePath,
+                schemaPath: undefined,
+                keyword: "type",
+                message: "should be a regular expression",
+                params: {
+                    keyword: "type",
+                },
+            },
+        ];
+    }
+    return valid;
+};
+const ajvRegexpKeyword = {
+    keyword: "regexp",
+    schema: false,
+    errors: true,
+    validate: ajvRegexpValidate,
+};
+
+/**
+ * AJV keyword "function" to validate the type to be a function. Injects errors
+ * with the "type" keyword to give the same output.
+ */
+const ajvFunctionValidate = function (data, dataCxt) {
+    const valid = typeof data === "function";
+    if (!valid) {
+        ajvFunctionValidate.errors = [
+            {
+                instancePath: /* istanbul ignore next */ dataCxt === null || dataCxt === void 0 ? void 0 : dataCxt.instancePath,
+                schemaPath: undefined,
+                keyword: "type",
+                message: "should be a function",
+                params: {
+                    keyword: "type",
+                },
+            },
+        ];
+    }
+    return valid;
+};
+const ajvFunctionKeyword = {
+    keyword: "function",
+    schema: false,
+    errors: true,
+    validate: ajvFunctionValidate,
+};
+
+/**
+ * @public
+ */
+exports.TextContent = void 0;
+(function (TextContent) {
+    /* forbid node to have text content, inter-element whitespace is ignored */
+    TextContent["NONE"] = "none";
+    /* node can have text but not required too */
+    TextContent["DEFAULT"] = "default";
+    /* node requires text-nodes to be present (direct or by descendant) */
+    TextContent["REQUIRED"] = "required";
+    /* node requires accessible text (hidden text is ignored, tries to get text from accessibility tree) */
+    TextContent["ACCESSIBLE"] = "accessible";
+})(exports.TextContent || (exports.TextContent = {}));
+/**
+ * Properties listed here can be copied (loaded) onto another element using
+ * [[HtmlElement.loadMeta]].
+ *
+ * @public
+ */
+const MetaCopyableProperty = [
+    "metadata",
+    "flow",
+    "sectioning",
+    "heading",
+    "phrasing",
+    "embedded",
+    "interactive",
+    "transparent",
+    "form",
+    "formAssociated",
+    "labelable",
+    "attributes",
+    "permittedContent",
+    "permittedDescendants",
+    "permittedOrder",
+    "permittedParent",
+    "requiredAncestors",
+    "requiredContent",
+];
+/**
+ * @internal
+ */
+function setMetaProperty(dst, key, value) {
+    dst[key] = value;
+}
+
+function isSet(value) {
+    return typeof value !== "undefined";
+}
+function flag(value) {
+    return value ? true : undefined;
+}
+function stripUndefined(src) {
+    const entries = Object.entries(src).filter(([, value]) => isSet(value));
+    return Object.fromEntries(entries);
+}
+function migrateSingleAttribute(src, key) {
+    var _a, _b;
+    const result = {};
+    result.deprecated = flag((_a = src.deprecatedAttributes) === null || _a === void 0 ? void 0 : _a.includes(key));
+    result.required = flag((_b = src.requiredAttributes) === null || _b === void 0 ? void 0 : _b.includes(key));
+    result.omit = undefined;
+    const attr = src.attributes ? src.attributes[key] : undefined;
+    if (typeof attr === "undefined") {
+        return stripUndefined(result);
+    }
+    /* when the attribute is set to null we use a special property "delete" to
+     * flag it, if it is still set during merge (inheritance, overwriting, etc) the attribute will be removed */
+    if (attr === null) {
+        result.delete = true;
+        return stripUndefined(result);
+    }
+    if (Array.isArray(attr)) {
+        if (attr.length === 0) {
+            result.boolean = true;
+        }
+        else {
+            result.enum = attr.filter((it) => it !== "");
+            if (attr.includes("")) {
+                result.omit = true;
+            }
+        }
+        return stripUndefined(result);
+    }
+    else {
+        return stripUndefined({ ...result, ...attr });
+    }
+}
+function migrateAttributes(src) {
+    var _a, _b, _c;
+    const keys = [
+        ...Object.keys((_a = src.attributes) !== null && _a !== void 0 ? _a : {}),
+        ...((_b = src.requiredAttributes) !== null && _b !== void 0 ? _b : []),
+        ...((_c = src.deprecatedAttributes) !== null && _c !== void 0 ? _c : []),
+    ].sort();
+    const entries = keys.map((key) => {
+        return [key, migrateSingleAttribute(src, key)];
+    });
+    return Object.fromEntries(entries);
+}
+function migrateElement(src) {
+    const result = {
+        ...src,
+        ...{
+            formAssociated: undefined,
+        },
+        attributes: migrateAttributes(src),
+        textContent: src.textContent,
+    };
+    /* removed properties */
+    delete result.deprecatedAttributes;
+    delete result.requiredAttributes;
+    /* strip out undefined */
+    if (!result.textContent) {
+        delete result.textContent;
+    }
+    if (src.formAssociated) {
+        result.formAssociated = {
+            listed: Boolean(src.formAssociated.listed),
+        };
+    }
+    else {
+        delete result.formAssociated;
+    }
+    return result;
+}
+
+/**
+ * Returns true if given element is a descendant of given tagname.
+ *
+ * @internal
+ */
+function isDescendant(node, tagName) {
+    let cur = node.parent;
+    while (cur && !cur.isRootElement()) {
+        if (cur.is(tagName)) {
+            return true;
+        }
+        cur = cur.parent;
+    }
+    return false;
+}
+
+/**
+ * Returns true if given element has given attribute (no matter the value, null,
+ * dynamic, etc).
+ */
+function hasAttribute(node, attr) {
+    return node.hasAttribute(attr);
+}
+
+/**
+ * Matches attribute against value.
+ */
+function matchAttribute(node, key, op, value) {
+    const nodeValue = (node.getAttributeValue(key) || "").toLowerCase();
+    switch (op) {
+        case "!=":
+            return nodeValue !== value;
+        case "=":
+            return nodeValue === value;
+    }
+}
+
+const dynamicKeys = [
+    "metadata",
+    "flow",
+    "sectioning",
+    "heading",
+    "phrasing",
+    "embedded",
+    "interactive",
+    "labelable",
+];
+const functionTable = {
+    isDescendant: isDescendantFacade,
+    hasAttribute: hasAttributeFacade,
+    matchAttribute: matchAttributeFacade,
+};
+const schemaCache = new Map();
+function clone(src) {
+    return JSON.parse(JSON.stringify(src));
+}
+function overwriteMerge$1(a, b) {
+    return b;
+}
+/**
+ * @public
+ */
+class MetaTable {
+    /**
+     * @internal
+     */
+    constructor() {
+        this.elements = {};
+        this.schema = clone(schema);
+    }
+    /**
+     * @internal
+     */
+    init() {
+        this.resolveGlobal();
+    }
+    /**
+     * Extend validation schema.
+     *
+     * @public
+     */
+    extendValidationSchema(patch) {
+        if (patch.properties) {
+            this.schema = deepmerge__default.default(this.schema, {
+                patternProperties: {
+                    "^[^$].*$": {
+                        properties: patch.properties,
+                    },
+                },
+            });
+        }
+        if (patch.definitions) {
+            this.schema = deepmerge__default.default(this.schema, {
+                definitions: patch.definitions,
+            });
+        }
+    }
+    /**
+     * Load metadata table from object.
+     *
+     * @public
+     * @param obj - Object with metadata to load
+     * @param filename - Optional filename used when presenting validation error
+     */
+    loadFromObject(obj, filename = null) {
+        var _a;
+        try {
+            const validate = this.getSchemaValidator();
+            if (!validate(obj)) {
+                throw new SchemaValidationError(filename, `Element metadata is not valid`, obj, this.schema, 
+                /* istanbul ignore next: AJV sets .errors when validate returns false */
+                (_a = validate.errors) !== null && _a !== void 0 ? _a : []);
+            }
+            for (const [key, value] of Object.entries(obj)) {
+                if (key === "$schema")
+                    continue;
+                this.addEntry(key, migrateElement(value));
+            }
+        }
+        catch (err) {
+            if (err instanceof InheritError) {
+                err.filename = filename;
+                throw err;
+            }
+            if (err instanceof SchemaValidationError) {
+                throw err;
+            }
+            if (!filename) {
+                throw err;
+            }
+            throw new UserError(`Failed to load element metadata from "${filename}"`, ensureError(err));
+        }
+    }
+    /**
+     * Get [[MetaElement]] for the given tag. If no specific metadata is present
+     * the global metadata is returned or null if no global is present.
+     *
+     * @public
+     * @returns A shallow copy of metadata.
+     */
+    getMetaFor(tagName) {
+        /* try to locate by tagname */
+        tagName = tagName.toLowerCase();
+        if (this.elements[tagName]) {
+            return { ...this.elements[tagName] };
+        }
+        /* try to locate global element */
+        if (this.elements["*"]) {
+            return { ...this.elements["*"] };
+        }
+        return null;
+    }
+    /**
+     * Find all tags which has enabled given property.
+     *
+     * @public
+     */
+    getTagsWithProperty(propName) {
+        return Object.entries(this.elements)
+            .filter(([, entry]) => entry[propName])
+            .map(([tagName]) => tagName);
+    }
+    /**
+     * Find tag matching tagName or inheriting from it.
+     *
+     * @public
+     */
+    getTagsDerivedFrom(tagName) {
+        return Object.entries(this.elements)
+            .filter(([key, entry]) => key === tagName || entry.inherit === tagName)
+            .map(([tagName]) => tagName);
+    }
+    addEntry(tagName, entry) {
+        let parent = this.elements[tagName] || {};
+        /* handle inheritance */
+        if (entry.inherit) {
+            const name = entry.inherit;
+            parent = this.elements[name];
+            if (!parent) {
+                throw new InheritError({
+                    tagName,
+                    inherit: name,
+                });
+            }
+        }
+        /* merge all sources together */
+        const expanded = this.mergeElement(parent, { ...entry, tagName });
+        expandRegex(expanded);
+        this.elements[tagName] = expanded;
+    }
+    /**
+     * Construct a new AJV schema validator.
+     */
+    getSchemaValidator() {
+        const hash = computeHash(JSON.stringify(this.schema));
+        const cached = schemaCache.get(hash);
+        if (cached) {
+            return cached;
+        }
+        else {
+            const ajv = new Ajv__default.default({ strict: true, strictTuples: true, strictTypes: true });
+            ajv.addMetaSchema(ajvSchemaDraft);
+            ajv.addKeyword(ajvFunctionKeyword);
+            ajv.addKeyword(ajvRegexpKeyword);
+            ajv.addKeyword({ keyword: "copyable" });
+            const validate = ajv.compile(this.schema);
+            schemaCache.set(hash, validate);
+            return validate;
+        }
+    }
+    /**
+     * @public
+     */
+    getJSONSchema() {
+        return this.schema;
+    }
+    /**
+     * Finds the global element definition and merges each known element with the
+     * global, e.g. to assign global attributes.
+     */
+    resolveGlobal() {
+        /* skip if there is no global elements */
+        if (!this.elements["*"])
+            return;
+        /* fetch and remove the global element, it should not be resolvable by
+         * itself */
+        const global = this.elements["*"];
+        delete this.elements["*"];
+        /* hack: unset default properties which global should not override */
+        delete global.tagName;
+        delete global.void;
+        /* merge elements */
+        for (const [tagName, entry] of Object.entries(this.elements)) {
+            this.elements[tagName] = this.mergeElement(global, entry);
+        }
+    }
+    mergeElement(a, b) {
+        const merged = deepmerge__default.default(a, b, { arrayMerge: overwriteMerge$1 });
+        /* special handling when removing attributes by setting them to null
+         * resulting in the deletion flag being set */
+        const filteredAttrs = Object.entries(merged.attributes).filter(([, attr]) => {
+            const val = !attr.delete;
+            delete attr.delete;
+            return val;
+        });
+        merged.attributes = Object.fromEntries(filteredAttrs);
+        return merged;
+    }
+    /**
+     * @internal
+     */
+    resolve(node) {
+        if (node.meta) {
+            expandProperties(node, node.meta);
+        }
+    }
+}
+function expandProperties(node, entry) {
+    for (const key of dynamicKeys) {
+        const property = entry[key];
+        if (property && typeof property !== "boolean") {
+            setMetaProperty(entry, key, evaluateProperty(node, property));
+        }
+    }
+}
+/**
+ * Given a string it returns either the string as-is or if the string is wrapped
+ * in /../ it creates and returns a regex instead.
+ */
+function expandRegexValue(value) {
+    if (value instanceof RegExp) {
+        return value;
+    }
+    const match = value.match(/^\/\^?([^/$]*)\$?\/([i]*)$/);
+    if (match) {
+        const [, expr, flags] = match;
+        // eslint-disable-next-line security/detect-non-literal-regexp -- expected to be regexp
+        return new RegExp(`^${expr}$`, flags);
+    }
+    else {
+        return value;
+    }
+}
+/**
+ * Expand all regular expressions in strings ("/../"). This mutates the object.
+ */
+function expandRegex(entry) {
+    for (const [name, values] of Object.entries(entry.attributes)) {
+        if (values.enum) {
+            entry.attributes[name].enum = values.enum.map(expandRegexValue);
+        }
+    }
+}
+function evaluateProperty(node, expr) {
+    const [func, options] = parseExpression(expr);
+    return func(node, options);
+}
+function parseExpression(expr) {
+    if (typeof expr === "string") {
+        return parseExpression([expr, {}]);
+    }
+    else {
+        /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- old style expressions should be replaced with typesafe functions */
+        const [funcName, options] = expr;
+        const func = functionTable[funcName];
+        if (!func) {
+            throw new Error(`Failed to find function "${funcName}" when evaluating property expression`);
+        }
+        return [func, options];
+    }
+}
+function isDescendantFacade(node, tagName) {
+    if (typeof tagName !== "string") {
+        throw new Error(`Property expression "isDescendant" must take string argument when evaluating metadata for <${node.tagName}>`);
+    }
+    return isDescendant(node, tagName);
+}
+function hasAttributeFacade(node, attr) {
+    if (typeof attr !== "string") {
+        throw new Error(`Property expression "hasAttribute" must take string argument when evaluating metadata for <${node.tagName}>`);
+    }
+    return hasAttribute(node, attr);
+}
+function matchAttributeFacade(node, match) {
+    if (!Array.isArray(match) || match.length !== 3) {
+        throw new Error(`Property expression "matchAttribute" must take [key, op, value] array as argument when evaluating metadata for <${node.tagName}>`);
+    }
+    const [key, op, value] = match.map((x) => x.toLowerCase());
+    switch (op) {
+        case "!=":
+        case "=":
+            return matchAttribute(node, key, op, value);
+        default:
+            throw new Error(`Property expression "matchAttribute" has invalid operator "${op}" when evaluating metadata for <${node.tagName}>`);
+    }
+}
+
+/**
+ * @public
+ */
+class DynamicValue {
+    constructor(expr) {
+        this.expr = expr;
+    }
+    toString() {
+        return this.expr;
+    }
+}
+
+/**
+ * DOM Attribute.
+ *
+ * Represents a HTML attribute. Can contain either a fixed static value or a
+ * placeholder for dynamic values (e.g. interpolated).
+ *
+ * @public
+ */
+class Attribute {
+    /**
+     * @param key - Attribute name.
+     * @param value - Attribute value. Set to `null` for boolean attributes.
+     * @param keyLocation - Source location of attribute name.
+     * @param valueLocation - Source location of attribute value.
+     * @param originalAttribute - If this attribute was dynamically added via a
+     * transformation (e.g. vuejs `:id` generating the `id` attribute) this
+     * parameter should be set to the attribute name of the source attribute (`:id`).
+     */
+    constructor(key, value, keyLocation, valueLocation, originalAttribute) {
+        this.key = key;
+        this.value = value;
+        this.keyLocation = keyLocation;
+        this.valueLocation = valueLocation;
+        this.originalAttribute = originalAttribute;
+        /* force undefined to null */
+        if (typeof this.value === "undefined") {
+            this.value = null;
+        }
+    }
+    /**
+     * Flag set to true if the attribute value is static.
+     */
+    get isStatic() {
+        return !this.isDynamic;
+    }
+    /**
+     * Flag set to true if the attribute value is dynamic.
+     */
+    get isDynamic() {
+        return this.value instanceof DynamicValue;
+    }
+    valueMatches(pattern, dynamicMatches = true) {
+        if (this.value === null) {
+            return false;
+        }
+        /* dynamic values matches everything */
+        if (this.value instanceof DynamicValue) {
+            return dynamicMatches;
+        }
+        /* test against an array of keywords */
+        if (Array.isArray(pattern)) {
+            return pattern.includes(this.value);
+        }
+        /* test value against pattern */
+        if (pattern instanceof RegExp) {
+            return this.value.match(pattern) !== null;
+        }
+        else {
+            return this.value === pattern;
+        }
+    }
+}
+
+function getCSSDeclarations(value) {
+    return value
+        .trim()
+        .split(";")
+        .filter(Boolean)
+        .map((it) => {
+        const [property, value] = it.split(":", 2);
+        return [property.trim(), value ? value.trim() : ""];
+    });
+}
+/**
+ * @internal
+ */
+function parseCssDeclaration(value) {
+    if (!value || value instanceof DynamicValue) {
+        return {};
+    }
+    const pairs = getCSSDeclarations(value);
+    return Object.fromEntries(pairs);
+}
+
+function sliceSize(size, begin, end) {
+    if (typeof size !== "number") {
+        return size;
+    }
+    if (typeof end !== "number") {
+        return size - begin;
+    }
+    if (end < 0) {
+        end = size + end;
+    }
+    return Math.min(size, end - begin);
+}
+function sliceLocation(location, begin, end, wrap) {
+    if (!location)
+        return null;
+    const size = sliceSize(location.size, begin, end);
+    const sliced = {
+        filename: location.filename,
+        offset: location.offset + begin,
+        line: location.line,
+        column: location.column + begin,
+        size,
+    };
+    /* if text content is provided try to find all newlines and modify line/column accordingly */
+    if (wrap) {
+        let index = -1;
+        const col = sliced.column;
+        do {
+            index = wrap.indexOf("\n", index + 1);
+            if (index >= 0 && index < begin) {
+                sliced.column = col - (index + 1);
+                sliced.line++;
+            }
+            else {
+                break;
+            }
+        } while (true); // eslint-disable-line no-constant-condition -- it will break out
+    }
+    return sliced;
+}
+
+var State;
+(function (State) {
+    State[State["INITIAL"] = 1] = "INITIAL";
+    State[State["DOCTYPE"] = 2] = "DOCTYPE";
+    State[State["TEXT"] = 3] = "TEXT";
+    State[State["TAG"] = 4] = "TAG";
+    State[State["ATTR"] = 5] = "ATTR";
+    State[State["CDATA"] = 6] = "CDATA";
+    State[State["SCRIPT"] = 7] = "SCRIPT";
+    State[State["STYLE"] = 8] = "STYLE";
+})(State || (State = {}));
+
+var ContentModel;
+(function (ContentModel) {
+    ContentModel[ContentModel["TEXT"] = 1] = "TEXT";
+    ContentModel[ContentModel["SCRIPT"] = 2] = "SCRIPT";
+    ContentModel[ContentModel["STYLE"] = 3] = "STYLE";
+})(ContentModel || (ContentModel = {}));
+class Context {
+    constructor(source) {
+        var _a, _b, _c, _d;
+        this.state = State.INITIAL;
+        this.string = source.data;
+        this.filename = (_a = source.filename) !== null && _a !== void 0 ? _a : "";
+        this.offset = (_b = source.offset) !== null && _b !== void 0 ? _b : 0;
+        this.line = (_c = source.line) !== null && _c !== void 0 ? _c : 1;
+        this.column = (_d = source.column) !== null && _d !== void 0 ? _d : 1;
+        this.contentModel = ContentModel.TEXT;
+    }
+    getTruncatedLine(n = 13) {
+        return JSON.stringify(this.string.length > n ? `${this.string.slice(0, 10)}...` : this.string);
+    }
+    consume(n, state) {
+        /* if "n" is an regex match the first value is the full matched
+         * string so consume that many characters. */
+        if (typeof n !== "number") {
+            n = n[0].length; /* regex match */
+        }
+        /* poor mans line counter :( */
+        let consumed = this.string.slice(0, n);
+        let offset;
+        while ((offset = consumed.indexOf("\n")) >= 0) {
+            this.line++;
+            this.column = 1;
+            consumed = consumed.substr(offset + 1);
+        }
+        this.column += consumed.length;
+        this.offset += n;
+        /* remove N chars */
+        this.string = this.string.substr(n);
+        /* change state */
+        this.state = state;
+    }
+    getLocation(size) {
+        return {
+            filename: this.filename,
+            offset: this.offset,
+            line: this.line,
+            column: this.column,
+            size,
+        };
+    }
+}
+
+/**
+ * @public
+ */
+exports.NodeType = void 0;
+(function (NodeType) {
+    NodeType[NodeType["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
+    NodeType[NodeType["TEXT_NODE"] = 3] = "TEXT_NODE";
+    NodeType[NodeType["DOCUMENT_NODE"] = 9] = "DOCUMENT_NODE";
+})(exports.NodeType || (exports.NodeType = {}));
+
+const DOCUMENT_NODE_NAME = "#document";
+const TEXT_CONTENT = Symbol("textContent");
+let counter = 0;
+/**
+ * @public
+ */
+class DOMNode {
+    /**
+     * Create a new DOMNode.
+     *
+     * @param nodeType - What node type to create.
+     * @param nodeName - What node name to use. For `HtmlElement` this corresponds
+     * to the tagName but other node types have specific predefined values.
+     * @param location - Source code location of this node.
+     */
+    constructor(nodeType, nodeName, location) {
+        this.nodeType = nodeType;
+        this.nodeName = nodeName !== null && nodeName !== void 0 ? nodeName : DOCUMENT_NODE_NAME;
+        this.location = location;
+        this.disabledRules = new Set();
+        this.blockedRules = new Map();
+        this.childNodes = [];
+        this.unique = counter++;
+        this.cache = null;
+    }
+    /**
+     * Enable cache for this node.
+     *
+     * Should not be called before the node and all children are fully constructed.
+     *
+     * @internal
+     */
+    cacheEnable() {
+        this.cache = new Map();
+    }
+    cacheGet(key) {
+        if (this.cache) {
+            return this.cache.get(key);
+        }
+        else {
+            return undefined;
+        }
+    }
+    cacheSet(key, value) {
+        if (this.cache) {
+            this.cache.set(key, value);
+        }
+        return value;
+    }
+    cacheRemove(key) {
+        if (this.cache) {
+            return this.cache.delete(key);
+        }
+        else {
+            return false;
+        }
+    }
+    cacheExists(key) {
+        return Boolean(this.cache && this.cache.has(key));
+    }
+    /**
+     * Get the text (recursive) from all child nodes.
+     */
+    get textContent() {
+        const cached = this.cacheGet(TEXT_CONTENT);
+        if (cached) {
+            return cached;
+        }
+        const text = this.childNodes.map((node) => node.textContent).join("");
+        this.cacheSet(TEXT_CONTENT, text);
+        return text;
+    }
+    append(node) {
+        this.childNodes.push(node);
+    }
+    isRootElement() {
+        return this.nodeType === exports.NodeType.DOCUMENT_NODE;
+    }
+    /**
+     * Tests if two nodes are the same (references the same object).
+     *
+     * @since v4.11.0
+     */
+    isSameNode(otherNode) {
+        return this.unique === otherNode.unique;
+    }
+    /**
+     * Returns a DOMNode representing the first direct child node or `null` if the
+     * node has no children.
+     */
+    get firstChild() {
+        return this.childNodes[0] || null;
+    }
+    /**
+     * Returns a DOMNode representing the last direct child node or `null` if the
+     * node has no children.
+     */
+    get lastChild() {
+        return this.childNodes[this.childNodes.length - 1] || null;
+    }
+    /**
+     * Block a rule for this node.
+     *
+     * @internal
+     */
+    blockRule(ruleId, blocker) {
+        const current = this.blockedRules.get(ruleId);
+        if (current) {
+            current.push(blocker);
+        }
+        else {
+            this.blockedRules.set(ruleId, [blocker]);
+        }
+    }
+    /**
+     * Blocks multiple rules.
+     *
+     * @internal
+     */
+    blockRules(rules, blocker) {
+        for (const rule of rules) {
+            this.blockRule(rule, blocker);
+        }
+    }
+    /**
+     * Disable a rule for this node.
+     *
+     * @internal
+     */
+    disableRule(ruleId) {
+        this.disabledRules.add(ruleId);
+    }
+    /**
+     * Disables multiple rules.
+     *
+     * @internal
+     */
+    disableRules(rules) {
+        for (const rule of rules) {
+            this.disableRule(rule);
+        }
+    }
+    /**
+     * Enable a previously disabled rule for this node.
+     */
+    enableRule(ruleId) {
+        this.disabledRules.delete(ruleId);
+    }
+    /**
+     * Enables multiple rules.
+     */
+    enableRules(rules) {
+        for (const rule of rules) {
+            this.enableRule(rule);
+        }
+    }
+    /**
+     * Test if a rule is enabled for this node.
+     *
+     * @internal
+     */
+    ruleEnabled(ruleId) {
+        return !this.disabledRules.has(ruleId);
+    }
+    /**
+     * Test if a rule is blocked for this node.
+     *
+     * @internal
+     */
+    ruleBlockers(ruleId) {
+        var _a;
+        return (_a = this.blockedRules.get(ruleId)) !== null && _a !== void 0 ? _a : [];
+    }
+    generateSelector() {
+        return null;
+    }
+}
+
+function parse(text, baseLocation) {
+    const tokens = [];
+    const locations = baseLocation ? [] : null;
+    for (let begin = 0; begin < text.length;) {
+        let end = text.indexOf(" ", begin);
+        /* if the last space was found move the position to the last character
+         * in the string */
+        if (end === -1) {
+            end = text.length;
+        }
+        /* handle multiple spaces */
+        const size = end - begin;
+        if (size === 0) {
+            begin++;
+            continue;
+        }
+        /* extract token */
+        const token = text.substring(begin, end);
+        tokens.push(token);
+        /* extract location */
+        if (locations && baseLocation) {
+            const location = sliceLocation(baseLocation, begin, end);
+            locations.push(location);
+        }
+        /* advance position to the character after the current end position */
+        begin += size + 1;
+    }
+    return { tokens, locations };
+}
+/**
+ * @public
+ */
+class DOMTokenList extends Array {
+    constructor(value, location) {
+        if (value && typeof value === "string") {
+            /* replace all whitespace with a single space for easier parsing */
+            const normalized = value.replace(/[\t\r\n]/g, " ");
+            const { tokens, locations } = parse(normalized, location);
+            super(...tokens);
+            this.locations = locations;
+        }
+        else {
+            super(0);
+            this.locations = null;
+        }
+        if (value instanceof DynamicValue) {
+            this.value = value.expr;
+        }
+        else {
+            this.value = value || "";
+        }
+    }
+    item(n) {
+        return this[n];
+    }
+    location(n) {
+        if (this.locations) {
+            return this.locations[n];
+        }
+        else {
+            throw new Error("Trying to access DOMTokenList location when base location isn't set");
+        }
+    }
+    contains(token) {
+        return this.includes(token);
+    }
+    *iterator() {
+        for (let index = 0; index < this.length; index++) {
+            /* eslint-disable @typescript-eslint/no-non-null-assertion -- as we loop over length this should always be set */
+            const item = this.item(index);
+            const location = this.location(index);
+            /* eslint-enable @typescript-eslint/no-non-null-assertion */
+            yield { index, item, location };
+        }
+    }
+}
+
+var Combinator;
+(function (Combinator) {
+    Combinator[Combinator["DESCENDANT"] = 1] = "DESCENDANT";
+    Combinator[Combinator["CHILD"] = 2] = "CHILD";
+    Combinator[Combinator["ADJACENT_SIBLING"] = 3] = "ADJACENT_SIBLING";
+    Combinator[Combinator["GENERAL_SIBLING"] = 4] = "GENERAL_SIBLING";
+    /* special cases */
+    Combinator[Combinator["SCOPE"] = 5] = "SCOPE";
+})(Combinator || (Combinator = {}));
+function parseCombinator(combinator, pattern) {
+    /* special case, when pattern is :scope [[Selector]] will handle this
+     * "combinator" to match itself instead of descendants */
+    if (pattern === ":scope") {
+        return Combinator.SCOPE;
+    }
+    switch (combinator) {
+        case undefined:
+        case null:
+        case "":
+            return Combinator.DESCENDANT;
+        case ">":
+            return Combinator.CHILD;
+        case "+":
+            return Combinator.ADJACENT_SIBLING;
+        case "~":
+            return Combinator.GENERAL_SIBLING;
+        default:
+            throw new Error(`Unknown combinator "${combinator}"`);
+    }
+}
+
+function firstChild(node) {
+    return node.previousSibling === null;
+}
+
+function lastChild(node) {
+    return node.nextSibling === null;
+}
+
+const cache = {};
+function getNthChild(node) {
+    if (!node.parent) {
+        return -1;
+    }
+    if (!cache[node.unique]) {
+        const parent = node.parent;
+        const index = parent.childElements.findIndex((cur) => {
+            return cur.unique === node.unique;
+        });
+        cache[node.unique] = index + 1; /* nthChild starts at 1 */
+    }
+    return cache[node.unique];
+}
+function nthChild(node, args) {
+    if (!args) {
+        throw new Error("Missing argument to nth-child");
+    }
+    const n = parseInt(args.trim(), 10);
+    const cur = getNthChild(node);
+    return cur === n;
+}
+
+function scope(node) {
+    return node.isSameNode(this.scope);
+}
+
+const table = {
+    "first-child": firstChild,
+    "last-child": lastChild,
+    "nth-child": nthChild,
+    scope: scope,
 };
+function factory(name, context) {
+    const fn = table[name];
+    if (fn) {
+        return fn.bind(context);
+    }
+    else {
+        throw new Error(`Pseudo-class "${name}" is not implemented`);
+    }
+}
+
+/**
+ * Homage to PHP: unescapes slashes.
+ *
+ * E.g. "foo\:bar" becomes "foo:bar"
+ */
+function stripslashes(value) {
+    return value.replace(/\\(.)/g, "$1");
+}
+/**
+ * @internal
+ */
+function escapeSelectorComponent(text) {
+    return text.toString().replace(/([^a-z0-9_-])/gi, "\\$1");
+}
+/**
+ * @internal
+ */
+function generateIdSelector(id) {
+    const escaped = escapeSelectorComponent(id);
+    return escaped.match(/^\d/) ? `[id="${escaped}"]` : `#${escaped}`;
+}
+/**
+ * Returns true if the character is a delimiter for different kinds of selectors:
+ *
+ * - `.` - begins a class selector
+ * - `#` - begins an id selector
+ * - `[` - begins an attribute selector
+ * - `:` - begins a pseudo class or element selector
+ */
+function isDelimiter(ch) {
+    return /[.#[:]/.test(ch);
+}
+/**
+ * Returns true if the character is a quotation mark.
+ */
+function isQuotationMark(ch) {
+    return /['"]/.test(ch);
+}
+function isPseudoElement(ch, buffer) {
+    return ch === ":" && buffer === ":";
+}
+/**
+ * @internal
+ */
+function* splitPattern(pattern) {
+    if (pattern === "") {
+        return;
+    }
+    const end = pattern.length;
+    let begin = 0;
+    let cur = 1;
+    let quoted = false;
+    while (cur < end) {
+        const ch = pattern[cur];
+        const buffer = pattern.slice(begin, cur);
+        /* escaped character, ignore whatever is next */
+        if (ch === "\\") {
+            cur += 2;
+            continue;
+        }
+        /* if inside quoted string we only look for the end quotation mark */
+        if (quoted) {
+            if (ch === quoted) {
+                quoted = false;
+            }
+            cur += 1;
+            continue;
+        }
+        /* if the character is a quotation mark we store the character and the above
+         * condition will look for a similar end quotation mark */
+        if (isQuotationMark(ch)) {
+            quoted = ch;
+            cur += 1;
+            continue;
+        }
+        /* special case when using :: pseudo element selector */
+        if (isPseudoElement(ch, buffer)) {
+            cur += 1;
+            continue;
+        }
+        /* if the character is a delimiter we yield the string and reset the
+         * position */
+        if (isDelimiter(ch)) {
+            begin = cur;
+            yield buffer;
+        }
+        cur += 1;
+    }
+    /* yield the rest of the string */
+    const tail = pattern.slice(begin, cur);
+    yield tail;
+}
+class Matcher {
+}
+class ClassMatcher extends Matcher {
+    constructor(classname) {
+        super();
+        this.classname = classname;
+    }
+    match(node) {
+        return node.classList.contains(this.classname);
+    }
+}
+class IdMatcher extends Matcher {
+    constructor(id) {
+        super();
+        this.id = stripslashes(id);
+    }
+    match(node) {
+        return node.id === this.id;
+    }
+}
+class AttrMatcher extends Matcher {
+    constructor(attr) {
+        super();
+        const [, key, op, value] = attr.match(/^(.+?)(?:([~^$*|]?=)"([^"]+?)")?$/);
+        this.key = key;
+        this.op = op;
+        this.value = value;
+    }
+    match(node) {
+        const attr = node.getAttribute(this.key, true) || [];
+        return attr.some((cur) => {
+            switch (this.op) {
+                case undefined:
+                    return true; /* attribute exists */
+                case "=":
+                    return cur.value === this.value;
+                default:
+                    throw new Error(`Attribute selector operator ${this.op} is not implemented yet`);
+            }
+        });
+    }
+}
+class PseudoClassMatcher extends Matcher {
+    constructor(pseudoclass, context) {
+        super();
+        const match = pseudoclass.match(/^([^(]+)(?:\((.*)\))?$/);
+        if (!match) {
+            throw new Error(`Missing pseudo-class after colon in selector pattern "${context}"`);
+        }
+        const [, name, args] = match;
+        this.name = name;
+        this.args = args;
+    }
+    match(node, context) {
+        const fn = factory(this.name, context);
+        return fn(node, this.args);
+    }
+}
+class Pattern {
+    constructor(pattern) {
+        const match = pattern.match(/^([~+\->]?)((?:[*]|[^.#[:]+)?)(.*)$/);
+        match.shift(); /* remove full matched string */
+        this.selector = pattern;
+        this.combinator = parseCombinator(match.shift(), pattern);
+        this.tagName = match.shift() || "*";
+        this.pattern = Array.from(splitPattern(match[0]), (it) => this.createMatcher(it));
+    }
+    match(node, context) {
+        return node.is(this.tagName) && this.pattern.every((cur) => cur.match(node, context));
+    }
+    createMatcher(pattern) {
+        switch (pattern[0]) {
+            case ".":
+                return new ClassMatcher(pattern.slice(1));
+            case "#":
+                return new IdMatcher(pattern.slice(1));
+            case "[":
+                return new AttrMatcher(pattern.slice(1, -1));
+            case ":":
+                return new PseudoClassMatcher(pattern.slice(1), this.selector);
+            default:
+                /* istanbul ignore next: fallback solution, the switch cases should cover
+                 * everything and there is no known way to trigger this fallback */
+                throw new Error(`Failed to create matcher for "${pattern}"`);
+        }
+    }
+}
+/**
+ * DOM Selector.
+ */
+class Selector {
+    constructor(selector) {
+        this.pattern = Selector.parse(selector);
+    }
+    /**
+     * Match this selector against a HtmlElement.
+     *
+     * @param root - Element to match against.
+     * @returns Iterator with matched elements.
+     */
+    *match(root) {
+        const context = { scope: root };
+        yield* this.matchInternal(root, 0, context);
+    }
+    *matchInternal(root, level, context) {
+        if (level >= this.pattern.length) {
+            yield root;
+            return;
+        }
+        const pattern = this.pattern[level];
+        const matches = Selector.findCandidates(root, pattern);
+        for (const node of matches) {
+            if (!pattern.match(node, context)) {
+                continue;
+            }
+            yield* this.matchInternal(node, level + 1, context);
+        }
+    }
+    static parse(selector) {
+        /* strip whitespace before combinators, "ul > li" becomes "ul >li", for
+         * easier parsing */
+        selector = selector.replace(/([+~>]) /g, "$1");
+        const pattern = selector.split(/(?:(?<!\\) )+/);
+        return pattern.map((part) => new Pattern(part));
+    }
+    static findCandidates(root, pattern) {
+        switch (pattern.combinator) {
+            case Combinator.DESCENDANT:
+                return root.getElementsByTagName(pattern.tagName);
+            case Combinator.CHILD:
+                return root.childElements.filter((node) => node.is(pattern.tagName));
+            case Combinator.ADJACENT_SIBLING:
+                return Selector.findAdjacentSibling(root);
+            case Combinator.GENERAL_SIBLING:
+                return Selector.findGeneralSibling(root);
+            case Combinator.SCOPE:
+                return [root];
+        }
+        /* istanbul ignore next: fallback solution, the switch cases should cover
+         * everything and there is no known way to trigger this fallback */
+        return [];
+    }
+    static findAdjacentSibling(node) {
+        let adjacent = false;
+        return node.siblings.filter((cur) => {
+            if (adjacent) {
+                adjacent = false;
+                return true;
+            }
+            if (cur === node) {
+                adjacent = true;
+            }
+            return false;
+        });
+    }
+    static findGeneralSibling(node) {
+        let after = false;
+        return node.siblings.filter((cur) => {
+            if (after) {
+                return true;
+            }
+            if (cur === node) {
+                after = true;
+            }
+            return false;
+        });
+    }
+}
+
+const TEXT_NODE_NAME = "#text";
+/**
+ * Returns true if the node is a text node.
+ *
+ * @public
+ */
+function isTextNode(node) {
+    return Boolean(node && node.nodeType === exports.NodeType.TEXT_NODE);
+}
+/**
+ * Represents a text in the HTML document.
+ *
+ * Text nodes are appended as children of `HtmlElement` and cannot have childen
+ * of its own.
+ *
+ * @public
+ */
+class TextNode extends DOMNode {
+    /**
+     * @param text - Text to add. When a `DynamicValue` is used the expression is
+     * used as "text".
+     * @param location - Source code location of this node.
+     */
+    constructor(text, location) {
+        super(exports.NodeType.TEXT_NODE, TEXT_NODE_NAME, location);
+        this.text = text;
+    }
+    /**
+     * Get the text from node.
+     */
+    get textContent() {
+        return this.text.toString();
+    }
+    /**
+     * Flag set to true if the attribute value is static.
+     */
+    get isStatic() {
+        return !this.isDynamic;
+    }
+    /**
+     * Flag set to true if the attribute value is dynamic.
+     */
+    get isDynamic() {
+        return this.text instanceof DynamicValue;
+    }
+}
 
 /**
- * AJV keyword "regexp" to validate the type to be a regular expression.
- * Injects errors with the "type" keyword to give the same output.
+ * @public
  */
-/* istanbul ignore next: manual testing */
-const ajvRegexpValidate = function (data, dataCxt) {
-    const valid = data instanceof RegExp;
-    if (!valid) {
-        ajvRegexpValidate.errors = [
-            {
-                instancePath: dataCxt === null || dataCxt === void 0 ? void 0 : dataCxt.instancePath,
-                schemaPath: undefined,
-                keyword: "type",
-                message: "should be a regular expression",
-                params: {
-                    keyword: "type",
-                },
-            },
-        ];
-    }
-    return valid;
-};
-const ajvRegexpKeyword = {
-    keyword: "regexp",
-    schema: false,
-    errors: true,
-    validate: ajvRegexpValidate,
-};
-
+exports.NodeClosed = void 0;
+(function (NodeClosed) {
+    NodeClosed[NodeClosed["Open"] = 0] = "Open";
+    NodeClosed[NodeClosed["EndTag"] = 1] = "EndTag";
+    NodeClosed[NodeClosed["VoidOmitted"] = 2] = "VoidOmitted";
+    NodeClosed[NodeClosed["VoidSelfClosed"] = 3] = "VoidSelfClosed";
+    NodeClosed[NodeClosed["ImplicitClosed"] = 4] = "ImplicitClosed";
+})(exports.NodeClosed || (exports.NodeClosed = {}));
 /**
- * AJV keyword "function" to validate the type to be a function. Injects errors
- * with the "type" keyword to give the same output.
+ * Returns true if the node is an element node.
+ *
+ * @public
  */
-const ajvFunctionValidate = function (data, dataCxt) {
-    const valid = typeof data === "function";
-    if (!valid) {
-        ajvFunctionValidate.errors = [
-            {
-                instancePath: /* istanbul ignore next */ dataCxt === null || dataCxt === void 0 ? void 0 : dataCxt.instancePath,
-                schemaPath: undefined,
-                keyword: "type",
-                message: "should be a function",
-                params: {
-                    keyword: "type",
-                },
-            },
-        ];
-    }
-    return valid;
-};
-const ajvFunctionKeyword = {
-    keyword: "function",
-    schema: false,
-    errors: true,
-    validate: ajvFunctionValidate,
-};
-
-function isSet(value) {
-    return typeof value !== "undefined";
-}
-function flag(value) {
-    return value ? true : undefined;
+function isElementNode(node) {
+    return Boolean(node && node.nodeType === exports.NodeType.ELEMENT_NODE);
 }
-function stripUndefined(src) {
-    const entries = Object.entries(src).filter(([, value]) => isSet(value));
-    return Object.fromEntries(entries);
+function isValidTagName(tagName) {
+    return Boolean(tagName !== "" && tagName !== "*");
 }
-function migrateSingleAttribute(src, key) {
-    var _a, _b;
-    const result = {};
-    result.deprecated = flag((_a = src.deprecatedAttributes) === null || _a === void 0 ? void 0 : _a.includes(key));
-    result.required = flag((_b = src.requiredAttributes) === null || _b === void 0 ? void 0 : _b.includes(key));
-    result.omit = undefined;
-    const attr = src.attributes ? src.attributes[key] : undefined;
-    if (typeof attr === "undefined") {
-        return stripUndefined(result);
+/**
+ * @public
+ */
+class HtmlElement extends DOMNode {
+    constructor(tagName, parent, closed, meta, location) {
+        const nodeType = tagName ? exports.NodeType.ELEMENT_NODE : exports.NodeType.DOCUMENT_NODE;
+        super(nodeType, tagName, location);
+        if (!isValidTagName(tagName)) {
+            throw new Error(`The tag name provided ('${tagName || ""}') is not a valid name`);
+        }
+        this.tagName = tagName || "#document";
+        this.parent = parent !== null && parent !== void 0 ? parent : null;
+        this.attr = {};
+        this.metaElement = meta !== null && meta !== void 0 ? meta : null;
+        this.closed = closed;
+        this.voidElement = meta ? Boolean(meta.void) : false;
+        this.depth = 0;
+        this.annotation = null;
+        if (parent) {
+            parent.childNodes.push(this);
+            /* calculate depth in domtree */
+            let cur = parent;
+            while (cur.parent) {
+                this.depth++;
+                cur = cur.parent;
+            }
+        }
     }
-    /* when the attribute is set to null we use a special property "delete" to
-     * flag it, if it is still set during merge (inheritance, overwriting, etc) the attribute will be removed */
-    if (attr === null) {
-        result.delete = true;
-        return stripUndefined(result);
+    /**
+     * @internal
+     */
+    static rootNode(location) {
+        const root = new HtmlElement(undefined, null, exports.NodeClosed.EndTag, null, location);
+        root.setAnnotation("#document");
+        return root;
     }
-    if (Array.isArray(attr)) {
-        if (attr.length === 0) {
-            result.boolean = true;
+    /**
+     * @internal
+     *
+     * @param namespace - If given it is appended to the tagName.
+     */
+    static fromTokens(startToken, endToken, parent, metaTable, namespace = "") {
+        const name = startToken.data[2];
+        const tagName = namespace ? `${namespace}:${name}` : name;
+        if (!name) {
+            throw new Error("tagName cannot be empty");
+        }
+        const meta = metaTable ? metaTable.getMetaFor(tagName) : null;
+        const open = startToken.data[1] !== "/";
+        const closed = isClosed(endToken, meta);
+        /* location contains position of '<' so strip it out */
+        const location = sliceLocation(startToken.location, 1);
+        return new HtmlElement(tagName, open ? parent : null, closed, meta, location);
+    }
+    /**
+     * Returns annotated name if set or defaults to `<tagName>`.
+     *
+     * E.g. `my-annotation` or `<div>`.
+     */
+    get annotatedName() {
+        if (this.annotation) {
+            return this.annotation;
+        }
+        else {
+            return `<${this.tagName}>`;
+        }
+    }
+    /**
+     * Get list of IDs referenced by `aria-labelledby`.
+     *
+     * If the attribute is unset or empty this getter returns null.
+     * If the attribute is dynamic the original {@link DynamicValue} is returned.
+     *
+     * @public
+     */
+    get ariaLabelledby() {
+        const attr = this.getAttribute("aria-labelledby");
+        if (!attr || !attr.value) {
+            return null;
+        }
+        if (attr.value instanceof DynamicValue) {
+            return attr.value;
+        }
+        const list = new DOMTokenList(attr.value, attr.valueLocation);
+        return list.length ? Array.from(list) : null;
+    }
+    /**
+     * Similar to childNodes but only elements.
+     */
+    get childElements() {
+        return this.childNodes.filter(isElementNode);
+    }
+    /**
+     * Find the first ancestor matching a selector.
+     *
+     * Implementation of DOM specification of Element.closest(selectors).
+     */
+    closest(selectors) {
+        /* eslint-disable-next-line @typescript-eslint/no-this-alias -- false positive*/
+        let node = this;
+        while (node) {
+            if (node.matches(selectors)) {
+                return node;
+            }
+            node = node.parent;
+        }
+        return null;
+    }
+    /**
+     * Generate a DOM selector for this element. The returned selector will be
+     * unique inside the current document.
+     */
+    generateSelector() {
+        /* root element cannot have a selector as it isn't a proper element */
+        if (this.isRootElement()) {
+            return null;
+        }
+        const parts = [];
+        let root;
+        /* eslint-disable-next-line @typescript-eslint/no-this-alias -- false positive */
+        for (root = this; root.parent; root = root.parent) {
+            /* .. */
+        }
+        // eslint-disable-next-line @typescript-eslint/no-this-alias -- false positive
+        for (let cur = this; cur.parent; cur = cur.parent) {
+            /* if a unique id is present, use it and short-circuit */
+            if (cur.id) {
+                const selector = generateIdSelector(cur.id);
+                const matches = root.querySelectorAll(selector);
+                if (matches.length === 1) {
+                    parts.push(selector);
+                    break;
+                }
+            }
+            const parent = cur.parent;
+            const child = parent.childElements;
+            const index = child.findIndex((it) => it.unique === cur.unique);
+            const numOfType = child.filter((it) => it.is(cur.tagName)).length;
+            const solo = numOfType === 1;
+            /* if this is the only tagName in this level of siblings nth-child isn't needed */
+            if (solo) {
+                parts.push(cur.tagName.toLowerCase());
+                continue;
+            }
+            /* this will generate the worst kind of selector but at least it will be accurate (optimizations welcome) */
+            parts.push(`${cur.tagName.toLowerCase()}:nth-child(${index + 1})`);
+        }
+        return parts.reverse().join(" > ");
+    }
+    /**
+     * Tests if this element has given tagname.
+     *
+     * If passing "*" this test will pass if any tagname is set.
+     */
+    is(tagName) {
+        return tagName === "*" || this.tagName.toLowerCase() === tagName.toLowerCase();
+    }
+    /**
+     * Load new element metadata onto this element.
+     *
+     * Do note that semantics such as `void` cannot be changed (as the element has
+     * already been created). In addition the element will still "be" the same
+     * element, i.e. even if loading meta for a `<p>` tag upon a `<div>` tag it
+     * will still be a `<div>` as far as the rest of the validator is concerned.
+     *
+     * In fact only certain properties will be copied onto the element:
+     *
+     * - content categories (flow, phrasing, etc)
+     * - required attributes
+     * - attribute allowed values
+     * - permitted/required elements
+     *
+     * Properties *not* loaded:
+     *
+     * - inherit
+     * - deprecated
+     * - foreign
+     * - void
+     * - implicitClosed
+     * - scriptSupporting
+     * - deprecatedAttributes
+     *
+     * Changes to element metadata will only be visible after `element:ready` (and
+     * the subsequent `dom:ready` event).
+     */
+    loadMeta(meta) {
+        if (!this.metaElement) {
+            this.metaElement = {};
         }
-        else {
-            result.enum = attr.filter((it) => it !== "");
-            if (attr.includes("")) {
-                result.omit = true;
+        for (const key of MetaCopyableProperty) {
+            const value = meta[key];
+            if (typeof value !== "undefined") {
+                setMetaProperty(this.metaElement, key, value);
+            }
+            else {
+                delete this.metaElement[key];
             }
         }
-        return stripUndefined(result);
-    }
-    else {
-        return stripUndefined({ ...result, ...attr });
-    }
-}
-function migrateAttributes(src) {
-    var _a, _b, _c;
-    const keys = [
-        ...Object.keys((_a = src.attributes) !== null && _a !== void 0 ? _a : {}),
-        ...((_b = src.requiredAttributes) !== null && _b !== void 0 ? _b : []),
-        ...((_c = src.deprecatedAttributes) !== null && _c !== void 0 ? _c : []),
-    ].sort();
-    const entries = keys.map((key) => {
-        return [key, migrateSingleAttribute(src, key)];
-    });
-    return Object.fromEntries(entries);
-}
-function migrateElement(src) {
-    const result = {
-        ...src,
-        ...{
-            formAssociated: undefined,
-        },
-        attributes: migrateAttributes(src),
-        textContent: src.textContent,
-    };
-    /* removed properties */
-    delete result.deprecatedAttributes;
-    delete result.requiredAttributes;
-    /* strip out undefined */
-    if (!result.textContent) {
-        delete result.textContent;
-    }
-    if (src.formAssociated) {
-        result.formAssociated = {
-            listed: Boolean(src.formAssociated.listed),
-        };
-    }
-    else {
-        delete result.formAssociated;
     }
-    return result;
-}
-
-/**
- * Returns true if given element is a descendant of given tagname.
- *
- * @internal
- */
-function isDescendant(node, tagName) {
-    let cur = node.parent;
-    while (cur && !cur.isRootElement()) {
-        if (cur.is(tagName)) {
-            return true;
+    /**
+     * Match this element against given selectors. Returns true if any selector
+     * matches.
+     *
+     * Implementation of DOM specification of Element.matches(selectors).
+     */
+    matches(selector) {
+        /* find root element */
+        /* eslint-disable-next-line @typescript-eslint/no-this-alias -- false positive */
+        let root = this;
+        while (root.parent) {
+            root = root.parent;
         }
-        cur = cur.parent;
+        /* a bit slow implementation as it finds all candidates for the selector and
+         * then tests if any of them are the current element. A better
+         * implementation would be to walk the selector right-to-left and test
+         * ancestors. */
+        for (const match of root.querySelectorAll(selector)) {
+            if (match.unique === this.unique) {
+                return true;
+            }
+        }
+        return false;
     }
-    return false;
-}
-
-/**
- * Returns true if given element has given attribute (no matter the value, null,
- * dynamic, etc).
- */
-function hasAttribute(node, attr) {
-    return node.hasAttribute(attr);
-}
-
-/**
- * Matches attribute against value.
- */
-function matchAttribute(node, key, op, value) {
-    const nodeValue = (node.getAttributeValue(key) || "").toLowerCase();
-    switch (op) {
-        case "!=":
-            return nodeValue !== value;
-        case "=":
-            return nodeValue === value;
+    get meta() {
+        return this.metaElement;
     }
-}
-
-const dynamicKeys = [
-    "metadata",
-    "flow",
-    "sectioning",
-    "heading",
-    "phrasing",
-    "embedded",
-    "interactive",
-    "labelable",
-];
-const functionTable = {
-    isDescendant: isDescendantFacade,
-    hasAttribute: hasAttributeFacade,
-    matchAttribute: matchAttributeFacade,
-};
-const schemaCache = new Map();
-function clone(src) {
-    return JSON.parse(JSON.stringify(src));
-}
-function overwriteMerge$1(a, b) {
-    return b;
-}
-/**
- * @public
- */
-class MetaTable {
     /**
-     * @internal
+     * Set annotation for this element.
      */
-    constructor() {
-        this.elements = {};
-        this.schema = clone(schema);
+    setAnnotation(text) {
+        this.annotation = text;
     }
     /**
-     * @internal
+     * Set attribute. Stores all attributes set even with the same name.
+     *
+     * @param key - Attribute name
+     * @param value - Attribute value. Use `null` if no value is present.
+     * @param keyLocation - Location of the attribute name.
+     * @param valueLocation - Location of the attribute value (excluding quotation)
+     * @param originalAttribute - If attribute is an alias for another attribute
+     * (dynamic attributes) set this to the original attribute name.
      */
-    init() {
-        this.resolveGlobal();
+    setAttribute(key, value, keyLocation, valueLocation, originalAttribute) {
+        key = key.toLowerCase();
+        if (!this.attr[key]) {
+            this.attr[key] = [];
+        }
+        this.attr[key].push(new Attribute(key, value, keyLocation, valueLocation, originalAttribute));
     }
     /**
-     * Extend validation schema.
-     *
-     * @public
+     * Get a list of all attributes on this node.
      */
-    extendValidationSchema(patch) {
-        if (patch.properties) {
-            this.schema = deepmerge__default.default(this.schema, {
-                patternProperties: {
-                    "^[^$].*$": {
-                        properties: patch.properties,
-                    },
-                },
-            });
+    get attributes() {
+        return Object.values(this.attr).reduce((result, cur) => {
+            return result.concat(cur);
+        }, []);
+    }
+    hasAttribute(key) {
+        key = key.toLowerCase();
+        return key in this.attr;
+    }
+    getAttribute(key, all = false) {
+        key = key.toLowerCase();
+        if (key in this.attr) {
+            const matches = this.attr[key];
+            return all ? matches : matches[0];
         }
-        if (patch.definitions) {
-            this.schema = deepmerge__default.default(this.schema, {
-                definitions: patch.definitions,
-            });
+        else {
+            return null;
         }
     }
     /**
-     * Load metadata table from object.
+     * Get attribute value.
      *
-     * @public
-     * @param obj - Object with metadata to load
-     * @param filename - Optional filename used when presenting validation error
+     * Returns the attribute value if present.
+     *
+     * - Missing attributes return `null`.
+     * - Boolean attributes return `null`.
+     * - `DynamicValue` returns attribute expression.
+     *
+     * @param key - Attribute name
+     * @returns Attribute value or null.
      */
-    loadFromObject(obj, filename = null) {
-        var _a;
-        try {
-            const validate = this.getSchemaValidator();
-            if (!validate(obj)) {
-                throw new SchemaValidationError(filename, `Element metadata is not valid`, obj, this.schema, 
-                /* istanbul ignore next: AJV sets .errors when validate returns false */
-                (_a = validate.errors) !== null && _a !== void 0 ? _a : []);
-            }
-            for (const [key, value] of Object.entries(obj)) {
-                if (key === "$schema")
-                    continue;
-                this.addEntry(key, migrateElement(value));
-            }
+    getAttributeValue(key) {
+        const attr = this.getAttribute(key);
+        if (attr) {
+            return attr.value !== null ? attr.value.toString() : null;
         }
-        catch (err) {
-            if (err instanceof InheritError) {
-                err.filename = filename;
-                throw err;
-            }
-            if (err instanceof SchemaValidationError) {
-                throw err;
-            }
-            if (!filename) {
-                throw err;
-            }
-            throw new UserError(`Failed to load element metadata from "${filename}"`, ensureError(err));
+        else {
+            return null;
         }
     }
     /**
-     * Get [[MetaElement]] for the given tag. If no specific metadata is present
-     * the global metadata is returned or null if no global is present.
+     * Add text as a child node to this element.
      *
-     * @public
-     * @returns A shallow copy of metadata.
+     * @param text - Text to add.
+     * @param location - Source code location of this text.
      */
-    getMetaFor(tagName) {
-        /* try to locate by tagname */
-        tagName = tagName.toLowerCase();
-        if (this.elements[tagName]) {
-            return { ...this.elements[tagName] };
-        }
-        /* try to locate global element */
-        if (this.elements["*"]) {
-            return { ...this.elements["*"] };
-        }
-        return null;
+    appendText(text, location) {
+        this.childNodes.push(new TextNode(text, location));
     }
     /**
-     * Find all tags which has enabled given property.
-     *
-     * @public
+     * Return a list of all known classes on the element. Dynamic values are
+     * ignored.
      */
-    getTagsWithProperty(propName) {
-        return Object.entries(this.elements)
-            .filter(([, entry]) => entry[propName])
-            .map(([tagName]) => tagName);
+    get classList() {
+        if (!this.hasAttribute("class")) {
+            return new DOMTokenList(null, null);
+        }
+        const classes = this.getAttribute("class", true)
+            .filter((attr) => attr.isStatic)
+            .map((attr) => attr.value)
+            .join(" ");
+        return new DOMTokenList(classes, null);
     }
     /**
-     * Find tag matching tagName or inheriting from it.
-     *
-     * @public
+     * Get element ID if present.
      */
-    getTagsDerivedFrom(tagName) {
-        return Object.entries(this.elements)
-            .filter(([key, entry]) => key === tagName || entry.inherit === tagName)
-            .map(([tagName]) => tagName);
+    get id() {
+        return this.getAttributeValue("id");
     }
-    addEntry(tagName, entry) {
-        let parent = this.elements[tagName] || {};
-        /* handle inheritance */
-        if (entry.inherit) {
-            const name = entry.inherit;
-            parent = this.elements[name];
-            if (!parent) {
-                throw new InheritError({
-                    tagName,
-                    inherit: name,
-                });
-            }
-        }
-        /* merge all sources together */
-        const expanded = this.mergeElement(parent, { ...entry, tagName });
-        expandRegex(expanded);
-        this.elements[tagName] = expanded;
+    get style() {
+        const attr = this.getAttribute("style");
+        return parseCssDeclaration(attr === null || attr === void 0 ? void 0 : attr.value);
     }
     /**
-     * Construct a new AJV schema validator.
+     * Returns the first child element or null if there are no child elements.
      */
-    getSchemaValidator() {
-        const hash = computeHash(JSON.stringify(this.schema));
-        const cached = schemaCache.get(hash);
-        if (cached) {
-            return cached;
+    get firstElementChild() {
+        const children = this.childElements;
+        return children.length > 0 ? children[0] : null;
+    }
+    /**
+     * Returns the last child element or null if there are no child elements.
+     */
+    get lastElementChild() {
+        const children = this.childElements;
+        return children.length > 0 ? children[children.length - 1] : null;
+    }
+    get siblings() {
+        return this.parent ? this.parent.childElements : [this];
+    }
+    get previousSibling() {
+        const i = this.siblings.findIndex((node) => node.unique === this.unique);
+        return i >= 1 ? this.siblings[i - 1] : null;
+    }
+    get nextSibling() {
+        const i = this.siblings.findIndex((node) => node.unique === this.unique);
+        return i <= this.siblings.length - 2 ? this.siblings[i + 1] : null;
+    }
+    getElementsByTagName(tagName) {
+        return this.childElements.reduce((matches, node) => {
+            return matches.concat(node.is(tagName) ? [node] : [], node.getElementsByTagName(tagName));
+        }, []);
+    }
+    querySelector(selector) {
+        const it = this.querySelectorImpl(selector);
+        const next = it.next();
+        if (next.done) {
+            return null;
         }
         else {
-            const ajv = new Ajv__default.default({ strict: true, strictTuples: true, strictTypes: true });
-            ajv.addMetaSchema(ajvSchemaDraft);
-            ajv.addKeyword(ajvFunctionKeyword);
-            ajv.addKeyword(ajvRegexpKeyword);
-            ajv.addKeyword({ keyword: "copyable" });
-            const validate = ajv.compile(this.schema);
-            schemaCache.set(hash, validate);
-            return validate;
+            return next.value;
+        }
+    }
+    querySelectorAll(selector) {
+        const it = this.querySelectorImpl(selector);
+        const unique = new Set(it);
+        return Array.from(unique.values());
+    }
+    *querySelectorImpl(selectorList) {
+        if (!selectorList) {
+            return;
+        }
+        for (const selector of selectorList.split(/,\s*/)) {
+            const pattern = new Selector(selector);
+            yield* pattern.match(this);
         }
     }
     /**
-     * @public
+     * Visit all nodes from this node and down. Depth first.
+     *
+     * @internal
      */
-    getJSONSchema() {
-        return this.schema;
+    visitDepthFirst(callback) {
+        function visit(node) {
+            node.childElements.forEach(visit);
+            if (!node.isRootElement()) {
+                callback(node);
+            }
+        }
+        visit(this);
     }
     /**
-     * Finds the global element definition and merges each known element with the
-     * global, e.g. to assign global attributes.
+     * Evaluates callbackk on all descendants, returning true if any are true.
+     *
+     * @internal
      */
-    resolveGlobal() {
-        /* skip if there is no global elements */
-        if (!this.elements["*"])
-            return;
-        /* fetch and remove the global element, it should not be resolvable by
-         * itself */
-        const global = this.elements["*"];
-        delete this.elements["*"];
-        /* hack: unset default properties which global should not override */
-        delete global.tagName;
-        delete global.void;
-        /* merge elements */
-        for (const [tagName, entry] of Object.entries(this.elements)) {
-            this.elements[tagName] = this.mergeElement(global, entry);
+    someChildren(callback) {
+        return this.childElements.some(visit);
+        function visit(node) {
+            if (callback(node)) {
+                return true;
+            }
+            else {
+                return node.childElements.some(visit);
+            }
         }
     }
-    mergeElement(a, b) {
-        const merged = deepmerge__default.default(a, b, { arrayMerge: overwriteMerge$1 });
-        /* special handling when removing attributes by setting them to null
-         * resulting in the deletion flag being set */
-        const filteredAttrs = Object.entries(merged.attributes).filter(([, attr]) => {
-            const val = !attr.delete;
-            delete attr.delete;
-            return val;
-        });
-        merged.attributes = Object.fromEntries(filteredAttrs);
-        return merged;
-    }
     /**
+     * Evaluates callbackk on all descendants, returning true if all are true.
+     *
      * @internal
      */
-    resolve(node) {
-        if (node.meta) {
-            expandProperties(node, node.meta);
+    everyChildren(callback) {
+        return this.childElements.every(visit);
+        function visit(node) {
+            if (!callback(node)) {
+                return false;
+            }
+            return node.childElements.every(visit);
         }
     }
-}
-function expandProperties(node, entry) {
-    for (const key of dynamicKeys) {
-        const property = entry[key];
-        if (property && typeof property !== "boolean") {
-            setMetaProperty(entry, key, evaluateProperty(node, property));
+    /**
+     * Visit all nodes from this node and down. Breadth first.
+     *
+     * The first node for which the callback evaluates to true is returned.
+     *
+     * @internal
+     */
+    find(callback) {
+        function visit(node) {
+            if (callback(node)) {
+                return node;
+            }
+            for (const child of node.childElements) {
+                const match = child.find(callback);
+                if (match) {
+                    return match;
+                }
+            }
+            return null;
         }
+        return visit(this);
     }
 }
-/**
- * Given a string it returns either the string as-is or if the string is wrapped
- * in /../ it creates and returns a regex instead.
- */
-function expandRegexValue(value) {
-    if (value instanceof RegExp) {
-        return value;
-    }
-    const match = value.match(/^\/\^?([^/$]*)\$?\/([i]*)$/);
-    if (match) {
-        const [, expr, flags] = match;
-        // eslint-disable-next-line security/detect-non-literal-regexp -- expected to be regexp
-        return new RegExp(`^${expr}$`, flags);
-    }
-    else {
-        return value;
+function isClosed(endToken, meta) {
+    let closed = exports.NodeClosed.Open;
+    if (meta && meta.void) {
+        closed = exports.NodeClosed.VoidOmitted;
     }
+    if (endToken.data[0] === "/>") {
+        closed = exports.NodeClosed.VoidSelfClosed;
+    }
+    return closed;
 }
+
 /**
- * Expand all regular expressions in strings ("/../"). This mutates the object.
+ * @public
  */
-function expandRegex(entry) {
-    for (const [name, values] of Object.entries(entry.attributes)) {
-        if (values.enum) {
-            entry.attributes[name].enum = values.enum.map(expandRegexValue);
-        }
+class DOMTree {
+    constructor(location) {
+        this.root = HtmlElement.rootNode(location);
+        this.active = this.root;
+        this.doctype = null;
     }
-}
-function evaluateProperty(node, expr) {
-    const [func, options] = parseExpression(expr);
-    return func(node, options);
-}
-function parseExpression(expr) {
-    if (typeof expr === "string") {
-        return parseExpression([expr, {}]);
+    pushActive(node) {
+        this.active = node;
     }
-    else {
-        /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- old style expressions should be replaced with typesafe functions */
-        const [funcName, options] = expr;
-        const func = functionTable[funcName];
-        if (!func) {
-            throw new Error(`Failed to find function "${funcName}" when evaluating property expression`);
+    popActive() {
+        if (this.active.isRootElement()) {
+            /* root element should never be popped, continue as if nothing happened */
+            return;
         }
-        return [func, options];
+        this.active = this.active.parent || this.root;
     }
-}
-function isDescendantFacade(node, tagName) {
-    if (typeof tagName !== "string") {
-        throw new Error(`Property expression "isDescendant" must take string argument when evaluating metadata for <${node.tagName}>`);
+    getActive() {
+        return this.active;
     }
-    return isDescendant(node, tagName);
-}
-function hasAttributeFacade(node, attr) {
-    if (typeof attr !== "string") {
-        throw new Error(`Property expression "hasAttribute" must take string argument when evaluating metadata for <${node.tagName}>`);
+    /**
+     * Resolve dynamic meta expressions.
+     */
+    resolveMeta(table) {
+        this.visitDepthFirst((node) => table.resolve(node));
     }
-    return hasAttribute(node, attr);
-}
-function matchAttributeFacade(node, match) {
-    if (!Array.isArray(match) || match.length !== 3) {
-        throw new Error(`Property expression "matchAttribute" must take [key, op, value] array as argument when evaluating metadata for <${node.tagName}>`);
+    getElementsByTagName(tagName) {
+        return this.root.getElementsByTagName(tagName);
     }
-    const [key, op, value] = match.map((x) => x.toLowerCase());
-    switch (op) {
-        case "!=":
-        case "=":
-            return matchAttribute(node, key, op, value);
-        default:
-            throw new Error(`Property expression "matchAttribute" has invalid operator "${op}" when evaluating metadata for <${node.tagName}>`);
+    visitDepthFirst(callback) {
+        this.root.visitDepthFirst(callback);
+    }
+    find(callback) {
+        return this.root.find(callback);
+    }
+    querySelector(selector) {
+        return this.root.querySelector(selector);
+    }
+    querySelectorAll(selector) {
+        return this.root.querySelectorAll(selector);
     }
 }
 
@@ -3233,6 +3233,275 @@ function interpolate(text, data) {
     });
 }
 
+const patternCache = new Map();
+function compileStringPattern(pattern) {
+    const regexp = pattern.replace(/[*]+/g, ".+");
+    /* eslint-disable-next-line security/detect-non-literal-regexp -- technical debt, should do input sanitation and precompilation */
+    return new RegExp(`^${regexp}$`);
+}
+function compileRegExpPattern(pattern) {
+    /* eslint-disable-next-line security/detect-non-literal-regexp -- technical debt, should do input sanitation and precompilation */
+    return new RegExp(`^${pattern}$`);
+}
+function compilePattern(pattern) {
+    const cached = patternCache.get(pattern);
+    if (cached) {
+        return cached;
+    }
+    const match = pattern.match(/^\/(.*)\/$/);
+    const regexp = match ? compileRegExpPattern(match[1]) : compileStringPattern(pattern);
+    patternCache.set(pattern, regexp);
+    return regexp;
+}
+/**
+ * @internal
+ */
+function keywordPatternMatcher(list, keyword) {
+    for (const pattern of list) {
+        const regexp = compilePattern(pattern);
+        if (regexp.test(keyword)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * @internal
+ */
+function isKeywordIgnored(options, keyword, matcher = (list, it) => list.includes(it)) {
+    const { include, exclude } = options;
+    /* ignore keyword if not present in "include" */
+    if (include && !matcher(include, keyword)) {
+        return true;
+    }
+    /* ignore keyword if present in "excludes" */
+    if (exclude && matcher(exclude, keyword)) {
+        return true;
+    }
+    return false;
+}
+
+const ARIA_HIDDEN_CACHE = Symbol(isAriaHidden.name);
+const HTML_HIDDEN_CACHE = Symbol(isHTMLHidden.name);
+const ROLE_PRESENTATION_CACHE = Symbol(isPresentation.name);
+/**
+ * Tests if this element is present in the accessibility tree.
+ *
+ * In practice it tests whenever the element or its parents has
+ * `role="presentation"` or `aria-hidden="false"`. Dynamic values counts as
+ * visible since the element might be in the visibility tree sometimes.
+ */
+function inAccessibilityTree(node) {
+    return !isAriaHidden(node) && !isPresentation(node);
+}
+function isAriaHiddenImpl(node) {
+    const isHidden = (node) => {
+        const ariaHidden = node.getAttribute("aria-hidden");
+        return Boolean(ariaHidden && ariaHidden.value === "true");
+    };
+    return {
+        byParent: node.parent ? isAriaHidden(node.parent) : false,
+        bySelf: isHidden(node),
+    };
+}
+function isAriaHidden(node, details) {
+    const cached = node.cacheGet(ARIA_HIDDEN_CACHE);
+    if (cached) {
+        return details ? cached : cached.byParent || cached.bySelf;
+    }
+    const result = node.cacheSet(ARIA_HIDDEN_CACHE, isAriaHiddenImpl(node));
+    return details ? result : result.byParent || result.bySelf;
+}
+function isHTMLHiddenImpl(node) {
+    const isHidden = (node) => {
+        const hidden = node.getAttribute("hidden");
+        return hidden !== null && hidden.isStatic;
+    };
+    return {
+        byParent: node.parent ? isHTMLHidden(node.parent) : false,
+        bySelf: isHidden(node),
+    };
+}
+function isHTMLHidden(node, details) {
+    const cached = node.cacheGet(HTML_HIDDEN_CACHE);
+    if (cached) {
+        return details ? cached : cached.byParent || cached.bySelf;
+    }
+    const result = node.cacheSet(HTML_HIDDEN_CACHE, isHTMLHiddenImpl(node));
+    return details ? result : result.byParent || result.bySelf;
+}
+/**
+ * Tests if this element or a parent element has role="presentation".
+ *
+ * Dynamic values yields `false` just as if the attribute wasn't present.
+ */
+function isPresentation(node) {
+    if (node.cacheExists(ROLE_PRESENTATION_CACHE)) {
+        return Boolean(node.cacheGet(ROLE_PRESENTATION_CACHE));
+    }
+    let cur = node;
+    do {
+        const role = cur.getAttribute("role");
+        /* role="presentation" */
+        if (role && role.value === "presentation") {
+            return cur.cacheSet(ROLE_PRESENTATION_CACHE, true);
+        }
+        /* sanity check: break if no parent is present, normally not an issue as the
+         * root element should be found first */
+        if (!cur.parent) {
+            break;
+        }
+        /* check parents */
+        cur = cur.parent;
+    } while (!cur.isRootElement());
+    return node.cacheSet(ROLE_PRESENTATION_CACHE, false);
+}
+
+const cachePrefix = classifyNodeText.name;
+const HTML_CACHE_KEY = Symbol(`${cachePrefix}|html`);
+const A11Y_CACHE_KEY = Symbol(`${cachePrefix}|a11y`);
+const IGNORE_HIDDEN_ROOT_HTML_CACHE_KEY = Symbol(`${cachePrefix}|html|ignore-hidden-root`);
+const IGNORE_HIDDEN_ROOT_A11Y_CACHE_KEY = Symbol(`${cachePrefix}|a11y|ignore-hidden-root`);
+/**
+ * @public
+ */
+exports.TextClassification = void 0;
+(function (TextClassification) {
+    TextClassification[TextClassification["EMPTY_TEXT"] = 0] = "EMPTY_TEXT";
+    TextClassification[TextClassification["DYNAMIC_TEXT"] = 1] = "DYNAMIC_TEXT";
+    TextClassification[TextClassification["STATIC_TEXT"] = 2] = "STATIC_TEXT";
+})(exports.TextClassification || (exports.TextClassification = {}));
+/**
+ * @internal
+ */
+function getCachekey(options) {
+    const { accessible = false, ignoreHiddenRoot = false } = options;
+    if (accessible && ignoreHiddenRoot) {
+        return IGNORE_HIDDEN_ROOT_A11Y_CACHE_KEY;
+    }
+    else if (ignoreHiddenRoot) {
+        return IGNORE_HIDDEN_ROOT_HTML_CACHE_KEY;
+    }
+    else if (accessible) {
+        return A11Y_CACHE_KEY;
+    }
+    else {
+        return HTML_CACHE_KEY;
+    }
+}
+/* While I cannot find a reference about this in the standard the <select>
+ * element kinda acts as if there is no text content, most particularly it
+ * doesn't receive and accessible name. The `.textContent` property does
+ * however include the <option> childrens text. But for the sake of the
+ * validator it is probably best if the classification acts as if there is no
+ * text as I think that is what is expected of the return values. Might have
+ * to revisit this at some point or if someone could clarify what section of
+ * the standard deals with this. */
+function isSpecialEmpty(node) {
+    return node.is("select") || node.is("textarea");
+}
+/**
+ * Checks text content of an element.
+ *
+ * Any text is considered including text from descendant elements. Whitespace is
+ * ignored.
+ *
+ * If any text is dynamic `TextClassification.DYNAMIC_TEXT` is returned.
+ *
+ * @public
+ */
+function classifyNodeText(node, options = {}) {
+    const { accessible = false, ignoreHiddenRoot = false } = options;
+    const cacheKey = getCachekey(options);
+    if (node.cacheExists(cacheKey)) {
+        return node.cacheGet(cacheKey);
+    }
+    if (!ignoreHiddenRoot && isHTMLHidden(node)) {
+        return node.cacheSet(cacheKey, exports.TextClassification.EMPTY_TEXT);
+    }
+    if (!ignoreHiddenRoot && accessible && isAriaHidden(node)) {
+        return node.cacheSet(cacheKey, exports.TextClassification.EMPTY_TEXT);
+    }
+    if (isSpecialEmpty(node)) {
+        return node.cacheSet(cacheKey, exports.TextClassification.EMPTY_TEXT);
+    }
+    const text = findTextNodes(node, {
+        ...options,
+        ignoreHiddenRoot: false,
+    });
+    /* if any text is dynamic classify as dynamic */
+    if (text.some((cur) => cur.isDynamic)) {
+        return node.cacheSet(cacheKey, exports.TextClassification.DYNAMIC_TEXT);
+    }
+    /* if any text has non-whitespace character classify as static */
+    if (text.some((cur) => cur.textContent.match(/\S/) !== null)) {
+        return node.cacheSet(cacheKey, exports.TextClassification.STATIC_TEXT);
+    }
+    /* default to empty */
+    return node.cacheSet(cacheKey, exports.TextClassification.EMPTY_TEXT);
+}
+function findTextNodes(node, options) {
+    const { accessible = false } = options;
+    let text = [];
+    for (const child of node.childNodes) {
+        if (isTextNode(child)) {
+            text.push(child);
+        }
+        else if (isElementNode(child)) {
+            if (isHTMLHidden(child, true).bySelf) {
+                continue;
+            }
+            if (accessible && isAriaHidden(child, true).bySelf) {
+                continue;
+            }
+            text = text.concat(findTextNodes(child, options));
+        }
+    }
+    return text;
+}
+
+function hasAltText(image) {
+    const alt = image.getAttribute("alt");
+    /* missing or boolean */
+    if (alt === null || alt.value === null) {
+        return false;
+    }
+    return alt.isDynamic || alt.value.toString() !== "";
+}
+
+function hasAriaLabel(node) {
+    const label = node.getAttribute("aria-label");
+    /* missing or boolean */
+    if (label === null || label.value === null) {
+        return false;
+    }
+    return label.isDynamic || label.value.toString() !== "";
+}
+
+/**
+ * Partition an array to two new lists based on the result of a
+ * predicate. Similar to `Array.filter` but returns both matching and
+ * non-matching in the same call.
+ *
+ * Elements matching the predicate is placed in the first array and elements not
+ * matching is placed in the second.
+ *
+ * @public
+ * @param values - The array of values to partition.
+ * @param predicate - A predicate function taking a single element and returning
+ * a boolean.
+ * @returns - Two arrays where the first contains all elements where the
+ * predicate matched and second contains the rest of the elements.
+ */
+function partition(values, predicate) {
+    const initial = [[], []];
+    return values.reduce((accumulator, value, index) => {
+        const match = predicate(value, index, values);
+        accumulator[match ? 0 : 1].push(value);
+        return accumulator;
+    }, initial);
+}
+
 const remapEvents = {
     "tag:open": "tag:start",
     "tag:close": "tag:end",
@@ -3386,7 +3655,7 @@ class Rule {
      * `exclude`.
      */
     isKeywordIgnored(keyword, matcher = (list, it) => list.includes(it)) {
-        return rulesHelper.isKeywordIgnored(this.options, keyword, matcher);
+        return isKeywordIgnored(this.options, keyword, matcher);
     }
     /**
      * Get [[MetaElement]] for the given tag. If no specific metadata is present
@@ -3950,6 +4219,60 @@ class ConfigError extends UserError {
     }
 }
 
+/**
+ * Represents casing for a name, e.g. lowercase, uppercase, etc.
+ */
+class CaseStyle {
+    /**
+     * @param style - Name of a valid case style.
+     */
+    constructor(style, ruleId) {
+        if (!Array.isArray(style)) {
+            style = [style];
+        }
+        if (style.length === 0) {
+            throw new ConfigError(`Missing style for ${ruleId} rule`);
+        }
+        this.styles = this.parseStyle(style, ruleId);
+    }
+    /**
+     * Test if a text matches this case style.
+     */
+    match(text) {
+        return this.styles.some((style) => text.match(style.pattern));
+    }
+    get name() {
+        const names = this.styles.map((style) => style.name);
+        switch (this.styles.length) {
+            case 1:
+                return names[0];
+            case 2:
+                return names.join(" or ");
+            default: {
+                const last = names.slice(-1);
+                const rest = names.slice(0, -1);
+                return `${rest.join(", ")} or ${last[0]}`;
+            }
+        }
+    }
+    parseStyle(style, ruleId) {
+        return style.map((cur) => {
+            switch (cur.toLowerCase()) {
+                case "lowercase":
+                    return { pattern: /^[a-z]*$/, name: "lowercase" };
+                case "uppercase":
+                    return { pattern: /^[A-Z]*$/, name: "uppercase" };
+                case "pascalcase":
+                    return { pattern: /^[A-Z][A-Za-z]*$/, name: "PascalCase" };
+                case "camelcase":
+                    return { pattern: /^[a-z][A-Za-z]*$/, name: "camelCase" };
+                default:
+                    throw new ConfigError(`Invalid style "${cur}" for ${ruleId} rule`);
+            }
+        });
+    }
+}
+
 const defaults$t = {
     style: "lowercase",
     ignoreForeign: true,
@@ -3957,7 +4280,7 @@ const defaults$t = {
 class AttrCase extends Rule {
     constructor(options) {
         super({ ...defaults$t, ...options });
-        this.style = new rulesHelper.CaseStyle(this.options.style, "attr-case");
+        this.style = new CaseStyle(this.options.style, "attr-case");
     }
     static schema() {
         const styleEnum = ["lowercase", "uppercase", "pascalcase", "camelcase"];
@@ -5207,7 +5530,7 @@ const defaults$l = {
 class ElementCase extends Rule {
     constructor(options) {
         super({ ...defaults$l, ...options });
-        this.style = new rulesHelper.CaseStyle(this.options.style, "element-case");
+        this.style = new CaseStyle(this.options.style, "element-case");
     }
     static schema() {
         const styleEnum = ["lowercase", "uppercase", "pascalcase", "camelcase"];
@@ -5591,7 +5914,7 @@ function formatMessage$1(node, parent, rules) {
     if (!isFormattable(rules)) {
         return `${nodeName} element cannot have ${parentName} element as parent`;
     }
-    const allowed = rulesHelper.naturalJoin(rules.filter(isCategoryOrTag).map(formatCategoryOrTag));
+    const allowed = utils_naturalJoin.naturalJoin(rules.filter(isCategoryOrTag).map(formatCategoryOrTag));
     return `${nodeName} element requires a ${allowed} element as parent`;
 }
 class ElementPermittedParent extends Rule {
@@ -5655,7 +5978,7 @@ function getRuleDescription(context) {
         ];
     }
     const escaped = context.ancestor.map((it) => `\`${it}\``);
-    return [`The \`${context.child}\` element requires a ${rulesHelper.naturalJoin(escaped)} ancestor.`];
+    return [`The \`${context.child}\` element requires a ${utils_naturalJoin.naturalJoin(escaped)} ancestor.`];
 }
 class ElementRequiredAncestor extends Rule {
     documentation(context) {
@@ -5691,7 +6014,7 @@ class ElementRequiredAncestor extends Rule {
         }
         const ancestor = rules.map((it) => (isTagnameOnly(it) ? `<${it}>` : `"${it}"`));
         const child = `<${node.tagName}>`;
-        const message = `<${node.tagName}> element requires a ${rulesHelper.naturalJoin(ancestor)} ancestor`;
+        const message = `<${node.tagName}> element requires a ${utils_naturalJoin.naturalJoin(ancestor)} ancestor`;
         const context = {
             ancestor,
             child,
@@ -5782,9 +6105,9 @@ class ElementRequiredContent extends Rule {
 }
 
 const selector = ["h1", "h2", "h3", "h4", "h5", "h6"].join(",");
-function hasImgAltText(node) {
+function hasImgAltText$1(node) {
     if (node.is("img")) {
-        return rulesHelper.hasAltText(node);
+        return hasAltText(node);
     }
     else if (node.is("svg")) {
         return node.textContent.trim() !== "";
@@ -5811,16 +6134,16 @@ class EmptyHeading extends Rule {
     validateHeading(heading) {
         const images = heading.querySelectorAll("img, svg");
         for (const child of images) {
-            if (hasImgAltText(child)) {
+            if (hasImgAltText$1(child)) {
                 return;
             }
         }
-        switch (rulesHelper.classifyNodeText(heading, { ignoreHiddenRoot: true })) {
-            case rulesHelper.TextClassification.DYNAMIC_TEXT:
-            case rulesHelper.TextClassification.STATIC_TEXT:
+        switch (classifyNodeText(heading, { ignoreHiddenRoot: true })) {
+            case exports.TextClassification.DYNAMIC_TEXT:
+            case exports.TextClassification.STATIC_TEXT:
                 /* have some text content, consider ok */
                 break;
-            case rulesHelper.TextClassification.EMPTY_TEXT:
+            case exports.TextClassification.EMPTY_TEXT:
                 /* no content or whitespace only */
                 this.report(heading, `<${heading.tagName}> cannot be empty, must have text content`);
                 break;
@@ -5847,12 +6170,12 @@ class EmptyTitle extends Rule {
             const node = event.previous;
             if (node.tagName !== "title")
                 return;
-            switch (rulesHelper.classifyNodeText(node)) {
-                case rulesHelper.TextClassification.DYNAMIC_TEXT:
-                case rulesHelper.TextClassification.STATIC_TEXT:
+            switch (classifyNodeText(node)) {
+                case exports.TextClassification.DYNAMIC_TEXT:
+                case exports.TextClassification.STATIC_TEXT:
                     /* have some text content, consider ok */
                     break;
-                case rulesHelper.TextClassification.EMPTY_TEXT:
+                case exports.TextClassification.EMPTY_TEXT:
                     /* no content or whitespace only */
                     {
                         const message = `<${node.tagName}> cannot be empty, must have text content`;
@@ -5925,7 +6248,7 @@ class FormDupName extends Rule {
             var _a, _b;
             const { document } = event;
             const controls = document.querySelectorAll(selector);
-            const [sharedControls, uniqueControls] = rulesHelper.partition(controls, (it) => {
+            const [sharedControls, uniqueControls] = partition(controls, (it) => {
                 return allowSharedName(it, shared);
             });
             /* validate all form controls which require unique elements first so each
@@ -6434,6 +6757,126 @@ class InputAttributes extends Rule {
     }
 }
 
+const HAS_ACCESSIBLE_TEXT_CACHE = Symbol(hasAccessibleName.name);
+function isHidden(node, context) {
+    const { reference } = context;
+    if (reference && reference.isSameNode(node)) {
+        return false;
+    }
+    else {
+        return isHTMLHidden(node) || !inAccessibilityTree(node);
+    }
+}
+function hasImgAltText(node, context) {
+    if (node.is("img")) {
+        return hasAltText(node);
+    }
+    else if (node.is("svg")) {
+        return node.textContent.trim() !== "";
+    }
+    else {
+        for (const img of node.querySelectorAll("img, svg")) {
+            const hasName = hasAccessibleNameImpl(img, context);
+            if (hasName) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+function hasLabel(node) {
+    var _a;
+    const value = (_a = node.getAttributeValue("aria-label")) !== null && _a !== void 0 ? _a : "";
+    return Boolean(value.trim());
+}
+function isLabelledby(node, context) {
+    const { document, reference } = context;
+    /* if we already have resolved one level of reference we don't resolve another
+     * level (as per accname step 2B) */
+    if (reference) {
+        return false;
+    }
+    const ariaLabelledby = node.ariaLabelledby;
+    /* consider dynamic aria-labelledby as having a name as we cannot resolve it
+     * so no way to prove correctness */
+    if (ariaLabelledby instanceof DynamicValue) {
+        return true;
+    }
+    /* ignore elements without aria-labelledby */
+    if (ariaLabelledby === null) {
+        return false;
+    }
+    return ariaLabelledby.some((id) => {
+        const selector = generateIdSelector(id);
+        return document.querySelectorAll(selector).some((child) => {
+            return hasAccessibleNameImpl(child, {
+                document,
+                reference: child,
+            });
+        });
+    });
+}
+/**
+ * This algorithm is based on ["Accessible Name and Description Computation
+ * 1.2"][accname] with some exceptions:
+ *
+ * It doesn't compute the actual name but only the presence of one, e.g. if a
+ * non-empty flat string is present the algorithm terminates with a positive
+ * result.
+ *
+ * It takes some optimization shortcuts such as starting with step F as it
+ * would be more common usage and as there is no actual name being computed
+ * the order wont matter.
+ *
+ * [accname]: https://w3c.github.io/accname
+ */
+function hasAccessibleNameImpl(current, context) {
+    const { reference } = context;
+    /* if this element is hidden (see function for exceptions) it does not have an accessible name */
+    if (isHidden(current, context)) {
+        return false;
+    }
+    /* special case: when this element is directly referenced by aria-labelledby
+     * we ignore `hidden` */
+    const ignoreHiddenRoot = Boolean(reference && reference.isSameNode(current));
+    const text = classifyNodeText(current, { accessible: true, ignoreHiddenRoot });
+    if (text !== exports.TextClassification.EMPTY_TEXT) {
+        return true;
+    }
+    if (hasImgAltText(current, context)) {
+        return true;
+    }
+    if (hasLabel(current)) {
+        return true;
+    }
+    if (isLabelledby(current, context)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Returns `true` if the element has an accessible name.
+ *
+ * It does not yet consider if the elements role prohibits naming, e.g. a `<p>`
+ * element will still show up as having an accessible name.
+ *
+ * @public
+ * @param document - Document element.
+ * @param current - The element to get accessible name for
+ * @returns `true` if the element has an accessible name.
+ */
+function hasAccessibleName(document, current) {
+    /* istanbul ignore next: we're not testing cache */
+    if (current.cacheExists(HAS_ACCESSIBLE_TEXT_CACHE)) {
+        return Boolean(current.cacheGet(HAS_ACCESSIBLE_TEXT_CACHE));
+    }
+    const result = hasAccessibleNameImpl(current, {
+        document,
+        reference: null,
+    });
+    return current.cacheSet(HAS_ACCESSIBLE_TEXT_CACHE, result);
+}
+
 function isIgnored(node) {
     var _a;
     if (node.is("input")) {
@@ -6468,14 +6911,14 @@ class InputMissingLabel extends Rule {
         });
     }
     validateInput(root, elem) {
-        if (rulesHelper.isHTMLHidden(elem) || rulesHelper.isAriaHidden(elem)) {
+        if (isHTMLHidden(elem) || isAriaHidden(elem)) {
             return;
         }
         /* hidden, submit, reset or button should not have label */
         if (isIgnored(elem)) {
             return;
         }
-        if (rulesHelper.hasAccessibleName(root, elem)) {
+        if (hasAccessibleName(root, elem)) {
             return;
         }
         let label = [];
@@ -6508,13 +6951,13 @@ class InputMissingLabel extends Rule {
             this.report(elem, `<${elem.tagName}> element has <label> but <label> element is hidden`);
             return;
         }
-        if (!labels.some((label) => rulesHelper.hasAccessibleName(root, label))) {
+        if (!labels.some((label) => hasAccessibleName(root, label))) {
             this.report(elem, `<${elem.tagName}> element has <label> but <label> has no text`);
         }
     }
 }
 function isVisible(elem) {
-    const hidden = rulesHelper.isHTMLHidden(elem) || rulesHelper.isAriaHidden(elem);
+    const hidden = isHTMLHidden(elem) || isAriaHidden(elem);
     return !hidden;
 }
 function findLabelById(root, id) {
@@ -7561,7 +8004,7 @@ class NoUnknownElements extends Rule {
             if (node.meta) {
                 return;
             }
-            if (this.isKeywordIgnored(node.tagName, rulesHelper.keywordPatternMatcher)) {
+            if (this.isKeywordIgnored(node.tagName, keywordPatternMatcher)) {
                 return;
             }
             this.report(node, `Unknown element <${node.tagName}>`, null, node.tagName);
@@ -8299,7 +8742,7 @@ function isNonEmptyText(node) {
  * - Elements with default text
  */
 function haveAccessibleText(node) {
-    if (!rulesHelper.inAccessibilityTree(node)) {
+    if (!inAccessibilityTree(node)) {
         return false;
     }
     /* check direct descendants for non-empty or dynamic text */
@@ -8378,7 +8821,7 @@ class TextContent extends Rule {
      * Validate element has empty text (inter-element whitespace is not considered text)
      */
     validateNone(node) {
-        if (rulesHelper.classifyNodeText(node) === rulesHelper.TextClassification.EMPTY_TEXT) {
+        if (classifyNodeText(node) === exports.TextClassification.EMPTY_TEXT) {
             return;
         }
         this.reportError(node, node.meta, `${node.annotatedName} must not have text content`);
@@ -8387,7 +8830,7 @@ class TextContent extends Rule {
      * Validate element has any text (inter-element whitespace is not considered text)
      */
     validateRequired(node) {
-        if (rulesHelper.classifyNodeText(node) !== rulesHelper.TextClassification.EMPTY_TEXT) {
+        if (classifyNodeText(node) !== exports.TextClassification.EMPTY_TEXT) {
             return;
         }
         this.reportError(node, node.meta, `${node.annotatedName} must have text content`);
@@ -8398,7 +8841,7 @@ class TextContent extends Rule {
      */
     validateAccessible(node) {
         /* skip this element if the element isn't present in accessibility tree */
-        if (!rulesHelper.inAccessibilityTree(node)) {
+        if (!inAccessibilityTree(node)) {
             return;
         }
         /* if the element or a child has aria-label, alt or default text, etc the
@@ -8786,22 +9229,22 @@ class H30 extends Rule {
             const links = event.document.getElementsByTagName("a");
             for (const link of links) {
                 /* ignore links with aria-hidden="true" */
-                if (!rulesHelper.inAccessibilityTree(link)) {
+                if (!inAccessibilityTree(link)) {
                     continue;
                 }
                 /* check if text content is present (or dynamic) */
-                const textClassification = rulesHelper.classifyNodeText(link, { ignoreHiddenRoot: true });
-                if (textClassification !== rulesHelper.TextClassification.EMPTY_TEXT) {
+                const textClassification = classifyNodeText(link, { ignoreHiddenRoot: true });
+                if (textClassification !== exports.TextClassification.EMPTY_TEXT) {
                     continue;
                 }
                 /* check if image with alt-text is present */
                 const images = link.querySelectorAll("img");
-                if (images.some((image) => rulesHelper.hasAltText(image))) {
+                if (images.some((image) => hasAltText(image))) {
                     continue;
                 }
                 /* check if aria-label is present on either the <a> element or a descendant */
                 const labels = link.querySelectorAll("[aria-label]");
-                if (rulesHelper.hasAriaLabel(link) || labels.some((cur) => rulesHelper.hasAriaLabel(cur))) {
+                if (hasAriaLabel(link) || labels.some((cur) => hasAriaLabel(cur))) {
                     continue;
                 }
                 this.report(link, "Anchor link must have a text describing its purpose");
@@ -8884,7 +9327,7 @@ class H36 extends Rule {
             if (node.getAttributeValue("type") !== "image") {
                 return;
             }
-            if (!rulesHelper.hasAltText(node)) {
+            if (!hasAltText(node)) {
                 this.report(node, "image used as submit button must have alt text");
             }
         });
@@ -8952,7 +9395,7 @@ class H37 extends Rule {
                 return;
             }
             /* ignore images with aria-hidden="true" or role="presentation" */
-            if (!rulesHelper.inAccessibilityTree(node)) {
+            if (!inAccessibilityTree(node)) {
                 return;
             }
             /* validate plain alt-attribute */
@@ -8981,7 +9424,7 @@ var _a;
 /* istanbul ignore next: this will always be present for the <th>
  * attribute (or the tests would fail) */
 const { enum: validScopes } = (_a = elements.html5.th.attributes) === null || _a === void 0 ? void 0 : _a.scope;
-const joinedScopes = rulesHelper.naturalJoin(validScopes);
+const joinedScopes = utils_naturalJoin.naturalJoin(validScopes);
 class H63 extends Rule {
     documentation() {
         return {
@@ -11701,7 +12144,7 @@ class HtmlValidate {
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "8.0.3";
+const version = "8.0.5";
 /** @public */
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
@@ -11748,6 +12191,27 @@ function compatibilityCheck(name, declared, options) {
     return false;
 }
 
+/**
+ * Similar to `require(..)` but removes the cached copy first.
+ */
+function requireUncached(require, moduleId) {
+    const filename = require.resolve(moduleId);
+    /* remove references from the parent module to prevent memory leak */
+    const m = require.cache[filename];
+    if (m && m.parent) {
+        const { parent } = m;
+        for (let i = parent.children.length - 1; i >= 0; i--) {
+            if (parent.children[i].id === filename) {
+                parent.children.splice(i, 1);
+            }
+        }
+    }
+    /* remove old module from cache */
+    delete require.cache[filename];
+    /* eslint-disable-next-line import/no-dynamic-require, security/detect-non-literal-require -- as expected but should be moved to upcoming resolver class */
+    return require(filename);
+}
+
 const ruleIds = new Set(Object.keys(rules));
 /**
  * Returns true if given ruleId is an existing builtin rule. It does not handle
@@ -12040,15 +12504,15 @@ exports.UserError = UserError;
 exports.Validator = Validator;
 exports.WrappedError = WrappedError;
 exports.bugs = bugs;
+exports.classifyNodeText = classifyNodeText;
 exports.codeframe = codeframe;
 exports.compatibilityCheck = compatibilityCheck;
 exports.definePlugin = definePlugin;
 exports.ensureError = ensureError;
-exports.generateIdSelector = generateIdSelector;
 exports.getFormatter = getFormatter;
-exports.isElementNode = isElementNode;
-exports.isTextNode = isTextNode;
+exports.keywordPatternMatcher = keywordPatternMatcher;
 exports.name = name;
+exports.requireUncached = requireUncached;
 exports.ruleExists = ruleExists;
 exports.sliceLocation = sliceLocation;
 exports.staticResolver = staticResolver;