@markuplint/rules 5.0.0-rc.2 → 5.0.0-rc.5

package/lib/no-unclosed-element-at-eof/index.js

@@ -0,0 +1,86 @@
+import { createRule } from '@markuplint/ml-core';
+import { isVoidElement } from '@markuplint/ml-spec';
+import meta from './meta.js';
+/**
+ * HTML LS "in body" insertion mode, "An end-of-file token":
+ *
+ * > If there is a node in the stack of open elements that is not either a dd
+ * > element, a dt element, an li element, an optgroup element, an option
+ * > element, a p element, an rb element, an rp element, an rt element, an
+ * > rtc element, a tbody element, a td element, a tfoot element, a th
+ * > element, a thead element, a tr element, the body element, or the html
+ * > element, then this is a parse error.
+ *
+ * Every name in that list has its own optional-tag-omission rule elsewhere in
+ * the spec, so parse5 never records an explicit end tag for it even in
+ * well-formed documents; excluding them keeps this rule from re-flagging
+ * markup that `end-tag` (a style preference, not this spec-conformance rule)
+ * already tolerates. Anything else still open when the source runs out —
+ * e.g. `<picture>`, which has no such omission rule — is this parse error.
+ *
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inbody
+ */
+const EOF_EXEMPT_NAMES = new Set([
+    'dd',
+    'dt',
+    'li',
+    'optgroup',
+    'option',
+    'p',
+    'rb',
+    'rp',
+    'rt',
+    'rtc',
+    'tbody',
+    'td',
+    'tfoot',
+    'th',
+    'thead',
+    'tr',
+    'body',
+    'html',
+]);
+/**
+ * The end offset of a node's own content, following the last descendant to
+ * its end when the node itself has no end tag. Elements without an explicit
+ * end tag only carry a start-tag span in `raw`/`startOffset`
+ * (`@markuplint/html-parser`'s `nodeize`), so their children's own closing
+ * position is the only way to find where the element's content actually
+ * ends in the source.
+ */
+function deepEndOffset(node) {
+    if (node.closeTag) {
+        return node.closeTag.startOffset + node.closeTag.raw.length;
+    }
+    const last = node.childNodes ? [...node.childNodes].at(-1) : undefined;
+    if (last) {
+        return deepEndOffset(last);
+    }
+    return node.startOffset + node.raw.length;
+}
+export default createRule({
+    meta: meta,
+    async verify({ document, report, t }) {
+        const eof = document.raw.length;
+        await document.walkOn('Element', el => {
+            if (el.isOmitted)
+                return;
+            if (isVoidElement(el))
+                return;
+            if (el.closeTag != null)
+                return;
+            if (EOF_EXEMPT_NAMES.has(el.localName))
+                return;
+            // Only the case where nothing but whitespace follows is the EOF
+            // case this rule targets — content implicitly closing the element
+            // mid-document (e.g. a sibling autoclosing it) is out of scope.
+            const contentEnd = deepEndOffset(el);
+            if (document.raw.slice(contentEnd, eof).trim() !== '')
+                return;
+            report({
+                scope: el,
+                message: t('{0} is not closed at the end of the file', t('the "{0}" {1}', el.localName, 'element')),
+            });
+        });
+    },
+});

package/lib/no-unclosed-element-at-eof/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "syntax";
+};
+export default _default;

package/lib/no-unclosed-element-at-eof/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'syntax',
+};

package/lib/no-unescaped-char/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Configuration options for the `no-unescaped-char` rule.
+ */
+type Option = {
+    /**
+     * When `true`, also flags `>`, `"`, and every bare `&` (not just a
+     * literal `<`). Off by default because HTML LS only prohibits `<` and
+     * ambiguous ampersands unescaped — `>` and `"` are conforming as-is, and
+     * a bare `&` not shaped like a reference attempt is not "ambiguous".
+     */
+    strict?: boolean;
+};
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Option>>;
+export default _default;

package/lib/{character-reference → no-unescaped-char}/index.js

@@ -1,26 +1,29 @@
 import { createRule, getLocationFromChars } from '@markuplint/ml-core';
 import meta from './meta.js';
 /**
- * Characters that must be escaped using character references in HTML text
- * and attribute values.
+ * HTML LS §13.1.2.3–4 prohibits exactly two things unescaped in text content
+ * and attribute values: a literal `<`, and an "ambiguous ampersand" (`&`
+ * followed by ASCII alphanumerics and a `;` that don't form a recognized
+ * named/numeric reference). Detecting the latter precisely requires
+ * validating the name against the full named-character-reference table —
+ * work parse5's tokenizer already does, surfaced as `no-malformed-character-reference`
+ * (`unknown-named-character-reference` and friends). So by default this rule
+ * only checks `<`; `strict` restores the pre-split behavior of also flagging
+ * `>`, `"`, and every bare `&` (entity-shaped sequences still exempted, so
+ * `&amp;` is never flagged even in strict mode).
  */
-const defaultChars = ['"', '&', '<', '>'];
+/** Characters that must always be escaped, regardless of `strict`. */
+const defaultChars = ['<'];
+/** Characters `strict: true` additionally requires to be escaped. */
+const strictChars = ['"', '&', '<', '>'];
 /**
  * Parent elements whose text content is exempt from character reference checks
  * because their content is not parsed as HTML.
  */
 const ignoreParentElement = new Set(['script', 'style']);
-/**
- * Rule that checks whether special characters are properly escaped as
- * character references.
- *
- * Scans text nodes and attribute values for the characters `"`, `&`, `<`,
- * and `>` that are not already part of a valid character reference. Text
- * inside `<script>` and `<style>` elements is excluded, as are bogus
- * text nodes (e.g., orphaned end tags).
- */
 export default createRule({
     meta: meta,
+    defaultOptions: {},
     async verify({ document, report, t }) {
         const targetNodes = [];
         await document.walkOn('Text', node => {
@@ -50,21 +53,29 @@ export default createRule({
                     continue;
                 }
                 const valueNode = attr.valueNode;
+                if (!valueNode) {
+                    continue;
+                }
                 targetNodes.push({
                     scope: node,
-                    line: valueNode?.startLine,
-                    col: valueNode?.startCol,
-                    raw: valueNode?.raw,
+                    line: valueNode.startLine,
+                    col: valueNode.startCol,
+                    raw: valueNode.raw,
                     message,
                 });
             }
         });
         for (const targetNode of targetNodes) {
-            if (!('scope' in targetNode && 'line' in targetNode && targetNode.line != null)) {
-                continue;
-            }
-            const escapedText = targetNode.raw.replaceAll(/&(?:[a-z]+|#\d+|#x[\da-f]+);/gi, $0 => '*'.repeat($0.length));
-            for (const location of getLocationFromChars(defaultChars, escapedText, targetNode.line, targetNode.col)) {
+            const strict = targetNode.scope.rule.options?.strict ?? false;
+            const chars = strict ? strictChars : defaultChars;
+            // Entity-shaped sequences (`&name;`, `&#123;`, `&#x1A;`) are never
+            // flagged, valid name or not — an unrecognized name is
+            // `no-malformed-character-reference`'s concern (it mirrors parse5's
+            // `unknown-named-character-reference`), not this rule's.
+            const escapedText = strict
+                ? targetNode.raw.replaceAll(/&(?:[a-z]+|#\d+|#x[\da-f]+);/gi, $0 => '*'.repeat($0.length))
+                : targetNode.raw;
+            for (const location of getLocationFromChars(chars, escapedText, targetNode.line, targetNode.col)) {
                 report({
                     scope: targetNode.scope,
                     message: targetNode.message,

package/lib/no-unescaped-char/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "syntax";
+};
+export default _default;

package/lib/no-unescaped-char/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'syntax',
+};

package/lib/{invalid-attr → no-unknown-attr}/index.d.ts

@@ -1,22 +1,17 @@
 import type { AttributeType } from '@markuplint/ml-spec';
 import type { Pattern } from '@markuplint/types';
 /**
- * Configuration options for the `invalid-attr` rule.
+ * Configuration options for the `no-unknown-attr` rule.
  */
 type Option = {
     /**
-     * Attributes to allow beyond what the spec permits.
-     * Can override spec-level restrictions such as `noUse`.
+     * Attribute names to treat as known, beyond what the spec defines.
+     * The value type is used by `no-invalid-attr-value` to validate the
+     * attribute's value; here it only determines whether the name is known.
      *
      * @since 3.7.0
      */
     allowAttrs?: (string | Attr)[] | Record<string, AttributeType | Pattern>;
-    /**
-     * Attributes to disallow in addition to spec restrictions.
-     *
-     * @since 3.7.0
-     */
-    disallowAttrs?: (string | Attr)[] | Record<string, AttributeType | Pattern>;
     /** Attribute name prefix(es) to ignore during validation. */
     ignoreAttrNamePrefix?: string | string[];
     /** Whether to allow additional properties for pretender elements (defaults to `true`). */
@@ -31,15 +26,5 @@ type Attr = {
     /** The expected attribute value type or validation rule. */
     value: AttributeType | Pattern;
 };
-/**
- * Rule that validates attributes against the HTML spec, allowed lists,
- * and disallowed lists.
- *
- * Checks each attribute for: existence in the spec, correct value type,
- * allowed/disallowed overrides from configuration, and typo suggestions
- * via candidate matching. Supports `allowAttrs` and `disallowAttrs`.
- * Non-existent attributes on elements that allow additional properties
- * (pretenders) can be optionally permitted.
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Option>>;
 export default _default;

package/lib/no-unknown-attr/index.js

@@ -0,0 +1,91 @@
+import { createRule, getAttrSpecs, getSpec } from '@markuplint/ml-core';
+import { resolveAttrEligibility, suggestionSuffix } from '../attr-eligibility.js';
+import meta from './meta.js';
+function allowedNames(allowAttrs) {
+    if (!allowAttrs) {
+        return new Set();
+    }
+    if (Array.isArray(allowAttrs)) {
+        return new Set(allowAttrs.map(a => (typeof a === 'string' ? a : a.name)));
+    }
+    return new Set(Object.keys(allowAttrs));
+}
+export default createRule({
+    meta: meta,
+    defaultOptions: {},
+    async verify({ document, report, t }) {
+        await document.walkOn('Attr', attr => {
+            if (attr.isDirective) {
+                return;
+            }
+            const allowToAddPropertiesForPretender = attr.rule.options.allowToAddPropertiesForPretender ?? true;
+            const name = attr.name;
+            const attrName = attr.nameNode;
+            // A parser-supplied IDL naming suggestion (e.g. `tabindex` -> `tabIndex`
+            // in JSX) takes priority over spec-driven typo detection below.
+            if (attr.ownerElement.elementType === 'html' && attr.candidate) {
+                report({
+                    scope: attr,
+                    line: attrName?.startLine,
+                    col: attrName?.startCol,
+                    raw: attrName?.raw,
+                    message: t('{0} is {1:c}', t('the "{0*}" {1}', name, 'attribute'), 'disallowed') +
+                        t('. ') +
+                        t('Did you mean "{0}"?', attr.candidate),
+                });
+                return;
+            }
+            if (attr.rule.options.ignoreAttrNamePrefix != null) {
+                const prefixes = Array.isArray(attr.rule.options.ignoreAttrNamePrefix)
+                    ? attr.rule.options.ignoreAttrNamePrefix
+                    : [attr.rule.options.ignoreAttrNamePrefix];
+                if (prefixes.some(prefix => name.indexOf(prefix) === 0)) {
+                    return;
+                }
+            }
+            if (allowedNames(attr.rule.options.allowAttrs).has(name)) {
+                return;
+            }
+            if (attr.ownerElement.elementType !== 'html') {
+                return;
+            }
+            const attrSpecs = getAttrSpecs(attr.ownerElement, document.specs);
+            if (!attrSpecs) {
+                return;
+            }
+            const eligibility = resolveAttrEligibility(name, attr.ownerElement, attrSpecs);
+            let message;
+            switch (eligibility.status) {
+                case 'unknown': {
+                    message =
+                        t('{0} is {1:c}', t('the "{0*}" {1}', name, 'attribute'), 'disallowed') +
+                            suggestionSuffix(t, eligibility.candidate);
+                    break;
+                }
+                case 'case-mismatch': {
+                    message =
+                        t('{0} is {1:c}', t('the "{0*}" {1}', name, 'attribute'), 'disallowed') +
+                            suggestionSuffix(t, eligibility.expectedName);
+                    break;
+                }
+                default: {
+                    return;
+                }
+            }
+            if (allowToAddPropertiesForPretender && attr.ownerElement.pretenderContext?.type === 'origin') {
+                return;
+            }
+            const spec = getSpec(attr.ownerElement, document.specs.specs);
+            if (spec?.possibleToAddProperties) {
+                return;
+            }
+            report({
+                scope: attr,
+                message,
+                line: attrName?.startLine,
+                col: attrName?.startCol,
+                raw: attrName?.raw,
+            });
+        });
+    },
+});

package/lib/no-unknown-attr/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "attributes";
+};
+export default _default;

package/lib/no-unknown-attr/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'attributes',
+};

package/lib/no-unknown-role/index.d.ts

@@ -0,0 +1,3 @@
+import type { Options } from '../wai-aria/types.js';
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/{wai-aria-non-existent-role → no-unknown-role}/index.js

@@ -2,7 +2,6 @@ import { createRule, getSpec } from '@markuplint/ml-core';
 import { checkingNonExistentRole } from '../wai-aria/checkings/non-existent-role.js';
 import { defaultOptions } from '../wai-aria/default-options.js';
 import meta from './meta.js';
-/** Warns when a role attribute value does not exist in the WAI-ARIA specification. */
 export default createRule({
     meta,
     defaultOptions,

package/lib/no-unknown-role/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "a11y";
+};
+export default _default;

package/lib/no-unknown-role/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'a11y',
+};

package/lib/no-unpaired-srcset-sizes/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * HTML LS § img/source `srcset` attributes: `sizes` and a width-descriptor
+ * `srcset` are mutually required. Split out of the former
+ * `srcset-sizes-constraint` rule's Checks 1 and 5, the two directions of this
+ * one constraint.
+ *
+ * `<source>`'s direction (Check 5) is conditional: `sizes` "may" be omitted
+ * when the following sibling `<img>` has `loading="lazy"` (auto-sizes
+ * support). `<img>`'s direction (Check 1) has no such escape.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+export default _default;

package/lib/no-unpaired-srcset-sizes/index.js

@@ -0,0 +1,77 @@
+import { createRule } from '@markuplint/ml-core';
+import { parseSrcset } from '../srcset-sizes-constraint/parse-srcset.js';
+import { findFollowingImg } from '../srcset-sizes-constraint/sibling-helpers.js';
+import meta from './meta.js';
+/**
+ * HTML LS § img/source `srcset` attributes: `sizes` and a width-descriptor
+ * `srcset` are mutually required. Split out of the former
+ * `srcset-sizes-constraint` rule's Checks 1 and 5, the two directions of this
+ * one constraint.
+ *
+ * `<source>`'s direction (Check 5) is conditional: `sizes` "may" be omitted
+ * when the following sibling `<img>` has `loading="lazy"` (auto-sizes
+ * support). `<img>`'s direction (Check 1) has no such escape.
+ */
+export default createRule({
+    meta,
+    async verify({ document, report }) {
+        await document.walkOn('Element', el => {
+            const localName = el.localName;
+            // Only check img and source (inside picture) elements
+            if (localName !== 'img' && localName !== 'source') {
+                return;
+            }
+            // source is only relevant inside <picture>
+            if (localName === 'source' && el.parentElement?.localName !== 'picture') {
+                return;
+            }
+            // Skip if element has spread attributes (dynamic props)
+            if (el.hasSpreadAttr) {
+                return;
+            }
+            const srcsetAttr = el.getAttributeNode('srcset');
+            if (!srcsetAttr) {
+                return;
+            }
+            const srcsetIsDynamic = srcsetAttr.isDynamicValue;
+            const sizesAttr = el.getAttributeNode('sizes');
+            const sizesIsDynamic = sizesAttr?.isDynamicValue;
+            // Parse srcset unless dynamic
+            const parsed = srcsetIsDynamic ? null : parseSrcset(srcsetAttr.value);
+            // sizes present → srcset must use width descriptors
+            if (sizesAttr && !sizesIsDynamic && parsed && !parsed.hasWidth) {
+                report({
+                    scope: el,
+                    line: srcsetAttr.valueNode?.startLine,
+                    col: srcsetAttr.valueNode?.startCol,
+                    raw: srcsetAttr.valueNode?.raw,
+                    message: 'The "srcset" attribute requires width descriptors when the "sizes" attribute is present',
+                });
+            }
+            // img / source-in-picture with w descriptors → sizes required.
+            //
+            // HTML LS § img srcset: unconditional — "the sizes attribute must
+            // also be present" when any candidate uses a width descriptor.
+            //
+            // HTML LS § source: conditional — sizes "may" be present with w
+            // descriptors, but the following sibling img must support
+            // auto-sizes for it to be omittable. img supports auto-sizes when
+            // loading=lazy (the dimensionsAttribute condition is also part of
+            // the spec but the lazy attribute is the user-facing trigger).
+            if (parsed && parsed.hasWidth && !sizesAttr) {
+                // For `<source>`, `findFollowingImg` may return null (malformed
+                // <picture> with no img). Optional chaining short-circuits to
+                // undefined, and `undefined === 'lazy'` is false → sizes is
+                // required. That's the correct fail-closed behaviour: an absent
+                // img cannot supply auto-sizes for the source.
+                const siblingImgLazy = localName === 'source' && findFollowingImg(el)?.getAttribute('loading') === 'lazy';
+                if (!siblingImgLazy) {
+                    report({
+                        scope: el,
+                        message: 'The "sizes" attribute is required when the "srcset" attribute uses width descriptors',
+                    });
+                }
+            }
+        });
+    },
+});

package/lib/no-unpaired-srcset-sizes/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "attributes";
+};
+export default _default;

package/lib/no-unpaired-srcset-sizes/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'attributes',
+};

package/lib/{no-unsupported-features → no-unsupported-browser-features}/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * Options for the `no-unsupported-features` rule.
+ * Options for the `no-unsupported-browser-features` rule.
  */
 type Options = {
     /** A browserslist query to override project configuration. */
@@ -10,15 +10,6 @@ type Options = {
     readonly browserslistEnv?: string;
     /** Features to ignore. Element name ("dialog") or attribute pattern ("input[list]"). */
     readonly ignoreFeatures?: readonly string[];
-    /** Whether to warn about experimental elements and attributes. */
-    readonly checkExperimental?: boolean;
-    /** Whether to warn about non-standard elements and attributes. */
-    readonly checkNonStandard?: boolean;
 };
-/**
- * Rule that warns when using HTML elements or attributes that are not
- * supported by the project's target browsers (via browserslist),
- * or that are experimental/non-standard.
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
 export default _default;

package/lib/no-unsupported-browser-features/index.js

@@ -0,0 +1,81 @@
+import { createRule } from '@markuplint/ml-core';
+import { checkAttributeSupport, checkElementSupport } from './compat-data.js';
+import meta from './meta.js';
+import { clearBrowserslistCache, resolveTargetBrowsers } from './resolve-browsers.js';
+export default createRule({
+    meta: meta,
+    defaultSeverity: 'warning',
+    defaultOptions: {},
+    async verify({ document, report, t }) {
+        const options = document.rule.options;
+        const targetBrowsers = resolveTargetBrowsers(document.filename, {
+            browserslist: options.browserslist,
+            browserslistConfig: options.browserslistConfig,
+            browserslistEnv: options.browserslistEnv,
+        });
+        // Without a browserslist configuration, there is nothing to check against.
+        if (targetBrowsers == null || targetBrowsers.length === 0) {
+            return;
+        }
+        const ignoreFeatures = new Set(options.ignoreFeatures);
+        await document.walkOn('Element', async (el) => {
+            // Web components and authored elements (JSX/Vue/Svelte) reach this rule
+            // via `pretenders`: they masquerade as a known HTML element on `el.localName`,
+            // so BCD lookups below resolve correctly. See #3740.
+            if (el.namespaceURI !== 'http://www.w3.org/1999/xhtml' ||
+                (el.elementType !== 'html' && el.pretenderContext?.type !== 'pretender')) {
+                return;
+            }
+            const elName = el.localName;
+            const elOptions = el.rule.options;
+            const elIgnoreFeatures = new Set(elOptions.ignoreFeatures ?? ignoreFeatures);
+            if (!elIgnoreFeatures.has(elName)) {
+                const unsupported = await checkElementSupport(elName, targetBrowsers);
+                if (unsupported.length > 0) {
+                    report({
+                        scope: el,
+                        message: formatUnsupportedMessage(t, elName, 'element', unsupported),
+                    });
+                }
+            }
+            for (const attr of el.attributes) {
+                if (attr.isDirective) {
+                    continue;
+                }
+                const attrName = attr.name;
+                const ignoreKey = `${elName}[${attrName}]`;
+                if (elIgnoreFeatures.has(ignoreKey)) {
+                    continue;
+                }
+                const unsupported = await checkAttributeSupport(elName, attrName, targetBrowsers);
+                if (unsupported.length > 0) {
+                    report({
+                        scope: attr,
+                        line: attr.nameNode?.startLine,
+                        col: attr.nameNode?.startCol,
+                        raw: attr.nameNode?.raw,
+                        message: formatUnsupportedMessage(t, attrName, 'attribute', unsupported),
+                    });
+                }
+            }
+        });
+        clearBrowserslistCache();
+    },
+});
+/**
+ * Format an unsupported feature message listing affected browsers.
+ */
+function formatUnsupportedMessage(t, featureName, featureType, unsupported) {
+    const browserDetails = unsupported
+        .map(u => {
+        if (u.addedVersion === false) {
+            if (u.removedVersion) {
+                return `${u.displayName} (removed in ${u.removedVersion})`;
+            }
+            return `${u.displayName} (not supported)`;
+        }
+        return `${u.displayName} (added in ${u.addedVersion}, target: ${u.targetVersion})`;
+    })
+        .join(', ');
+    return t('{0} is not supported in {1}', t('the "{0*}" {1}', featureName, featureType), browserDetails);
+}

package/lib/no-unsupported-browser-features/meta.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly category: "compat";
+};
+export default _default;

package/lib/no-unsupported-browser-features/meta.js

@@ -0,0 +1,3 @@
+export default {
+    category: 'compat',
+};

package/lib/permitted-contents/index.d.ts

@@ -1,21 +1,3 @@
 import type { Options, TagRule } from './types.js';
-/**
- * The `permitted-contents` rule validates that each element's child nodes conform
- * to the HTML content model specification. It is the most complex rule in markuplint,
- * implementing a full content model validation engine that handles ordered sequences,
- * quantified patterns (require, optional, oneOrMore, zeroOrMore), choice alternations,
- * transparent content models, and conditional child node branches.
- *
- * For each element, it resolves the applicable content model (from the HTML spec or
- * user-defined tag rules), evaluates the element's children against that model, and
- * reports violations such as unexpected elements, missing required elements, or
- * disallowed content through transparent models. It also checks forbidden ancestor
- * constraints — elements like `<header>`, `<footer>`, `<main>`, and `<address>` must
- * not appear as descendants of certain other elements as defined by the HTML spec.
- * Additionally, it enforces required ancestor constraints (`descendantOf`) — certain
- * elements must appear as descendants of specific other elements. It also validates
- * sibling-unique attribute constraints (`uniqueAttrs`) — certain attributes must not
- * appear on more than one element of the same type within the same parent.
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<TagRule[], Options>>;
 export default _default;