html-validate 10.13.1 → 10.14.0

package/dist/cjs/core.js

@@ -2120,6 +2120,26 @@ class Compound {
   }
 }
 
+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* ancestors$1(element) {
   let current = element.parent;
   while (current && !current.isRootElement()) {
@@ -2242,24 +2262,6 @@ function unescapeCodepoint(value) {
     (_, 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) {
@@ -2378,6 +2380,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 +2547,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.
@@ -2940,12 +2947,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;
   }
 }
@@ -12513,7 +12532,7 @@ class EventHandler {
 }
 
 const name = "html-validate";
-const version = "10.13.1";
+const version = "10.14.0";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 
 function freeze(src) {
@@ -12813,32 +12832,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 +13006,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 +13032,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);