html-validate 10.14.0 → 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,37 +2108,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) {
@@ -2202,70 +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 */;
+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.
@@ -2282,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;
@@ -2298,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:
@@ -2311,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];
     }
@@ -2325,7 +2313,7 @@ class Selector {
         adjacent = false;
         return true;
       }
-      if (cur === node) {
+      if (cur.isSameNode(node)) {
         adjacent = true;
       }
       return false;
@@ -2337,7 +2325,7 @@ class Selector {
       if (after) {
         return true;
       }
-      if (cur === node) {
+      if (cur.isSameNode(node)) {
         after = true;
       }
       return false;
@@ -2345,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;
@@ -2658,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);
     });
   }
@@ -2891,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);
     }
   }
   /**
@@ -3746,6 +3759,7 @@ class Rule {
   severity;
   // rule severity
   event;
+  tracker;
   /**
    * Rule name. Defaults to filename without extension but can be overwritten by
    * subclasses.
@@ -3765,6 +3779,7 @@ class Rule {
     this.blockers = [];
     this.severity = Severity.DISABLED;
     this.name = "";
+    this.tracker = null;
   }
   getSeverity() {
     return this.severity;
@@ -3940,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);
+        }
       }
     });
   }
@@ -3957,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.
    *
@@ -12471,8 +12502,10 @@ class StaticConfigLoader extends ConfigLoader {
 
 class EventHandler {
   listeners;
+  tracker;
   constructor() {
     this.listeners = {};
+    this.tracker = null;
   }
   /**
    * Add an event listener.
@@ -12511,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.
    *
@@ -12519,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) {
@@ -12532,7 +12583,7 @@ class EventHandler {
 }
 
 const name = "html-validate";
-const version = "10.14.0";
+const version = "10.15.0";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function freeze(src) {
@@ -13466,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);
@@ -13513,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,
@@ -13532,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 = {
@@ -13808,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();
     }
@@ -15183,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;