html-validate 8.20.0 → 8.21.0

package/dist/es/core.js

@@ -1269,14 +1269,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.
@@ -1284,7 +1282,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.
@@ -1292,10 +1290,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];
@@ -1306,7 +1304,7 @@ class MetaTable {
         });
       }
     }
-    const expanded = this.mergeElement(parent, { ...entry, tagName });
+    const expanded = this.mergeElement(parent ?? {}, { ...entry, tagName });
     expandRegex(expanded);
     this.elements[tagName] = expanded;
   }
@@ -1335,6 +1333,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.
@@ -1346,7 +1350,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);
     }
   }
@@ -2134,7 +2138,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:
@@ -2580,10 +2584,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.
@@ -2640,7 +2647,7 @@ class HtmlElement extends DOMNode {
       const matches = this.attr[key];
       return all ? matches : matches[0];
     } else {
-      return null;
+      return all ? [] : null;
     }
   }
   /**
@@ -2746,20 +2753,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.
    *
@@ -2823,591 +2816,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)) {
@@ -5012,7 +4547,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;
@@ -5043,11 +4578,7 @@ class AttributeAllowedValues extends Rule {
     }
   }
   getLocation(attr) {
-    if (attr.value !== null) {
-      return attr.valueLocation;
-    } else {
-      return attr.keyLocation;
-    }
+    return attr.valueLocation ?? attr.keyLocation;
   }
 }
 
@@ -5076,7 +4607,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;
@@ -5148,7 +4679,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;
@@ -5800,7 +5331,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;
@@ -5879,7 +5410,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;
         }
@@ -5912,7 +5443,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;
         }
@@ -5982,7 +5513,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) {
@@ -6030,7 +5561,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;
@@ -6114,7 +5645,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;
         }
@@ -6634,7 +6165,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);
@@ -8544,1778 +8075,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 = entities$1.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 entities$1;
     }
-    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 = entities$1.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 entities$1;
-    }
-  }
-  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 = html5.th.attributes) == null ? void 0 : _a.scope;
+const joinedScopes = 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 = html5.th.attributes) == null ? void 0 : _a.scope;
-const joinedScopes = 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 = {};
@@ -11443,7 +11487,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
@@ -11795,15 +11839,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,
@@ -11974,7 +12009,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);
           }
         }
@@ -12105,7 +12140,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":
@@ -12129,7 +12166,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));
     });
   }
@@ -12137,7 +12174,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));
     });
   }
@@ -12149,14 +12186,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) {
@@ -12167,7 +12204,7 @@ class Engine {
         }
       }
     });
-    parser.on("rule:error", (event, data) => {
+    parser.on("rule:error", (_event, data) => {
       if (data.blockers.includes(blocker)) {
         unused.delete(data.ruleId);
       }
@@ -12183,10 +12220,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);
       }
@@ -12750,7 +12787,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) {
@@ -13625,5 +13662,5 @@ function compatibilityCheckImpl(name, declared, options) {
   return false;
 }
 
-export { Attribute as A, definePlugin as B, Config as C, DOMNode as D, Parser as E, ruleExists as F, EventHandler as G, HtmlValidate as H, compatibilityCheckImpl as I, codeframe as J, name as K, bugs as L, MetaCopyableProperty as M, NodeClosed as N, Presets as P, ResolvedConfig as R, Severity as S, TextNode as T, UserError as U, Validator as V, WrappedError as W, ConfigError as a, ConfigLoader as b, defineConfig as c, deepmerge$1 as d, ensureError as e, StaticConfigLoader as f, getFormatter as g, DOMTokenList as h, ignore$1 as i, DOMTree as j, DynamicValue as k, HtmlElement as l, NodeType as m, NestedError as n, SchemaValidationError as o, MetaTable as p, TextContent$1 as q, Rule as r, staticResolver as s, ariaNaming as t, TextClassification as u, version as v, classifyNodeText as w, keywordPatternMatcher as x, sliceLocation as y, Reporter as z };
+export { Attribute as A, definePlugin as B, Config as C, DOMNode as D, Parser as E, ruleExists as F, walk as G, HtmlValidate as H, EventHandler as I, compatibilityCheckImpl as J, codeframe as K, name as L, MetaCopyableProperty as M, NodeClosed as N, bugs as O, Presets as P, ResolvedConfig as R, Severity as S, TextNode as T, UserError as U, Validator as V, WrappedError as W, ConfigError as a, ConfigLoader as b, defineConfig as c, deepmerge$1 as d, ensureError as e, StaticConfigLoader as f, getFormatter as g, DOMTokenList as h, ignore$1 as i, DOMTree as j, DynamicValue as k, HtmlElement as l, NodeType as m, NestedError as n, SchemaValidationError as o, MetaTable as p, TextContent$1 as q, Rule as r, staticResolver as s, ariaNaming as t, TextClassification as u, version as v, classifyNodeText as w, keywordPatternMatcher as x, sliceLocation as y, Reporter as z };
 //# sourceMappingURL=core.js.map