html-validate 6.8.0 → 6.10.0

package/dist/es/core.js

@@ -243,6 +243,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);
@@ -296,6 +332,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.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../");
 			const legacyRequire = createRequire(import.meta.url);
 			const distFolder = path.resolve(projectRoot, "dist/es");
@@ -700,6 +762,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 */
@@ -807,6 +898,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",
@@ -818,44 +946,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
  */
@@ -931,7 +1032,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));
         }
     }
     /**
@@ -992,11 +1093,20 @@ class MetaTable {
      * Construct a new AJV schema validator.
      */
     getSchemaValidator() {
-        const ajv = new Ajv({ 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({ 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
@@ -1098,36 +1208,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}>`);
     }
@@ -1978,9 +2079,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;
                 }
             }
@@ -2980,7 +3082,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 */
@@ -3301,7 +3403,7 @@ function ruleDocumentationUrl(filename) {
     return `${homepage}/rules/${normalized}.html`;
 }
 
-const defaults$q = {
+const defaults$r = {
     allowExternal: true,
     allowRelative: true,
     allowAbsolute: true,
@@ -3345,7 +3447,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);
@@ -3646,13 +3748,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() {
@@ -3968,9 +4070,6 @@ class Lexer {
 }
 
 const whitespace = /(\s+)/;
-function isRelevant$3(event) {
-    return event.type === TokenType.ATTR_VALUE;
-}
 class AttrDelimiter extends Rule {
     documentation() {
         return {
@@ -3979,8 +4078,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);
@@ -3991,7 +4094,7 @@ class AttrDelimiter extends Rule {
 }
 
 const DEFAULT_PATTERN = "[a-z0-9-:]+";
-const defaults$o = {
+const defaults$p = {
     pattern: DEFAULT_PATTERN,
     ignoreForeign: true,
 };
@@ -4028,7 +4131,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() {
@@ -4088,13 +4191,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() {
@@ -4259,12 +4362,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() {
@@ -4340,12 +4443,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() {
@@ -4453,12 +4556,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() {
@@ -4567,13 +4670,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 {
@@ -4736,12 +4839,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 {
@@ -4773,12 +4876,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() {
@@ -4844,14 +4947,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);
     }
@@ -4892,7 +4995,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:`,
                 "",
@@ -5294,7 +5397,7 @@ class EmptyTitle extends Rule {
     }
 }
 
-const defaults$f = {
+const defaults$g = {
     allowMultipleH1: false,
     minInitialRank: "h1",
     sectioningRoots: ["dialog", '[role="dialog"]'],
@@ -5325,7 +5428,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));
@@ -5483,12 +5586,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() {
@@ -5839,12 +5942,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() {
@@ -5991,13 +6094,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}>` : "";
@@ -6238,14 +6341,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 {
@@ -6447,7 +6550,7 @@ class NoMultipleMain extends Rule {
     }
 }
 
-const defaults$a = {
+const defaults$b = {
     relaxed: false,
 };
 const textRegexp = /([<>]|&(?![a-zA-Z0-9#]+;))/g;
@@ -6464,7 +6567,7 @@ const replacementTable = {
 };
 class NoRawCharacters extends Rule {
     constructor(options) {
-        super({ ...defaults$a, ...options });
+        super({ ...defaults$b, ...options });
         this.relaxed = this.options.relaxed;
     }
     static schema() {
@@ -6642,13 +6745,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 {
@@ -6781,13 +6884,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 {
@@ -6862,7 +6965,7 @@ class PreferButton extends Rule {
     }
 }
 
-const defaults$7 = {
+const defaults$8 = {
     mapping: {
         article: "article",
         banner: "header",
@@ -6892,7 +6995,7 @@ const defaults$7 = {
 };
 class PreferNativeElement extends Rule {
     constructor(options) {
-        super({ ...defaults$7, ...options });
+        super({ ...defaults$8, ...options });
     }
     static schema() {
         return {
@@ -7012,7 +7115,7 @@ class PreferTbody extends Rule {
     }
 }
 
-const defaults$6 = {
+const defaults$7 = {
     target: "all",
 };
 const crossorigin = new RegExp("^(\\w+://|//)"); /* e.g. https:// or // */
@@ -7022,7 +7125,7 @@ const supportSri = {
 };
 class RequireSri extends Rule {
     constructor(options) {
-        super({ ...defaults$6, ...options });
+        super({ ...defaults$7, ...options });
         this.target = this.options.target;
     }
     static schema() {
@@ -7150,7 +7253,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" },
@@ -7193,7 +7296,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() {
@@ -9272,6 +9375,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";
@@ -9783,6 +9975,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,
@@ -9880,6 +10073,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",
@@ -9915,6 +10109,7 @@ const config = {
         "no-raw-characters": ["error", { relaxed: true }],
         "script-element": "error",
         "unrecognized-char-ref": "error",
+        "valid-id": ["error", { relaxed: true }],
         "void-content": "error",
     },
 };
@@ -9984,7 +10179,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 {
@@ -10056,7 +10251,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"]) {
@@ -10261,7 +10456,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();
@@ -10338,7 +10533,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));
             }
         });
     }
@@ -10431,7 +10626,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));
                 }
             }
         });
@@ -11155,6 +11350,7 @@ class Parser {
                 location: token.location,
                 type: token.type,
                 data: Array.from(token.data),
+                token,
             });
         }
         return it;
@@ -11473,8 +11669,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);
         }
@@ -12405,5 +12602,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, codeframe 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, WrappedError as W, ConfigError as a, ConfigLoader as b, StaticConfigLoader as c, HtmlElement as d, SchemaValidationError as e, NestedError as f, MetaCopyableProperty as g, Reporter as h, TemplateExtractor as i, getFormatter as j, ensureError as k, legacyRequire as l, compatibilityCheck as m, codeframe as n, name as o, presets as p, bugs as q, ruleExists as r, version as v };
 //# sourceMappingURL=core.js.map