html-validate 7.12.1 → 7.13.0

package/dist/es/core.js

@@ -511,6 +511,7 @@ class DOMNode {
         this.nodeName = nodeName !== null && nodeName !== void 0 ? nodeName : DOCUMENT_NODE_NAME;
         this.location = location;
         this.disabledRules = new Set();
+        this.blockedRules = new Map();
         this.childNodes = [];
         this.unique = counter++;
         this.cache = null;
@@ -586,14 +587,42 @@ class DOMNode {
     get lastChild() {
         return this.childNodes[this.childNodes.length - 1] || null;
     }
+    /**
+     * Block a rule for this node.
+     *
+     * @internal
+     */
+    blockRule(ruleId, blocker) {
+        const current = this.blockedRules.get(ruleId);
+        if (current) {
+            current.push(blocker);
+        }
+        else {
+            this.blockedRules.set(ruleId, [blocker]);
+        }
+    }
+    /**
+     * Blocks multiple rules.
+     *
+     * @internal
+     */
+    blockRules(rules, blocker) {
+        for (const rule of rules) {
+            this.blockRule(rule, blocker);
+        }
+    }
     /**
      * Disable a rule for this node.
+     *
+     * @internal
      */
     disableRule(ruleId) {
         this.disabledRules.add(ruleId);
     }
     /**
      * Disables multiple rules.
+     *
+     * @internal
      */
     disableRules(rules) {
         for (const rule of rules) {
@@ -616,10 +645,21 @@ class DOMNode {
     }
     /**
      * Test if a rule is enabled for this node.
+     *
+     * @internal
      */
     ruleEnabled(ruleId) {
         return !this.disabledRules.has(ruleId);
     }
+    /**
+     * Test if a rule is blocked for this node.
+     *
+     * @internal
+     */
+    ruleBlockers(ruleId) {
+        var _a;
+        return (_a = this.blockedRules.get(ruleId)) !== null && _a !== void 0 ? _a : [];
+    }
     generateSelector() {
         return null;
     }
@@ -2675,6 +2715,8 @@ function matchAttributeFacade(node, match) {
 const allowedKeys = ["exclude"];
 /**
  * Helper class to validate elements against metadata rules.
+ *
+ * @public
  */
 class Validator {
     /**
@@ -3430,6 +3472,7 @@ class Rule {
         this.event = null;
         this.options = options;
         this.enabled = true;
+        this.blockers = [];
         this.severity = 0;
         this.name = "";
     }
@@ -3439,6 +3482,26 @@ class Rule {
     setServerity(severity) {
         this.severity = severity;
     }
+    /**
+     * Block this rule from generating errors. Pass in an id generated by {@link
+     * createBlocker}. Can be unblocked by {@link unblock}.
+     *
+     * A blocked rule is similar to disabling it but it will still receive parser
+     * events. A list of all blockers is passed to the `rule:error` event.
+     *
+     * @internal
+     */
+    block(id) {
+        this.blockers.push(id);
+    }
+    /**
+     * Unblock a rule previously blocked by {@link block}.
+     *
+     * @internal
+     */
+    unblock(id) {
+        this.blockers = this.blockers.filter((it) => it !== id);
+    }
     setEnabled(enabled) {
         this.enabled = enabled;
     }
@@ -3455,9 +3518,36 @@ class Rule {
      *
      * To be considered enabled the enabled flag must be true and the severity at
      * least warning.
+     *
+     * @internal
+     */
+    isEnabled(node) {
+        return this.enabled && this.severity >= Severity.WARN && (!node || node.ruleEnabled(this.name));
+    }
+    /**
+     * Test if rule is enabled.
+     *
+     * To be considered enabled the enabled flag must be true and the severity at
+     * least warning.
+     *
+     * @internal
      */
-    isEnabled() {
-        return this.enabled && this.severity >= Severity.WARN;
+    isBlocked(node) {
+        if (this.blockers.length > 0) {
+            return true;
+        }
+        if (node && node.ruleBlockers(this.name).length > 0) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get a list of all blockers currently active this rule.
+     *
+     * @internal
+     */
+    getBlockers(node) {
+        return [...this.blockers, ...(node ? node.ruleBlockers(this.name) : [])];
     }
     /**
      * Check if keyword is being ignored by the current rule configuration.
@@ -3521,8 +3611,16 @@ class Rule {
     }
     report(...args) {
         const { node, message, location, context } = unpackErrorDescriptor(args);
-        if (this.isEnabled() && (!node || node.ruleEnabled(this.name))) {
-            const where = this.findLocation({ node, location, event: this.event });
+        const enabled = this.isEnabled(node);
+        const blocked = this.isBlocked(node);
+        const where = this.findLocation({ node, location, event: this.event });
+        this.parser.trigger("rule:error", {
+            location: where,
+            ruleId: this.name,
+            enabled,
+            blockers: this.getBlockers(node),
+        });
+        if (enabled && !blocked) {
             const interpolated = interpolate(message, context !== null && context !== void 0 ? context : {});
             this.reporter.add(this, interpolated, this.severity, node, where, context);
         }
@@ -3621,7 +3719,7 @@ class Rule {
     }
 }
 
-const defaults$v = {
+const defaults$w = {
     allowExternal: true,
     allowRelative: true,
     allowAbsolute: true,
@@ -3665,7 +3763,7 @@ function matchList(value, list) {
 }
 class AllowedLinks extends Rule {
     constructor(options) {
-        super({ ...defaults$v, ...options });
+        super({ ...defaults$w, ...options });
         this.allowExternal = parseAllow(this.options.allowExternal);
         this.allowRelative = parseAllow(this.options.allowRelative);
         this.allowAbsolute = parseAllow(this.options.allowAbsolute);
@@ -3813,7 +3911,7 @@ var RuleContext$1;
     RuleContext["MISSING_ALT"] = "missing-alt";
     RuleContext["MISSING_HREF"] = "missing-href";
 })(RuleContext$1 || (RuleContext$1 = {}));
-const defaults$u = {
+const defaults$v = {
     accessible: true,
 };
 function findByTarget(target, siblings) {
@@ -3851,7 +3949,7 @@ function getDescription$1(context) {
 }
 class AreaAlt extends Rule {
     constructor(options) {
-        super({ ...defaults$u, ...options });
+        super({ ...defaults$v, ...options });
     }
     static schema() {
         return {
@@ -4020,13 +4118,13 @@ class ConfigError extends UserError {
     }
 }
 
-const defaults$t = {
+const defaults$u = {
     style: "lowercase",
     ignoreForeign: true,
 };
 class AttrCase extends Rule {
     constructor(options) {
-        super({ ...defaults$t, ...options });
+        super({ ...defaults$u, ...options });
         this.style = new CaseStyle(this.options.style, "attr-case");
     }
     static schema() {
@@ -4136,7 +4234,7 @@ const MATCH_SCRIPT_DATA = /^[^]*?(?=<\/script)/;
 const MATCH_SCRIPT_END = /^<(\/)(script)/;
 const MATCH_STYLE_DATA = /^[^]*?(?=<\/style)/;
 const MATCH_STYLE_END = /^<(\/)(style)/;
-const MATCH_DIRECTIVE = /^<!--\s*(\[)html-validate-([a-z0-9-]+)\s*(.*?)(]?)\s*-->/;
+const MATCH_DIRECTIVE = /^(<!--\s*\[html-validate-)([a-z0-9-]+)(\s*)(.*?)(]?\s*-->)/;
 const MATCH_COMMENT = /^<!--([^]*?)-->/;
 const MATCH_CONDITIONAL = /^<!\[([^\]]*?)\]>/;
 class InvalidTokenError extends Error {
@@ -4371,7 +4469,7 @@ class AttrDelimiter extends Rule {
 }
 
 const DEFAULT_PATTERN = "[a-z0-9-:]+";
-const defaults$s = {
+const defaults$t = {
     pattern: DEFAULT_PATTERN,
     ignoreForeign: true,
 };
@@ -4408,7 +4506,7 @@ function generateDescription(name, pattern) {
 }
 class AttrPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$s, ...options });
+        super({ ...defaults$t, ...options });
         this.pattern = generateRegexp(this.options.pattern);
     }
     static schema() {
@@ -4469,7 +4567,7 @@ var QuoteStyle;
     QuoteStyle["AUTO_QUOTE"] = "auto";
     QuoteStyle["ANY_QUOTE"] = "any";
 })(QuoteStyle || (QuoteStyle = {}));
-const defaults$r = {
+const defaults$s = {
     style: "auto",
     unquoted: false,
 };
@@ -4536,7 +4634,7 @@ class AttrQuotes extends Rule {
         };
     }
     constructor(options) {
-        super({ ...defaults$r, ...options });
+        super({ ...defaults$s, ...options });
         this.style = parseStyle$4(this.options.style);
     }
     setup() {
@@ -4706,12 +4804,12 @@ class AttributeAllowedValues extends Rule {
     }
 }
 
-const defaults$q = {
+const defaults$r = {
     style: "omit",
 };
 class AttributeBooleanStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$q, ...options });
+        super({ ...defaults$r, ...options });
         this.hasInvalidStyle = parseStyle$3(this.options.style);
     }
     static schema() {
@@ -4787,12 +4885,12 @@ function reportMessage$1(attr, style) {
     return "";
 }
 
-const defaults$p = {
+const defaults$q = {
     style: "omit",
 };
 class AttributeEmptyStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$p, ...options });
+        super({ ...defaults$q, ...options });
         this.hasInvalidStyle = parseStyle$2(this.options.style);
     }
     static schema() {
@@ -4948,12 +5046,12 @@ function describePattern(pattern) {
     }
 }
 
-const defaults$o = {
+const defaults$p = {
     pattern: "kebabcase",
 };
 class ClassPattern extends Rule {
     constructor(options) {
-        super({ ...defaults$o, ...options });
+        super({ ...defaults$p, ...options });
         this.pattern = parsePattern(this.options.pattern);
     }
     static schema() {
@@ -5062,13 +5160,13 @@ class CloseOrder extends Rule {
     }
 }
 
-const defaults$n = {
+const defaults$o = {
     include: null,
     exclude: null,
 };
 class Deprecated extends Rule {
     constructor(options) {
-        super({ ...defaults$n, ...options });
+        super({ ...defaults$o, ...options });
     }
     static schema() {
         return {
@@ -5231,12 +5329,12 @@ let NoStyleTag$1 = class NoStyleTag extends Rule {
     }
 };
 
-const defaults$m = {
+const defaults$n = {
     style: "uppercase",
 };
 class DoctypeStyle extends Rule {
     constructor(options) {
-        super({ ...defaults$m, ...options });
+        super({ ...defaults$n, ...options });
     }
     static schema() {
         return {
@@ -5268,12 +5366,12 @@ class DoctypeStyle extends Rule {
     }
 }
 
-const defaults$l = {
+const defaults$m = {
     style: "lowercase",
 };
 class ElementCase extends Rule {
     constructor(options) {
-        super({ ...defaults$l, ...options });
+        super({ ...defaults$m, ...options });
         this.style = new CaseStyle(this.options.style, "element-case");
     }
     static schema() {
@@ -5339,14 +5437,14 @@ class ElementCase extends Rule {
     }
 }
 
-const defaults$k = {
+const defaults$l = {
     pattern: "^[a-z][a-z0-9\\-._]*-[a-z0-9\\-._]*$",
     whitelist: [],
     blacklist: [],
 };
 class ElementName extends Rule {
     constructor(options) {
-        super({ ...defaults$k, ...options });
+        super({ ...defaults$l, ...options });
         // eslint-disable-next-line security/detect-non-literal-regexp
         this.pattern = new RegExp(this.options.pattern);
     }
@@ -5387,7 +5485,7 @@ class ElementName extends Rule {
                 ...context.blacklist.map((cur) => `- ${cur}`),
             ];
         }
-        if (context.pattern !== defaults$k.pattern) {
+        if (context.pattern !== defaults$l.pattern) {
             return [
                 `<${context.tagName}> is not a valid element name. This project is configured to only allow names matching the following regular expression:`,
                 "",
@@ -5931,29 +6029,70 @@ class EmptyTitle extends Rule {
     }
 }
 
+const defaults$k = {
+    allowArrayBrackets: true,
+    shared: ["radio"],
+};
 const UNIQUE_CACHE_KEY = Symbol("form-elements-unique");
 const SHARED_CACHE_KEY = Symbol("form-elements-shared");
 function haveName(name) {
     return typeof name === "string" && name !== "";
 }
-function allowSharedName(node) {
+function allowSharedName(node, shared) {
     const type = node.getAttribute("type");
-    return Boolean(type && type.valueMatches(["radio", "checkbox"], false));
+    return Boolean(type && type.valueMatches(shared, false));
+}
+function getDocumentation(context) {
+    const trailer = "Each form control must have a unique name.";
+    if (!context) {
+        return trailer;
+    }
+    else {
+        const { name } = context;
+        switch (context.kind) {
+            case "duplicate":
+                return [`Duplicate form control name "${name}"`, trailer].join("\n");
+            case "mix":
+                return [
+                    `Form control name cannot mix regular name "{{ name }}" with array brackets "{{ name }}[]"`,
+                    trailer,
+                ].join("\n");
+        }
+    }
 }
 class FormDupName extends Rule {
-    documentation() {
+    constructor(options) {
+        super({ ...defaults$k, ...options });
+    }
+    static schema() {
         return {
-            description: "Each form control must have a unique name.",
+            allowArrayBrackets: {
+                type: "boolean",
+            },
+            shared: {
+                type: "array",
+                items: {
+                    enum: ["radio", "checkbox", "submit"],
+                },
+            },
+        };
+    }
+    documentation(context) {
+        return {
+            description: getDocumentation(context),
             url: "https://html-validate.org/rules/form-dup-name.html",
         };
     }
     setup() {
         const selector = this.getSelector();
+        const { shared } = this.options;
         this.on("dom:ready", (event) => {
             var _a, _b;
             const { document } = event;
             const controls = document.querySelectorAll(selector);
-            const [sharedControls, uniqueControls] = partition(controls, allowSharedName);
+            const [sharedControls, uniqueControls] = partition(controls, (it) => {
+                return allowSharedName(it, shared);
+            });
             /* validate all form controls which require unique elements first so each
              * form has a populated list of unique names */
             for (const control of uniqueControls) {
@@ -5980,9 +6119,35 @@ class FormDupName extends Rule {
     }
     validateUniqueName(control, form, attr, name) {
         const elements = this.getUniqueElements(form);
+        const { allowArrayBrackets } = this.options;
+        if (allowArrayBrackets) {
+            const isarray = name.endsWith("[]");
+            const basename = isarray ? name.slice(0, -2) : name;
+            const details = elements.get(basename);
+            if (details && details.array !== isarray) {
+                const context = {
+                    name: basename,
+                    kind: "mix",
+                };
+                this.report({
+                    node: control,
+                    location: attr.valueLocation,
+                    message: 'Cannot mix "{{ name }}[]" and "{{ name }}"',
+                    context,
+                });
+                return;
+            }
+            else if (!details && isarray) {
+                elements.set(basename, {
+                    array: true,
+                });
+                return;
+            }
+        }
         if (elements.has(name)) {
             const context = {
                 name,
+                kind: "duplicate",
             };
             this.report({
                 node: control,
@@ -5992,7 +6157,9 @@ class FormDupName extends Rule {
             });
         }
         else {
-            elements.add(name);
+            elements.set(name, {
+                array: false,
+            });
         }
     }
     validateSharedName(control, form, attr, name) {
@@ -6005,6 +6172,7 @@ class FormDupName extends Rule {
             (sharedElements.has(name) && sharedElements.get(name) !== type)) {
             const context = {
                 name,
+                kind: "duplicate",
             };
             this.report({
                 node: control,
@@ -6036,7 +6204,7 @@ class FormDupName extends Rule {
             return existing;
         }
         else {
-            const elements = new Set();
+            const elements = new Map();
             form.cacheSet(UNIQUE_CACHE_KEY, elements);
             return elements;
         }
@@ -7566,6 +7734,39 @@ class NoUnknownElements extends Rule {
     }
 }
 
+class NoUnusedDisable extends Rule {
+    documentation(context) {
+        return {
+            description: context
+                ? `\`${context.ruleId}\` rule is disabled but no error was reported.`
+                : "Rule is disabled but no error was reported.",
+            url: "https://html-validate.org/rules/no-unused-disable.html",
+        };
+    }
+    setup() {
+        /* this is a special rule, the `Engine` class directly emits errors on this
+         * rule, it exists only to be able to configure whenever the rule is enabled
+         * or not and to get the regular documentation and contextual help. */
+    }
+    reportUnused(unused, options, location) {
+        const tokens = new DOMTokenList(options.replace(",", " "), location);
+        for (const ruleId of unused) {
+            const index = tokens.indexOf(ruleId);
+            /* istanbul ignore next: the token should be present or it wouldn't be
+             * reported as unused, this is just a sanity check and fallback */
+            const tokenLocation = index >= 0 ? tokens.location(index) : location;
+            this.report({
+                node: null,
+                message: '"{{ ruleId }}" rule is disabled but no error was reported',
+                location: tokenLocation,
+                context: {
+                    ruleId: ruleId,
+                },
+            });
+        }
+    }
+}
+
 class NoUtf8Bom extends Rule {
     documentation() {
         return {
@@ -9189,6 +9390,7 @@ const bundledRules = {
     "no-style-tag": NoStyleTag,
     "no-trailing-whitespace": NoTrailingWhitespace,
     "no-unknown-elements": NoUnknownElements,
+    "no-unused-disable": NoUnusedDisable,
     "no-utf8-bom": NoUtf8Bom,
     "prefer-button": PreferButton,
     "prefer-native-element": PreferNativeElement,
@@ -9299,6 +9501,7 @@ const config$1 = {
         "no-self-closing": "error",
         "no-trailing-whitespace": "error",
         "no-utf8-bom": "error",
+        "no-unused-disable": "error",
         "prefer-button": "error",
         "prefer-native-element": "error",
         "prefer-tbody": "error",
@@ -9349,6 +9552,7 @@ const config = {
         "no-dup-id": "error",
         "no-multiple-main": "error",
         "no-raw-characters": ["error", { relaxed: true }],
+        "no-unused-disable": "error",
         "script-element": "error",
         "unrecognized-char-ref": "error",
         "valid-id": ["error", { relaxed: true }],
@@ -10148,6 +10352,10 @@ class Parser {
                 offset: 0,
             };
         }
+        /* trigger starting event */
+        this.trigger("parse:begin", {
+            location: null,
+        });
         /* reset DOM in case there are multiple calls in the same session */
         this.dom = new DOMTree({
             filename: (_a = source.filename) !== null && _a !== void 0 ? _a : "",
@@ -10182,6 +10390,10 @@ class Parser {
              * instead */
             location: null,
         });
+        /* trigger ending event */
+        this.trigger("parse:end", {
+            location: null,
+        });
         return this.dom.root;
     }
     /**
@@ -10492,11 +10704,11 @@ class Parser {
         };
     }
     consumeDirective(token) {
-        const [text, , action, directive, end] = token.data;
-        if (end === "") {
+        const [text, preamble, action, separator1, directive, postamble] = token.data;
+        if (!postamble.startsWith("]")) {
             throw new ParserError(token.location, `Missing end bracket "]" on directive "${text}"`);
         }
-        const match = directive.match(/^(.*?)(?:\s*(?:--|:)\s*(.*))?$/);
+        const match = directive.match(/^(.*?)(?:(\s*(?:--|:)\s*)(.*))?$/);
         /* istanbul ignore next: should not be possible, would be emitted as comment token */
         if (!match) {
             throw new Error(`Failed to parse directive "${text}"`);
@@ -10504,12 +10716,32 @@ class Parser {
         if (!isValidDirective(action)) {
             throw new ParserError(token.location, `Unknown directive "${action}"`);
         }
-        const [, data, comment] = match;
+        const [, data, separator2, comment] = match;
+        const prefix = "html-validate-";
+        /* <!-- [html-validate-action options -- comment] -->
+         *                     ^      ^          ^--------------- comment offset
+         *                     |      \-------------------------- options offset
+         *                     \--------------------------------- action offset
+         */
+        const actionOffset = preamble.length;
+        const optionsOffset = actionOffset + action.length + separator1.length;
+        const commentOffset = optionsOffset + data.length + (separator2 || "").length;
+        const location = sliceLocation(token.location, preamble.length - prefix.length - 1, -postamble.length + 1);
+        const actionLocation = sliceLocation(token.location, actionOffset, actionOffset + action.length);
+        const optionsLocation = data
+            ? sliceLocation(token.location, optionsOffset, optionsOffset + data.length)
+            : undefined;
+        const commentLocation = comment
+            ? sliceLocation(token.location, commentOffset, commentOffset + comment.length)
+            : undefined;
         this.trigger("directive", {
             action,
             data,
             comment: comment || "",
-            location: token.location,
+            location,
+            actionLocation,
+            optionsLocation,
+            commentLocation,
         });
     }
     /**
@@ -10795,6 +11027,18 @@ function messageSort(a, b) {
     return 0;
 }
 
+let blockerCounter = 1;
+/**
+ * Creates a new rule blocker for using when blocking rules from generating
+ * errors.
+ *
+ * @internal
+ */
+function createBlocker() {
+    const id = blockerCounter++;
+    return id;
+}
+
 /**
  * @internal
  */
@@ -10822,6 +11066,15 @@ class Engine {
             const parser = this.instantiateParser();
             /* setup plugins and rules */
             const { rules } = this.setupPlugins(source, this.config, parser);
+            const noUnusedDisable = rules["no-unused-disable"];
+            const directiveContext = {
+                rules,
+                reportUnused(unused, options, location) {
+                    if (noUnusedDisable) {
+                        noUnusedDisable.reportUnused(unused, options, location);
+                    }
+                },
+            };
             /* create a faux location at the start of the stream for the next events */
             const location = {
                 filename: source.filename,
@@ -10847,7 +11100,7 @@ class Engine {
             parser.trigger("source:ready", sourceEvent);
             /* setup directive handling */
             parser.on("directive", (_, event) => {
-                this.processDirective(event, parser, rules);
+                this.processDirective(event, parser, directiveContext);
             });
             /* parse token stream */
             try {
@@ -10954,12 +11207,15 @@ class Engine {
     instantiateParser() {
         return new this.ParserClass(this.config);
     }
-    processDirective(event, parser, allRules) {
+    processDirective(event, parser, context) {
+        var _a;
         const rules = event.data
             .split(",")
             .map((name) => name.trim())
-            .map((name) => allRules[name])
+            .map((name) => context.rules[name])
             .filter((rule) => rule); /* filter out missing rules */
+        /* istanbul ignore next: option must be present or there would be no rules to disable */
+        const location = (_a = event.optionsLocation) !== null && _a !== void 0 ? _a : event.location;
         switch (event.action) {
             case "enable":
                 this.processEnableDirective(rules, parser);
@@ -10968,10 +11224,10 @@ class Engine {
                 this.processDisableDirective(rules, parser);
                 break;
             case "disable-block":
-                this.processDisableBlockDirective(rules, parser);
+                this.processDisableBlockDirective(context, rules, parser, event.data, location);
                 break;
             case "disable-next":
-                this.processDisableNextDirective(rules, parser);
+                this.processDisableNextDirective(context, rules, parser, event.data, location);
                 break;
         }
     }
@@ -10996,10 +11252,13 @@ class Engine {
             data.target.disableRules(rules.map((rule) => rule.name));
         });
     }
-    processDisableBlockDirective(rules, parser) {
+    processDisableBlockDirective(context, rules, parser, options, location) {
+        const ruleIds = rules.map((it) => it.name);
+        const blocker = createBlocker();
+        const unused = new Set(ruleIds);
         let directiveBlock = null;
         for (const rule of rules) {
-            rule.setEnabled(false);
+            rule.block(blocker);
         }
         const unregisterOpen = parser.on("tag:start", (event, data) => {
             var _a, _b;
@@ -11011,7 +11270,7 @@ class Engine {
             }
             /* disable rules directly on the node so it will be recorded for later,
              * more specifically when using the domtree to trigger errors */
-            data.target.disableRules(rules.map((rule) => rule.name));
+            data.target.blockRules(ruleIds, blocker);
         });
         const unregisterClose = parser.on("tag:end", (event, data) => {
             /* if the directive is the last thing in a block no id would be set */
@@ -11024,26 +11283,45 @@ class Engine {
                 unregisterClose();
                 unregisterOpen();
                 for (const rule of rules) {
-                    rule.setEnabled(true);
+                    rule.unblock(blocker);
                 }
             }
         });
+        parser.on("rule:error", (event, data) => {
+            if (data.blockers.includes(blocker)) {
+                unused.delete(data.ruleId);
+            }
+        });
+        parser.on("parse:end", () => {
+            context.reportUnused(unused, options, location);
+        });
     }
-    processDisableNextDirective(rules, parser) {
+    processDisableNextDirective(context, rules, parser, options, location) {
+        const ruleIds = rules.map((it) => it.name);
+        const blocker = createBlocker();
+        const unused = new Set(ruleIds);
         for (const rule of rules) {
-            rule.setEnabled(false);
+            rule.block(blocker);
         }
-        /* disable rules directly on the node so it will be recorded for later,
+        /* block rules directly on the node so it will be recorded for later,
          * more specifically when using the domtree to trigger errors */
         const unregister = parser.on("tag:start", (event, data) => {
-            data.target.disableRules(rules.map((rule) => rule.name));
+            data.target.blockRules(ruleIds, blocker);
+        });
+        parser.on("rule:error", (event, data) => {
+            if (data.blockers.includes(blocker)) {
+                unused.delete(data.ruleId);
+            }
+        });
+        parser.on("parse:end", () => {
+            context.reportUnused(unused, options, location);
         });
         /* disable directive after next event occurs */
         parser.once("tag:ready, tag:end, attr", () => {
             unregister();
             parser.defer(() => {
                 for (const rule of rules) {
-                    rule.setEnabled(true);
+                    rule.unblock(blocker);
                 }
             });
         });
@@ -11435,7 +11713,7 @@ class HtmlValidate {
 /** @public */
 const name = "html-validate";
 /** @public */
-const version = "7.12.1";
+const version = "7.13.0";
 /** @public */
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
@@ -11878,5 +12156,5 @@ function getFormatter(name) {
     return (_a = availableFormatters[name]) !== null && _a !== void 0 ? _a : null;
 }
 
-export { Attribute as A, 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, definePlugin as j, getFormatter as k, legacyRequire as l, ensureError as m, configDataFromFile as n, compatibilityCheck as o, presets as p, codeframe as q, ruleExists as r, sliceLocation as s, isTextNode as t, isElementNode as u, version as v, generateIdSelector as w, name as x, bugs as y };
+export { Attribute as A, 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, Validator as V, 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, definePlugin as j, getFormatter as k, legacyRequire as l, ensureError as m, configDataFromFile as n, compatibilityCheck as o, presets as p, codeframe as q, ruleExists as r, sliceLocation as s, isTextNode as t, isElementNode as u, version as v, generateIdSelector as w, name as x, bugs as y };
 //# sourceMappingURL=core.js.map