html-validate 8.0.4 → 8.0.5

package/dist/es/core.js

@@ -4,8 +4,8 @@ import { e as entities$1, h as html5, b as bundledElements } from './elements.js
 import fs from 'fs';
 import semver from 'semver';
 import kleur from 'kleur';
-import { i as isKeywordIgnored, C as CaseStyle, n as naturalJoin, c as classifyNodeText, T as TextClassification, h as hasAltText, p as partition, a as isHTMLHidden, b as isAriaHidden, d as hasAccessibleName, k as keywordPatternMatcher, e as inAccessibilityTree, f as hasAriaLabel } from './rules-helper.js';
 import betterAjvErrors from '@sidvind/better-ajv-errors';
+import { n as naturalJoin } from './utils/natural-join.js';
 import { codeFrameColumns } from '@babel/code-frame';
 import { stylish as stylish$2 } from '@html-validate/stylish';
 
@@ -240,1593 +240,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(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(this.schema, this.obj, this.errors, {
+            format: "cli",
+            indent: 2,
+            json,
+        });
     }
-    if (end < 0) {
-        end = size + end;
+    getRawJSON() {
+        if (this.filename && fs.existsSync(this.filename)) {
+            return fs.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
- */
-var TextContent$1;
-(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";
-})(TextContent$1 || (TextContent$1 = {}));
-/**
- * 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
- */
-var NodeType;
-(function (NodeType) {
-    NodeType[NodeType["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
-    NodeType[NodeType["TEXT_NODE"] = 3] = "TEXT_NODE";
-    NodeType[NodeType["DOCUMENT_NODE"] = 9] = "DOCUMENT_NODE";
-})(NodeType || (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 === 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 === 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(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
- */
-var NodeClosed;
-(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";
-})(NodeClosed || (NodeClosed = {}));
-/**
- * Returns true if the node is an element node.
- *
- * @public
- */
-function isElementNode(node) {
-    return Boolean(node && node.nodeType === NodeType.ELEMENT_NODE);
-}
-function isValidTagName(tagName) {
-    return Boolean(tagName !== "" && tagName !== "*");
-}
-/**
- * @public
- */
-class HtmlElement extends DOMNode {
-    constructor(tagName, parent, closed, meta, location) {
-        const nodeType = tagName ? NodeType.ELEMENT_NODE : 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, 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 = NodeClosed.Open;
-    if (meta && meta.void) {
-        closed = NodeClosed.VoidOmitted;
-    }
-    if (endToken.data[0] === "/>") {
-        closed = 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(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(this.schema, this.obj, this.errors, {
-            format: "cli",
-            indent: 2,
-            json,
-        });
-    }
-    getRawJSON() {
-        if (this.filename && fs.existsSync(this.filename)) {
-            return fs.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";
@@ -2224,487 +797,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
+ */
+var TextContent$1;
+(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";
+})(TextContent$1 || (TextContent$1 = {}));
+/**
+ * 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(this.schema, {
+                patternProperties: {
+                    "^[^$].*$": {
+                        properties: patch.properties,
+                    },
+                },
+            });
+        }
+        if (patch.definitions) {
+            this.schema = deepmerge(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({ 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(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
+ */
+var NodeType;
+(function (NodeType) {
+    NodeType[NodeType["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
+    NodeType[NodeType["TEXT_NODE"] = 3] = "TEXT_NODE";
+    NodeType[NodeType["DOCUMENT_NODE"] = 9] = "DOCUMENT_NODE";
+})(NodeType || (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 === 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`);
+    }
+}
 
 /**
- * AJV keyword "regexp" to validate the type to be a regular expression.
- * Injects errors with the "type" keyword to give the same output.
+ * Homage to PHP: unescapes slashes.
+ *
+ * E.g. "foo\:bar" becomes "foo:bar"
  */
-/* 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,
-};
-
+function stripslashes(value) {
+    return value.replace(/\\(.)/g, "$1");
+}
 /**
- * AJV keyword "function" to validate the type to be a function. Injects errors
- * with the "type" keyword to give the same output.
+ * @internal
  */
-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",
-                },
-            },
-        ];
+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;
     }
-    return valid;
-};
-const ajvFunctionKeyword = {
-    keyword: "function",
-    schema: false,
-    errors: true,
-    validate: ajvFunctionValidate,
-};
-
-function isSet(value) {
-    return typeof value !== "undefined";
+    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;
 }
-function flag(value) {
-    return value ? true : undefined;
+class Matcher {
 }
-function stripUndefined(src) {
-    const entries = Object.entries(src).filter(([, value]) => isSet(value));
-    return Object.fromEntries(entries);
+class ClassMatcher extends Matcher {
+    constructor(classname) {
+        super();
+        this.classname = classname;
+    }
+    match(node) {
+        return node.classList.contains(this.classname);
+    }
 }
-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);
+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);
     }
-    /* 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);
+    /**
+     * 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);
     }
-    if (Array.isArray(attr)) {
-        if (attr.length === 0) {
-            result.boolean = true;
+    *matchInternal(root, level, context) {
+        if (level >= this.pattern.length) {
+            yield root;
+            return;
         }
-        else {
-            result.enum = attr.filter((it) => it !== "");
-            if (attr.includes("")) {
-                result.omit = true;
+        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);
         }
-        return stripUndefined(result);
     }
-    else {
-        return stripUndefined({ ...result, ...attr });
+    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));
     }
-}
-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;
+    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 [];
     }
-    if (src.formAssociated) {
-        result.formAssociated = {
-            listed: Boolean(src.formAssociated.listed),
-        };
+    static findAdjacentSibling(node) {
+        let adjacent = false;
+        return node.siblings.filter((cur) => {
+            if (adjacent) {
+                adjacent = false;
+                return true;
+            }
+            if (cur === node) {
+                adjacent = true;
+            }
+            return false;
+        });
     }
-    else {
-        delete result.formAssociated;
+    static findGeneralSibling(node) {
+        let after = false;
+        return node.siblings.filter((cur) => {
+            if (after) {
+                return true;
+            }
+            if (cur === node) {
+                after = true;
+            }
+            return false;
+        });
     }
-    return result;
 }
 
+const TEXT_NODE_NAME = "#text";
 /**
- * Returns true if given element is a descendant of given tagname.
+ * Returns true if the node is a text node.
  *
- * @internal
+ * @public
  */
-function isDescendant(node, tagName) {
-    let cur = node.parent;
-    while (cur && !cur.isRootElement()) {
-        if (cur.is(tagName)) {
-            return true;
-        }
-        cur = cur.parent;
-    }
-    return false;
+function isTextNode(node) {
+    return Boolean(node && node.nodeType === NodeType.TEXT_NODE);
 }
-
 /**
- * Returns true if given element has given attribute (no matter the value, null,
- * dynamic, etc).
+ * Represents a text in the HTML document.
+ *
+ * Text nodes are appended as children of `HtmlElement` and cannot have childen
+ * of its own.
+ *
+ * @public
  */
-function hasAttribute(node, attr) {
-    return node.hasAttribute(attr);
+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(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;
+    }
 }
 
 /**
- * Matches attribute against value.
+ * @public
  */
-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));
+var NodeClosed;
+(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";
+})(NodeClosed || (NodeClosed = {}));
+/**
+ * Returns true if the node is an element node.
+ *
+ * @public
+ */
+function isElementNode(node) {
+    return Boolean(node && node.nodeType === NodeType.ELEMENT_NODE);
 }
-function overwriteMerge$1(a, b) {
-    return b;
+function isValidTagName(tagName) {
+    return Boolean(tagName !== "" && tagName !== "*");
 }
 /**
  * @public
  */
-class MetaTable {
+class HtmlElement extends DOMNode {
+    constructor(tagName, parent, closed, meta, location) {
+        const nodeType = tagName ? NodeType.ELEMENT_NODE : 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, NodeClosed.EndTag, null, location);
+        root.setAnnotation("#document");
+        return root;
+    }
     /**
      * @internal
+     *
+     * @param namespace - If given it is appended to the tagName.
      */
-    constructor() {
-        this.elements = {};
-        this.schema = clone(schema);
+    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);
     }
     /**
-     * @internal
+     * Returns annotated name if set or defaults to `<tagName>`.
+     *
+     * E.g. `my-annotation` or `<div>`.
      */
-    init() {
-        this.resolveGlobal();
+    get annotatedName() {
+        if (this.annotation) {
+            return this.annotation;
+        }
+        else {
+            return `<${this.tagName}>`;
+        }
     }
     /**
-     * Extend validation schema.
+     * 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
      */
-    extendValidationSchema(patch) {
-        if (patch.properties) {
-            this.schema = deepmerge(this.schema, {
-                patternProperties: {
-                    "^[^$].*$": {
-                        properties: patch.properties,
-                    },
-                },
-            });
+    get ariaLabelledby() {
+        const attr = this.getAttribute("aria-labelledby");
+        if (!attr || !attr.value) {
+            return null;
         }
-        if (patch.definitions) {
-            this.schema = deepmerge(this.schema, {
-                definitions: patch.definitions,
-            });
+        if (attr.value instanceof DynamicValue) {
+            return attr.value;
         }
+        const list = new DOMTokenList(attr.value, attr.valueLocation);
+        return list.length ? Array.from(list) : null;
     }
     /**
-     * Load metadata table from object.
+     * Similar to childNodes but only elements.
+     */
+    get childElements() {
+        return this.childNodes.filter(isElementNode);
+    }
+    /**
+     * Find the first ancestor matching a selector.
      *
-     * @public
-     * @param obj - Object with metadata to load
-     * @param filename - Optional filename used when presenting validation error
+     * Implementation of DOM specification of Element.closest(selectors).
      */
-    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 : []);
+    closest(selectors) {
+        /* eslint-disable-next-line @typescript-eslint/no-this-alias -- false positive*/
+        let node = this;
+        while (node) {
+            if (node.matches(selectors)) {
+                return node;
             }
-            for (const [key, value] of Object.entries(obj)) {
-                if (key === "$schema")
-                    continue;
-                this.addEntry(key, migrateElement(value));
+            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})`);
         }
-        catch (err) {
-            if (err instanceof InheritError) {
-                err.filename = filename;
-                throw err;
+        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);
             }
-            if (err instanceof SchemaValidationError) {
-                throw err;
+            else {
+                delete this.metaElement[key];
             }
-            if (!filename) {
-                throw err;
+        }
+    }
+    /**
+     * 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;
             }
-            throw new UserError(`Failed to load element metadata from "${filename}"`, ensureError(err));
+        }
+        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 [[MetaElement]] for the given tag. If no specific metadata is present
-     * the global metadata is returned or null if no global is present.
+     * Get attribute value.
      *
-     * @public
-     * @returns A shallow copy of metadata.
+     * 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.
      */
-    getMetaFor(tagName) {
-        /* try to locate by tagname */
-        tagName = tagName.toLowerCase();
-        if (this.elements[tagName]) {
-            return { ...this.elements[tagName] };
+    getAttributeValue(key) {
+        const attr = this.getAttribute(key);
+        if (attr) {
+            return attr.value !== null ? attr.value.toString() : null;
         }
-        /* try to locate global element */
-        if (this.elements["*"]) {
-            return { ...this.elements["*"] };
+        else {
+            return null;
         }
-        return null;
     }
     /**
-     * Find all tags which has enabled given property.
+     * Add text as a child node to this element.
      *
-     * @public
+     * @param text - Text to add.
+     * @param location - Source code location of this text.
      */
-    getTagsWithProperty(propName) {
-        return Object.entries(this.elements)
-            .filter(([, entry]) => entry[propName])
-            .map(([tagName]) => tagName);
+    appendText(text, location) {
+        this.childNodes.push(new TextNode(text, location));
     }
     /**
-     * Find tag matching tagName or inheriting from it.
-     *
-     * @public
+     * Return a list of all known classes on the element. Dynamic values are
+     * ignored.
      */
-    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,
-                });
-            }
+    get classList() {
+        if (!this.hasAttribute("class")) {
+            return new DOMTokenList(null, null);
         }
-        /* merge all sources together */
-        const expanded = this.mergeElement(parent, { ...entry, tagName });
-        expandRegex(expanded);
-        this.elements[tagName] = expanded;
+        const classes = this.getAttribute("class", true)
+            .filter((attr) => attr.isStatic)
+            .map((attr) => attr.value)
+            .join(" ");
+        return new DOMTokenList(classes, null);
     }
     /**
-     * Construct a new AJV schema validator.
+     * Get element ID if present.
      */
-    getSchemaValidator() {
-        const hash = computeHash(JSON.stringify(this.schema));
-        const cached = schemaCache.get(hash);
-        if (cached) {
-            return cached;
+    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 {
-            const ajv = new Ajv({ 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(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);
+function isClosed(endToken, meta) {
+    let closed = NodeClosed.Open;
+    if (meta && meta.void) {
+        closed = NodeClosed.VoidOmitted;
     }
-    else {
-        return value;
+    if (endToken.data[0] === "/>") {
+        closed = 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);
     }
 }
 
@@ -3222,6 +3222,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
+ */
+var TextClassification;
+(function (TextClassification) {
+    TextClassification[TextClassification["EMPTY_TEXT"] = 0] = "EMPTY_TEXT";
+    TextClassification[TextClassification["DYNAMIC_TEXT"] = 1] = "DYNAMIC_TEXT";
+    TextClassification[TextClassification["STATIC_TEXT"] = 2] = "STATIC_TEXT";
+})(TextClassification || (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, TextClassification.EMPTY_TEXT);
+    }
+    if (!ignoreHiddenRoot && accessible && isAriaHidden(node)) {
+        return node.cacheSet(cacheKey, TextClassification.EMPTY_TEXT);
+    }
+    if (isSpecialEmpty(node)) {
+        return node.cacheSet(cacheKey, 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, 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, TextClassification.STATIC_TEXT);
+    }
+    /* default to empty */
+    return node.cacheSet(cacheKey, 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",
@@ -3939,6 +4208,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,
@@ -5771,7 +6094,7 @@ 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 hasAltText(node);
     }
@@ -5800,7 +6123,7 @@ 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;
             }
         }
@@ -6423,6 +6746,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 !== 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")) {
@@ -11690,7 +12133,7 @@ class HtmlValidate {
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "8.0.4";
+const version = "8.0.5";
 /** @public */
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
@@ -11737,6 +12180,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
@@ -12003,5 +12467,5 @@ function getFormatter(name) {
     return (_a = availableFormatters[name]) !== null && _a !== void 0 ? _a : null;
 }
 
-export { Attribute as A, generateIdSelector as B, Config as C, DynamicValue as D, EventHandler as E, name as F, bugs as G, HtmlValidate as H, MetaTable as M, NodeClosed as N, Presets as P, ResolvedConfig as R, Severity as S, TextNode as T, UserError as U, Validator as V, WrappedError as W, ConfigError as a, ConfigLoader as b, StaticConfigLoader as c, DOMTokenList as d, HtmlElement as e, DOMNode as f, DOMTree as g, NodeType as h, SchemaValidationError as i, NestedError as j, TextContent$1 as k, MetaCopyableProperty as l, Rule as m, sliceLocation as n, Reporter as o, definePlugin as p, Parser as q, ruleExists as r, staticResolver as s, getFormatter as t, ensureError as u, version as v, compatibilityCheck as w, codeframe as x, isTextNode as y, isElementNode as z };
+export { Attribute as A, codeframe as B, Config as C, DynamicValue as D, EventHandler as E, requireUncached as F, name as G, HtmlValidate as H, bugs as I, MetaTable as M, NodeClosed as N, Presets as P, ResolvedConfig as R, Severity as S, TextNode as T, UserError as U, Validator as V, WrappedError as W, ConfigError as a, ConfigLoader as b, StaticConfigLoader as c, DOMTokenList as d, HtmlElement as e, DOMNode as f, DOMTree as g, NodeType as h, SchemaValidationError as i, NestedError as j, TextContent$1 as k, MetaCopyableProperty as l, Rule as m, TextClassification as n, classifyNodeText as o, keywordPatternMatcher as p, sliceLocation as q, Reporter as r, staticResolver as s, definePlugin as t, Parser as u, version as v, ruleExists as w, getFormatter as x, ensureError as y, compatibilityCheck as z };
 //# sourceMappingURL=core.js.map