html-validate 10.13.1 → 10.15.0

package/dist/cjs/core.js

@@ -1204,9 +1204,6 @@ function clone(value) {
     return JSON.parse(JSON.stringify(value));
   }
 }
-function overwriteMerge$1(_a, b) {
-  return b;
-}
 class MetaTable {
   elements;
   schema;
@@ -1379,15 +1376,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;
   }
   /**
@@ -1968,71 +1972,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) {
@@ -2107,19 +2108,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()) {
@@ -2182,88 +2250,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.
@@ -2280,15 +2276,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;
@@ -2296,12 +2292,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:
@@ -2309,9 +2299,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];
     }
@@ -2323,7 +2313,7 @@ class Selector {
         adjacent = false;
         return true;
       }
-      if (cur === node) {
+      if (cur.isSameNode(node)) {
         adjacent = true;
       }
       return false;
@@ -2335,7 +2325,7 @@ class Selector {
       if (after) {
         return true;
       }
-      if (cur === node) {
+      if (cur.isSameNode(node)) {
         after = true;
       }
       return false;
@@ -2343,6 +2333,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;
@@ -2378,6 +2393,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) => {
@@ -2544,7 +2560,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.
@@ -2651,7 +2671,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);
     });
   }
@@ -2884,9 +2904,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);
     }
   }
   /**
@@ -2940,12 +2960,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;
   }
 }
@@ -3727,6 +3759,7 @@ class Rule {
   severity;
   // rule severity
   event;
+  tracker;
   /**
    * Rule name. Defaults to filename without extension but can be overwritten by
    * subclasses.
@@ -3746,6 +3779,7 @@ class Rule {
     this.blockers = [];
     this.severity = Severity.DISABLED;
     this.name = "";
+    this.tracker = null;
   }
   getSeverity() {
     return this.severity;
@@ -3921,7 +3955,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);
+        }
       }
     });
   }
@@ -3938,6 +3980,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.
    *
@@ -12452,8 +12502,10 @@ class StaticConfigLoader extends ConfigLoader {
 
 class EventHandler {
   listeners;
+  tracker;
   constructor() {
     this.listeners = {};
+    this.tracker = null;
   }
   /**
    * Add an event listener.
@@ -12492,6 +12544,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.
    *
@@ -12500,8 +12560,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) {
@@ -12513,7 +12583,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) {
@@ -12813,32 +12883,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
@@ -12927,8 +13057,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(
@@ -12940,7 +13083,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);
@@ -13374,6 +13517,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);
@@ -13421,10 +13636,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,
@@ -13440,6 +13657,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 = {
@@ -13716,6 +13936,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();
     }
@@ -15091,6 +15312,7 @@ exports.NestedError = NestedError;
 exports.NodeClosed = NodeClosed;
 exports.NodeType = NodeType;
 exports.Parser = Parser;
+exports.PerformanceTracker = PerformanceTracker;
 exports.Reporter = Reporter;
 exports.ResolvedConfig = ResolvedConfig;
 exports.Rule = Rule;