html-validate 8.13.0 → 8.15.0

package/dist/es/core.js

@@ -3844,7 +3844,7 @@ class Rule {
   }
 }
 
-const defaults$v = {
+const defaults$w = {
   allowExternal: true,
   allowRelative: true,
   allowAbsolute: true,
@@ -3885,7 +3885,7 @@ function matchList(value, list) {
 }
 class AllowedLinks extends Rule {
   constructor(options) {
-    super({ ...defaults$v, ...options });
+    super({ ...defaults$w, ...options });
     this.allowExternal = parseAllow(this.options.allowExternal);
     this.allowRelative = parseAllow(this.options.allowRelative);
     this.allowAbsolute = parseAllow(this.options.allowAbsolute);
@@ -4049,7 +4049,7 @@ class AllowedLinks extends Rule {
   }
 }
 
-const defaults$u = {
+const defaults$v = {
   accessible: true
 };
 function findByTarget(target, siblings) {
@@ -4079,7 +4079,7 @@ function getDescription$1(context) {
 }
 class AreaAlt extends Rule {
   constructor(options) {
-    super({ ...defaults$u, ...options });
+    super({ ...defaults$v, ...options });
   }
   static schema() {
     return {
@@ -4158,7 +4158,7 @@ class AriaHiddenBody extends Rule {
   }
 }
 
-const defaults$t = {
+const defaults$u = {
   allowAnyNamable: false
 };
 const whitelisted = [
@@ -4200,7 +4200,7 @@ function isValidUsage(target, meta) {
 }
 class AriaLabelMisuse extends Rule {
   constructor(options) {
-    super({ ...defaults$t, ...options });
+    super({ ...defaults$u, ...options });
   }
   documentation() {
     const valid = [
@@ -4310,13 +4310,13 @@ class CaseStyle {
   }
 }
 
-const defaults$s = {
+const defaults$t = {
   style: "lowercase",
   ignoreForeign: true
 };
 class AttrCase extends Rule {
   constructor(options) {
-    super({ ...defaults$s, ...options });
+    super({ ...defaults$t, ...options });
     this.style = new CaseStyle(this.options.style, "attr-case");
   }
   static schema() {
@@ -4672,7 +4672,7 @@ class AttrDelimiter extends Rule {
 }
 
 const DEFAULT_PATTERN = "[a-z0-9-:]+";
-const defaults$r = {
+const defaults$s = {
   pattern: DEFAULT_PATTERN,
   ignoreForeign: true
 };
@@ -4704,7 +4704,7 @@ function generateDescription(name, pattern) {
 }
 class AttrPattern extends Rule {
   constructor(options) {
-    super({ ...defaults$r, ...options });
+    super({ ...defaults$s, ...options });
     this.pattern = generateRegexp(this.options.pattern);
   }
   static schema() {
@@ -4751,7 +4751,7 @@ class AttrPattern extends Rule {
   }
 }
 
-const defaults$q = {
+const defaults$r = {
   style: "auto",
   unquoted: false
 };
@@ -4790,7 +4790,7 @@ function describeStyle(style, unquoted) {
 }
 class AttrQuotes extends Rule {
   constructor(options) {
-    super({ ...defaults$q, ...options });
+    super({ ...defaults$r, ...options });
     this.style = parseStyle$3(this.options.style);
   }
   static schema() {
@@ -4974,12 +4974,12 @@ class AttributeAllowedValues extends Rule {
   }
 }
 
-const defaults$p = {
+const defaults$q = {
   style: "omit"
 };
 class AttributeBooleanStyle extends Rule {
   constructor(options) {
-    super({ ...defaults$p, ...options });
+    super({ ...defaults$q, ...options });
     this.hasInvalidStyle = parseStyle$2(this.options.style);
   }
   static schema() {
@@ -5046,12 +5046,12 @@ function reportMessage$1(attr, style) {
   return "";
 }
 
-const defaults$o = {
+const defaults$p = {
   style: "omit"
 };
 class AttributeEmptyStyle extends Rule {
   constructor(options) {
-    super({ ...defaults$o, ...options });
+    super({ ...defaults$p, ...options });
     this.hasInvalidStyle = parseStyle$1(this.options.style);
   }
   static schema() {
@@ -5191,12 +5191,12 @@ function describePattern(pattern) {
   }
 }
 
-const defaults$n = {
+const defaults$o = {
   pattern: "kebabcase"
 };
 class ClassPattern extends Rule {
   constructor(options) {
-    super({ ...defaults$n, ...options });
+    super({ ...defaults$o, ...options });
     this.pattern = parsePattern(this.options.pattern);
   }
   static schema() {
@@ -5302,13 +5302,13 @@ class CloseOrder extends Rule {
   }
 }
 
-const defaults$m = {
+const defaults$n = {
   include: null,
   exclude: null
 };
 class Deprecated extends Rule {
   constructor(options) {
-    super({ ...defaults$m, ...options });
+    super({ ...defaults$n, ...options });
   }
   static schema() {
     return {
@@ -5462,12 +5462,12 @@ let NoStyleTag$1 = class NoStyleTag extends Rule {
   }
 };
 
-const defaults$l = {
+const defaults$m = {
   style: "uppercase"
 };
 class DoctypeStyle extends Rule {
   constructor(options) {
-    super({ ...defaults$l, ...options });
+    super({ ...defaults$m, ...options });
   }
   static schema() {
     return {
@@ -5495,12 +5495,12 @@ class DoctypeStyle extends Rule {
   }
 }
 
-const defaults$k = {
+const defaults$l = {
   style: "lowercase"
 };
 class ElementCase extends Rule {
   constructor(options) {
-    super({ ...defaults$k, ...options });
+    super({ ...defaults$l, ...options });
     this.style = new CaseStyle(this.options.style, "element-case");
   }
   static schema() {
@@ -5560,14 +5560,14 @@ class ElementCase extends Rule {
   }
 }
 
-const defaults$j = {
+const defaults$k = {
   pattern: "^[a-z][a-z0-9\\-._]*-[a-z0-9\\-._]*$",
   whitelist: [],
   blacklist: []
 };
 class ElementName extends Rule {
   constructor(options) {
-    super({ ...defaults$j, ...options });
+    super({ ...defaults$k, ...options });
     this.pattern = new RegExp(this.options.pattern);
   }
   static schema() {
@@ -5604,7 +5604,7 @@ class ElementName extends Rule {
         ...context.blacklist.map((cur) => `- ${cur}`)
       ];
     }
-    if (context.pattern !== defaults$j.pattern) {
+    if (context.pattern !== defaults$k.pattern) {
       return [
         `<${context.tagName}> is not a valid element name. This project is configured to only allow names matching the following regular expression:`,
         "",
@@ -6093,7 +6093,7 @@ class EmptyTitle extends Rule {
   }
 }
 
-const defaults$i = {
+const defaults$j = {
   allowArrayBrackets: true,
   shared: ["radio", "button", "reset", "submit"]
 };
@@ -6121,7 +6121,7 @@ function getDocumentation(context) {
 }
 class FormDupName extends Rule {
   constructor(options) {
-    super({ ...defaults$i, ...options });
+    super({ ...defaults$j, ...options });
   }
   static schema() {
     return {
@@ -6270,7 +6270,7 @@ class FormDupName extends Rule {
   }
 }
 
-const defaults$h = {
+const defaults$i = {
   allowMultipleH1: false,
   minInitialRank: "h1",
   sectioningRoots: ["dialog", '[role="dialog"]', '[role="alertdialog"]']
@@ -6299,7 +6299,7 @@ function parseMaxInitial(value) {
 }
 class HeadingLevel extends Rule {
   constructor(options) {
-    super({ ...defaults$h, ...options });
+    super({ ...defaults$i, ...options });
     this.stack = [];
     this.minInitialRank = parseMaxInitial(this.options.minInitialRank);
     this.sectionRoots = this.options.sectioningRoots.map((it) => new Pattern(it));
@@ -6502,12 +6502,12 @@ class HiddenFocusable extends Rule {
   }
 }
 
-const defaults$g = {
+const defaults$h = {
   pattern: "kebabcase"
 };
 class IdPattern extends Rule {
   constructor(options) {
-    super({ ...defaults$g, ...options });
+    super({ ...defaults$h, ...options });
     this.pattern = parsePattern(this.options.pattern);
   }
   static schema() {
@@ -6546,26 +6546,6 @@ class IdPattern extends Rule {
 const restricted = /* @__PURE__ */ new Map([
   ["accept", ["file"]],
   ["alt", ["image"]],
-  [
-    "autocomplete",
-    [
-      "hidden",
-      "text",
-      "search",
-      "url",
-      "tel",
-      "email",
-      "password",
-      "date",
-      "month",
-      "week",
-      "time",
-      "datetime-local",
-      "number",
-      "range",
-      "color"
-    ]
-  ],
   ["capture", ["file"]],
   ["checked", ["checkbox", "radio"]],
   ["dirname", ["text", "search"]],
@@ -6860,12 +6840,12 @@ function findLabelByParent(el) {
   return [];
 }
 
-const defaults$f = {
+const defaults$g = {
   maxlength: 70
 };
 class LongTitle extends Rule {
   constructor(options) {
-    super({ ...defaults$f, ...options });
+    super({ ...defaults$g, ...options });
     this.maxlength = this.options.maxlength;
   }
   static schema() {
@@ -6894,7 +6874,13 @@ class LongTitle extends Rule {
   }
 }
 
+const defaults$f = {
+  allowLongDelay: false
+};
 class MetaRefresh extends Rule {
+  constructor(options) {
+    super({ ...defaults$f, ...options });
+  }
   documentation() {
     return {
       description: `Meta refresh directive must use the \`0;url=...\` format. Non-zero values for time interval is disallowed as people with assistive technology might be unable to read and understand the page content before automatically reloading. For the same reason skipping the url is disallowed as it would put the browser in an infinite loop reloading the same page over and over again.`,
@@ -6920,17 +6906,27 @@ class MetaRefresh extends Rule {
         this.report(target, "Malformed meta refresh directive", location);
         return;
       }
-      if (!value.url) {
-        this.report(target, "Don't use meta refresh to reload the page", location);
-      }
-      if (value.delay !== 0) {
-        this.report(target, "Meta refresh must use 0 second delay", location);
-      }
+      const { delay, url } = value;
+      this.validateDelay(target, location, delay, url);
     });
   }
+  validateDelay(target, location, delay, url) {
+    const { allowLongDelay } = this.options;
+    if (allowLongDelay && delay > 72e3) {
+      return;
+    }
+    if (!url && delay === 0) {
+      this.report(target, "Don't use instant meta refresh to reload the page", location);
+      return;
+    }
+    if (delay !== 0) {
+      const message = allowLongDelay ? "Meta refresh must be instant (0 second delay) or greater than 20 hours (72000 second delay)" : "Meta refresh must be instant (0 second delay)";
+      this.report(target, message, location);
+    }
+  }
 }
 function parseContent(text) {
-  const match = text.match(/^(\d+)(?:\s*;\s*url=(.*))?/);
+  const match = text.match(/^(\d+)(?:\s*;\s*url=(.*))?/i);
   if (match) {
     return {
       delay: parseInt(match[1], 10),
@@ -9017,6 +9013,522 @@ class UnknownCharReference extends Rule {
   }
 }
 
+const expectedOrder = ["section", "hint", "contact", "field1", "field2", "webauthn"];
+const fieldNames1 = [
+  "name",
+  "honorific-prefix",
+  "given-name",
+  "additional-name",
+  "family-name",
+  "honorific-suffix",
+  "nickname",
+  "username",
+  "new-password",
+  "current-password",
+  "one-time-code",
+  "organization-title",
+  "organization",
+  "street-address",
+  "address-line1",
+  "address-line2",
+  "address-line3",
+  "address-level4",
+  "address-level3",
+  "address-level2",
+  "address-level1",
+  "country",
+  "country-name",
+  "postal-code",
+  "cc-name",
+  "cc-given-name",
+  "cc-additional-name",
+  "cc-family-name",
+  "cc-number",
+  "cc-exp",
+  "cc-exp-month",
+  "cc-exp-year",
+  "cc-csc",
+  "cc-type",
+  "transaction-currency",
+  "transaction-amount",
+  "language",
+  "bday",
+  "bday-day",
+  "bday-month",
+  "bday-year",
+  "sex",
+  "url",
+  "photo"
+];
+const fieldNames2 = [
+  "tel",
+  "tel-country-code",
+  "tel-national",
+  "tel-area-code",
+  "tel-local",
+  "tel-local-prefix",
+  "tel-local-suffix",
+  "tel-extension",
+  "email",
+  "impp"
+];
+const fieldNameGroup = {
+  name: "text",
+  "honorific-prefix": "text",
+  "given-name": "text",
+  "additional-name": "text",
+  "family-name": "text",
+  "honorific-suffix": "text",
+  nickname: "text",
+  username: "username",
+  "new-password": "password",
+  "current-password": "password",
+  "one-time-code": "password",
+  "organization-title": "text",
+  organization: "text",
+  "street-address": "multiline",
+  "address-line1": "text",
+  "address-line2": "text",
+  "address-line3": "text",
+  "address-level4": "text",
+  "address-level3": "text",
+  "address-level2": "text",
+  "address-level1": "text",
+  country: "text",
+  "country-name": "text",
+  "postal-code": "text",
+  "cc-name": "text",
+  "cc-given-name": "text",
+  "cc-additional-name": "text",
+  "cc-family-name": "text",
+  "cc-number": "text",
+  "cc-exp": "month",
+  "cc-exp-month": "numeric",
+  "cc-exp-year": "numeric",
+  "cc-csc": "text",
+  "cc-type": "text",
+  "transaction-currency": "text",
+  "transaction-amount": "numeric",
+  language: "text",
+  bday: "date",
+  "bday-day": "numeric",
+  "bday-month": "numeric",
+  "bday-year": "numeric",
+  sex: "text",
+  url: "url",
+  photo: "url",
+  tel: "tel",
+  "tel-country-code": "text",
+  "tel-national": "text",
+  "tel-area-code": "text",
+  "tel-local": "text",
+  "tel-local-prefix": "text",
+  "tel-local-suffix": "text",
+  "tel-extension": "text",
+  email: "username",
+  impp: "url"
+};
+const disallowedInputTypes = ["checkbox", "radio", "file", "submit", "image", "reset", "button"];
+function matchSection(token) {
+  return token.startsWith("section-");
+}
+function matchHint(token) {
+  return token === "shipping" || token === "billing";
+}
+function matchFieldNames1(token) {
+  return fieldNames1.includes(token);
+}
+function matchContact(token) {
+  const haystack = ["home", "work", "mobile", "fax", "pager"];
+  return haystack.includes(token);
+}
+function matchFieldNames2(token) {
+  return fieldNames2.includes(token);
+}
+function matchWebauthn(token) {
+  return token === "webauthn";
+}
+function matchToken(token) {
+  if (matchSection(token)) {
+    return "section";
+  }
+  if (matchHint(token)) {
+    return "hint";
+  }
+  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"]
+  };
+  const groups = mapping[type];
+  if (groups) {
+    return groups;
+  }
+  return [];
+}
+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
 };
@@ -9571,6 +10083,7 @@ const bundledRules = {
   "text-content": TextContent,
   "unique-landmark": UniqueLandmark,
   "unrecognized-char-ref": UnknownCharReference,
+  "valid-autocomplete": ValidAutocomplete,
   "valid-id": ValidID,
   "void-content": VoidContent,
   "void-style": VoidStyle,
@@ -9601,6 +10114,7 @@ const config$4 = {
     "svg-focusable": "off",
     "text-content": "error",
     "unique-landmark": "error",
+    "valid-autocomplete": "error",
     "wcag/h30": "error",
     "wcag/h32": "error",
     "wcag/h36": "error",
@@ -9700,6 +10214,7 @@ const config$1 = {
     "text-content": "error",
     "unique-landmark": "error",
     "unrecognized-char-ref": "error",
+    "valid-autocomplete": "error",
     "valid-id": ["error", { relaxed: false }],
     void: "off",
     "void-content": "error",
@@ -9747,6 +10262,7 @@ const config = {
     "no-unused-disable": "error",
     "script-element": "error",
     "unrecognized-char-ref": "error",
+    "valid-autocomplete": "error",
     "valid-id": ["error", { relaxed: true }],
     "void-content": "error"
   }
@@ -11972,7 +12488,7 @@ class HtmlValidate {
 }
 
 const name = "html-validate";
-const version = "8.13.0";
+const version = "8.15.0";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function definePlugin(plugin) {