html-validate 6.5.0 → 6.7.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}`;
         }
     }
@@ -1838,8 +1840,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 !== "*");
@@ -1880,10 +1887,13 @@ class HtmlElement extends DOMNode {
     }
     /**
      * @internal
+     *
+     * @param namespace - If given it is appended to the tagName.
      */
-    static fromTokens(startToken, endToken, parent, metaTable) {
-        const tagName = startToken.data[2];
-        if (!tagName) {
+    static fromTokens(startToken, endToken, parent, metaTable, namespace = "") {
+        const name = startToken.data[2];
+        const tagName = namespace ? `${namespace}:${name}` : name;
+        if (!name) {
             throw new Error("tagName cannot be empty");
         }
         const meta = metaTable ? metaTable.getMetaFor(tagName) : null;
@@ -1910,7 +1920,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.
@@ -2171,8 +2181,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);
@@ -2739,8 +2750,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 = "";
@@ -2921,7 +2930,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);
@@ -2945,7 +2955,7 @@ var TRANSFORMER_API;
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "6.5.0";
+const version = "6.7.0";
 /** @public */
 const homepage = "https://html-validate.org";
 /** @public */
@@ -3266,7 +3276,7 @@ function ruleDocumentationUrl(filename) {
     return `${homepage}/rules/${normalized}.html`;
 }
 
-const defaults$p = {
+const defaults$q = {
     allowExternal: true,
     allowRelative: true,
     allowAbsolute: true,
@@ -3310,7 +3320,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);
@@ -3589,7 +3599,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]}`;
             }
         }
     }
@@ -3605,19 +3615,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() {
@@ -3644,8 +3654,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"),
         };
     }
@@ -3936,7 +3949,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"),
         };
     }
@@ -3953,7 +3966,7 @@ class AttrDelimiter extends Rule {
 }
 
 const DEFAULT_PATTERN = "[a-z0-9-:]+";
-const defaults$n = {
+const defaults$o = {
     pattern: DEFAULT_PATTERN,
     ignoreForeign: true,
 };
@@ -3990,7 +4003,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() {
@@ -4050,13 +4063,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() {
@@ -4221,12 +4234,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() {
@@ -4302,12 +4315,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() {
@@ -4415,12 +4428,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() {
@@ -4446,7 +4459,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);
                 }
             });
         });
@@ -4527,13 +4542,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 {
@@ -4696,12 +4711,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 {
@@ -4733,12 +4748,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() {
@@ -4762,8 +4777,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"),
         };
     }
@@ -4801,14 +4819,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);
     }
@@ -4849,7 +4867,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:`,
                 "",
@@ -5251,7 +5269,7 @@ class EmptyTitle extends Rule {
     }
 }
 
-const defaults$e = {
+const defaults$f = {
     allowMultipleH1: false,
     minInitialRank: "h1",
     sectioningRoots: ["dialog", '[role="dialog"]'],
@@ -5282,7 +5300,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));
@@ -5440,12 +5458,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() {
@@ -5464,6 +5482,7 @@ class IdPattern extends Rule {
     }
     setup() {
         this.on("attr", (event) => {
+            var _a;
             if (event.key.toLowerCase() !== "id") {
                 return;
             }
@@ -5472,7 +5491,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);
             }
         });
     }
@@ -5792,12 +5814,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() {
@@ -5944,13 +5966,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}>` : "";
@@ -6191,7 +6213,7 @@ 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"],
@@ -6208,7 +6230,7 @@ function getCSSDeclarations(value) {
 }
 class NoInlineStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$a, ...options });
+        super({ ...defaults$b, ...options });
     }
     static schema() {
         return {
@@ -6413,24 +6435,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() {
@@ -6480,7 +6502,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;
@@ -6496,7 +6517,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);
@@ -6609,13 +6630,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 {
@@ -6748,13 +6769,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 {
@@ -6829,7 +6850,7 @@ class PreferButton extends Rule {
     }
 }
 
-const defaults$6 = {
+const defaults$7 = {
     mapping: {
         article: "article",
         banner: "header",
@@ -6859,7 +6880,7 @@ const defaults$6 = {
 };
 class PreferNativeElement extends Rule {
     constructor(options) {
-        super({ ...defaults$6, ...options });
+        super({ ...defaults$7, ...options });
     }
     static schema() {
         return {
@@ -6979,7 +7000,7 @@ class PreferTbody extends Rule {
     }
 }
 
-const defaults$5 = {
+const defaults$6 = {
     target: "all",
 };
 const crossorigin = new RegExp("^(\\w+://|//)"); /* e.g. https:// or // */
@@ -6989,7 +7010,7 @@ const supportSri = {
 };
 class RequireSri extends Rule {
     constructor(options) {
-        super({ ...defaults$5, ...options });
+        super({ ...defaults$6, ...options });
         this.target = this.options.target;
     }
     static schema() {
@@ -7117,6 +7138,155 @@ class SvgFocusable extends Rule {
     }
 }
 
+const defaults$5 = {
+    characters: [
+        { pattern: " ", replacement: "&nbsp;", description: "non-breaking space" },
+        { pattern: "-", replacement: "&#8209;", description: "non-breaking hyphen" },
+    ],
+    ignoreClasses: [],
+};
+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",
+                },
+            },
+        };
+    }
+    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;
+            const { ignoreClasses } = this.options;
+            /* skip if element has a class in the ignore list */
+            const isIgnored = ignoreClasses.some((it) => target.classList.contains(it));
+            if (isIgnored) {
+                return;
+            }
+            this.walk(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;
+    }
+    walk(node) {
+        for (const child of node.childNodes) {
+            if (isTextNode(child)) {
+                this.detectDisallowed(child);
+            }
+            else if (isElementNode(child)) {
+                this.walk(child);
+            }
+        }
+    }
+    detectDisallowed(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}" 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(node, message, location, context);
+        }
+    }
+}
+
 function hasAltText(image) {
     const alt = image.getAttribute("alt");
     /* missing or boolean */
@@ -9147,9 +9317,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`);
     }
 }
 
@@ -9581,6 +9748,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,
@@ -9605,7 +9773,7 @@ const config$3 = {
         "no-redundant-for": "error",
         "no-redundant-role": "error",
         "prefer-native-element": "error",
-        "svg-focusable": "error",
+        "svg-focusable": "off",
         "text-content": "error",
         "wcag/h30": "error",
         "wcag/h32": "error",
@@ -9676,7 +9844,8 @@ const config$1 = {
         "prefer-tbody": "error",
         "script-element": "error",
         "script-type": "error",
-        "svg-focusable": "error",
+        "svg-focusable": "off",
+        "tel-non-breaking": "error",
         "text-content": "error",
         "unrecognized-char-ref": "error",
         void: "off",
@@ -9782,7 +9951,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 {
@@ -9858,9 +10028,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));
         });
     }
@@ -10018,6 +10189,7 @@ class Config {
     /**
      * Get element metadata.
      */
+    /* eslint-disable-next-line complexity, sonarjs/cognitive-complexity */
     getMetaTable() {
         /* use cached table if it exists */
         if (this.metaTable) {
@@ -10056,7 +10228,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();
@@ -10132,7 +10305,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);
             }
         });
     }
@@ -10454,6 +10628,9 @@ class ParserError extends Error {
 function isAttrValueToken(token) {
     return Boolean(token && token.type === TokenType.ATTR_VALUE);
 }
+function svgShouldRetainTag(foreignTagName, tagName) {
+    return foreignTagName === "svg" && ["title", "desc"].includes(tagName);
+}
 /**
  * Parse HTML document into a DOM tree.
  *
@@ -10466,6 +10643,7 @@ class Parser {
      * @param config - Configuration
      */
     constructor(config) {
+        this.currentNamespace = "";
         this.event = new EventHandler();
         this.dom = null;
         this.metaTable = config.getMetaTable();
@@ -10476,7 +10654,6 @@ class Parser {
      * @param source - HTML markup.
      * @returns DOM tree representing the HTML markup.
      */
-    // eslint-disable-next-line complexity
     parseHtml(source) {
         var _a, _b, _c, _d;
         if (typeof source === "string") {
@@ -10507,40 +10684,7 @@ class Parser {
         let it = this.next(tokenStream);
         while (!it.done) {
             const token = it.value;
-            switch (token.type) {
-                case TokenType.UNICODE_BOM:
-                    /* ignore */
-                    break;
-                case TokenType.TAG_OPEN:
-                    this.consumeTag(source, token, tokenStream);
-                    break;
-                case TokenType.WHITESPACE:
-                    this.trigger("whitespace", {
-                        text: token.data[0],
-                        location: token.location,
-                    });
-                    this.appendText(token.data[0], token.location);
-                    break;
-                case TokenType.DIRECTIVE:
-                    this.consumeDirective(token);
-                    break;
-                case TokenType.CONDITIONAL:
-                    this.consumeConditional(token);
-                    break;
-                case TokenType.COMMENT:
-                    this.consumeComment(token);
-                    break;
-                case TokenType.DOCTYPE_OPEN:
-                    this.consumeDoctype(token, tokenStream);
-                    break;
-                case TokenType.TEXT:
-                case TokenType.TEMPLATING:
-                    this.appendText(token.data[0], token.location);
-                    break;
-                case TokenType.EOF:
-                    this.closeTree(source, token.location);
-                    break;
-            }
+            this.consume(source, token, tokenStream);
             it = this.next(tokenStream);
         }
         /* resolve any dynamic meta element properties */
@@ -10587,13 +10731,50 @@ class Parser {
             return Boolean(active.parent && active.parent.is(tagName) && meta.includes(active.tagName));
         }
     }
+    /* eslint-disable-next-line complexity */
+    consume(source, token, tokenStream) {
+        switch (token.type) {
+            case TokenType.UNICODE_BOM:
+                /* ignore */
+                break;
+            case TokenType.TAG_OPEN:
+                this.consumeTag(source, token, tokenStream);
+                break;
+            case TokenType.WHITESPACE:
+                this.trigger("whitespace", {
+                    text: token.data[0],
+                    location: token.location,
+                });
+                this.appendText(token.data[0], token.location);
+                break;
+            case TokenType.DIRECTIVE:
+                this.consumeDirective(token);
+                break;
+            case TokenType.CONDITIONAL:
+                this.consumeConditional(token);
+                break;
+            case TokenType.COMMENT:
+                this.consumeComment(token);
+                break;
+            case TokenType.DOCTYPE_OPEN:
+                this.consumeDoctype(token, tokenStream);
+                break;
+            case TokenType.TEXT:
+            case TokenType.TEMPLATING:
+                this.appendText(token.data[0], token.location);
+                break;
+            case TokenType.EOF:
+                this.closeTree(source, token.location);
+                break;
+        }
+    }
     /* eslint-disable-next-line complexity, sonarjs/cognitive-complexity */
     consumeTag(source, startToken, tokenStream) {
         const tokens = Array.from(this.consumeUntil(tokenStream, TokenType.TAG_CLOSE, startToken.location));
         const endToken = tokens.slice(-1)[0];
         const closeOptional = this.closeOptional(startToken);
         const parent = closeOptional ? this.dom.getActive().parent : this.dom.getActive();
-        const node = HtmlElement.fromTokens(startToken, endToken, parent, this.metaTable);
+        const node = HtmlElement.fromTokens(startToken, endToken, parent, this.metaTable, this.currentNamespace);
         const isStartTag = !startToken.data[1];
         const isClosing = !isStartTag || node.closed !== NodeClosed.Open;
         const isForeign = node.meta && node.meta.foreign;
@@ -10698,6 +10879,15 @@ class Parser {
             const tokens = Array.from(this.consumeUntil(tokenStream, TokenType.TAG_OPEN, errorLocation));
             const [last] = tokens.slice(-1);
             const [, tagClosed, tagName] = last.data;
+            /* special case: svg <title> and <desc> should be intact as it affects accessibility */
+            if (!tagClosed && svgShouldRetainTag(foreignTagName, tagName)) {
+                const oldNamespace = this.currentNamespace;
+                this.currentNamespace = "svg";
+                this.consumeTag(source, last, tokenStream);
+                this.consumeUntilMatchingTag(source, tokenStream, tagName);
+                this.currentNamespace = oldNamespace;
+                continue;
+            }
             /* keep going unless the new tag matches the foreign root element */
             if (tagName !== foreignTagName) {
                 continue;
@@ -10896,6 +11086,35 @@ class Parser {
         }
         throw new ParserError(errorLocation, `stream ended before ${TokenType[search]} token was found`);
     }
+    /**
+     * Consumes tokens until a matching close-tag is found. Tags are appended to
+     * the document.
+     *
+     * @internal
+     */
+    consumeUntilMatchingTag(source, tokenStream, searchTag) {
+        let numOpen = 1;
+        let it = this.next(tokenStream);
+        while (!it.done) {
+            const token = it.value;
+            this.consume(source, token, tokenStream);
+            if (token.type === TokenType.TAG_OPEN) {
+                const [, close, tagName] = token.data;
+                if (tagName === searchTag) {
+                    if (close) {
+                        numOpen--;
+                    }
+                    else {
+                        numOpen++;
+                    }
+                    if (numOpen === 0) {
+                        return;
+                    }
+                }
+            }
+            it = this.next(tokenStream);
+        }
+    }
     next(tokenStream) {
         const it = tokenStream.next();
         if (!it.done) {
@@ -11091,7 +11310,7 @@ class Engine {
     /**
      * Lint sources and return report
      *
-     * @param src - Parsed source.
+     * @param sources - Sources to lint.
      * @returns Report output.
      */
     lint(sources) {
@@ -11185,7 +11404,7 @@ class Engine {
         const lines = [];
         function decoration(node) {
             let output = "";
-            if (node.hasAttribute("id")) {
+            if (node.id) {
                 output += `#${node.id}`;
             }
             if (node.hasAttribute("class")) {