html-validate 6.8.0 → 6.10.0

package/dist/cjs/core.js

@@ -274,6 +274,42 @@ var ajvSchemaDraft = {
 }
 };
 
+function stringify(value) {
+    if (typeof value === "string") {
+        return String(value);
+    }
+    else {
+        return JSON.stringify(value);
+    }
+}
+/**
+ * Represents an `Error` created from arbitrary values.
+ *
+ * @public
+ */
+class WrappedError extends Error {
+    constructor(message) {
+        super(stringify(message));
+    }
+}
+
+/**
+ * Ensures the value is an Error.
+ *
+ * If the passed value is not an `Error` instance a [[WrappedError]] is
+ * constructed with the stringified value.
+ *
+ * @internal
+ */
+function ensureError(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    else {
+        return new WrappedError(value);
+    }
+}
+
 class NestedError extends Error {
     constructor(message, nested) {
         super(message);
@@ -327,6 +363,32 @@ class SchemaValidationError extends UserError {
     }
 }
 
+/**
+ * Computes hash for given string.
+ *
+ * @internal
+ */
+function cyrb53(str) {
+    const a = 2654435761;
+    const b = 1597334677;
+    const c = 2246822507;
+    const d = 3266489909;
+    const e = 4294967296;
+    const f = 2097151;
+    const seed = 0;
+    let h1 = 0xdeadbeef ^ seed;
+    let h2 = 0x41c6ce57 ^ seed;
+    for (let i = 0, ch; i < str.length; i++) {
+        ch = str.charCodeAt(i);
+        h1 = Math.imul(h1 ^ ch, a);
+        h2 = Math.imul(h2 ^ ch, b);
+    }
+    h1 = Math.imul(h1 ^ (h1 >>> 16), c) ^ Math.imul(h2 ^ (h2 >>> 13), d);
+    h2 = Math.imul(h2 ^ (h2 >>> 16), c) ^ Math.imul(h1 ^ (h1 >>> 13), d);
+    return e * (f & h2) + (h1 >>> 0);
+}
+const computeHash = cyrb53;
+
 const projectRoot = path__default["default"].resolve(__dirname, "../../");
 			const legacyRequire = require;
 			const distFolder = path__default["default"].resolve(projectRoot, "dist/cjs");
@@ -731,6 +793,35 @@ var schema = {
 	definitions: definitions
 };
 
+/**
+ * AJV keyword "regexp" to validate the type to be a regular expression.
+ * Injects errors with the "type" keyword to give the same output.
+ */
+/* istanbul ignore next: manual testing */
+const ajvRegexpValidate = function (data, dataCxt) {
+    const valid = data instanceof RegExp;
+    if (!valid) {
+        ajvRegexpValidate.errors = [
+            {
+                instancePath: dataCxt === null || dataCxt === void 0 ? void 0 : dataCxt.instancePath,
+                schemaPath: undefined,
+                keyword: "type",
+                message: "should be a regular expression",
+                params: {
+                    keyword: "type",
+                },
+            },
+        ];
+    }
+    return valid;
+};
+const ajvRegexpKeyword = {
+    keyword: "regexp",
+    schema: false,
+    errors: true,
+    validate: ajvRegexpValidate,
+};
+
 var TextContent$1;
 (function (TextContent) {
     /* forbid node to have text content, inter-element whitespace is ignored */
@@ -838,6 +929,43 @@ function migrateElement(src) {
     return result;
 }
 
+/**
+ * Returns true if given element is a descendant of given tagname.
+ *
+ * @internal
+ */
+function isDescendant(node, tagName) {
+    let cur = node.parent;
+    while (cur && !cur.isRootElement()) {
+        if (cur.is(tagName)) {
+            return true;
+        }
+        cur = cur.parent;
+    }
+    return false;
+}
+
+/**
+ * Returns true if given element has given attribute (no matter the value, null,
+ * dynamic, etc).
+ */
+function hasAttribute(node, attr) {
+    return node.hasAttribute(attr);
+}
+
+/**
+ * Matches attribute against value.
+ */
+function matchAttribute(node, key, op, value) {
+    const nodeValue = (node.getAttributeValue(key) || "").toLowerCase();
+    switch (op) {
+        case "!=":
+            return nodeValue !== value;
+        case "=":
+            return nodeValue === value;
+    }
+}
+
 const dynamicKeys = [
     "metadata",
     "flow",
@@ -849,44 +977,17 @@ const dynamicKeys = [
     "labelable",
 ];
 const functionTable = {
-    isDescendant,
-    hasAttribute,
-    matchAttribute,
+    isDescendant: isDescendantFacade,
+    hasAttribute: hasAttributeFacade,
+    matchAttribute: matchAttributeFacade,
 };
+const schemaCache = new Map();
 function clone(src) {
     return JSON.parse(JSON.stringify(src));
 }
 function overwriteMerge$1(a, b) {
     return b;
 }
-/**
- * AJV keyword "regexp" to validate the type to be a regular expression.
- * Injects errors with the "type" keyword to give the same output.
- */
-/* istanbul ignore next: manual testing */
-const ajvRegexpValidate = function (data, dataCxt) {
-    const valid = data instanceof RegExp;
-    if (!valid) {
-        ajvRegexpValidate.errors = [
-            {
-                instancePath: dataCxt === null || dataCxt === void 0 ? void 0 : dataCxt.instancePath,
-                schemaPath: undefined,
-                keyword: "type",
-                message: "should be regexp",
-                params: {
-                    keyword: "type",
-                },
-            },
-        ];
-    }
-    return valid;
-};
-const ajvRegexpKeyword = {
-    keyword: "regexp",
-    schema: false,
-    errors: true,
-    validate: ajvRegexpValidate,
-};
 /**
  * @public
  */
@@ -962,7 +1063,7 @@ class MetaTable {
             if (err instanceof SchemaValidationError) {
                 throw err;
             }
-            throw new UserError(`Failed to load element metadata from "${filename}"`, err);
+            throw new UserError(`Failed to load element metadata from "${filename}"`, ensureError(err));
         }
     }
     /**
@@ -1023,11 +1124,20 @@ class MetaTable {
      * Construct a new AJV schema validator.
      */
     getSchemaValidator() {
-        const ajv = new Ajv__default["default"]({ strict: true, strictTuples: true, strictTypes: true });
-        ajv.addMetaSchema(ajvSchemaDraft);
-        ajv.addKeyword(ajvRegexpKeyword);
-        ajv.addKeyword({ keyword: "copyable" });
-        return ajv.compile(this.schema);
+        const hash = computeHash(JSON.stringify(this.schema));
+        const cached = schemaCache.get(hash);
+        if (cached) {
+            return cached;
+        }
+        else {
+            const ajv = new Ajv__default["default"]({ strict: true, strictTuples: true, strictTypes: true });
+            ajv.addMetaSchema(ajvSchemaDraft);
+            ajv.addKeyword(ajvRegexpKeyword);
+            ajv.addKeyword({ keyword: "copyable" });
+            const validate = ajv.compile(this.schema);
+            schemaCache.set(hash, validate);
+            return validate;
+        }
     }
     /**
      * @public
@@ -1129,36 +1239,27 @@ function parseExpression(expr) {
         return [func, options];
     }
 }
-function isDescendant(node, tagName) {
+function isDescendantFacade(node, tagName) {
     if (typeof tagName !== "string") {
         throw new Error(`Property expression "isDescendant" must take string argument when evaluating metadata for <${node.tagName}>`);
     }
-    let cur = node.parent;
-    while (cur && !cur.isRootElement()) {
-        if (cur.is(tagName)) {
-            return true;
-        }
-        cur = cur.parent;
-    }
-    return false;
+    return isDescendant(node, tagName);
 }
-function hasAttribute(node, attr) {
+function hasAttributeFacade(node, attr) {
     if (typeof attr !== "string") {
         throw new Error(`Property expression "hasAttribute" must take string argument when evaluating metadata for <${node.tagName}>`);
     }
-    return node.hasAttribute(attr);
+    return hasAttribute(node, attr);
 }
-function matchAttribute(node, match) {
+function matchAttributeFacade(node, match) {
     if (!Array.isArray(match) || match.length !== 3) {
         throw new Error(`Property expression "matchAttribute" must take [key, op, value] array as argument when evaluating metadata for <${node.tagName}>`);
     }
     const [key, op, value] = match.map((x) => x.toLowerCase());
-    const nodeValue = (node.getAttributeValue(key) || "").toLowerCase();
     switch (op) {
         case "!=":
-            return nodeValue !== value;
         case "=":
-            return nodeValue === value;
+            return matchAttribute(node, key, op, value);
         default:
             throw new Error(`Property expression "matchAttribute" has invalid operator "${op}" when evaluating metadata for <${node.tagName}>`);
     }
@@ -2009,9 +2110,10 @@ class HtmlElement extends DOMNode {
             /* if a unique id is present, use it and short-circuit */
             if (cur.id) {
                 const escaped = escapeSelectorComponent(cur.id);
-                const matches = root.querySelectorAll(`#${escaped}`);
+                const selector = escaped.match(/^\d/) ? `[id="${escaped}"]` : `#${escaped}`;
+                const matches = root.querySelectorAll(selector);
                 if (matches.length === 1) {
-                    parts.push(`#${escaped}`);
+                    parts.push(selector);
                     break;
                 }
             }
@@ -3011,7 +3113,7 @@ var TRANSFORMER_API;
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "6.8.0";
+const version = "6.10.0";
 /** @public */
 const homepage = "https://html-validate.org";
 /** @public */
@@ -3332,7 +3434,7 @@ function ruleDocumentationUrl(filename) {
     return `${homepage}/rules/${normalized}.html`;
 }
 
-const defaults$q = {
+const defaults$r = {
     allowExternal: true,
     allowRelative: true,
     allowAbsolute: true,
@@ -3376,7 +3478,7 @@ function matchList(value, list) {
 }
 class AllowedLinks extends Rule {
     constructor(options) {
-        super({ ...defaults$q, ...options });
+        super({ ...defaults$r, ...options });
         this.allowExternal = parseAllow(this.options.allowExternal);
         this.allowRelative = parseAllow(this.options.allowRelative);
         this.allowAbsolute = parseAllow(this.options.allowAbsolute);
@@ -3677,13 +3779,13 @@ class CaseStyle {
     }
 }
 
-const defaults$p = {
+const defaults$q = {
     style: "lowercase",
     ignoreForeign: true,
 };
 class AttrCase extends Rule {
     constructor(options) {
-        super({ ...defaults$p, ...options });
+        super({ ...defaults$q, ...options });
         this.style = new CaseStyle(this.options.style, "attr-case");
     }
     static schema() {
@@ -3999,9 +4101,6 @@ class Lexer {
 }
 
 const whitespace = /(\s+)/;
-function isRelevant$3(event) {
-    return event.type === TokenType.ATTR_VALUE;
-}
 class AttrDelimiter extends Rule {
     documentation() {
         return {
@@ -4010,8 +4109,12 @@ class AttrDelimiter extends Rule {
         };
     }
     setup() {
-        this.on("token", isRelevant$3, (event) => {
-            const delimiter = event.data[1];
+        this.on("token", (event) => {
+            const { token } = event;
+            if (token.type !== TokenType.ATTR_VALUE) {
+                return;
+            }
+            const delimiter = token.data[1];
             const match = whitespace.exec(delimiter);
             if (match) {
                 const location = sliceLocation(event.location, 0, delimiter.length);
@@ -4022,7 +4125,7 @@ class AttrDelimiter extends Rule {
 }
 
 const DEFAULT_PATTERN = "[a-z0-9-:]+";
-const defaults$o = {
+const defaults$p = {
     pattern: DEFAULT_PATTERN,
     ignoreForeign: true,
 };
@@ -4059,7 +4162,7 @@ function generateDescription(name, pattern) {
 }
 class AttrPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$o, ...options });
+        super({ ...defaults$p, ...options });
         this.pattern = generateRegexp(this.options.pattern);
     }
     static schema() {
@@ -4119,13 +4222,13 @@ var QuoteStyle;
     QuoteStyle["DOUBLE_QUOTE"] = "\"";
     QuoteStyle["AUTO_QUOTE"] = "auto";
 })(QuoteStyle || (QuoteStyle = {}));
-const defaults$n = {
+const defaults$o = {
     style: "auto",
     unquoted: false,
 };
 class AttrQuotes extends Rule {
     constructor(options) {
-        super({ ...defaults$n, ...options });
+        super({ ...defaults$o, ...options });
         this.style = parseStyle$4(this.options.style);
     }
     static schema() {
@@ -4290,12 +4393,12 @@ class AttributeAllowedValues extends Rule {
     }
 }
 
-const defaults$m = {
+const defaults$n = {
     style: "omit",
 };
 class AttributeBooleanStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$m, ...options });
+        super({ ...defaults$n, ...options });
         this.hasInvalidStyle = parseStyle$3(this.options.style);
     }
     static schema() {
@@ -4371,12 +4474,12 @@ function reportMessage$1(attr, style) {
     return "";
 }
 
-const defaults$l = {
+const defaults$m = {
     style: "omit",
 };
 class AttributeEmptyStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$l, ...options });
+        super({ ...defaults$m, ...options });
         this.hasInvalidStyle = parseStyle$2(this.options.style);
     }
     static schema() {
@@ -4484,12 +4587,12 @@ function describePattern(pattern) {
     }
 }
 
-const defaults$k = {
+const defaults$l = {
     pattern: "kebabcase",
 };
 class ClassPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$k, ...options });
+        super({ ...defaults$l, ...options });
         this.pattern = parsePattern(this.options.pattern);
     }
     static schema() {
@@ -4598,13 +4701,13 @@ class CloseOrder extends Rule {
     }
 }
 
-const defaults$j = {
+const defaults$k = {
     include: null,
     exclude: null,
 };
 class Deprecated extends Rule {
     constructor(options) {
-        super({ ...defaults$j, ...options });
+        super({ ...defaults$k, ...options });
     }
     static schema() {
         return {
@@ -4767,12 +4870,12 @@ class NoStyleTag$1 extends Rule {
     }
 }
 
-const defaults$i = {
+const defaults$j = {
     style: "uppercase",
 };
 class DoctypeStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$i, ...options });
+        super({ ...defaults$j, ...options });
     }
     static schema() {
         return {
@@ -4804,12 +4907,12 @@ class DoctypeStyle extends Rule {
     }
 }
 
-const defaults$h = {
+const defaults$i = {
     style: "lowercase",
 };
 class ElementCase extends Rule {
     constructor(options) {
-        super({ ...defaults$h, ...options });
+        super({ ...defaults$i, ...options });
         this.style = new CaseStyle(this.options.style, "element-case");
     }
     static schema() {
@@ -4875,14 +4978,14 @@ class ElementCase extends Rule {
     }
 }
 
-const defaults$g = {
+const defaults$h = {
     pattern: "^[a-z][a-z0-9\\-._]*-[a-z0-9\\-._]*$",
     whitelist: [],
     blacklist: [],
 };
 class ElementName extends Rule {
     constructor(options) {
-        super({ ...defaults$g, ...options });
+        super({ ...defaults$h, ...options });
         // eslint-disable-next-line security/detect-non-literal-regexp
         this.pattern = new RegExp(this.options.pattern);
     }
@@ -4923,7 +5026,7 @@ class ElementName extends Rule {
                 ...context.blacklist.map((cur) => `- ${cur}`),
             ];
         }
-        if (context.pattern !== defaults$g.pattern) {
+        if (context.pattern !== defaults$h.pattern) {
             return [
                 `<${context.tagName}> is not a valid element name. This project is configured to only allow names matching the following regular expression:`,
                 "",
@@ -5325,7 +5428,7 @@ class EmptyTitle extends Rule {
     }
 }
 
-const defaults$f = {
+const defaults$g = {
     allowMultipleH1: false,
     minInitialRank: "h1",
     sectioningRoots: ["dialog", '[role="dialog"]'],
@@ -5356,7 +5459,7 @@ function parseMaxInitial(value) {
 }
 class HeadingLevel extends Rule {
     constructor(options) {
-        super({ ...defaults$f, ...options });
+        super({ ...defaults$g, ...options });
         this.stack = [];
         this.minInitialRank = parseMaxInitial(this.options.minInitialRank);
         this.sectionRoots = this.options.sectioningRoots.map((it) => new Pattern(it));
@@ -5514,12 +5617,12 @@ class HeadingLevel extends Rule {
     }
 }
 
-const defaults$e = {
+const defaults$f = {
     pattern: "kebabcase",
 };
 class IdPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$e, ...options });
+        super({ ...defaults$f, ...options });
         this.pattern = parsePattern(this.options.pattern);
     }
     static schema() {
@@ -5870,12 +5973,12 @@ function findLabelByParent(el) {
     return [];
 }
 
-const defaults$d = {
+const defaults$e = {
     maxlength: 70,
 };
 class LongTitle extends Rule {
     constructor(options) {
-        super({ ...defaults$d, ...options });
+        super({ ...defaults$e, ...options });
         this.maxlength = this.options.maxlength;
     }
     static schema() {
@@ -6022,13 +6125,13 @@ class MultipleLabeledControls extends Rule {
     }
 }
 
-const defaults$c = {
+const defaults$d = {
     include: null,
     exclude: null,
 };
 class NoAutoplay extends Rule {
     constructor(options) {
-        super({ ...defaults$c, ...options });
+        super({ ...defaults$d, ...options });
     }
     documentation(context) {
         const tagName = context ? ` on <${context.tagName}>` : "";
@@ -6269,14 +6372,14 @@ Omitted end tags can be ambigious for humans to read and many editors have troub
     }
 }
 
-const defaults$b = {
+const defaults$c = {
     include: null,
     exclude: null,
     allowedProperties: ["display"],
 };
 class NoInlineStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$b, ...options });
+        super({ ...defaults$c, ...options });
     }
     static schema() {
         return {
@@ -6478,7 +6581,7 @@ class NoMultipleMain extends Rule {
     }
 }
 
-const defaults$a = {
+const defaults$b = {
     relaxed: false,
 };
 const textRegexp = /([<>]|&(?![a-zA-Z0-9#]+;))/g;
@@ -6495,7 +6598,7 @@ const replacementTable = {
 };
 class NoRawCharacters extends Rule {
     constructor(options) {
-        super({ ...defaults$a, ...options });
+        super({ ...defaults$b, ...options });
         this.relaxed = this.options.relaxed;
     }
     static schema() {
@@ -6673,13 +6776,13 @@ class NoRedundantRole extends Rule {
 }
 
 const xmlns = /^(.+):.+$/;
-const defaults$9 = {
+const defaults$a = {
     ignoreForeign: true,
     ignoreXML: true,
 };
 class NoSelfClosing extends Rule {
     constructor(options) {
-        super({ ...defaults$9, ...options });
+        super({ ...defaults$a, ...options });
     }
     static schema() {
         return {
@@ -6812,13 +6915,13 @@ const replacement = {
     reset: '<button type="reset">',
     image: '<button type="button">',
 };
-const defaults$8 = {
+const defaults$9 = {
     include: null,
     exclude: null,
 };
 class PreferButton extends Rule {
     constructor(options) {
-        super({ ...defaults$8, ...options });
+        super({ ...defaults$9, ...options });
     }
     static schema() {
         return {
@@ -6893,7 +6996,7 @@ class PreferButton extends Rule {
     }
 }
 
-const defaults$7 = {
+const defaults$8 = {
     mapping: {
         article: "article",
         banner: "header",
@@ -6923,7 +7026,7 @@ const defaults$7 = {
 };
 class PreferNativeElement extends Rule {
     constructor(options) {
-        super({ ...defaults$7, ...options });
+        super({ ...defaults$8, ...options });
     }
     static schema() {
         return {
@@ -7043,7 +7146,7 @@ class PreferTbody extends Rule {
     }
 }
 
-const defaults$6 = {
+const defaults$7 = {
     target: "all",
 };
 const crossorigin = new RegExp("^(\\w+://|//)"); /* e.g. https:// or // */
@@ -7053,7 +7156,7 @@ const supportSri = {
 };
 class RequireSri extends Rule {
     constructor(options) {
-        super({ ...defaults$6, ...options });
+        super({ ...defaults$7, ...options });
         this.target = this.options.target;
     }
     static schema() {
@@ -7181,7 +7284,7 @@ class SvgFocusable extends Rule {
     }
 }
 
-const defaults$5 = {
+const defaults$6 = {
     characters: [
         { pattern: " ", replacement: "&nbsp;", description: "non-breaking space" },
         { pattern: "-", replacement: "&#8209;", description: "non-breaking hyphen" },
@@ -7224,7 +7327,7 @@ function matchAll(text, regexp) {
 }
 class TelNonBreaking extends Rule {
     constructor(options) {
-        super({ ...defaults$5, ...options });
+        super({ ...defaults$6, ...options });
         this.regex = constructRegex(this.options.characters);
     }
     static schema() {
@@ -9303,6 +9406,95 @@ class UnknownCharReference extends Rule {
     }
 }
 
+var RuleContext;
+(function (RuleContext) {
+    RuleContext[RuleContext["EMPTY"] = 1] = "EMPTY";
+    RuleContext[RuleContext["WHITESPACE"] = 2] = "WHITESPACE";
+    RuleContext[RuleContext["LEADING_CHARACTER"] = 3] = "LEADING_CHARACTER";
+    RuleContext[RuleContext["DISALLOWED_CHARACTER"] = 4] = "DISALLOWED_CHARACTER";
+})(RuleContext || (RuleContext = {}));
+const defaults$5 = {
+    relaxed: false,
+};
+class ValidID extends Rule {
+    constructor(options) {
+        super({ ...defaults$5, ...options });
+    }
+    static schema() {
+        return {
+            relaxed: {
+                type: "boolean",
+            },
+        };
+    }
+    documentation(context) {
+        const { relaxed } = this.options;
+        const message = context
+            ? this.messages[context].replace("id", "ID").replace(/^(.)/, (m) => m.toUpperCase())
+            : "Element ID is not valid";
+        const relaxedDescription = relaxed
+            ? []
+            : [
+                "  - ID must begin with a letter",
+                "  - ID must only contain alphanumerical characters, `-` and `_`",
+            ];
+        return {
+            description: [
+                `${message}.`,
+                "",
+                "Under the current configuration the following rules are applied:",
+                "",
+                "  - ID must not be empty",
+                "  - ID must not contain any whitespace characters",
+                ...relaxedDescription,
+            ].join("\n"),
+            url: ruleDocumentationUrl("@/rules/valid-id.ts"),
+        };
+    }
+    setup() {
+        this.on("attr", this.isRelevant, (event) => {
+            const { value } = event;
+            if (value === null || value instanceof DynamicValue) {
+                return;
+            }
+            if (value === "") {
+                const context = RuleContext.EMPTY;
+                this.report(event.target, this.messages[context], event.location, context);
+                return;
+            }
+            if (value.match(/\s/)) {
+                const context = RuleContext.WHITESPACE;
+                this.report(event.target, this.messages[context], event.valueLocation, context);
+                return;
+            }
+            const { relaxed } = this.options;
+            if (relaxed) {
+                return;
+            }
+            if (value.match(/^[^a-zA-Z]/)) {
+                const context = RuleContext.LEADING_CHARACTER;
+                this.report(event.target, this.messages[context], event.valueLocation, context);
+                return;
+            }
+            if (value.match(/[^a-zA-Z0-9-_]/)) {
+                const context = RuleContext.DISALLOWED_CHARACTER;
+                this.report(event.target, this.messages[context], event.valueLocation, context);
+            }
+        });
+    }
+    get messages() {
+        return {
+            [RuleContext.EMPTY]: "element id must not be empty",
+            [RuleContext.WHITESPACE]: "element id must not contain whitespace",
+            [RuleContext.LEADING_CHARACTER]: "element id must begin with a letter",
+            [RuleContext.DISALLOWED_CHARACTER]: "element id must only contain alphanumerical, dash and underscore characters",
+        };
+    }
+    isRelevant(event) {
+        return event.key === "id";
+    }
+}
+
 var Style$1;
 (function (Style) {
     Style[Style["Any"] = 0] = "Any";
@@ -9814,6 +10006,7 @@ const bundledRules = {
     "tel-non-breaking": TelNonBreaking,
     "text-content": TextContent,
     "unrecognized-char-ref": UnknownCharReference,
+    "valid-id": ValidID,
     void: Void,
     "void-content": VoidContent,
     "void-style": VoidStyle,
@@ -9911,6 +10104,7 @@ const config$1 = {
         "tel-non-breaking": "error",
         "text-content": "error",
         "unrecognized-char-ref": "error",
+        "valid-id": ["error", { relaxed: false }],
         void: "off",
         "void-content": "error",
         "void-style": "error",
@@ -9946,6 +10140,7 @@ const config = {
         "no-raw-characters": ["error", { relaxed: true }],
         "script-element": "error",
         "unrecognized-char-ref": "error",
+        "valid-id": ["error", { relaxed: true }],
         "void-content": "error",
     },
 };
@@ -10015,7 +10210,7 @@ class ResolvedConfig {
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                throw new NestedError(`When transforming "${source.filename}": ${message}`, err);
+                throw new NestedError(`When transforming "${source.filename}": ${message}`, ensureError(err));
             }
         }
         else {
@@ -10087,7 +10282,7 @@ function loadFromFile(filename) {
         json = requireUncached(filename);
     }
     catch (err) {
-        throw new ConfigError(`Failed to read configuration from "${filename}"`, err);
+        throw new ConfigError(`Failed to read configuration from "${filename}"`, ensureError(err));
     }
     /* expand any relative paths */
     for (const key of ["extends", "elements", "plugins"]) {
@@ -10292,7 +10487,7 @@ class Config {
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                throw new ConfigError(`Failed to load elements from "${entry}": ${message}`, err);
+                throw new ConfigError(`Failed to load elements from "${entry}": ${message}`, ensureError(err));
             }
         }
         metaTable.init();
@@ -10369,7 +10564,7 @@ class Config {
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
-                throw new ConfigError(`Failed to load plugin "${moduleName}": ${message}`, err);
+                throw new ConfigError(`Failed to load plugin "${moduleName}": ${message}`, ensureError(err));
             }
         });
     }
@@ -10462,7 +10657,7 @@ class Config {
                     throw new ConfigError(`Failed to load transformer "${name}": ${err.message}`, err);
                 }
                 else {
-                    throw new ConfigError(`Failed to load transformer "${name}"`, err);
+                    throw new ConfigError(`Failed to load transformer "${name}"`, ensureError(err));
                 }
             }
         });
@@ -11186,6 +11381,7 @@ class Parser {
                 location: token.location,
                 type: token.type,
                 data: Array.from(token.data),
+                token,
             });
         }
         return it;
@@ -11504,8 +11700,9 @@ class Engine {
     getRuleDocumentation(ruleId, context // eslint-disable-line @typescript-eslint/explicit-module-boundary-types
     ) {
         const rules = this.config.getRules();
-        if (rules.has(ruleId)) {
-            const [, options] = rules.get(ruleId);
+        const ruleData = rules.get(ruleId);
+        if (ruleData) {
+            const [, options] = ruleData;
             const rule = this.instantiateRule(ruleId, options);
             return rule.documentation(context);
         }
@@ -12446,6 +12643,7 @@ exports.HtmlElement = HtmlElement;
 exports.HtmlValidate = HtmlValidate;
 exports.MetaCopyableProperty = MetaCopyableProperty;
 exports.MetaTable = MetaTable;
+exports.NestedError = NestedError;
 exports.Parser = Parser;
 exports.Reporter = Reporter;
 exports.Rule = Rule;
@@ -12454,9 +12652,11 @@ exports.StaticConfigLoader = StaticConfigLoader;
 exports.TemplateExtractor = TemplateExtractor;
 exports.TextNode = TextNode;
 exports.UserError = UserError;
+exports.WrappedError = WrappedError;
 exports.bugs = bugs;
 exports.codeframe = codeframe;
 exports.compatibilityCheck = compatibilityCheck;
+exports.ensureError = ensureError;
 exports.getFormatter = getFormatter;
 exports.legacyRequire = legacyRequire;
 exports.name = name;