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

html-validate 10.13.0 → 10.13.1

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 (12) hide show

package/dist/cjs/core.js +116 -5
package/dist/cjs/core.js.map +1 -1
package/dist/cjs/elements.js +5 -1
package/dist/cjs/elements.js.map +1 -1
package/dist/esm/core.js +116 -5
package/dist/esm/core.js.map +1 -1
package/dist/esm/elements.js +5 -1
package/dist/esm/elements.js.map +1 -1
package/dist/schema/elements.json +25 -1
package/dist/types/browser.d.ts +43 -0
package/dist/types/index.d.ts +43 -0
package/package.json +1 -1

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.",
@@ -12476,7 +12504,7 @@ class EventHandler {
 }
 const name = "html-validate";
-const version = "10.13.0";
+const version = "10.13.1";
 const bugs = "https://gitlab.com/html-validate/html-validate/issues/new";
 function freeze(src) {
@@ -12665,6 +12693,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;
 }
@@ -12760,7 +12813,16 @@ class Parser {
     const open = !token.data[1];
     const implicitClosed = active.meta.implicitClosed;
     if (open) {
-      return Boolean(implicitClosed?.includes(tagName));
+      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;
+      });
     } else {
       if (active.is(tagName)) {
         return false;
@@ -12769,6 +12831,42 @@ class Parser {
       return Boolean(active.parent && active.parent.is(tagName) && canOmitEnd);
     }
   }
+  /**
+   * 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 +12917,11 @@ class Parser {
       this.consumeUntil(tokenStream, TokenType.TAG_CLOSE, startToken.location)
     );
     const endToken = tokens.at(-1);
+    const isStartTag = !startToken.data[1];
     const closeOptional = this.closeOptional(startToken);
-    const parent = closeOptional ? this.dom.getActive().parent : this.dom.getActive();
+    const baseParent = closeOptional ? this.dom.getActive().parent : this.dom.getActive();
+    const implicitParent = isStartTag ? this.peekImplicitOpen(startToken, baseParent) : null;
+    const parent = implicitParent ?? baseParent;
     const node = HtmlElement.fromTokens(
       startToken,
       endToken,
@@ -12828,7 +12929,6 @@ 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) {
@@ -12838,6 +12938,17 @@ class Parser {
       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,