html-validate 7.10.1 → 7.11.1

package/dist/cjs/core.js

@@ -7,10 +7,10 @@ var Ajv = require('ajv');
 var deepmerge = require('deepmerge');
 var espree = require('espree');
 var walk = require('acorn-walk');
-var elements = require('./elements.js');
 var path = require('path');
 var semver = require('semver');
 var kleur = require('kleur');
+var elements = require('./elements.js');
 var codeFrame = require('@babel/code-frame');
 var stylishImpl = require('@html-validate/stylish');
 
@@ -1672,6 +1672,7 @@ class NestedError extends Error {
     constructor(message, nested) {
         super(message);
         Error.captureStackTrace(this, NestedError);
+        this.name = NestedError.name;
         if (nested && nested.stack) {
             this.stack += `\nCaused by: ${nested.stack}`;
         }
@@ -1682,6 +1683,44 @@ class NestedError extends Error {
  * @public
  */
 class UserError extends NestedError {
+    constructor(message, nested) {
+        super(message, nested);
+        Error.captureStackTrace(this, UserError);
+        this.name = UserError.name;
+    }
+    prettyFormat() {
+        return undefined;
+    }
+}
+
+/**
+ * @internal
+ */
+class InheritError extends UserError {
+    constructor({ tagName, inherit }) {
+        const message = `Element <${tagName}> cannot inherit from <${inherit}>: no such element`;
+        super(message);
+        Error.captureStackTrace(this, InheritError);
+        this.name = InheritError.name;
+        this.tagName = tagName;
+        this.inherit = inherit;
+        this.filename = null;
+    }
+    prettyFormat() {
+        const { message, tagName, inherit } = this;
+        const source = this.filename
+            ? ["", "This error occurred when loading element metadata from:", `"${this.filename}"`, ""]
+            : [""];
+        return [
+            message,
+            ...source,
+            "This usually occurs when the elements are defined in the wrong order, try one of the following:",
+            "",
+            `  - Ensure the spelling of "${inherit}" is correct.`,
+            `  - Ensure the file containing "${inherit}" is loaded before the file containing "${tagName}".`,
+            `  - Move the definition of "${inherit}" above the definition for "${tagName}".`,
+        ].join("\n");
+    }
 }
 
 function getSummary(schema, obj, errors) {
@@ -2105,6 +2144,9 @@ const definitions = {
 						items: {
 							type: "string"
 						}
+					},
+					{
+						type: "null"
 					}
 				]
 			}
@@ -2415,6 +2457,10 @@ class MetaTable {
             this.loadFromObject(data, filename);
         }
         catch (err) {
+            if (err instanceof InheritError) {
+                err.filename = filename;
+                throw err;
+            }
             if (err instanceof SchemaValidationError) {
                 throw err;
             }
@@ -2467,7 +2513,10 @@ class MetaTable {
             const name = entry.inherit;
             parent = this.elements[name];
             if (!parent) {
-                throw new UserError(`Element <${tagName}> cannot inherit from <${name}>: no such element`);
+                throw new InheritError({
+                    tagName,
+                    inherit: name,
+                });
             }
         }
         /* merge all sources together */
@@ -2646,29 +2695,40 @@ class Validator {
      *
      * For instance, a `<table>` element can only contain a single `<tbody>`
      * child. If multiple `<tbody>` exists this test will fail both nodes.
+     * Note that this is called on the parent but will fail the children violating
+     * the rule.
      *
-     * @param node - Element to test.
-     * @param rules - List of rules.
-     * @param numSiblings - How many siblings of the same type as the element
-     * exists (including the element itself)
-     * @returns `true` if the element passes the test.
+     * @param children - Array of children to validate.
+     * @param rules - List of rules of the parent element.
+     * @returns `true` if the parent element of the children passes the test.
      */
-    static validateOccurrences(node, rules, numSiblings) {
+    static validateOccurrences(children, rules, cb) {
         if (!rules) {
             return true;
         }
-        const category = rules.find((cur) => {
+        let valid = true;
+        for (const rule of rules) {
             /** @todo handle complex rules and not just plain arrays (but as of now
              * there is no use-case for it) */
             // istanbul ignore next
-            if (typeof cur !== "string") {
+            if (typeof rule !== "string") {
                 return false;
             }
-            const match = cur.match(/^(.*?)[?*]?$/);
-            return match && match[1] === node.tagName;
-        });
-        const limit = parseAmountQualifier(category);
-        return limit === null || numSiblings <= limit;
+            // Check if the rule has a quantifier
+            const [, category, quantifier] = rule.match(/^(@?.*?)([?*]?)$/);
+            const limit = category && quantifier && parseQuantifier(quantifier);
+            if (limit) {
+                const siblings = children.filter((cur) => Validator.validatePermittedCategory(cur, rule, true));
+                if (siblings.length > limit) {
+                    // fail only the children above the limit (currently limit can only be 1)
+                    for (const child of siblings.slice(limit)) {
+                        cb(child, category);
+                    }
+                    valid = false;
+                }
+            }
+        }
+        return valid;
     }
     /**
      * Validate elements order.
@@ -2730,14 +2790,15 @@ class Validator {
      * Check if an element has the required set of elements. At least one of the
      * selectors must match.
      *
-     * Returns [] when valid or a list of tagNames missing as content.
+     * Returns `[]` when valid or a list of required but missing tagnames or
+     * categories.
      */
     static validateRequiredContent(node, rules) {
         if (!rules || rules.length === 0) {
             return [];
         }
         return rules.filter((tagName) => {
-            const haveMatchingChild = node.childElements.some((child) => child.is(tagName));
+            const haveMatchingChild = node.childElements.some((child) => Validator.validatePermittedCategory(child, tagName, false));
             return !haveMatchingChild;
         });
     }
@@ -2841,16 +2902,16 @@ class Validator {
      */
     // eslint-disable-next-line complexity
     static validatePermittedCategory(node, category, defaultMatch) {
+        const [, rawCategory] = category.match(/^(@?.*?)([?*]?)$/);
         /* match tagName when an explicit name is given */
-        if (category[0] !== "@") {
-            const [, tagName] = category.match(/^(.*?)[?*]?$/);
-            return node.tagName === tagName;
+        if (rawCategory[0] !== "@") {
+            return node.tagName === rawCategory;
         }
         /* if the meta entry is missing assume any content model would match */
         if (!node.meta) {
             return defaultMatch;
         }
-        switch (category) {
+        switch (rawCategory) {
             case "@meta":
                 return node.meta.metadata;
             case "@flow":
@@ -2882,23 +2943,15 @@ function validateKeys(rule) {
         }
     }
 }
-function parseAmountQualifier(category) {
-    if (!category) {
-        /* content not allowed, catched by another rule so just assume unlimited
-         * usage for this purpose */
-        return null;
-    }
-    const [, qualifier] = category.match(/^.*?([?*]?)$/);
-    switch (qualifier) {
+function parseQuantifier(quantifier) {
+    switch (quantifier) {
         case "?":
             return 1;
-        case "":
-            return null;
         case "*":
             return null;
-        /* istanbul ignore next */
+        // istanbul ignore next
         default:
-            throw new Error(`Invalid amount qualifier "${qualifier}" used`);
+            throw new Error(`Invalid quantifier "${quantifier}" used`);
     }
 }
 
@@ -3430,16 +3483,7 @@ class Rule {
      * `exclude`.
      */
     isKeywordIgnored(keyword, matcher = (list, it) => list.includes(it)) {
-        const { include, exclude } = this.options;
-        /* ignore keyword if not present in "include" */
-        if (include && !matcher(include, keyword)) {
-            return true;
-        }
-        /* ignore keyword if present in "excludes" */
-        if (exclude && matcher(exclude, keyword)) {
-            return true;
-        }
-        return false;
+        return rulesHelper.isKeywordIgnored(this.options, keyword, matcher);
     }
     /**
      * Find all tags which has enabled given property.
@@ -3565,7 +3609,7 @@ class Rule {
     }
 }
 
-const defaults$u = {
+const defaults$v = {
     allowExternal: true,
     allowRelative: true,
     allowAbsolute: true,
@@ -3609,7 +3653,7 @@ function matchList(value, list) {
 }
 class AllowedLinks extends Rule {
     constructor(options) {
-        super({ ...defaults$u, ...options });
+        super({ ...defaults$v, ...options });
         this.allowExternal = parseAllow(this.options.allowExternal);
         this.allowRelative = parseAllow(this.options.allowRelative);
         this.allowAbsolute = parseAllow(this.options.allowAbsolute);
@@ -3757,7 +3801,7 @@ var RuleContext$1;
     RuleContext["MISSING_ALT"] = "missing-alt";
     RuleContext["MISSING_HREF"] = "missing-href";
 })(RuleContext$1 || (RuleContext$1 = {}));
-const defaults$t = {
+const defaults$u = {
     accessible: true,
 };
 function findByTarget(target, siblings) {
@@ -3795,7 +3839,7 @@ function getDescription$1(context) {
 }
 class AreaAlt extends Rule {
     constructor(options) {
-        super({ ...defaults$t, ...options });
+        super({ ...defaults$u, ...options });
     }
     static schema() {
         return {
@@ -3957,15 +4001,20 @@ class AriaLabelMisuse extends Rule {
  * @public
  */
 class ConfigError extends UserError {
+    constructor(message, nested) {
+        super(message, nested);
+        Error.captureStackTrace(this, ConfigError);
+        this.name = ConfigError.name;
+    }
 }
 
-const defaults$s = {
+const defaults$t = {
     style: "lowercase",
     ignoreForeign: true,
 };
 class AttrCase extends Rule {
     constructor(options) {
-        super({ ...defaults$s, ...options });
+        super({ ...defaults$t, ...options });
         this.style = new rulesHelper.CaseStyle(this.options.style, "attr-case");
     }
     static schema() {
@@ -4310,7 +4359,7 @@ class AttrDelimiter extends Rule {
 }
 
 const DEFAULT_PATTERN = "[a-z0-9-:]+";
-const defaults$r = {
+const defaults$s = {
     pattern: DEFAULT_PATTERN,
     ignoreForeign: true,
 };
@@ -4347,7 +4396,7 @@ function generateDescription(name, pattern) {
 }
 class AttrPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$r, ...options });
+        super({ ...defaults$s, ...options });
         this.pattern = generateRegexp(this.options.pattern);
     }
     static schema() {
@@ -4408,7 +4457,7 @@ var QuoteStyle;
     QuoteStyle["AUTO_QUOTE"] = "auto";
     QuoteStyle["ANY_QUOTE"] = "any";
 })(QuoteStyle || (QuoteStyle = {}));
-const defaults$q = {
+const defaults$r = {
     style: "auto",
     unquoted: false,
 };
@@ -4475,7 +4524,7 @@ class AttrQuotes extends Rule {
         };
     }
     constructor(options) {
-        super({ ...defaults$q, ...options });
+        super({ ...defaults$r, ...options });
         this.style = parseStyle$4(this.options.style);
     }
     setup() {
@@ -4645,12 +4694,12 @@ class AttributeAllowedValues extends Rule {
     }
 }
 
-const defaults$p = {
+const defaults$q = {
     style: "omit",
 };
 class AttributeBooleanStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$p, ...options });
+        super({ ...defaults$q, ...options });
         this.hasInvalidStyle = parseStyle$3(this.options.style);
     }
     static schema() {
@@ -4726,12 +4775,12 @@ function reportMessage$1(attr, style) {
     return "";
 }
 
-const defaults$o = {
+const defaults$p = {
     style: "omit",
 };
 class AttributeEmptyStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$o, ...options });
+        super({ ...defaults$p, ...options });
         this.hasInvalidStyle = parseStyle$2(this.options.style);
     }
     static schema() {
@@ -4887,12 +4936,12 @@ function describePattern(pattern) {
     }
 }
 
-const defaults$n = {
+const defaults$o = {
     pattern: "kebabcase",
 };
 class ClassPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$n, ...options });
+        super({ ...defaults$o, ...options });
         this.pattern = parsePattern(this.options.pattern);
     }
     static schema() {
@@ -5001,13 +5050,13 @@ class CloseOrder extends Rule {
     }
 }
 
-const defaults$m = {
+const defaults$n = {
     include: null,
     exclude: null,
 };
 class Deprecated extends Rule {
     constructor(options) {
-        super({ ...defaults$m, ...options });
+        super({ ...defaults$n, ...options });
     }
     static schema() {
         return {
@@ -5170,12 +5219,12 @@ let NoStyleTag$1 = class NoStyleTag extends Rule {
     }
 };
 
-const defaults$l = {
+const defaults$m = {
     style: "uppercase",
 };
 class DoctypeStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$l, ...options });
+        super({ ...defaults$m, ...options });
     }
     static schema() {
         return {
@@ -5207,12 +5256,12 @@ class DoctypeStyle extends Rule {
     }
 }
 
-const defaults$k = {
+const defaults$l = {
     style: "lowercase",
 };
 class ElementCase extends Rule {
     constructor(options) {
-        super({ ...defaults$k, ...options });
+        super({ ...defaults$l, ...options });
         this.style = new rulesHelper.CaseStyle(this.options.style, "element-case");
     }
     static schema() {
@@ -5278,14 +5327,14 @@ class ElementCase extends Rule {
     }
 }
 
-const defaults$j = {
+const defaults$k = {
     pattern: "^[a-z][a-z0-9\\-._]*-[a-z0-9\\-._]*$",
     whitelist: [],
     blacklist: [],
 };
 class ElementName extends Rule {
     constructor(options) {
-        super({ ...defaults$j, ...options });
+        super({ ...defaults$k, ...options });
         // eslint-disable-next-line security/detect-non-literal-regexp
         this.pattern = new RegExp(this.options.pattern);
     }
@@ -5326,7 +5375,7 @@ class ElementName extends Rule {
                 ...context.blacklist.map((cur) => `- ${cur}`),
             ];
         }
-        if (context.pattern !== defaults$j.pattern) {
+        if (context.pattern !== defaults$k.pattern) {
             return [
                 `<${context.tagName}> is not a valid element name. This project is configured to only allow names matching the following regular expression:`,
                 "",
@@ -5517,24 +5566,16 @@ class ElementPermittedOccurrences extends Rule {
         this.on("dom:ready", (event) => {
             const doc = event.document;
             doc.visitDepthFirst((node) => {
-                const parent = node.parent;
-                if (!parent || !parent.meta) {
+                if (!node || !node.meta) {
                     return;
                 }
-                const rules = parent.meta.permittedContent;
+                const rules = node.meta.permittedContent;
                 if (!rules) {
                     return;
                 }
-                const siblings = parent.childElements.filter((cur) => cur.tagName === node.tagName);
-                const first = node.unique === siblings[0].unique;
-                /* the first occurrence should not trigger any errors, only the
-                 * subsequent occurrences should. */
-                if (first) {
-                    return;
-                }
-                if (parent.meta && !Validator.validateOccurrences(node, rules, siblings.length)) {
-                    this.report(node, `Element <${node.tagName}> can only appear once under ${parent.annotatedName}`);
-                }
+                Validator.validateOccurrences(node.childElements, rules, (child, category) => {
+                    this.report(child, `Element <${category}> can only appear once under ${node.annotatedName}`);
+                });
             });
         });
     }
@@ -5569,11 +5610,11 @@ class ElementPermittedOrder extends Rule {
 function isCategoryOrTag(value) {
     return typeof value === "string";
 }
-function isCategory(value) {
+function isCategory$1(value) {
     return value[0] === "@";
 }
 function formatCategoryOrTag(value) {
-    return isCategory(value) ? value.slice(1) : `<${value}>`;
+    return isCategory$1(value) ? value.slice(1) : `<${value}>`;
 }
 function isFormattable(rules) {
     return rules.length > 0 && rules.every(isCategoryOrTag);
@@ -5586,7 +5627,7 @@ function getRuleDescription$1(context) {
     const preamble = `The \`${child}\` element cannot have a \`${parent}\` element as parent.`;
     if (isFormattable(rules)) {
         const allowed = rules.filter(isCategoryOrTag).map((it) => {
-            if (isCategory(it)) {
+            if (isCategory$1(it)) {
                 return `- any ${it.slice(1)} element`;
             }
             else {
@@ -5749,6 +5790,9 @@ class ElementRequiredAttributes extends Rule {
     }
 }
 
+function isCategory(value) {
+    return value[0] === "@";
+}
 class ElementRequiredContent extends Rule {
     documentation(context) {
         if (context) {
@@ -5783,7 +5827,8 @@ class ElementRequiredContent extends Rule {
                         element: node.annotatedName,
                         missing: `<${missing}>`,
                     };
-                    const message = `${node.annotatedName} element must have <${missing}> as content`;
+                    const tag = isCategory(missing) ? `${missing.slice(1)} element` : `<${missing}>`;
+                    const message = `${node.annotatedName} element must have ${tag} as content`;
                     this.report(node, message, null, context);
                 }
             });
@@ -5874,7 +5919,7 @@ class EmptyTitle extends Rule {
     }
 }
 
-const defaults$i = {
+const defaults$j = {
     allowMultipleH1: false,
     minInitialRank: "h1",
     sectioningRoots: ["dialog", '[role="dialog"]'],
@@ -5905,7 +5950,7 @@ function parseMaxInitial(value) {
 }
 class HeadingLevel extends Rule {
     constructor(options) {
-        super({ ...defaults$i, ...options });
+        super({ ...defaults$j, ...options });
         this.stack = [];
         this.minInitialRank = parseMaxInitial(this.options.minInitialRank);
         this.sectionRoots = this.options.sectioningRoots.map((it) => new Pattern(it));
@@ -6063,12 +6108,12 @@ class HeadingLevel extends Rule {
     }
 }
 
-const defaults$h = {
+const defaults$i = {
     pattern: "kebabcase",
 };
 class IdPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$h, ...options });
+        super({ ...defaults$i, ...options });
         this.pattern = parsePattern(this.options.pattern);
     }
     static schema() {
@@ -6350,12 +6395,12 @@ function findLabelByParent(el) {
     return [];
 }
 
-const defaults$g = {
+const defaults$h = {
     maxlength: 70,
 };
 class LongTitle extends Rule {
     constructor(options) {
-        super({ ...defaults$g, ...options });
+        super({ ...defaults$h, ...options });
         this.maxlength = this.options.maxlength;
     }
     static schema() {
@@ -6545,13 +6590,13 @@ class MultipleLabeledControls extends Rule {
     }
 }
 
-const defaults$f = {
+const defaults$g = {
     include: null,
     exclude: null,
 };
 class NoAutoplay extends Rule {
     constructor(options) {
-        super({ ...defaults$f, ...options });
+        super({ ...defaults$g, ...options });
     }
     documentation(context) {
         const tagName = context ? ` on <${context.tagName}>` : "";
@@ -6792,14 +6837,14 @@ Omitted end tags can be ambigious for humans to read and many editors have troub
     }
 }
 
-const defaults$e = {
+const defaults$f = {
     include: null,
     exclude: null,
     allowedProperties: ["display"],
 };
 class NoInlineStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$e, ...options });
+        super({ ...defaults$f, ...options });
     }
     static schema() {
         return {
@@ -7001,7 +7046,7 @@ class NoMultipleMain extends Rule {
     }
 }
 
-const defaults$d = {
+const defaults$e = {
     relaxed: false,
 };
 const textRegexp = /([<>]|&(?![a-zA-Z0-9#]+;))/g;
@@ -7018,7 +7063,7 @@ const replacementTable = {
 };
 class NoRawCharacters extends Rule {
     constructor(options) {
-        super({ ...defaults$d, ...options });
+        super({ ...defaults$e, ...options });
         this.relaxed = this.options.relaxed;
     }
     static schema() {
@@ -7196,13 +7241,13 @@ class NoRedundantRole extends Rule {
 }
 
 const xmlns = /^(.+):.+$/;
-const defaults$c = {
+const defaults$d = {
     ignoreForeign: true,
     ignoreXML: true,
 };
 class NoSelfClosing extends Rule {
     constructor(options) {
-        super({ ...defaults$c, ...options });
+        super({ ...defaults$d, ...options });
     }
     static schema() {
         return {
@@ -7291,7 +7336,44 @@ class NoTrailingWhitespace extends Rule {
     }
 }
 
+const defaults$c = {
+    include: null,
+    exclude: null,
+};
 class NoUnknownElements extends Rule {
+    constructor(options) {
+        super({ ...defaults$c, ...options });
+    }
+    static schema() {
+        return {
+            exclude: {
+                anyOf: [
+                    {
+                        items: {
+                            type: "string",
+                        },
+                        type: "array",
+                    },
+                    {
+                        type: "null",
+                    },
+                ],
+            },
+            include: {
+                anyOf: [
+                    {
+                        items: {
+                            type: "string",
+                        },
+                        type: "array",
+                    },
+                    {
+                        type: "null",
+                    },
+                ],
+            },
+        };
+    }
     documentation(context) {
         const element = context ? ` <${context}>` : "";
         return {
@@ -7302,9 +7384,13 @@ class NoUnknownElements extends Rule {
     setup() {
         this.on("tag:start", (event) => {
             const node = event.target;
-            if (!node.meta) {
-                this.report(node, `Unknown element <${node.tagName}>`, null, node.tagName);
+            if (node.meta) {
+                return;
             }
+            if (this.isKeywordIgnored(node.tagName, rulesHelper.keywordPatternMatcher)) {
+                return;
+            }
+            this.report(node, `Unknown element <${node.tagName}>`, null, node.tagName);
         });
     }
 }
@@ -8766,6 +8852,11 @@ class H37 extends Rule {
     }
 }
 
+var _a;
+/* istanbul ignore next: this will always be present for the <th>
+ * attribute (or the tests would fail) */
+const { enum: validScopes } = (_a = elements.html5.th.attributes) === null || _a === void 0 ? void 0 : _a.scope;
+const joinedScopes = rulesHelper.naturalJoin(validScopes);
 class H63 extends Rule {
     documentation() {
         return {
@@ -8775,19 +8866,25 @@ class H63 extends Rule {
     }
     setup() {
         this.on("tag:ready", (event) => {
-            var _a, _b, _c, _d;
+            var _a, _b;
             const node = event.target;
             /* only validate th */
             if (!node || node.tagName !== "th") {
                 return;
             }
+            const scope = node.getAttribute("scope");
+            const value = scope === null || scope === void 0 ? void 0 : scope.value;
+            /* ignore dynamic scope */
+            if (value instanceof DynamicValue) {
+                return;
+            }
             /* ignore elements with valid scope values */
-            const scope = node.getAttributeValue("scope");
-            const scopeMeta = (_b = (_a = elements.html5 === null || elements.html5 === void 0 ? void 0 : elements.html5.th) === null || _a === void 0 ? void 0 : _a.attributes) === null || _b === void 0 ? void 0 : _b.scope;
-            if (scope && ((_c = scopeMeta.enum) === null || _c === void 0 ? void 0 : _c.includes(scope))) {
+            if (value && validScopes.includes(value)) {
                 return;
             }
-            this.report(node, `<th> element must have a valid scope attribute: ${((_d = scopeMeta.enum) !== null && _d !== void 0 ? _d : []).join(", ")}`, node.location);
+            const message = `<th> element must have a valid scope attribute: ${joinedScopes}`;
+            const location = (_b = (_a = scope === null || scope === void 0 ? void 0 : scope.valueLocation) !== null && _a !== void 0 ? _a : scope === null || scope === void 0 ? void 0 : scope.keyLocation) !== null && _b !== void 0 ? _b : node.location;
+            this.report(node, message, location);
         });
     }
 }
@@ -11158,7 +11255,7 @@ class HtmlValidate {
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "7.10.1";
+const version = "7.11.1";
 /** @public */
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";