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/schema/elements.json CHANGED Viewed

@@ -85,11 +85,35 @@
         "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.",

package/dist/tsdoc-metadata.json CHANGED Viewed

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

package/dist/types/browser.d.ts CHANGED Viewed

@@ -979,6 +979,9 @@ export declare class HtmlElement extends DOMNode {
     /* Excluded from this release type: someChildren */
     /* Excluded from this release type: everyChildren */
     /* Excluded from this release type: find */
+    append(node: DOMNode): void;
+    insertBefore(node: DOMNode, reference: DOMNode | null): void;
+    removeChild<T extends DOMNode>(node: T): T;
     /* Excluded from this release type: _setParent */
 }
@@ -1334,6 +1337,25 @@ export declare class HtmlValidate {
     flushConfigCache(filename?: string): void;
 }
+/**
+ * Describes a single implicit-open rule for a parent element.
+ *
+ * When a child element matching one of the `for` selectors would be inserted
+ * directly under the parent but is not permitted there, the element named by
+ * `open` is implicitly opened first, making it the new insertion point.
+ *
+ * Selectors may be explicit tag names (e.g., `title`) or content-category
+ * shorthand strings prefixed with `@` (e.g., `@meta`, `@flow`).
+ *
+ * @public
+ */
+export declare interface ImplicitOpenEntry {
+    /** Tags or `@category` selectors that trigger the implicit open. */
+    for: string[];
+    /** Tag name of the element to implicitly open. */
+    open: string;
+}
 /**
  * @public
  */
@@ -1576,6 +1598,17 @@ export declare interface MetaData {
      *   still open (e.g. `</html>` implicitly closing an open `<body>`).
      */
     optionalEnd?: boolean;
+    /**
+     * Describes elements that should be implicitly opened when a child element
+     * that would otherwise be inserted directly under this element matches one of
+     * the given selectors but is not permitted here.
+     *
+     * This handles the HTML5 optional start-tag algorithm for `<head>` and
+     * `<body>`: when a metadata element arrives directly under `<html>`, the
+     * parser implicitly opens `<head>`; when a flow element arrives, it implicitly
+     * opens `<body>` (first closing any open `<head>`).
+     */
+    implicitOpen?: ImplicitOpenEntry[];
     scriptSupporting?: boolean;
     /** Mark element as able to receive focus (without explicit `tabindex`) */
     focusable?: boolean | MetaFocusableCallback;
@@ -1887,7 +1920,44 @@ export declare 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.
+     */
+    private wouldCloseElement;
+    /**
+     * 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`.
+     */
+    private getParentAfterImplicitClose;
     private closeOptional;
+    /**
+     * 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.
+     */
+    private canOmitEndTag;
+    /**
+     * 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>`.
+     */
+    private closeOptionalEndTag;
+    /**
+     * 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.
+     */
+    private peekImplicitOpen;
     /* Excluded from this release type: consume */
     /* Excluded from this release type: consumeTag */
     /* Excluded from this release type: closeElement */

package/dist/types/index.d.ts CHANGED Viewed

@@ -1215,6 +1215,9 @@ export declare class HtmlElement extends DOMNode {
     /* Excluded from this release type: someChildren */
     /* Excluded from this release type: everyChildren */
     /* Excluded from this release type: find */
+    append(node: DOMNode): void;
+    insertBefore(node: DOMNode, reference: DOMNode | null): void;
+    removeChild<T extends DOMNode>(node: T): T;
     /* Excluded from this release type: _setParent */
 }
@@ -1570,6 +1573,25 @@ export declare class HtmlValidate {
     flushConfigCache(filename?: string): void;
 }
+/**
+ * Describes a single implicit-open rule for a parent element.
+ *
+ * When a child element matching one of the `for` selectors would be inserted
+ * directly under the parent but is not permitted there, the element named by
+ * `open` is implicitly opened first, making it the new insertion point.
+ *
+ * Selectors may be explicit tag names (e.g., `title`) or content-category
+ * shorthand strings prefixed with `@` (e.g., `@meta`, `@flow`).
+ *
+ * @public
+ */
+export declare interface ImplicitOpenEntry {
+    /** Tags or `@category` selectors that trigger the implicit open. */
+    for: string[];
+    /** Tag name of the element to implicitly open. */
+    open: string;
+}
 /**
  * @public
  */
@@ -1819,6 +1841,17 @@ export declare interface MetaData {
      *   still open (e.g. `</html>` implicitly closing an open `<body>`).
      */
     optionalEnd?: boolean;
+    /**
+     * Describes elements that should be implicitly opened when a child element
+     * that would otherwise be inserted directly under this element matches one of
+     * the given selectors but is not permitted here.
+     *
+     * This handles the HTML5 optional start-tag algorithm for `<head>` and
+     * `<body>`: when a metadata element arrives directly under `<html>`, the
+     * parser implicitly opens `<head>`; when a flow element arrives, it implicitly
+     * opens `<body>` (first closing any open `<head>`).
+     */
+    implicitOpen?: ImplicitOpenEntry[];
     scriptSupporting?: boolean;
     /** Mark element as able to receive focus (without explicit `tabindex`) */
     focusable?: boolean | MetaFocusableCallback;
@@ -2155,7 +2188,44 @@ export declare 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.
+     */
+    private wouldCloseElement;
+    /**
+     * 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`.
+     */
+    private getParentAfterImplicitClose;
     private closeOptional;
+    /**
+     * 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.
+     */
+    private canOmitEndTag;
+    /**
+     * 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>`.
+     */
+    private closeOptionalEndTag;
+    /**
+     * 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.
+     */
+    private peekImplicitOpen;
     /* Excluded from this release type: consume */
     /* Excluded from this release type: consumeTag */
     /* Excluded from this release type: closeElement */

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "html-validate",
-  "version": "10.13.0",
+  "version": "10.14.0",
   "description": "Offline HTML5 validator and linter",
   "keywords": [
     "html",