npm - html-validate - Versions diffs - 10.13.0 → 10.14.0 - Mend

html-validate 10.13.0 → 10.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/dist/cjs/core.js +234 -31
package/dist/cjs/core.js.map +1 -1
package/dist/cjs/elements.js +76 -5
package/dist/cjs/elements.js.map +1 -1
package/dist/cjs/tsdoc-metadata.json +1 -1
package/dist/esm/core.js +234 -31
package/dist/esm/core.js.map +1 -1
package/dist/esm/elements.js +76 -5
package/dist/esm/elements.js.map +1 -1
package/dist/schema/elements.json +25 -1
package/dist/tsdoc-metadata.json +1 -1
package/dist/types/browser.d.ts +70 -0
package/dist/types/index.d.ts +70 -0
package/package.json +1 -1

package/dist/cjs/tsdoc-metadata.json CHANGED Viewed

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.58.2"
+      "packageVersion": "7.58.7"
     }
   ]
 }

package/dist/esm/core.js CHANGED Viewed

@@ -582,12 +582,40 @@ const patternProperties = {
 			},
 			implicitClosed: {
 				title: "List of elements which implicitly closes this element",
-				description: "Some elements are automatically closed when another start tag occurs",
+				description: "Some elements are automatically closed when another start tag occurs. Entries may be explicit tag names or @category strings (e.g. \"@flow\").",
 				type: "array",
 				items: {
 					type: "string"
 				}
 			},
+			implicitOpen: {
+				title: "Implicit-open rules for child elements",
+				description: "Describes intermediary elements (e.g. <head> or <body>) that should be implicitly opened when a child of a given category or tag is inserted directly under this element without a matching container being present.",
+				type: "array",
+				items: {
+					type: "object",
+					required: [
+						"for",
+						"open"
+					],
+					additionalProperties: false,
+					properties: {
+						"for": {
+							title: "Selector list",
+							description: "Tag names or @category strings (e.g. \"@flow\") that trigger the implicit open.",
+							type: "array",
+							items: {
+								type: "string"
+							}
+						},
+						open: {
+							title: "Element to open",
+							description: "Tag name of the element to implicitly open.",
+							type: "string"
+						}
+					}
+				}
+			},
 			optionalEnd: {
 				title: "Mark element as having an optional end tag",
 				description: "Elements whose end tag may be omitted per the HTML spec. Such an element is treated as implicitly closed at end-of-document and when a parent’s explicit end tag is encountered while it is still open.",
@@ -2083,6 +2111,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()) {
@@ -2205,24 +2253,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) {
@@ -2341,6 +2371,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) => {
@@ -2507,7 +2538,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.
@@ -2903,12 +2938,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;
   }
 }
@@ -12476,7 +12523,7 @@ class EventHandler {
 }
 const name = "html-validate";
-const version = "10.13.0";
+const version = "10.14.0";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 function freeze(src) {
@@ -12665,6 +12712,31 @@ class ParserError extends Error {
   }
 }
+function isStaticTrue(value) {
+  return value === true;
+}
+function matchesContentCategory(meta, category) {
+  switch (category) {
+    case "@meta":
+      return isStaticTrue(meta.metadata);
+    case "@flow":
+      return isStaticTrue(meta.flow);
+    case "@flow-not-meta":
+      return isStaticTrue(meta.flow) && !isStaticTrue(meta.metadata);
+    case "@sectioning":
+      return isStaticTrue(meta.sectioning);
+    case "@heading":
+      return isStaticTrue(meta.heading);
+    case "@phrasing":
+      return isStaticTrue(meta.phrasing);
+    case "@embedded":
+      return isStaticTrue(meta.embedded);
+    case "@interactive":
+      return isStaticTrue(meta.interactive);
+    default:
+      return false;
+  }
+}
 function isAttrValueToken(token) {
   return token?.type === TokenType.ATTR_VALUE;
 }
@@ -12751,23 +12823,128 @@ 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) {
-      return Boolean(implicitClosed?.includes(tagName));
+      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
+   * be implicitly opened before the incoming element is inserted under
+   * `parent`.
+   *
+   * If the parent's metadata defines an `implicitOpen` rule that matches the
+   * incoming element, a new `HtmlElement` for the intermediary is created and
+   * returned (with `parent` as its parent). The caller is responsible for
+   * pushing it onto the active stack and firing the relevant events.
+   *
+   * Returns `null` when no implicit open is required.
+   */
+  peekImplicitOpen(token, parent) {
+    if (!parent?.meta?.implicitOpen) {
+      return null;
+    }
+    const tagName = token.data[2];
+    const incomingMeta = this.metaTable.getMetaFor(tagName);
+    for (const entry of parent.meta.implicitOpen) {
+      const matches = entry.for.some((selector) => {
+        if (!selector.startsWith("@")) {
+          return selector === tagName;
+        }
+        return incomingMeta ? matchesContentCategory(incomingMeta, selector) : false;
+      });
+      if (matches) {
+        const intermediaryMeta = this.metaTable.getMetaFor(entry.open);
+        return HtmlElement.createElement(entry.open, token.location, {
+          closed: NodeClosed.Open,
+          meta: intermediaryMeta,
+          parent
+        });
+      }
     }
+    return null;
   }
   /**
    * @internal
@@ -12819,8 +12996,24 @@ class Parser {
       this.consumeUntil(tokenStream, TokenType.TAG_CLOSE, startToken.location)
     );
     const endToken = tokens.at(-1);
-    const closeOptional = this.closeOptional(startToken);
-    const parent = closeOptional ? this.dom.getActive().parent : this.dom.getActive();
+    const isStartTag = !startToken.data[1];
+    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(
       startToken,
       endToken,
@@ -12828,16 +13021,26 @@ class Parser {
       this.metaTable,
       this.currentNamespace
     );
-    const isStartTag = !startToken.data[1];
     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);
       this.dom.popActive();
     }
     if (isStartTag) {
+      if (implicitParent) {
+        this.dom.pushActive(implicitParent);
+        this.trigger("tag:start", {
+          target: implicitParent,
+          location: startToken.location
+        });
+        this.trigger("tag:ready", {
+          target: implicitParent,
+          location: startToken.location
+        });
+      }
       this.dom.pushActive(node);
       this.trigger("tag:start", {
         target: node,