html-validate 10.5.0 → 10.7.0

package/dist/esm/core.js

@@ -1207,7 +1207,9 @@ class MetaTable {
         );
       }
       for (const [key, value] of Object.entries(obj)) {
-        if (key === "$schema") continue;
+        if (key === "$schema") {
+          continue;
+        }
         this.addEntry(key, migrateElement(value));
       }
     } catch (err) {
@@ -1307,7 +1309,9 @@ class MetaTable {
    * global, e.g. to assign global attributes.
    */
   resolveGlobal() {
-    if (!this.elements["*"]) return;
+    if (!this.elements["*"]) {
+      return;
+    }
     const global = this.elements["*"];
     delete this.elements["*"];
     delete global.tagName;
@@ -1481,7 +1485,9 @@ function sliceSize(size, begin, end) {
   return Math.min(size, end - begin);
 }
 function sliceLocation(location, begin, end, wrap) {
-  if (!location) return null;
+  if (!location) {
+    return null;
+  }
   const size = sliceSize(location.size, begin, end);
   const sliced = {
     filename: location.filename,
@@ -2360,7 +2366,7 @@ class Selector {
 
 const TEXT_NODE_NAME = "#text";
 function isTextNode(node) {
-  return Boolean(node && node.nodeType === NodeType.TEXT_NODE);
+  return node?.nodeType === NodeType.TEXT_NODE;
 }
 class TextNode extends DOMNode {
   text;
@@ -2404,7 +2410,7 @@ var NodeClosed = /* @__PURE__ */ ((NodeClosed2) => {
   return NodeClosed2;
 })(NodeClosed || {});
 function isElementNode(node) {
-  return Boolean(node && node.nodeType === NodeType.ELEMENT_NODE);
+  return node?.nodeType === NodeType.ELEMENT_NODE;
 }
 function isInvalidTagName(tagName) {
   return tagName === "" || tagName === "*";
@@ -3700,6 +3706,7 @@ function interpolate(text, data) {
 
 const ajv$1 = new Ajv({ strict: true, strictTuples: true, strictTypes: true });
 ajv$1.addMetaSchema(ajvSchemaDraft);
+ajv$1.addKeyword(ajvRegexpKeyword);
 function getSchemaValidator(ruleId, properties) {
   const $id = `rule/${ruleId}`;
   const cached = ajv$1.getSchema($id);
@@ -3956,6 +3963,7 @@ class Rule {
    *
    * @internal
    */
+  /* eslint-disable-next-line @typescript-eslint/max-params -- technical debt */
   static validateOptions(cls, ruleId, jsonPath, options, filename, config) {
     if (!cls) {
       return;
@@ -3991,7 +3999,7 @@ class Rule {
   }
 }
 
-const defaults$y = {
+const defaults$z = {
   allowExternal: true,
   allowRelative: true,
   allowAbsolute: true,
@@ -4035,7 +4043,7 @@ class AllowedLinks extends Rule {
   allowRelative;
   allowAbsolute;
   constructor(options) {
-    super({ ...defaults$y, ...options });
+    super({ ...defaults$z, ...options });
     this.allowExternal = parseAllow(this.options.allowExternal);
     this.allowRelative = parseAllow(this.options.allowRelative);
     this.allowAbsolute = parseAllow(this.options.allowAbsolute);
@@ -4203,7 +4211,7 @@ class AllowedLinks extends Rule {
   }
 }
 
-const defaults$x = {
+const defaults$y = {
   accessible: true
 };
 function findByTarget(target, siblings) {
@@ -4233,7 +4241,7 @@ function getDescription$1(context) {
 }
 class AreaAlt extends Rule {
   constructor(options) {
-    super({ ...defaults$x, ...options });
+    super({ ...defaults$y, ...options });
   }
   static schema() {
     return {
@@ -4312,8 +4320,12 @@ class AriaHiddenBody extends Rule {
   }
 }
 
-const defaults$w = {
-  allowAnyNamable: false
+const defaults$x = {
+  allowAnyNamable: false,
+  elements: {
+    include: null,
+    exclude: null
+  }
 };
 const allowlist = /* @__PURE__ */ new Set([
   "main",
@@ -4356,7 +4368,26 @@ function isValidUsage(target, meta) {
 }
 class AriaLabelMisuse extends Rule {
   constructor(options) {
-    super({ ...defaults$w, ...options });
+    super({ ...defaults$x, ...options });
+  }
+  static schema() {
+    return {
+      allowAnyNamable: {
+        type: "boolean"
+      },
+      elements: {
+        type: "object",
+        properties: {
+          include: {
+            anyOf: [{ type: "array", items: { type: "string" } }, { type: "null" }]
+          },
+          exclude: {
+            anyOf: [{ type: "array", items: { type: "string" } }, { type: "null" }]
+          }
+        },
+        additionalProperties: false
+      }
+    };
   }
   documentation(context) {
     const valid = [
@@ -4414,6 +4445,9 @@ class AriaLabelMisuse extends Rule {
     if (!meta) {
       return;
     }
+    if (this.shouldIgnoreElement(target)) {
+      return;
+    }
     if (isValidUsage(target, meta)) {
       return;
     }
@@ -4438,6 +4472,9 @@ class AriaLabelMisuse extends Rule {
       });
     }
   }
+  shouldIgnoreElement(target) {
+    return isKeywordIgnored(this.options.elements, target.tagName, keywordPatternMatcher);
+  }
 }
 
 class ConfigError extends UserError {
@@ -4500,14 +4537,14 @@ class CaseStyle {
   }
 }
 
-const defaults$v = {
+const defaults$w = {
   style: "lowercase",
   ignoreForeign: true
 };
 class AttrCase extends Rule {
   style;
   constructor(options) {
-    super({ ...defaults$v, ...options });
+    super({ ...defaults$w, ...options });
     this.style = new CaseStyle(this.options.style, "attr-case");
   }
   static schema() {
@@ -4614,7 +4651,7 @@ const MATCH_TEXTAREA_DATA = /^[^]*?(?=<\/textarea)/;
 const MATCH_TEXTAREA_END = /^<(\/)(textarea)/;
 const MATCH_TITLE_DATA = /^[^]*?(?=<\/title)/;
 const MATCH_TITLE_END = /^<(\/)(title)/;
-const MATCH_DIRECTIVE = /^(<!--\s*\[html-validate-)([a-z0-9-]+)(\s*)(.*?)(]?\s*-->)/;
+const MATCH_DIRECTIVE = /^(<!--\s*\[?)(html-validate-)([a-z0-9-]+)(\s*)(.*?)(]?\s*-->)/;
 const MATCH_COMMENT = /^<!--([^]*?)-->/;
 const MATCH_CONDITIONAL = /^<!\[([^\]]*?)\]>/;
 class InvalidTokenError extends Error {
@@ -4912,7 +4949,7 @@ class AttrDelimiter extends Rule {
 }
 
 const DEFAULT_PATTERN = "[a-z0-9-:]+";
-const defaults$u = {
+const defaults$v = {
   pattern: DEFAULT_PATTERN,
   ignoreForeign: true
 };
@@ -4945,7 +4982,7 @@ function generateDescription(name, pattern) {
 class AttrPattern extends Rule {
   pattern;
   constructor(options) {
-    super({ ...defaults$u, ...options });
+    super({ ...defaults$v, ...options });
     this.pattern = generateRegexp(this.options.pattern);
   }
   static schema() {
@@ -4992,7 +5029,7 @@ class AttrPattern extends Rule {
   }
 }
 
-const defaults$t = {
+const defaults$u = {
   style: "auto",
   unquoted: false
 };
@@ -5058,7 +5095,7 @@ class AttrQuotes extends Rule {
     };
   }
   constructor(options) {
-    super({ ...defaults$t, ...options });
+    super({ ...defaults$u, ...options });
     this.style = parseStyle$3(this.options.style);
   }
   setup() {
@@ -5180,7 +5217,9 @@ class AttributeAllowedValues extends Rule {
       const doc = event.document;
       walk.depthFirst(doc, (node) => {
         const meta = node.meta;
-        if (!meta?.attributes) return;
+        if (!meta?.attributes) {
+          return;
+        }
         for (const attr of node.attributes) {
           if (Validator.validateAttribute(attr, meta.attributes)) {
             continue;
@@ -5212,13 +5251,13 @@ class AttributeAllowedValues extends Rule {
   }
 }
 
-const defaults$s = {
+const defaults$t = {
   style: "omit"
 };
 class AttributeBooleanStyle extends Rule {
   hasInvalidStyle;
   constructor(options) {
-    super({ ...defaults$s, ...options });
+    super({ ...defaults$t, ...options });
     this.hasInvalidStyle = parseStyle$2(this.options.style);
   }
   static schema() {
@@ -5240,9 +5279,13 @@ class AttributeBooleanStyle extends Rule {
       const doc = event.document;
       walk.depthFirst(doc, (node) => {
         const meta = node.meta;
-        if (!meta?.attributes) return;
+        if (!meta?.attributes) {
+          return;
+        }
         for (const attr of node.attributes) {
-          if (!this.isBoolean(attr, meta.attributes)) continue;
+          if (!this.isBoolean(attr, meta.attributes)) {
+            continue;
+          }
           if (attr.originalAttribute) {
             continue;
           }
@@ -5284,13 +5327,13 @@ function reportMessage$1(attr, style) {
   return "";
 }
 
-const defaults$r = {
+const defaults$s = {
   style: "omit"
 };
 class AttributeEmptyStyle extends Rule {
   hasInvalidStyle;
   constructor(options) {
-    super({ ...defaults$r, ...options });
+    super({ ...defaults$s, ...options });
     this.hasInvalidStyle = parseStyle$1(this.options.style);
   }
   static schema() {
@@ -5312,7 +5355,9 @@ class AttributeEmptyStyle extends Rule {
       const doc = event.document;
       walk.depthFirst(doc, (node) => {
         const meta = node.meta;
-        if (!meta?.attributes) return;
+        if (!meta?.attributes) {
+          return;
+        }
         for (const attr of node.attributes) {
           if (!allowsEmpty(attr, meta.attributes)) {
             continue;
@@ -5405,7 +5450,22 @@ class AttributeMisuse extends Rule {
   }
 }
 
+const patternNamesValues = [
+  "kebabcase",
+  "camelcase",
+  "underscore",
+  "snakecase",
+  "bem",
+  "tailwind"
+];
+const patternNames = new Set(patternNamesValues);
+function isNamedPattern(value) {
+  return typeof value === "string" && patternNames.has(value);
+}
 function parsePattern(pattern) {
+  if (pattern instanceof RegExp) {
+    return { regexp: pattern, description: pattern.toString() };
+  }
   switch (pattern) {
     case "kebabcase":
       return { regexp: /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/, description: pattern };
@@ -5423,7 +5483,21 @@ function parsePattern(pattern) {
         description: pattern
       };
     }
+    case "tailwind": {
+      return {
+        regexp: /^!?(?:[-a-z[]|\d+xl:)[\w\-:./\\[\]()#'&>,!=%]*$/,
+        description: "tailwind"
+      };
+    }
     default: {
+      if (pattern.startsWith("/") && pattern.endsWith("/")) {
+        const regexpSource = pattern.slice(1, -1);
+        const regexp2 = new RegExp(regexpSource);
+        return { regexp: regexp2, description: regexp2.toString() };
+      }
+      console.warn(
+        `Custom pattern "${pattern}" should be wrapped in forward slashes, e.g., "/${pattern}/". Support for unwrapped patterns is deprecated and will be removed in a future version.`
+      );
       const regexp = new RegExp(pattern);
       return { regexp, description: regexp.toString() };
     }
@@ -5431,27 +5505,49 @@ function parsePattern(pattern) {
 }
 
 function toArray$2(value) {
-  return Array.isArray(value) ? value : [value];
+  if (Array.isArray(value)) {
+    return value;
+  } else {
+    return [value];
+  }
+}
+function validateAllowedPatterns(patterns, allowedPatterns, ruleId) {
+  const extraneous = patterns.filter(isNamedPattern).filter((p) => !allowedPatterns.has(p));
+  if (extraneous.length > 0) {
+    const quote = (it) => `"${it}"`;
+    const disallowed = naturalJoin(extraneous.map(quote), "and");
+    const allowed = naturalJoin(Array.from(allowedPatterns, quote), "and");
+    throw new Error(
+      `Pattern ${disallowed} cannot be used with "${ruleId}". Allowed patterns: ${allowed}`
+    );
+  }
 }
 class BasePatternRule extends Rule {
   /** Attribute being tested */
   attr;
   /** Parsed configured patterns */
   patterns;
-  /**
-   * @param attr - Attribute holding the value.
-   * @param options - Rule options with defaults expanded.
-   */
-  constructor(attr, options) {
+  constructor({
+    ruleId,
+    attr,
+    options,
+    allowedPatterns
+  }) {
     super(options);
     const { pattern } = this.options;
     this.attr = attr;
-    this.patterns = toArray$2(pattern).map((it) => parsePattern(it));
+    const patterns = toArray$2(pattern);
+    validateAllowedPatterns(patterns, allowedPatterns, ruleId);
+    this.patterns = patterns.map((it) => parsePattern(it));
   }
   static schema() {
     return {
       pattern: {
-        oneOf: [{ type: "array", items: { type: "string" }, minItems: 1 }, { type: "string" }]
+        anyOf: [
+          { type: "array", items: { anyOf: [{ type: "string" }, { regexp: true }] }, minItems: 1 },
+          { type: "string" },
+          { regexp: true }
+        ]
       }
     };
   }
@@ -5485,12 +5581,18 @@ class BasePatternRule extends Rule {
   }
 }
 
-const defaults$q = {
+const defaults$r = {
   pattern: "kebabcase"
 };
 class ClassPattern extends BasePatternRule {
   constructor(options) {
-    super("class", { ...defaults$q, ...options });
+    super({
+      ruleId: "class-pattern",
+      attr: "class",
+      options: { ...defaults$r, ...options },
+      allowedPatterns: patternNames
+      // allow all patterns
+    });
   }
   static schema() {
     return BasePatternRule.schema();
@@ -5637,13 +5739,13 @@ class CloseOrder extends Rule {
   }
 }
 
-const defaults$p = {
+const defaults$q = {
   include: null,
   exclude: null
 };
 class Deprecated extends Rule {
   constructor(options) {
-    super({ ...defaults$p, ...options });
+    super({ ...defaults$q, ...options });
   }
   static schema() {
     return {
@@ -5797,12 +5899,12 @@ let NoStyleTag$1 = class NoStyleTag extends Rule {
   }
 };
 
-const defaults$o = {
+const defaults$p = {
   style: "uppercase"
 };
 class DoctypeStyle extends Rule {
   constructor(options) {
-    super({ ...defaults$o, ...options });
+    super({ ...defaults$p, ...options });
   }
   static schema() {
     return {
@@ -5830,13 +5932,13 @@ class DoctypeStyle extends Rule {
   }
 }
 
-const defaults$n = {
+const defaults$o = {
   style: "lowercase"
 };
 class ElementCase extends Rule {
   style;
   constructor(options) {
-    super({ ...defaults$n, ...options });
+    super({ ...defaults$o, ...options });
     this.style = new CaseStyle(this.options.style, "element-case");
   }
   static schema() {
@@ -5896,7 +5998,7 @@ class ElementCase extends Rule {
   }
 }
 
-const defaults$m = {
+const defaults$n = {
   pattern: "^[a-z][a-z0-9\\-._]*-[a-z0-9\\-._]*$",
   whitelist: [],
   blacklist: []
@@ -5904,7 +6006,7 @@ const defaults$m = {
 class ElementName extends Rule {
   pattern;
   constructor(options) {
-    super({ ...defaults$m, ...options });
+    super({ ...defaults$n, ...options });
     this.pattern = new RegExp(this.options.pattern);
   }
   static schema() {
@@ -5941,7 +6043,7 @@ class ElementName extends Rule {
         ...context.blacklist.map((cur) => `- ${cur}`)
       ];
     }
-    if (context.pattern !== defaults$m.pattern) {
+    if (context.pattern !== defaults$n.pattern) {
       return [
         `<${context.tagName}> is not a valid element name. This project is configured to only allow names matching the following regular expression:`,
         "",
@@ -6440,7 +6542,9 @@ class EmptyTitle extends Rule {
   setup() {
     this.on("tag:end", (event) => {
       const node = event.previous;
-      if (node.tagName !== "title") return;
+      if (node.tagName !== "title") {
+        return;
+      }
       switch (classifyNodeText(node)) {
         case TextClassification.DYNAMIC_TEXT:
         case TextClassification.STATIC_TEXT:
@@ -6456,7 +6560,7 @@ class EmptyTitle extends Rule {
   }
 }
 
-const defaults$l = {
+const defaults$m = {
   allowArrayBrackets: true,
   allowCheckboxDefault: true,
   shared: ["radio", "button", "reset", "submit"]
@@ -6516,7 +6620,7 @@ function getDocumentation(context) {
 }
 class FormDupName extends Rule {
   constructor(options) {
-    super({ ...defaults$l, ...options });
+    super({ ...defaults$m, ...options });
   }
   static schema() {
     return {
@@ -6675,7 +6779,7 @@ class FormDupName extends Rule {
   }
 }
 
-const defaults$k = {
+const defaults$l = {
   allowMultipleH1: false,
   minInitialRank: "h1",
   sectioningRoots: ["dialog", '[role="dialog"]', '[role="alertdialog"]']
@@ -6707,7 +6811,7 @@ class HeadingLevel extends Rule {
   sectionRoots;
   stack = [];
   constructor(options) {
-    super({ ...defaults$k, ...options });
+    super({ ...defaults$l, ...options });
     this.minInitialRank = parseMaxInitial(this.options.minInitialRank);
     this.sectionRoots = this.options.sectioningRoots.map((it) => new Compound(it));
     this.stack.push({
@@ -6761,7 +6865,9 @@ class HeadingLevel extends Rule {
   }
   onTagStart(event) {
     const level = extractLevel(event.target);
-    if (!level) return;
+    if (!level) {
+      return;
+    }
     const root = this.getCurrentRoot();
     if (!this.options.allowMultipleH1 && level === 1) {
       if (root.h1Count >= 1) {
@@ -6944,12 +7050,25 @@ class HiddenFocusable extends Rule {
   }
 }
 
-const defaults$j = {
+const defaults$k = {
   pattern: "kebabcase"
 };
+function exclude$1(set, ...values) {
+  const result = new Set(set);
+  for (const value of values) {
+    result.delete(value);
+  }
+  return result;
+}
 class IdPattern extends BasePatternRule {
   constructor(options) {
-    super("id", { ...defaults$j, ...options });
+    const allowedPatterns = exclude$1(patternNames, "tailwind");
+    super({
+      ruleId: "id-pattern",
+      attr: "id",
+      options: { ...defaults$k, ...options },
+      allowedPatterns
+    });
   }
   static schema() {
     return BasePatternRule.schema();
@@ -7253,7 +7372,9 @@ class InputMissingLabel extends Rule {
   }
 }
 function findLabelById(root, id) {
-  if (!id) return [];
+  if (!id) {
+    return [];
+  }
   return root.querySelectorAll(`label[for="${id}"]`);
 }
 function findLabelByParent(el) {
@@ -7267,13 +7388,13 @@ function findLabelByParent(el) {
   return [];
 }
 
-const defaults$i = {
+const defaults$j = {
   maxlength: 70
 };
 class LongTitle extends Rule {
   maxlength;
   constructor(options) {
-    super({ ...defaults$i, ...options });
+    super({ ...defaults$j, ...options });
     this.maxlength = this.options.maxlength;
   }
   static schema() {
@@ -7292,7 +7413,9 @@ class LongTitle extends Rule {
   setup() {
     this.on("tag:end", (event) => {
       const node = event.previous;
-      if (node.tagName !== "title") return;
+      if (node.tagName !== "title") {
+        return;
+      }
       const text = node.textContent;
       if (text.length > this.maxlength) {
         this.report(node, `title text cannot be longer than ${String(this.maxlength)} characters`);
@@ -7375,12 +7498,12 @@ class MapIdName extends Rule {
   }
 }
 
-const defaults$h = {
+const defaults$i = {
   allowLongDelay: false
 };
 class MetaRefresh extends Rule {
   constructor(options) {
-    super({ ...defaults$h, ...options });
+    super({ ...defaults$i, ...options });
   }
   documentation() {
     return {
@@ -7491,12 +7614,25 @@ class MultipleLabeledControls extends Rule {
   }
 }
 
-const defaults$g = {
+const defaults$h = {
   pattern: "camelcase"
 };
+function exclude(set, ...values) {
+  const result = new Set(set);
+  for (const value of values) {
+    result.delete(value);
+  }
+  return result;
+}
 class NamePattern extends BasePatternRule {
   constructor(options) {
-    super("name", { ...defaults$g, ...options });
+    const allowedPatterns = exclude(patternNames, "tailwind");
+    super({
+      ruleId: "name-pattern",
+      attr: "name",
+      options: { ...defaults$h, ...options },
+      allowedPatterns
+    });
   }
   static schema() {
     return BasePatternRule.schema();
@@ -7585,13 +7721,13 @@ class NoAbstractRole extends Rule {
   }
 }
 
-const defaults$f = {
+const defaults$g = {
   include: null,
   exclude: null
 };
 class NoAutoplay extends Rule {
   constructor(options) {
-    super({ ...defaults$f, ...options });
+    super({ ...defaults$g, ...options });
   }
   documentation(context) {
     return {
@@ -7857,7 +7993,7 @@ Omitted end tags can be ambigious for humans to read and many editors have troub
         return;
       }
       const parent = closed.parent;
-      const closedByParent = parent && parent.tagName === by.tagName;
+      const closedByParent = parent?.tagName === by.tagName;
       const closedByDocument = closedByParent && parent.isRootElement();
       const sameTag = closed.tagName === by.tagName;
       if (closedByDocument) {
@@ -7913,14 +8049,14 @@ class NoImplicitInputType extends Rule {
   }
 }
 
-const defaults$e = {
+const defaults$f = {
   include: null,
   exclude: null,
   allowedProperties: ["display"]
 };
 class NoInlineStyle extends Rule {
   constructor(options) {
-    super({ ...defaults$e, ...options });
+    super({ ...defaults$f, ...options });
   }
   static schema() {
     return {
@@ -8106,7 +8242,7 @@ class NoMultipleMain extends Rule {
   }
 }
 
-const defaults$d = {
+const defaults$e = {
   relaxed: false
 };
 const textRegexp = /([<>]|&(?![a-zA-Z0-9#]+;))/g;
@@ -8124,7 +8260,7 @@ const replacementTable = {
 class NoRawCharacters extends Rule {
   relaxed;
   constructor(options) {
-    super({ ...defaults$d, ...options });
+    super({ ...defaults$e, ...options });
     this.relaxed = this.options.relaxed;
   }
   static schema() {
@@ -8219,7 +8355,7 @@ class NoRedundantAriaLabel extends Rule {
           continue;
         }
         const label = document.querySelector(`label[for="${id}"]`);
-        if (!ariaLabel || !label || label.textContent.trim() !== ariaLabel.value) {
+        if (!ariaLabel || label?.textContent.trim() !== ariaLabel.value) {
           continue;
         }
         const message = "aria-label is redundant when label containing same text exists";
@@ -8304,13 +8440,13 @@ class NoRedundantRole extends Rule {
 }
 
 const xmlns = /^(.+):.+$/;
-const defaults$c = {
+const defaults$d = {
   ignoreForeign: true,
   ignoreXML: true
 };
 class NoSelfClosing extends Rule {
   constructor(options) {
-    super({ ...defaults$c, ...options });
+    super({ ...defaults$d, ...options });
   }
   static schema() {
     return {
@@ -8360,7 +8496,20 @@ function isRelevant(node, options) {
   return true;
 }
 
+const defaults$c = {
+  allowTemplate: true
+};
 class NoStyleTag extends Rule {
+  constructor(options) {
+    super({ ...defaults$c, ...options });
+  }
+  static schema() {
+    return {
+      allowTemplate: {
+        type: "boolean"
+      }
+    };
+  }
   documentation() {
     return {
       description: "Prefer to use external stylesheets with the `<link>` tag instead of inlining the styling.",
@@ -8368,9 +8517,13 @@ class NoStyleTag extends Rule {
     };
   }
   setup() {
+    const { allowTemplate } = this.options;
     this.on("tag:start", (event) => {
       const node = event.target;
       if (node.tagName === "style") {
+        if (allowTemplate && node.parent?.is("template")) {
+          return;
+        }
         this.report(node, "Use external stylesheet with <link> instead of <style> tag");
       }
     });
@@ -9277,7 +9430,7 @@ function getTextFromReference(document, id) {
   if (!id || id instanceof DynamicValue) {
     return id;
   }
-  const selector = `#${id}`;
+  const selector = generateIdSelector(id);
   const ref = document.querySelector(selector);
   if (ref) {
     return ref.textContent;
@@ -10038,6 +10191,46 @@ class ValidAutocomplete extends Rule {
   }
 }
 
+function isLabelable(target) {
+  const { meta } = target;
+  if (!meta) {
+    return true;
+  }
+  return Boolean(meta.labelable);
+}
+class ValidFor extends Rule {
+  documentation() {
+    return {
+      description: `The \`<label>\` \`for\` attribute must reference a labelable form control.`,
+      url: "https://html-validate.org/rules/valid-for.html"
+    };
+  }
+  setup() {
+    this.on("dom:ready", (event) => {
+      const { document } = event;
+      for (const node of document.querySelectorAll("label[for]")) {
+        const attr = node.getAttribute("for");
+        if (!isStaticAttribute(attr) || !attr.value) {
+          continue;
+        }
+        const selector = generateIdSelector(attr.value);
+        const target = document.querySelector(selector);
+        if (!target) {
+          continue;
+        }
+        if (isLabelable(target)) {
+          continue;
+        }
+        this.report({
+          node,
+          message: '<label> "for" attribute must reference a labelable form control',
+          location: attr.valueLocation
+        });
+      }
+    });
+  }
+}
+
 const defaults$4 = {
   relaxed: false
 };
@@ -10336,7 +10529,9 @@ class H36 extends Rule {
   setup() {
     this.on("tag:end", (event) => {
       const node = event.previous;
-      if (node.tagName !== "input") return;
+      if (node.tagName !== "input") {
+        return;
+      }
       if (node.getAttributeValue("type") !== "image") {
         return;
       }
@@ -10662,6 +10857,7 @@ const bundledRules = {
   "unique-landmark": UniqueLandmark,
   "unrecognized-char-ref": UnknownCharReference,
   "valid-autocomplete": ValidAutocomplete,
+  "valid-for": ValidFor,
   "valid-id": ValidID,
   "void-content": VoidContent,
   "void-style": VoidStyle,
@@ -11015,6 +11211,7 @@ const config$1 = {
     "unique-landmark": "error",
     "unrecognized-char-ref": "error",
     "valid-autocomplete": "error",
+    "valid-for": "error",
     "valid-id": ["error", { relaxed: false }],
     void: "off",
     "void-content": "error",
@@ -11062,6 +11259,7 @@ const config = {
     "script-element": "error",
     "unrecognized-char-ref": "error",
     "valid-autocomplete": "error",
+    "valid-for": "error",
     "valid-id": ["error", { relaxed: true }],
     "void-content": "error"
   }
@@ -11668,7 +11866,9 @@ class Config {
     }
     for (const plugin of plugins) {
       for (const [name, config] of Object.entries(plugin.configs ?? {})) {
-        if (!config) continue;
+        if (!config) {
+          continue;
+        }
         Config.validate(config, name);
         configs.set(`${plugin.name}:${name}`, config);
         if (plugin.name !== plugin.originalName) {
@@ -11969,7 +12169,7 @@ class EventHandler {
 }
 
 const name = "html-validate";
-const version = "10.5.0";
+const version = "10.7.0";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function freeze(src) {
@@ -12020,6 +12220,7 @@ class Reporter {
       warningCount: sumWarnings(results)
     };
   }
+  /* eslint-disable-next-line @typescript-eslint/max-params -- technical debt */
   add(rule, message, severity, node, location, context) {
     if (!(location.filename in this.result)) {
       this.result[location.filename] = [];
@@ -12139,7 +12340,7 @@ class ParserError extends Error {
 }
 
 function isAttrValueToken(token) {
-  return Boolean(token && token.type === TokenType.ATTR_VALUE);
+  return token?.type === TokenType.ATTR_VALUE;
 }
 function svgShouldRetainTag(foreignTagName, tagName) {
   return foreignTagName === "svg" && ["title", "desc"].includes(tagName);
@@ -12485,7 +12686,7 @@ class Parser {
    *      ^^^          ^^^         ^^^    (null)   (null)
    */
   getAttributeValueLocation(token) {
-    if (!token || token.type !== TokenType.ATTR_VALUE || token.data[2] === "") {
+    if (token?.type !== TokenType.ATTR_VALUE || token.data[2] === "") {
       return null;
     }
     const quote = token.data[3];
@@ -12501,7 +12702,7 @@ class Parser {
    */
   getAttributeLocation(key, value) {
     const begin = key.location;
-    const end = value && value.type === TokenType.ATTR_VALUE ? value.location : void 0;
+    const end = value?.type === TokenType.ATTR_VALUE ? value.location : void 0;
     return {
       filename: begin.filename,
       line: begin.line,
@@ -12514,27 +12715,34 @@ class Parser {
    * @internal
    */
   consumeDirective(token) {
-    const [text, preamble, action, separator1, directive, postamble] = token.data;
-    if (!postamble.startsWith("]")) {
-      throw new ParserError(token.location, `Missing end bracket "]" on directive "${text}"`);
+    const [text, preamble, prefix, action, separator1, directive, postamble] = token.data;
+    const hasStartBracket = preamble.includes("[");
+    const hasEndBracket = postamble.startsWith("]");
+    if (hasStartBracket && !hasEndBracket) {
+      this.trigger("parse:error", {
+        location: sliceLocation(token.location, preamble.length - 1, -postamble.length),
+        message: `Missing end bracket "]" on directive "${text}"`
+      });
+      return;
     }
     const match = /^(.*?)(?:(\s*(?:--|:)\s*)(.*))?$/.exec(directive);
     if (!match) {
       throw new Error(`Failed to parse directive "${text}"`);
     }
     if (!isValidDirective(action)) {
-      throw new ParserError(token.location, `Unknown directive "${action}"`);
+      const begin = preamble.length;
+      const end = preamble.length + prefix.length + action.length;
+      this.trigger("parse:error", {
+        location: sliceLocation(token.location, begin, -text.length + end),
+        message: `Unknown directive "${action}"`
+      });
+      return;
     }
     const [, data, separator2, comment] = match;
-    const prefix = "html-validate-";
-    const actionOffset = preamble.length;
+    const actionOffset = preamble.length + prefix.length;
     const optionsOffset = actionOffset + action.length + separator1.length;
     const commentOffset = optionsOffset + data.length + (separator2 || "").length;
-    const location = sliceLocation(
-      token.location,
-      preamble.length - prefix.length - 1,
-      -postamble.length + 1
-    );
+    const location = sliceLocation(token.location, preamble.length - 1, -postamble.length + 1);
     const actionLocation = sliceLocation(
       token.location,
       actionOffset,
@@ -12616,7 +12824,9 @@ class Parser {
     while (!it.done) {
       const token = it.value;
       yield token;
-      if (token.type === search) return;
+      if (token.type === search) {
+        return;
+      }
       it = this.next(tokenStream);
     }
     throw new ParserError(
@@ -12779,6 +12989,9 @@ class Engine {
       parser.on("directive", (_2, event) => {
         this.processDirective(event, parser, directiveContext);
       });
+      parser.on("parse:error", (_2, event) => {
+        this.reportError("parser-error", event.message, event.location);
+      });
       try {
         parser.parseHtml(source);
       } catch (e) {
@@ -12976,7 +13189,9 @@ class Engine {
     const availableRules = {};
     for (const plugin of config.getPlugins()) {
       for (const [name, rule] of Object.entries(plugin.rules ?? {})) {
-        if (!rule) continue;
+        if (!rule) {
+          continue;
+        }
         availableRules[name] = rule;
       }
     }
@@ -13009,6 +13224,7 @@ class Engine {
   /**
    * Load and setup a rule using current config.
    */
+  /* eslint-disable-next-line @typescript-eslint/max-params -- technical debt */
   loadRule(ruleId, config, severity, options, parser, report) {
     const meta = config.getMetaTable();
     const rule = this.instantiateRule(ruleId, options);
@@ -14373,5 +14589,5 @@ const engines = {
 
 var workerPath = "./jest-worker.js";
 
-export { compatibilityCheckImpl as $, Attribute as A, Reporter as B, Config as C, DOMNode as D, definePlugin as E, ruleExists as F, walk as G, HtmlElement as H, EventHandler as I, engines as J, normalizeSource as K, transformSource as L, MetaCopyableProperty as M, NodeClosed as N, Engine as O, Parser as P, transformSourceSync as Q, ResolvedConfig as R, Severity as S, TextNode as T, UserError as U, Validator as V, WrappedError as W, transformFilename as X, transformFilenameSync as Y, configurationSchema as Z, isThenable as _, ConfigError as a, workerPath as a0, codeframe as a1, name as a2, bugs as a3, ConfigLoader as b, defineConfig as c, deepmerge as d, ensureError as e, StaticConfigLoader as f, getFormatter as g, DOMTokenList as h, ignore as i, DOMTree as j, DynamicValue as k, NodeType as l, NestedError as m, SchemaValidationError as n, isUserError as o, presets as p, MetaTable as q, TextContent$1 as r, staticResolver as s, Rule as t, TextClassification as u, version as v, ariaNaming as w, classifyNodeText as x, keywordPatternMatcher as y, sliceLocation as z };
+export { engines as $, Attribute as A, isUserError as B, ConfigLoader as C, DOMNode as D, Engine as E, MetaTable as F, TextContent$1 as G, HtmlElement as H, Rule as I, TextClassification as J, ariaNaming as K, classifyNodeText as L, MetaCopyableProperty as M, NodeClosed as N, keywordPatternMatcher as O, Parser as P, sliceLocation as Q, Reporter as R, StaticConfigLoader as S, TextNode as T, UserError as U, Validator as V, WrappedError as W, definePlugin as X, ruleExists as Y, walk as Z, EventHandler as _, transformSourceSync as a, workerPath as a0, codeframe as a1, name as a2, bugs as a3, transformFilename as b, transformFilenameSync as c, configurationSchema as d, ConfigError as e, Config as f, compatibilityCheckImpl as g, getFormatter as h, isThenable as i, ensureError as j, deepmerge as k, ignore as l, ResolvedConfig as m, normalizeSource as n, Severity as o, presets as p, defineConfig as q, DOMTokenList as r, staticResolver as s, transformSource as t, DOMTree as u, version as v, DynamicValue as w, NodeType as x, NestedError as y, SchemaValidationError as z };
 //# sourceMappingURL=core.js.map