html-validate 8.20.0 → 8.21.0

package/dist/cjs/core.js

@@ -1279,14 +1279,12 @@ class MetaTable {
    * @returns A shallow copy of metadata.
    */
   getMetaFor(tagName) {
-    tagName = tagName.toLowerCase();
-    if (this.elements[tagName]) {
-      return { ...this.elements[tagName] };
-    }
-    if (this.elements["*"]) {
-      return { ...this.elements["*"] };
+    const meta = this.elements[tagName.toLowerCase()] ?? this.elements["*"];
+    if (meta) {
+      return { ...meta };
+    } else {
+      return null;
     }
-    return null;
   }
   /**
    * Find all tags which has enabled given property.
@@ -1294,7 +1292,7 @@ class MetaTable {
    * @public
    */
   getTagsWithProperty(propName) {
-    return Object.entries(this.elements).filter(([, entry]) => entry[propName]).map(([tagName]) => tagName);
+    return this.entries.filter(([, entry]) => entry[propName]).map(([tagName]) => tagName);
   }
   /**
    * Find tag matching tagName or inheriting from it.
@@ -1302,10 +1300,10 @@ class MetaTable {
    * @public
    */
   getTagsDerivedFrom(tagName) {
-    return Object.entries(this.elements).filter(([key, entry]) => key === tagName || entry.inherit === tagName).map(([tagName2]) => tagName2);
+    return this.entries.filter(([key, entry]) => key === tagName || entry.inherit === tagName).map(([tagName2]) => tagName2);
   }
   addEntry(tagName, entry) {
-    let parent = this.elements[tagName] || {};
+    let parent = this.elements[tagName];
     if (entry.inherit) {
       const name = entry.inherit;
       parent = this.elements[name];
@@ -1316,7 +1314,7 @@ class MetaTable {
         });
       }
     }
-    const expanded = this.mergeElement(parent, { ...entry, tagName });
+    const expanded = this.mergeElement(parent ?? {}, { ...entry, tagName });
     expandRegex(expanded);
     this.elements[tagName] = expanded;
   }
@@ -1345,6 +1343,12 @@ class MetaTable {
   getJSONSchema() {
     return this.schema;
   }
+  /**
+   * @internal
+   */
+  get entries() {
+    return Object.entries(this.elements);
+  }
   /**
    * Finds the global element definition and merges each known element with the
    * global, e.g. to assign global attributes.
@@ -1356,7 +1360,7 @@ class MetaTable {
     delete this.elements["*"];
     delete global.tagName;
     delete global.void;
-    for (const [tagName, entry] of Object.entries(this.elements)) {
+    for (const [tagName, entry] of this.entries) {
       this.elements[tagName] = this.mergeElement(global, entry);
     }
   }
@@ -2144,7 +2148,7 @@ class AttrMatcher extends Matcher {
     this.value = value;
   }
   match(node) {
-    const attr = node.getAttribute(this.key, true) || [];
+    const attr = node.getAttribute(this.key, true);
     return attr.some((cur) => {
       switch (this.op) {
         case void 0:
@@ -2590,10 +2594,13 @@ class HtmlElement extends DOMNode {
    */
   setAttribute(key, value, keyLocation, valueLocation, originalAttribute) {
     key = key.toLowerCase();
-    if (!this.attr[key]) {
-      this.attr[key] = [];
+    const attr = new Attribute(key, value, keyLocation, valueLocation, originalAttribute);
+    const list = this.attr[key];
+    if (list) {
+      list.push(attr);
+    } else {
+      this.attr[key] = [attr];
     }
-    this.attr[key].push(new Attribute(key, value, keyLocation, valueLocation, originalAttribute));
   }
   /**
    * Get parsed tabindex for this element.
@@ -2650,7 +2657,7 @@ class HtmlElement extends DOMNode {
       const matches = this.attr[key];
       return all ? matches : matches[0];
     } else {
-      return null;
+      return all ? [] : null;
     }
   }
   /**
@@ -2756,20 +2763,6 @@ class HtmlElement extends DOMNode {
       yield* pattern.match(this);
     }
   }
-  /**
-   * Visit all nodes from this node and down. Depth first.
-   *
-   * @internal
-   */
-  visitDepthFirst(callback) {
-    function visit(node) {
-      node.childElements.forEach(visit);
-      if (!node.isRootElement()) {
-        callback(node);
-      }
-    }
-    visit(this);
-  }
   /**
    * Evaluates callbackk on all descendants, returning true if any are true.
    *
@@ -2833,591 +2826,133 @@ function isClosed(endToken, meta) {
   return closed;
 }
 
-class DOMTree {
-  constructor(location) {
-    this.root = HtmlElement.rootNode(location);
-    this.active = this.root;
-    this.doctype = null;
-  }
-  pushActive(node) {
-    this.active = node;
+function escape(value) {
+  return JSON.stringify(value);
+}
+function format(value, quote = false) {
+  if (value === null) {
+    return "null";
   }
-  popActive() {
-    if (this.active.isRootElement()) {
-      return;
-    }
-    this.active = this.active.parent ?? this.root;
+  if (typeof value === "number") {
+    return value.toString();
   }
-  getActive() {
-    return this.active;
+  if (typeof value === "string") {
+    return quote ? escape(value) : value;
   }
-  /**
-   * Resolve dynamic meta expressions.
-   */
-  resolveMeta(table) {
-    this.visitDepthFirst((node) => {
-      table.resolve(node);
-    });
+  if (Array.isArray(value)) {
+    const content = value.map((it) => format(it, true)).join(", ");
+    return `[ ${content} ]`;
   }
-  getElementsByTagName(tagName) {
-    return this.root.getElementsByTagName(tagName);
+  if (typeof value === "object") {
+    const content = Object.entries(value).map(([key, nested]) => `${key}: ${format(nested, true)}`).join(", ");
+    return `{ ${content} }`;
   }
-  visitDepthFirst(callback) {
-    this.root.visitDepthFirst(callback);
+  return String(value);
+}
+function interpolate(text, data) {
+  return text.replace(/{{\s*([^\s{}]+)\s*}}/g, (match, key) => {
+    return typeof data[key] !== "undefined" ? format(data[key]) : match;
+  });
+}
+
+function isThenable(value) {
+  return value && typeof value === "object" && "then" in value && typeof value.then === "function";
+}
+
+var Severity = /* @__PURE__ */ ((Severity2) => {
+  Severity2[Severity2["DISABLED"] = 0] = "DISABLED";
+  Severity2[Severity2["WARN"] = 1] = "WARN";
+  Severity2[Severity2["ERROR"] = 2] = "ERROR";
+  return Severity2;
+})(Severity || {});
+function parseSeverity(value) {
+  switch (value) {
+    case 0:
+    case "off":
+      return 0 /* DISABLED */;
+    case 1:
+    case "warn":
+      return 1 /* WARN */;
+    case 2:
+    case "error":
+      return 2 /* ERROR */;
+    default:
+      throw new Error(`Invalid severity "${String(value)}"`);
   }
-  find(callback) {
-    return this.root.find(callback);
+}
+
+const cacheKey = Symbol("aria-naming");
+const defaultValue = "allowed";
+const prohibitedRoles = [
+  "caption",
+  "code",
+  "deletion",
+  "emphasis",
+  "generic",
+  "insertion",
+  "paragraph",
+  "presentation",
+  "strong",
+  "subscript",
+  "superscript"
+];
+function byRole(role) {
+  return prohibitedRoles.includes(role) ? "prohibited" : "allowed";
+}
+function byMeta(element, meta) {
+  return meta.aria.naming(element._adapter);
+}
+function ariaNaming(element) {
+  var _a;
+  const cached = element.cacheGet(cacheKey);
+  if (cached) {
+    return cached;
   }
-  querySelector(selector) {
-    return this.root.querySelector(selector);
+  const role = (_a = element.getAttribute("role")) == null ? void 0 : _a.value;
+  if (role) {
+    if (role instanceof DynamicValue) {
+      return element.cacheSet(cacheKey, defaultValue);
+    } else {
+      return element.cacheSet(cacheKey, byRole(role));
+    }
   }
-  querySelectorAll(selector) {
-    return this.root.querySelectorAll(selector);
+  const meta = element.meta;
+  if (!meta) {
+    return element.cacheSet(cacheKey, defaultValue);
   }
+  return element.cacheSet(cacheKey, byMeta(element, meta));
 }
 
-const allowedKeys = ["exclude"];
-class Validator {
-  /**
-   * Test if element is used in a proper context.
-   *
-   * @param node - Element to test.
-   * @param rules - List of rules.
-   * @returns `true` if element passes all tests.
-   */
-  static validatePermitted(node, rules) {
-    if (!rules) {
-      return true;
-    }
-    return rules.some((rule) => {
-      return Validator.validatePermittedRule(node, rule);
-    });
+const patternCache = /* @__PURE__ */ new Map();
+function compileStringPattern(pattern) {
+  const regexp = pattern.replace(/[*]+/g, ".+");
+  return new RegExp(`^${regexp}$`);
+}
+function compileRegExpPattern(pattern) {
+  return new RegExp(`^${pattern}$`);
+}
+function compilePattern(pattern) {
+  const cached = patternCache.get(pattern);
+  if (cached) {
+    return cached;
   }
-  /**
-   * Test if an element is used the correct amount of times.
-   *
-   * For instance, a `<table>` element can only contain a single `<tbody>`
-   * child. If multiple `<tbody>` exists this test will fail both nodes.
-   * Note that this is called on the parent but will fail the children violating
-   * the rule.
-   *
-   * @param children - Array of children to validate.
-   * @param rules - List of rules of the parent element.
-   * @returns `true` if the parent element of the children passes the test.
-   */
-  static validateOccurrences(children, rules, cb) {
-    if (!rules) {
+  const match = pattern.match(/^\/(.*)\/$/);
+  const regexp = match ? compileRegExpPattern(match[1]) : compileStringPattern(pattern);
+  patternCache.set(pattern, regexp);
+  return regexp;
+}
+function keywordPatternMatcher(list, keyword) {
+  for (const pattern of list) {
+    const regexp = compilePattern(pattern);
+    if (regexp.test(keyword)) {
       return true;
     }
-    let valid = true;
-    for (const rule of rules) {
-      if (typeof rule !== "string") {
-        return false;
-      }
-      const [, category, quantifier] = rule.match(/^(@?.*?)([?*]?)$/);
-      const limit = category && quantifier && parseQuantifier(quantifier);
-      if (limit) {
-        const siblings = children.filter(
-          (cur) => Validator.validatePermittedCategory(cur, rule, true)
-        );
-        if (siblings.length > limit) {
-          for (const child of siblings.slice(limit)) {
-            cb(child, category);
-          }
-          valid = false;
-        }
-      }
-    }
-    return valid;
   }
-  /**
-   * Validate elements order.
-   *
-   * Given a parent element with children and metadata containing permitted
-   * order it will validate each children and ensure each one exists in the
-   * specified order.
-   *
-   * For instance, for a `<table>` element the `<caption>` element must come
-   * before a `<thead>` which must come before `<tbody>`.
-   *
-   * @param children - Array of children to validate.
-   */
-  static validateOrder(children, rules, cb) {
-    if (!rules) {
-      return true;
-    }
-    let i = 0;
-    let prev = null;
-    for (const node of children) {
-      const old = i;
-      while (rules[i] && !Validator.validatePermittedCategory(node, rules[i], true)) {
-        i++;
-      }
-      if (i >= rules.length) {
-        const orderSpecified = rules.find(
-          (cur) => Validator.validatePermittedCategory(node, cur, true)
-        );
-        if (orderSpecified) {
-          cb(node, prev);
-          return false;
-        }
-        i = old;
-      }
-      prev = node;
-    }
-    return true;
-  }
-  /**
-   * Validate element ancestors.
-   *
-   * Check if an element has the required set of elements. At least one of the
-   * selectors must match.
-   */
-  static validateAncestors(node, rules) {
-    if (!rules || rules.length === 0) {
-      return true;
-    }
-    return rules.some((rule) => node.closest(rule));
-  }
-  /**
-   * Validate element required content.
-   *
-   * Check if an element has the required set of elements. At least one of the
-   * selectors must match.
-   *
-   * Returns `[]` when valid or a list of required but missing tagnames or
-   * categories.
-   */
-  static validateRequiredContent(node, rules) {
-    if (!rules || rules.length === 0) {
-      return [];
-    }
-    return rules.filter((tagName) => {
-      const haveMatchingChild = node.childElements.some(
-        (child) => Validator.validatePermittedCategory(child, tagName, false)
-      );
-      return !haveMatchingChild;
-    });
-  }
-  /**
-   * Test if an attribute has an allowed value and/or format.
-   *
-   * @param attr - Attribute to test.
-   * @param rules - Element attribute metadta.
-   * @returns `true` if attribute passes all tests.
-   */
-  static validateAttribute(attr, rules) {
-    const rule = rules[attr.key];
-    if (!rule) {
-      return true;
-    }
-    const value = attr.value;
-    if (value instanceof DynamicValue) {
-      return true;
-    }
-    const empty = value === null || value === "";
-    if (rule.boolean) {
-      return empty || value === attr.key;
-    }
-    if (rule.omit && empty) {
-      return true;
-    }
-    if (rule.list) {
-      const tokens = new DOMTokenList(value, attr.valueLocation);
-      return tokens.every((token) => {
-        return this.validateAttributeValue(token, rule);
-      });
-    }
-    return this.validateAttributeValue(value, rule);
-  }
-  static validateAttributeValue(value, rule) {
-    if (!rule.enum) {
-      return true;
-    }
-    if (value === null || value === void 0) {
-      return false;
-    }
-    const caseInsensitiveValue = value.toLowerCase();
-    return rule.enum.some((entry) => {
-      if (entry instanceof RegExp) {
-        return !!value.match(entry);
-      } else {
-        return caseInsensitiveValue === entry;
-      }
-    });
-  }
-  static validatePermittedRule(node, rule, isExclude = false) {
-    if (typeof rule === "string") {
-      return Validator.validatePermittedCategory(node, rule, !isExclude);
-    } else if (Array.isArray(rule)) {
-      return rule.every((inner) => {
-        return Validator.validatePermittedRule(node, inner, isExclude);
-      });
-    } else {
-      validateKeys(rule);
-      if (rule.exclude) {
-        if (Array.isArray(rule.exclude)) {
-          return !rule.exclude.some((inner) => {
-            return Validator.validatePermittedRule(node, inner, true);
-          });
-        } else {
-          return !Validator.validatePermittedRule(node, rule.exclude, true);
-        }
-      } else {
-        return true;
-      }
-    }
-  }
-  /**
-   * Validate node against a content category.
-   *
-   * When matching parent nodes against permitted parents use the superset
-   * parameter to also match for `@flow`. E.g. if a node expects a `@phrasing`
-   * parent it should also allow `@flow` parent since `@phrasing` is a subset of
-   * `@flow`.
-   *
-   * @param node - The node to test against
-   * @param category - Name of category with `@` prefix or tag name.
-   * @param defaultMatch - The default return value when node categories is not known.
-   */
-  /* eslint-disable-next-line complexity -- rule does not like switch */
-  static validatePermittedCategory(node, category, defaultMatch) {
-    const [, rawCategory] = category.match(/^(@?.*?)([?*]?)$/);
-    if (!rawCategory.startsWith("@")) {
-      return node.tagName === rawCategory;
-    }
-    if (!node.meta) {
-      return defaultMatch;
-    }
-    switch (rawCategory) {
-      case "@meta":
-        return node.meta.metadata;
-      case "@flow":
-        return node.meta.flow;
-      case "@sectioning":
-        return node.meta.sectioning;
-      case "@heading":
-        return node.meta.heading;
-      case "@phrasing":
-        return node.meta.phrasing;
-      case "@embedded":
-        return node.meta.embedded;
-      case "@interactive":
-        return node.meta.interactive;
-      case "@script":
-        return Boolean(node.meta.scriptSupporting);
-      case "@form":
-        return Boolean(node.meta.form);
-      default:
-        throw new Error(`Invalid content category "${category}"`);
-    }
-  }
-}
-function validateKeys(rule) {
-  for (const key of Object.keys(rule)) {
-    if (!allowedKeys.includes(key)) {
-      const str = JSON.stringify(rule);
-      throw new Error(`Permitted rule "${str}" contains unknown property "${key}"`);
-    }
-  }
-}
-function parseQuantifier(quantifier) {
-  switch (quantifier) {
-    case "?":
-      return 1;
-    case "*":
-      return null;
-    default:
-      throw new Error(`Invalid quantifier "${quantifier}" used`);
-  }
-}
-
-const $schema = "http://json-schema.org/draft-06/schema#";
-const $id = "https://html-validate.org/schemas/config.json";
-const type = "object";
-const additionalProperties = false;
-const properties = {
-	$schema: {
-		type: "string"
-	},
-	root: {
-		type: "boolean",
-		title: "Mark as root configuration",
-		description: "If this is set to true no further configurations will be searched.",
-		"default": false
-	},
-	"extends": {
-		type: "array",
-		items: {
-			type: "string"
-		},
-		title: "Configurations to extend",
-		description: "Array of shareable or builtin configurations to extend."
-	},
-	elements: {
-		type: "array",
-		items: {
-			anyOf: [
-				{
-					type: "string"
-				},
-				{
-					type: "object"
-				}
-			]
-		},
-		title: "Element metadata to load",
-		description: "Array of modules, plugins or files to load element metadata from. Use <rootDir> to refer to the folder with the package.json file.",
-		examples: [
-			[
-				"html-validate:recommended",
-				"plugin:recommended",
-				"module",
-				"./local-file.json"
-			]
-		]
-	},
-	plugins: {
-		type: "array",
-		items: {
-			anyOf: [
-				{
-					type: "string"
-				},
-				{
-					type: "object"
-				}
-			]
-		},
-		title: "Plugins to load",
-		description: "Array of plugins load. Use <rootDir> to refer to the folder with the package.json file.",
-		examples: [
-			[
-				"my-plugin",
-				"./local-plugin"
-			]
-		]
-	},
-	transform: {
-		type: "object",
-		additionalProperties: {
-			type: "string"
-		},
-		title: "File transformations to use.",
-		description: "Object where key is regular expression to match filename and value is name of transformer.",
-		examples: [
-			{
-				"^.*\\.foo$": "my-transformer",
-				"^.*\\.bar$": "my-plugin",
-				"^.*\\.baz$": "my-plugin:named"
-			}
-		]
-	},
-	rules: {
-		type: "object",
-		patternProperties: {
-			".*": {
-				anyOf: [
-					{
-						"enum": [
-							0,
-							1,
-							2,
-							"off",
-							"warn",
-							"error"
-						]
-					},
-					{
-						type: "array",
-						minItems: 1,
-						maxItems: 1,
-						items: [
-							{
-								"enum": [
-									0,
-									1,
-									2,
-									"off",
-									"warn",
-									"error"
-								]
-							}
-						]
-					},
-					{
-						type: "array",
-						minItems: 2,
-						maxItems: 2,
-						items: [
-							{
-								"enum": [
-									0,
-									1,
-									2,
-									"off",
-									"warn",
-									"error"
-								]
-							},
-							{
-							}
-						]
-					}
-				]
-			}
-		},
-		title: "Rule configuration.",
-		description: "Enable/disable rules, set severity. Some rules have additional configuration like style or patterns to use.",
-		examples: [
-			{
-				foo: "error",
-				bar: "off",
-				baz: [
-					"error",
-					{
-						style: "camelcase"
-					}
-				]
-			}
-		]
-	}
-};
-var configurationSchema = {
-	$schema: $schema,
-	$id: $id,
-	type: type,
-	additionalProperties: additionalProperties,
-	properties: properties
-};
-
-const TRANSFORMER_API = {
-  VERSION: 1
-};
-
-var Severity = /* @__PURE__ */ ((Severity2) => {
-  Severity2[Severity2["DISABLED"] = 0] = "DISABLED";
-  Severity2[Severity2["WARN"] = 1] = "WARN";
-  Severity2[Severity2["ERROR"] = 2] = "ERROR";
-  return Severity2;
-})(Severity || {});
-function parseSeverity(value) {
-  switch (value) {
-    case 0:
-    case "off":
-      return 0 /* DISABLED */;
-    case 1:
-    case "warn":
-      return 1 /* WARN */;
-    case 2:
-    case "error":
-      return 2 /* ERROR */;
-    default:
-      throw new Error(`Invalid severity "${String(value)}"`);
-  }
-}
-
-function escape(value) {
-  return JSON.stringify(value);
-}
-function format(value, quote = false) {
-  if (value === null) {
-    return "null";
-  }
-  if (typeof value === "number") {
-    return value.toString();
-  }
-  if (typeof value === "string") {
-    return quote ? escape(value) : value;
-  }
-  if (Array.isArray(value)) {
-    const content = value.map((it) => format(it, true)).join(", ");
-    return `[ ${content} ]`;
-  }
-  if (typeof value === "object") {
-    const content = Object.entries(value).map(([key, nested]) => `${key}: ${format(nested, true)}`).join(", ");
-    return `{ ${content} }`;
-  }
-  return String(value);
-}
-function interpolate(text, data) {
-  return text.replace(/{{\s*([^\s{}]+)\s*}}/g, (match, key) => {
-    return typeof data[key] !== "undefined" ? format(data[key]) : match;
-  });
-}
-
-const cacheKey = Symbol("aria-naming");
-const defaultValue = "allowed";
-const prohibitedRoles = [
-  "caption",
-  "code",
-  "deletion",
-  "emphasis",
-  "generic",
-  "insertion",
-  "paragraph",
-  "presentation",
-  "strong",
-  "subscript",
-  "superscript"
-];
-function byRole(role) {
-  return prohibitedRoles.includes(role) ? "prohibited" : "allowed";
-}
-function byMeta(element, meta) {
-  return meta.aria.naming(element._adapter);
-}
-function ariaNaming(element) {
-  var _a;
-  const cached = element.cacheGet(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const role = (_a = element.getAttribute("role")) == null ? void 0 : _a.value;
-  if (role) {
-    if (role instanceof DynamicValue) {
-      return element.cacheSet(cacheKey, defaultValue);
-    } else {
-      return element.cacheSet(cacheKey, byRole(role));
-    }
-  }
-  const meta = element.meta;
-  if (!meta) {
-    return element.cacheSet(cacheKey, defaultValue);
-  }
-  return element.cacheSet(cacheKey, byMeta(element, meta));
-}
-
-const patternCache = /* @__PURE__ */ new Map();
-function compileStringPattern(pattern) {
-  const regexp = pattern.replace(/[*]+/g, ".+");
-  return new RegExp(`^${regexp}$`);
-}
-function compileRegExpPattern(pattern) {
-  return new RegExp(`^${pattern}$`);
-}
-function compilePattern(pattern) {
-  const cached = patternCache.get(pattern);
-  if (cached) {
-    return cached;
-  }
-  const match = pattern.match(/^\/(.*)\/$/);
-  const regexp = match ? compileRegExpPattern(match[1]) : compileStringPattern(pattern);
-  patternCache.set(pattern, regexp);
-  return regexp;
-}
-function keywordPatternMatcher(list, keyword) {
-  for (const pattern of list) {
-    const regexp = compilePattern(pattern);
-    if (regexp.test(keyword)) {
-      return true;
-    }
-  }
-  return false;
-}
-function isKeywordIgnored(options, keyword, matcher = (list, it) => list.includes(it)) {
-  const { include, exclude } = options;
-  if (include && !matcher(include, keyword)) {
+  return false;
+}
+function isKeywordIgnored(options, keyword, matcher = (list, it) => list.includes(it)) {
+  const { include, exclude } = options;
+  if (include && !matcher(include, keyword)) {
     return true;
   }
   if (exclude && matcher(exclude, keyword)) {
@@ -5022,7 +4557,7 @@ class AttributeAllowedValues extends Rule {
   setup() {
     this.on("dom:ready", (event) => {
       const doc = event.document;
-      doc.visitDepthFirst((node) => {
+      walk.depthFirst(doc, (node) => {
         const meta = node.meta;
         if (!(meta == null ? void 0 : meta.attributes))
           return;
@@ -5053,11 +4588,7 @@ class AttributeAllowedValues extends Rule {
     }
   }
   getLocation(attr) {
-    if (attr.value !== null) {
-      return attr.valueLocation;
-    } else {
-      return attr.keyLocation;
-    }
+    return attr.valueLocation ?? attr.keyLocation;
   }
 }
 
@@ -5086,7 +4617,7 @@ class AttributeBooleanStyle extends Rule {
   setup() {
     this.on("dom:ready", (event) => {
       const doc = event.document;
-      doc.visitDepthFirst((node) => {
+      walk.depthFirst(doc, (node) => {
         const meta = node.meta;
         if (!(meta == null ? void 0 : meta.attributes))
           return;
@@ -5158,7 +4689,7 @@ class AttributeEmptyStyle extends Rule {
   setup() {
     this.on("dom:ready", (event) => {
       const doc = event.document;
-      doc.visitDepthFirst((node) => {
+      walk.depthFirst(doc, (node) => {
         const meta = node.meta;
         if (!(meta == null ? void 0 : meta.attributes))
           return;
@@ -5810,7 +5341,7 @@ class ElementPermittedContent extends Rule {
   setup() {
     this.on("dom:ready", (event) => {
       const doc = event.document;
-      doc.visitDepthFirst((node) => {
+      walk.depthFirst(doc, (node) => {
         const parent = node.parent;
         if (!parent) {
           return;
@@ -5889,7 +5420,7 @@ class ElementPermittedOccurrences extends Rule {
   setup() {
     this.on("dom:ready", (event) => {
       const doc = event.document;
-      doc.visitDepthFirst((node) => {
+      walk.depthFirst(doc, (node) => {
         if (!node.meta) {
           return;
         }
@@ -5922,7 +5453,7 @@ class ElementPermittedOrder extends Rule {
   setup() {
     this.on("dom:ready", (event) => {
       const doc = event.document;
-      doc.visitDepthFirst((node) => {
+      walk.depthFirst(doc, (node) => {
         if (!node.meta) {
           return;
         }
@@ -5992,7 +5523,7 @@ class ElementPermittedParent extends Rule {
   setup() {
     this.on("dom:ready", (event) => {
       const doc = event.document;
-      doc.visitDepthFirst((node) => {
+      walk.depthFirst(doc, (node) => {
         var _a;
         const parent = node.parent;
         if (!parent) {
@@ -6040,7 +5571,7 @@ class ElementRequiredAncestor extends Rule {
   setup() {
     this.on("dom:ready", (event) => {
       const doc = event.document;
-      doc.visitDepthFirst((node) => {
+      walk.depthFirst(doc, (node) => {
         const parent = node.parent;
         if (!parent) {
           return;
@@ -6124,7 +5655,7 @@ class ElementRequiredContent extends Rule {
   setup() {
     this.on("dom:ready", (event) => {
       const doc = event.document;
-      doc.visitDepthFirst((node) => {
+      walk.depthFirst(doc, (node) => {
         if (!node.meta) {
           return;
         }
@@ -6644,7 +6175,7 @@ function isFocusableImpl(element) {
   if (isDisabled(element, meta)) {
     return false;
   }
-  return Boolean(meta == null ? void 0 : meta.focusable);
+  return Boolean(meta.focusable);
 }
 function isFocusable(element) {
   const cached = element.cacheGet(FOCUSABLE_CACHE);
@@ -8554,1778 +8085,2291 @@ class RequireSri extends Rule {
             items: {
               type: "string"
             },
-            type: "array"
-          },
-          {
-            type: "null"
-          }
-        ]
-      },
-      exclude: {
-        anyOf: [
-          {
-            items: {
+            type: "array"
+          },
+          {
+            type: "null"
+          }
+        ]
+      },
+      exclude: {
+        anyOf: [
+          {
+            items: {
+              type: "string"
+            },
+            type: "array"
+          },
+          {
+            type: "null"
+          }
+        ]
+      }
+    };
+  }
+  documentation() {
+    return {
+      description: `Subresource Integrity (SRI) \`integrity\` attribute is required to prevent tampering or manipulation from Content Delivery Networks (CDN), rouge proxies,  malicious entities, etc.`,
+      url: "https://html-validate.org/rules/require-sri.html"
+    };
+  }
+  setup() {
+    this.on("tag:end", (event) => {
+      const node = event.previous;
+      if (!(this.supportSri(node) && this.needSri(node))) {
+        return;
+      }
+      if (node.hasAttribute("integrity")) {
+        return;
+      }
+      this.report(
+        node,
+        `SRI "integrity" attribute is required on <${node.tagName}> element`,
+        node.location
+      );
+    });
+  }
+  supportSri(node) {
+    return Object.keys(supportSri).includes(node.tagName);
+  }
+  needSri(node) {
+    const attr = this.elementSourceAttr(node);
+    if (!attr) {
+      return false;
+    }
+    if (attr.value === null || attr.value === "" || attr.isDynamic) {
+      return false;
+    }
+    const url = attr.value.toString();
+    if (this.target === "all" || crossorigin.test(url)) {
+      return !this.isIgnored(url);
+    }
+    return false;
+  }
+  elementSourceAttr(node) {
+    const key = supportSri[node.tagName];
+    return node.getAttribute(key);
+  }
+  isIgnored(url) {
+    return this.isKeywordIgnored(url, (list, it) => {
+      return list.some((pattern) => it.includes(pattern));
+    });
+  }
+}
+
+class ScriptElement extends Rule {
+  documentation() {
+    return {
+      description: "The end tag for `<script>` is a hard requirement and must never be omitted even when using the `src` attribute.",
+      url: "https://html-validate.org/rules/script-element.html"
+    };
+  }
+  setup() {
+    this.on("tag:end", (event) => {
+      const node = event.target;
+      if (!node || node.tagName !== "script") {
+        return;
+      }
+      if (node.closed !== NodeClosed.EndTag) {
+        this.report(node, `End tag for <${node.tagName}> must not be omitted`);
+      }
+    });
+  }
+}
+
+const javascript = [
+  "",
+  "application/ecmascript",
+  "application/javascript",
+  "text/ecmascript",
+  "text/javascript"
+];
+class ScriptType extends Rule {
+  documentation() {
+    return {
+      description: "While valid the HTML5 standard encourages authors to omit the type element for JavaScript resources.",
+      url: "https://html-validate.org/rules/script-type.html"
+    };
+  }
+  setup() {
+    this.on("tag:end", (event) => {
+      const node = event.previous;
+      if (node.tagName !== "script") {
+        return;
+      }
+      const attr = node.getAttribute("type");
+      if (!attr || attr.isDynamic) {
+        return;
+      }
+      const value = attr.value ? attr.value.toString() : "";
+      if (!this.isJavascript(value)) {
+        return;
+      }
+      this.report(
+        node,
+        '"type" attribute is unnecessary for javascript resources',
+        attr.keyLocation
+      );
+    });
+  }
+  isJavascript(mime) {
+    const type = mime.replace(/;.*/, "");
+    return javascript.includes(type);
+  }
+}
+
+class SvgFocusable extends Rule {
+  documentation() {
+    return {
+      description: `Inline SVG elements in IE are focusable by default which may cause issues with tab-ordering. The \`focusable\` attribute should explicitly be set to avoid unintended behaviour.`,
+      url: "https://html-validate.org/rules/svg-focusable.html"
+    };
+  }
+  setup() {
+    this.on("element:ready", (event) => {
+      if (event.target.is("svg")) {
+        this.validate(event.target);
+      }
+    });
+  }
+  validate(svg) {
+    if (svg.hasAttribute("focusable")) {
+      return;
+    }
+    this.report(svg, `<${svg.tagName}> is missing required "focusable" attribute`);
+  }
+}
+
+const defaults$5 = {
+  characters: [
+    { pattern: " ", replacement: "&nbsp;", description: "non-breaking space" },
+    { pattern: "-", replacement: "&#8209;", description: "non-breaking hyphen" }
+  ],
+  ignoreClasses: [],
+  ignoreStyle: true
+};
+function constructRegex(characters) {
+  const disallowed = characters.map((it) => {
+    return it.pattern;
+  }).join("|");
+  const pattern = `(${disallowed})`;
+  return new RegExp(pattern, "g");
+}
+function getText(node) {
+  const match = node.textContent.match(/^(\s*)(.*)$/);
+  const [, leading, text] = match;
+  return [leading.length, text.trimEnd()];
+}
+function matchAll(text, regexp) {
+  const copy = new RegExp(regexp);
+  const matches = [];
+  let match;
+  while (match = copy.exec(text)) {
+    matches.push(match);
+  }
+  return matches;
+}
+class TelNonBreaking extends Rule {
+  constructor(options) {
+    super({ ...defaults$5, ...options });
+    this.regex = constructRegex(this.options.characters);
+  }
+  static schema() {
+    return {
+      characters: {
+        type: "array",
+        items: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            pattern: {
+              type: "string"
+            },
+            replacement: {
               type: "string"
             },
-            type: "array"
-          },
-          {
-            type: "null"
+            description: {
+              type: "string"
+            }
           }
-        ]
+        }
+      },
+      ignoreClasses: {
+        type: "array",
+        items: {
+          type: "string"
+        }
+      },
+      ignoreStyle: {
+        type: "boolean"
       }
     };
   }
-  documentation() {
+  documentation(context) {
+    const { characters } = this.options;
+    const replacements = characters.map((it) => {
+      return `  - \`${it.pattern}\` - replace with \`${it.replacement}\` (${it.description}).`;
+    });
     return {
-      description: `Subresource Integrity (SRI) \`integrity\` attribute is required to prevent tampering or manipulation from Content Delivery Networks (CDN), rouge proxies,  malicious entities, etc.`,
-      url: "https://html-validate.org/rules/require-sri.html"
+      description: [
+        `The \`${context.pattern}\` character should be replaced with \`${context.replacement}\` character (${context.description}) when used in a telephone number.`,
+        "",
+        "Unless non-breaking characters is used there could be a line break inserted at that character.",
+        "Line breaks make is harder to read and understand the telephone number.",
+        "",
+        "The following characters should be avoided:",
+        "",
+        ...replacements
+      ].join("\n"),
+      url: "https://html-validate.org/rules/tel-non-breaking.html"
     };
   }
   setup() {
-    this.on("tag:end", (event) => {
-      const node = event.previous;
-      if (!(this.supportSri(node) && this.needSri(node))) {
-        return;
-      }
-      if (node.hasAttribute("integrity")) {
+    this.on("element:ready", this.isRelevant, (event) => {
+      const { target } = event;
+      if (this.isIgnored(target)) {
         return;
       }
-      this.report(
-        node,
-        `SRI "integrity" attribute is required on <${node.tagName}> element`,
-        node.location
-      );
+      this.walk(target, target);
     });
   }
-  supportSri(node) {
-    return Object.keys(supportSri).includes(node.tagName);
-  }
-  needSri(node) {
-    const attr = this.elementSourceAttr(node);
-    if (!attr) {
+  isRelevant(event) {
+    const { target } = event;
+    if (!target.is("a")) {
       return false;
     }
-    if (attr.value === null || attr.value === "" || attr.isDynamic) {
+    const attr = target.getAttribute("href");
+    if (!(attr == null ? void 0 : attr.valueMatches(/^tel:/, false))) {
       return false;
     }
-    const url = attr.value.toString();
-    if (this.target === "all" || crossorigin.test(url)) {
-      return !this.isIgnored(url);
+    return true;
+  }
+  isIgnoredClass(node) {
+    const { ignoreClasses } = this.options;
+    const { classList } = node;
+    return ignoreClasses.some((it) => classList.contains(it));
+  }
+  isIgnoredStyle(node) {
+    const { ignoreStyle } = this.options;
+    const { style } = node;
+    if (!ignoreStyle) {
+      return false;
+    }
+    if (style["white-space"] === "nowrap" || style["white-space"] === "pre") {
+      return true;
     }
     return false;
   }
-  elementSourceAttr(node) {
-    const key = supportSri[node.tagName];
-    return node.getAttribute(key);
+  isIgnored(node) {
+    return this.isIgnoredClass(node) || this.isIgnoredStyle(node);
+  }
+  walk(anchor, node) {
+    for (const child of node.childNodes) {
+      if (isTextNode(child)) {
+        this.detectDisallowed(anchor, child);
+      } else if (isElementNode(child)) {
+        this.walk(anchor, child);
+      }
+    }
+  }
+  detectDisallowed(anchor, node) {
+    const [offset, text] = getText(node);
+    const matches = matchAll(text, this.regex);
+    for (const match of matches) {
+      const detected = match[0];
+      const entry = this.options.characters.find((it) => it.pattern === detected);
+      if (!entry) {
+        throw new Error(`Failed to find entry for "${detected}" when searching text "${text}"`);
+      }
+      const message = `"${detected}" should be replaced with "${entry.replacement}" (${entry.description}) in telephone number`;
+      const begin = offset + match.index;
+      const end = begin + detected.length;
+      const location = sliceLocation(node.location, begin, end);
+      const context = entry;
+      this.report(anchor, message, location, context);
+    }
+  }
+}
+
+function hasNonEmptyAttribute(node, key) {
+  const attr = node.getAttribute(key);
+  return Boolean(attr == null ? void 0 : attr.valueMatches(/.+/, true));
+}
+function hasDefaultText(node) {
+  if (!node.is("input")) {
+    return false;
+  }
+  if (node.hasAttribute("value")) {
+    return false;
+  }
+  const type = node.getAttribute("type");
+  return Boolean(type == null ? void 0 : type.valueMatches(/submit|reset/, false));
+}
+function isNonEmptyText(node) {
+  if (isTextNode(node)) {
+    return node.isDynamic || node.textContent.trim() !== "";
+  } else {
+    return false;
+  }
+}
+function haveAccessibleText(node) {
+  if (!inAccessibilityTree(node)) {
+    return false;
+  }
+  const haveText = node.childNodes.some((child) => isNonEmptyText(child));
+  if (haveText) {
+    return true;
+  }
+  if (hasNonEmptyAttribute(node, "aria-label")) {
+    return true;
+  }
+  if (hasNonEmptyAttribute(node, "aria-labelledby")) {
+    return true;
+  }
+  if (node.is("img") && hasNonEmptyAttribute(node, "alt")) {
+    return true;
+  }
+  if (hasDefaultText(node)) {
+    return true;
+  }
+  return node.childElements.some((child) => {
+    return haveAccessibleText(child);
+  });
+}
+class TextContent extends Rule {
+  documentation(context) {
+    const doc = {
+      description: `The textual content for this element is not valid.`,
+      url: "https://html-validate.org/rules/text-content.html"
+    };
+    switch (context.textContent) {
+      case TextContent$1.NONE:
+        doc.description = `The \`<${context.tagName}>\` element must not have textual content.`;
+        break;
+      case TextContent$1.REQUIRED:
+        doc.description = `The \`<${context.tagName}>\` element must have textual content.`;
+        break;
+      case TextContent$1.ACCESSIBLE:
+        doc.description = `The \`<${context.tagName}>\` element must have accessible text.`;
+        break;
+    }
+    return doc;
+  }
+  static filter(event) {
+    const { target } = event;
+    if (!target.meta) {
+      return false;
+    }
+    const { textContent } = target.meta;
+    if (!textContent || textContent === TextContent$1.DEFAULT) {
+      return false;
+    }
+    return true;
+  }
+  setup() {
+    this.on("element:ready", TextContent.filter, (event) => {
+      const target = event.target;
+      const { textContent } = target.meta;
+      switch (textContent) {
+        case TextContent$1.NONE:
+          this.validateNone(target);
+          break;
+        case TextContent$1.REQUIRED:
+          this.validateRequired(target);
+          break;
+        case TextContent$1.ACCESSIBLE:
+          this.validateAccessible(target);
+          break;
+      }
+    });
+  }
+  /**
+   * Validate element has empty text (inter-element whitespace is not considered text)
+   */
+  validateNone(node) {
+    if (classifyNodeText(node) === TextClassification.EMPTY_TEXT) {
+      return;
+    }
+    this.reportError(node, node.meta, `${node.annotatedName} must not have text content`);
+  }
+  /**
+   * Validate element has any text (inter-element whitespace is not considered text)
+   */
+  validateRequired(node) {
+    if (classifyNodeText(node) !== TextClassification.EMPTY_TEXT) {
+      return;
+    }
+    this.reportError(node, node.meta, `${node.annotatedName} must have text content`);
+  }
+  /**
+   * Validate element has accessible text (either regular text or text only
+   * exposed in accessibility tree via aria-label or similar)
+   */
+  validateAccessible(node) {
+    if (!inAccessibilityTree(node)) {
+      return;
+    }
+    if (haveAccessibleText(node)) {
+      return;
+    }
+    this.reportError(node, node.meta, `${node.annotatedName} must have accessible text`);
   }
-  isIgnored(url) {
-    return this.isKeywordIgnored(url, (list, it) => {
-      return list.some((pattern) => it.includes(pattern));
+  reportError(node, meta, message) {
+    this.report(node, message, null, {
+      tagName: node.tagName,
+      textContent: meta.textContent
     });
   }
 }
 
-class ScriptElement extends Rule {
-  documentation() {
-    return {
-      description: "The end tag for `<script>` is a hard requirement and must never be omitted even when using the `src` attribute.",
-      url: "https://html-validate.org/rules/script-element.html"
-    };
+const roles = ["complementary", "contentinfo", "form", "banner", "main", "navigation", "region"];
+const selectors = [
+  "aside",
+  "footer",
+  "form",
+  "header",
+  "main",
+  "nav",
+  "section",
+  ...roles.map((it) => `[role="${it}"]`)
+  /* <search> does not (yet?) require a unique name */
+];
+function getTextFromReference(document, id) {
+  if (!id || id instanceof DynamicValue) {
+    return id;
   }
-  setup() {
-    this.on("tag:end", (event) => {
-      const node = event.target;
-      if (!node || node.tagName !== "script") {
-        return;
-      }
-      if (node.closed !== NodeClosed.EndTag) {
-        this.report(node, `End tag for <${node.tagName}> must not be omitted`);
-      }
-    });
+  const selector = `#${id}`;
+  const ref = document.querySelector(selector);
+  if (ref) {
+    return ref.textContent;
+  } else {
+    return selector;
   }
 }
-
-const javascript = [
-  "",
-  "application/ecmascript",
-  "application/javascript",
-  "text/ecmascript",
-  "text/javascript"
-];
-class ScriptType extends Rule {
-  documentation() {
+function groupBy(values, callback) {
+  const result = {};
+  for (const value of values) {
+    const key = callback(value);
+    if (key in result) {
+      result[key].push(value);
+    } else {
+      result[key] = [value];
+    }
+  }
+  return result;
+}
+function getTextEntryFromElement(document, node) {
+  const ariaLabel = node.getAttribute("aria-label");
+  if (ariaLabel) {
     return {
-      description: "While valid the HTML5 standard encourages authors to omit the type element for JavaScript resources.",
-      url: "https://html-validate.org/rules/script-type.html"
+      node,
+      text: ariaLabel.value,
+      location: ariaLabel.keyLocation
     };
   }
-  setup() {
-    this.on("tag:end", (event) => {
-      const node = event.previous;
-      if (node.tagName !== "script") {
-        return;
-      }
-      const attr = node.getAttribute("type");
-      if (!attr || attr.isDynamic) {
-        return;
-      }
-      const value = attr.value ? attr.value.toString() : "";
-      if (!this.isJavascript(value)) {
-        return;
-      }
-      this.report(
-        node,
-        '"type" attribute is unnecessary for javascript resources',
-        attr.keyLocation
-      );
-    });
+  const ariaLabelledby = node.getAttribute("aria-labelledby");
+  if (ariaLabelledby) {
+    const text = getTextFromReference(document, ariaLabelledby.value);
+    return {
+      node,
+      text,
+      location: ariaLabelledby.keyLocation
+    };
   }
-  isJavascript(mime) {
-    const type = mime.replace(/;.*/, "");
-    return javascript.includes(type);
+  return {
+    node,
+    text: null,
+    location: node.location
+  };
+}
+function isExcluded(entry) {
+  const { node, text } = entry;
+  if (text === null) {
+    return !(node.is("form") || node.is("section"));
   }
+  return true;
 }
-
-class SvgFocusable extends Rule {
+class UniqueLandmark extends Rule {
   documentation() {
     return {
-      description: `Inline SVG elements in IE are focusable by default which may cause issues with tab-ordering. The \`focusable\` attribute should explicitly be set to avoid unintended behaviour.`,
-      url: "https://html-validate.org/rules/svg-focusable.html"
+      description: [
+        "When the same type of landmark is present more than once in the same document each must be uniquely identifiable with a non-empty and unique name.",
+        "For instance, if the document has two `<nav>` elements each of them need an accessible name to be distinguished from each other.",
+        "",
+        "The following elements / roles are considered landmarks:",
+        "",
+        '  - `aside` or `[role="complementary"]`',
+        '  - `footer` or `[role="contentinfo"]`',
+        '  - `form` or `[role="form"]`',
+        '  - `header` or `[role="banner"]`',
+        '  - `main` or `[role="main"]`',
+        '  - `nav` or `[role="navigation"]`',
+        '  - `section` or `[role="region"]`',
+        "",
+        "To fix this either:",
+        "",
+        "  - Add `aria-label`.",
+        "  - Add `aria-labelledby`.",
+        "  - Remove one of the landmarks."
+      ].join("\n"),
+      url: "https://html-validate.org/rules/unique-landmark.html"
     };
   }
   setup() {
-    this.on("element:ready", (event) => {
-      if (event.target.is("svg")) {
-        this.validate(event.target);
+    this.on("dom:ready", (event) => {
+      const { document } = event;
+      const elements = document.querySelectorAll(selectors.join(",")).filter((it) => typeof it.role === "string" && roles.includes(it.role));
+      const grouped = groupBy(elements, (it) => it.role);
+      for (const nodes of Object.values(grouped)) {
+        if (nodes.length <= 1) {
+          continue;
+        }
+        const entries = nodes.map((it) => getTextEntryFromElement(document, it));
+        const filteredEntries = entries.filter(isExcluded);
+        for (const entry of filteredEntries) {
+          if (entry.text instanceof DynamicValue) {
+            continue;
+          }
+          const dup = entries.filter((it) => it.text === entry.text).length > 1;
+          if (!entry.text || dup) {
+            const message = `Landmarks must have a non-empty and unique accessible name (aria-label or aria-labelledby)`;
+            const location = entry.location;
+            this.report({
+              node: entry.node,
+              message,
+              location
+            });
+          }
+        }
       }
     });
   }
-  validate(svg) {
-    if (svg.hasAttribute("focusable")) {
-      return;
-    }
-    this.report(svg, `<${svg.tagName}> is missing required "focusable" attribute`);
-  }
 }
 
-const defaults$5 = {
-  characters: [
-    { pattern: " ", replacement: "&nbsp;", description: "non-breaking space" },
-    { pattern: "-", replacement: "&#8209;", description: "non-breaking hyphen" }
-  ],
-  ignoreClasses: [],
-  ignoreStyle: true
+const defaults$4 = {
+  ignoreCase: false,
+  requireSemicolon: true
 };
-function constructRegex(characters) {
-  const disallowed = characters.map((it) => {
-    return it.pattern;
-  }).join("|");
-  const pattern = `(${disallowed})`;
-  return new RegExp(pattern, "g");
-}
-function getText(node) {
-  const match = node.textContent.match(/^(\s*)(.*)$/);
-  const [, leading, text] = match;
-  return [leading.length, text.trimEnd()];
+const regexp$1 = /&(?:[a-z0-9]+|#x?[0-9a-f]+)(;|[^a-z0-9]|$)/gi;
+const lowercaseEntities = elements.entities.map((it) => it.toLowerCase());
+function isNumerical(entity) {
+  return entity.startsWith("&#");
 }
-function matchAll(text, regexp) {
-  const copy = new RegExp(regexp);
-  const matches = [];
-  let match;
-  while (match = copy.exec(text)) {
-    matches.push(match);
-  }
-  return matches;
+function getLocation(location, entity, match) {
+  const index = match.index ?? 0;
+  return sliceLocation(location, index, index + entity.length);
 }
-class TelNonBreaking extends Rule {
-  constructor(options) {
-    super({ ...defaults$5, ...options });
-    this.regex = constructRegex(this.options.characters);
+function getDescription(context, options) {
+  const url = "https://html.spec.whatwg.org/multipage/named-characters.html";
+  let message;
+  if (context.terminated) {
+    message = `Unrecognized character reference \`${context.entity}\`.`;
+  } else {
+    message = `Character reference \`${context.entity}\` must be terminated by a semicolon.`;
   }
-  static schema() {
-    return {
-      characters: {
-        type: "array",
-        items: {
-          type: "object",
-          additionalProperties: false,
-          properties: {
-            pattern: {
-              type: "string"
-            },
-            replacement: {
-              type: "string"
-            },
-            description: {
-              type: "string"
-            }
-          }
-        }
-      },
-      ignoreClasses: {
-        type: "array",
-        items: {
-          type: "string"
-        }
+  return [
+    message,
+    `HTML5 defines a set of [valid character references](${url}) but this is not a valid one.`,
+    "",
+    "Ensure that:",
+    "",
+    "1. The character is one of the listed names.",
+    ...options.ignoreCase ? [] : ["1. The case is correct (names are case sensitive)."],
+    ...options.requireSemicolon ? ["1. The name is terminated with a `;`."] : []
+  ].join("\n");
+}
+class UnknownCharReference extends Rule {
+  constructor(options) {
+    super({ ...defaults$4, ...options });
+  }
+  static schema() {
+    return {
+      ignoreCase: {
+        type: "boolean"
       },
-      ignoreStyle: {
+      requireSemicolon: {
         type: "boolean"
       }
     };
   }
   documentation(context) {
-    const { characters } = this.options;
-    const replacements = characters.map((it) => {
-      return `  - \`${it.pattern}\` - replace with \`${it.replacement}\` (${it.description}).`;
-    });
     return {
-      description: [
-        `The \`${context.pattern}\` character should be replaced with \`${context.replacement}\` character (${context.description}) when used in a telephone number.`,
-        "",
-        "Unless non-breaking characters is used there could be a line break inserted at that character.",
-        "Line breaks make is harder to read and understand the telephone number.",
-        "",
-        "The following characters should be avoided:",
-        "",
-        ...replacements
-      ].join("\n"),
-      url: "https://html-validate.org/rules/tel-non-breaking.html"
+      description: getDescription(context, this.options),
+      url: "https://html-validate.org/rules/unrecognized-char-ref.html"
     };
   }
   setup() {
-    this.on("element:ready", this.isRelevant, (event) => {
-      const { target } = event;
-      if (this.isIgnored(target)) {
+    this.on("element:ready", (event) => {
+      const node = event.target;
+      for (const child of node.childNodes) {
+        if (child.nodeType !== NodeType.TEXT_NODE) {
+          continue;
+        }
+        this.findCharacterReferences(node, child.textContent, child.location, {
+          isAttribute: false
+        });
+      }
+    });
+    this.on("attr", (event) => {
+      if (!event.value) {
         return;
       }
-      this.walk(target, target);
+      this.findCharacterReferences(event.target, event.value.toString(), event.valueLocation, {
+        isAttribute: true
+      });
     });
   }
-  isRelevant(event) {
-    const { target } = event;
-    if (!target.is("a")) {
-      return false;
+  get entities() {
+    if (this.options.ignoreCase) {
+      return lowercaseEntities;
+    } else {
+      return elements.entities;
     }
-    const attr = target.getAttribute("href");
-    if (!(attr == null ? void 0 : attr.valueMatches(/^tel:/, false))) {
-      return false;
+  }
+  findCharacterReferences(node, text, location, { isAttribute }) {
+    const isQuerystring = isAttribute && text.includes("?");
+    for (const match of this.getMatches(text)) {
+      this.validateCharacterReference(node, location, match, { isQuerystring });
     }
-    return true;
   }
-  isIgnoredClass(node) {
-    const { ignoreClasses } = this.options;
-    const { classList } = node;
-    return ignoreClasses.some((it) => classList.contains(it));
+  validateCharacterReference(node, location, foobar, { isQuerystring }) {
+    const { requireSemicolon } = this.options;
+    const { match, entity, raw, terminated } = foobar;
+    if (isNumerical(entity)) {
+      return;
+    }
+    if (isQuerystring && !terminated) {
+      return;
+    }
+    const found = this.entities.includes(entity);
+    if (found && (terminated || !requireSemicolon)) {
+      return;
+    }
+    if (found && !terminated) {
+      const entityLocation2 = getLocation(location, entity, match);
+      const message2 = `Character reference "{{ entity }}" must be terminated by a semicolon`;
+      const context2 = {
+        entity: raw,
+        terminated: false
+      };
+      this.report(node, message2, entityLocation2, context2);
+      return;
+    }
+    const entityLocation = getLocation(location, entity, match);
+    const message = `Unrecognized character reference "{{ entity }}"`;
+    const context = {
+      entity: raw,
+      terminated: true
+    };
+    this.report(node, message, entityLocation, context);
+  }
+  *getMatches(text) {
+    let match;
+    do {
+      match = regexp$1.exec(text);
+      if (match) {
+        const terminator = match[1];
+        const terminated = terminator === ";";
+        const needSlice = terminator !== ";" && terminator.length > 0;
+        const entity = needSlice ? match[0].slice(0, -1) : match[0];
+        if (this.options.ignoreCase) {
+          yield { match, entity: entity.toLowerCase(), raw: entity, terminated };
+        } else {
+          yield { match, entity, raw: entity, terminated };
+        }
+      }
+    } while (match);
+  }
+}
+
+const expectedOrder = ["section", "hint", "contact", "field1", "field2", "webauthn"];
+const fieldNames1 = [
+  "name",
+  "honorific-prefix",
+  "given-name",
+  "additional-name",
+  "family-name",
+  "honorific-suffix",
+  "nickname",
+  "username",
+  "new-password",
+  "current-password",
+  "one-time-code",
+  "organization-title",
+  "organization",
+  "street-address",
+  "address-line1",
+  "address-line2",
+  "address-line3",
+  "address-level4",
+  "address-level3",
+  "address-level2",
+  "address-level1",
+  "country",
+  "country-name",
+  "postal-code",
+  "cc-name",
+  "cc-given-name",
+  "cc-additional-name",
+  "cc-family-name",
+  "cc-number",
+  "cc-exp",
+  "cc-exp-month",
+  "cc-exp-year",
+  "cc-csc",
+  "cc-type",
+  "transaction-currency",
+  "transaction-amount",
+  "language",
+  "bday",
+  "bday-day",
+  "bday-month",
+  "bday-year",
+  "sex",
+  "url",
+  "photo"
+];
+const fieldNames2 = [
+  "tel",
+  "tel-country-code",
+  "tel-national",
+  "tel-area-code",
+  "tel-local",
+  "tel-local-prefix",
+  "tel-local-suffix",
+  "tel-extension",
+  "email",
+  "impp"
+];
+const fieldNameGroup = {
+  name: "text",
+  "honorific-prefix": "text",
+  "given-name": "text",
+  "additional-name": "text",
+  "family-name": "text",
+  "honorific-suffix": "text",
+  nickname: "text",
+  username: "username",
+  "new-password": "password",
+  "current-password": "password",
+  "one-time-code": "password",
+  "organization-title": "text",
+  organization: "text",
+  "street-address": "multiline",
+  "address-line1": "text",
+  "address-line2": "text",
+  "address-line3": "text",
+  "address-level4": "text",
+  "address-level3": "text",
+  "address-level2": "text",
+  "address-level1": "text",
+  country: "text",
+  "country-name": "text",
+  "postal-code": "text",
+  "cc-name": "text",
+  "cc-given-name": "text",
+  "cc-additional-name": "text",
+  "cc-family-name": "text",
+  "cc-number": "text",
+  "cc-exp": "month",
+  "cc-exp-month": "numeric",
+  "cc-exp-year": "numeric",
+  "cc-csc": "text",
+  "cc-type": "text",
+  "transaction-currency": "text",
+  "transaction-amount": "numeric",
+  language: "text",
+  bday: "date",
+  "bday-day": "numeric",
+  "bday-month": "numeric",
+  "bday-year": "numeric",
+  sex: "text",
+  url: "url",
+  photo: "url",
+  tel: "tel",
+  "tel-country-code": "text",
+  "tel-national": "text",
+  "tel-area-code": "text",
+  "tel-local": "text",
+  "tel-local-prefix": "text",
+  "tel-local-suffix": "text",
+  "tel-extension": "text",
+  email: "username",
+  impp: "url"
+};
+const disallowedInputTypes = ["checkbox", "radio", "file", "submit", "image", "reset", "button"];
+function matchSection(token) {
+  return token.startsWith("section-");
+}
+function matchHint(token) {
+  return token === "shipping" || token === "billing";
+}
+function matchFieldNames1(token) {
+  return fieldNames1.includes(token);
+}
+function matchContact(token) {
+  const haystack = ["home", "work", "mobile", "fax", "pager"];
+  return haystack.includes(token);
+}
+function matchFieldNames2(token) {
+  return fieldNames2.includes(token);
+}
+function matchWebauthn(token) {
+  return token === "webauthn";
+}
+function matchToken(token) {
+  if (matchSection(token)) {
+    return "section";
+  }
+  if (matchHint(token)) {
+    return "hint";
   }
-  isIgnoredStyle(node) {
-    const { ignoreStyle } = this.options;
-    const { style } = node;
-    if (!ignoreStyle) {
-      return false;
-    }
-    if (style["white-space"] === "nowrap" || style["white-space"] === "pre") {
-      return true;
-    }
-    return false;
+  if (matchFieldNames1(token)) {
+    return "field1";
   }
-  isIgnored(node) {
-    return this.isIgnoredClass(node) || this.isIgnoredStyle(node);
+  if (matchFieldNames2(token)) {
+    return "field2";
   }
-  walk(anchor, node) {
-    for (const child of node.childNodes) {
-      if (isTextNode(child)) {
-        this.detectDisallowed(anchor, child);
-      } else if (isElementNode(child)) {
-        this.walk(anchor, child);
-      }
-    }
+  if (matchContact(token)) {
+    return "contact";
   }
-  detectDisallowed(anchor, node) {
-    const [offset, text] = getText(node);
-    const matches = matchAll(text, this.regex);
-    for (const match of matches) {
-      const detected = match[0];
-      const entry = this.options.characters.find((it) => it.pattern === detected);
-      if (!entry) {
-        throw new Error(`Failed to find entry for "${detected}" when searching text "${text}"`);
-      }
-      const message = `"${detected}" should be replaced with "${entry.replacement}" (${entry.description}) in telephone number`;
-      const begin = offset + match.index;
-      const end = begin + detected.length;
-      const location = sliceLocation(node.location, begin, end);
-      const context = entry;
-      this.report(anchor, message, location, context);
-    }
+  if (matchWebauthn(token)) {
+    return "webauthn";
   }
+  return null;
 }
-
-function hasNonEmptyAttribute(node, key) {
-  const attr = node.getAttribute(key);
-  return Boolean(attr == null ? void 0 : attr.valueMatches(/.+/, true));
+function getControlGroups(type) {
+  const allGroups = [
+    "text",
+    "multiline",
+    "password",
+    "url",
+    "username",
+    "tel",
+    "numeric",
+    "month",
+    "date"
+  ];
+  const mapping = {
+    hidden: allGroups,
+    text: allGroups.filter((it) => it !== "multiline"),
+    search: allGroups.filter((it) => it !== "multiline"),
+    password: ["password"],
+    url: ["url"],
+    email: ["username"],
+    tel: ["tel"],
+    number: ["numeric"],
+    month: ["month"],
+    date: ["date"]
+  };
+  return mapping[type] ?? [];
 }
-function hasDefaultText(node) {
+function isDisallowedType(node, type) {
   if (!node.is("input")) {
     return false;
   }
-  if (node.hasAttribute("value")) {
-    return false;
-  }
-  const type = node.getAttribute("type");
-  return Boolean(type == null ? void 0 : type.valueMatches(/submit|reset/, false));
+  return disallowedInputTypes.includes(type);
 }
-function isNonEmptyText(node) {
-  if (isTextNode(node)) {
-    return node.isDynamic || node.textContent.trim() !== "";
-  } else {
-    return false;
+function getTerminalMessage(context) {
+  switch (context.msg) {
+    case 0 /* InvalidAttribute */:
+      return "autocomplete attribute cannot be used on {{ what }}";
+    case 1 /* InvalidValue */:
+      return '"{{ value }}" cannot be used on {{ what }}';
+    case 2 /* InvalidOrder */:
+      return '"{{ second }}" must appear before "{{ first }}"';
+    case 3 /* InvalidToken */:
+      return '"{{ token }}" is not a valid autocomplete token or field name';
+    case 4 /* InvalidCombination */:
+      return '"{{ second }}" cannot be combined with "{{ first }}"';
+    case 5 /* MissingField */:
+      return "autocomplete attribute is missing field name";
   }
 }
-function haveAccessibleText(node) {
-  if (!inAccessibilityTree(node)) {
-    return false;
-  }
-  const haveText = node.childNodes.some((child) => isNonEmptyText(child));
-  if (haveText) {
-    return true;
-  }
-  if (hasNonEmptyAttribute(node, "aria-label")) {
-    return true;
-  }
-  if (hasNonEmptyAttribute(node, "aria-labelledby")) {
-    return true;
-  }
-  if (node.is("img") && hasNonEmptyAttribute(node, "alt")) {
-    return true;
-  }
-  if (hasDefaultText(node)) {
-    return true;
+function getMarkdownMessage(context) {
+  switch (context.msg) {
+    case 0 /* InvalidAttribute */:
+      return [
+        `\`autocomplete\` attribute cannot be used on \`${context.what}\``,
+        "",
+        "The following input types cannot use the `autocomplete` attribute:",
+        "",
+        ...disallowedInputTypes.map((it) => `- \`${it}\``)
+      ].join("\n");
+    case 1 /* InvalidValue */: {
+      const message = `\`"${context.value}"\` cannot be used on \`${context.what}\``;
+      if (context.type === "form") {
+        return [
+          message,
+          "",
+          'The `<form>` element can only use the values `"on"` and `"off"`.'
+        ].join("\n");
+      }
+      if (context.type === "hidden") {
+        return [
+          message,
+          "",
+          '`<input type="hidden">` cannot use the values `"on"` and `"off"`.'
+        ].join("\n");
+      }
+      const controlGroups = getControlGroups(context.type);
+      const currentGroup = fieldNameGroup[context.value];
+      return [
+        message,
+        "",
+        `\`${context.what}\` allows autocomplete fields from the following group${controlGroups.length > 1 ? "s" : ""}:`,
+        "",
+        ...controlGroups.map((it) => `- ${it}`),
+        "",
+        `The field \`"${context.value}"\` belongs to the group /${currentGroup}/ which cannot be used with this input type.`
+      ].join("\n");
+    }
+    case 2 /* InvalidOrder */:
+      return [
+        `\`"${context.second}"\` must appear before \`"${context.first}"\``,
+        "",
+        "The autocomplete tokens must appear in the following order:",
+        "",
+        "- Optional section name (`section-` prefix).",
+        "- Optional `shipping` or `billing` token.",
+        "- Optional `home`, `work`, `mobile`, `fax` or `pager` token (for fields supporting it).",
+        "- Field name",
+        "- Optional `webauthn` token."
+      ].join("\n");
+    case 3 /* InvalidToken */:
+      return `\`"${context.token}"\` is not a valid autocomplete token or field name`;
+    case 4 /* InvalidCombination */:
+      return `\`"${context.second}"\` cannot be combined with \`"${context.first}"\``;
+    case 5 /* MissingField */:
+      return "Autocomplete attribute is missing field name";
   }
-  return node.childElements.some((child) => {
-    return haveAccessibleText(child);
-  });
 }
-class TextContent extends Rule {
+class ValidAutocomplete extends Rule {
   documentation(context) {
-    const doc = {
-      description: `The textual content for this element is not valid.`,
-      url: "https://html-validate.org/rules/text-content.html"
+    return {
+      description: getMarkdownMessage(context),
+      url: "https://html-validate.org/rules/valid-autocomplete.html"
     };
-    switch (context.textContent) {
-      case TextContent$1.NONE:
-        doc.description = `The \`<${context.tagName}>\` element must not have textual content.`;
-        break;
-      case TextContent$1.REQUIRED:
-        doc.description = `The \`<${context.tagName}>\` element must have textual content.`;
-        break;
-      case TextContent$1.ACCESSIBLE:
-        doc.description = `The \`<${context.tagName}>\` element must have accessible text.`;
-        break;
-    }
-    return doc;
-  }
-  static filter(event) {
-    const { target } = event;
-    if (!target.meta) {
-      return false;
-    }
-    const { textContent } = target.meta;
-    if (!textContent || textContent === TextContent$1.DEFAULT) {
-      return false;
-    }
-    return true;
   }
   setup() {
-    this.on("element:ready", TextContent.filter, (event) => {
-      const target = event.target;
-      const { textContent } = target.meta;
-      switch (textContent) {
-        case TextContent$1.NONE:
-          this.validateNone(target);
-          break;
-        case TextContent$1.REQUIRED:
-          this.validateRequired(target);
-          break;
-        case TextContent$1.ACCESSIBLE:
-          this.validateAccessible(target);
-          break;
+    this.on("dom:ready", (event) => {
+      const { document } = event;
+      const elements = document.querySelectorAll("[autocomplete]");
+      for (const element of elements) {
+        const autocomplete = element.getAttribute("autocomplete");
+        if (autocomplete.value === null || autocomplete.value instanceof DynamicValue) {
+          continue;
+        }
+        const location = autocomplete.valueLocation;
+        const value = autocomplete.value.toLowerCase();
+        const tokens = new DOMTokenList(value, location);
+        if (tokens.length === 0) {
+          continue;
+        }
+        this.validate(element, value, tokens, autocomplete.keyLocation, location);
       }
     });
   }
-  /**
-   * Validate element has empty text (inter-element whitespace is not considered text)
-   */
-  validateNone(node) {
-    if (classifyNodeText(node) === TextClassification.EMPTY_TEXT) {
-      return;
+  validate(node, value, tokens, keyLocation, valueLocation) {
+    switch (node.tagName) {
+      case "form":
+        this.validateFormAutocomplete(node, value, valueLocation);
+        break;
+      case "input":
+      case "textarea":
+      case "select":
+        this.validateControlAutocomplete(node, tokens, keyLocation);
+        break;
     }
-    this.reportError(node, node.meta, `${node.annotatedName} must not have text content`);
   }
-  /**
-   * Validate element has any text (inter-element whitespace is not considered text)
-   */
-  validateRequired(node) {
-    if (classifyNodeText(node) !== TextClassification.EMPTY_TEXT) {
+  validateControlAutocomplete(node, tokens, keyLocation) {
+    const type = node.getAttributeValue("type") ?? "text";
+    const mantle = type !== "hidden" ? "expectation" : "anchor";
+    if (isDisallowedType(node, type)) {
+      const context = {
+        msg: 0 /* InvalidAttribute */,
+        what: `<input type="${type}">`
+      };
+      this.report({
+        node,
+        message: getTerminalMessage(context),
+        location: keyLocation,
+        context
+      });
       return;
     }
-    this.reportError(node, node.meta, `${node.annotatedName} must have text content`);
-  }
-  /**
-   * Validate element has accessible text (either regular text or text only
-   * exposed in accessibility tree via aria-label or similar)
-   */
-  validateAccessible(node) {
-    if (!inAccessibilityTree(node)) {
+    if (tokens.includes("on") || tokens.includes("off")) {
+      this.validateOnOff(node, mantle, tokens);
       return;
     }
-    if (haveAccessibleText(node)) {
+    this.validateTokens(node, tokens, keyLocation);
+  }
+  validateFormAutocomplete(node, value, location) {
+    const trimmed = value.trim();
+    if (["on", "off"].includes(trimmed)) {
       return;
     }
-    this.reportError(node, node.meta, `${node.annotatedName} must have accessible text`);
-  }
-  reportError(node, meta, message) {
-    this.report(node, message, null, {
-      tagName: node.tagName,
-      textContent: meta.textContent
+    const context = {
+      msg: 1 /* InvalidValue */,
+      type: "form",
+      value: trimmed,
+      what: "<form>"
+    };
+    this.report({
+      node,
+      message: getTerminalMessage(context),
+      location,
+      context
     });
   }
-}
-
-const roles = ["complementary", "contentinfo", "form", "banner", "main", "navigation", "region"];
-const selectors = [
-  "aside",
-  "footer",
-  "form",
-  "header",
-  "main",
-  "nav",
-  "section",
-  ...roles.map((it) => `[role="${it}"]`)
-  /* <search> does not (yet?) require a unique name */
-];
-function getTextFromReference(document, id) {
-  if (!id || id instanceof DynamicValue) {
-    return id;
-  }
-  const selector = `#${id}`;
-  const ref = document.querySelector(selector);
-  if (ref) {
-    return ref.textContent;
-  } else {
-    return selector;
-  }
-}
-function groupBy(values, callback) {
-  const result = {};
-  for (const value of values) {
-    const key = callback(value);
-    if (key in result) {
-      result[key].push(value);
-    } else {
-      result[key] = [value];
+  validateOnOff(node, mantle, tokens) {
+    const index = tokens.findIndex((it) => it === "on" || it === "off");
+    const value = tokens.item(index);
+    const location = tokens.location(index);
+    if (tokens.length > 1) {
+      const context = {
+        msg: 4 /* InvalidCombination */,
+        /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- it must be present of it wouldn't be found */
+        first: tokens.item(index > 0 ? 0 : 1),
+        second: value
+      };
+      this.report({
+        node,
+        message: getTerminalMessage(context),
+        location,
+        context
+      });
+    }
+    switch (mantle) {
+      case "expectation":
+        return;
+      case "anchor": {
+        const context = {
+          msg: 1 /* InvalidValue */,
+          type: "hidden",
+          value,
+          what: `<input type="hidden">`
+        };
+        this.report({
+          node,
+          message: getTerminalMessage(context),
+          location: tokens.location(0),
+          context
+        });
+      }
     }
   }
-  return result;
-}
-function getTextEntryFromElement(document, node) {
-  const ariaLabel = node.getAttribute("aria-label");
-  if (ariaLabel) {
-    return {
-      node,
-      text: ariaLabel.value,
-      location: ariaLabel.keyLocation
-    };
-  }
-  const ariaLabelledby = node.getAttribute("aria-labelledby");
-  if (ariaLabelledby) {
-    const text = getTextFromReference(document, ariaLabelledby.value);
-    return {
-      node,
-      text,
-      location: ariaLabelledby.keyLocation
-    };
+  validateTokens(node, tokens, keyLocation) {
+    const order = [];
+    for (const { item, location } of tokens.iterator()) {
+      const tokenType = matchToken(item);
+      if (tokenType) {
+        order.push(tokenType);
+      } else {
+        const context = {
+          msg: 3 /* InvalidToken */,
+          token: item
+        };
+        this.report({
+          node,
+          message: getTerminalMessage(context),
+          location,
+          context
+        });
+        return;
+      }
+    }
+    const fieldTokens = order.map((it) => it === "field1" || it === "field2");
+    this.validateFieldPresence(node, tokens, fieldTokens, keyLocation);
+    this.validateContact(node, tokens, order);
+    this.validateOrder(node, tokens, order);
+    this.validateControlGroup(node, tokens, fieldTokens);
   }
-  return {
-    node,
-    text: null,
-    location: node.location
-  };
-}
-function isExcluded(entry) {
-  const { node, text } = entry;
-  if (text === null) {
-    return !(node.is("form") || node.is("section"));
+  /**
+   * Ensure that exactly one field name is present from the two field lists.
+   */
+  validateFieldPresence(node, tokens, fieldTokens, keyLocation) {
+    const numFields = fieldTokens.filter(Boolean).length;
+    if (numFields === 0) {
+      const context = {
+        msg: 5 /* MissingField */
+      };
+      this.report({
+        node,
+        message: getTerminalMessage(context),
+        location: keyLocation,
+        context
+      });
+    } else if (numFields > 1) {
+      const a = fieldTokens.indexOf(true);
+      const b = fieldTokens.lastIndexOf(true);
+      const context = {
+        msg: 4 /* InvalidCombination */,
+        /* eslint-disable @typescript-eslint/no-non-null-assertion -- it must be present of it wouldn't be found */
+        first: tokens.item(a),
+        second: tokens.item(b)
+        /* eslint-enable @typescript-eslint/no-non-null-assertion */
+      };
+      this.report({
+        node,
+        message: getTerminalMessage(context),
+        location: tokens.location(b),
+        context
+      });
+    }
   }
-  return true;
-}
-class UniqueLandmark extends Rule {
-  documentation() {
-    return {
-      description: [
-        "When the same type of landmark is present more than once in the same document each must be uniquely identifiable with a non-empty and unique name.",
-        "For instance, if the document has two `<nav>` elements each of them need an accessible name to be distinguished from each other.",
-        "",
-        "The following elements / roles are considered landmarks:",
-        "",
-        '  - `aside` or `[role="complementary"]`',
-        '  - `footer` or `[role="contentinfo"]`',
-        '  - `form` or `[role="form"]`',
-        '  - `header` or `[role="banner"]`',
-        '  - `main` or `[role="main"]`',
-        '  - `nav` or `[role="navigation"]`',
-        '  - `section` or `[role="region"]`',
-        "",
-        "To fix this either:",
-        "",
-        "  - Add `aria-label`.",
-        "  - Add `aria-labelledby`.",
-        "  - Remove one of the landmarks."
-      ].join("\n"),
-      url: "https://html-validate.org/rules/unique-landmark.html"
-    };
+  /**
+   * Ensure contact token is only used with field names from the second list.
+   */
+  validateContact(node, tokens, order) {
+    if (order.includes("contact") && order.includes("field1")) {
+      const a = order.indexOf("field1");
+      const b = order.indexOf("contact");
+      const context = {
+        msg: 4 /* InvalidCombination */,
+        /* eslint-disable @typescript-eslint/no-non-null-assertion -- it must be present of it wouldn't be found */
+        first: tokens.item(a),
+        second: tokens.item(b)
+        /* eslint-enable @typescript-eslint/no-non-null-assertion */
+      };
+      this.report({
+        node,
+        message: getTerminalMessage(context),
+        location: tokens.location(b),
+        context
+      });
+    }
   }
-  setup() {
-    this.on("dom:ready", (event) => {
-      const { document } = event;
-      const elements = document.querySelectorAll(selectors.join(",")).filter((it) => typeof it.role === "string" && roles.includes(it.role));
-      const grouped = groupBy(elements, (it) => it.role);
-      for (const nodes of Object.values(grouped)) {
-        if (nodes.length <= 1) {
-          continue;
-        }
-        const entries = nodes.map((it) => getTextEntryFromElement(document, it));
-        const filteredEntries = entries.filter(isExcluded);
-        for (const entry of filteredEntries) {
-          if (entry.text instanceof DynamicValue) {
-            continue;
-          }
-          const dup = entries.filter((it) => it.text === entry.text).length > 1;
-          if (!entry.text || dup) {
-            const message = `Landmarks must have a non-empty and unique accessible name (aria-label or aria-labelledby)`;
-            const location = entry.location;
-            this.report({
-              node: entry.node,
-              message,
-              location
-            });
-          }
-        }
+  validateOrder(node, tokens, order) {
+    const indicies = order.map((it) => expectedOrder.indexOf(it));
+    for (let i = 0; i < indicies.length - 1; i++) {
+      if (indicies[0] > indicies[i + 1]) {
+        const context = {
+          msg: 2 /* InvalidOrder */,
+          /* eslint-disable @typescript-eslint/no-non-null-assertion -- it must be present of it wouldn't be found */
+          first: tokens.item(i),
+          second: tokens.item(i + 1)
+          /* eslint-enable @typescript-eslint/no-non-null-assertion */
+        };
+        this.report({
+          node,
+          message: getTerminalMessage(context),
+          location: tokens.location(i + 1),
+          context
+        });
       }
-    });
+    }
+  }
+  validateControlGroup(node, tokens, fieldTokens) {
+    const numFields = fieldTokens.filter(Boolean).length;
+    if (numFields === 0) {
+      return;
+    }
+    if (!node.is("input")) {
+      return;
+    }
+    const attr = node.getAttribute("type");
+    const type = (attr == null ? void 0 : attr.value) ?? "text";
+    if (type instanceof DynamicValue) {
+      return;
+    }
+    const controlGroups = getControlGroups(type);
+    const fieldIndex = fieldTokens.indexOf(true);
+    const fieldToken = tokens.item(fieldIndex);
+    const fieldGroup = fieldNameGroup[fieldToken];
+    if (!controlGroups.includes(fieldGroup)) {
+      const context = {
+        msg: 1 /* InvalidValue */,
+        type,
+        value: fieldToken,
+        what: `<input type="${type}">`
+      };
+      this.report({
+        node,
+        message: getTerminalMessage(context),
+        location: tokens.location(fieldIndex),
+        context
+      });
+    }
   }
 }
 
-const defaults$4 = {
-  ignoreCase: false,
-  requireSemicolon: true
+const defaults$3 = {
+  relaxed: false
 };
-const regexp$1 = /&(?:[a-z0-9]+|#x?[0-9a-f]+)(;|[^a-z0-9]|$)/gi;
-const lowercaseEntities = elements.entities.map((it) => it.toLowerCase());
-function isNumerical(entity) {
-  return entity.startsWith("&#");
-}
-function getLocation(location, entity, match) {
-  const index = match.index ?? 0;
-  return sliceLocation(location, index, index + entity.length);
-}
-function getDescription(context, options) {
-  const url = "https://html.spec.whatwg.org/multipage/named-characters.html";
-  let message;
-  if (context.terminated) {
-    message = `Unrecognized character reference \`${context.entity}\`.`;
-  } else {
-    message = `Character reference \`${context.entity}\` must be terminated by a semicolon.`;
-  }
-  return [
-    message,
-    `HTML5 defines a set of [valid character references](${url}) but this is not a valid one.`,
-    "",
-    "Ensure that:",
-    "",
-    "1. The character is one of the listed names.",
-    ...options.ignoreCase ? [] : ["1. The case is correct (names are case sensitive)."],
-    ...options.requireSemicolon ? ["1. The name is terminated with a `;`."] : []
-  ].join("\n");
-}
-class UnknownCharReference extends Rule {
+class ValidID extends Rule {
   constructor(options) {
-    super({ ...defaults$4, ...options });
+    super({ ...defaults$3, ...options });
   }
   static schema() {
     return {
-      ignoreCase: {
-        type: "boolean"
-      },
-      requireSemicolon: {
+      relaxed: {
         type: "boolean"
       }
     };
   }
   documentation(context) {
+    const { relaxed } = this.options;
+    const message = this.messages[context].replace("id", "ID").replace(/^(.)/, (m) => m.toUpperCase());
+    const relaxedDescription = relaxed ? [] : [
+      "  - ID must begin with a letter",
+      "  - ID must only contain letters, digits, `-` and `_`"
+    ];
     return {
-      description: getDescription(context, this.options),
-      url: "https://html-validate.org/rules/unrecognized-char-ref.html"
+      description: [
+        `${message}.`,
+        "",
+        "Under the current configuration the following rules are applied:",
+        "",
+        "  - ID must not be empty",
+        "  - ID must not contain any whitespace characters",
+        ...relaxedDescription
+      ].join("\n"),
+      url: "https://html-validate.org/rules/valid-id.html"
     };
   }
   setup() {
-    this.on("element:ready", (event) => {
-      const node = event.target;
-      for (const child of node.childNodes) {
-        if (child.nodeType !== NodeType.TEXT_NODE) {
-          continue;
-        }
-        this.findCharacterReferences(node, child.textContent, child.location, {
-          isAttribute: false
-        });
+    this.on("attr", this.isRelevant, (event) => {
+      const { value } = event;
+      if (value === null || value instanceof DynamicValue) {
+        return;
       }
-    });
-    this.on("attr", (event) => {
-      if (!event.value) {
+      if (value === "") {
+        const context = 1 /* EMPTY */;
+        this.report(event.target, this.messages[context], event.location, context);
         return;
       }
-      this.findCharacterReferences(event.target, event.value.toString(), event.valueLocation, {
-        isAttribute: true
-      });
+      if (value.match(/\s/)) {
+        const context = 2 /* WHITESPACE */;
+        this.report(event.target, this.messages[context], event.valueLocation, context);
+        return;
+      }
+      const { relaxed } = this.options;
+      if (relaxed) {
+        return;
+      }
+      if (value.match(/^[^\p{L}]/u)) {
+        const context = 3 /* LEADING_CHARACTER */;
+        this.report(event.target, this.messages[context], event.valueLocation, context);
+        return;
+      }
+      if (value.match(/[^\p{L}\p{N}_-]/u)) {
+        const context = 4 /* DISALLOWED_CHARACTER */;
+        this.report(event.target, this.messages[context], event.valueLocation, context);
+      }
     });
   }
-  get entities() {
-    if (this.options.ignoreCase) {
-      return lowercaseEntities;
-    } else {
-      return elements.entities;
-    }
-  }
-  findCharacterReferences(node, text, location, { isAttribute }) {
-    const isQuerystring = isAttribute && text.includes("?");
-    for (const match of this.getMatches(text)) {
-      this.validateCharacterReference(node, location, match, { isQuerystring });
-    }
-  }
-  validateCharacterReference(node, location, foobar, { isQuerystring }) {
-    const { requireSemicolon } = this.options;
-    const { match, entity, raw, terminated } = foobar;
-    if (isNumerical(entity)) {
-      return;
-    }
-    if (isQuerystring && !terminated) {
-      return;
-    }
-    const found = this.entities.includes(entity);
-    if (found && (terminated || !requireSemicolon)) {
-      return;
-    }
-    if (found && !terminated) {
-      const entityLocation2 = getLocation(location, entity, match);
-      const message2 = `Character reference "{{ entity }}" must be terminated by a semicolon`;
-      const context2 = {
-        entity: raw,
-        terminated: false
-      };
-      this.report(node, message2, entityLocation2, context2);
-      return;
-    }
-    const entityLocation = getLocation(location, entity, match);
-    const message = `Unrecognized character reference "{{ entity }}"`;
-    const context = {
-      entity: raw,
-      terminated: true
+  get messages() {
+    return {
+      [1 /* EMPTY */]: "element id must not be empty",
+      [2 /* WHITESPACE */]: "element id must not contain whitespace",
+      [3 /* LEADING_CHARACTER */]: "element id must begin with a letter",
+      [4 /* DISALLOWED_CHARACTER */]: "element id must only contain letters, digits, dash and underscore characters"
     };
-    this.report(node, message, entityLocation, context);
   }
-  *getMatches(text) {
-    let match;
-    do {
-      match = regexp$1.exec(text);
-      if (match) {
-        const terminator = match[1];
-        const terminated = terminator === ";";
-        const needSlice = terminator !== ";" && terminator.length > 0;
-        const entity = needSlice ? match[0].slice(0, -1) : match[0];
-        if (this.options.ignoreCase) {
-          yield { match, entity: entity.toLowerCase(), raw: entity, terminated };
-        } else {
-          yield { match, entity, raw: entity, terminated };
-        }
+  isRelevant(event) {
+    return event.key === "id";
+  }
+}
+
+class VoidContent extends Rule {
+  documentation(tagName) {
+    const doc = {
+      description: "HTML void elements cannot have any content and must not have content or end tag.",
+      url: "https://html-validate.org/rules/void-content.html"
+    };
+    if (tagName) {
+      doc.description = `<${tagName}> is a void element and must not have content or end tag.`;
+    }
+    return doc;
+  }
+  setup() {
+    this.on("tag:end", (event) => {
+      const node = event.target;
+      if (!node) {
+        return;
       }
-    } while (match);
+      if (!node.voidElement) {
+        return;
+      }
+      if (node.closed === NodeClosed.EndTag) {
+        this.report(
+          null,
+          `End tag for <${node.tagName}> must be omitted`,
+          node.location,
+          node.tagName
+        );
+      }
+    });
   }
 }
 
-const expectedOrder = ["section", "hint", "contact", "field1", "field2", "webauthn"];
-const fieldNames1 = [
-  "name",
-  "honorific-prefix",
-  "given-name",
-  "additional-name",
-  "family-name",
-  "honorific-suffix",
-  "nickname",
-  "username",
-  "new-password",
-  "current-password",
-  "one-time-code",
-  "organization-title",
-  "organization",
-  "street-address",
-  "address-line1",
-  "address-line2",
-  "address-line3",
-  "address-level4",
-  "address-level3",
-  "address-level2",
-  "address-level1",
-  "country",
-  "country-name",
-  "postal-code",
-  "cc-name",
-  "cc-given-name",
-  "cc-additional-name",
-  "cc-family-name",
-  "cc-number",
-  "cc-exp",
-  "cc-exp-month",
-  "cc-exp-year",
-  "cc-csc",
-  "cc-type",
-  "transaction-currency",
-  "transaction-amount",
-  "language",
-  "bday",
-  "bday-day",
-  "bday-month",
-  "bday-year",
-  "sex",
-  "url",
-  "photo"
-];
-const fieldNames2 = [
-  "tel",
-  "tel-country-code",
-  "tel-national",
-  "tel-area-code",
-  "tel-local",
-  "tel-local-prefix",
-  "tel-local-suffix",
-  "tel-extension",
-  "email",
-  "impp"
-];
-const fieldNameGroup = {
-  name: "text",
-  "honorific-prefix": "text",
-  "given-name": "text",
-  "additional-name": "text",
-  "family-name": "text",
-  "honorific-suffix": "text",
-  nickname: "text",
-  username: "username",
-  "new-password": "password",
-  "current-password": "password",
-  "one-time-code": "password",
-  "organization-title": "text",
-  organization: "text",
-  "street-address": "multiline",
-  "address-line1": "text",
-  "address-line2": "text",
-  "address-line3": "text",
-  "address-level4": "text",
-  "address-level3": "text",
-  "address-level2": "text",
-  "address-level1": "text",
-  country: "text",
-  "country-name": "text",
-  "postal-code": "text",
-  "cc-name": "text",
-  "cc-given-name": "text",
-  "cc-additional-name": "text",
-  "cc-family-name": "text",
-  "cc-number": "text",
-  "cc-exp": "month",
-  "cc-exp-month": "numeric",
-  "cc-exp-year": "numeric",
-  "cc-csc": "text",
-  "cc-type": "text",
-  "transaction-currency": "text",
-  "transaction-amount": "numeric",
-  language: "text",
-  bday: "date",
-  "bday-day": "numeric",
-  "bday-month": "numeric",
-  "bday-year": "numeric",
-  sex: "text",
-  url: "url",
-  photo: "url",
-  tel: "tel",
-  "tel-country-code": "text",
-  "tel-national": "text",
-  "tel-area-code": "text",
-  "tel-local": "text",
-  "tel-local-prefix": "text",
-  "tel-local-suffix": "text",
-  "tel-extension": "text",
-  email: "username",
-  impp: "url"
+const defaults$2 = {
+  style: "omit"
 };
-const disallowedInputTypes = ["checkbox", "radio", "file", "submit", "image", "reset", "button"];
-function matchSection(token) {
-  return token.startsWith("section-");
-}
-function matchHint(token) {
-  return token === "shipping" || token === "billing";
-}
-function matchFieldNames1(token) {
-  return fieldNames1.includes(token);
-}
-function matchContact(token) {
-  const haystack = ["home", "work", "mobile", "fax", "pager"];
-  return haystack.includes(token);
-}
-function matchFieldNames2(token) {
-  return fieldNames2.includes(token);
-}
-function matchWebauthn(token) {
-  return token === "webauthn";
-}
-function matchToken(token) {
-  if (matchSection(token)) {
-    return "section";
+class VoidStyle extends Rule {
+  constructor(options) {
+    super({ ...defaults$2, ...options });
+    this.style = parseStyle(this.options.style);
   }
-  if (matchHint(token)) {
-    return "hint";
+  static schema() {
+    return {
+      style: {
+        enum: ["omit", "selfclose", "selfclosing"],
+        type: "string"
+      }
+    };
   }
-  if (matchFieldNames1(token)) {
-    return "field1";
+  documentation(context) {
+    const [desc, end] = styleDescription(context.style);
+    return {
+      description: `The current configuration requires void elements to ${desc}, use <${context.tagName}${end}> instead.`,
+      url: "https://html-validate.org/rules/void-style.html"
+    };
   }
-  if (matchFieldNames2(token)) {
-    return "field2";
+  setup() {
+    this.on("tag:end", (event) => {
+      const active = event.previous;
+      if (active.meta) {
+        this.validateActive(active);
+      }
+    });
   }
-  if (matchContact(token)) {
-    return "contact";
+  validateActive(node) {
+    if (!node.voidElement) {
+      return;
+    }
+    if (this.shouldBeOmitted(node)) {
+      this.reportError(
+        node,
+        `Expected omitted end tag <${node.tagName}> instead of self-closing element <${node.tagName}/>`
+      );
+    }
+    if (this.shouldBeSelfClosed(node)) {
+      this.reportError(
+        node,
+        `Expected self-closing element <${node.tagName}/> instead of omitted end-tag <${node.tagName}>`
+      );
+    }
   }
-  if (matchWebauthn(token)) {
-    return "webauthn";
+  reportError(node, message) {
+    const context = {
+      style: this.style,
+      tagName: node.tagName
+    };
+    super.report(node, message, null, context);
+  }
+  shouldBeOmitted(node) {
+    return this.style === 1 /* AlwaysOmit */ && node.closed === NodeClosed.VoidSelfClosed;
+  }
+  shouldBeSelfClosed(node) {
+    return this.style === 2 /* AlwaysSelfclose */ && node.closed === NodeClosed.VoidOmitted;
   }
-  return null;
 }
-function getControlGroups(type) {
-  const allGroups = [
-    "text",
-    "multiline",
-    "password",
-    "url",
-    "username",
-    "tel",
-    "numeric",
-    "month",
-    "date"
-  ];
-  const mapping = {
-    hidden: allGroups,
-    text: allGroups.filter((it) => it !== "multiline"),
-    search: allGroups.filter((it) => it !== "multiline"),
-    password: ["password"],
-    url: ["url"],
-    email: ["username"],
-    tel: ["tel"],
-    number: ["numeric"],
-    month: ["month"],
-    date: ["date"]
-  };
-  const groups = mapping[type];
-  if (groups) {
-    return groups;
+function parseStyle(name) {
+  switch (name) {
+    case "omit":
+      return 1 /* AlwaysOmit */;
+    case "selfclose":
+    case "selfclosing":
+      return 2 /* AlwaysSelfclose */;
+    default:
+      throw new Error(`Invalid style "${name}" for "void-style" rule`);
   }
-  return [];
 }
-function isDisallowedType(node, type) {
-  if (!node.is("input")) {
-    return false;
+function styleDescription(style) {
+  switch (style) {
+    case 1 /* AlwaysOmit */:
+      return ["omit end tag", ""];
+    case 2 /* AlwaysSelfclose */:
+      return ["be self-closed", "/"];
+    default:
+      throw new Error(`Unknown style`);
   }
-  return disallowedInputTypes.includes(type);
 }
-function getTerminalMessage(context) {
-  switch (context.msg) {
-    case 0 /* InvalidAttribute */:
-      return "autocomplete attribute cannot be used on {{ what }}";
-    case 1 /* InvalidValue */:
-      return '"{{ value }}" cannot be used on {{ what }}';
-    case 2 /* InvalidOrder */:
-      return '"{{ second }}" must appear before "{{ first }}"';
-    case 3 /* InvalidToken */:
-      return '"{{ token }}" is not a valid autocomplete token or field name';
-    case 4 /* InvalidCombination */:
-      return '"{{ second }}" cannot be combined with "{{ first }}"';
-    case 5 /* MissingField */:
-      return "autocomplete attribute is missing field name";
+
+class H30 extends Rule {
+  documentation() {
+    return {
+      description: "WCAG 2.1 requires each `<a href>` anchor link to have a text describing the purpose of the link using either plain text or an `<img>` with the `alt` attribute set.",
+      url: "https://html-validate.org/rules/wcag/h30.html"
+    };
   }
-}
-function getMarkdownMessage(context) {
-  switch (context.msg) {
-    case 0 /* InvalidAttribute */:
-      return [
-        `\`autocomplete\` attribute cannot be used on \`${context.what}\``,
-        "",
-        "The following input types cannot use the `autocomplete` attribute:",
-        "",
-        ...disallowedInputTypes.map((it) => `- \`${it}\``)
-      ].join("\n");
-    case 1 /* InvalidValue */: {
-      const message = `\`"${context.value}"\` cannot be used on \`${context.what}\``;
-      if (context.type === "form") {
-        return [
-          message,
-          "",
-          'The `<form>` element can only use the values `"on"` and `"off"`.'
-        ].join("\n");
-      }
-      if (context.type === "hidden") {
-        return [
-          message,
-          "",
-          '`<input type="hidden">` cannot use the values `"on"` and `"off"`.'
-        ].join("\n");
+  setup() {
+    this.on("dom:ready", (event) => {
+      const links = event.document.getElementsByTagName("a");
+      for (const link of links) {
+        if (!link.hasAttribute("href")) {
+          continue;
+        }
+        if (!inAccessibilityTree(link)) {
+          continue;
+        }
+        const textClassification = classifyNodeText(link, { ignoreHiddenRoot: true });
+        if (textClassification !== TextClassification.EMPTY_TEXT) {
+          continue;
+        }
+        const images = link.querySelectorAll("img");
+        if (images.some((image) => hasAltText(image))) {
+          continue;
+        }
+        const labels = link.querySelectorAll("[aria-label]");
+        if (hasAriaLabel(link) || labels.some((cur) => hasAriaLabel(cur))) {
+          continue;
+        }
+        this.report(link, "Anchor link must have a text describing its purpose");
       }
-      const controlGroups = getControlGroups(context.type);
-      const currentGroup = fieldNameGroup[context.value];
-      return [
-        message,
-        "",
-        `\`${context.what}\` allows autocomplete fields from the following group${controlGroups.length > 1 ? "s" : ""}:`,
-        "",
-        ...controlGroups.map((it) => `- ${it}`),
-        "",
-        `The field \`"${context.value}"\` belongs to the group /${currentGroup}/ which cannot be used with this input type.`
-      ].join("\n");
-    }
-    case 2 /* InvalidOrder */:
-      return [
-        `\`"${context.second}"\` must appear before \`"${context.first}"\``,
-        "",
-        "The autocomplete tokens must appear in the following order:",
-        "",
-        "- Optional section name (`section-` prefix).",
-        "- Optional `shipping` or `billing` token.",
-        "- Optional `home`, `work`, `mobile`, `fax` or `pager` token (for fields supporting it).",
-        "- Field name",
-        "- Optional `webauthn` token."
-      ].join("\n");
-    case 3 /* InvalidToken */:
-      return `\`"${context.token}"\` is not a valid autocomplete token or field name`;
-    case 4 /* InvalidCombination */:
-      return `\`"${context.second}"\` cannot be combined with \`"${context.first}"\``;
-    case 5 /* MissingField */:
-      return "Autocomplete attribute is missing field name";
+    });
   }
 }
-class ValidAutocomplete extends Rule {
-  documentation(context) {
+
+class H32 extends Rule {
+  documentation() {
     return {
-      description: getMarkdownMessage(context),
-      url: "https://html-validate.org/rules/valid-autocomplete.html"
+      description: "WCAG 2.1 requires each `<form>` element to have at least one submit button.",
+      url: "https://html-validate.org/rules/wcag/h32.html"
     };
   }
   setup() {
+    const formTags = this.getTagsWithProperty("form");
+    const formSelector = formTags.join(",");
     this.on("dom:ready", (event) => {
       const { document } = event;
-      const elements = document.querySelectorAll("[autocomplete]");
-      for (const element of elements) {
-        const autocomplete = element.getAttribute("autocomplete");
-        if (autocomplete.value === null || autocomplete.value instanceof DynamicValue) {
+      const forms = document.querySelectorAll(formSelector);
+      for (const form of forms) {
+        if (hasNestedSubmit(form)) {
           continue;
         }
-        const location = autocomplete.valueLocation;
-        const value = autocomplete.value.toLowerCase();
-        const tokens = new DOMTokenList(value, location);
-        if (tokens.length === 0) {
+        if (hasAssociatedSubmit(document, form)) {
           continue;
         }
-        this.validate(element, value, tokens, autocomplete.keyLocation, location);
+        this.report(form, `<${form.tagName}> element must have a submit button`);
       }
     });
   }
-  validate(node, value, tokens, keyLocation, valueLocation) {
-    switch (node.tagName) {
-      case "form":
-        this.validateFormAutocomplete(node, value, valueLocation);
-        break;
-      case "input":
-      case "textarea":
-      case "select":
-        this.validateControlAutocomplete(node, tokens, keyLocation);
-        break;
-    }
-  }
-  validateControlAutocomplete(node, tokens, keyLocation) {
-    const type = node.getAttributeValue("type") ?? "text";
-    const mantle = type !== "hidden" ? "expectation" : "anchor";
-    if (isDisallowedType(node, type)) {
-      const context = {
-        msg: 0 /* InvalidAttribute */,
-        what: `<input type="${type}">`
-      };
-      this.report({
-        node,
-        message: getTerminalMessage(context),
-        location: keyLocation,
-        context
-      });
-      return;
-    }
-    if (tokens.includes("on") || tokens.includes("off")) {
-      this.validateOnOff(node, mantle, tokens);
-      return;
-    }
-    this.validateTokens(node, tokens, keyLocation);
+}
+function isSubmit(node) {
+  const type = node.getAttribute("type");
+  return Boolean(!type || type.valueMatches(/submit|image/));
+}
+function isAssociated(id, node) {
+  const form = node.getAttribute("form");
+  return Boolean(form == null ? void 0 : form.valueMatches(id, true));
+}
+function hasNestedSubmit(form) {
+  const matches = form.querySelectorAll("button,input").filter(isSubmit).filter((node) => !node.hasAttribute("form"));
+  return matches.length > 0;
+}
+function hasAssociatedSubmit(document, form) {
+  const { id } = form;
+  if (!id) {
+    return false;
   }
-  validateFormAutocomplete(node, value, location) {
-    const trimmed = value.trim();
-    if (["on", "off"].includes(trimmed)) {
-      return;
-    }
-    const context = {
-      msg: 1 /* InvalidValue */,
-      type: "form",
-      value: trimmed,
-      what: "<form>"
+  const matches = document.querySelectorAll("button[form],input[form]").filter(isSubmit).filter((node) => isAssociated(id, node));
+  return matches.length > 0;
+}
+
+class H36 extends Rule {
+  documentation() {
+    return {
+      description: [
+        "WCAG 2.1 requires all images used as submit buttons to have a non-empty textual description using the `alt` attribute.",
+        'The alt text cannot be empty (`alt=""`).'
+      ].join("\n"),
+      url: "https://html-validate.org/rules/wcag/h36.html"
     };
-    this.report({
-      node,
-      message: getTerminalMessage(context),
-      location,
-      context
-    });
   }
-  validateOnOff(node, mantle, tokens) {
-    const index = tokens.findIndex((it) => it === "on" || it === "off");
-    const value = tokens.item(index);
-    const location = tokens.location(index);
-    if (tokens.length > 1) {
-      const context = {
-        msg: 4 /* InvalidCombination */,
-        /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- it must be present of it wouldn't be found */
-        first: tokens.item(index > 0 ? 0 : 1),
-        second: value
-      };
-      this.report({
-        node,
-        message: getTerminalMessage(context),
-        location,
-        context
-      });
-    }
-    switch (mantle) {
-      case "expectation":
-        return;
-      case "anchor": {
-        const context = {
-          msg: 1 /* InvalidValue */,
-          type: "hidden",
-          value,
-          what: `<input type="hidden">`
-        };
-        this.report({
-          node,
-          message: getTerminalMessage(context),
-          location: tokens.location(0),
-          context
-        });
+  setup() {
+    this.on("tag:end", (event) => {
+      const node = event.previous;
+      if (node.tagName !== "input")
+        return;
+      if (node.getAttributeValue("type") !== "image") {
+        return;
       }
-    }
-  }
-  validateTokens(node, tokens, keyLocation) {
-    const order = [];
-    for (const { item, location } of tokens.iterator()) {
-      const tokenType = matchToken(item);
-      if (tokenType) {
-        order.push(tokenType);
-      } else {
-        const context = {
-          msg: 3 /* InvalidToken */,
-          token: item
-        };
-        this.report({
-          node,
-          message: getTerminalMessage(context),
-          location,
-          context
-        });
+      if (!inAccessibilityTree(node)) {
         return;
       }
-    }
-    const fieldTokens = order.map((it) => it === "field1" || it === "field2");
-    this.validateFieldPresence(node, tokens, fieldTokens, keyLocation);
-    this.validateContact(node, tokens, order);
-    this.validateOrder(node, tokens, order);
-    this.validateControlGroup(node, tokens, fieldTokens);
-  }
-  /**
-   * Ensure that exactly one field name is present from the two field lists.
-   */
-  validateFieldPresence(node, tokens, fieldTokens, keyLocation) {
-    const numFields = fieldTokens.filter(Boolean).length;
-    if (numFields === 0) {
-      const context = {
-        msg: 5 /* MissingField */
-      };
-      this.report({
-        node,
-        message: getTerminalMessage(context),
-        location: keyLocation,
-        context
-      });
-    } else if (numFields > 1) {
-      const a = fieldTokens.indexOf(true);
-      const b = fieldTokens.lastIndexOf(true);
-      const context = {
-        msg: 4 /* InvalidCombination */,
-        /* eslint-disable @typescript-eslint/no-non-null-assertion -- it must be present of it wouldn't be found */
-        first: tokens.item(a),
-        second: tokens.item(b)
-        /* eslint-enable @typescript-eslint/no-non-null-assertion */
-      };
-      this.report({
-        node,
-        message: getTerminalMessage(context),
-        location: tokens.location(b),
-        context
-      });
-    }
-  }
-  /**
-   * Ensure contact token is only used with field names from the second list.
-   */
-  validateContact(node, tokens, order) {
-    if (order.includes("contact") && order.includes("field1")) {
-      const a = order.indexOf("field1");
-      const b = order.indexOf("contact");
-      const context = {
-        msg: 4 /* InvalidCombination */,
-        /* eslint-disable @typescript-eslint/no-non-null-assertion -- it must be present of it wouldn't be found */
-        first: tokens.item(a),
-        second: tokens.item(b)
-        /* eslint-enable @typescript-eslint/no-non-null-assertion */
-      };
-      this.report({
-        node,
-        message: getTerminalMessage(context),
-        location: tokens.location(b),
-        context
-      });
-    }
-  }
-  validateOrder(node, tokens, order) {
-    const indicies = order.map((it) => expectedOrder.indexOf(it));
-    for (let i = 0; i < indicies.length - 1; i++) {
-      if (indicies[0] > indicies[i + 1]) {
-        const context = {
-          msg: 2 /* InvalidOrder */,
-          /* eslint-disable @typescript-eslint/no-non-null-assertion -- it must be present of it wouldn't be found */
-          first: tokens.item(i),
-          second: tokens.item(i + 1)
-          /* eslint-enable @typescript-eslint/no-non-null-assertion */
-        };
+      if (!hasAltText(node)) {
+        const message = "image used as submit button must have non-empty alt text";
+        const alt = node.getAttribute("alt");
         this.report({
           node,
-          message: getTerminalMessage(context),
-          location: tokens.location(i + 1),
-          context
+          message,
+          location: alt ? alt.keyLocation : node.location
         });
       }
-    }
-  }
-  validateControlGroup(node, tokens, fieldTokens) {
-    const numFields = fieldTokens.filter(Boolean).length;
-    if (numFields === 0) {
-      return;
-    }
-    if (!node.is("input")) {
-      return;
-    }
-    const attr = node.getAttribute("type");
-    const type = (attr == null ? void 0 : attr.value) ?? "text";
-    if (type instanceof DynamicValue) {
-      return;
-    }
-    const controlGroups = getControlGroups(type);
-    const fieldIndex = fieldTokens.indexOf(true);
-    const fieldToken = tokens.item(fieldIndex);
-    const fieldGroup = fieldNameGroup[fieldToken];
-    if (!controlGroups.includes(fieldGroup)) {
-      const context = {
-        msg: 1 /* InvalidValue */,
-        type,
-        value: fieldToken,
-        what: `<input type="${type}">`
-      };
-      this.report({
-        node,
-        message: getTerminalMessage(context),
-        location: tokens.location(fieldIndex),
-        context
-      });
-    }
+    });
   }
 }
 
-const defaults$3 = {
-  relaxed: false
+const defaults$1 = {
+  allowEmpty: true,
+  alias: []
 };
-class ValidID extends Rule {
+class H37 extends Rule {
   constructor(options) {
-    super({ ...defaults$3, ...options });
+    super({ ...defaults$1, ...options });
+    if (!Array.isArray(this.options.alias)) {
+      this.options.alias = [this.options.alias];
+    }
   }
   static schema() {
     return {
-      relaxed: {
+      alias: {
+        anyOf: [
+          {
+            items: {
+              type: "string"
+            },
+            type: "array"
+          },
+          {
+            type: "string"
+          }
+        ]
+      },
+      allowEmpty: {
         type: "boolean"
       }
     };
   }
-  documentation(context) {
-    const { relaxed } = this.options;
-    const message = this.messages[context].replace("id", "ID").replace(/^(.)/, (m) => m.toUpperCase());
-    const relaxedDescription = relaxed ? [] : [
-      "  - ID must begin with a letter",
-      "  - ID must only contain letters, digits, `-` and `_`"
-    ];
+  documentation() {
     return {
-      description: [
-        `${message}.`,
-        "",
-        "Under the current configuration the following rules are applied:",
-        "",
-        "  - ID must not be empty",
-        "  - ID must not contain any whitespace characters",
-        ...relaxedDescription
-      ].join("\n"),
-      url: "https://html-validate.org/rules/valid-id.html"
+      description: "Both HTML5 and WCAG 2.0 requires images to have a alternative text for each image.",
+      url: "https://html-validate.org/rules/wcag/h37.html"
     };
   }
   setup() {
-    this.on("attr", this.isRelevant, (event) => {
-      const { value } = event;
-      if (value === null || value instanceof DynamicValue) {
-        return;
-      }
-      if (value === "") {
-        const context = 1 /* EMPTY */;
-        this.report(event.target, this.messages[context], event.location, context);
-        return;
-      }
-      if (value.match(/\s/)) {
-        const context = 2 /* WHITESPACE */;
-        this.report(event.target, this.messages[context], event.valueLocation, context);
-        return;
-      }
-      const { relaxed } = this.options;
-      if (relaxed) {
-        return;
-      }
-      if (value.match(/^[^\p{L}]/u)) {
-        const context = 3 /* LEADING_CHARACTER */;
-        this.report(event.target, this.messages[context], event.valueLocation, context);
-        return;
-      }
-      if (value.match(/[^\p{L}\p{N}_-]/u)) {
-        const context = 4 /* DISALLOWED_CHARACTER */;
-        this.report(event.target, this.messages[context], event.valueLocation, context);
+    this.on("dom:ready", (event) => {
+      const { document } = event;
+      const nodes = document.querySelectorAll("img");
+      for (const node of nodes) {
+        this.validateNode(node);
       }
     });
   }
-  get messages() {
-    return {
-      [1 /* EMPTY */]: "element id must not be empty",
-      [2 /* WHITESPACE */]: "element id must not contain whitespace",
-      [3 /* LEADING_CHARACTER */]: "element id must begin with a letter",
-      [4 /* DISALLOWED_CHARACTER */]: "element id must only contain letters, digits, dash and underscore characters"
-    };
-  }
-  isRelevant(event) {
-    return event.key === "id";
+  validateNode(node) {
+    if (!inAccessibilityTree(node)) {
+      return;
+    }
+    if (Boolean(node.getAttributeValue("alt")) || Boolean(node.hasAttribute("alt") && this.options.allowEmpty)) {
+      return;
+    }
+    for (const attr of this.options.alias) {
+      if (node.getAttribute(attr)) {
+        return;
+      }
+    }
+    const tag = node.annotatedName;
+    if (node.hasAttribute("alt")) {
+      const attr = node.getAttribute("alt");
+      this.report(node, `${tag} cannot have empty "alt" attribute`, attr.keyLocation);
+    } else {
+      this.report(node, `${tag} is missing required "alt" attribute`, node.location);
+    }
   }
 }
 
-class VoidContent extends Rule {
-  documentation(tagName) {
-    const doc = {
-      description: "HTML void elements cannot have any content and must not have content or end tag.",
-      url: "https://html-validate.org/rules/void-content.html"
+var _a;
+const { enum: validScopes } = (_a = elements.html5.th.attributes) == null ? void 0 : _a.scope;
+const joinedScopes = utils_naturalJoin.naturalJoin(validScopes);
+class H63 extends Rule {
+  documentation() {
+    return {
+      description: "H63: Using the scope attribute to associate header cells and data cells in data tables",
+      url: "https://html-validate.org/rules/wcag/h63.html"
     };
-    if (tagName) {
-      doc.description = `<${tagName}> is a void element and must not have content or end tag.`;
-    }
-    return doc;
   }
   setup() {
-    this.on("tag:end", (event) => {
+    this.on("tag:ready", (event) => {
       const node = event.target;
-      if (!node) {
+      if (node.tagName !== "th") {
         return;
       }
-      if (!node.voidElement) {
+      const scope = node.getAttribute("scope");
+      const value = scope == null ? void 0 : scope.value;
+      if (value instanceof DynamicValue) {
         return;
       }
-      if (node.closed === NodeClosed.EndTag) {
-        this.report(
-          null,
-          `End tag for <${node.tagName}> must be omitted`,
-          node.location,
-          node.tagName
-        );
+      if (value && validScopes.includes(value)) {
+        return;
       }
+      const message = `<th> element must have a valid scope attribute: ${joinedScopes}`;
+      const location = (scope == null ? void 0 : scope.valueLocation) ?? (scope == null ? void 0 : scope.keyLocation) ?? node.location;
+      this.report(node, message, location);
     });
   }
 }
 
-const defaults$2 = {
-  style: "omit"
-};
-class VoidStyle extends Rule {
-  constructor(options) {
-    super({ ...defaults$2, ...options });
-    this.style = parseStyle(this.options.style);
-  }
-  static schema() {
-    return {
-      style: {
-        enum: ["omit", "selfclose", "selfclosing"],
-        type: "string"
-      }
-    };
-  }
-  documentation(context) {
-    const [desc, end] = styleDescription(context.style);
+class H67 extends Rule {
+  documentation() {
     return {
-      description: `The current configuration requires void elements to ${desc}, use <${context.tagName}${end}> instead.`,
-      url: "https://html-validate.org/rules/void-style.html"
+      description: "A decorative image cannot have a title attribute. Either remove `title` or add a descriptive `alt` text.",
+      url: "https://html-validate.org/rules/wcag/h67.html"
     };
   }
   setup() {
     this.on("tag:end", (event) => {
-      const active = event.previous;
-      if (active.meta) {
-        this.validateActive(active);
+      const node = event.target;
+      if (!node || node.tagName !== "img") {
+        return;
+      }
+      const title = node.getAttribute("title");
+      if (!title || title.value === "") {
+        return;
+      }
+      const alt = node.getAttributeValue("alt");
+      if (alt && alt !== "") {
+        return;
       }
+      this.report(node, "<img> with empty alt text cannot have title attribute", title.keyLocation);
     });
   }
-  validateActive(node) {
-    if (!node.voidElement) {
-      return;
-    }
-    if (this.shouldBeOmitted(node)) {
-      this.reportError(
-        node,
-        `Expected omitted end tag <${node.tagName}> instead of self-closing element <${node.tagName}/>`
-      );
-    }
-    if (this.shouldBeSelfClosed(node)) {
-      this.reportError(
-        node,
-        `Expected self-closing element <${node.tagName}/> instead of omitted end-tag <${node.tagName}>`
-      );
-    }
-  }
-  reportError(node, message) {
-    const context = {
-      style: this.style,
-      tagName: node.tagName
-    };
-    super.report(node, message, null, context);
-  }
-  shouldBeOmitted(node) {
-    return this.style === 1 /* AlwaysOmit */ && node.closed === NodeClosed.VoidSelfClosed;
-  }
-  shouldBeSelfClosed(node) {
-    return this.style === 2 /* AlwaysSelfclose */ && node.closed === NodeClosed.VoidOmitted;
-  }
-}
-function parseStyle(name) {
-  switch (name) {
-    case "omit":
-      return 1 /* AlwaysOmit */;
-    case "selfclose":
-    case "selfclosing":
-      return 2 /* AlwaysSelfclose */;
-    default:
-      throw new Error(`Invalid style "${name}" for "void-style" rule`);
-  }
-}
-function styleDescription(style) {
-  switch (style) {
-    case 1 /* AlwaysOmit */:
-      return ["omit end tag", ""];
-    case 2 /* AlwaysSelfclose */:
-      return ["be self-closed", "/"];
-    default:
-      throw new Error(`Unknown style`);
-  }
 }
 
-class H30 extends Rule {
+class H71 extends Rule {
   documentation() {
     return {
-      description: "WCAG 2.1 requires each `<a href>` anchor link to have a text describing the purpose of the link using either plain text or an `<img>` with the `alt` attribute set.",
-      url: "https://html-validate.org/rules/wcag/h30.html"
+      description: "H71: Providing a description for groups of form controls using fieldset and legend elements",
+      url: "https://html-validate.org/rules/wcag/h71.html"
     };
   }
   setup() {
     this.on("dom:ready", (event) => {
-      const links = event.document.getElementsByTagName("a");
-      for (const link of links) {
-        if (!link.hasAttribute("href")) {
-          continue;
-        }
-        if (!inAccessibilityTree(link)) {
-          continue;
-        }
-        const textClassification = classifyNodeText(link, { ignoreHiddenRoot: true });
-        if (textClassification !== TextClassification.EMPTY_TEXT) {
-          continue;
-        }
-        const images = link.querySelectorAll("img");
-        if (images.some((image) => hasAltText(image))) {
-          continue;
-        }
-        const labels = link.querySelectorAll("[aria-label]");
-        if (hasAriaLabel(link) || labels.some((cur) => hasAriaLabel(cur))) {
-          continue;
-        }
-        this.report(link, "Anchor link must have a text describing its purpose");
+      const { document } = event;
+      const fieldsets = document.querySelectorAll(this.selector);
+      for (const fieldset of fieldsets) {
+        this.validate(fieldset);
       }
     });
   }
+  validate(fieldset) {
+    const legend = fieldset.querySelectorAll("> legend");
+    if (legend.length === 0) {
+      this.reportNode(fieldset);
+    }
+  }
+  reportNode(node) {
+    super.report(node, `${node.annotatedName} must have a <legend> as the first child`);
+  }
+  get selector() {
+    return this.getTagsDerivedFrom("fieldset").join(",");
+  }
+}
+
+const bundledRules$1 = {
+  "wcag/h30": H30,
+  "wcag/h32": H32,
+  "wcag/h36": H36,
+  "wcag/h37": H37,
+  "wcag/h63": H63,
+  "wcag/h67": H67,
+  "wcag/h71": H71
+};
+
+const bundledRules = {
+  "allowed-links": AllowedLinks,
+  "area-alt": AreaAlt,
+  "aria-hidden-body": AriaHiddenBody,
+  "aria-label-misuse": AriaLabelMisuse,
+  "attr-case": AttrCase,
+  "attr-delimiter": AttrDelimiter,
+  "attr-pattern": AttrPattern,
+  "attr-quotes": AttrQuotes,
+  "attr-spacing": AttrSpacing,
+  "attribute-allowed-values": AttributeAllowedValues,
+  "attribute-boolean-style": AttributeBooleanStyle,
+  "attribute-empty-style": AttributeEmptyStyle,
+  "attribute-misuse": AttributeMisuse,
+  "class-pattern": ClassPattern,
+  "close-attr": CloseAttr,
+  "close-order": CloseOrder,
+  deprecated: Deprecated,
+  "deprecated-rule": DeprecatedRule,
+  "doctype-html": NoStyleTag$1,
+  "doctype-style": DoctypeStyle,
+  "element-case": ElementCase,
+  "element-name": ElementName,
+  "element-permitted-content": ElementPermittedContent,
+  "element-permitted-occurrences": ElementPermittedOccurrences,
+  "element-permitted-order": ElementPermittedOrder,
+  "element-permitted-parent": ElementPermittedParent,
+  "element-required-ancestor": ElementRequiredAncestor,
+  "element-required-attributes": ElementRequiredAttributes,
+  "element-required-content": ElementRequiredContent,
+  "empty-heading": EmptyHeading,
+  "empty-title": EmptyTitle,
+  "form-dup-name": FormDupName,
+  "heading-level": HeadingLevel,
+  "hidden-focusable": HiddenFocusable,
+  "id-pattern": IdPattern,
+  "input-attributes": InputAttributes,
+  "input-missing-label": InputMissingLabel,
+  "long-title": LongTitle,
+  "map-dup-name": MapDupName,
+  "map-id-name": MapIdName,
+  "meta-refresh": MetaRefresh,
+  "missing-doctype": MissingDoctype,
+  "multiple-labeled-controls": MultipleLabeledControls,
+  "name-pattern": NamePattern,
+  "no-abstract-role": NoAbstractRole,
+  "no-autoplay": NoAutoplay,
+  "no-conditional-comment": NoConditionalComment,
+  "no-deprecated-attr": NoDeprecatedAttr,
+  "no-dup-attr": NoDupAttr,
+  "no-dup-class": NoDupClass,
+  "no-dup-id": NoDupID,
+  "no-implicit-button-type": NoImplicitButtonType,
+  "no-implicit-input-type": NoImplicitInputType,
+  "no-implicit-close": NoImplicitClose,
+  "no-inline-style": NoInlineStyle,
+  "no-missing-references": NoMissingReferences,
+  "no-multiple-main": NoMultipleMain,
+  "no-raw-characters": NoRawCharacters,
+  "no-redundant-aria-label": NoRedundantAriaLabel,
+  "no-redundant-for": NoRedundantFor,
+  "no-redundant-role": NoRedundantRole,
+  "no-self-closing": NoSelfClosing,
+  "no-style-tag": NoStyleTag,
+  "no-trailing-whitespace": NoTrailingWhitespace,
+  "no-unknown-elements": NoUnknownElements,
+  "no-unused-disable": NoUnusedDisable,
+  "no-utf8-bom": NoUtf8Bom,
+  "prefer-button": PreferButton,
+  "prefer-native-element": PreferNativeElement,
+  "prefer-tbody": PreferTbody,
+  "require-csp-nonce": RequireCSPNonce,
+  "require-sri": RequireSri,
+  "script-element": ScriptElement,
+  "script-type": ScriptType,
+  "svg-focusable": SvgFocusable,
+  "tel-non-breaking": TelNonBreaking,
+  "text-content": TextContent,
+  "unique-landmark": UniqueLandmark,
+  "unrecognized-char-ref": UnknownCharReference,
+  "valid-autocomplete": ValidAutocomplete,
+  "valid-id": ValidID,
+  "void-content": VoidContent,
+  "void-style": VoidStyle,
+  ...bundledRules$1
+};
+
+const ruleIds = new Set(Object.keys(bundledRules));
+function ruleExists(ruleId) {
+  return ruleIds.has(ruleId);
 }
 
-class H32 extends Rule {
-  documentation() {
-    return {
-      description: "WCAG 2.1 requires each `<form>` element to have at least one submit button.",
-      url: "https://html-validate.org/rules/wcag/h32.html"
-    };
-  }
-  setup() {
-    const formTags = this.getTagsWithProperty("form");
-    const formSelector = formTags.join(",");
-    this.on("dom:ready", (event) => {
-      const { document } = event;
-      const forms = document.querySelectorAll(formSelector);
-      for (const form of forms) {
-        if (hasNestedSubmit(form)) {
-          continue;
-        }
-        if (hasAssociatedSubmit(document, form)) {
-          continue;
-        }
-        this.report(form, `<${form.tagName}> element must have a submit button`);
-      }
-    });
+function depthFirst(root, callback) {
+  if (root instanceof DOMTree) {
+    if (root.readyState !== "complete") {
+      throw new Error(`Cannot call walk.depthFirst(..) before document is ready`);
+    }
+    root = root.root;
   }
-}
-function isSubmit(node) {
-  const type = node.getAttribute("type");
-  return Boolean(!type || type.valueMatches(/submit|image/));
-}
-function isAssociated(id, node) {
-  const form = node.getAttribute("form");
-  return Boolean(form == null ? void 0 : form.valueMatches(id, true));
-}
-function hasNestedSubmit(form) {
-  const matches = form.querySelectorAll("button,input").filter(isSubmit).filter((node) => !node.hasAttribute("form"));
-  return matches.length > 0;
-}
-function hasAssociatedSubmit(document, form) {
-  const { id } = form;
-  if (!id) {
-    return false;
+  function visit(node) {
+    node.childElements.forEach(visit);
+    if (!node.isRootElement()) {
+      callback(node);
+    }
   }
-  const matches = document.querySelectorAll("button[form],input[form]").filter(isSubmit).filter((node) => isAssociated(id, node));
-  return matches.length > 0;
+  visit(root);
 }
+const walk = {
+  depthFirst
+};
 
-class H36 extends Rule {
-  documentation() {
-    return {
-      description: [
-        "WCAG 2.1 requires all images used as submit buttons to have a non-empty textual description using the `alt` attribute.",
-        'The alt text cannot be empty (`alt=""`).'
-      ].join("\n"),
-      url: "https://html-validate.org/rules/wcag/h36.html"
-    };
+class DOMTree {
+  /**
+   * @internal
+   */
+  constructor(location) {
+    this.root = HtmlElement.rootNode(location);
+    this.active = this.root;
+    this.doctype = null;
+    this._readyState = "loading";
   }
-  setup() {
-    this.on("tag:end", (event) => {
-      const node = event.previous;
-      if (node.tagName !== "input")
-        return;
-      if (node.getAttributeValue("type") !== "image") {
-        return;
-      }
-      if (!inAccessibilityTree(node)) {
-        return;
-      }
-      if (!hasAltText(node)) {
-        const message = "image used as submit button must have non-empty alt text";
-        const alt = node.getAttribute("alt");
-        this.report({
-          node,
-          message,
-          location: alt ? alt.keyLocation : node.location
-        });
-      }
+  /**
+   * @internal
+   */
+  pushActive(node) {
+    this.active = node;
+  }
+  /**
+   * @internal
+   */
+  popActive() {
+    if (this.active.isRootElement()) {
+      return;
+    }
+    this.active = this.active.parent ?? this.root;
+  }
+  /**
+   * @internal
+   */
+  getActive() {
+    return this.active;
+  }
+  /**
+   * Describes the loading state of the document.
+   *
+   * When `"loading"` it is still not safe to use functions such as
+   * `querySelector` or presence of attributes, child nodes, etc.
+   */
+  get readyState() {
+    return this._readyState;
+  }
+  /**
+   * Resolve dynamic meta expressions.
+   *
+   * @internal
+   */
+  resolveMeta(table) {
+    this._readyState = "complete";
+    walk.depthFirst(this, (node) => {
+      table.resolve(node);
     });
   }
+  getElementsByTagName(tagName) {
+    return this.root.getElementsByTagName(tagName);
+  }
+  /**
+   * @deprecated use utility function `walk.depthFirst(..)` instead (since 8.21.0).
+   */
+  visitDepthFirst(callback) {
+    walk.depthFirst(this, callback);
+  }
+  /**
+   * @deprecated use `querySelector(..)` instead (since 8.21.0)
+   */
+  find(callback) {
+    return this.root.find(callback);
+  }
+  querySelector(selector) {
+    return this.root.querySelector(selector);
+  }
+  querySelectorAll(selector) {
+    return this.root.querySelectorAll(selector);
+  }
 }
 
-const defaults$1 = {
-  allowEmpty: true,
-  alias: []
-};
-class H37 extends Rule {
-  constructor(options) {
-    super({ ...defaults$1, ...options });
-    if (!Array.isArray(this.options.alias)) {
-      this.options.alias = [this.options.alias];
+const allowedKeys = ["exclude"];
+class Validator {
+  /**
+   * Test if element is used in a proper context.
+   *
+   * @param node - Element to test.
+   * @param rules - List of rules.
+   * @returns `true` if element passes all tests.
+   */
+  static validatePermitted(node, rules) {
+    if (!rules) {
+      return true;
     }
+    return rules.some((rule) => {
+      return Validator.validatePermittedRule(node, rule);
+    });
   }
-  static schema() {
-    return {
-      alias: {
-        anyOf: [
-          {
-            items: {
-              type: "string"
-            },
-            type: "array"
-          },
-          {
-            type: "string"
+  /**
+   * Test if an element is used the correct amount of times.
+   *
+   * For instance, a `<table>` element can only contain a single `<tbody>`
+   * child. If multiple `<tbody>` exists this test will fail both nodes.
+   * Note that this is called on the parent but will fail the children violating
+   * the rule.
+   *
+   * @param children - Array of children to validate.
+   * @param rules - List of rules of the parent element.
+   * @returns `true` if the parent element of the children passes the test.
+   */
+  static validateOccurrences(children, rules, cb) {
+    if (!rules) {
+      return true;
+    }
+    let valid = true;
+    for (const rule of rules) {
+      if (typeof rule !== "string") {
+        return false;
+      }
+      const [, category, quantifier] = rule.match(/^(@?.*?)([?*]?)$/);
+      const limit = category && quantifier && parseQuantifier(quantifier);
+      if (limit) {
+        const siblings = children.filter(
+          (cur) => Validator.validatePermittedCategory(cur, rule, true)
+        );
+        if (siblings.length > limit) {
+          for (const child of siblings.slice(limit)) {
+            cb(child, category);
           }
-        ]
-      },
-      allowEmpty: {
-        type: "boolean"
+          valid = false;
+        }
       }
-    };
-  }
-  documentation() {
-    return {
-      description: "Both HTML5 and WCAG 2.0 requires images to have a alternative text for each image.",
-      url: "https://html-validate.org/rules/wcag/h37.html"
-    };
+    }
+    return valid;
   }
-  setup() {
-    this.on("dom:ready", (event) => {
-      const { document } = event;
-      const nodes = document.querySelectorAll("img");
-      for (const node of nodes) {
-        this.validateNode(node);
+  /**
+   * Validate elements order.
+   *
+   * Given a parent element with children and metadata containing permitted
+   * order it will validate each children and ensure each one exists in the
+   * specified order.
+   *
+   * For instance, for a `<table>` element the `<caption>` element must come
+   * before a `<thead>` which must come before `<tbody>`.
+   *
+   * @param children - Array of children to validate.
+   */
+  static validateOrder(children, rules, cb) {
+    if (!rules) {
+      return true;
+    }
+    let i = 0;
+    let prev = null;
+    for (const node of children) {
+      const old = i;
+      while (rules[i] && !Validator.validatePermittedCategory(node, rules[i], true)) {
+        i++;
+      }
+      if (i >= rules.length) {
+        const orderSpecified = rules.find(
+          (cur) => Validator.validatePermittedCategory(node, cur, true)
+        );
+        if (orderSpecified) {
+          cb(node, prev);
+          return false;
+        }
+        i = old;
       }
+      prev = node;
+    }
+    return true;
+  }
+  /**
+   * Validate element ancestors.
+   *
+   * Check if an element has the required set of elements. At least one of the
+   * selectors must match.
+   */
+  static validateAncestors(node, rules) {
+    if (!rules || rules.length === 0) {
+      return true;
+    }
+    return rules.some((rule) => node.closest(rule));
+  }
+  /**
+   * Validate element required content.
+   *
+   * Check if an element has the required set of elements. At least one of the
+   * selectors must match.
+   *
+   * Returns `[]` when valid or a list of required but missing tagnames or
+   * categories.
+   */
+  static validateRequiredContent(node, rules) {
+    if (!rules || rules.length === 0) {
+      return [];
+    }
+    return rules.filter((tagName) => {
+      const haveMatchingChild = node.childElements.some(
+        (child) => Validator.validatePermittedCategory(child, tagName, false)
+      );
+      return !haveMatchingChild;
     });
   }
-  validateNode(node) {
-    if (!inAccessibilityTree(node)) {
-      return;
+  /**
+   * Test if an attribute has an allowed value and/or format.
+   *
+   * @param attr - Attribute to test.
+   * @param rules - Element attribute metadta.
+   * @returns `true` if attribute passes all tests.
+   */
+  static validateAttribute(attr, rules) {
+    const rule = rules[attr.key];
+    if (!rule) {
+      return true;
     }
-    if (Boolean(node.getAttributeValue("alt")) || Boolean(node.hasAttribute("alt") && this.options.allowEmpty)) {
-      return;
+    const value = attr.value;
+    if (value instanceof DynamicValue) {
+      return true;
     }
-    for (const attr of this.options.alias) {
-      if (node.getAttribute(attr)) {
-        return;
-      }
+    const empty = value === null || value === "";
+    if (rule.boolean) {
+      return empty || value === attr.key;
     }
-    const tag = node.annotatedName;
-    if (node.hasAttribute("alt")) {
-      const attr = node.getAttribute("alt");
-      this.report(node, `${tag} cannot have empty "alt" attribute`, attr.keyLocation);
-    } else {
-      this.report(node, `${tag} is missing required "alt" attribute`, node.location);
+    if (rule.omit && empty) {
+      return true;
     }
+    if (rule.list) {
+      const tokens = new DOMTokenList(value, attr.valueLocation);
+      return tokens.every((token) => {
+        return this.validateAttributeValue(token, rule);
+      });
+    }
+    return this.validateAttributeValue(value, rule);
   }
-}
-
-var _a;
-const { enum: validScopes } = (_a = elements.html5.th.attributes) == null ? void 0 : _a.scope;
-const joinedScopes = utils_naturalJoin.naturalJoin(validScopes);
-class H63 extends Rule {
-  documentation() {
-    return {
-      description: "H63: Using the scope attribute to associate header cells and data cells in data tables",
-      url: "https://html-validate.org/rules/wcag/h63.html"
-    };
-  }
-  setup() {
-    this.on("tag:ready", (event) => {
-      const node = event.target;
-      if (node.tagName !== "th") {
-        return;
-      }
-      const scope = node.getAttribute("scope");
-      const value = scope == null ? void 0 : scope.value;
-      if (value instanceof DynamicValue) {
-        return;
-      }
-      if (value && validScopes.includes(value)) {
-        return;
-      }
-      const message = `<th> element must have a valid scope attribute: ${joinedScopes}`;
-      const location = (scope == null ? void 0 : scope.valueLocation) ?? (scope == null ? void 0 : scope.keyLocation) ?? node.location;
-      this.report(node, message, location);
-    });
-  }
-}
-
-class H67 extends Rule {
-  documentation() {
-    return {
-      description: "A decorative image cannot have a title attribute. Either remove `title` or add a descriptive `alt` text.",
-      url: "https://html-validate.org/rules/wcag/h67.html"
-    };
-  }
-  setup() {
-    this.on("tag:end", (event) => {
-      const node = event.target;
-      if (!node || node.tagName !== "img") {
-        return;
-      }
-      const title = node.getAttribute("title");
-      if (!title || title.value === "") {
-        return;
-      }
-      const alt = node.getAttributeValue("alt");
-      if (alt && alt !== "") {
-        return;
+  static validateAttributeValue(value, rule) {
+    if (!rule.enum) {
+      return true;
+    }
+    if (value === null) {
+      return false;
+    }
+    const caseInsensitiveValue = value.toLowerCase();
+    return rule.enum.some((entry) => {
+      if (entry instanceof RegExp) {
+        return !!value.match(entry);
+      } else {
+        return caseInsensitiveValue === entry;
       }
-      this.report(node, "<img> with empty alt text cannot have title attribute", title.keyLocation);
     });
   }
-}
-
-class H71 extends Rule {
-  documentation() {
-    return {
-      description: "H71: Providing a description for groups of form controls using fieldset and legend elements",
-      url: "https://html-validate.org/rules/wcag/h71.html"
-    };
-  }
-  setup() {
-    this.on("dom:ready", (event) => {
-      const { document } = event;
-      const fieldsets = document.querySelectorAll(this.selector);
-      for (const fieldset of fieldsets) {
-        this.validate(fieldset);
+  static validatePermittedRule(node, rule, isExclude = false) {
+    if (typeof rule === "string") {
+      return Validator.validatePermittedCategory(node, rule, !isExclude);
+    } else if (Array.isArray(rule)) {
+      return rule.every((inner) => {
+        return Validator.validatePermittedRule(node, inner, isExclude);
+      });
+    } else {
+      validateKeys(rule);
+      if (rule.exclude) {
+        if (Array.isArray(rule.exclude)) {
+          return !rule.exclude.some((inner) => {
+            return Validator.validatePermittedRule(node, inner, true);
+          });
+        } else {
+          return !Validator.validatePermittedRule(node, rule.exclude, true);
+        }
+      } else {
+        return true;
       }
-    });
-  }
-  validate(fieldset) {
-    const legend = fieldset.querySelectorAll("> legend");
-    if (legend.length === 0) {
-      this.reportNode(fieldset);
     }
   }
-  reportNode(node) {
-    super.report(node, `${node.annotatedName} must have a <legend> as the first child`);
+  /**
+   * Validate node against a content category.
+   *
+   * When matching parent nodes against permitted parents use the superset
+   * parameter to also match for `@flow`. E.g. if a node expects a `@phrasing`
+   * parent it should also allow `@flow` parent since `@phrasing` is a subset of
+   * `@flow`.
+   *
+   * @param node - The node to test against
+   * @param category - Name of category with `@` prefix or tag name.
+   * @param defaultMatch - The default return value when node categories is not known.
+   */
+  /* eslint-disable-next-line complexity -- rule does not like switch */
+  static validatePermittedCategory(node, category, defaultMatch) {
+    const [, rawCategory] = category.match(/^(@?.*?)([?*]?)$/);
+    if (!rawCategory.startsWith("@")) {
+      return node.tagName === rawCategory;
+    }
+    if (!node.meta) {
+      return defaultMatch;
+    }
+    switch (rawCategory) {
+      case "@meta":
+        return node.meta.metadata;
+      case "@flow":
+        return node.meta.flow;
+      case "@sectioning":
+        return node.meta.sectioning;
+      case "@heading":
+        return node.meta.heading;
+      case "@phrasing":
+        return node.meta.phrasing;
+      case "@embedded":
+        return node.meta.embedded;
+      case "@interactive":
+        return node.meta.interactive;
+      case "@script":
+        return Boolean(node.meta.scriptSupporting);
+      case "@form":
+        return Boolean(node.meta.form);
+      default:
+        throw new Error(`Invalid content category "${category}"`);
+    }
   }
-  get selector() {
-    return this.getTagsDerivedFrom("fieldset").join(",");
+}
+function validateKeys(rule) {
+  for (const key of Object.keys(rule)) {
+    if (!allowedKeys.includes(key)) {
+      const str = JSON.stringify(rule);
+      throw new Error(`Permitted rule "${str}" contains unknown property "${key}"`);
+    }
   }
 }
-
-const bundledRules$1 = {
-  "wcag/h30": H30,
-  "wcag/h32": H32,
-  "wcag/h36": H36,
-  "wcag/h37": H37,
-  "wcag/h63": H63,
-  "wcag/h67": H67,
-  "wcag/h71": H71
+function parseQuantifier(quantifier) {
+  switch (quantifier) {
+    case "?":
+      return 1;
+    case "*":
+      return null;
+    default:
+      throw new Error(`Invalid quantifier "${quantifier}" used`);
+  }
+}
+
+const $schema = "http://json-schema.org/draft-06/schema#";
+const $id = "https://html-validate.org/schemas/config.json";
+const type = "object";
+const additionalProperties = false;
+const properties = {
+	$schema: {
+		type: "string"
+	},
+	root: {
+		type: "boolean",
+		title: "Mark as root configuration",
+		description: "If this is set to true no further configurations will be searched.",
+		"default": false
+	},
+	"extends": {
+		type: "array",
+		items: {
+			type: "string"
+		},
+		title: "Configurations to extend",
+		description: "Array of shareable or builtin configurations to extend."
+	},
+	elements: {
+		type: "array",
+		items: {
+			anyOf: [
+				{
+					type: "string"
+				},
+				{
+					type: "object"
+				}
+			]
+		},
+		title: "Element metadata to load",
+		description: "Array of modules, plugins or files to load element metadata from. Use <rootDir> to refer to the folder with the package.json file.",
+		examples: [
+			[
+				"html-validate:recommended",
+				"plugin:recommended",
+				"module",
+				"./local-file.json"
+			]
+		]
+	},
+	plugins: {
+		type: "array",
+		items: {
+			anyOf: [
+				{
+					type: "string"
+				},
+				{
+					type: "object"
+				}
+			]
+		},
+		title: "Plugins to load",
+		description: "Array of plugins load. Use <rootDir> to refer to the folder with the package.json file.",
+		examples: [
+			[
+				"my-plugin",
+				"./local-plugin"
+			]
+		]
+	},
+	transform: {
+		type: "object",
+		additionalProperties: {
+			type: "string"
+		},
+		title: "File transformations to use.",
+		description: "Object where key is regular expression to match filename and value is name of transformer.",
+		examples: [
+			{
+				"^.*\\.foo$": "my-transformer",
+				"^.*\\.bar$": "my-plugin",
+				"^.*\\.baz$": "my-plugin:named"
+			}
+		]
+	},
+	rules: {
+		type: "object",
+		patternProperties: {
+			".*": {
+				anyOf: [
+					{
+						"enum": [
+							0,
+							1,
+							2,
+							"off",
+							"warn",
+							"error"
+						]
+					},
+					{
+						type: "array",
+						minItems: 1,
+						maxItems: 1,
+						items: [
+							{
+								"enum": [
+									0,
+									1,
+									2,
+									"off",
+									"warn",
+									"error"
+								]
+							}
+						]
+					},
+					{
+						type: "array",
+						minItems: 2,
+						maxItems: 2,
+						items: [
+							{
+								"enum": [
+									0,
+									1,
+									2,
+									"off",
+									"warn",
+									"error"
+								]
+							},
+							{
+							}
+						]
+					}
+				]
+			}
+		},
+		title: "Rule configuration.",
+		description: "Enable/disable rules, set severity. Some rules have additional configuration like style or patterns to use.",
+		examples: [
+			{
+				foo: "error",
+				bar: "off",
+				baz: [
+					"error",
+					{
+						style: "camelcase"
+					}
+				]
+			}
+		]
+	}
+};
+var configurationSchema = {
+	$schema: $schema,
+	$id: $id,
+	type: type,
+	additionalProperties: additionalProperties,
+	properties: properties
 };
 
-const bundledRules = {
-  "allowed-links": AllowedLinks,
-  "area-alt": AreaAlt,
-  "aria-hidden-body": AriaHiddenBody,
-  "aria-label-misuse": AriaLabelMisuse,
-  "attr-case": AttrCase,
-  "attr-delimiter": AttrDelimiter,
-  "attr-pattern": AttrPattern,
-  "attr-quotes": AttrQuotes,
-  "attr-spacing": AttrSpacing,
-  "attribute-allowed-values": AttributeAllowedValues,
-  "attribute-boolean-style": AttributeBooleanStyle,
-  "attribute-empty-style": AttributeEmptyStyle,
-  "attribute-misuse": AttributeMisuse,
-  "class-pattern": ClassPattern,
-  "close-attr": CloseAttr,
-  "close-order": CloseOrder,
-  deprecated: Deprecated,
-  "deprecated-rule": DeprecatedRule,
-  "doctype-html": NoStyleTag$1,
-  "doctype-style": DoctypeStyle,
-  "element-case": ElementCase,
-  "element-name": ElementName,
-  "element-permitted-content": ElementPermittedContent,
-  "element-permitted-occurrences": ElementPermittedOccurrences,
-  "element-permitted-order": ElementPermittedOrder,
-  "element-permitted-parent": ElementPermittedParent,
-  "element-required-ancestor": ElementRequiredAncestor,
-  "element-required-attributes": ElementRequiredAttributes,
-  "element-required-content": ElementRequiredContent,
-  "empty-heading": EmptyHeading,
-  "empty-title": EmptyTitle,
-  "form-dup-name": FormDupName,
-  "heading-level": HeadingLevel,
-  "hidden-focusable": HiddenFocusable,
-  "id-pattern": IdPattern,
-  "input-attributes": InputAttributes,
-  "input-missing-label": InputMissingLabel,
-  "long-title": LongTitle,
-  "map-dup-name": MapDupName,
-  "map-id-name": MapIdName,
-  "meta-refresh": MetaRefresh,
-  "missing-doctype": MissingDoctype,
-  "multiple-labeled-controls": MultipleLabeledControls,
-  "name-pattern": NamePattern,
-  "no-abstract-role": NoAbstractRole,
-  "no-autoplay": NoAutoplay,
-  "no-conditional-comment": NoConditionalComment,
-  "no-deprecated-attr": NoDeprecatedAttr,
-  "no-dup-attr": NoDupAttr,
-  "no-dup-class": NoDupClass,
-  "no-dup-id": NoDupID,
-  "no-implicit-button-type": NoImplicitButtonType,
-  "no-implicit-input-type": NoImplicitInputType,
-  "no-implicit-close": NoImplicitClose,
-  "no-inline-style": NoInlineStyle,
-  "no-missing-references": NoMissingReferences,
-  "no-multiple-main": NoMultipleMain,
-  "no-raw-characters": NoRawCharacters,
-  "no-redundant-aria-label": NoRedundantAriaLabel,
-  "no-redundant-for": NoRedundantFor,
-  "no-redundant-role": NoRedundantRole,
-  "no-self-closing": NoSelfClosing,
-  "no-style-tag": NoStyleTag,
-  "no-trailing-whitespace": NoTrailingWhitespace,
-  "no-unknown-elements": NoUnknownElements,
-  "no-unused-disable": NoUnusedDisable,
-  "no-utf8-bom": NoUtf8Bom,
-  "prefer-button": PreferButton,
-  "prefer-native-element": PreferNativeElement,
-  "prefer-tbody": PreferTbody,
-  "require-csp-nonce": RequireCSPNonce,
-  "require-sri": RequireSri,
-  "script-element": ScriptElement,
-  "script-type": ScriptType,
-  "svg-focusable": SvgFocusable,
-  "tel-non-breaking": TelNonBreaking,
-  "text-content": TextContent,
-  "unique-landmark": UniqueLandmark,
-  "unrecognized-char-ref": UnknownCharReference,
-  "valid-autocomplete": ValidAutocomplete,
-  "valid-id": ValidID,
-  "void-content": VoidContent,
-  "void-style": VoidStyle,
-  ...bundledRules$1
+const TRANSFORMER_API = {
+  VERSION: 1
 };
 
 var defaultConfig = {};
@@ -11453,7 +11497,7 @@ class Parser {
       location
     };
     this.trigger("tag:end", event);
-    if (active && !active.isRootElement()) {
+    if (!active.isRootElement()) {
       this.trigger("element:ready", {
         target: active,
         location: active.location
@@ -11805,15 +11849,6 @@ class Parser {
   }
 }
 
-function isThenable(value) {
-  return value && typeof value === "object" && "then" in value && typeof value.then === "function";
-}
-
-const ruleIds = new Set(Object.keys(bundledRules));
-function ruleExists(ruleId) {
-  return ruleIds.has(ruleId);
-}
-
 function freeze(src) {
   return {
     ...src,
@@ -11984,7 +12019,7 @@ class Engine {
       const directiveContext = {
         rules,
         reportUnused(rules2, unused, options, location2) {
-          if (noUnusedDisable && !rules2.has(noUnusedDisable.name)) {
+          if (!rules2.has(noUnusedDisable.name)) {
             noUnusedDisable.reportUnused(unused, options, location2);
           }
         }
@@ -12115,7 +12150,9 @@ class Engine {
     return new this.ParserClass(this.config);
   }
   processDirective(event, parser, context) {
-    const rules = event.data.split(",").map((name) => name.trim()).map((name) => context.rules[name]).filter((rule) => rule);
+    const rules = event.data.split(",").map((name) => name.trim()).map((name) => context.rules[name]).filter((rule) => {
+      return Boolean(rule);
+    });
     const location = event.optionsLocation ?? event.location;
     switch (event.action) {
       case "enable":
@@ -12139,7 +12176,7 @@ class Engine {
         rule.setServerity(Severity.ERROR);
       }
     }
-    parser.on("tag:start", (event, data) => {
+    parser.on("tag:start", (_event, data) => {
       data.target.enableRules(rules.map((rule) => rule.name));
     });
   }
@@ -12147,7 +12184,7 @@ class Engine {
     for (const rule of rules) {
       rule.setEnabled(false);
     }
-    parser.on("tag:start", (event, data) => {
+    parser.on("tag:start", (_event, data) => {
       data.target.disableRules(rules.map((rule) => rule.name));
     });
   }
@@ -12159,14 +12196,14 @@ class Engine {
     for (const rule of rules) {
       rule.block(blocker);
     }
-    const unregisterOpen = parser.on("tag:start", (event, data) => {
+    const unregisterOpen = parser.on("tag:start", (_event, data) => {
       var _a;
       if (directiveBlock === null) {
         directiveBlock = ((_a = data.target.parent) == null ? void 0 : _a.unique) ?? null;
       }
       data.target.blockRules(ruleIds, blocker);
     });
-    const unregisterClose = parser.on("tag:end", (event, data) => {
+    const unregisterClose = parser.on("tag:end", (_event, data) => {
       const lastNode = directiveBlock === null;
       const parentClosed = directiveBlock === data.previous.unique;
       if (lastNode || parentClosed) {
@@ -12177,7 +12214,7 @@ class Engine {
         }
       }
     });
-    parser.on("rule:error", (event, data) => {
+    parser.on("rule:error", (_event, data) => {
       if (data.blockers.includes(blocker)) {
         unused.delete(data.ruleId);
       }
@@ -12193,10 +12230,10 @@ class Engine {
     for (const rule of rules) {
       rule.block(blocker);
     }
-    const unregister = parser.on("tag:start", (event, data) => {
+    const unregister = parser.on("tag:start", (_event, data) => {
       data.target.blockRules(ruleIds, blocker);
     });
-    parser.on("rule:error", (event, data) => {
+    parser.on("rule:error", (_event, data) => {
       if (data.blockers.includes(blocker)) {
         unused.delete(data.ruleId);
       }
@@ -12760,7 +12797,7 @@ class HtmlValidate {
 }
 
 const name = "html-validate";
-const version = "8.20.0";
+const version = "8.21.0";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function definePlugin(plugin) {
@@ -13682,4 +13719,5 @@ exports.ruleExists = ruleExists;
 exports.sliceLocation = sliceLocation;
 exports.staticResolver = staticResolver;
 exports.version = version;
+exports.walk = walk;
 //# sourceMappingURL=core.js.map