html-validate 7.8.0 → 7.9.0

package/dist/cjs/core.js

@@ -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,
 };
@@ -4449,7 +4449,7 @@ function describeStyle(style, unquoted) {
 }
 class AttrQuotes extends Rule {
     constructor(options) {
-        super({ ...defaults$p, ...options });
+        super({ ...defaults$q, ...options });
         this.style = parseStyle$4(this.options.style);
     }
     static schema() {
@@ -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:`,
                 "",
@@ -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);
     }
@@ -8727,6 +8871,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,
@@ -8836,6 +8981,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"] }],
@@ -8894,6 +9040,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",
@@ -10982,10 +11129,19 @@ class HtmlValidate {
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "7.8.0";
+const version = "7.9.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 +11596,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;