html-validate 10.14.0 → 10.16.0

package/dist/esm/core.js

@@ -1195,9 +1195,6 @@ function clone(value) {
     return JSON.parse(JSON.stringify(value));
   }
 }
-function overwriteMerge$1(_a, b) {
-  return b;
-}
 class MetaTable {
   elements;
   schema;
@@ -1370,15 +1367,22 @@ class MetaTable {
     }
   }
   mergeElement(a, b) {
-    const merged = deepmerge(a, b, { arrayMerge: overwriteMerge$1 });
-    const filteredAttrs = Object.entries(
-      merged.attributes
-    ).filter(([, attr]) => {
-      const val = !attr.delete;
-      delete attr.delete;
-      return val;
-    });
-    merged.attributes = Object.fromEntries(filteredAttrs);
+    const merged = { ...a, ...b };
+    const mergedAttrs = {
+      ...a.attributes,
+      ...b.attributes
+    };
+    for (const [name, attr] of Object.entries(mergedAttrs)) {
+      if (attr.delete) {
+        delete mergedAttrs[name];
+      } else {
+        delete attr.delete;
+      }
+    }
+    merged.attributes = mergedAttrs;
+    if (a.aria) {
+      merged.aria = { ...a.aria, ...b.aria };
+    }
     return merged;
   }
   /**
@@ -1959,71 +1963,68 @@ function factory(name, context) {
 function stripslashes(value) {
   return value.replaceAll(/\\(.)/g, "$1");
 }
-class Condition {
+function createClassCondition(classname) {
+  return {
+    kind: "class",
+    classname,
+    match(node) {
+      return node.classList.contains(classname);
+    }
+  };
 }
-class ClassCondition extends Condition {
-  classname;
-  constructor(classname) {
-    super();
-    this.classname = classname;
-  }
-  match(node) {
-    return node.classList.contains(this.classname);
-  }
+function createIdCondition(raw) {
+  const id = stripslashes(raw);
+  return {
+    kind: "id",
+    id,
+    match(node) {
+      return node.id === id;
+    }
+  };
 }
-class IdCondition extends Condition {
-  id;
-  constructor(id) {
-    super();
-    this.id = stripslashes(id);
-  }
-  match(node) {
-    return node.id === this.id;
-  }
+function createAttributeCondition(attr) {
+  const match = /^(.+?)(?:([$*^|~]?=)"([^"]+?)")?$/.exec(attr);
+  const key = match[1];
+  const op = match[2];
+  const rawValue = match[3];
+  const value = typeof rawValue === "string" ? stripslashes(rawValue) : rawValue;
+  return {
+    kind: "attribute",
+    key,
+    op,
+    value,
+    match(node) {
+      const attrs = node.getAttribute(key, true);
+      return attrs.some((cur) => {
+        switch (op) {
+          case void 0:
+            return true;
+          /* attribute exists */
+          case "=":
+            return cur.value === value;
+          default:
+            throw new Error(`Attribute selector operator ${op} is not implemented yet`);
+        }
+      });
+    }
+  };
 }
-class AttributeCondition extends Condition {
-  key;
-  op;
-  value;
-  constructor(attr) {
-    super();
-    const [, key, op, value] = /^(.+?)(?:([$*^|~]?=)"([^"]+?)")?$/.exec(attr);
-    this.key = key;
-    this.op = op;
-    this.value = typeof value === "string" ? stripslashes(value) : value;
-  }
-  match(node) {
-    const attr = node.getAttribute(this.key, true);
-    return attr.some((cur) => {
-      switch (this.op) {
-        case void 0:
-          return true;
-        /* attribute exists */
-        case "=":
-          return cur.value === this.value;
-        default:
-          throw new Error(`Attribute selector operator ${this.op} is not implemented yet`);
-      }
-    });
+function createPseudoClassCondition(pseudoclass, context) {
+  const match = /^([^(]+)(?:\((.*)\))?$/.exec(pseudoclass);
+  if (!match) {
+    throw new Error(`Missing pseudo-class after colon in selector pattern "${context}"`);
   }
-}
-class PseudoClassCondition extends Condition {
-  name;
-  args;
-  constructor(pseudoclass, context) {
-    super();
-    const match = /^([^(]+)(?:\((.*)\))?$/.exec(pseudoclass);
-    if (!match) {
-      throw new Error(`Missing pseudo-class after colon in selector pattern "${context}"`);
+  const name = match[1];
+  const args = match[2];
+  return {
+    kind: "pseudo",
+    name,
+    args,
+    match(node, selectorContext) {
+      const fn = factory(name, selectorContext);
+      return fn(node, args);
     }
-    const [, name, args] = match;
-    this.name = name;
-    this.args = args;
-  }
-  match(node, context) {
-    const fn = factory(this.name, context);
-    return fn(node, this.args);
-  }
+  };
 }
 
 function isDelimiter(ch) {
@@ -2098,37 +2099,84 @@ class Compound {
   createCondition(pattern) {
     switch (pattern[0]) {
       case ".":
-        return new ClassCondition(pattern.slice(1));
+        return createClassCondition(pattern.slice(1));
       case "#":
-        return new IdCondition(pattern.slice(1));
+        return createIdCondition(pattern.slice(1));
       case "[":
-        return new AttributeCondition(pattern.slice(1, -1));
+        return createAttributeCondition(pattern.slice(1, -1));
       case ":":
-        return new PseudoClassCondition(pattern.slice(1), this.selector);
+        return createPseudoClassCondition(pattern.slice(1), this.selector);
       default:
         throw new Error(`Failed to create selector condition for "${pattern}"`);
     }
   }
 }
 
-const codepoints = {
-  "	": "\\9 ",
-  "\n": "\\a ",
-  "\r": "\\d "
-};
-function escapeSelectorComponent(text) {
-  return text.toString().replaceAll(/([\t\n\r]|[^\w-])/gi, (_, ch) => {
-    if (codepoints[ch]) {
-      return codepoints[ch];
-    } else {
-      return `\\${ch}`;
+const escapedCodepoints = /* @__PURE__ */ new Set(["9", "a", "d"]);
+function* splitSelectorElements(selector) {
+  let begin = 0;
+  let end = 0;
+  function initialState(ch, p) {
+    if (ch === "\\") {
+      return 1 /* ESCAPED */;
     }
-  });
+    if (ch === " ") {
+      end = p;
+      return 2 /* WHITESPACE */;
+    }
+    return 0 /* INITIAL */;
+  }
+  function escapedState(ch) {
+    if (escapedCodepoints.has(ch)) {
+      return 1 /* ESCAPED */;
+    }
+    return 0 /* INITIAL */;
+  }
+  function* whitespaceState(ch, p) {
+    if (ch === " ") {
+      return 2 /* WHITESPACE */;
+    }
+    yield selector.slice(begin, end);
+    begin = p;
+    end = p;
+    return 0 /* INITIAL */;
+  }
+  let state = 0 /* INITIAL */;
+  for (let p = 0; p < selector.length; p++) {
+    const ch = selector[p];
+    switch (state) {
+      case 0 /* INITIAL */:
+        state = initialState(ch, p);
+        break;
+      case 1 /* ESCAPED */:
+        state = escapedState(ch);
+        break;
+      case 2 /* WHITESPACE */:
+        state = yield* whitespaceState(ch, p);
+        break;
+    }
+  }
+  if (begin !== selector.length) {
+    yield selector.slice(begin);
+  }
 }
 
-function generateIdSelector(id) {
-  const escaped = escapeSelectorComponent(id);
-  return /^\d/.test(escaped) ? `[id="${escaped}"]` : `#${escaped}`;
+function unescapeCodepoint(value) {
+  const replacement = {
+    "\\9 ": "	",
+    "\\a ": "\n",
+    "\\d ": "\r"
+  };
+  return value.replaceAll(
+    /(\\[9ad] )/g,
+    (_, codepoint) => replacement[codepoint]
+  );
+}
+function getCompounds(selector) {
+  selector = selector.replaceAll(/([+>~]) /g, "$1");
+  return Array.from(splitSelectorElements(selector), (element) => {
+    return new Compound(unescapeCodepoint(element));
+  });
 }
 
 function* ancestors$1(element) {
@@ -2193,70 +2241,16 @@ function matchElement(element, compounds, context) {
   return false;
 }
 
-const escapedCodepoints = /* @__PURE__ */ new Set(["9", "a", "d"]);
-function* splitSelectorElements(selector) {
-  let begin = 0;
-  let end = 0;
-  function initialState(ch, p) {
-    if (ch === "\\") {
-      return 1 /* ESCAPED */;
-    }
-    if (ch === " ") {
-      end = p;
-      return 2 /* WHITESPACE */;
-    }
-    return 0 /* INITIAL */;
+class ComplexSelector {
+  compounds;
+  constructor(compounds) {
+    this.compounds = compounds;
   }
-  function escapedState(ch) {
-    if (escapedCodepoints.has(ch)) {
-      return 1 /* ESCAPED */;
-    }
-    return 0 /* INITIAL */;
+  static fromString(selector) {
+    return new ComplexSelector(getCompounds(selector));
   }
-  function* whitespaceState(ch, p) {
-    if (ch === " ") {
-      return 2 /* WHITESPACE */;
-    }
-    yield selector.slice(begin, end);
-    begin = p;
-    end = p;
-    return 0 /* INITIAL */;
-  }
-  let state = 0 /* INITIAL */;
-  for (let p = 0; p < selector.length; p++) {
-    const ch = selector[p];
-    switch (state) {
-      case 0 /* INITIAL */:
-        state = initialState(ch, p);
-        break;
-      case 1 /* ESCAPED */:
-        state = escapedState(ch);
-        break;
-      case 2 /* WHITESPACE */:
-        state = yield* whitespaceState(ch, p);
-        break;
-    }
-  }
-  if (begin !== selector.length) {
-    yield selector.slice(begin);
-  }
-}
-
-function unescapeCodepoint(value) {
-  const replacement = {
-    "\\9 ": "	",
-    "\\a ": "\n",
-    "\\d ": "\r"
-  };
-  return value.replaceAll(
-    /(\\[9ad] )/g,
-    (_, codepoint) => replacement[codepoint]
-  );
-}
-class Selector {
-  pattern;
-  constructor(selector) {
-    this.pattern = Selector.parse(selector);
+  static fromCompounds(compounds) {
+    return new ComplexSelector(compounds);
   }
   /**
    * Match this selector against a HtmlElement.
@@ -2273,15 +2267,15 @@ class Selector {
    */
   matchElement(element) {
     const context = { scope: null };
-    return matchElement(element, this.pattern, context);
+    return matchElement(element, this.compounds, context);
   }
   *matchInternal(root, level, context) {
-    if (level >= this.pattern.length) {
+    if (level >= this.compounds.length) {
       yield root;
       return;
     }
-    const pattern = this.pattern[level];
-    const matches = Selector.findCandidates(root, pattern);
+    const pattern = this.compounds[level];
+    const matches = ComplexSelector.findCandidates(root, pattern);
     for (const node of matches) {
       if (!pattern.match(node, context)) {
         continue;
@@ -2289,12 +2283,6 @@ class Selector {
       yield* this.matchInternal(node, level + 1, context);
     }
   }
-  static parse(selector) {
-    selector = selector.replaceAll(/([+>~]) /g, "$1");
-    return Array.from(splitSelectorElements(selector), (element) => {
-      return new Compound(unescapeCodepoint(element));
-    });
-  }
   static findCandidates(root, pattern) {
     switch (pattern.combinator) {
       case Combinator.DESCENDANT:
@@ -2302,9 +2290,9 @@ class Selector {
       case Combinator.CHILD:
         return root.childElements.filter((node) => node.is(pattern.tagName));
       case Combinator.ADJACENT_SIBLING:
-        return Selector.findAdjacentSibling(root);
+        return ComplexSelector.findAdjacentSibling(root);
       case Combinator.GENERAL_SIBLING:
-        return Selector.findGeneralSibling(root);
+        return ComplexSelector.findGeneralSibling(root);
       case Combinator.SCOPE:
         return [root];
     }
@@ -2316,7 +2304,7 @@ class Selector {
         adjacent = false;
         return true;
       }
-      if (cur === node) {
+      if (cur.isSameNode(node)) {
         adjacent = true;
       }
       return false;
@@ -2328,7 +2316,7 @@ class Selector {
       if (after) {
         return true;
       }
-      if (cur === node) {
+      if (cur.isSameNode(node)) {
         after = true;
       }
       return false;
@@ -2336,6 +2324,31 @@ class Selector {
   }
 }
 
+const codepoints = {
+  "	": "\\9 ",
+  "\n": "\\a ",
+  "\r": "\\d "
+};
+function escapeSelectorComponent(text) {
+  return text.toString().replaceAll(/([\t\n\r]|[^\w-])/gi, (_, ch) => {
+    if (codepoints[ch]) {
+      return codepoints[ch];
+    } else {
+      return `\\${ch}`;
+    }
+  });
+}
+
+function generateIdSelector(id) {
+  const escaped = escapeSelectorComponent(id);
+  return /^\d/.test(escaped) ? `[id="${escaped}"]` : `#${escaped}`;
+}
+
+function parseSelector(selector) {
+  const compounds = getCompounds(selector);
+  return ComplexSelector.fromCompounds(compounds);
+}
+
 const TEXT_NODE_NAME = "#text";
 function isTextNode(node) {
   return node?.nodeType === NodeType.TEXT_NODE;
@@ -2649,7 +2662,7 @@ class HtmlElement extends DOMNode {
    */
   matches(selectorList) {
     return selectorList.split(",").some((it) => {
-      const selector = new Selector(it.trim());
+      const selector = parseSelector(it.trim());
       return selector.matchElement(this);
     });
   }
@@ -2882,9 +2895,9 @@ class HtmlElement extends DOMNode {
     if (!selectorList) {
       return;
     }
-    for (const selector of selectorList.split(/(?<!\\),\s*/)) {
-      const pattern = new Selector(selector);
-      yield* pattern.match(this);
+    for (const selectorString of selectorList.split(/(?<!\\),\s*/)) {
+      const selector = parseSelector(selectorString);
+      yield* selector.match(this);
     }
   }
   /**
@@ -3737,6 +3750,7 @@ class Rule {
   severity;
   // rule severity
   event;
+  tracker;
   /**
    * Rule name. Defaults to filename without extension but can be overwritten by
    * subclasses.
@@ -3756,6 +3770,7 @@ class Rule {
     this.blockers = [];
     this.severity = Severity.DISABLED;
     this.name = "";
+    this.tracker = null;
   }
   getSeverity() {
     return this.severity;
@@ -3931,7 +3946,15 @@ class Rule {
     return this.parser.on(event, (_event, data) => {
       if (this.isEnabled() && filter(data)) {
         this.event = data;
-        callback(data);
+        const { tracker } = this;
+        if (tracker) {
+          const start = performance.now();
+          callback(data);
+          const end = performance.now();
+          tracker.trackRule(this.name, end - start);
+        } else {
+          callback(data);
+        }
       }
     });
   }
@@ -3948,6 +3971,14 @@ class Rule {
     this.severity = severity;
     this.meta = meta;
   }
+  /**
+   * Set (or clear) the performance tracker.
+   *
+   * @internal
+   */
+  setTracker(tracker) {
+    this.tracker = tracker;
+  }
   /**
    * Validate rule options against schema. Throws error if object does not validate.
    *
@@ -4330,24 +4361,27 @@ const defaults$A = {
   }
 };
 const allowlist = /* @__PURE__ */ new Set([
-  "main",
-  "nav",
-  "table",
-  "td",
-  "th",
+  /* landmark elements */
+  "article",
   "aside",
-  "header",
   "footer",
+  "form",
+  "header",
+  "main",
+  "nav",
+  "search",
   "section",
-  "article",
+  /* other allowed elements */
+  "area",
   "dialog",
-  "form",
+  "fieldset",
+  "figure",
   "iframe",
   "img",
-  "area",
-  "fieldset",
   "summary",
-  "figure"
+  "table",
+  "td",
+  "th"
 ]);
 function isValidUsage(target, meta) {
   const explicit = meta.attributes["aria-label"];
@@ -7677,7 +7711,7 @@ class InputMissingLabel extends Rule {
     if (hasAccessibleName(root, elem)) {
       return;
     }
-    let label = [];
+    let label;
     if ((label = findLabelById(root, elem.id)).length > 0) {
       this.validateLabel(root, elem, label);
       return;
@@ -8391,7 +8425,8 @@ class NoImplicitInputType extends Rule {
 const defaults$g = {
   include: null,
   exclude: null,
-  allowedProperties: ["display"]
+  allowedProperties: ["display"],
+  allowVariables: true
 };
 class NoInlineStyle extends Rule {
   constructor(options) {
@@ -8430,17 +8465,26 @@ class NoInlineStyle extends Rule {
           type: "string"
         },
         type: "array"
+      },
+      allowVariables: {
+        type: "boolean"
       }
     };
   }
   documentation() {
+    const { allowVariables, allowedProperties } = this.options;
     const text = [
       "Inline style is not allowed.\n",
       "Inline style is a sign of unstructured CSS. Use class or ID with a separate stylesheet.\n"
     ];
-    if (this.options.allowedProperties.length > 0) {
+    if (allowedProperties.length > 0 || allowVariables) {
       text.push("Under the current configuration the following CSS properties are allowed:\n");
-      text.push(this.options.allowedProperties.map((it) => `- \`${it}\``).join("\n"));
+    }
+    if (allowedProperties.length > 0) {
+      text.push(allowedProperties.map((it) => `- \`${it}\``).join("\n"));
+    }
+    if (allowVariables) {
+      text.push("- CSS variables (custom properties starting with `--`).\n");
     }
     return {
       description: text.join("\n"),
@@ -8475,13 +8519,16 @@ class NoInlineStyle extends Rule {
     return true;
   }
   allPropertiesAllowed(value) {
-    const allowProperties = this.options.allowedProperties;
-    if (allowProperties.length === 0) {
+    const { allowedProperties, allowVariables } = this.options;
+    if (allowedProperties.length === 0 && !allowVariables) {
       return false;
     }
     const declarations = Object.keys(parseCssDeclaration(value));
     return declarations.length > 0 && declarations.every((it) => {
-      return allowProperties.includes(it);
+      if (allowVariables && it.startsWith("--")) {
+        return true;
+      }
+      return allowedProperties.includes(it);
     });
   }
 }
@@ -8584,7 +8631,7 @@ class NoMultipleMain extends Rule {
 const defaults$f = {
   relaxed: false
 };
-const textRegexp = /([<>]|&(?![\d#A-Za-z]+;))/g;
+const textRegexp = /(<|&(?![\d#A-Za-z]+;))/g;
 const unquotedAttrRegexp = /(["'<=>`]|&(?![\d#A-Za-z]+;))/g;
 const matchTemplate = /^(<%.*?%>|<\?.*?\?>|<\$.*?\$>)$/s;
 const replacementTable = {
@@ -8611,7 +8658,7 @@ class NoRawCharacters extends Rule {
   }
   documentation() {
     return {
-      description: `Some characters such as \`<\`, \`>\` and \`&\` hold special meaning in HTML and must be escaped using a character reference (html entity).`,
+      description: `Some characters such as \`<\` and \`&\` hold special meaning in HTML and must be escaped using a character reference (HTML entity).`,
       url: "https://html-validate.org/rules/no-raw-characters.html"
     };
   }
@@ -10026,14 +10073,17 @@ class UnknownCharReference extends Rule {
     if (found && (terminated || !requireSemicolon)) {
       return;
     }
-    if (found && !terminated) {
-      const entityLocation2 = getLocation(location, entity, match);
-      const message2 = `Character reference "{{ entity }}" must be terminated by a semicolon`;
-      const context2 = {
-        entity: raw,
-        terminated: false
-      };
-      this.report(node, message2, entityLocation2, context2);
+    if (!terminated) {
+      const isKnownName = found || this.entities.includes(`${entity};`);
+      if (isKnownName) {
+        const entityLocation2 = getLocation(location, entity, match);
+        const message2 = `Character reference "{{ entity }}" must be terminated by a semicolon`;
+        const context2 = {
+          entity: raw,
+          terminated: false
+        };
+        this.report(node, message2, entityLocation2, context2);
+      }
       return;
     }
     const entityLocation = getLocation(location, entity, match);
@@ -12462,8 +12512,10 @@ class StaticConfigLoader extends ConfigLoader {
 
 class EventHandler {
   listeners;
+  tracker;
   constructor() {
     this.listeners = {};
+    this.tracker = null;
   }
   /**
    * Add an event listener.
@@ -12502,6 +12554,14 @@ class EventHandler {
     });
     return deregister;
   }
+  /**
+   * Set (or clear) the performance tracker.
+   *
+   * @internal
+   */
+  setTracker(tracker) {
+    this.tracker = tracker;
+  }
   /**
    * Trigger event causing all listeners to be called.
    *
@@ -12510,8 +12570,18 @@ class EventHandler {
    */
   /* eslint-disable-next-line @typescript-eslint/no-explicit-any -- technical debt, should be made typesafe */
   trigger(event, data) {
-    for (const listener of this.getCallbacks(event)) {
-      listener.call(null, event, data);
+    const { tracker } = this;
+    if (tracker) {
+      const start = performance.now();
+      for (const listener of this.getCallbacks(event)) {
+        listener.call(null, event, data);
+      }
+      const end = performance.now();
+      tracker.trackEvent(event, end - start);
+    } else {
+      for (const listener of this.getCallbacks(event)) {
+        listener.call(null, event, data);
+      }
     }
   }
   getCallbacks(event) {
@@ -12523,7 +12593,7 @@ class EventHandler {
 }
 
 const name = "html-validate";
-const version = "10.14.0";
+const version = "10.16.0";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function freeze(src) {
@@ -13457,6 +13527,78 @@ class Parser {
   }
 }
 
+class PerformanceTracker {
+  eventData;
+  ruleData;
+  startTime;
+  accConfigTime;
+  accTransformTime;
+  constructor() {
+    this.eventData = /* @__PURE__ */ new Map();
+    this.ruleData = /* @__PURE__ */ new Map();
+    this.startTime = performance.now();
+    this.accConfigTime = 0;
+    this.accTransformTime = 0;
+  }
+  /**
+   * Record a single event trigger with the time it took to run all listeners.
+   */
+  trackEvent(name, time) {
+    const existing = this.eventData.get(name);
+    if (existing) {
+      existing.count += 1;
+      existing.time += time;
+    } else {
+      this.eventData.set(name, { count: 1, time });
+    }
+  }
+  /**
+   * Record time spent loading configuration.
+   */
+  trackConfig(time) {
+    this.accConfigTime += time;
+  }
+  /**
+   * Record time spent in transformers.
+   */
+  trackTransform(time) {
+    this.accTransformTime += time;
+  }
+  /**
+   * Record a single rule callback invocation with its execution time.
+   */
+  trackRule(ruleName, time) {
+    const existing = this.ruleData.get(ruleName);
+    if (existing) {
+      existing.count += 1;
+      existing.time += time;
+    } else {
+      this.ruleData.set(ruleName, { count: 1, time });
+    }
+  }
+  /**
+   * Returns a snapshot of the recorded performance data, with both arrays
+   * sorted by time (descending).
+   */
+  getResult() {
+    const events = Array.from(
+      this.eventData.entries(),
+      ([event, { count, time }]) => ({ event, count, time })
+    ).toSorted((a, b) => b.time - a.time);
+    const rules = Array.from(
+      this.ruleData.entries(),
+      ([rule, { count, time }]) => ({ rule, count, time })
+    ).toSorted((a, b) => b.time - a.time);
+    return {
+      events,
+      rules,
+      configTime: this.accConfigTime,
+      transformTime: this.accTransformTime,
+      totalTime: performance.now() - this.startTime
+    };
+  }
+}
+
 const ruleIds = new Set(Object.keys(bundledRules));
 function ruleExists(ruleId) {
   return ruleIds.has(ruleId);
@@ -13504,10 +13646,12 @@ class Engine {
   config;
   ParserClass;
   availableRules;
-  constructor(config, ParserClass) {
+  tracker;
+  constructor(config, ParserClass, options) {
     this.report = new Reporter();
     this.config = config;
     this.ParserClass = ParserClass;
+    this.tracker = options.tracker;
     const result = this.initPlugins(this.config);
     this.availableRules = {
       ...bundledRules,
@@ -13523,6 +13667,9 @@ class Engine {
   lint(sources) {
     for (const source of sources) {
       const parser = this.instantiateParser();
+      if (this.tracker) {
+        parser.getEventHandler().setTracker(this.tracker);
+      }
       const { rules } = this.setupPlugins(source, this.config, parser);
       const noUnusedDisable = rules["no-unused-disable"];
       const directiveContext = {
@@ -13799,6 +13946,7 @@ class Engine {
     const rule = this.instantiateRule(ruleId, options);
     rule.name = ruleId;
     rule.init(parser, report, severity, meta);
+    rule.setTracker(this.tracker);
     if (rule.setup) {
       rule.setup();
     }
@@ -15157,5 +15305,5 @@ const engines = {
 
 var workerPath = "./jest-worker.js";
 
-export { engines as $, Attribute as A, TextContent$1 as B, ConfigLoader as C, DOMNode as D, Engine as E, TextNode as F, ariaNaming as G, HtmlElement as H, classifyNodeText as I, presets as J, defineConfig as K, definePlugin as L, MetaCopyableProperty as M, NestedError as N, isUserError as O, Parser as P, keywordPatternMatcher as Q, Reporter as R, StaticConfigLoader as S, TextClassification as T, UserError as U, Validator as V, WrappedError as W, ruleExists as X, sliceLocation as Y, staticResolver as Z, walk as _, transformSourceSync as a, codeFrameColumns as a0, getEndLocation as a1, getStartLocation as a2, workerPath as a3, name as a4, bugs as a5, transformFilename as b, transformFilenameSync as c, configurationSchema as d, ConfigError as e, Config as f, compatibilityCheckImpl as g, ensureError as h, isThenable as i, getFormatter as j, deepmerge as k, ignore as l, DOMTokenList as m, normalizeSource as n, DOMTree as o, DynamicValue as p, EventHandler as q, MetaTable as r, NodeClosed as s, transformSource as t, NodeType as u, version as v, ResolvedConfig as w, Rule as x, SchemaValidationError as y, Severity as z };
+export { walk as $, Attribute as A, Severity as B, ConfigLoader as C, DOMNode as D, Engine as E, TextContent$1 as F, TextNode as G, HtmlElement as H, ariaNaming as I, classifyNodeText as J, presets as K, defineConfig as L, MetaCopyableProperty as M, NestedError as N, definePlugin as O, PerformanceTracker as P, isUserError as Q, Reporter as R, StaticConfigLoader as S, TextClassification as T, UserError as U, Validator as V, WrappedError as W, keywordPatternMatcher as X, ruleExists as Y, sliceLocation as Z, staticResolver as _, Parser as a, engines as a0, codeFrameColumns as a1, getEndLocation as a2, getStartLocation as a3, workerPath as a4, name as a5, bugs as a6, transformSourceSync as b, transformFilename as c, transformFilenameSync as d, configurationSchema as e, ConfigError as f, Config as g, compatibilityCheckImpl as h, isThenable as i, ensureError as j, getFormatter as k, deepmerge as l, ignore as m, normalizeSource as n, DOMTokenList as o, DOMTree as p, DynamicValue as q, EventHandler as r, MetaTable as s, transformSource as t, NodeClosed as u, version as v, NodeType as w, ResolvedConfig as x, Rule as y, SchemaValidationError as z };
 //# sourceMappingURL=core.js.map