html-validate 10.13.1 → 10.15.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,19 +2099,86 @@ 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 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 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) {
   let current = element.parent;
   while (current && !current.isRootElement()) {
@@ -2173,88 +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 */;
-  }
-  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 */;
+class ComplexSelector {
+  compounds;
+  constructor(compounds) {
+    this.compounds = compounds;
   }
-  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;
-    }
+  static fromString(selector) {
+    return new ComplexSelector(getCompounds(selector));
   }
-  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]
-  );
-}
-function escapeSelectorComponent(text) {
-  const codepoints = {
-    "	": "\\9 ",
-    "\n": "\\a ",
-    "\r": "\\d "
-  };
-  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}`;
-}
-class Selector {
-  pattern;
-  constructor(selector) {
-    this.pattern = Selector.parse(selector);
+  static fromCompounds(compounds) {
+    return new ComplexSelector(compounds);
   }
   /**
    * Match this selector against a HtmlElement.
@@ -2271,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;
@@ -2287,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:
@@ -2300,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];
     }
@@ -2314,7 +2304,7 @@ class Selector {
         adjacent = false;
         return true;
       }
-      if (cur === node) {
+      if (cur.isSameNode(node)) {
         adjacent = true;
       }
       return false;
@@ -2326,7 +2316,7 @@ class Selector {
       if (after) {
         return true;
       }
-      if (cur === node) {
+      if (cur.isSameNode(node)) {
         after = true;
       }
       return false;
@@ -2334,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;
@@ -2369,6 +2384,7 @@ class TextNode extends DOMNode {
   }
 }
 
+const CHILD_ELEMENTS = /* @__PURE__ */ Symbol("childElements");
 const ROLE = /* @__PURE__ */ Symbol("role");
 const TABINDEX = /* @__PURE__ */ Symbol("tabindex");
 var NodeClosed = /* @__PURE__ */ ((NodeClosed2) => {
@@ -2535,7 +2551,11 @@ class HtmlElement extends DOMNode {
    * Similar to childNodes but only elements.
    */
   get childElements() {
-    return this.childNodes.filter(isElementNode);
+    const cached = this.cacheGet(CHILD_ELEMENTS);
+    if (cached !== void 0) {
+      return cached;
+    }
+    return this.cacheSet(CHILD_ELEMENTS, this.childNodes.filter(isElementNode));
   }
   /**
    * Find the first ancestor matching a selector.
@@ -2642,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);
     });
   }
@@ -2875,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);
     }
   }
   /**
@@ -2931,12 +2951,24 @@ class HtmlElement extends DOMNode {
     }
     return visit(this);
   }
+  append(node) {
+    super.append(node);
+    this.cacheRemove(CHILD_ELEMENTS);
+  }
+  insertBefore(node, reference) {
+    super.insertBefore(node, reference);
+    this.cacheRemove(CHILD_ELEMENTS);
+  }
+  removeChild(node) {
+    return super.removeChild(node);
+  }
   /**
    * @internal
    */
   _setParent(node) {
     const oldParent = this._parent;
     this._parent = node instanceof HtmlElement ? node : null;
+    oldParent?.cacheRemove(CHILD_ELEMENTS);
     return oldParent;
   }
 }
@@ -3718,6 +3750,7 @@ class Rule {
   severity;
   // rule severity
   event;
+  tracker;
   /**
    * Rule name. Defaults to filename without extension but can be overwritten by
    * subclasses.
@@ -3737,6 +3770,7 @@ class Rule {
     this.blockers = [];
     this.severity = Severity.DISABLED;
     this.name = "";
+    this.tracker = null;
   }
   getSeverity() {
     return this.severity;
@@ -3912,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);
+        }
       }
     });
   }
@@ -3929,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.
    *
@@ -12443,8 +12493,10 @@ class StaticConfigLoader extends ConfigLoader {
 
 class EventHandler {
   listeners;
+  tracker;
   constructor() {
     this.listeners = {};
+    this.tracker = null;
   }
   /**
    * Add an event listener.
@@ -12483,6 +12535,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.
    *
@@ -12491,8 +12551,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) {
@@ -12504,7 +12574,7 @@ class EventHandler {
 }
 
 const name = "html-validate";
-const version = "10.13.1";
+const version = "10.15.0";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function freeze(src) {
@@ -12804,32 +12874,92 @@ class Parser {
    * valid). The parser handles this by checking if the element on top of the
    * stack when is allowed to omit.
    */
+  /**
+   * Check whether a given element would be implicitly closed by an incoming
+   * start tag. Used both in `closeOptional` and in the multi-level lookahead.
+   */
+  wouldCloseElement(token, element) {
+    if (!element.meta) {
+      return false;
+    }
+    const implicitClosed = element.meta.implicitClosed;
+    if (!implicitClosed) {
+      return false;
+    }
+    const tagName = token.data[2];
+    const incomingMeta = this.metaTable.getMetaFor(tagName);
+    return implicitClosed.some((entry) => {
+      if (!entry.startsWith("@")) {
+        return entry === tagName;
+      }
+      return incomingMeta ? matchesContentCategory(incomingMeta, entry) : false;
+    });
+  }
+  /**
+   * Walk up the active stack to find the parent element that will remain
+   * after all multi-level implicit closes triggered by the incoming start tag.
+   * For a single-level close this is equivalent to `getActive().parent`.
+   */
+  getParentAfterImplicitClose(token) {
+    let current = this.dom.getActive();
+    while (!current.isRootElement() && this.wouldCloseElement(token, current)) {
+      const { parent } = current;
+      if (!parent) {
+        break;
+      }
+      current = parent;
+    }
+    return current;
+  }
   closeOptional(token) {
     const active = this.dom.getActive();
     if (!active.meta) {
       return false;
     }
-    const tagName = token.data[2];
     const open = !token.data[1];
-    const implicitClosed = active.meta.implicitClosed;
     if (open) {
-      if (!implicitClosed) {
-        return false;
-      }
-      const incomingMeta = this.metaTable.getMetaFor(tagName);
-      return implicitClosed.some((entry) => {
-        if (!entry.startsWith("@")) {
-          return entry === tagName;
-        }
-        return incomingMeta ? matchesContentCategory(incomingMeta, entry) : false;
-      });
+      return this.wouldCloseElement(token, active);
     } else {
-      if (active.is(tagName)) {
+      return this.closeOptionalEndTag(token, active);
+    }
+  }
+  /**
+   * Returns `true` if the element’s end tag may be omitted, either because
+   * its `implicitClosed` list includes its own tag name (e.g. `<li>`, `<td>`)
+   * or because `optionalEnd` is set.
+   */
+  canOmitEndTag(element) {
+    if (!element.meta) {
+      return false;
+    }
+    const { implicitClosed, optionalEnd } = element.meta;
+    return Boolean(implicitClosed?.includes(element.tagName)) || Boolean(optionalEnd);
+  }
+  /**
+   * Check whether the active element can be implicitly closed by an incoming
+   * end tag. The end tag may close a direct parent or any ancestor, as long as
+   * every intermediate element can also have its end tag omitted.
+   * This handles cases like `</table>` implicitly closing `<td>`, `<tr>`, `<tbody>`.
+   */
+  closeOptionalEndTag(token, active) {
+    const tagName = token.data[2];
+    if (active.is(tagName)) {
+      return false;
+    }
+    if (!this.canOmitEndTag(active)) {
+      return false;
+    }
+    let ancestor = active.parent;
+    while (ancestor && !ancestor.isRootElement()) {
+      if (ancestor.is(tagName)) {
+        return true;
+      }
+      if (!this.canOmitEndTag(ancestor)) {
         return false;
       }
-      const canOmitEnd = Boolean(implicitClosed?.includes(active.tagName)) || Boolean(active.meta.optionalEnd);
-      return Boolean(active.parent && active.parent.is(tagName) && canOmitEnd);
+      ancestor = ancestor.parent;
     }
+    return false;
   }
   /**
    * Check whether an intermediary element (e.g. `<head>` or `<body>`) should
@@ -12918,8 +13048,21 @@ class Parser {
     );
     const endToken = tokens.at(-1);
     const isStartTag = !startToken.data[1];
-    const closeOptional = this.closeOptional(startToken);
-    const baseParent = closeOptional ? this.dom.getActive().parent : this.dom.getActive();
+    let baseParent;
+    if (isStartTag) {
+      baseParent = this.getParentAfterImplicitClose(startToken);
+    } else {
+      const tagName = startToken.data[2];
+      let cur = this.dom.getActive();
+      while (!cur.isRootElement() && !cur.is(tagName)) {
+        const { parent: parent2 } = cur;
+        if (!parent2) {
+          break;
+        }
+        cur = parent2;
+      }
+      baseParent = cur;
+    }
     const implicitParent = isStartTag ? this.peekImplicitOpen(startToken, baseParent) : null;
     const parent = implicitParent ?? baseParent;
     const node = HtmlElement.fromTokens(
@@ -12931,7 +13074,7 @@ class Parser {
     );
     const isClosing = !isStartTag || node.closed !== NodeClosed.Open;
     const isForeign = node.meta?.foreign;
-    if (closeOptional) {
+    while (this.closeOptional(startToken)) {
       const active = this.dom.getActive();
       active.closed = NodeClosed.ImplicitClosed;
       this.closeElement(source, node, active, startToken.location);
@@ -13365,6 +13508,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);
@@ -13412,10 +13627,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,
@@ -13431,6 +13648,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 = {
@@ -13707,6 +13927,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();
     }
@@ -15065,5 +15286,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