html-validate 8.25.1 → 8.26.0

package/dist/cjs/core.js

@@ -5059,6 +5059,27 @@ class CloseAttr extends Rule {
   }
 }
 
+function* ancestors(node) {
+  if (!node) {
+    return;
+  }
+  let ancestor = node;
+  while (ancestor && !ancestor.isRootElement()) {
+    yield ancestor;
+    ancestor = ancestor.parent;
+  }
+  if (ancestor) {
+    yield ancestor;
+  }
+}
+function findAncestor(node, predicate) {
+  for (const ancestor of ancestors(node)) {
+    if (predicate(ancestor)) {
+      return ancestor;
+    }
+  }
+  return null;
+}
 class CloseOrder extends Rule {
   documentation() {
     return {
@@ -5067,15 +5088,28 @@ class CloseOrder extends Rule {
     };
   }
   setup() {
+    let reported;
+    this.on("parse:begin", () => {
+      reported = /* @__PURE__ */ new Set();
+    });
+    this.on("tag:end", (event) => {
+      const current = event.target;
+      const active = event.previous;
+      if (current) {
+        return;
+      }
+      for (const ancestor of ancestors(active)) {
+        if (ancestor.isRootElement() || reported.has(ancestor.unique)) {
+          continue;
+        }
+        this.report(ancestor, `Unclosed element '<${ancestor.tagName}>'`, ancestor.location);
+        reported.add(ancestor.unique);
+      }
+    });
     this.on("tag:end", (event) => {
       const current = event.target;
       const active = event.previous;
       if (!current) {
-        this.report(
-          null,
-          `Missing close-tag, expected '</${active.tagName}>' but document ended before it was found.`,
-          event.location
-        );
         return;
       }
       if (current.voidElement) {
@@ -5092,15 +5126,32 @@ class CloseOrder extends Rule {
           offset: current.location.offset,
           size: current.tagName.length + 1
         };
-        this.report(null, "Unexpected close-tag, expected opening tag.", location);
+        this.report(null, `Stray end tag '</${current.tagName}>'`, location);
+        return;
+      }
+      if (current.tagName === active.tagName) {
         return;
       }
-      if (current.tagName !== active.tagName) {
+      const ancestor = findAncestor(active.parent, (node) => node.is(current.tagName));
+      if (ancestor && !ancestor.isRootElement()) {
+        for (const element of ancestors(active)) {
+          if (ancestor.isSameNode(element)) {
+            break;
+          }
+          if (reported.has(element.unique)) {
+            continue;
+          }
+          this.report(element, `Unclosed element '<${element.tagName}>'`, element.location);
+          reported.add(element.unique);
+        }
         this.report(
           null,
-          `Mismatched close-tag, expected '</${active.tagName}>' but found '</${current.tagName}>'.`,
+          `End tag '</${current.tagName}>' seen but there were open elements`,
           current.location
         );
+        reported.add(ancestor.unique);
+      } else {
+        this.report(null, `Stray end tag '</${current.tagName}>'`, current.location);
       }
     });
   }
@@ -11656,8 +11707,9 @@ class Parser {
         node.closed = NodeClosed.EndTag;
       }
       this.closeElement(source, node, active, endToken.location);
+      const mismatched = node.tagName !== active.tagName;
       const voidClosed = !isStartTag && node.voidElement;
-      if (!voidClosed) {
+      if (!voidClosed && !mismatched) {
         this.dom.popActive();
       }
     } else if (isForeign) {
@@ -11675,6 +11727,9 @@ class Parser {
       location
     };
     this.trigger("tag:end", event);
+    if (node && node.tagName !== active.tagName && active.closed !== NodeClosed.ImplicitClosed) {
+      return;
+    }
     if (!active.isRootElement()) {
       this.trigger("element:ready", {
         target: active,