html-validate 7.6.0 → 7.7.1

package/dist/es/core.js

@@ -333,2222 +333,2537 @@ class SchemaValidationError extends UserError {
 }
 
 /**
- * Computes hash for given string.
+ * Helper function to assist IDE with completion and type-checking.
  *
- * @internal
+ * @public
  */
-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);
+function defineMetadata(metatable) {
+    return metatable;
+}
+
+/**
+ * @public
+ */
+class DynamicValue {
+    constructor(expr) {
+        this.expr = expr;
+    }
+    toString() {
+        return this.expr;
     }
-    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 projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../");
-			const legacyRequire = createRequire(import.meta.url);
-			const distFolder = path.resolve(projectRoot, "dist/es");
+/**
+ * DOM Attribute.
+ *
+ * Represents a HTML attribute. Can contain either a fixed static value or a
+ * placeholder for dynamic values (e.g. interpolated).
+ */
+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 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() : ""];
+    });
+}
 /**
- * Similar to `require(..)` but removes the cached copy first.
+ * @internal
  */
-function requireUncached(moduleId) {
-    const filename = legacyRequire.resolve(moduleId);
-    /* remove references from the parent module to prevent memory leak */
-    const m = legacyRequire.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);
+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
+    }
+    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,
+        };
     }
-    /* remove old module from cache */
-    delete legacyRequire.cache[filename];
-    return legacyRequire(filename);
 }
 
-const $schema$1 = "http://json-schema.org/draft-06/schema#";
-const $id$1 = "https://html-validate.org/schemas/elements.json";
-const type$1 = "object";
-const properties$1 = {
-	$schema: {
-		type: "string"
-	}
-};
-const patternProperties = {
-	"^[^$].*$": {
-		type: "object",
-		properties: {
-			inherit: {
-				title: "Inherit from another element",
-				description: "Most properties from the parent element will be copied onto this one",
-				type: "string"
-			},
-			embedded: {
-				title: "Mark this element as belonging in the embedded content category",
-				$ref: "#/definitions/contentCategory"
-			},
-			flow: {
-				title: "Mark this element as belonging in the flow content category",
-				$ref: "#/definitions/contentCategory"
-			},
-			heading: {
-				title: "Mark this element as belonging in the heading content category",
-				$ref: "#/definitions/contentCategory"
-			},
-			interactive: {
-				title: "Mark this element as belonging in the interactive content category",
-				$ref: "#/definitions/contentCategory"
-			},
-			metadata: {
-				title: "Mark this element as belonging in the metadata content category",
-				$ref: "#/definitions/contentCategory"
-			},
-			phrasing: {
-				title: "Mark this element as belonging in the phrasing content category",
-				$ref: "#/definitions/contentCategory"
-			},
-			sectioning: {
-				title: "Mark this element as belonging in the sectioning content category",
-				$ref: "#/definitions/contentCategory"
-			},
-			deprecated: {
-				title: "Mark element as deprecated",
-				description: "Deprecated elements should not be used. If a message is provided it will be included in the error",
-				anyOf: [
-					{
-						type: "boolean"
-					},
-					{
-						type: "string"
-					},
-					{
-						$ref: "#/definitions/deprecatedElement"
-					}
-				]
-			},
-			foreign: {
-				title: "Mark element as foreign",
-				description: "Foreign elements are elements which have a start and end tag but is otherwize not parsed",
-				type: "boolean"
-			},
-			"void": {
-				title: "Mark element as void",
-				description: "Void elements are elements which cannot have content and thus must not use an end tag",
-				type: "boolean"
-			},
-			transparent: {
-				title: "Mark element as transparent",
-				description: "Transparent elements follows the same content model as its parent, i.e. the content must be allowed in the parent.",
-				anyOf: [
-					{
-						type: "boolean"
-					},
-					{
-						type: "array",
-						items: {
-							type: "string"
-						}
-					}
-				]
-			},
-			implicitClosed: {
-				title: "List of elements which implicitly closes this element",
-				description: "Some elements are automatically closed when another start tag occurs",
-				type: "array",
-				items: {
-					type: "string"
-				}
-			},
-			scriptSupporting: {
-				title: "Mark element as script-supporting",
-				description: "Script-supporting elements are elements which can be inserted where othersise not permitted to assist in templating",
-				type: "boolean"
-			},
-			form: {
-				title: "Mark element as a submittable form element",
-				type: "boolean"
-			},
-			labelable: {
-				title: "Mark this element as labelable",
-				description: "This element may contain an associated label element.",
-				anyOf: [
-					{
-						type: "boolean"
-					},
-					{
-						$ref: "#/definitions/expression"
-					}
-				]
-			},
-			deprecatedAttributes: {
-				title: "List of deprecated attributes",
-				type: "array",
-				items: {
-					type: "string"
-				}
-			},
-			requiredAttributes: {
-				title: "List of required attributes",
-				type: "array",
-				items: {
-					type: "string"
-				}
-			},
-			attributes: {
-				title: "List of known attributes and allowed values",
-				$ref: "#/definitions/PermittedAttribute"
-			},
-			permittedContent: {
-				title: "List of elements or categories allowed as content in this element",
-				$ref: "#/definitions/Permitted"
-			},
-			permittedDescendants: {
-				title: "List of elements or categories allowed as descendants in this element",
-				$ref: "#/definitions/Permitted"
-			},
-			permittedOrder: {
-				title: "Required order of child elements",
-				$ref: "#/definitions/PermittedOrder"
-			},
-			permittedParent: {
-				title: "List of elements or categories allowed as parent to this element",
-				$ref: "#/definitions/Permitted"
-			},
-			requiredAncestors: {
-				title: "List of required ancestor elements",
-				$ref: "#/definitions/RequiredAncestors"
-			},
-			requiredContent: {
-				title: "List of required content elements",
-				$ref: "#/definitions/RequiredContent"
-			},
-			textContent: {
-				title: "Allow, disallow or require textual content",
-				description: "This property controls whenever an element allows, disallows or requires text. Text from any descendant counts, not only direct children",
-				"default": "default",
-				type: "string",
-				"enum": [
-					"none",
-					"default",
-					"required",
-					"accessible"
-				]
-			}
-		},
-		additionalProperties: false
-	}
-};
-const definitions = {
-	contentCategory: {
-		anyOf: [
-			{
-				type: "boolean"
-			},
-			{
-				$ref: "#/definitions/expression"
-			}
-		]
-	},
-	expression: {
-		type: "array",
-		minItems: 2,
-		maxItems: 2,
-		items: [
-			{
-				type: "string",
-				"enum": [
-					"isDescendant",
-					"hasAttribute",
-					"matchAttribute"
-				]
-			},
-			{
-				anyOf: [
-					{
-						type: "string"
-					},
-					{
-						$ref: "#/definitions/operation"
-					}
-				]
-			}
-		]
-	},
-	operation: {
-		type: "array",
-		minItems: 3,
-		maxItems: 3,
-		items: [
-			{
-				type: "string"
-			},
-			{
-				type: "string",
-				"enum": [
-					"!=",
-					"="
-				]
-			},
-			{
-				type: "string"
-			}
-		]
-	},
-	deprecatedElement: {
-		type: "object",
-		additionalProperties: false,
-		properties: {
-			message: {
-				type: "string",
-				title: "A short text message shown next to the regular error message."
-			},
-			documentation: {
-				type: "string",
-				title: "An extended markdown formatted message shown with the contextual rule documentation."
-			},
-			source: {
-				type: "string",
-				title: "Element source, e.g. what standard or library deprecated this element.",
-				"default": "html5"
-			}
-		}
-	},
-	Permitted: {
-		type: "array",
-		items: {
-			anyOf: [
-				{
-					type: "string"
-				},
-				{
-					type: "array",
-					items: {
-						anyOf: [
-							{
-								type: "string"
-							},
-							{
-								$ref: "#/definitions/PermittedGroup"
-							}
-						]
-					}
-				},
-				{
-					$ref: "#/definitions/PermittedGroup"
-				}
-			]
-		}
-	},
-	PermittedAttribute: {
-		type: "object",
-		patternProperties: {
-			"^.*$": {
-				anyOf: [
-					{
-						type: "object",
-						additionalProperties: false,
-						properties: {
-							boolean: {
-								type: "boolean",
-								title: "Set to true if this is a boolean attribute"
-							},
-							deprecated: {
-								title: "Set to true or string if this attribute is deprecated",
-								oneOf: [
-									{
-										type: "boolean"
-									},
-									{
-										type: "string"
-									}
-								]
-							},
-							list: {
-								type: "boolean",
-								title: "Set to true if this attribute is a list of space-separated tokens, each which must be valid by itself"
-							},
-							"enum": {
-								type: "array",
-								title: "Exhaustive list of values (string or regex) this attribute accepts",
-								uniqueItems: true,
-								items: {
-									anyOf: [
-										{
-											type: "string"
-										},
-										{
-											regexp: true
-										}
-									]
-								}
-							},
-							omit: {
-								type: "boolean",
-								title: "Set to true if this attribute can optionally omit its value"
-							},
-							required: {
-								type: "boolean",
-								title: "Set to true if this attribute is required"
-							}
-						}
-					},
-					{
-						type: "array",
-						uniqueItems: true,
-						items: {
-							type: "string"
-						}
-					}
-				]
-			}
-		}
-	},
-	PermittedGroup: {
-		type: "object",
-		additionalProperties: false,
-		properties: {
-			exclude: {
-				anyOf: [
-					{
-						items: {
-							type: "string"
-						},
-						type: "array"
-					},
-					{
-						type: "string"
-					}
-				]
-			}
-		}
-	},
-	PermittedOrder: {
-		type: "array",
-		items: {
-			type: "string"
-		}
-	},
-	RequiredAncestors: {
-		type: "array",
-		items: {
-			type: "string"
-		}
-	},
-	RequiredContent: {
-		type: "array",
-		items: {
-			type: "string"
-		}
-	}
-};
-var schema = {
-	$schema: $schema$1,
-	$id: $id$1,
-	type: type$1,
-	properties: properties$1,
-	patternProperties: patternProperties,
-	definitions: definitions
-};
+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",
+    "labelable",
+    "attributes",
+    "permittedContent",
+    "permittedDescendants",
+    "permittedOrder",
+    "permittedParent",
+    "requiredAncestors",
+    "requiredContent",
+];
+/**
+ * @internal
+ */
+function setMetaProperty(dst, key, value) {
+    dst[key] = value;
+}
+
+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;
+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.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.
+     */
+    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).
+     */
+    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;
+    }
+    /**
+     * Disable a rule for this node.
+     */
+    disableRule(ruleId) {
+        this.disabledRules.add(ruleId);
+    }
+    /**
+     * Disables multiple rules.
+     */
+    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.
+     */
+    ruleEnabled(ruleId) {
+        return !this.disabledRules.has(ruleId);
+    }
+    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 };
+}
+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 */
+            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}"`);
+    }
+}
 
-/**
- * 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",
-                },
-            },
-        ];
+function firstChild(node) {
+    return node.previousSibling === null;
+}
+
+function lastChild(node) {
+    return node.nextSibling === null;
+}
+
+const cache = {};
+function getNthChild(node) {
+    if (!node.parent) {
+        return -1;
     }
-    return valid;
-};
-const ajvRegexpKeyword = {
-    keyword: "regexp",
-    schema: false,
-    errors: true,
-    validate: ajvRegexpValidate,
+    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`);
+    }
+}
 
-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]].
+ * Homage to PHP: unescapes slashes.
  *
- * @public
+ * E.g. "foo\:bar" becomes "foo:bar"
  */
-const MetaCopyableProperty = [
-    "metadata",
-    "flow",
-    "sectioning",
-    "heading",
-    "phrasing",
-    "embedded",
-    "interactive",
-    "transparent",
-    "form",
-    "labelable",
-    "attributes",
-    "permittedContent",
-    "permittedDescendants",
-    "permittedOrder",
-    "permittedParent",
-    "requiredAncestors",
-    "requiredContent",
-];
+function stripslashes(value) {
+    return value.replace(/\\(.)/g, "$1");
+}
 /**
  * @internal
  */
-function setMetaProperty(dst, key, value) {
-    dst[key] = value;
+function escapeSelectorComponent(text) {
+    return text.toString().replace(/([^a-z0-9_-])/gi, "\\$1");
 }
-
-function isSet(value) {
-    return typeof value !== "undefined";
+/**
+ * @internal
+ */
+function generateIdSelector(id) {
+    const escaped = escapeSelectorComponent(id);
+    return escaped.match(/^\d/) ? `[id="${escaped}"]` : `#${escaped}`;
 }
-function flag(value) {
-    return value ? true : undefined;
+/**
+ * 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);
 }
-function stripUndefined(src) {
-    const entries = Object.entries(src).filter(([, value]) => isSet(value));
-    return Object.fromEntries(entries);
+/**
+ * Returns true if the character is a quotation mark.
+ */
+function isQuotationMark(ch) {
+    return /['"]/.test(ch);
 }
-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);
+function isPseudoElement(ch, buffer) {
+    return ch === ":" && buffer === ":";
+}
+/**
+ * @internal
+ */
+function* splitPattern(pattern) {
+    if (pattern === "") {
+        return;
     }
-    if (Array.isArray(attr)) {
-        if (attr.length === 0) {
-            result.boolean = true;
+    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;
         }
-        else {
-            result.enum = attr.filter((it) => it !== "");
-            if (attr.includes("")) {
-                result.omit = true;
+        /* if inside quoted string we only look for the end quotation mark */
+        if (quoted) {
+            if (ch === quoted) {
+                quoted = false;
             }
+            cur += 1;
+            continue;
         }
-        return stripUndefined(result);
-    }
-    else {
-        return stripUndefined({ ...result, ...attr });
+        /* 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 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,
-        attributes: migrateAttributes(src),
-    };
-    /* removed properties */
-    delete result.deprecatedAttributes;
-    delete result.requiredAttributes;
-    return result;
+class Matcher {
 }
-
-/**
- * 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;
+class ClassMatcher extends Matcher {
+    constructor(classname) {
+        super();
+        this.classname = classname;
+    }
+    match(node) {
+        return node.classList.contains(this.classname);
     }
-    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);
+class IdMatcher extends Matcher {
+    constructor(id) {
+        super();
+        this.id = stripslashes(id);
+    }
+    match(node) {
+        return node.id === this.id;
+    }
 }
-
-/**
- * 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;
+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`);
+            }
+        });
     }
 }
-
-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));
+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);
+    }
 }
-function overwriteMerge$1(a, b) {
-    return b;
+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}"`);
+        }
+    }
 }
 /**
- * @public
+ * DOM Selector.
  */
-class MetaTable {
-    /**
-     * @internal
-     */
-    constructor() {
-        this.elements = {};
-        this.schema = clone(schema);
-    }
-    /**
-     * @internal
-     */
-    init() {
-        this.resolveGlobal();
+class Selector {
+    constructor(selector) {
+        this.pattern = Selector.parse(selector);
     }
     /**
-     * Extend validation schema.
+     * Match this selector against a HtmlElement.
      *
-     * @internal
+     * @param root - Element to match against.
+     * @returns Iterator with matched elements.
      */
-    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,
-            });
-        }
+    *match(root) {
+        const context = { scope: root };
+        yield* this.matchInternal(root, 0, context);
     }
-    /**
-     * Load metadata table from object.
-     *
-     * @internal
-     * @param obj - Object with metadata to load
-     * @param filename - Optional filename used when presenting validation error
-     */
-    loadFromObject(obj, filename = null) {
-        var _a;
-        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 : []);
+    *matchInternal(root, level, context) {
+        if (level >= this.pattern.length) {
+            yield root;
+            return;
         }
-        for (const [key, value] of Object.entries(obj)) {
-            if (key === "$schema")
+        const pattern = this.pattern[level];
+        const matches = Selector.findCandidates(root, pattern);
+        for (const node of matches) {
+            if (!pattern.match(node, context)) {
                 continue;
-            this.addEntry(key, migrateElement(value));
-        }
-    }
-    /**
-     * Load metadata table from filename
-     *
-     * @internal
-     * @param filename - Filename to load
-     */
-    loadFromFile(filename) {
-        try {
-            /* load using require as it can process both js and json */
-            const data = requireUncached(filename);
-            this.loadFromObject(data, filename);
-        }
-        catch (err) {
-            if (err instanceof SchemaValidationError) {
-                throw err;
             }
-            throw new UserError(`Failed to load element metadata from "${filename}"`, ensureError(err));
+            yield* this.matchInternal(node, level + 1, context);
         }
     }
-    /**
-     * 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["*"] };
+    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];
         }
-        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);
+        /* istanbul ignore next: fallback solution, the switch cases should cover
+         * everything and there is no known way to trigger this fallback */
+        return [];
     }
-    /**
-     * 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);
+    static findAdjacentSibling(node) {
+        let adjacent = false;
+        return node.siblings.filter((cur) => {
+            if (adjacent) {
+                adjacent = false;
+                return true;
+            }
+            if (cur === node) {
+                adjacent = true;
+            }
+            return false;
+        });
     }
-    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 UserError(`Element <${tagName}> cannot inherit from <${name}>: no such element`);
+    static findGeneralSibling(node) {
+        let after = false;
+        return node.siblings.filter((cur) => {
+            if (after) {
+                return true;
             }
-        }
-        /* merge all sources together */
-        const expanded = this.mergeElement(parent, { ...entry, tagName });
-        expandRegex(expanded);
-        this.elements[tagName] = expanded;
+            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 {
     /**
-     * Construct a new AJV schema validator.
+     * @param text - Text to add. When a `DynamicValue` is used the expression is
+     * used as "text".
+     * @param location - Source code location of this node.
      */
-    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(ajvRegexpKeyword);
-            ajv.addKeyword({ keyword: "copyable" });
-            const validate = ajv.compile(this.schema);
-            schemaCache.set(hash, validate);
-            return validate;
-        }
+    constructor(text, location) {
+        super(NodeType.TEXT_NODE, TEXT_NODE_NAME, location);
+        this.text = text;
     }
     /**
-     * @public
+     * Get the text from node.
      */
-    getJSONSchema() {
-        return this.schema;
+    get textContent() {
+        return this.text.toString();
     }
     /**
-     * Finds the global element definition and merges each known element with the
-     * global, e.g. to assign global attributes.
+     * Flag set to true if the attribute value is static.
      */
-    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;
+    get isStatic() {
+        return !this.isDynamic;
     }
     /**
-     * @internal
+     * Flag set to true if the attribute value is dynamic.
      */
-    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));
-        }
+    get isDynamic() {
+        return this.text instanceof DynamicValue;
     }
 }
+
 /**
- * Given a string it returns either the string as-is or if the string is wrapped
- * in /../ it creates and returns a regex instead.
+ * @public
  */
-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
-        return new RegExp(`^${expr}$`, flags);
-    }
-    else {
-        return value;
-    }
-}
+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 = {}));
 /**
- * Expand all regular expressions in strings ("/../"). This mutates the object.
+ * Returns true if the node is an element node.
+ *
+ * @public
  */
-function expandRegex(entry) {
-    for (const [name, values] of Object.entries(entry.attributes)) {
-        if (values.enum) {
-            entry.attributes[name].enum = values.enum.map(expandRegexValue);
-        }
-    }
+function isElementNode(node) {
+    return Boolean(node && node.nodeType === NodeType.ELEMENT_NODE);
 }
-function evaluateProperty(node, expr) {
-    const [func, options] = parseExpression(expr);
-    return func(node, options);
+function isValidTagName(tagName) {
+    return Boolean(tagName !== "" && tagName !== "*");
 }
-function parseExpression(expr) {
-    if (typeof expr === "string") {
-        return parseExpression([expr, {}]);
-    }
-    else {
-        const [funcName, options] = expr;
-        const func = functionTable[funcName];
-        if (!func) {
-            throw new Error(`Failed to find function "${funcName}" when evaluating property expression`);
+/**
+ * @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;
+            }
         }
-        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;
+    /**
+     * @internal
+     */
+    static rootNode(location) {
+        const root = new HtmlElement(undefined, null, NodeClosed.EndTag, null, location);
+        root.setAnnotation("#document");
+        return root;
     }
-    toString() {
-        return this.expr;
+    /**
+     * @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);
     }
-}
-
-/**
- * DOM Attribute.
- *
- * Represents a HTML attribute. Can contain either a fixed static value or a
- * placeholder for dynamic values (e.g. interpolated).
- */
-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`).
+     * Returns annotated name if set or defaults to `<tagName>`.
+     *
+     * E.g. `my-annotation` or `<div>`.
      */
-    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;
+    get annotatedName() {
+        if (this.annotation) {
+            return this.annotation;
+        }
+        else {
+            return `<${this.tagName}>`;
         }
     }
     /**
-     * Flag set to true if the attribute value is static.
+     * 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 isStatic() {
-        return !this.isDynamic;
+    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;
     }
     /**
-     * Flag set to true if the attribute value is dynamic.
+     * Similar to childNodes but only elements.
      */
-    get isDynamic() {
-        return this.value instanceof DynamicValue;
+    get childElements() {
+        return this.childNodes.filter(isElementNode);
     }
-    valueMatches(pattern, dynamicMatches = true) {
-        if (this.value === null) {
-            return false;
+    /**
+     * 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 */
+        let node = this;
+        while (node) {
+            if (node.matches(selectors)) {
+                return node;
+            }
+            node = node.parent;
         }
-        /* dynamic values matches everything */
-        if (this.value instanceof DynamicValue) {
-            return dynamicMatches;
+        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;
         }
-        /* test value against pattern */
-        if (pattern instanceof RegExp) {
-            return this.value.match(pattern) !== null;
+        const parts = [];
+        let root;
+        /* eslint-disable-next-line @typescript-eslint/no-this-alias */
+        for (root = this; root.parent; root = root.parent) {
+            /* .. */
         }
-        else {
-            return this.value === pattern;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        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(" > ");
     }
-}
-
-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;
+    /**
+     * 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();
     }
-    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++;
+    /**
+     * 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 {
-                break;
+                delete this.metaElement[key];
             }
-        } while (true); // eslint-disable-line no-constant-condition
-    }
-    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 */
+    /**
+     * 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 */
+        let root = this;
+        while (root.parent) {
+            root = root.parent;
         }
-        /* 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);
+        /* 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;
+            }
         }
-        this.column += consumed.length;
-        this.offset += n;
-        /* remove N chars */
-        this.string = this.string.substr(n);
-        /* change state */
-        this.state = state;
+        return false;
     }
-    getLocation(size) {
-        return {
-            filename: this.filename,
-            offset: this.offset,
-            line: this.line,
-            column: this.column,
-            size,
-        };
+    get meta() {
+        return this.metaElement;
     }
-}
-
-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;
-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.
+     * Set annotation for this element.
      */
-    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.childNodes = [];
-        this.unique = counter++;
-        this.cache = null;
+    setAnnotation(text) {
+        this.annotation = text;
     }
     /**
-     * Enable cache for this node.
+     * Set attribute. Stores all attributes set even with the same name.
      *
-     * Should not be called before the node and all children are fully constructed.
+     * @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.
      */
-    cacheEnable() {
-        this.cache = new Map();
+    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));
     }
-    cacheGet(key) {
-        if (this.cache) {
-            return this.cache.get(key);
+    /**
+     * 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 undefined;
-        }
-    }
-    cacheSet(key, value) {
-        if (this.cache) {
-            this.cache.set(key, value);
+            return null;
         }
-        return value;
     }
-    cacheRemove(key) {
-        if (this.cache) {
-            return this.cache.delete(key);
+    /**
+     * 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 false;
+            return null;
         }
     }
-    cacheExists(key) {
-        return Boolean(this.cache && this.cache.has(key));
+    /**
+     * 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));
     }
     /**
-     * Get the text (recursive) from all child nodes.
+     * Return a list of all known classes on the element. Dynamic values are
+     * ignored.
      */
-    get textContent() {
-        const cached = this.cacheGet(TEXT_CONTENT);
-        if (cached) {
-            return cached;
+    get classList() {
+        if (!this.hasAttribute("class")) {
+            return new DOMTokenList(null, null);
         }
-        const text = this.childNodes.map((node) => node.textContent).join("");
-        this.cacheSet(TEXT_CONTENT, text);
-        return text;
+        const classes = this.getAttribute("class", true)
+            .filter((attr) => attr.isStatic)
+            .map((attr) => attr.value)
+            .join(" ");
+        return new DOMTokenList(classes, null);
     }
-    append(node) {
-        this.childNodes.push(node);
+    /**
+     * Get element ID if present.
+     */
+    get id() {
+        return this.getAttributeValue("id");
     }
-    isRootElement() {
-        return this.nodeType === NodeType.DOCUMENT_NODE;
+    get style() {
+        const attr = this.getAttribute("style");
+        return parseCssDeclaration(attr === null || attr === void 0 ? void 0 : attr.value);
     }
     /**
-     * Tests if two nodes are the same (references the same object).
+     * Returns the first child element or null if there are no child elements.
      */
-    isSameNode(otherNode) {
-        return this.unique === otherNode.unique;
+    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));
+        }, []);
     }
-    /**
-     * Returns a DOMNode representing the first direct child node or `null` if the
-     * node has no children.
-     */
-    get firstChild() {
-        return this.childNodes[0] || null;
+    querySelector(selector) {
+        var _a;
+        const it = this.querySelectorImpl(selector);
+        return (_a = it.next().value) !== null && _a !== void 0 ? _a : null; // eslint-disable-line @typescript-eslint/no-unsafe-return
     }
-    /**
-     * 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;
+    querySelectorAll(selector) {
+        const it = this.querySelectorImpl(selector);
+        const unique = new Set(it);
+        return Array.from(unique.values());
     }
-    /**
-     * Disable a rule for this node.
-     */
-    disableRule(ruleId) {
-        this.disabledRules.add(ruleId);
+    *querySelectorImpl(selectorList) {
+        if (!selectorList) {
+            return;
+        }
+        for (const selector of selectorList.split(/,\s*/)) {
+            const pattern = new Selector(selector);
+            yield* pattern.match(this);
+        }
     }
     /**
-     * Disables multiple rules.
+     * Visit all nodes from this node and down. Depth first.
+     *
+     * @internal
      */
-    disableRules(rules) {
-        for (const rule of rules) {
-            this.disableRule(rule);
+    visitDepthFirst(callback) {
+        function visit(node) {
+            node.childElements.forEach(visit);
+            if (!node.isRootElement()) {
+                callback(node);
+            }
         }
+        visit(this);
     }
     /**
-     * Enable a previously disabled rule for this node.
+     * Evaluates callbackk on all descendants, returning true if any are true.
+     *
+     * @internal
      */
-    enableRule(ruleId) {
-        this.disabledRules.delete(ruleId);
+    someChildren(callback) {
+        return this.childElements.some(visit);
+        function visit(node) {
+            if (callback(node)) {
+                return true;
+            }
+            else {
+                return node.childElements.some(visit);
+            }
+        }
     }
     /**
-     * Enables multiple rules.
+     * Evaluates callbackk on all descendants, returning true if all are true.
+     *
+     * @internal
      */
-    enableRules(rules) {
-        for (const rule of rules) {
-            this.enableRule(rule);
+    everyChildren(callback) {
+        return this.childElements.every(visit);
+        function visit(node) {
+            if (!callback(node)) {
+                return false;
+            }
+            return node.childElements.every(visit);
         }
     }
     /**
-     * Test if a rule is enabled for this node.
+     * Visit all nodes from this node and down. Breadth first.
+     *
+     * The first node for which the callback evaluates to true is returned.
+     *
+     * @internal
      */
-    ruleEnabled(ruleId) {
-        return !this.disabledRules.has(ruleId);
-    }
-    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);
+    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;
         }
-        /* advance position to the character after the current end position */
-        begin += size + 1;
+        return visit(this);
     }
-    return { tokens, locations };
 }
-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);
+function isClosed(endToken, meta) {
+    let closed = NodeClosed.Open;
+    if (meta && meta.void) {
+        closed = NodeClosed.VoidOmitted;
     }
-    *iterator() {
-        for (let index = 0; index < this.length; index++) {
-            /* eslint-disable @typescript-eslint/no-non-null-assertion */
-            const item = this.item(index);
-            const location = this.location(index);
-            /* eslint-enable @typescript-eslint/no-non-null-assertion */
-            yield { index, item, location };
-        }
+    if (endToken.data[0] === "/>") {
+        closed = NodeClosed.VoidSelfClosed;
     }
+    return closed;
 }
 
-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;
+class DOMTree {
+    constructor(location) {
+        this.root = HtmlElement.rootNode(location);
+        this.active = this.root;
+        this.doctype = null;
     }
-    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}"`);
+    pushActive(node) {
+        this.active = node;
     }
-}
-
-function firstChild(node) {
-    return node.previousSibling === null;
-}
-
-function lastChild(node) {
-    return node.nextSibling === null;
-}
-
-const cache = {};
-function getNthChild(node) {
-    if (!node.parent) {
-        return -1;
+    popActive() {
+        if (this.active.isRootElement()) {
+            /* root element should never be popped, continue as if nothing happened */
+            return;
+        }
+        this.active = this.active.parent || this.root;
     }
-    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 */
+    getActive() {
+        return this.active;
     }
-    return cache[node.unique];
-}
-function nthChild(node, args) {
-    if (!args) {
-        throw new Error("Missing argument to nth-child");
+    /**
+     * Resolve dynamic meta expressions.
+     */
+    resolveMeta(table) {
+        this.visitDepthFirst((node) => table.resolve(node));
+    }
+    getElementsByTagName(tagName) {
+        return this.root.getElementsByTagName(tagName);
     }
-    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);
+    visitDepthFirst(callback) {
+        this.root.visitDepthFirst(callback);
     }
-    else {
-        throw new Error(`Pseudo-class "${name}" is not implemented`);
+    find(callback) {
+        return this.root.find(callback);
+    }
+    querySelector(selector) {
+        return this.root.querySelector(selector);
+    }
+    querySelectorAll(selector) {
+        return this.root.querySelectorAll(selector);
     }
 }
 
+const ARIA_HIDDEN_CACHE = Symbol(isAriaHidden.name);
+const HTML_HIDDEN_CACHE = Symbol(isHTMLHidden.name);
+const ROLE_PRESENTATION_CACHE = Symbol(isPresentation.name);
 /**
- * Homage to PHP: unescapes slashes.
+ * Tests if this element is present in the accessibility tree.
  *
- * E.g. "foo\:bar" becomes "foo:bar"
- */
-function stripslashes(value) {
-    return value.replace(/\\(.)/g, "$1");
-}
-/**
- * @internal
+ * 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 escapeSelectorComponent(text) {
-    return text.toString().replace(/([^a-z0-9_-])/gi, "\\$1");
+function inAccessibilityTree(node) {
+    return !isAriaHidden(node) && !isPresentation(node);
 }
-/**
- * @internal
- */
-function generateIdSelector(id) {
-    const escaped = escapeSelectorComponent(id);
-    return escaped.match(/^\d/) ? `[id="${escaped}"]` : `#${escaped}`;
+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),
+    };
 }
-/**
- * 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);
+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;
 }
-/**
- * Returns true if the character is a quotation mark.
- */
-function isQuotationMark(ch) {
-    return /['"]/.test(ch);
+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 isPseudoElement(ch, buffer) {
-    return ch === ":" && buffer === ":";
+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;
 }
 /**
- * @internal
+ * Tests if this element or a parent element has role="presentation".
+ *
+ * Dynamic values yields `false` just as if the attribute wasn't present.
  */
-function* splitPattern(pattern) {
-    if (pattern === "") {
-        return;
+function isPresentation(node) {
+    if (node.cacheExists(ROLE_PRESENTATION_CACHE)) {
+        return Boolean(node.cacheGet(ROLE_PRESENTATION_CACHE));
     }
-    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;
+    let cur = node;
+    do {
+        const role = cur.getAttribute("role");
+        /* role="presentation" */
+        if (role && role.value === "presentation") {
+            return cur.cacheSet(ROLE_PRESENTATION_CACHE, true);
         }
-        /* if the character is a delimiter we yield the string and reset the
-         * position */
-        if (isDelimiter(ch)) {
-            begin = cur;
-            yield buffer;
+        /* sanity check: break if no parent is present, normally not an issue as the
+         * root element should be found first */
+        if (!cur.parent) {
+            break;
         }
-        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`);
-            }
-        });
-    }
+        /* check parents */
+        cur = cur.parent;
+    } while (!cur.isRootElement());
+    return node.cacheSet(ROLE_PRESENTATION_CACHE, false);
 }
-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);
+
+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 = {}));
+function getCachekey(options = {}) {
+    const { accessible = false, ignoreHiddenRoot = false } = options;
+    if (accessible && ignoreHiddenRoot) {
+        return IGNORE_HIDDEN_ROOT_A11Y_CACHE_KEY;
     }
-}
-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));
+    else if (ignoreHiddenRoot) {
+        return IGNORE_HIDDEN_ROOT_HTML_CACHE_KEY;
     }
-    match(node, context) {
-        return node.is(this.tagName) && this.pattern.every((cur) => cur.match(node, context));
+    else if (accessible) {
+        return A11Y_CACHE_KEY;
     }
-    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}"`);
-        }
+    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");
+}
 /**
- * DOM Selector.
+ * 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
  */
-class Selector {
-    constructor(selector) {
-        this.pattern = Selector.parse(selector);
+function classifyNodeText(node, options = {}) {
+    const { accessible = false, ignoreHiddenRoot = false } = options;
+    const cacheKey = getCachekey(options);
+    if (node.cacheExists(cacheKey)) {
+        return node.cacheGet(cacheKey);
     }
-    /**
-     * 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 (!ignoreHiddenRoot && isHTMLHidden(node)) {
+        return node.cacheSet(cacheKey, TextClassification.EMPTY_TEXT);
     }
-    *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);
-        }
+    if (!ignoreHiddenRoot && accessible && isAriaHidden(node)) {
+        return node.cacheSet(cacheKey, TextClassification.EMPTY_TEXT);
     }
-    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));
+    if (isSpecialEmpty(node)) {
+        return node.cacheSet(cacheKey, TextClassification.EMPTY_TEXT);
     }
-    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 [];
+    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);
     }
-    static findAdjacentSibling(node) {
-        let adjacent = false;
-        return node.siblings.filter((cur) => {
-            if (adjacent) {
-                adjacent = false;
-                return true;
-            }
-            if (cur === node) {
-                adjacent = true;
-            }
-            return false;
-        });
+    /* 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);
     }
-    static findGeneralSibling(node) {
-        let after = false;
-        return node.siblings.filter((cur) => {
-            if (after) {
-                return true;
+    /* 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 (cur === node) {
-                after = true;
+            if (accessible && isAriaHidden(child, true).bySelf) {
+                continue;
             }
-            return false;
-        });
+            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() !== "";
 }
 
-const TEXT_NODE_NAME = "#text";
 /**
- * Returns true if the node is a text node.
+ * Joins a list of words into natural language.
  *
- * @public
+ * - `["foo"]` becomes `"foo"`
+ * - `["foo", "bar"]` becomes `"foo or bar"`
+ * - `["foo", "bar", "baz"]` becomes `"foo, bar or baz"`
+ * - and so on...
+ *
+ * @internal
+ * @param values - List of words to join
+ * @param conjunction - Conjunction for the last element.
+ * @returns String with the words naturally joined with a conjunction.
  */
-function isTextNode(node) {
-    return Boolean(node && node.nodeType === NodeType.TEXT_NODE);
+function naturalJoin(values, conjunction = "or") {
+    switch (values.length) {
+        case 0:
+            return "";
+        case 1:
+            return values[0];
+        case 2:
+            return `${values[0]} ${conjunction} ${values[1]}`;
+        default:
+            return `${values.slice(0, -1).join(", ")} ${conjunction} ${values.slice(-1)[0]}`;
+    }
 }
+
 /**
- * Represents a text in the HTML document.
- *
- * Text nodes are appended as children of `HtmlElement` and cannot have childen
- * of its own.
+ * @internal
+ */
+function allowedIfAttributeIsPresent(...attr) {
+    return (node) => {
+        if (attr.some((it) => node.hasAttribute(it))) {
+            return null;
+        }
+        const expected = naturalJoin(attr.map((it) => `"${it}"`));
+        return `requires ${expected} attribute to be present`;
+    };
+}
+/**
+ * @internal
+ */
+function allowedIfAttributeIsAbsent(...attr) {
+    return (node) => {
+        const present = attr.filter((it) => node.hasAttribute(it));
+        if (present.length === 0) {
+            return null;
+        }
+        const expected = naturalJoin(present.map((it) => `"${it}"`));
+        return `cannot be used at the same time as ${expected}`;
+    };
+}
+/**
+ * @internal
+ */
+function allowedIfAttributeHasValue(key, expectedValue, { defaultValue } = {}) {
+    return (node) => {
+        const attr = node.getAttribute(key);
+        if (attr === null || attr === void 0 ? void 0 : attr.isDynamic) {
+            return null;
+        }
+        const actualValue = (attr === null || attr === void 0 ? void 0 : attr.value) ? attr.value.toString() : defaultValue;
+        if (actualValue && expectedValue.includes(actualValue.toLocaleLowerCase())) {
+            return null;
+        }
+        const expected = naturalJoin(expectedValue.map((it) => `"${it}"`));
+        return `"${key}" attribute must be ${expected}`;
+    };
+}
+const metadataHelper = {
+    allowedIfAttributeIsPresent,
+    allowedIfAttributeIsAbsent,
+    allowedIfAttributeHasValue,
+};
+
+/**
+ * Computes hash for given string.
  *
- * @public
+ * @internal
  */
-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;
+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);
     }
-    /**
-     * Flag set to true if the attribute value is dynamic.
-     */
-    get isDynamic() {
-        return this.text instanceof DynamicValue;
+    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 projectRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../");
+			const legacyRequire = createRequire(import.meta.url);
+			const distFolder = path.resolve(projectRoot, "dist/es");
+
+/**
+ * Similar to `require(..)` but removes the cached copy first.
+ */
+function requireUncached(moduleId) {
+    const filename = legacyRequire.resolve(moduleId);
+    /* remove references from the parent module to prevent memory leak */
+    const m = legacyRequire.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 legacyRequire.cache[filename];
+    return legacyRequire(filename);
 }
 
+const $schema$1 = "http://json-schema.org/draft-06/schema#";
+const $id$1 = "https://html-validate.org/schemas/elements.json";
+const type$1 = "object";
+const properties$1 = {
+	$schema: {
+		type: "string"
+	}
+};
+const patternProperties = {
+	"^[^$].*$": {
+		type: "object",
+		properties: {
+			inherit: {
+				title: "Inherit from another element",
+				description: "Most properties from the parent element will be copied onto this one",
+				type: "string"
+			},
+			embedded: {
+				title: "Mark this element as belonging in the embedded content category",
+				$ref: "#/definitions/contentCategory"
+			},
+			flow: {
+				title: "Mark this element as belonging in the flow content category",
+				$ref: "#/definitions/contentCategory"
+			},
+			heading: {
+				title: "Mark this element as belonging in the heading content category",
+				$ref: "#/definitions/contentCategory"
+			},
+			interactive: {
+				title: "Mark this element as belonging in the interactive content category",
+				$ref: "#/definitions/contentCategory"
+			},
+			metadata: {
+				title: "Mark this element as belonging in the metadata content category",
+				$ref: "#/definitions/contentCategory"
+			},
+			phrasing: {
+				title: "Mark this element as belonging in the phrasing content category",
+				$ref: "#/definitions/contentCategory"
+			},
+			sectioning: {
+				title: "Mark this element as belonging in the sectioning content category",
+				$ref: "#/definitions/contentCategory"
+			},
+			deprecated: {
+				title: "Mark element as deprecated",
+				description: "Deprecated elements should not be used. If a message is provided it will be included in the error",
+				anyOf: [
+					{
+						type: "boolean"
+					},
+					{
+						type: "string"
+					},
+					{
+						$ref: "#/definitions/deprecatedElement"
+					}
+				]
+			},
+			foreign: {
+				title: "Mark element as foreign",
+				description: "Foreign elements are elements which have a start and end tag but is otherwize not parsed",
+				type: "boolean"
+			},
+			"void": {
+				title: "Mark element as void",
+				description: "Void elements are elements which cannot have content and thus must not use an end tag",
+				type: "boolean"
+			},
+			transparent: {
+				title: "Mark element as transparent",
+				description: "Transparent elements follows the same content model as its parent, i.e. the content must be allowed in the parent.",
+				anyOf: [
+					{
+						type: "boolean"
+					},
+					{
+						type: "array",
+						items: {
+							type: "string"
+						}
+					}
+				]
+			},
+			implicitClosed: {
+				title: "List of elements which implicitly closes this element",
+				description: "Some elements are automatically closed when another start tag occurs",
+				type: "array",
+				items: {
+					type: "string"
+				}
+			},
+			scriptSupporting: {
+				title: "Mark element as script-supporting",
+				description: "Script-supporting elements are elements which can be inserted where othersise not permitted to assist in templating",
+				type: "boolean"
+			},
+			form: {
+				title: "Mark element as a submittable form element",
+				type: "boolean"
+			},
+			labelable: {
+				title: "Mark this element as labelable",
+				description: "This element may contain an associated label element.",
+				anyOf: [
+					{
+						type: "boolean"
+					},
+					{
+						$ref: "#/definitions/expression"
+					}
+				]
+			},
+			deprecatedAttributes: {
+				title: "List of deprecated attributes",
+				type: "array",
+				items: {
+					type: "string"
+				}
+			},
+			requiredAttributes: {
+				title: "List of required attributes",
+				type: "array",
+				items: {
+					type: "string"
+				}
+			},
+			attributes: {
+				title: "List of known attributes and allowed values",
+				$ref: "#/definitions/PermittedAttribute"
+			},
+			permittedContent: {
+				title: "List of elements or categories allowed as content in this element",
+				$ref: "#/definitions/Permitted"
+			},
+			permittedDescendants: {
+				title: "List of elements or categories allowed as descendants in this element",
+				$ref: "#/definitions/Permitted"
+			},
+			permittedOrder: {
+				title: "Required order of child elements",
+				$ref: "#/definitions/PermittedOrder"
+			},
+			permittedParent: {
+				title: "List of elements or categories allowed as parent to this element",
+				$ref: "#/definitions/Permitted"
+			},
+			requiredAncestors: {
+				title: "List of required ancestor elements",
+				$ref: "#/definitions/RequiredAncestors"
+			},
+			requiredContent: {
+				title: "List of required content elements",
+				$ref: "#/definitions/RequiredContent"
+			},
+			textContent: {
+				title: "Allow, disallow or require textual content",
+				description: "This property controls whenever an element allows, disallows or requires text. Text from any descendant counts, not only direct children",
+				"default": "default",
+				type: "string",
+				"enum": [
+					"none",
+					"default",
+					"required",
+					"accessible"
+				]
+			}
+		},
+		additionalProperties: false
+	}
+};
+const definitions = {
+	contentCategory: {
+		anyOf: [
+			{
+				type: "boolean"
+			},
+			{
+				$ref: "#/definitions/expression"
+			}
+		]
+	},
+	expression: {
+		type: "array",
+		minItems: 2,
+		maxItems: 2,
+		items: [
+			{
+				type: "string",
+				"enum": [
+					"isDescendant",
+					"hasAttribute",
+					"matchAttribute"
+				]
+			},
+			{
+				anyOf: [
+					{
+						type: "string"
+					},
+					{
+						$ref: "#/definitions/operation"
+					}
+				]
+			}
+		]
+	},
+	operation: {
+		type: "array",
+		minItems: 3,
+		maxItems: 3,
+		items: [
+			{
+				type: "string"
+			},
+			{
+				type: "string",
+				"enum": [
+					"!=",
+					"="
+				]
+			},
+			{
+				type: "string"
+			}
+		]
+	},
+	deprecatedElement: {
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			message: {
+				type: "string",
+				title: "A short text message shown next to the regular error message."
+			},
+			documentation: {
+				type: "string",
+				title: "An extended markdown formatted message shown with the contextual rule documentation."
+			},
+			source: {
+				type: "string",
+				title: "Element source, e.g. what standard or library deprecated this element.",
+				"default": "html5"
+			}
+		}
+	},
+	Permitted: {
+		type: "array",
+		items: {
+			anyOf: [
+				{
+					type: "string"
+				},
+				{
+					type: "array",
+					items: {
+						anyOf: [
+							{
+								type: "string"
+							},
+							{
+								$ref: "#/definitions/PermittedGroup"
+							}
+						]
+					}
+				},
+				{
+					$ref: "#/definitions/PermittedGroup"
+				}
+			]
+		}
+	},
+	PermittedAttribute: {
+		type: "object",
+		patternProperties: {
+			"^.*$": {
+				anyOf: [
+					{
+						type: "object",
+						additionalProperties: false,
+						properties: {
+							allowed: {
+								"function": true,
+								title: "Set to a function to evaluate if this attribute is allowed in this context"
+							},
+							boolean: {
+								type: "boolean",
+								title: "Set to true if this is a boolean attribute"
+							},
+							deprecated: {
+								title: "Set to true or string if this attribute is deprecated",
+								oneOf: [
+									{
+										type: "boolean"
+									},
+									{
+										type: "string"
+									}
+								]
+							},
+							list: {
+								type: "boolean",
+								title: "Set to true if this attribute is a list of space-separated tokens, each which must be valid by itself"
+							},
+							"enum": {
+								type: "array",
+								title: "Exhaustive list of values (string or regex) this attribute accepts",
+								uniqueItems: true,
+								items: {
+									anyOf: [
+										{
+											type: "string"
+										},
+										{
+											regexp: true
+										}
+									]
+								}
+							},
+							omit: {
+								type: "boolean",
+								title: "Set to true if this attribute can optionally omit its value"
+							},
+							required: {
+								type: "boolean",
+								title: "Set to true if this attribute is required"
+							}
+						}
+					},
+					{
+						type: "array",
+						uniqueItems: true,
+						items: {
+							type: "string"
+						}
+					}
+				]
+			}
+		}
+	},
+	PermittedGroup: {
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			exclude: {
+				anyOf: [
+					{
+						items: {
+							type: "string"
+						},
+						type: "array"
+					},
+					{
+						type: "string"
+					}
+				]
+			}
+		}
+	},
+	PermittedOrder: {
+		type: "array",
+		items: {
+			type: "string"
+		}
+	},
+	RequiredAncestors: {
+		type: "array",
+		items: {
+			type: "string"
+		}
+	},
+	RequiredContent: {
+		type: "array",
+		items: {
+			type: "string"
+		}
+	}
+};
+var schema = {
+	$schema: $schema$1,
+	$id: $id$1,
+	type: type$1,
+	properties: properties$1,
+	patternProperties: patternProperties,
+	definitions: definitions
+};
+
 /**
- * @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
+ * AJV keyword "regexp" to validate the type to be a regular expression.
+ * Injects errors with the "type" keyword to give the same output.
  */
-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}>`;
-        }
+/* 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",
+                },
+            },
+        ];
     }
-    /**
-     * 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;
+    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",
+                },
+            },
+        ];
     }
-    /**
-     * Similar to childNodes but only elements.
-     */
-    get childElements() {
-        return this.childNodes.filter(isElementNode);
+    return valid;
+};
+const ajvFunctionKeyword = {
+    keyword: "function",
+    schema: false,
+    errors: true,
+    validate: ajvFunctionValidate,
+};
+
+function isSet(value) {
+    return typeof value !== "undefined";
+}
+function flag(value) {
+    return value ? true : undefined;
+}
+function 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);
     }
-    /**
-     * 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 */
-        let node = this;
-        while (node) {
-            if (node.matches(selectors)) {
-                return node;
-            }
-            node = node.parent;
-        }
-        return null;
+    /* 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);
     }
-    /**
-     * 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 */
-        for (root = this; root.parent; root = root.parent) {
-            /* .. */
+    if (Array.isArray(attr)) {
+        if (attr.length === 0) {
+            result.boolean = true;
         }
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        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;
+        else {
+            result.enum = attr.filter((it) => it !== "");
+            if (attr.includes("")) {
+                result.omit = true;
             }
-            /* 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(" > ");
+        return stripUndefined(result);
     }
-    /**
-     * 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();
+    else {
+        return stripUndefined({ ...result, ...attr });
     }
-    /**
-     * 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];
-            }
+}
+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,
+        attributes: migrateAttributes(src),
+        textContent: src.textContent,
+    };
+    /* removed properties */
+    delete result.deprecatedAttributes;
+    delete result.requiredAttributes;
+    /* strip out undefined */
+    if (!result.textContent) {
+        delete result.textContent;
+    }
+    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 {
     /**
-     * Match this element against given selectors. Returns true if any selector
-     * matches.
-     *
-     * Implementation of DOM specification of Element.matches(selectors).
+     * @internal
      */
-    matches(selector) {
-        /* find root element */
-        /* eslint-disable-next-line @typescript-eslint/no-this-alias */
-        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;
+    constructor() {
+        this.elements = {};
+        this.schema = clone(schema);
     }
     /**
-     * Set annotation for this element.
+     * @internal
      */
-    setAnnotation(text) {
-        this.annotation = text;
+    init() {
+        this.resolveGlobal();
     }
     /**
-     * Set attribute. Stores all attributes set even with the same name.
+     * Extend validation schema.
      *
-     * @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.
+     * @internal
      */
-    setAttribute(key, value, keyLocation, valueLocation, originalAttribute) {
-        key = key.toLowerCase();
-        if (!this.attr[key]) {
-            this.attr[key] = [];
+    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,
+            });
         }
-        this.attr[key].push(new Attribute(key, value, keyLocation, valueLocation, originalAttribute));
     }
     /**
-     * Get a list of all attributes on this node.
+     * Load metadata table from object.
+     *
+     * @internal
+     * @param obj - Object with metadata to load
+     * @param filename - Optional filename used when presenting validation error
      */
-    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];
+    loadFromObject(obj, filename = null) {
+        var _a;
+        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 : []);
         }
-        else {
-            return null;
+        for (const [key, value] of Object.entries(obj)) {
+            if (key === "$schema")
+                continue;
+            this.addEntry(key, migrateElement(value));
         }
     }
     /**
-     * Get attribute value.
-     *
-     * Returns the attribute value if present.
-     *
-     * - Missing attributes return `null`.
-     * - Boolean attributes return `null`.
-     * - `DynamicValue` returns attribute expression.
+     * Load metadata table from filename
      *
-     * @param key - Attribute name
-     * @returns Attribute value or null.
+     * @internal
+     * @param filename - Filename to load
      */
-    getAttributeValue(key) {
-        const attr = this.getAttribute(key);
-        if (attr) {
-            return attr.value !== null ? attr.value.toString() : null;
+    loadFromFile(filename) {
+        try {
+            /* load using require as it can process both js and json */
+            const data = requireUncached(filename);
+            this.loadFromObject(data, filename);
         }
-        else {
-            return null;
+        catch (err) {
+            if (err instanceof SchemaValidationError) {
+                throw err;
+            }
+            throw new UserError(`Failed to load element metadata from "${filename}"`, ensureError(err));
         }
     }
     /**
-     * Add text as a child node to this element.
+     * Get [[MetaElement]] for the given tag. If no specific metadata is present
+     * the global metadata is returned or null if no global is present.
      *
-     * @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.
+     * @public
+     * @returns A shallow copy of metadata.
      */
-    get classList() {
-        if (!this.hasAttribute("class")) {
-            return new DOMTokenList(null, null);
+    getMetaFor(tagName) {
+        /* try to locate by tagname */
+        tagName = tagName.toLowerCase();
+        if (this.elements[tagName]) {
+            return { ...this.elements[tagName] };
         }
-        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);
+        /* try to locate global element */
+        if (this.elements["*"]) {
+            return { ...this.elements["*"] };
+        }
+        return null;
     }
     /**
-     * Returns the first child element or null if there are no child elements.
+     * Find all tags which has enabled given property.
+     *
+     * @public
      */
-    get firstElementChild() {
-        const children = this.childElements;
-        return children.length > 0 ? children[0] : null;
+    getTagsWithProperty(propName) {
+        return Object.entries(this.elements)
+            .filter(([, entry]) => entry[propName])
+            .map(([tagName]) => tagName);
     }
     /**
-     * Returns the last child element or null if there are no child elements.
+     * Find tag matching tagName or inheriting from it.
+     *
+     * @public
      */
-    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) {
-        var _a;
-        const it = this.querySelectorImpl(selector);
-        return (_a = it.next().value) !== null && _a !== void 0 ? _a : null; // eslint-disable-line @typescript-eslint/no-unsafe-return
-    }
-    querySelectorAll(selector) {
-        const it = this.querySelectorImpl(selector);
-        const unique = new Set(it);
-        return Array.from(unique.values());
+    getTagsDerivedFrom(tagName) {
+        return Object.entries(this.elements)
+            .filter(([key, entry]) => key === tagName || entry.inherit === tagName)
+            .map(([tagName]) => tagName);
     }
-    *querySelectorImpl(selectorList) {
-        if (!selectorList) {
-            return;
-        }
-        for (const selector of selectorList.split(/,\s*/)) {
-            const pattern = new Selector(selector);
-            yield* pattern.match(this);
+    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 UserError(`Element <${tagName}> cannot inherit from <${name}>: no such element`);
+            }
         }
+        /* merge all sources together */
+        const expanded = this.mergeElement(parent, { ...entry, tagName });
+        expandRegex(expanded);
+        this.elements[tagName] = expanded;
     }
     /**
-     * Visit all nodes from this node and down. Depth first.
-     *
-     * @internal
+     * Construct a new AJV schema validator.
      */
-    visitDepthFirst(callback) {
-        function visit(node) {
-            node.childElements.forEach(visit);
-            if (!node.isRootElement()) {
-                callback(node);
-            }
+    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;
         }
-        visit(this);
     }
     /**
-     * Evaluates callbackk on all descendants, returning true if any are true.
-     *
-     * @internal
+     * @public
      */
-    someChildren(callback) {
-        return this.childElements.some(visit);
-        function visit(node) {
-            if (callback(node)) {
-                return true;
-            }
-            else {
-                return node.childElements.some(visit);
-            }
-        }
+    getJSONSchema() {
+        return this.schema;
     }
     /**
-     * Evaluates callbackk on all descendants, returning true if all are true.
-     *
-     * @internal
+     * Finds the global element definition and merges each known element with the
+     * global, e.g. to assign global attributes.
      */
-    everyChildren(callback) {
-        return this.childElements.every(visit);
-        function visit(node) {
-            if (!callback(node)) {
-                return false;
-            }
-            return node.childElements.every(visit);
+    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;
+    }
     /**
-     * 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;
+    resolve(node) {
+        if (node.meta) {
+            expandProperties(node, node.meta);
         }
-        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;
+function expandProperties(node, entry) {
+    for (const key of dynamicKeys) {
+        const property = entry[key];
+        if (property && typeof property !== "boolean") {
+            setMetaProperty(entry, key, evaluateProperty(node, property));
+        }
     }
-    return closed;
 }
-
-class DOMTree {
-    constructor(location) {
-        this.root = HtmlElement.rootNode(location);
-        this.active = this.root;
-        this.doctype = null;
+/**
+ * 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;
     }
-    pushActive(node) {
-        this.active = node;
+    const match = value.match(/^\/\^?([^/$]*)\$?\/([i]*)$/);
+    if (match) {
+        const [, expr, flags] = match;
+        // eslint-disable-next-line security/detect-non-literal-regexp
+        return new RegExp(`^${expr}$`, flags);
     }
-    popActive() {
-        if (this.active.isRootElement()) {
-            /* root element should never be popped, continue as if nothing happened */
-            return;
-        }
-        this.active = this.active.parent || this.root;
+    else {
+        return value;
     }
-    getActive() {
-        return this.active;
+}
+/**
+ * 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);
+        }
     }
-    /**
-     * Resolve dynamic meta expressions.
-     */
-    resolveMeta(table) {
-        this.visitDepthFirst((node) => table.resolve(node));
+}
+function evaluateProperty(node, expr) {
+    const [func, options] = parseExpression(expr);
+    return func(node, options);
+}
+function parseExpression(expr) {
+    if (typeof expr === "string") {
+        return parseExpression([expr, {}]);
     }
-    getElementsByTagName(tagName) {
-        return this.root.getElementsByTagName(tagName);
+    else {
+        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];
     }
-    visitDepthFirst(callback) {
-        this.root.visitDepthFirst(callback);
+}
+function isDescendantFacade(node, tagName) {
+    if (typeof tagName !== "string") {
+        throw new Error(`Property expression "isDescendant" must take string argument when evaluating metadata for <${node.tagName}>`);
     }
-    find(callback) {
-        return this.root.find(callback);
+    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}>`);
     }
-    querySelector(selector) {
-        return this.root.querySelector(selector);
+    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}>`);
     }
-    querySelectorAll(selector) {
-        return this.root.querySelectorAll(selector);
+    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}>`);
     }
 }
 
@@ -3191,7 +3506,7 @@ var TRANSFORMER_API;
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "7.6.0";
+const version = "7.7.1";
 /** @public */
 const homepage = "https://html-validate.org";
 /** @public */
@@ -3520,7 +3835,7 @@ function ruleDocumentationUrl(filename) {
     return `${homepage}/rules/${normalized}.html`;
 }
 
-const defaults$s = {
+const defaults$t = {
     allowExternal: true,
     allowRelative: true,
     allowAbsolute: true,
@@ -3564,7 +3879,7 @@ function matchList(value, list) {
 }
 class AllowedLinks extends Rule {
     constructor(options) {
-        super({ ...defaults$s, ...options });
+        super({ ...defaults$t, ...options });
         this.allowExternal = parseAllow(this.options.allowExternal);
         this.allowRelative = parseAllow(this.options.allowRelative);
         this.allowAbsolute = parseAllow(this.options.allowAbsolute);
@@ -3707,6 +4022,109 @@ class AllowedLinks extends Rule {
     }
 }
 
+var RuleContext$1;
+(function (RuleContext) {
+    RuleContext["MISSING_ALT"] = "missing-alt";
+    RuleContext["MISSING_HREF"] = "missing-href";
+})(RuleContext$1 || (RuleContext$1 = {}));
+const defaults$s = {
+    accessible: true,
+};
+function findByTarget(target, siblings) {
+    return siblings.filter((it) => it.getAttributeValue("href") === target);
+}
+function getAltText(node) {
+    return node.getAttributeValue("alt");
+}
+function getDescription(context) {
+    switch (context) {
+        case RuleContext$1.MISSING_ALT:
+            return [
+                "The `alt` attribute must be set (and not empty) when the `href` attribute is present on an `<area>` element.",
+                "",
+                "The attribute is used to provide an alternative text description for the area of the image map.",
+                "The text should describe the purpose of area and the resource referenced by the `href` attribute.",
+                "",
+                "Either add the `alt` attribute or remove the `href` attribute.",
+            ];
+        case RuleContext$1.MISSING_HREF:
+            return [
+                "The `alt` attribute must not be set when the `href` attribute is missing on an `<area>` element.",
+                "",
+                "Either add the `href` attribute or remove the `alt` attribute.",
+            ];
+        default:
+            return [
+                "The `alt` attribute must only be used together with the `href` attribute.",
+                "It must be set if `href` is present and must be omitted if `href` is missing",
+                "",
+                "The attribute is used to provide an alternative text description for the area of the image map.",
+                "The text should describe the purpose of area and the resource referenced by the `href` attribute.",
+            ];
+    }
+}
+class AreaAlt extends Rule {
+    constructor(options) {
+        super({ ...defaults$s, ...options });
+    }
+    static schema() {
+        return {
+            accessible: {
+                type: "boolean",
+            },
+        };
+    }
+    documentation(context) {
+        return {
+            description: getDescription(context).join("\n"),
+            url: ruleDocumentationUrl("@/rules/area-alt.ts"),
+        };
+    }
+    setup() {
+        this.on("element:ready", this.isRelevant, (event) => {
+            const { target } = event;
+            const siblings = target.querySelectorAll("area");
+            for (const child of siblings) {
+                this.validateArea(child, siblings);
+            }
+        });
+    }
+    validateArea(area, siblings) {
+        const { accessible } = this.options;
+        const href = area.getAttribute("href");
+        const alt = area.getAttribute("alt");
+        if (href) {
+            if (alt && alt.isDynamic) {
+                return;
+            }
+            const target = area.getAttributeValue("href");
+            const altTexts = accessible
+                ? [getAltText(area)]
+                : findByTarget(target, siblings).map(getAltText);
+            if (!altTexts.some(Boolean)) {
+                this.report({
+                    node: area,
+                    message: `"alt" attribute must be set and non-empty when the "href" attribute is present`,
+                    location: alt ? alt.keyLocation : href.keyLocation,
+                    context: RuleContext$1.MISSING_ALT,
+                });
+            }
+        }
+        else if (alt) {
+            this.report({
+                node: area,
+                message: `"alt" attribute cannot be used unless the "href" attribute is present`,
+                location: alt.keyLocation,
+                context: RuleContext$1.MISSING_HREF,
+            });
+        }
+    }
+    isRelevant(event) {
+        const { target } = event;
+        return target.is("map");
+    }
+}
+
 class AriaHiddenBody extends Rule {
     documentation() {
         return {
@@ -4463,6 +4881,16 @@ class AttrSpacing extends Rule {
     }
 }
 
+function pick(attr) {
+    const result = {};
+    if (typeof attr.enum !== "undefined") {
+        result.enum = attr.enum;
+    }
+    if (typeof attr.boolean !== "undefined") {
+        result.boolean = attr.boolean;
+    }
+    return result;
+}
 class AttributeAllowedValues extends Rule {
     documentation(context) {
         const docs = {
@@ -4513,7 +4941,7 @@ class AttributeAllowedValues extends Rule {
                         element: node.tagName,
                         attribute: attr.key,
                         value,
-                        allowed: meta.attributes[attr.key],
+                        allowed: pick(meta.attributes[attr.key]),
                     };
                     const message = this.getMessage(attr);
                     const location = this.getLocation(attr);
@@ -4709,6 +5137,54 @@ function reportMessage(attr, style) {
     return "";
 }
 
+function ruleDescription(context) {
+    if (context) {
+        const { attr, details } = context;
+        return `The "${attr}" attribute cannot be used in this context: ${details}`;
+    }
+    else {
+        return "This attribute cannot be used in this context.";
+    }
+}
+class AttributeMisuse extends Rule {
+    documentation(context) {
+        return {
+            description: ruleDescription(context),
+            url: ruleDocumentationUrl("@/rules/attribute-misuse.ts"),
+        };
+    }
+    setup() {
+        this.on("element:ready", (event) => {
+            const { target } = event;
+            const { meta } = target;
+            if (!meta) {
+                return;
+            }
+            for (const attr of target.attributes) {
+                const key = attr.key.toLowerCase();
+                this.validateAttr(target, attr, meta.attributes[key]);
+            }
+        });
+    }
+    validateAttr(node, attr, meta) {
+        if (!meta || !meta.allowed) {
+            return;
+        }
+        const details = meta.allowed(node);
+        if (details) {
+            this.report({
+                node,
+                message: `"{{ attr }}" attribute cannot be used in this context: {{ details }}`,
+                location: attr.keyLocation,
+                context: {
+                    attr: attr.key,
+                    details,
+                },
+            });
+        }
+    }
+}
+
 function parsePattern(pattern) {
     switch (pattern) {
         case "kebabcase":
@@ -4995,7 +5471,7 @@ class DeprecatedRule extends Rule {
     }
 }
 
-class NoStyleTag$1 extends Rule {
+let NoStyleTag$1 = class NoStyleTag extends Rule {
     documentation() {
         return {
             description: [
@@ -5016,7 +5492,7 @@ class NoStyleTag$1 extends Rule {
             }
         });
     }
-}
+};
 
 const defaults$k = {
     style: "uppercase",
@@ -5414,226 +5890,6 @@ class ElementPermittedOrder extends Rule {
     }
 }
 
-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 = {}));
-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() !== "";
-}
-
-/**
- * Joins a list of words into natural language.
- *
- * - `["foo"]` becomes `"foo"`
- * - `["foo", "bar"]` becomes `"foo or bar"`
- * - `["foo", "bar", "baz"]` becomes `"foo, bar or baz"`
- * - and so on...
- *
- * @internal
- * @param values - List of words to join
- * @param conjunction - Conjunction for the last element.
- * @returns String with the words naturally joined with a conjunction.
- */
-function naturalJoin(values, conjunction = "or") {
-    switch (values.length) {
-        case 0:
-            return "";
-        case 1:
-            return values[0];
-        case 2:
-            return `${values[0]} ${conjunction} ${values[1]}`;
-        default:
-            return `${values.slice(0, -1).join(", ")} ${conjunction} ${values.slice(-1)[0]}`;
-    }
-}
-
 function isCategoryOrTag(value) {
     return typeof value === "string";
 }
@@ -6200,11 +6456,6 @@ const restricted = new Map([
     ["capture", ["file"]],
     ["checked", ["checkbox", "radio"]],
     ["dirname", ["text", "search"]],
-    ["formaction", ["submit", "image"]],
-    ["formenctype", ["submit", "image"]],
-    ["formmethod", ["submit", "image"]],
-    ["formnovalidate", ["submit", "image"]],
-    ["formtarget", ["submit", "image"]],
     ["height", ["image"]],
     [
         "list",
@@ -10610,6 +10861,7 @@ const bundledRules$1 = {
 
 const bundledRules = {
     "allowed-links": AllowedLinks,
+    "area-alt": AreaAlt,
     "aria-hidden-body": AriaHiddenBody,
     "aria-label-misuse": AriaLabelMisuse,
     "attr-case": AttrCase,
@@ -10620,6 +10872,7 @@ const bundledRules = {
     "attribute-allowed-values": AttributeAllowedValues,
     "attribute-boolean-style": AttributeBooleanStyle,
     "attribute-empty-style": AttributeEmptyStyle,
+    "attribute-misuse": AttributeMisuse,
     "class-pattern": ClassPattern,
     "close-attr": CloseAttr,
     "close-order": CloseOrder,
@@ -10686,6 +10939,7 @@ var defaultConfig = {};
 
 const config$3 = {
     rules: {
+        "area-alt": ["error", { accessible: true }],
         "aria-hidden-body": "error",
         "aria-label-misuse": "error",
         "deprecated-rule": "warn",
@@ -10721,6 +10975,7 @@ const config$2 = {
 
 const config$1 = {
     rules: {
+        "area-alt": ["error", { accessible: true }],
         "aria-hidden-body": "error",
         "aria-label-misuse": "error",
         "attr-case": "error",
@@ -10730,6 +10985,7 @@ const config$1 = {
         "attribute-allowed-values": "error",
         "attribute-boolean-style": "error",
         "attribute-empty-style": "error",
+        "attribute-misuse": "error",
         "close-attr": "error",
         "close-order": "error",
         deprecated: "error",
@@ -10790,8 +11046,10 @@ const config$1 = {
 
 const config = {
     rules: {
+        "area-alt": ["error", { accessible: false }],
         "attr-spacing": "error",
         "attribute-allowed-values": "error",
+        "attribute-misuse": "error",
         "close-attr": "error",
         "close-order": "error",
         deprecated: "error",
@@ -13327,5 +13585,5 @@ function getFormatter(name) {
     return (_a = availableFormatters[name]) !== null && _a !== void 0 ? _a : null;
 }
 
-export { Config as C, DynamicValue as D, EventHandler as E, FileSystemConfigLoader as F, HtmlValidate as H, MetaTable as M, NodeClosed as N, Parser as P, Rule as R, Severity as S, TextNode as T, UserError as U, WrappedError as W, ConfigError as a, ConfigLoader as b, StaticConfigLoader as c, HtmlElement as d, SchemaValidationError as e, NestedError as f, MetaCopyableProperty as g, classifyNodeText as h, TextClassification as i, Reporter as j, TemplateExtractor as k, getFormatter as l, legacyRequire as m, ensureError as n, configDataFromFile as o, presets as p, compatibilityCheck as q, ruleExists as r, codeframe as s, name as t, bugs as u, version as v };
+export { Config as C, DynamicValue as D, EventHandler as E, FileSystemConfigLoader as F, HtmlValidate as H, MetaTable as M, NodeClosed as N, Parser as P, Rule as R, Severity as S, TextNode as T, UserError as U, WrappedError as W, ConfigError as a, ConfigLoader as b, StaticConfigLoader as c, HtmlElement as d, SchemaValidationError as e, NestedError as f, MetaCopyableProperty as g, defineMetadata as h, classifyNodeText as i, TextClassification as j, Reporter as k, TemplateExtractor as l, metadataHelper as m, getFormatter as n, legacyRequire as o, presets as p, ensureError as q, ruleExists as r, configDataFromFile as s, compatibilityCheck as t, codeframe as u, version as v, name as w, bugs as x };
 //# sourceMappingURL=core.js.map