html-validate 7.8.0 → 7.10.0

package/dist/cjs/core.js

@@ -7,10 +7,10 @@ var Ajv = require('ajv');
 var deepmerge = require('deepmerge');
 var espree = require('espree');
 var walk = require('acorn-walk');
+var elements = require('./elements.js');
 var path = require('path');
 var semver = require('semver');
 var kleur = require('kleur');
-var elements = require('./elements.js');
 var codeFrame = require('@babel/code-frame');
 var stylishImpl = require('@html-validate/stylish');
 
@@ -3565,7 +3565,7 @@ class Rule {
     }
 }
 
-const defaults$t = {
+const defaults$u = {
     allowExternal: true,
     allowRelative: true,
     allowAbsolute: true,
@@ -3609,7 +3609,7 @@ function matchList(value, list) {
 }
 class AllowedLinks extends Rule {
     constructor(options) {
-        super({ ...defaults$t, ...options });
+        super({ ...defaults$u, ...options });
         this.allowExternal = parseAllow(this.options.allowExternal);
         this.allowRelative = parseAllow(this.options.allowRelative);
         this.allowAbsolute = parseAllow(this.options.allowAbsolute);
@@ -3757,7 +3757,7 @@ var RuleContext$1;
     RuleContext["MISSING_ALT"] = "missing-alt";
     RuleContext["MISSING_HREF"] = "missing-href";
 })(RuleContext$1 || (RuleContext$1 = {}));
-const defaults$s = {
+const defaults$t = {
     accessible: true,
 };
 function findByTarget(target, siblings) {
@@ -3766,7 +3766,7 @@ function findByTarget(target, siblings) {
 function getAltText(node) {
     return node.getAttributeValue("alt");
 }
-function getDescription(context) {
+function getDescription$1(context) {
     switch (context) {
         case RuleContext$1.MISSING_ALT:
             return [
@@ -3795,7 +3795,7 @@ function getDescription(context) {
 }
 class AreaAlt extends Rule {
     constructor(options) {
-        super({ ...defaults$s, ...options });
+        super({ ...defaults$t, ...options });
     }
     static schema() {
         return {
@@ -3806,7 +3806,7 @@ class AreaAlt extends Rule {
     }
     documentation(context) {
         return {
-            description: getDescription(context).join("\n"),
+            description: getDescription$1(context).join("\n"),
             url: "https://html-validate.org/rules/area-alt.html",
         };
     }
@@ -3959,13 +3959,13 @@ class AriaLabelMisuse extends Rule {
 class ConfigError extends UserError {
 }
 
-const defaults$r = {
+const defaults$s = {
     style: "lowercase",
     ignoreForeign: true,
 };
 class AttrCase extends Rule {
     constructor(options) {
-        super({ ...defaults$r, ...options });
+        super({ ...defaults$s, ...options });
         this.style = new rulesHelper.CaseStyle(this.options.style, "attr-case");
     }
     static schema() {
@@ -4310,7 +4310,7 @@ class AttrDelimiter extends Rule {
 }
 
 const DEFAULT_PATTERN = "[a-z0-9-:]+";
-const defaults$q = {
+const defaults$r = {
     pattern: DEFAULT_PATTERN,
     ignoreForeign: true,
 };
@@ -4347,7 +4347,7 @@ function generateDescription(name, pattern) {
 }
 class AttrPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$q, ...options });
+        super({ ...defaults$r, ...options });
         this.pattern = generateRegexp(this.options.pattern);
     }
     static schema() {
@@ -4408,7 +4408,7 @@ var QuoteStyle;
     QuoteStyle["AUTO_QUOTE"] = "auto";
     QuoteStyle["ANY_QUOTE"] = "any";
 })(QuoteStyle || (QuoteStyle = {}));
-const defaults$p = {
+const defaults$q = {
     style: "auto",
     unquoted: false,
 };
@@ -4448,10 +4448,6 @@ function describeStyle(style, unquoted) {
     return `${description.join(" or\n")}\n`;
 }
 class AttrQuotes extends Rule {
-    constructor(options) {
-        super({ ...defaults$p, ...options });
-        this.style = parseStyle$4(this.options.style);
-    }
     static schema() {
         return {
             style: {
@@ -4478,6 +4474,10 @@ class AttrQuotes extends Rule {
             url: "https://html-validate.org/rules/attr-quotes.html",
         };
     }
+    constructor(options) {
+        super({ ...defaults$q, ...options });
+        this.style = parseStyle$4(this.options.style);
+    }
     setup() {
         this.on("attr", (event) => {
             /* ignore attributes with no value */
@@ -4645,12 +4645,12 @@ class AttributeAllowedValues extends Rule {
     }
 }
 
-const defaults$o = {
+const defaults$p = {
     style: "omit",
 };
 class AttributeBooleanStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$o, ...options });
+        super({ ...defaults$p, ...options });
         this.hasInvalidStyle = parseStyle$3(this.options.style);
     }
     static schema() {
@@ -4726,12 +4726,12 @@ function reportMessage$1(attr, style) {
     return "";
 }
 
-const defaults$n = {
+const defaults$o = {
     style: "omit",
 };
 class AttributeEmptyStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$n, ...options });
+        super({ ...defaults$o, ...options });
         this.hasInvalidStyle = parseStyle$2(this.options.style);
     }
     static schema() {
@@ -4887,12 +4887,12 @@ function describePattern(pattern) {
     }
 }
 
-const defaults$m = {
+const defaults$n = {
     pattern: "kebabcase",
 };
 class ClassPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$m, ...options });
+        super({ ...defaults$n, ...options });
         this.pattern = parsePattern(this.options.pattern);
     }
     static schema() {
@@ -5001,13 +5001,13 @@ class CloseOrder extends Rule {
     }
 }
 
-const defaults$l = {
+const defaults$m = {
     include: null,
     exclude: null,
 };
 class Deprecated extends Rule {
     constructor(options) {
-        super({ ...defaults$l, ...options });
+        super({ ...defaults$m, ...options });
     }
     static schema() {
         return {
@@ -5170,12 +5170,12 @@ let NoStyleTag$1 = class NoStyleTag extends Rule {
     }
 };
 
-const defaults$k = {
+const defaults$l = {
     style: "uppercase",
 };
 class DoctypeStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$k, ...options });
+        super({ ...defaults$l, ...options });
     }
     static schema() {
         return {
@@ -5207,12 +5207,12 @@ class DoctypeStyle extends Rule {
     }
 }
 
-const defaults$j = {
+const defaults$k = {
     style: "lowercase",
 };
 class ElementCase extends Rule {
     constructor(options) {
-        super({ ...defaults$j, ...options });
+        super({ ...defaults$k, ...options });
         this.style = new rulesHelper.CaseStyle(this.options.style, "element-case");
     }
     static schema() {
@@ -5278,14 +5278,14 @@ class ElementCase extends Rule {
     }
 }
 
-const defaults$i = {
+const defaults$j = {
     pattern: "^[a-z][a-z0-9\\-._]*-[a-z0-9\\-._]*$",
     whitelist: [],
     blacklist: [],
 };
 class ElementName extends Rule {
     constructor(options) {
-        super({ ...defaults$i, ...options });
+        super({ ...defaults$j, ...options });
         // eslint-disable-next-line security/detect-non-literal-regexp
         this.pattern = new RegExp(this.options.pattern);
     }
@@ -5326,7 +5326,7 @@ class ElementName extends Rule {
                 ...context.blacklist.map((cur) => `- ${cur}`),
             ];
         }
-        if (context.pattern !== defaults$i.pattern) {
+        if (context.pattern !== defaults$j.pattern) {
             return [
                 `<${context.tagName}> is not a valid element name. This project is configured to only allow names matching the following regular expression:`,
                 "",
@@ -5799,9 +5799,9 @@ function hasImgAltText(node) {
     else if (node.is("svg")) {
         return node.textContent.trim() !== "";
     }
-    else {
-        return false;
-    }
+    /* istanbul ignore next -- querySelector(..) is only going to return the two
+     * above tags but this serves as a sane default if above assumption changes  */
+    return false;
 }
 class EmptyHeading extends Rule {
     documentation() {
@@ -5825,7 +5825,7 @@ class EmptyHeading extends Rule {
                 return;
             }
         }
-        switch (rulesHelper.classifyNodeText(heading)) {
+        switch (rulesHelper.classifyNodeText(heading, { ignoreHiddenRoot: true })) {
             case rulesHelper.TextClassification.DYNAMIC_TEXT:
             case rulesHelper.TextClassification.STATIC_TEXT:
                 /* have some text content, consider ok */
@@ -5874,7 +5874,7 @@ class EmptyTitle extends Rule {
     }
 }
 
-const defaults$h = {
+const defaults$i = {
     allowMultipleH1: false,
     minInitialRank: "h1",
     sectioningRoots: ["dialog", '[role="dialog"]'],
@@ -5905,7 +5905,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));
@@ -6063,12 +6063,12 @@ class HeadingLevel 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() {
@@ -6350,12 +6350,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() {
@@ -6438,6 +6438,49 @@ function parseContent(text) {
     }
 }
 
+function getName(attr) {
+    const name = attr.value;
+    if (!name || name instanceof DynamicValue) {
+        return null;
+    }
+    return name;
+}
+class MapDupName extends Rule {
+    documentation() {
+        return {
+            description: "`<map>` must have a unique name, it cannot be the same name as another `<map>` element",
+            url: "https://html-validate.org/rules/map-dup-name.html",
+        };
+    }
+    setup() {
+        this.on("dom:ready", (event) => {
+            const { document } = event;
+            const maps = document.querySelectorAll("map[name]");
+            const names = new Set();
+            for (const map of maps) {
+                const attr = map.getAttribute("name");
+                /* istanbul ignore next -- should not happen as querySelector matches
+                 * only the elements with the name attribute */
+                if (!attr) {
+                    continue;
+                }
+                const name = getName(attr);
+                if (!name) {
+                    continue;
+                }
+                if (names.has(name)) {
+                    this.report({
+                        node: map,
+                        message: `<map> name must be unique`,
+                        location: attr.keyLocation,
+                    });
+                }
+                names.add(name);
+            }
+        });
+    }
+}
+
 class MissingDoctype extends Rule {
     documentation() {
         return {
@@ -6502,13 +6545,13 @@ class MultipleLabeledControls extends Rule {
     }
 }
 
-const defaults$e = {
+const defaults$f = {
     include: null,
     exclude: null,
 };
 class NoAutoplay extends Rule {
     constructor(options) {
-        super({ ...defaults$e, ...options });
+        super({ ...defaults$f, ...options });
     }
     documentation(context) {
         const tagName = context ? ` on <${context.tagName}>` : "";
@@ -6749,14 +6792,14 @@ Omitted end tags can be ambigious for humans to read and many editors have troub
     }
 }
 
-const defaults$d = {
+const defaults$e = {
     include: null,
     exclude: null,
     allowedProperties: ["display"],
 };
 class NoInlineStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$d, ...options });
+        super({ ...defaults$e, ...options });
     }
     static schema() {
         return {
@@ -6958,7 +7001,7 @@ class NoMultipleMain extends Rule {
     }
 }
 
-const defaults$c = {
+const defaults$d = {
     relaxed: false,
 };
 const textRegexp = /([<>]|&(?![a-zA-Z0-9#]+;))/g;
@@ -6975,7 +7018,7 @@ const replacementTable = {
 };
 class NoRawCharacters extends Rule {
     constructor(options) {
-        super({ ...defaults$c, ...options });
+        super({ ...defaults$d, ...options });
         this.relaxed = this.options.relaxed;
     }
     static schema() {
@@ -7153,13 +7196,13 @@ class NoRedundantRole extends Rule {
 }
 
 const xmlns = /^(.+):.+$/;
-const defaults$b = {
+const defaults$c = {
     ignoreForeign: true,
     ignoreXML: true,
 };
 class NoSelfClosing extends Rule {
     constructor(options) {
-        super({ ...defaults$b, ...options });
+        super({ ...defaults$c, ...options });
     }
     static schema() {
         return {
@@ -7292,13 +7335,13 @@ const replacement = {
     reset: '<button type="reset">',
     image: '<button type="button">',
 };
-const defaults$a = {
+const defaults$b = {
     include: null,
     exclude: null,
 };
 class PreferButton extends Rule {
     constructor(options) {
-        super({ ...defaults$a, ...options });
+        super({ ...defaults$b, ...options });
     }
     static schema() {
         return {
@@ -7373,7 +7416,7 @@ class PreferButton extends Rule {
     }
 }
 
-const defaults$9 = {
+const defaults$a = {
     mapping: {
         article: "article",
         banner: "header",
@@ -7403,7 +7446,7 @@ const defaults$9 = {
 };
 class PreferNativeElement extends Rule {
     constructor(options) {
-        super({ ...defaults$9, ...options });
+        super({ ...defaults$a, ...options });
     }
     static schema() {
         return {
@@ -7523,12 +7566,12 @@ class PreferTbody extends Rule {
     }
 }
 
-const defaults$8 = {
+const defaults$9 = {
     tags: ["script", "style"],
 };
 class RequireCSPNonce extends Rule {
     constructor(options) {
-        super({ ...defaults$8, ...options });
+        super({ ...defaults$9, ...options });
     }
     static schema() {
         return {
@@ -7579,7 +7622,7 @@ class RequireCSPNonce extends Rule {
     }
 }
 
-const defaults$7 = {
+const defaults$8 = {
     target: "all",
     include: null,
     exclude: null,
@@ -7591,7 +7634,7 @@ const supportSri = {
 };
 class RequireSri extends Rule {
     constructor(options) {
-        super({ ...defaults$7, ...options });
+        super({ ...defaults$8, ...options });
         this.target = this.options.target;
     }
     static schema() {
@@ -7753,7 +7796,7 @@ class SvgFocusable extends Rule {
     }
 }
 
-const defaults$6 = {
+const defaults$7 = {
     characters: [
         { pattern: " ", replacement: "&nbsp;", description: "non-breaking space" },
         { pattern: "-", replacement: "&#8209;", description: "non-breaking hyphen" },
@@ -7796,7 +7839,7 @@ function matchAll(text, regexp) {
 }
 class TelNonBreaking extends Rule {
     constructor(options) {
-        super({ ...defaults$6, ...options });
+        super({ ...defaults$7, ...options });
         this.regex = constructRegex(this.options.characters);
     }
     static schema() {
@@ -8084,11 +8127,63 @@ class TextContent extends Rule {
     }
 }
 
-const regexp$1 = /&([a-z0-9]+|#x?[0-9a-f]+);/gi;
+const defaults$6 = {
+    ignoreCase: false,
+    requireSemicolon: true,
+};
+const regexp$1 = /&(?:[a-z0-9]+|#x?[0-9a-f]+)(;|[^a-z0-9]|$)/gi;
+const lowercaseEntities = elements.entities.map((it) => it.toLowerCase());
+function isNumerical(entity) {
+    return entity.startsWith("&#");
+}
+function getLocation(location, entity, match) {
+    var _a;
+    /* istanbul ignore next: never happens in practive */
+    const index = (_a = match.index) !== null && _a !== void 0 ? _a : 0;
+    return sliceLocation(location, index, index + entity.length);
+}
+function getDescription(context, options) {
+    const url = "https://html.spec.whatwg.org/multipage/named-characters.html";
+    let message;
+    if (context) {
+        if (context.terminated) {
+            message = `Unrecognized character reference \`${context.entity}\`.`;
+        }
+        else {
+            message = `Character reference \`${context.entity}\` must be terminated by a semicolon.`;
+        }
+    }
+    else {
+        message = `Unrecognized character reference.`;
+    }
+    return [
+        message,
+        `HTML5 defines a set of [valid character references](${url}) but this is not a valid one.`,
+        "",
+        "Ensure that:",
+        "",
+        "1. The character is one of the listed names.",
+        ...(options.ignoreCase ? [] : ["1. The case is correct (names are case sensitive)."]),
+        ...(options.requireSemicolon ? ["1. The name is terminated with a `;`."] : []),
+    ].join("\n");
+}
 class UnknownCharReference extends Rule {
+    constructor(options) {
+        super({ ...defaults$6, ...options });
+    }
+    static schema() {
+        return {
+            ignoreCase: {
+                type: "boolean",
+            },
+            requireSemicolon: {
+                type: "boolean",
+            },
+        };
+    }
     documentation(context) {
         return {
-            description: `HTML defines a set of valid character references but ${context || "this"} is not a valid one.`,
+            description: getDescription(context, this.options),
             url: "https://html-validate.org/rules/unrecognized-char-ref.html",
         };
     }
@@ -8100,7 +8195,9 @@ class UnknownCharReference extends Rule {
                 if (child.nodeType !== NodeType.TEXT_NODE) {
                     continue;
                 }
-                this.findCharacterReferences(child.textContent, child.location);
+                this.findCharacterReferences(node, child.textContent, child.location, {
+                    isAttribute: false,
+                });
             }
         });
         this.on("attr", (event) => {
@@ -8108,25 +8205,72 @@ class UnknownCharReference extends Rule {
             if (!event.value) {
                 return;
             }
-            this.findCharacterReferences(event.value.toString(), event.valueLocation);
+            this.findCharacterReferences(event.target, event.value.toString(), event.valueLocation, {
+                isAttribute: true,
+            });
         });
     }
-    findCharacterReferences(text, location) {
+    get entities() {
+        if (this.options.ignoreCase) {
+            return lowercaseEntities;
+        }
+        else {
+            return elements.entities;
+        }
+    }
+    /* eslint-disable-next-line complexity */
+    findCharacterReferences(node, text, location, { isAttribute }) {
+        const { requireSemicolon } = this.options;
+        const isQuerystring = isAttribute && text.includes("?");
+        for (const { match, entity, raw, terminated } of this.getMatches(text)) {
+            /* assume numeric entities are valid for now */
+            if (isNumerical(entity)) {
+                continue;
+            }
+            /* special case: when attributes use query parameters we skip checking
+             * unterminated attributes */
+            if (isQuerystring && !terminated) {
+                continue;
+            }
+            const found = this.entities.includes(entity);
+            /* ignore if this is a known character reference name */
+            if (found && (terminated || !requireSemicolon)) {
+                continue;
+            }
+            if (found && !terminated) {
+                const entityLocation = getLocation(location, entity, match);
+                const message = `Character reference "{{ entity }}" must be terminated by a semicolon`;
+                const context = {
+                    entity: raw,
+                    terminated: false,
+                };
+                this.report(node, message, entityLocation, context);
+                continue;
+            }
+            const entityLocation = getLocation(location, entity, match);
+            const message = `Unrecognized character reference "{{ entity }}"`;
+            const context = {
+                entity: raw,
+                terminated: true,
+            };
+            this.report(node, message, entityLocation, context);
+        }
+    }
+    *getMatches(text) {
         let match;
         do {
             match = regexp$1.exec(text);
             if (match) {
-                const entity = match[0];
-                /* assume numeric entities are valid for now */
-                if (entity.startsWith("&#")) {
-                    continue;
+                const terminator = match[1]; // === ";" ? match[1] : "";
+                const terminated = terminator === ";";
+                const needSlice = terminator !== ";" && terminator.length > 0;
+                const entity = needSlice ? match[0].slice(0, -1) : match[0];
+                if (this.options.ignoreCase) {
+                    yield { match, entity: entity.toLowerCase(), raw: entity, terminated };
                 }
-                /* ignore if this is a known character reference name */
-                if (elements.entities.includes(entity)) {
-                    continue;
+                else {
+                    yield { match, entity, raw: entity, terminated };
                 }
-                const entityLocation = sliceLocation(location, match.index, match.index + entity.length);
-                this.report(null, `Unrecognized character reference "${entity}"`, entityLocation, entity);
             }
         } while (match);
     }
@@ -8231,10 +8375,6 @@ const defaults$4 = {
     style: "omit",
 };
 class Void extends Rule {
-    constructor(options) {
-        super({ ...defaults$4, ...options });
-        this.style = parseStyle$1(this.options.style);
-    }
     get deprecated() {
         return true;
     }
@@ -8252,6 +8392,10 @@ class Void extends Rule {
             url: "https://html-validate.org/rules/void.html",
         };
     }
+    constructor(options) {
+        super({ ...defaults$4, ...options });
+        this.style = parseStyle$1(this.options.style);
+    }
     setup() {
         this.on("tag:end", (event) => {
             const current = event.target; // The current element being closed
@@ -8434,7 +8578,7 @@ class H30 extends Rule {
                     continue;
                 }
                 /* check if text content is present (or dynamic) */
-                const textClassification = rulesHelper.classifyNodeText(link);
+                const textClassification = rulesHelper.classifyNodeText(link, { ignoreHiddenRoot: true });
                 if (textClassification !== rulesHelper.TextClassification.EMPTY_TEXT) {
                     continue;
                 }
@@ -8622,6 +8766,32 @@ class H37 extends Rule {
     }
 }
 
+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) => {
+            var _a, _b, _c, _d;
+            const node = event.target;
+            /* only validate th */
+            if (!node || node.tagName !== "th") {
+                return;
+            }
+            /* ignore elements with valid scope values */
+            const scope = node.getAttributeValue("scope");
+            const scopeMeta = (_b = (_a = elements.html5 === null || elements.html5 === void 0 ? void 0 : elements.html5.th) === null || _a === void 0 ? void 0 : _a.attributes) === null || _b === void 0 ? void 0 : _b.scope;
+            if (scope && ((_c = scopeMeta.enum) === null || _c === void 0 ? void 0 : _c.includes(scope))) {
+                return;
+            }
+            this.report(node, `<th> element must have a valid scope attribute: ${((_d = scopeMeta.enum) !== null && _d !== void 0 ? _d : []).join(", ")}`, node.location);
+        });
+    }
+}
+
 class H67 extends Rule {
     documentation() {
         return {
@@ -8686,6 +8856,7 @@ const bundledRules$1 = {
     "wcag/h32": H32,
     "wcag/h36": H36,
     "wcag/h37": H37,
+    "wcag/h63": H63,
     "wcag/h67": H67,
     "wcag/h71": H71,
 };
@@ -8727,6 +8898,7 @@ const bundledRules = {
     "input-attributes": InputAttributes,
     "input-missing-label": InputMissingLabel,
     "long-title": LongTitle,
+    "map-dup-name": MapDupName,
     "meta-refresh": MetaRefresh,
     "missing-doctype": MissingDoctype,
     "multiple-labeled-controls": MultipleLabeledControls,
@@ -8789,6 +8961,7 @@ const config$3 = {
         "wcag/h32": "error",
         "wcag/h36": "error",
         "wcag/h37": "error",
+        "wcag/h63": "error",
         "wcag/h67": "error",
         "wcag/h71": "error",
     },
@@ -8836,6 +9009,7 @@ const config$1 = {
         "empty-title": "error",
         "input-attributes": "error",
         "long-title": "error",
+        "map-dup-name": "error",
         "meta-refresh": "error",
         "multiple-labeled-controls": "error",
         "no-autoplay": ["error", { include: ["audio", "video"] }],
@@ -8870,6 +9044,7 @@ const config$1 = {
         "wcag/h32": "error",
         "wcag/h36": "error",
         "wcag/h37": "error",
+        "wcag/h63": "error",
         "wcag/h67": "error",
         "wcag/h71": "error",
     },
@@ -8894,6 +9069,7 @@ const config = {
         "element-required-ancestor": "error",
         "element-required-attributes": "error",
         "element-required-content": "error",
+        "map-dup-name": "error",
         "multiple-labeled-controls": "error",
         "no-deprecated-attr": "error",
         "no-dup-attr": "error",
@@ -9070,38 +9246,6 @@ function configDataFromFile(filename) {
  * @public
  */
 class Config {
-    /**
-     * @internal
-     */
-    constructor(options) {
-        var _a;
-        this.transformers = [];
-        const initial = {
-            extends: [],
-            plugins: [],
-            rules: {},
-            transform: {},
-        };
-        this.config = mergeInternal(initial, options || {});
-        this.metaTable = null;
-        this.rootDir = this.findRootDir();
-        this.initialized = false;
-        /* load plugins */
-        this.plugins = this.loadPlugins(this.config.plugins || []);
-        this.configurations = this.loadConfigurations(this.plugins);
-        this.extendMeta(this.plugins);
-        /* process extended configs */
-        this.config = this.extendConfig((_a = this.config.extends) !== null && _a !== void 0 ? _a : []);
-        /* reset extends as we already processed them, this prevents the next config
-         * from reapplying config from extended config as well as duplicate entries
-         * when merging arrays */
-        this.config.extends = [];
-        /* rules explicitly set by passed options should have precedence over any
-         * extended rules, not the other way around. */
-        if (options && options.rules) {
-            this.config = mergeInternal(this.config, { rules: options.rules });
-        }
-    }
     /**
      * Create a new blank configuration. See also `Config.defaultConfig()`.
      */
@@ -9163,6 +9307,38 @@ class Config {
     static defaultConfig() {
         return new Config(defaultConfig);
     }
+    /**
+     * @internal
+     */
+    constructor(options) {
+        var _a;
+        this.transformers = [];
+        const initial = {
+            extends: [],
+            plugins: [],
+            rules: {},
+            transform: {},
+        };
+        this.config = mergeInternal(initial, options || {});
+        this.metaTable = null;
+        this.rootDir = this.findRootDir();
+        this.initialized = false;
+        /* load plugins */
+        this.plugins = this.loadPlugins(this.config.plugins || []);
+        this.configurations = this.loadConfigurations(this.plugins);
+        this.extendMeta(this.plugins);
+        /* process extended configs */
+        this.config = this.extendConfig((_a = this.config.extends) !== null && _a !== void 0 ? _a : []);
+        /* reset extends as we already processed them, this prevents the next config
+         * from reapplying config from extended config as well as duplicate entries
+         * when merging arrays */
+        this.config.extends = [];
+        /* rules explicitly set by passed options should have precedence over any
+         * extended rules, not the other way around. */
+        if (options && options.rules) {
+            this.config = mergeInternal(this.config, { rules: options.rules });
+        }
+    }
     /**
      * Initialize plugins, transforms etc.
      *
@@ -10982,10 +11158,19 @@ class HtmlValidate {
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "7.8.0";
+const version = "7.10.0";
 /** @public */
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
+/**
+ * Helper function to assist IDE with completion and type-checking.
+ *
+ * @public
+ */
+function definePlugin(plugin) {
+    return plugin;
+}
+
 const defaults$1 = {
     silent: false,
     version,
@@ -11440,6 +11625,7 @@ exports.bugs = bugs;
 exports.codeframe = codeframe;
 exports.compatibilityCheck = compatibilityCheck;
 exports.configDataFromFile = configDataFromFile;
+exports.definePlugin = definePlugin;
 exports.ensureError = ensureError;
 exports.generateIdSelector = generateIdSelector;
 exports.getFormatter = getFormatter;