html-validate 6.6.1 → 6.8.0

package/dist/es/core.js

@@ -2,6 +2,8 @@ import fs from 'fs';
 import betterAjvErrors from '@sidvind/better-ajv-errors';
 import Ajv from 'ajv';
 import deepmerge from 'deepmerge';
+import * as espree from 'espree';
+import * as walk from 'acorn-walk';
 import path from 'path';
 import semver from 'semver';
 import kleur from 'kleur';
@@ -245,7 +247,7 @@ class NestedError extends Error {
     constructor(message, nested) {
         super(message);
         Error.captureStackTrace(this, NestedError);
-        if (nested) {
+        if (nested && nested.stack) {
             this.stack += `\nCaused by: ${nested.stack}`;
         }
     }
@@ -1200,6 +1202,27 @@ class Attribute {
     }
 }
 
+function getCSSDeclarations(value) {
+    return value
+        .trim()
+        .split(";")
+        .filter(Boolean)
+        .map((it) => {
+        const [property, value] = it.split(":", 2);
+        return [property.trim(), value ? value.trim() : ""];
+    });
+}
+/**
+ * @internal
+ */
+function parseCssDeclaration(value) {
+    if (!value || value instanceof DynamicValue) {
+        return {};
+    }
+    const pairs = getCSSDeclarations(value);
+    return Object.fromEntries(pairs);
+}
+
 function sliceSize(size, begin, end) {
     if (typeof size !== "number") {
         return size;
@@ -1838,8 +1861,13 @@ var NodeClosed;
     NodeClosed[NodeClosed["VoidSelfClosed"] = 3] = "VoidSelfClosed";
     NodeClosed[NodeClosed["ImplicitClosed"] = 4] = "ImplicitClosed";
 })(NodeClosed || (NodeClosed = {}));
-function isElement(node) {
-    return node.nodeType === NodeType.ELEMENT_NODE;
+/**
+ * Returns true if the node is an element node.
+ *
+ * @public
+ */
+function isElementNode(node) {
+    return Boolean(node && node.nodeType === NodeType.ELEMENT_NODE);
 }
 function isValidTagName(tagName) {
     return Boolean(tagName !== "" && tagName !== "*");
@@ -1913,7 +1941,7 @@ class HtmlElement extends DOMNode {
      * Similar to childNodes but only elements.
      */
     get childElements() {
-        return this.childNodes.filter(isElement);
+        return this.childNodes.filter(isElementNode);
     }
     /**
      * Find the first ancestor matching a selector.
@@ -2143,6 +2171,10 @@ class HtmlElement extends DOMNode {
     get id() {
         return this.getAttributeValue("id");
     }
+    get style() {
+        const attr = this.getAttribute("style");
+        return parseCssDeclaration(attr === null || attr === void 0 ? void 0 : attr.value);
+    }
     /**
      * Returns the first child element or null if there are no child elements.
      */
@@ -2174,8 +2206,9 @@ class HtmlElement extends DOMNode {
         }, []);
     }
     querySelector(selector) {
+        var _a;
         const it = this.querySelectorImpl(selector);
-        return it.next().value || null;
+        return (_a = it.next().value) !== null && _a !== void 0 ? _a : null; // eslint-disable-line @typescript-eslint/no-unsafe-return
     }
     querySelectorAll(selector) {
         const it = this.querySelectorImpl(selector);
@@ -2742,8 +2775,6 @@ var configurationSchema = {
 };
 
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-const espree = legacyRequire("espree");
-const walk = legacyRequire("acorn-walk");
 function joinTemplateLiteral(nodes) {
     let offset = nodes[0].start + 1;
     let output = "";
@@ -2924,7 +2955,8 @@ class TemplateExtractor {
     extractObjectProperty(key) {
         const result = [];
         const { filename, data } = this;
-        walk.simple(this.ast, {
+        const node = this.ast;
+        walk.simple(node, {
             Property(node) {
                 if (compareKey(node.key, key, filename)) {
                     const source = extractLiteral(node.value, filename, data);
@@ -2948,7 +2980,7 @@ var TRANSFORMER_API;
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "6.6.1";
+const version = "6.8.0";
 /** @public */
 const homepage = "https://html-validate.org";
 /** @public */
@@ -3269,7 +3301,7 @@ function ruleDocumentationUrl(filename) {
     return `${homepage}/rules/${normalized}.html`;
 }
 
-const defaults$p = {
+const defaults$q = {
     allowExternal: true,
     allowRelative: true,
     allowAbsolute: true,
@@ -3313,7 +3345,7 @@ function matchList(value, list) {
 }
 class AllowedLinks extends Rule {
     constructor(options) {
-        super({ ...defaults$p, ...options });
+        super({ ...defaults$q, ...options });
         this.allowExternal = parseAllow(this.options.allowExternal);
         this.allowRelative = parseAllow(this.options.allowRelative);
         this.allowAbsolute = parseAllow(this.options.allowAbsolute);
@@ -3592,7 +3624,7 @@ class CaseStyle {
             default: {
                 const last = names.slice(-1);
                 const rest = names.slice(0, -1);
-                return `${rest.join(", ")} or ${last}`;
+                return `${rest.join(", ")} or ${last[0]}`;
             }
         }
     }
@@ -3608,19 +3640,19 @@ class CaseStyle {
                 case "camelcase":
                     return { pattern: /^[a-z][A-Za-z]*$/, name: "camelCase" };
                 default:
-                    throw new ConfigError(`Invalid style "${style}" for ${ruleId} rule`);
+                    throw new ConfigError(`Invalid style "${cur}" for ${ruleId} rule`);
             }
         });
     }
 }
 
-const defaults$o = {
+const defaults$p = {
     style: "lowercase",
     ignoreForeign: true,
 };
 class AttrCase extends Rule {
     constructor(options) {
-        super({ ...defaults$o, ...options });
+        super({ ...defaults$p, ...options });
         this.style = new CaseStyle(this.options.style, "attr-case");
     }
     static schema() {
@@ -3647,8 +3679,11 @@ class AttrCase extends Rule {
         };
     }
     documentation() {
+        const { style } = this.options;
         return {
-            description: `Attribute name must be ${this.options.style}.`,
+            description: Array.isArray(style)
+                ? [`Attribute name must be in one of:`, "", ...style.map((it) => `- ${it}`)].join("\n")
+                : `Attribute name must be in ${style}.`,
             url: ruleDocumentationUrl("@/rules/attr-case.ts"),
         };
     }
@@ -3939,7 +3974,7 @@ function isRelevant$3(event) {
 class AttrDelimiter extends Rule {
     documentation() {
         return {
-            description: `Attribute value should be separated by `,
+            description: `Attribute value must not be separated by whitespace.`,
             url: ruleDocumentationUrl("@/rules/attr-delimiter.ts"),
         };
     }
@@ -3956,7 +3991,7 @@ class AttrDelimiter extends Rule {
 }
 
 const DEFAULT_PATTERN = "[a-z0-9-:]+";
-const defaults$n = {
+const defaults$o = {
     pattern: DEFAULT_PATTERN,
     ignoreForeign: true,
 };
@@ -3993,7 +4028,7 @@ function generateDescription(name, pattern) {
 }
 class AttrPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$n, ...options });
+        super({ ...defaults$o, ...options });
         this.pattern = generateRegexp(this.options.pattern);
     }
     static schema() {
@@ -4053,13 +4088,13 @@ var QuoteStyle;
     QuoteStyle["DOUBLE_QUOTE"] = "\"";
     QuoteStyle["AUTO_QUOTE"] = "auto";
 })(QuoteStyle || (QuoteStyle = {}));
-const defaults$m = {
+const defaults$n = {
     style: "auto",
     unquoted: false,
 };
 class AttrQuotes extends Rule {
     constructor(options) {
-        super({ ...defaults$m, ...options });
+        super({ ...defaults$n, ...options });
         this.style = parseStyle$4(this.options.style);
     }
     static schema() {
@@ -4224,12 +4259,12 @@ class AttributeAllowedValues extends Rule {
     }
 }
 
-const defaults$l = {
+const defaults$m = {
     style: "omit",
 };
 class AttributeBooleanStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$l, ...options });
+        super({ ...defaults$m, ...options });
         this.hasInvalidStyle = parseStyle$3(this.options.style);
     }
     static schema() {
@@ -4305,12 +4340,12 @@ function reportMessage$1(attr, style) {
     return "";
 }
 
-const defaults$k = {
+const defaults$l = {
     style: "omit",
 };
 class AttributeEmptyStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$k, ...options });
+        super({ ...defaults$l, ...options });
         this.hasInvalidStyle = parseStyle$2(this.options.style);
     }
     static schema() {
@@ -4418,12 +4453,12 @@ function describePattern(pattern) {
     }
 }
 
-const defaults$j = {
+const defaults$k = {
     pattern: "kebabcase",
 };
 class ClassPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$j, ...options });
+        super({ ...defaults$k, ...options });
         this.pattern = parsePattern(this.options.pattern);
     }
     static schema() {
@@ -4449,7 +4484,9 @@ class ClassPattern extends Rule {
             classes.forEach((cur, index) => {
                 if (!cur.match(this.pattern)) {
                     const location = classes.location(index);
-                    this.report(event.target, `Class "${cur}" does not match required pattern "${this.pattern}"`, location);
+                    const pattern = this.pattern.toString();
+                    const message = `Class "${cur}" does not match required pattern "${pattern}"`;
+                    this.report(event.target, message, location);
                 }
             });
         });
@@ -4530,13 +4567,13 @@ class CloseOrder extends Rule {
     }
 }
 
-const defaults$i = {
+const defaults$j = {
     include: null,
     exclude: null,
 };
 class Deprecated extends Rule {
     constructor(options) {
-        super({ ...defaults$i, ...options });
+        super({ ...defaults$j, ...options });
     }
     static schema() {
         return {
@@ -4699,12 +4736,12 @@ class NoStyleTag$1 extends Rule {
     }
 }
 
-const defaults$h = {
+const defaults$i = {
     style: "uppercase",
 };
 class DoctypeStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$h, ...options });
+        super({ ...defaults$i, ...options });
     }
     static schema() {
         return {
@@ -4736,12 +4773,12 @@ class DoctypeStyle extends Rule {
     }
 }
 
-const defaults$g = {
+const defaults$h = {
     style: "lowercase",
 };
 class ElementCase extends Rule {
     constructor(options) {
-        super({ ...defaults$g, ...options });
+        super({ ...defaults$h, ...options });
         this.style = new CaseStyle(this.options.style, "element-case");
     }
     static schema() {
@@ -4765,8 +4802,11 @@ class ElementCase extends Rule {
         };
     }
     documentation() {
+        const { style } = this.options;
         return {
-            description: `Element tagname must be ${this.options.style}.`,
+            description: Array.isArray(style)
+                ? [`Element tagname must be in one of:`, "", ...style.map((it) => `- ${it}`)].join("\n")
+                : `Element tagname must be in ${style}.`,
             url: ruleDocumentationUrl("@/rules/element-case.ts"),
         };
     }
@@ -4804,14 +4844,14 @@ class ElementCase extends Rule {
     }
 }
 
-const defaults$f = {
+const defaults$g = {
     pattern: "^[a-z][a-z0-9\\-._]*-[a-z0-9\\-._]*$",
     whitelist: [],
     blacklist: [],
 };
 class ElementName extends Rule {
     constructor(options) {
-        super({ ...defaults$f, ...options });
+        super({ ...defaults$g, ...options });
         // eslint-disable-next-line security/detect-non-literal-regexp
         this.pattern = new RegExp(this.options.pattern);
     }
@@ -4852,7 +4892,7 @@ class ElementName extends Rule {
                 ...context.blacklist.map((cur) => `- ${cur}`),
             ];
         }
-        if (context.pattern !== defaults$f.pattern) {
+        if (context.pattern !== defaults$g.pattern) {
             return [
                 `<${context.tagName}> is not a valid element name. This project is configured to only allow names matching the following regular expression:`,
                 "",
@@ -5254,7 +5294,7 @@ class EmptyTitle extends Rule {
     }
 }
 
-const defaults$e = {
+const defaults$f = {
     allowMultipleH1: false,
     minInitialRank: "h1",
     sectioningRoots: ["dialog", '[role="dialog"]'],
@@ -5285,7 +5325,7 @@ function parseMaxInitial(value) {
 }
 class HeadingLevel extends Rule {
     constructor(options) {
-        super({ ...defaults$e, ...options });
+        super({ ...defaults$f, ...options });
         this.stack = [];
         this.minInitialRank = parseMaxInitial(this.options.minInitialRank);
         this.sectionRoots = this.options.sectioningRoots.map((it) => new Pattern(it));
@@ -5443,12 +5483,12 @@ class HeadingLevel extends Rule {
     }
 }
 
-const defaults$d = {
+const defaults$e = {
     pattern: "kebabcase",
 };
 class IdPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$d, ...options });
+        super({ ...defaults$e, ...options });
         this.pattern = parsePattern(this.options.pattern);
     }
     static schema() {
@@ -5467,6 +5507,7 @@ class IdPattern extends Rule {
     }
     setup() {
         this.on("attr", (event) => {
+            var _a;
             if (event.key.toLowerCase() !== "id") {
                 return;
             }
@@ -5475,7 +5516,10 @@ class IdPattern extends Rule {
                 return;
             }
             if (!event.value || !event.value.match(this.pattern)) {
-                this.report(event.target, `ID "${event.value}" does not match required pattern "${this.pattern}"`, event.valueLocation);
+                const value = (_a = event.value) !== null && _a !== void 0 ? _a : "";
+                const pattern = this.pattern.toString();
+                const message = `ID "${value}" does not match required pattern "${pattern}"`;
+                this.report(event.target, message, event.valueLocation);
             }
         });
     }
@@ -5795,12 +5839,12 @@ function findLabelByParent(el) {
     return [];
 }
 
-const defaults$c = {
+const defaults$d = {
     maxlength: 70,
 };
 class LongTitle extends Rule {
     constructor(options) {
-        super({ ...defaults$c, ...options });
+        super({ ...defaults$d, ...options });
         this.maxlength = this.options.maxlength;
     }
     static schema() {
@@ -5947,13 +5991,13 @@ class MultipleLabeledControls extends Rule {
     }
 }
 
-const defaults$b = {
+const defaults$c = {
     include: null,
     exclude: null,
 };
 class NoAutoplay extends Rule {
     constructor(options) {
-        super({ ...defaults$b, ...options });
+        super({ ...defaults$c, ...options });
     }
     documentation(context) {
         const tagName = context ? ` on <${context.tagName}>` : "";
@@ -6194,24 +6238,14 @@ Omitted end tags can be ambigious for humans to read and many editors have troub
     }
 }
 
-const defaults$a = {
+const defaults$b = {
     include: null,
     exclude: null,
     allowedProperties: ["display"],
 };
-function getCSSDeclarations(value) {
-    return value
-        .trim()
-        .split(";")
-        .filter(Boolean)
-        .map((it) => {
-        const [property, value] = it.split(":", 2);
-        return { property: property.trim(), value: value ? value.trim() : undefined };
-    });
-}
 class NoInlineStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$a, ...options });
+        super({ ...defaults$b, ...options });
     }
     static schema() {
         return {
@@ -6289,18 +6323,15 @@ class NoInlineStyle extends Rule {
         return true;
     }
     allPropertiesAllowed(value) {
-        if (typeof value !== "string") {
-            return false;
-        }
         const allowProperties = this.options.allowedProperties;
         /* quick path: no properties are allowed, no need to check each one individually */
         if (allowProperties.length === 0) {
             return false;
         }
-        const declarations = getCSSDeclarations(value);
+        const declarations = Object.keys(parseCssDeclaration(value));
         return (declarations.length > 0 &&
             declarations.every((it) => {
-                return allowProperties.includes(it.property);
+                return allowProperties.includes(it);
             }));
     }
 }
@@ -6416,24 +6447,24 @@ class NoMultipleMain extends Rule {
     }
 }
 
-const defaults$9 = {
+const defaults$a = {
     relaxed: false,
 };
 const textRegexp = /([<>]|&(?![a-zA-Z0-9#]+;))/g;
 const unquotedAttrRegexp = /([<>"'=`]|&(?![a-zA-Z0-9#]+;))/g;
 const matchTemplate = /^(<%.*?%>|<\?.*?\?>|<\$.*?\$>)$/s;
-const replacementTable = new Map([
-    ['"', "&quot;"],
-    ["&", "&amp;"],
-    ["'", "&apos;"],
-    ["<", "&lt;"],
-    ["=", "&equals;"],
-    [">", "&gt;"],
-    ["`", "&grave;"],
-]);
+const replacementTable = {
+    '"': "&quot;",
+    "&": "&amp;",
+    "'": "&apos;",
+    "<": "&lt;",
+    "=": "&equals;",
+    ">": "&gt;",
+    "`": "&grave;",
+};
 class NoRawCharacters extends Rule {
     constructor(options) {
-        super({ ...defaults$9, ...options });
+        super({ ...defaults$a, ...options });
         this.relaxed = this.options.relaxed;
     }
     static schema() {
@@ -6483,7 +6514,6 @@ class NoRawCharacters extends Rule {
      * @param text - The full text to find unescaped raw characters in.
      * @param location - Location of text.
      * @param regexp - Regexp pattern to match using.
-     * @param ignore - List of characters to ignore for this text.
      */
     findRawChars(node, text, location, regexp) {
         let match;
@@ -6499,7 +6529,7 @@ class NoRawCharacters extends Rule {
                     continue;
                 }
                 /* determine replacement character and location */
-                const replacement = replacementTable.get(char);
+                const replacement = replacementTable[char];
                 const charLocation = sliceLocation(location, match.index, match.index + 1);
                 /* report as error */
                 this.report(node, `Raw "${char}" must be encoded as "${replacement}"`, charLocation);
@@ -6612,13 +6642,13 @@ class NoRedundantRole extends Rule {
 }
 
 const xmlns = /^(.+):.+$/;
-const defaults$8 = {
+const defaults$9 = {
     ignoreForeign: true,
     ignoreXML: true,
 };
 class NoSelfClosing extends Rule {
     constructor(options) {
-        super({ ...defaults$8, ...options });
+        super({ ...defaults$9, ...options });
     }
     static schema() {
         return {
@@ -6751,13 +6781,13 @@ const replacement = {
     reset: '<button type="reset">',
     image: '<button type="button">',
 };
-const defaults$7 = {
+const defaults$8 = {
     include: null,
     exclude: null,
 };
 class PreferButton extends Rule {
     constructor(options) {
-        super({ ...defaults$7, ...options });
+        super({ ...defaults$8, ...options });
     }
     static schema() {
         return {
@@ -6832,7 +6862,7 @@ class PreferButton extends Rule {
     }
 }
 
-const defaults$6 = {
+const defaults$7 = {
     mapping: {
         article: "article",
         banner: "header",
@@ -6862,7 +6892,7 @@ const defaults$6 = {
 };
 class PreferNativeElement extends Rule {
     constructor(options) {
-        super({ ...defaults$6, ...options });
+        super({ ...defaults$7, ...options });
     }
     static schema() {
         return {
@@ -6982,7 +7012,7 @@ class PreferTbody extends Rule {
     }
 }
 
-const defaults$5 = {
+const defaults$6 = {
     target: "all",
 };
 const crossorigin = new RegExp("^(\\w+://|//)"); /* e.g. https:// or // */
@@ -6992,7 +7022,7 @@ const supportSri = {
 };
 class RequireSri extends Rule {
     constructor(options) {
-        super({ ...defaults$5, ...options });
+        super({ ...defaults$6, ...options });
         this.target = this.options.target;
     }
     static schema() {
@@ -7120,6 +7150,175 @@ class SvgFocusable extends Rule {
     }
 }
 
+const defaults$5 = {
+    characters: [
+        { pattern: " ", replacement: "&nbsp;", description: "non-breaking space" },
+        { pattern: "-", replacement: "&#8209;", description: "non-breaking hyphen" },
+    ],
+    ignoreClasses: [],
+    ignoreStyle: true,
+};
+function constructRegex(characters) {
+    const disallowed = characters
+        .map((it) => {
+        return it.pattern;
+    })
+        .join("|");
+    const pattern = `(${disallowed})`;
+    /* eslint-disable-next-line security/detect-non-literal-regexp */
+    return new RegExp(pattern, "g");
+}
+function getText(node) {
+    /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion */
+    const match = node.textContent.match(/^(\s*)(.*)$/);
+    const [, leading, text] = match;
+    return [leading.length, text.trimEnd()];
+}
+/**
+ * Node 12 does not support String.matchAll, this simulates it's behavior.
+ */
+function matchAll(text, regexp) {
+    /* eslint-disable-next-line security/detect-non-literal-regexp */
+    const copy = new RegExp(regexp);
+    const matches = [];
+    /* eslint-disable-next-line no-constant-condition */
+    while (true) {
+        const match = copy.exec(text);
+        if (match === null) {
+            break;
+        }
+        matches.push(match);
+    }
+    return matches;
+}
+class TelNonBreaking extends Rule {
+    constructor(options) {
+        super({ ...defaults$5, ...options });
+        this.regex = constructRegex(this.options.characters);
+    }
+    static schema() {
+        return {
+            characters: {
+                type: "array",
+                items: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        pattern: {
+                            type: "string",
+                        },
+                        replacement: {
+                            type: "string",
+                        },
+                        description: {
+                            type: "string",
+                        },
+                    },
+                },
+            },
+            ignoreClasses: {
+                type: "array",
+                items: {
+                    type: "string",
+                },
+            },
+            ignoreStyle: {
+                type: "boolean",
+            },
+        };
+    }
+    documentation(context) {
+        const { characters } = this.options;
+        const replacements = characters.map((it) => {
+            return `  - \`${it.pattern}\` - replace with \`${it.replacement}\` (${it.description}).`;
+        });
+        return {
+            description: [
+                context
+                    ? `The \`${context.pattern}\` character should be replaced with \`${context.replacement}\` character (${context.description}) when used in a telephone number.`
+                    : `Replace this character with a non-breaking version.`,
+                "",
+                "Unless non-breaking characters is used there could be a line break inserted at that character.",
+                "Line breaks make is harder to read and understand the telephone number.",
+                "",
+                "The following characters should be avoided:",
+                "",
+                ...replacements,
+            ].join("\n"),
+            url: ruleDocumentationUrl("@/rules/tel-non-breaking.ts"),
+        };
+    }
+    setup() {
+        this.on("element:ready", this.isRelevant, (event) => {
+            const { target } = event;
+            if (this.isIgnored(target)) {
+                return;
+            }
+            this.walk(target, target);
+        });
+    }
+    isRelevant(event) {
+        const { target } = event;
+        /* should only deal with anchors */
+        if (!target.is("a")) {
+            return false;
+        }
+        /* ignore if anchor does not have tel href */
+        const attr = target.getAttribute("href");
+        if (!attr || !attr.valueMatches(/^tel:/, false)) {
+            return false;
+        }
+        return true;
+    }
+    isIgnoredClass(node) {
+        const { ignoreClasses } = this.options;
+        const { classList } = node;
+        return ignoreClasses.some((it) => classList.contains(it));
+    }
+    isIgnoredStyle(node) {
+        const { ignoreStyle } = this.options;
+        const { style } = node;
+        if (!ignoreStyle) {
+            return false;
+        }
+        if (style["white-space"] === "nowrap" || style["white-space"] === "pre") {
+            return true;
+        }
+        return false;
+    }
+    isIgnored(node) {
+        return this.isIgnoredClass(node) || this.isIgnoredStyle(node);
+    }
+    walk(anchor, node) {
+        for (const child of node.childNodes) {
+            if (isTextNode(child)) {
+                this.detectDisallowed(anchor, child);
+            }
+            else if (isElementNode(child)) {
+                this.walk(anchor, child);
+            }
+        }
+    }
+    detectDisallowed(anchor, node) {
+        const [offset, text] = getText(node);
+        const matches = matchAll(text, this.regex);
+        for (const match of matches) {
+            const detected = match[0];
+            const entry = this.options.characters.find((it) => it.pattern === detected);
+            /* istanbul ignore next: should never happen and cannot be tested, just a sanity check */
+            if (!entry) {
+                throw new Error(`Failed to find entry for "${detected}" when searching text "${text}"`);
+            }
+            const message = `"${detected}" should be replaced with "${entry.replacement}" (${entry.description}) in telephone number`;
+            const begin = offset + match.index;
+            const end = begin + detected.length;
+            const location = sliceLocation(node.location, begin, end);
+            const context = entry;
+            this.report(anchor, message, location, context);
+        }
+    }
+}
+
 function hasAltText(image) {
     const alt = image.getAttribute("alt");
     /* missing or boolean */
@@ -9150,9 +9349,6 @@ function parseStyle$1(name) {
         case "selfclose":
         case "selfclosing":
             return Style$1.AlwaysSelfclose;
-        /* istanbul ignore next: covered by schema validation */
-        default:
-            throw new Error(`Invalid style "${name}" for "void" rule`);
     }
 }
 
@@ -9584,6 +9780,7 @@ const bundledRules = {
     "script-element": ScriptElement,
     "script-type": ScriptType,
     "svg-focusable": SvgFocusable,
+    "tel-non-breaking": TelNonBreaking,
     "text-content": TextContent,
     "unrecognized-char-ref": UnknownCharReference,
     void: Void,
@@ -9680,6 +9877,7 @@ const config$1 = {
         "script-element": "error",
         "script-type": "error",
         "svg-focusable": "off",
+        "tel-non-breaking": "error",
         "text-content": "error",
         "unrecognized-char-ref": "error",
         void: "off",
@@ -9785,7 +9983,8 @@ class ResolvedConfig {
                 });
             }
             catch (err) {
-                throw new NestedError(`When transforming "${source.filename}": ${err.message}`, err);
+                const message = err instanceof Error ? err.message : String(err);
+                throw new NestedError(`When transforming "${source.filename}": ${message}`, err);
             }
         }
         else {
@@ -9861,9 +10060,10 @@ function loadFromFile(filename) {
     }
     /* expand any relative paths */
     for (const key of ["extends", "elements", "plugins"]) {
-        if (!json[key])
+        const value = json[key];
+        if (!value)
             continue;
-        json[key] = json[key].map((ref) => {
+        json[key] = value.map((ref) => {
             return Config.expandRelative(ref, path.dirname(filename));
         });
     }
@@ -10021,6 +10221,7 @@ class Config {
     /**
      * Get element metadata.
      */
+    /* eslint-disable-next-line complexity, sonarjs/cognitive-complexity */
     getMetaTable() {
         /* use cached table if it exists */
         if (this.metaTable) {
@@ -10043,7 +10244,7 @@ class Config {
             }
             let filename;
             /* try searching builtin metadata */
-            filename = path.join(projectRoot, "elements", `${entry}.json`);
+            filename = path.join(projectRoot, "elements", `${entry}.js`);
             if (fs.existsSync(filename)) {
                 metaTable.loadFromFile(filename);
                 continue;
@@ -10059,7 +10260,8 @@ class Config {
                 metaTable.loadFromObject(legacyRequire(entry));
             }
             catch (err) {
-                throw new ConfigError(`Failed to load elements from "${entry}": ${err.message}`, err);
+                const message = err instanceof Error ? err.message : String(err);
+                throw new ConfigError(`Failed to load elements from "${entry}": ${message}`, err);
             }
         }
         metaTable.init();
@@ -10135,7 +10337,8 @@ class Config {
                 return plugin;
             }
             catch (err) {
-                throw new ConfigError(`Failed to load plugin "${moduleName}": ${err}`, err);
+                const message = err instanceof Error ? err.message : String(err);
+                throw new ConfigError(`Failed to load plugin "${moduleName}": ${message}`, err);
             }
         });
     }
@@ -11000,6 +11203,12 @@ class Parser {
     }
 }
 
+function freeze(src) {
+    return {
+        ...src,
+        selector: src.selector(),
+    };
+}
 /**
  * @internal
  */
@@ -11051,7 +11260,9 @@ class Reporter {
             line: location.line,
             column: location.column,
             size: location.size || 0,
-            selector: node ? node.generateSelector() : null,
+            selector() {
+                return node ? node.generateSelector() : null;
+            },
             context,
         });
     }
@@ -11065,7 +11276,7 @@ class Reporter {
         const report = {
             valid: this.isValid(),
             results: Object.keys(this.result).map((filePath) => {
-                const messages = Array.from(this.result[filePath]).sort(messageSort);
+                const messages = Array.from(this.result[filePath], freeze).sort(messageSort);
                 const source = (sources || []).find((source) => { var _a; return filePath === ((_a = source.filename) !== null && _a !== void 0 ? _a : ""); });
                 return {
                     filePath,
@@ -11139,7 +11350,7 @@ class Engine {
     /**
      * Lint sources and return report
      *
-     * @param src - Parsed source.
+     * @param sources - Sources to lint.
      * @returns Report output.
      */
     lint(sources) {
@@ -11233,7 +11444,7 @@ class Engine {
         const lines = [];
         function decoration(node) {
             let output = "";
-            if (node.hasAttribute("id")) {
+            if (node.id) {
                 output += `#${node.id}`;
             }
             if (node.hasAttribute("class")) {
@@ -11467,7 +11678,7 @@ class Engine {
             line: location.line,
             column: location.column,
             size: location.size || 0,
-            selector: null,
+            selector: () => null,
         });
     }
 }
@@ -11989,6 +12200,8 @@ const formatter$4 = checkstyleFormatter;
 
 const defaults = {
     showLink: true,
+    showSummary: true,
+    showSelector: false,
 };
 /**
  * Codeframe formatter based on ESLint codeframe.
@@ -12044,6 +12257,7 @@ function getEndLocation(message, source) {
  * @returns The formatted output.
  */
 function formatMessage(message, parentResult, options) {
+    var _a;
     const type = message.severity === 2 ? kleur.red("error") : kleur.yellow("warning");
     const msg = `${kleur.bold(message.message.replace(/([^ ])\.$/, "$1"))}`;
     const ruleId = kleur.dim(`(${message.ruleId})`);
@@ -12066,6 +12280,9 @@ function formatMessage(message, parentResult, options) {
             end: getEndLocation(message, sourceCode),
         }, { highlightCode: false }));
     }
+    if (options.showSelector) {
+        result.push(`${kleur.bold("Selector:")} ${(_a = message.selector) !== null && _a !== void 0 ? _a : "-"}`);
+    }
     if (options.showLink && message.ruleUrl) {
         result.push(`${kleur.bold("Details:")} ${message.ruleUrl}`);
     }
@@ -12103,9 +12320,11 @@ function codeframe(results, options) {
         return resultsOutput.concat(messages);
     }, [])
         .join("\n");
-    output += "\n";
-    output += formatSummary(errors, warnings);
-    output += "\n";
+    if (merged.showSummary) {
+        output += "\n";
+        output += formatSummary(errors, warnings);
+        output += "\n";
+    }
     return errors + warnings > 0 ? output : "";
 }
 const formatter$3 = codeframe;
@@ -12186,5 +12405,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, ConfigError as a, ConfigLoader as b, StaticConfigLoader as c, HtmlElement as d, SchemaValidationError as e, MetaCopyableProperty as f, Reporter as g, TemplateExtractor as h, getFormatter as i, compatibilityCheck as j, TokenType as k, legacyRequire as l, bugs as m, name as n, presets as p, ruleExists as r, version as v };
+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, ConfigError as a, ConfigLoader as b, StaticConfigLoader as c, HtmlElement as d, SchemaValidationError as e, MetaCopyableProperty as f, Reporter as g, TemplateExtractor as h, getFormatter as i, compatibilityCheck as j, codeframe as k, legacyRequire as l, bugs as m, name as n, presets as p, ruleExists as r, version as v };
 //# sourceMappingURL=core.js.map