html-validate 8.20.1 → 8.22.0

package/dist/es/core.js

@@ -3,7 +3,6 @@ import { e as entities$1, h as html5, b as bundledElements } from './elements.js
 import betterAjvErrors from '@sidvind/better-ajv-errors';
 import { n as naturalJoin } from './utils/natural-join.js';
 import fs from 'fs';
-import { codeFrameColumns } from '@babel/code-frame';
 import kleur from 'kleur';
 import { stylish as stylish$1 } from '@html-validate/stylish';
 import semver from 'semver';
@@ -1269,14 +1268,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 +1281,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 +1289,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 +1303,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 +1332,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 +1349,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);
     }
   }
@@ -1667,6 +1670,7 @@ class DOMNode {
   /**
    * Create a new DOMNode.
    *
+   * @internal
    * @param nodeType - What node type to create.
    * @param nodeName - What node name to use. For `HtmlElement` this corresponds
    * to the tagName but other node types have specific predefined values.
@@ -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:
@@ -2335,8 +2339,15 @@ function createAdapter(node) {
   };
 }
 class HtmlElement extends DOMNode {
-  constructor(tagName, parent, closed, meta, location) {
-    const nodeType = tagName ? NodeType.ELEMENT_NODE : NodeType.DOCUMENT_NODE;
+  constructor(details) {
+    const {
+      nodeType,
+      tagName,
+      parent = null,
+      closed = 1 /* EndTag */,
+      meta = null,
+      location
+    } = details;
     super(nodeType, tagName, location);
     if (isInvalidTagName(tagName)) {
       throw new Error(`The tag name provided ("${tagName}") is not a valid name`);
@@ -2359,11 +2370,39 @@ class HtmlElement extends DOMNode {
       }
     }
   }
+  /**
+   * Manually create a new element. This is primary useful for test-cases. While
+   * the API is public it is not meant for general consumption and is not
+   * guaranteed to be stable across versions.
+   *
+   * Use at your own risk. Prefer to use [[Parser]] to parse a string of markup
+   * instead.
+   *
+   * @public
+   * @since 8.22.0
+   * @param tagName - Element tagname.
+   * @param location - Element location.
+   * @param details - Additional element details.
+   */
+  static createElement(tagName, location, details = {}) {
+    const { closed = 1 /* EndTag */, meta = null, parent = null } = details;
+    return new HtmlElement({
+      nodeType: NodeType.ELEMENT_NODE,
+      tagName,
+      parent,
+      closed,
+      meta,
+      location
+    });
+  }
   /**
    * @internal
    */
   static rootNode(location) {
-    const root = new HtmlElement(void 0, null, 1 /* EndTag */, null, location);
+    const root = new HtmlElement({
+      nodeType: NodeType.DOCUMENT_NODE,
+      location
+    });
     root.setAnnotation("#document");
     return root;
   }
@@ -2382,7 +2421,14 @@ class HtmlElement extends DOMNode {
     const open = startToken.data[1] !== "/";
     const closed = isClosed(endToken, meta);
     const location = sliceLocation(startToken.location, 1);
-    return new HtmlElement(tagName, open ? parent : null, closed, meta, location);
+    return new HtmlElement({
+      nodeType: NodeType.ELEMENT_NODE,
+      tagName,
+      parent: open ? parent : null,
+      closed,
+      meta,
+      location
+    });
   }
   /**
    * Returns annotated name if set or defaults to `<tagName>`.
@@ -2580,10 +2626,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 +2689,7 @@ class HtmlElement extends DOMNode {
       const matches = this.attr[key];
       return all ? matches : matches[0];
     } else {
-      return null;
+      return all ? [] : null;
     }
   }
   /**
@@ -2746,20 +2795,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,738 +2858,309 @@ 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;
-  }
-  popActive() {
-    if (this.active.isRootElement()) {
-      return;
+function dumpTree(root) {
+  const lines = [];
+  function decoration(node) {
+    let output = "";
+    if (node.id) {
+      output += `#${node.id}`;
     }
-    this.active = this.active.parent ?? this.root;
-  }
-  getActive() {
-    return this.active;
+    if (node.hasAttribute("class")) {
+      output += `.${node.classList.join(".")}`;
+    }
+    return output;
   }
-  /**
-   * Resolve dynamic meta expressions.
-   */
-  resolveMeta(table) {
-    this.visitDepthFirst((node) => {
-      table.resolve(node);
+  function writeNode(node, level, sibling) {
+    if (node.parent) {
+      const indent = "  ".repeat(level - 1);
+      const l = node.childElements.length > 0 ? "\u252C" : "\u2500";
+      const b = sibling < node.parent.childElements.length - 1 ? "\u251C" : "\u2514";
+      lines.push(`${indent}${b}\u2500${l} ${node.tagName}${decoration(node)}`);
+    } else {
+      lines.push("(root)");
+    }
+    node.childElements.forEach((child, index) => {
+      writeNode(child, level + 1, index);
     });
   }
-  getElementsByTagName(tagName) {
-    return this.root.getElementsByTagName(tagName);
+  writeNode(root, 0, 0);
+  return lines;
+}
+
+function escape(value) {
+  return JSON.stringify(value);
+}
+function format(value, quote = false) {
+  if (value === null) {
+    return "null";
   }
-  visitDepthFirst(callback) {
-    this.root.visitDepthFirst(callback);
+  if (typeof value === "number") {
+    return value.toString();
   }
-  find(callback) {
-    return this.root.find(callback);
+  if (typeof value === "string") {
+    return quote ? escape(value) : value;
   }
-  querySelector(selector) {
-    return this.root.querySelector(selector);
+  if (Array.isArray(value)) {
+    const content = value.map((it) => format(it, true)).join(", ");
+    return `[ ${content} ]`;
   }
-  querySelectorAll(selector) {
-    return this.root.querySelectorAll(selector);
+  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 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);
-    });
+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)}"`);
   }
-  /**
-   * 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);
-          }
-          valid = false;
-        }
-      }
-    }
-    return valid;
+}
+
+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;
   }
-  /**
-   * 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;
+  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));
     }
-    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));
+  const meta = element.meta;
+  if (!meta) {
+    return element.cacheSet(cacheKey, defaultValue);
   }
-  /**
-   * 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;
-    });
+  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;
   }
-  /**
-   * 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) {
+  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;
     }
-    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;
-      }
-    });
+  return false;
+}
+function isKeywordIgnored(options, keyword, matcher = (list, it) => list.includes(it)) {
+  const { include, exclude } = options;
+  if (include && !matcher(include, keyword)) {
+    return true;
   }
-  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;
-      }
-    }
+  if (exclude && matcher(exclude, keyword)) {
+    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}"`);
-    }
+  return false;
+}
+
+const ARIA_HIDDEN_CACHE = Symbol(isAriaHidden.name);
+const HTML_HIDDEN_CACHE = Symbol(isHTMLHidden.name);
+const INERT_CACHE = Symbol(isInert.name);
+const ROLE_PRESENTATION_CACHE = Symbol(isPresentation.name);
+const STYLE_HIDDEN_CACHE = Symbol(isStyleHidden.name);
+function inAccessibilityTree(node) {
+  if (isAriaHidden(node)) {
+    return false;
   }
+  if (isPresentation(node)) {
+    return false;
+  }
+  if (isHTMLHidden(node)) {
+    return false;
+  }
+  if (isInert(node)) {
+    return false;
+  }
+  if (isStyleHidden(node)) {
+    return false;
+  }
+  return true;
 }
-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 isAriaHiddenImpl(node) {
+  const getAriaHiddenAttr = (node2) => {
+    const ariaHidden = node2.getAttribute("aria-hidden");
+    return Boolean(ariaHidden && ariaHidden.value === "true");
+  };
+  return {
+    byParent: node.parent ? isAriaHidden(node.parent) : false,
+    bySelf: getAriaHiddenAttr(node)
+  };
+}
+function isAriaHidden(node, details) {
+  const cached = node.cacheGet(ARIA_HIDDEN_CACHE);
+  if (cached) {
+    return details ? cached : cached.byParent || cached.bySelf;
   }
+  const result = node.cacheSet(ARIA_HIDDEN_CACHE, isAriaHiddenImpl(node));
+  return details ? result : result.byParent || result.bySelf;
 }
-function parseQuantifier(quantifier) {
-  switch (quantifier) {
-    case "?":
-      return 1;
-    case "*":
-      return null;
-    default:
-      throw new Error(`Invalid quantifier "${quantifier}" used`);
+function isHTMLHiddenImpl(node) {
+  const getHiddenAttr = (node2) => {
+    const hidden = node2.getAttribute("hidden");
+    return Boolean(hidden == null ? void 0 : hidden.isStatic);
+  };
+  return {
+    byParent: node.parent ? isHTMLHidden(node.parent) : false,
+    bySelf: getHiddenAttr(node)
+  };
+}
+function isHTMLHidden(node, details) {
+  const cached = node.cacheGet(HTML_HIDDEN_CACHE);
+  if (cached) {
+    return details ? cached : cached.byParent || cached.bySelf;
   }
+  const result = node.cacheSet(HTML_HIDDEN_CACHE, isHTMLHiddenImpl(node));
+  return details ? result : result.byParent || result.bySelf;
 }
-
-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 isInertImpl(node) {
+  const getInertAttr = (node2) => {
+    const inert = node2.getAttribute("inert");
+    return Boolean(inert == null ? void 0 : inert.isStatic);
+  };
+  return {
+    byParent: node.parent ? isInert(node.parent) : false,
+    bySelf: getInertAttr(node)
+  };
+}
+function isInert(node, details) {
+  const cached = node.cacheGet(INERT_CACHE);
+  if (cached) {
+    return details ? cached : cached.byParent || cached.bySelf;
   }
+  const result = node.cacheSet(INERT_CACHE, isInertImpl(node));
+  return details ? result : result.byParent || result.bySelf;
 }
-
-function escape(value) {
-  return JSON.stringify(value);
+function isStyleHiddenImpl(node) {
+  const getStyleAttr = (node2) => {
+    const style = node2.getAttribute("style");
+    const { display, visibility } = parseCssDeclaration(style == null ? void 0 : style.value);
+    return display === "none" || visibility === "hidden";
+  };
+  const byParent = node.parent ? isStyleHidden(node.parent) : false;
+  const bySelf = getStyleAttr(node);
+  return byParent || bySelf;
 }
-function format(value, quote = false) {
-  if (value === null) {
-    return "null";
+function isStyleHidden(node) {
+  const cached = node.cacheGet(STYLE_HIDDEN_CACHE);
+  if (cached) {
+    return cached;
   }
-  if (typeof value === "number") {
-    return value.toString();
+  return node.cacheSet(STYLE_HIDDEN_CACHE, isStyleHiddenImpl(node));
+}
+function isPresentation(node) {
+  if (node.cacheExists(ROLE_PRESENTATION_CACHE)) {
+    return Boolean(node.cacheGet(ROLE_PRESENTATION_CACHE));
   }
-  if (typeof value === "string") {
-    return quote ? escape(value) : value;
+  const meta = node.meta;
+  if (meta == null ? void 0 : meta.interactive) {
+    return node.cacheSet(ROLE_PRESENTATION_CACHE, false);
   }
-  if (Array.isArray(value)) {
-    const content = value.map((it) => format(it, true)).join(", ");
-    return `[ ${content} ]`;
+  const tabindex = node.getAttribute("tabindex");
+  if (tabindex) {
+    return node.cacheSet(ROLE_PRESENTATION_CACHE, false);
   }
-  if (typeof value === "object") {
-    const content = Object.entries(value).map(([key, nested]) => `${key}: ${format(nested, true)}`).join(", ");
-    return `{ ${content} }`;
+  const role = node.getAttribute("role");
+  if (role && (role.value === "presentation" || role.value === "none")) {
+    return node.cacheSet(ROLE_PRESENTATION_CACHE, true);
+  } else {
+    return node.cacheSet(ROLE_PRESENTATION_CACHE, false);
   }
-  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";
+const cachePrefix = classifyNodeText.name;
+const HTML_CACHE_KEY = Symbol(`${cachePrefix}|html`);
+const A11Y_CACHE_KEY = Symbol(`${cachePrefix}|a11y`);
+const IGNORE_HIDDEN_ROOT_HTML_CACHE_KEY = Symbol(`${cachePrefix}|html|ignore-hidden-root`);
+const IGNORE_HIDDEN_ROOT_A11Y_CACHE_KEY = Symbol(`${cachePrefix}|a11y|ignore-hidden-root`);
+var TextClassification = /* @__PURE__ */ ((TextClassification2) => {
+  TextClassification2[TextClassification2["EMPTY_TEXT"] = 0] = "EMPTY_TEXT";
+  TextClassification2[TextClassification2["DYNAMIC_TEXT"] = 1] = "DYNAMIC_TEXT";
+  TextClassification2[TextClassification2["STATIC_TEXT"] = 2] = "STATIC_TEXT";
+  return TextClassification2;
+})(TextClassification || {});
+function getCachekey(options) {
+  const { accessible = false, ignoreHiddenRoot = false } = options;
+  if (accessible && ignoreHiddenRoot) {
+    return IGNORE_HIDDEN_ROOT_A11Y_CACHE_KEY;
+  } else if (ignoreHiddenRoot) {
+    return IGNORE_HIDDEN_ROOT_HTML_CACHE_KEY;
+  } else if (accessible) {
+    return A11Y_CACHE_KEY;
+  } else {
+    return HTML_CACHE_KEY;
+  }
 }
-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 true;
-  }
-  if (exclude && matcher(exclude, keyword)) {
-    return true;
-  }
-  return false;
-}
-
-const ARIA_HIDDEN_CACHE = Symbol(isAriaHidden.name);
-const HTML_HIDDEN_CACHE = Symbol(isHTMLHidden.name);
-const INERT_CACHE = Symbol(isInert.name);
-const ROLE_PRESENTATION_CACHE = Symbol(isPresentation.name);
-const STYLE_HIDDEN_CACHE = Symbol(isStyleHidden.name);
-function inAccessibilityTree(node) {
-  if (isAriaHidden(node)) {
-    return false;
-  }
-  if (isPresentation(node)) {
-    return false;
-  }
-  if (isHTMLHidden(node)) {
-    return false;
-  }
-  if (isInert(node)) {
-    return false;
-  }
-  if (isStyleHidden(node)) {
-    return false;
-  }
-  return true;
-}
-function isAriaHiddenImpl(node) {
-  const getAriaHiddenAttr = (node2) => {
-    const ariaHidden = node2.getAttribute("aria-hidden");
-    return Boolean(ariaHidden && ariaHidden.value === "true");
-  };
-  return {
-    byParent: node.parent ? isAriaHidden(node.parent) : false,
-    bySelf: getAriaHiddenAttr(node)
-  };
-}
-function isAriaHidden(node, details) {
-  const cached = node.cacheGet(ARIA_HIDDEN_CACHE);
-  if (cached) {
-    return details ? cached : cached.byParent || cached.bySelf;
-  }
-  const result = node.cacheSet(ARIA_HIDDEN_CACHE, isAriaHiddenImpl(node));
-  return details ? result : result.byParent || result.bySelf;
-}
-function isHTMLHiddenImpl(node) {
-  const getHiddenAttr = (node2) => {
-    const hidden = node2.getAttribute("hidden");
-    return Boolean(hidden == null ? void 0 : hidden.isStatic);
-  };
-  return {
-    byParent: node.parent ? isHTMLHidden(node.parent) : false,
-    bySelf: getHiddenAttr(node)
-  };
-}
-function isHTMLHidden(node, details) {
-  const cached = node.cacheGet(HTML_HIDDEN_CACHE);
-  if (cached) {
-    return details ? cached : cached.byParent || cached.bySelf;
-  }
-  const result = node.cacheSet(HTML_HIDDEN_CACHE, isHTMLHiddenImpl(node));
-  return details ? result : result.byParent || result.bySelf;
-}
-function isInertImpl(node) {
-  const getInertAttr = (node2) => {
-    const inert = node2.getAttribute("inert");
-    return Boolean(inert == null ? void 0 : inert.isStatic);
-  };
-  return {
-    byParent: node.parent ? isInert(node.parent) : false,
-    bySelf: getInertAttr(node)
-  };
-}
-function isInert(node, details) {
-  const cached = node.cacheGet(INERT_CACHE);
-  if (cached) {
-    return details ? cached : cached.byParent || cached.bySelf;
-  }
-  const result = node.cacheSet(INERT_CACHE, isInertImpl(node));
-  return details ? result : result.byParent || result.bySelf;
-}
-function isStyleHiddenImpl(node) {
-  const getStyleAttr = (node2) => {
-    const style = node2.getAttribute("style");
-    const { display, visibility } = parseCssDeclaration(style == null ? void 0 : style.value);
-    return display === "none" || visibility === "hidden";
-  };
-  const byParent = node.parent ? isStyleHidden(node.parent) : false;
-  const bySelf = getStyleAttr(node);
-  return byParent || bySelf;
-}
-function isStyleHidden(node) {
-  const cached = node.cacheGet(STYLE_HIDDEN_CACHE);
-  if (cached) {
-    return cached;
-  }
-  return node.cacheSet(STYLE_HIDDEN_CACHE, isStyleHiddenImpl(node));
-}
-function isPresentation(node) {
-  if (node.cacheExists(ROLE_PRESENTATION_CACHE)) {
-    return Boolean(node.cacheGet(ROLE_PRESENTATION_CACHE));
-  }
-  const meta = node.meta;
-  if (meta == null ? void 0 : meta.interactive) {
-    return node.cacheSet(ROLE_PRESENTATION_CACHE, false);
-  }
-  const tabindex = node.getAttribute("tabindex");
-  if (tabindex) {
-    return node.cacheSet(ROLE_PRESENTATION_CACHE, false);
-  }
-  const role = node.getAttribute("role");
-  if (role && (role.value === "presentation" || role.value === "none")) {
-    return node.cacheSet(ROLE_PRESENTATION_CACHE, true);
-  } else {
-    return node.cacheSet(ROLE_PRESENTATION_CACHE, false);
-  }
-}
-
-const cachePrefix = classifyNodeText.name;
-const HTML_CACHE_KEY = Symbol(`${cachePrefix}|html`);
-const A11Y_CACHE_KEY = Symbol(`${cachePrefix}|a11y`);
-const IGNORE_HIDDEN_ROOT_HTML_CACHE_KEY = Symbol(`${cachePrefix}|html|ignore-hidden-root`);
-const IGNORE_HIDDEN_ROOT_A11Y_CACHE_KEY = Symbol(`${cachePrefix}|a11y|ignore-hidden-root`);
-var TextClassification = /* @__PURE__ */ ((TextClassification2) => {
-  TextClassification2[TextClassification2["EMPTY_TEXT"] = 0] = "EMPTY_TEXT";
-  TextClassification2[TextClassification2["DYNAMIC_TEXT"] = 1] = "DYNAMIC_TEXT";
-  TextClassification2[TextClassification2["STATIC_TEXT"] = 2] = "STATIC_TEXT";
-  return TextClassification2;
-})(TextClassification || {});
-function getCachekey(options) {
-  const { accessible = false, ignoreHiddenRoot = false } = options;
-  if (accessible && ignoreHiddenRoot) {
-    return IGNORE_HIDDEN_ROOT_A11Y_CACHE_KEY;
-  } else if (ignoreHiddenRoot) {
-    return IGNORE_HIDDEN_ROOT_HTML_CACHE_KEY;
-  } else if (accessible) {
-    return A11Y_CACHE_KEY;
-  } else {
-    return HTML_CACHE_KEY;
-  }
-}
-function isSpecialEmpty(node) {
-  return node.is("select") || node.is("textarea");
+function isSpecialEmpty(node) {
+  return node.is("select") || node.is("textarea");
 }
 function classifyNodeText(node, options = {}) {
   const { accessible = false, ignoreHiddenRoot = false } = options;
@@ -5012,7 +4618,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;
@@ -5072,7 +4678,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;
@@ -5144,7 +4750,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;
@@ -5796,7 +5402,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;
@@ -5875,7 +5481,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;
         }
@@ -5908,7 +5514,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;
         }
@@ -5978,7 +5584,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) {
@@ -6026,7 +5632,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;
@@ -6110,7 +5716,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;
         }
@@ -6630,7 +6236,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);
@@ -9372,946 +8978,1459 @@ function matchFieldNames2(token) {
 function matchWebauthn(token) {
   return token === "webauthn";
 }
-function matchToken(token) {
-  if (matchSection(token)) {
-    return "section";
+function matchToken(token) {
+  if (matchSection(token)) {
+    return "section";
+  }
+  if (matchHint(token)) {
+    return "hint";
+  }
+  if (matchFieldNames1(token)) {
+    return "field1";
+  }
+  if (matchFieldNames2(token)) {
+    return "field2";
+  }
+  if (matchContact(token)) {
+    return "contact";
+  }
+  if (matchWebauthn(token)) {
+    return "webauthn";
+  }
+  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"]
+  };
+  return mapping[type] ?? [];
+}
+function isDisallowedType(node, type) {
+  if (!node.is("input")) {
+    return false;
+  }
+  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";
+  }
+}
+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";
+  }
+}
+class ValidAutocomplete extends Rule {
+  documentation(context) {
+    return {
+      description: getMarkdownMessage(context),
+      url: "https://html-validate.org/rules/valid-autocomplete.html"
+    };
+  }
+  setup() {
+    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(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);
+  }
+  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>"
+    };
+    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
+        });
+      }
+    }
+  }
+  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);
+  }
+  /**
+   * 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 */
+        };
+        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$3 = {
+  relaxed: false
+};
+class ValidID extends Rule {
+  constructor(options) {
+    super({ ...defaults$3, ...options });
   }
-  if (matchHint(token)) {
-    return "hint";
+  static schema() {
+    return {
+      relaxed: {
+        type: "boolean"
+      }
+    };
   }
-  if (matchFieldNames1(token)) {
-    return "field1";
+  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: [
+        `${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"
+    };
   }
-  if (matchFieldNames2(token)) {
-    return "field2";
+  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);
+      }
+    });
   }
-  if (matchContact(token)) {
-    return "contact";
+  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"
+    };
   }
-  if (matchWebauthn(token)) {
-    return "webauthn";
+  isRelevant(event) {
+    return event.key === "id";
   }
-  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;
+
+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;
   }
-  return [];
-}
-function isDisallowedType(node, type) {
-  if (!node.is("input")) {
-    return false;
+  setup() {
+    this.on("tag:end", (event) => {
+      const node = event.target;
+      if (!node) {
+        return;
+      }
+      if (!node.voidElement) {
+        return;
+      }
+      if (node.closed === NodeClosed.EndTag) {
+        this.report(
+          null,
+          `End tag for <${node.tagName}> must be omitted`,
+          node.location,
+          node.tagName
+        );
+      }
+    });
   }
-  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";
+
+const defaults$2 = {
+  style: "omit"
+};
+class VoidStyle extends Rule {
+  constructor(options) {
+    super({ ...defaults$2, ...options });
+    this.style = parseStyle(this.options.style);
   }
-}
-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";
+  static schema() {
+    return {
+      style: {
+        enum: ["omit", "selfclose", "selfclosing"],
+        type: "string"
+      }
+    };
   }
-}
-class ValidAutocomplete extends Rule {
   documentation(context) {
+    const [desc, end] = styleDescription(context.style);
     return {
-      description: getMarkdownMessage(context),
-      url: "https://html-validate.org/rules/valid-autocomplete.html"
+      description: `The current configuration requires void elements to ${desc}, use <${context.tagName}${end}> instead.`,
+      url: "https://html-validate.org/rules/void-style.html"
     };
   }
   setup() {
-    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);
+    this.on("tag:end", (event) => {
+      const active = event.previous;
+      if (active.meta) {
+        this.validateActive(active);
       }
     });
   }
-  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;
+  validateActive(node) {
+    if (!node.voidElement) {
+      return;
     }
-  }
-  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({
+    if (this.shouldBeOmitted(node)) {
+      this.reportError(
         node,
-        message: getTerminalMessage(context),
-        location: keyLocation,
-        context
-      });
-      return;
+        `Expected omitted end tag <${node.tagName}> instead of self-closing element <${node.tagName}/>`
+      );
     }
-    if (tokens.includes("on") || tokens.includes("off")) {
-      this.validateOnOff(node, mantle, tokens);
-      return;
+    if (this.shouldBeSelfClosed(node)) {
+      this.reportError(
+        node,
+        `Expected self-closing element <${node.tagName}/> instead of omitted end-tag <${node.tagName}>`
+      );
     }
-    this.validateTokens(node, tokens, keyLocation);
   }
-  validateFormAutocomplete(node, value, location) {
-    const trimmed = value.trim();
-    if (["on", "off"].includes(trimmed)) {
-      return;
-    }
+  reportError(node, message) {
     const context = {
-      msg: 1 /* InvalidValue */,
-      type: "form",
-      value: trimmed,
-      what: "<form>"
+      style: this.style,
+      tagName: node.tagName
     };
-    this.report({
-      node,
-      message: getTerminalMessage(context),
-      location,
-      context
-    });
+    super.report(node, message, null, 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
-        });
-      }
-    }
+  shouldBeOmitted(node) {
+    return this.style === 1 /* AlwaysOmit */ && node.closed === NodeClosed.VoidSelfClosed;
   }
-  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;
+  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 {
+  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"
+    };
+  }
+  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 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
-      });
-    }
+}
+
+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`);
+      }
+    });
   }
-  /**
-   * 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
-      });
-    }
+}
+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;
   }
-  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 */
-        };
+  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"
+    };
+  }
+  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: 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;
+    this.on("dom:ready", (event) => {
+      const { document } = event;
+      const nodes = document.querySelectorAll("img");
+      for (const node of nodes) {
+        this.validateNode(node);
       }
-      if (value === "") {
-        const context = 1 /* EMPTY */;
-        this.report(event.target, this.messages[context], event.location, context);
+    });
+  }
+  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;
       }
-      if (value.match(/\s/)) {
-        const context = 2 /* WHITESPACE */;
-        this.report(event.target, this.messages[context], event.valueLocation, context);
+    }
+    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);
+    }
+  }
+}
+
+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 { relaxed } = this.options;
-      if (relaxed) {
+      const scope = node.getAttribute("scope");
+      const value = scope == null ? void 0 : scope.value;
+      if (value instanceof DynamicValue) {
         return;
       }
-      if (value.match(/^[^\p{L}]/u)) {
-        const context = 3 /* LEADING_CHARACTER */;
-        this.report(event.target, this.messages[context], event.valueLocation, context);
+      if (value && validScopes.includes(value)) {
         return;
       }
-      if (value.match(/[^\p{L}\p{N}_-]/u)) {
-        const context = 4 /* DISALLOWED_CHARACTER */;
-        this.report(event.target, this.messages[context], event.valueLocation, context);
-      }
+      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);
     });
   }
-  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";
-  }
-}
-
-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"
+}
+
+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"
     };
-    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) {
+      if (!node || node.tagName !== "img") {
         return;
       }
-      if (!node.voidElement) {
+      const title = node.getAttribute("title");
+      if (!title || title.value === "") {
         return;
       }
-      if (node.closed === NodeClosed.EndTag) {
-        this.report(
-          null,
-          `End tag for <${node.tagName}> must be omitted`,
-          node.location,
-          node.tagName
-        );
+      const alt = node.getAttributeValue("alt");
+      if (alt && alt !== "") {
+        return;
       }
+      this.report(node, "<img> with empty alt text cannot have title attribute", title.keyLocation);
     });
   }
 }
 
-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 H71 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: "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("tag:end", (event) => {
-      const active = event.previous;
-      if (active.meta) {
-        this.validateActive(active);
+    this.on("dom:ready", (event) => {
+      const { document } = event;
+      const fieldsets = document.querySelectorAll(this.selector);
+      for (const fieldset of fieldsets) {
+        this.validate(fieldset);
       }
     });
   }
-  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}>`
-      );
+  validate(fieldset) {
+    const legend = fieldset.querySelectorAll("> legend");
+    if (legend.length === 0) {
+      this.reportNode(fieldset);
     }
   }
-  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;
+  reportNode(node) {
+    super.report(node, `${node.annotatedName} must have a <legend> as the first child`);
   }
-  shouldBeSelfClosed(node) {
-    return this.style === 2 /* AlwaysSelfclose */ && node.closed === NodeClosed.VoidOmitted;
+  get selector() {
+    return this.getTagsDerivedFrom("fieldset").join(",");
   }
 }
-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`);
-  }
+
+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);
 }
-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`);
+
+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 visit(node) {
+    node.childElements.forEach(visit);
+    if (!node.isRootElement()) {
+      callback(node);
+    }
   }
+  visit(root);
 }
+const walk = {
+  depthFirst
+};
 
-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"
-    };
+class DOMTree {
+  /**
+   * @internal
+   */
+  constructor(location) {
+    this.root = HtmlElement.rootNode(location);
+    this.active = this.root;
+    this.doctype = null;
+    this._readyState = "loading";
+  }
+  /**
+   * @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;
   }
-  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");
-      }
+  /**
+   * Resolve dynamic meta expressions.
+   *
+   * @internal
+   */
+  resolveMeta(table) {
+    this._readyState = "complete";
+    walk.depthFirst(this, (node) => {
+      table.resolve(node);
     });
   }
-}
-
-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"
-    };
+  getElementsByTagName(tagName) {
+    return this.root.getElementsByTagName(tagName);
   }
-  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`);
-      }
-    });
+  /**
+   * @deprecated use utility function `walk.depthFirst(..)` instead (since 8.21.0).
+   */
+  visitDepthFirst(callback) {
+    walk.depthFirst(this, callback);
   }
-}
-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;
+  /**
+   * @deprecated use `querySelector(..)` instead (since 8.21.0)
+   */
+  find(callback) {
+    return this.root.find(callback);
   }
-  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"
-    };
+  querySelector(selector) {
+    return this.root.querySelector(selector);
   }
-  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
-        });
-      }
-    });
+  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);
+  /**
+   * 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}"`);
     }
   }
-  reportNode(node) {
-    super.report(node, `${node.annotatedName} must have a <legend> as the first child`);
+}
+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}"`);
+    }
   }
-  get selector() {
-    return this.getTagsDerivedFrom("fieldset").join(",");
+}
+function parseQuantifier(quantifier) {
+  switch (quantifier) {
+    case "?":
+      return 1;
+    case "*":
+      return null;
+    default:
+      throw new Error(`Invalid quantifier "${quantifier}" used`);
   }
 }
 
-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 $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 = {};
@@ -11439,7 +11558,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
@@ -11791,15 +11910,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,
@@ -11970,7 +12080,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);
           }
         }
@@ -12047,33 +12157,8 @@ class Engine {
   }
   dumpTree(source) {
     const parser = this.instantiateParser();
-    const document = parser.parseHtml(source[0]);
-    const lines = [];
-    function decoration(node) {
-      let output = "";
-      if (node.id) {
-        output += `#${node.id}`;
-      }
-      if (node.hasAttribute("class")) {
-        output += `.${node.classList.join(".")}`;
-      }
-      return output;
-    }
-    function writeNode(node, level, sibling) {
-      if (node.parent) {
-        const indent = "  ".repeat(level - 1);
-        const l = node.childElements.length > 0 ? "\u252C" : "\u2500";
-        const b = sibling < node.parent.childElements.length - 1 ? "\u251C" : "\u2514";
-        lines.push(`${indent}${b}\u2500${l} ${node.tagName}${decoration(node)}`);
-      } else {
-        lines.push("(root)");
-      }
-      node.childElements.forEach((child, index) => {
-        writeNode(child, level + 1, index);
-      });
-    }
-    writeNode(document, 0, 0);
-    return lines;
+    const root = parser.parseHtml(source[0]);
+    return dumpTree(root);
   }
   /**
    * Get rule documentation.
@@ -12101,7 +12186,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":
@@ -12125,7 +12212,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));
     });
   }
@@ -12133,7 +12220,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));
     });
   }
@@ -12145,14 +12232,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) {
@@ -12163,7 +12250,7 @@ class Engine {
         }
       }
     });
-    parser.on("rule:error", (event, data) => {
+    parser.on("rule:error", (_event, data) => {
       if (data.blockers.includes(blocker)) {
         unused.delete(data.ruleId);
       }
@@ -12179,10 +12266,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);
       }
@@ -12746,7 +12833,7 @@ class HtmlValidate {
 }
 
 const name = "html-validate";
-const version = "8.20.1";
+const version = "8.22.0";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function definePlugin(plugin) {
@@ -12834,17 +12921,26 @@ const REPLACERS = [
   [
     // (a\ ) -> (a )
     // (a  ) -> (a)
+    // (a ) -> (a)
     // (a \ ) -> (a  )
-    /\\?\s+$/,
-    match => match.indexOf('\\') === 0
-      ? SPACE
-      : EMPTY
+    /((?:\\\\)*?)(\\?\s+)$/,
+    (_, m1, m2) => m1 + (
+      m2.indexOf('\\') === 0
+        ? SPACE
+        : EMPTY
+    )
   ],
 
   // replace (\ ) with ' '
+  // (\ ) -> ' '
+  // (\\ ) -> '\\ '
+  // (\\\ ) -> '\\ '
   [
-    /\\\s/g,
-    () => SPACE
+    /(\\+?)\s/g,
+    (_, m1) => {
+      const {length} = m1;
+      return m1.slice(0, length - length % 2) + SPACE
+    }
   ],
 
   // Escape metacharacters
@@ -13072,7 +13168,8 @@ const makeRegex = (pattern, ignoreCase) => {
 
   if (!source) {
     source = REPLACERS.reduce(
-      (prev, current) => prev.replace(current[0], current[1].bind(pattern)),
+      (prev, [matcher, replacer]) =>
+        prev.replace(matcher, replacer.bind(pattern)),
       pattern
     );
     regexCache[pattern] = source;
@@ -13438,6 +13535,81 @@ const defaults = {
   showSummary: true,
   showSelector: false
 };
+const NEWLINE = /\r\n|[\n\r\u2028\u2029]/;
+function getMarkerLines(loc, source) {
+  const startLoc = {
+    ...loc.start
+  };
+  const endLoc = {
+    ...startLoc,
+    ...loc.end
+  };
+  const linesAbove = 2;
+  const linesBelow = 3;
+  const startLine = startLoc.line;
+  const startColumn = startLoc.column;
+  const endLine = endLoc.line;
+  const endColumn = endLoc.column;
+  const start = Math.max(startLine - (linesAbove + 1), 0);
+  const end = Math.min(source.length, endLine + linesBelow);
+  const lineDiff = endLine - startLine;
+  const markerLines = {};
+  if (lineDiff) {
+    for (let i = 0; i <= lineDiff; i++) {
+      const lineNumber = i + startLine;
+      if (!startColumn) {
+        markerLines[lineNumber] = true;
+      } else if (i === 0) {
+        const sourceLength = source[lineNumber - 1].length;
+        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
+      } else if (i === lineDiff) {
+        markerLines[lineNumber] = [0, endColumn];
+      } else {
+        const sourceLength = source[lineNumber - i].length;
+        markerLines[lineNumber] = [0, sourceLength];
+      }
+    }
+  } else {
+    if (startColumn === endColumn) {
+      if (startColumn) {
+        markerLines[startLine] = [startColumn, 0];
+      } else {
+        markerLines[startLine] = true;
+      }
+    } else {
+      markerLines[startLine] = [startColumn, endColumn - startColumn];
+    }
+  }
+  return { start, end, markerLines };
+}
+function codeFrameColumns(rawLines, loc) {
+  const lines = rawLines.split(NEWLINE);
+  const { start, end, markerLines } = getMarkerLines(loc, lines);
+  const numberMaxWidth = String(end).length;
+  return rawLines.split(NEWLINE, end).slice(start, end).map((line, index) => {
+    const number = start + 1 + index;
+    const paddedNumber = ` ${String(number)}`.slice(-numberMaxWidth);
+    const gutter = ` ${paddedNumber} |`;
+    const hasMarker = markerLines[number];
+    if (hasMarker) {
+      let markerLine = "";
+      if (Array.isArray(hasMarker)) {
+        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, " ");
+        const numberOfMarkers = hasMarker[1] || 1;
+        markerLine = [
+          "\n ",
+          gutter.replace(/\d/g, " "),
+          " ",
+          markerSpacing,
+          "^".repeat(numberOfMarkers)
+        ].join("");
+      }
+      return [">", gutter, line.length > 0 ? ` ${line}` : "", markerLine].join("");
+    } else {
+      return [" ", gutter, line.length > 0 ? ` ${line}` : ""].join("");
+    }
+  }).join("\n");
+}
 function pluralize(word, count) {
   return count === 1 ? word : `${word}s`;
 }
@@ -13480,16 +13652,11 @@ function formatMessage(message, parentResult, options) {
   ].filter(String).join(" ");
   const result = [firstLine];
   if (sourceCode) {
-    result.push(
-      codeFrameColumns(
-        sourceCode,
-        {
-          start: getStartLocation(message),
-          end: getEndLocation(message, sourceCode)
-        },
-        { highlightCode: false }
-      )
-    );
+    const output = codeFrameColumns(sourceCode, {
+      start: getStartLocation(message),
+      end: getEndLocation(message, sourceCode)
+    });
+    result.push(output);
   }
   if (options.showSelector) {
     result.push(`${kleur.bold("Selector:")} ${message.selector ?? "-"}`);
@@ -13621,5 +13788,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