html-validate 8.25.0 → 8.26.0

package/dist/cjs/core.js

@@ -1753,7 +1753,31 @@ class DOMNode {
     return text;
   }
   append(node) {
+    const oldParent = node._setParent(this);
+    if (oldParent && this.isSameNode(oldParent)) {
+      return;
+    }
     this.childNodes.push(node);
+    if (oldParent) {
+      oldParent._removeChild(node);
+    }
+  }
+  /**
+   * Insert a node before a reference node.
+   *
+   * @internal
+   */
+  insertBefore(node, reference) {
+    const index = reference ? this.childNodes.findIndex((it) => it.isSameNode(reference)) : -1;
+    if (index >= 0) {
+      this.childNodes.splice(index, 0, node);
+    } else {
+      this.childNodes.push(node);
+    }
+    const oldParent = node._setParent(this);
+    if (oldParent) {
+      oldParent._removeChild(node);
+    }
   }
   isRootElement() {
     return this.nodeType === NodeType.DOCUMENT_NODE;
@@ -1780,6 +1804,14 @@ class DOMNode {
   get lastChild() {
     return this.childNodes[this.childNodes.length - 1] || null;
   }
+  /**
+   * @internal
+   */
+  removeChild(node) {
+    this._removeChild(node);
+    node._setParent(null);
+    return node;
+  }
   /**
    * Block a rule for this node.
    *
@@ -1854,6 +1886,22 @@ class DOMNode {
   generateSelector() {
     return null;
   }
+  /**
+   * @internal
+   *
+   * @returns Old parent, if set.
+   */
+  _setParent(_node) {
+    return null;
+  }
+  _removeChild(node) {
+    const index = this.childNodes.findIndex((it) => it.isSameNode(node));
+    if (index >= 0) {
+      this.childNodes.splice(index, 1);
+    } else {
+      throw new Error("DOMException: _removeChild(..) could not find child to remove");
+    }
+  }
 }
 
 function parse(text, baseLocation) {
@@ -2373,7 +2421,7 @@ class HtmlElement extends DOMNode {
       throw new Error(`The tag name provided ("${tagName}") is not a valid name`);
     }
     this.tagName = tagName ?? "#document";
-    this.parent = parent ?? null;
+    this._parent = null;
     this.attr = {};
     this.metaElement = meta ?? null;
     this.closed = closed;
@@ -2382,7 +2430,7 @@ class HtmlElement extends DOMNode {
     this.annotation = null;
     this._adapter = createAdapter(this);
     if (parent) {
-      parent.childNodes.push(this);
+      parent.append(this);
       let cur = parent;
       while (cur.parent) {
         this.depth++;
@@ -2606,6 +2654,9 @@ class HtmlElement extends DOMNode {
   get meta() {
     return this.metaElement;
   }
+  get parent() {
+    return this._parent;
+  }
   /**
    * Get current role for this element (explicit with `role` attribute or mapped
    * with implicit role).
@@ -2866,6 +2917,14 @@ class HtmlElement extends DOMNode {
     }
     return visit(this);
   }
+  /**
+   * @internal
+   */
+  _setParent(node) {
+    const oldParent = this._parent;
+    this._parent = node instanceof HtmlElement ? node : null;
+    return oldParent;
+  }
 }
 function isClosed(endToken, meta) {
   let closed = 0 /* Open */;
@@ -2890,20 +2949,22 @@ function dumpTree(root) {
     }
     return output;
   }
-  function writeNode(node, level, sibling) {
+  function writeNode(node, level, indent, sibling) {
+    const numSiblings = node.parent ? node.parent.childElements.length : 0;
+    const lastSibling = sibling === numSiblings - 1;
     if (node.parent) {
-      const indent = "  ".repeat(level - 1);
-      const l = node.childElements.length > 0 ? "\u252C" : "\u2500";
-      const b = sibling < node.parent.childElements.length - 1 ? "\u251C" : "\u2514";
-      lines.push(`${indent}${b}\u2500${l} ${node.tagName}${decoration(node)}`);
+      const b = lastSibling ? "\u2514" : "\u251C";
+      lines.push(`${indent}${b}\u2500\u2500 ${node.tagName}${decoration(node)}`);
     } else {
       lines.push("(root)");
     }
     node.childElements.forEach((child, index) => {
-      writeNode(child, level + 1, index);
+      const s = lastSibling ? " " : "\u2502";
+      const i = level > 0 ? `${indent}${s}   ` : "";
+      writeNode(child, level + 1, i, index);
     });
   }
-  writeNode(root, 0, 0);
+  writeNode(root, 0, "", 0);
   return lines;
 }
 
@@ -4998,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 {
@@ -5006,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) {
@@ -5031,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);
       }
     });
   }
@@ -7262,8 +7374,9 @@ Omitted end tags can be ambigious for humans to read and many editors have troub
       if (closed.closed !== NodeClosed.ImplicitClosed) {
         return;
       }
-      const closedByParent = closed.parent && closed.parent.tagName === by.tagName;
-      const closedByDocument = closedByParent && closed.parent.isRootElement();
+      const parent = closed.parent;
+      const closedByParent = parent && parent.tagName === by.tagName;
+      const closedByDocument = closedByParent && parent.isRootElement();
       const sameTag = closed.tagName === by.tagName;
       if (closedByDocument) {
         this.report(
@@ -11594,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) {
@@ -11613,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,
@@ -12895,7 +13012,7 @@ class HtmlValidate {
 }
 
 const name = "html-validate";
-const version = "8.25.0";
+const version = "8.25.1";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function definePlugin(plugin) {