html-validate 7.8.0 → 7.10.0

package/dist/es/core.js

@@ -5,10 +5,10 @@ import Ajv from 'ajv';
 import deepmerge from 'deepmerge';
 import * as espree from 'espree';
 import * as walk from 'acorn-walk';
+import { e as entities$1, h as html5, b as bundledElements } from './elements.js';
 import path from 'path';
 import semver from 'semver';
 import kleur from 'kleur';
-import { e as entities$1, b as bundledElements } from './elements.js';
 import { createRequire } from 'module';
 import { codeFrameColumns } from '@babel/code-frame';
 import stylishImpl from '@html-validate/stylish';
@@ -3533,7 +3533,7 @@ class Rule {
     }
 }
 
-const defaults$t = {
+const defaults$u = {
     allowExternal: true,
     allowRelative: true,
     allowAbsolute: true,
@@ -3577,7 +3577,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);
@@ -3725,7 +3725,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) {
@@ -3734,7 +3734,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 [
@@ -3763,7 +3763,7 @@ function getDescription(context) {
 }
 class AreaAlt extends Rule {
     constructor(options) {
-        super({ ...defaults$s, ...options });
+        super({ ...defaults$t, ...options });
     }
     static schema() {
         return {
@@ -3774,7 +3774,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",
         };
     }
@@ -3927,13 +3927,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 CaseStyle(this.options.style, "attr-case");
     }
     static schema() {
@@ -4278,7 +4278,7 @@ class AttrDelimiter extends Rule {
 }
 
 const DEFAULT_PATTERN = "[a-z0-9-:]+";
-const defaults$q = {
+const defaults$r = {
     pattern: DEFAULT_PATTERN,
     ignoreForeign: true,
 };
@@ -4315,7 +4315,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() {
@@ -4376,7 +4376,7 @@ var QuoteStyle;
     QuoteStyle["AUTO_QUOTE"] = "auto";
     QuoteStyle["ANY_QUOTE"] = "any";
 })(QuoteStyle || (QuoteStyle = {}));
-const defaults$p = {
+const defaults$q = {
     style: "auto",
     unquoted: false,
 };
@@ -4416,10 +4416,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: {
@@ -4446,6 +4442,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 */
@@ -4613,12 +4613,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() {
@@ -4694,12 +4694,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() {
@@ -4855,12 +4855,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() {
@@ -4969,13 +4969,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 {
@@ -5138,12 +5138,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 {
@@ -5175,12 +5175,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 CaseStyle(this.options.style, "element-case");
     }
     static schema() {
@@ -5246,14 +5246,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);
     }
@@ -5294,7 +5294,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:`,
                 "",
@@ -5767,9 +5767,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() {
@@ -5793,7 +5793,7 @@ class EmptyHeading extends Rule {
                 return;
             }
         }
-        switch (classifyNodeText(heading)) {
+        switch (classifyNodeText(heading, { ignoreHiddenRoot: true })) {
             case TextClassification.DYNAMIC_TEXT:
             case TextClassification.STATIC_TEXT:
                 /* have some text content, consider ok */
@@ -5842,7 +5842,7 @@ class EmptyTitle extends Rule {
     }
 }
 
-const defaults$h = {
+const defaults$i = {
     allowMultipleH1: false,
     minInitialRank: "h1",
     sectioningRoots: ["dialog", '[role="dialog"]'],
@@ -5873,7 +5873,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));
@@ -6031,12 +6031,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() {
@@ -6318,12 +6318,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() {
@@ -6406,6 +6406,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 {
@@ -6470,13 +6513,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}>` : "";
@@ -6717,14 +6760,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 {
@@ -6926,7 +6969,7 @@ class NoMultipleMain extends Rule {
     }
 }
 
-const defaults$c = {
+const defaults$d = {
     relaxed: false,
 };
 const textRegexp = /([<>]|&(?![a-zA-Z0-9#]+;))/g;
@@ -6943,7 +6986,7 @@ const replacementTable = {
 };
 class NoRawCharacters extends Rule {
     constructor(options) {
-        super({ ...defaults$c, ...options });
+        super({ ...defaults$d, ...options });
         this.relaxed = this.options.relaxed;
     }
     static schema() {
@@ -7121,13 +7164,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 {
@@ -7260,13 +7303,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 {
@@ -7341,7 +7384,7 @@ class PreferButton extends Rule {
     }
 }
 
-const defaults$9 = {
+const defaults$a = {
     mapping: {
         article: "article",
         banner: "header",
@@ -7371,7 +7414,7 @@ const defaults$9 = {
 };
 class PreferNativeElement extends Rule {
     constructor(options) {
-        super({ ...defaults$9, ...options });
+        super({ ...defaults$a, ...options });
     }
     static schema() {
         return {
@@ -7491,12 +7534,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 {
@@ -7547,7 +7590,7 @@ class RequireCSPNonce extends Rule {
     }
 }
 
-const defaults$7 = {
+const defaults$8 = {
     target: "all",
     include: null,
     exclude: null,
@@ -7559,7 +7602,7 @@ const supportSri = {
 };
 class RequireSri extends Rule {
     constructor(options) {
-        super({ ...defaults$7, ...options });
+        super({ ...defaults$8, ...options });
         this.target = this.options.target;
     }
     static schema() {
@@ -7721,7 +7764,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" },
@@ -7764,7 +7807,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() {
@@ -8052,11 +8095,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 = entities$1.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",
         };
     }
@@ -8068,7 +8163,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) => {
@@ -8076,25 +8173,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 entities$1;
+        }
+    }
+    /* 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 (entities$1.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);
     }
@@ -8199,10 +8343,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;
     }
@@ -8220,6 +8360,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
@@ -8402,7 +8546,7 @@ class H30 extends Rule {
                     continue;
                 }
                 /* check if text content is present (or dynamic) */
-                const textClassification = classifyNodeText(link);
+                const textClassification = classifyNodeText(link, { ignoreHiddenRoot: true });
                 if (textClassification !== TextClassification.EMPTY_TEXT) {
                     continue;
                 }
@@ -8590,6 +8734,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 = html5 === null || html5 === void 0 ? void 0 : 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 {
@@ -8654,6 +8824,7 @@ const bundledRules$1 = {
     "wcag/h32": H32,
     "wcag/h36": H36,
     "wcag/h37": H37,
+    "wcag/h63": H63,
     "wcag/h67": H67,
     "wcag/h71": H71,
 };
@@ -8695,6 +8866,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,
@@ -8757,6 +8929,7 @@ const config$3 = {
         "wcag/h32": "error",
         "wcag/h36": "error",
         "wcag/h37": "error",
+        "wcag/h63": "error",
         "wcag/h67": "error",
         "wcag/h71": "error",
     },
@@ -8804,6 +8977,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"] }],
@@ -8838,6 +9012,7 @@ const config$1 = {
         "wcag/h32": "error",
         "wcag/h36": "error",
         "wcag/h37": "error",
+        "wcag/h63": "error",
         "wcag/h67": "error",
         "wcag/h71": "error",
     },
@@ -8862,6 +9037,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",
@@ -9038,38 +9214,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()`.
      */
@@ -9131,6 +9275,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.
      *
@@ -10950,10 +11126,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,
@@ -11384,5 +11569,5 @@ function getFormatter(name) {
     return (_a = availableFormatters[name]) !== null && _a !== void 0 ? _a : null;
 }
 
-export { Config as C, DynamicValue as D, EventHandler as E, FileSystemConfigLoader as F, HtmlValidate as H, MetaTable as M, NodeClosed as N, Parser as P, Rule as R, Severity as S, TextNode as T, UserError as U, WrappedError as W, ConfigError as a, ConfigLoader as b, StaticConfigLoader as c, HtmlElement as d, SchemaValidationError as e, NestedError as f, MetaCopyableProperty as g, Reporter as h, TemplateExtractor as i, getFormatter as j, ensureError as k, legacyRequire as l, configDataFromFile as m, compatibilityCheck as n, codeframe as o, presets as p, isTextNode as q, ruleExists as r, sliceLocation as s, isElementNode as t, generateIdSelector as u, version as v, name as w, bugs as x };
+export { Config as C, DynamicValue as D, EventHandler as E, FileSystemConfigLoader as F, HtmlValidate as H, MetaTable as M, NodeClosed as N, Parser as P, Rule as R, Severity as S, TextNode as T, UserError as U, WrappedError as W, ConfigError as a, ConfigLoader as b, StaticConfigLoader as c, HtmlElement as d, SchemaValidationError as e, NestedError as f, MetaCopyableProperty as g, Reporter as h, TemplateExtractor as i, definePlugin as j, getFormatter as k, legacyRequire as l, ensureError as m, configDataFromFile as n, compatibilityCheck as o, presets as p, codeframe as q, ruleExists as r, sliceLocation as s, isTextNode as t, isElementNode as u, version as v, generateIdSelector as w, name as x, bugs as y };
 //# sourceMappingURL=core.js.map