@markuplint/rules 4.11.2 → 5.0.0-alpha.0

package/lib/require-accessible-name/index.js

@@ -2,28 +2,36 @@ import { createRule, getRoleSpec, getComputedRole } from '@markuplint/ml-core';
 import { ARIA_RECOMMENDED_VERSION, isExposed } from '@markuplint/ml-spec';
 import { accnameMayBeMutable } from '../helpers.js';
 import meta from './meta.js';
+/**
+ * Rule that requires elements with roles that need accessible names to have one.
+ *
+ * For each element exposed to the accessibility tree whose computed ARIA role
+ * has `accessibleNameRequired` set to `true`, this rule verifies that the element
+ * provides a non-empty accessible name.
+ */
 export default createRule({
     meta: meta,
     defaultOptions: {
-        ariaVersion: ARIA_RECOMMENDED_VERSION,
+        ariaVersion: undefined,
     },
     async verify({ document, report, t }) {
         await document.walkOn('Element', el => {
+            const ariaVersion = el.rule.options?.ariaVersion ?? document.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;
             if (accnameMayBeMutable(el, document)) {
                 return;
             }
-            if (!isExposed(el, document.specs, el.rule.options.ariaVersion)) {
+            if (!isExposed(el, document.specs, ariaVersion)) {
                 return;
             }
-            const computed = getComputedRole(document.specs, el, el.rule.options.ariaVersion);
+            const computed = getComputedRole(document.specs, el, ariaVersion);
             if (!computed.role) {
                 return;
             }
-            const roleSpec = getRoleSpec(document.specs, computed.role.name, el.namespaceURI, el.rule.options.ariaVersion);
+            const roleSpec = getRoleSpec(document.specs, computed.role.name, el.namespaceURI, ariaVersion);
             if (!roleSpec || !roleSpec.accessibleNameRequired) {
                 return;
             }
-            const hasAccessibleName = !!el.getAccessibleName(el.rule.options.ariaVersion).trim();
+            const hasAccessibleName = !!el.getAccessibleName(ariaVersion).trim();
             if (!hasAccessibleName) {
                 report({ scope: el, message: t('Require {0}', 'accessible name') });
             }

package/lib/require-accessible-name/meta.d.ts

@@ -1,3 +1,4 @@
+/** Rule metadata for the `require-accessible-name` rule, categorized as accessibility. */
 declare const _default: {
     readonly category: "a11y";
 };

package/lib/require-accessible-name/meta.js

@@ -1,3 +1,4 @@
+/** Rule metadata for the `require-accessible-name` rule, categorized as accessibility. */
 export default {
     category: 'a11y',
 };

package/lib/require-datetime/index.d.ts

@@ -1,6 +1,18 @@
 import type { Lang } from './types.js';
+/**
+ * Configuration options for the require-datetime rule.
+ */
 type Options = {
+    /** Languages to use when parsing natural language date/time text content. */
     langs?: Lang[];
 };
+/**
+ * Rule that validates `<time>` elements without a `datetime` attribute have
+ * machine-readable date/time content.
+ *
+ * When a `<time>` element lacks the `datetime` attribute, this rule checks
+ * whether the text content is a valid datetime string. If not, it attempts
+ * to parse the content as natural language and suggests a `datetime` value.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
 export default _default;

package/lib/require-datetime/index.js

@@ -2,6 +2,14 @@ import { createRule } from '@markuplint/ml-core';
 import { check } from '@markuplint/types';
 import meta from './meta.js';
 import { getCandidateDatetimeString } from './utils.js';
+/**
+ * Rule that validates `<time>` elements without a `datetime` attribute have
+ * machine-readable date/time content.
+ *
+ * When a `<time>` element lacks the `datetime` attribute, this rule checks
+ * whether the text content is a valid datetime string. If not, it attempts
+ * to parse the content as natural language and suggests a `datetime` value.
+ */
 export default createRule({
     meta: meta,
     defaultOptions: {

package/lib/require-datetime/meta.d.ts

@@ -1,3 +1,4 @@
+/** Rule metadata for the `require-datetime` rule, categorized as validation. */
 declare const _default: {
     readonly category: "validation";
 };

package/lib/require-datetime/meta.js

@@ -1,3 +1,4 @@
+/** Rule metadata for the `require-datetime` rule, categorized as validation. */
 export default {
     category: 'validation',
 };

package/lib/require-datetime/types.d.ts

@@ -1,10 +1,17 @@
+/** Union of possible date/time component keys used in parsed datetime data. */
 export type DateTimeKey = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'ms';
+/** A partial record mapping date/time component keys to their numeric values. */
 export type DateTimeData = Partial<Record<DateTimeKey, number>>;
+/** Represents a parsed date/time value with optional timezone offset. */
 export type DateTime = {
+    /** The parsed date/time component values. */
     datetime: DateTimeData;
+    /** Timezone offset in minutes from UTC (e.g., -300 for UTC-5). */
     zone?: number;
 };
 /**
+ * Supported locale codes for natural language date/time parsing.
+ *
  * @see https://github.com/wanasit/chrono#locales
  */
 export type Lang = 'en' | 'ja' | 'fr' | 'nl' | 'ru' | 'de' | 'pt' | 'zh';

package/lib/require-datetime/utils.d.ts

@@ -1,11 +1,24 @@
 import type { DateTime, Lang } from './types.js';
 /**
- * Datetime-ish text to a datetime data
+ * Parses natural language datetime text into structured datetime data.
  *
- * @param content
- * @param langs
- * @param base Reference date for a test
- * @returns
+ * Tries multiple locale parsers and returns the first successful parse result
+ * with only the certain (non-implied) date/time components included.
+ *
+ * @param content - The text content to parse as a datetime.
+ * @param langs - Locale codes to attempt parsing with.
+ * @param base - Optional reference date for relative date parsing (e.g., "tomorrow").
+ * @returns Parsed datetime data with timezone, or `null` if parsing fails.
  */
 export declare function parseADatetime(content: string, langs: readonly Lang[], base?: Readonly<Date>): DateTime | null;
+/**
+ * Generates an HTML `datetime` attribute value from natural language text.
+ *
+ * Parses the text content using chrono-node and formats the result as an
+ * ISO 8601-like datetime string suitable for the `datetime` attribute.
+ *
+ * @param content - The text content to parse.
+ * @param langs - Locale codes to use for parsing. Defaults to all supported languages.
+ * @returns A formatted datetime string, or `null` if the content cannot be parsed.
+ */
 export declare function getCandidateDatetimeString(content: string, langs?: Lang[]): string | null;

package/lib/require-datetime/utils.js

@@ -1,12 +1,16 @@
 import * as chrono from 'chrono-node';
+/** Default set of languages to try when parsing natural language datetime text. */
 const defaultLangs = ['en', 'ja', 'fr', 'nl', 'ru', 'de', 'pt', 'zh'];
 /**
- * Datetime-ish text to a datetime data
+ * Parses natural language datetime text into structured datetime data.
  *
- * @param content
- * @param langs
- * @param base Reference date for a test
- * @returns
+ * Tries multiple locale parsers and returns the first successful parse result
+ * with only the certain (non-implied) date/time components included.
+ *
+ * @param content - The text content to parse as a datetime.
+ * @param langs - Locale codes to attempt parsing with.
+ * @param base - Optional reference date for relative date parsing (e.g., "tomorrow").
+ * @returns Parsed datetime data with timezone, or `null` if parsing fails.
  */
 export function parseADatetime(content, langs, base) {
     const date = parseTryMultipleLangs(content, langs, base);
@@ -43,6 +47,16 @@ export function parseADatetime(content, langs, base) {
     }
     return datetime;
 }
+/**
+ * Generates an HTML `datetime` attribute value from natural language text.
+ *
+ * Parses the text content using chrono-node and formats the result as an
+ * ISO 8601-like datetime string suitable for the `datetime` attribute.
+ *
+ * @param content - The text content to parse.
+ * @param langs - Locale codes to use for parsing. Defaults to all supported languages.
+ * @returns A formatted datetime string, or `null` if the content cannot be parsed.
+ */
 export function getCandidateDatetimeString(content, langs = defaultLangs) {
     const date = parseADatetime(content, langs);
     if (!date) {
@@ -60,6 +74,15 @@ export function getCandidateDatetimeString(content, langs = defaultLangs) {
     }
     return datetimeStr;
 }
+/**
+ * Converts parsed datetime data into an ISO 8601-like string.
+ *
+ * Produces different formats depending on which components are present
+ * (e.g., date-only, time-only, or combined date-time).
+ *
+ * @param date - The parsed date/time component data.
+ * @returns A formatted datetime string, or `null` if the components do not match any known format.
+ */
 function toDatetimeString(date) {
     if (only(date, ['year', 'month'])) {
         return `${f(date.year, 4)}-${f(date.month, 2)}`;
@@ -90,6 +113,17 @@ function toDatetimeString(date) {
     }
     return null;
 }
+/**
+ * Attempts to parse datetime text using multiple locale parsers sequentially.
+ *
+ * Returns the parsed start component from the first locale that produces a
+ * valid result (non-range, single datetime).
+ *
+ * @param content - The text content to parse.
+ * @param langs - Locale codes to try in order.
+ * @param base - Optional reference date for relative date parsing.
+ * @returns The parsed start component, or `null` if no locale succeeds.
+ */
 function parseTryMultipleLangs(content, langs, base) {
     for (const lang of langs) {
         const results = 
@@ -111,6 +145,16 @@ function parseTryMultipleLangs(content, langs, base) {
     }
     return null;
 }
+/**
+ * Type guard that checks if the given datetime data contains only the specified keys.
+ *
+ * @template K - The array of datetime keys to check for.
+ * @template U - Union of the key types.
+ * @template R - The resulting narrowed type with required properties.
+ * @param date - The datetime data to check.
+ * @param keys - The keys that should be the only ones present.
+ * @returns `true` if the date contains only the specified keys (and narrows the type).
+ */
 function only(date, keys) {
     const list = Object.keys(date);
     for (const exists of list) {
@@ -121,11 +165,11 @@ function only(date, keys) {
     return true;
 }
 /**
- * Formatter
+ * Formats a number with zero-padding to the specified width.
  *
- * @param n
- * @param pad zero padding
- * @returns
+ * @param n - The number to format.
+ * @param pad - The minimum number of digits in the output string.
+ * @returns The zero-padded string representation.
  */
 function f(n, pad) {
     return n.toString(10).padStart(pad, '0');

package/lib/require-dialog-autofocus/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Rule that requires a `<dialog>` element referenced by a `show-modal` command
+ * to contain a descendant (or itself) with the `autofocus` attribute.
+ *
+ * Without `autofocus`, the browser's dialog focusing steps fall back to the
+ * `<dialog>` element itself, which is not ideal for accessibility — screen
+ * reader users may miss the dialog content, and keyboard users may need
+ * extra tab presses to reach interactive elements.
+ *
+ * Detection algorithm:
+ * 1. Find all `<button>` elements with both `command` and `commandfor` attributes
+ * 2. Filter to triggers whose `command` value is `show-modal` (case-insensitive)
+ * 3. Resolve the referenced `<dialog>` via `document.getElementById(commandfor)`
+ * 4. Skip non-dialog targets and already-reported dialogs (deduplication)
+ * 5. Report if neither the dialog nor any descendant has the `autofocus` attribute
+ *
+ * @see https://html.spec.whatwg.org/multipage/interactive-elements.html#dialog-focusing-steps
+ * @see https://html.spec.whatwg.org/multipage/interactive-elements.html#the-dialog-element
+ * @see https://www.w3.org/WAI/ARIA/apg/patterns/dialog-modal/
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+export default _default;

package/lib/require-dialog-autofocus/index.js

@@ -0,0 +1,62 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+/**
+ * Rule that requires a `<dialog>` element referenced by a `show-modal` command
+ * to contain a descendant (or itself) with the `autofocus` attribute.
+ *
+ * Without `autofocus`, the browser's dialog focusing steps fall back to the
+ * `<dialog>` element itself, which is not ideal for accessibility — screen
+ * reader users may miss the dialog content, and keyboard users may need
+ * extra tab presses to reach interactive elements.
+ *
+ * Detection algorithm:
+ * 1. Find all `<button>` elements with both `command` and `commandfor` attributes
+ * 2. Filter to triggers whose `command` value is `show-modal` (case-insensitive)
+ * 3. Resolve the referenced `<dialog>` via `document.getElementById(commandfor)`
+ * 4. Skip non-dialog targets and already-reported dialogs (deduplication)
+ * 5. Report if neither the dialog nor any descendant has the `autofocus` attribute
+ *
+ * @see https://html.spec.whatwg.org/multipage/interactive-elements.html#dialog-focusing-steps
+ * @see https://html.spec.whatwg.org/multipage/interactive-elements.html#the-dialog-element
+ * @see https://www.w3.org/WAI/ARIA/apg/patterns/dialog-modal/
+ */
+export default createRule({
+    defaultSeverity: 'warning',
+    meta: meta,
+    verify({ document, report, t }) {
+        const triggers = document.querySelectorAll('button[command][commandfor]');
+        const reportedDialogIds = new Set();
+        for (const trigger of triggers) {
+            const command = trigger.getAttribute('command');
+            if (!command || command.toLowerCase() !== 'show-modal') {
+                continue;
+            }
+            const targetId = trigger.getAttribute('commandfor');
+            if (!targetId) {
+                continue;
+            }
+            if (reportedDialogIds.has(targetId)) {
+                continue;
+            }
+            const target = document.getElementById(targetId);
+            if (!target) {
+                continue;
+            }
+            if (target.localName !== 'dialog') {
+                continue;
+            }
+            if (target.hasAttribute('autofocus')) {
+                continue;
+            }
+            const autofocusDescendants = target.querySelectorAll('[autofocus]');
+            if (autofocusDescendants.length > 0) {
+                continue;
+            }
+            reportedDialogIds.add(targetId);
+            report({
+                scope: target,
+                message: t('The "{0*}" element referenced by a "{1*}" command requires an element with the "{2*}" attribute', 'dialog', 'show-modal', 'autofocus'),
+            });
+        }
+    },
+});

package/lib/require-dialog-autofocus/meta.d.ts

@@ -0,0 +1,5 @@
+/** Rule metadata for the `require-dialog-autofocus` rule, categorized as accessibility. */
+declare const _default: {
+    readonly category: "a11y";
+};
+export default _default;

package/lib/require-dialog-autofocus/meta.js

@@ -0,0 +1,4 @@
+/** Rule metadata for the `require-dialog-autofocus` rule, categorized as accessibility. */
+export default {
+    category: 'a11y',
+};

package/lib/required-attr/index.d.ts

@@ -1,7 +1,27 @@
+/** The rule value: either a single attribute name or an array of required attribute descriptors. */
 type RequiredAttributes = string | (string | Attr)[];
+/**
+ * Descriptor for a required attribute with an optional set of allowed values.
+ */
 type Attr = {
+    /** The attribute name that is required. */
     name: string;
+    /** One or more allowed values for the attribute, if constrained. */
     value?: string | string[];
 };
-declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<RequiredAttributes, undefined>>;
+/**
+ * Configuration options for the `required-attr` rule.
+ */
+type Options = {
+    /** Attribute names to exclude from required-attribute checks. */
+    readonly ignoreAttrs?: readonly string[];
+};
+/**
+ * Rule that validates elements have all required attributes.
+ *
+ * Checks both HTML-spec-defined required attributes and custom required attributes
+ * specified in the rule configuration. Also validates that required attribute values
+ * match expected patterns when value constraints are provided.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<RequiredAttributes, Options>>;
 export default _default;

package/lib/required-attr/index.js

@@ -1,9 +1,17 @@
 import { createRule, getAttrSpecs } from '@markuplint/ml-core';
 import { attrMatches, match } from '../helpers.js';
 import meta from './meta.js';
+/**
+ * Rule that validates elements have all required attributes.
+ *
+ * Checks both HTML-spec-defined required attributes and custom required attributes
+ * specified in the rule configuration. Also validates that required attribute values
+ * match expected patterns when value constraints are provided.
+ */
 export default createRule({
     meta: meta,
     defaultValue: [],
+    defaultOptions: {},
     async verify({ document, report, t }) {
         await document.walkOn('Element', el => {
             if (el.hasSpreadAttr) {
@@ -11,6 +19,7 @@ export default createRule({
             }
             const customRequiredAttrs = typeof el.rule.value === 'string' ? [el.rule.value] : el.rule.value;
             const attrSpec = getAttrSpecs(el, document.specs);
+            const ignoreAttrs = new Set(el.rule.options.ignoreAttrs);
             const attributeSpecs = {};
             if (attrSpec && el.elementType === 'html') {
                 for (const spec of attrSpec) {
@@ -44,12 +53,33 @@ export default createRule({
                 };
             }
             for (const spec of Object.values(attributeSpecs)) {
+                if (ignoreAttrs.has(spec.name)) {
+                    if (spec.requiredEither) {
+                        const activeCandidates = spec.requiredEither.filter(n => !ignoreAttrs.has(n));
+                        if (activeCandidates.length > 0) {
+                            const invalid = !activeCandidates.some(attrName => el.hasAttribute(attrName));
+                            if (invalid) {
+                                const sortedCandidate = activeCandidates.toSorted();
+                                const expects = sortedCandidate.length === 1
+                                    ? t('the "{0*}" {1}', sortedCandidate[0], 'attribute')
+                                    : t('{0} {1}', sortedCandidate
+                                        .map(attrName => t('the "{0*}"', attrName))
+                                        // eslint-disable-next-line unicorn/no-array-reduce
+                                        .reduce((a, b) => t('{0} or {1}', a, b)), t('attribute'));
+                                const message = t('{0} expects {1}', t('the "{0*}" {1}', el.localName, 'element'), expects);
+                                report({ scope: el, message });
+                            }
+                        }
+                    }
+                    continue;
+                }
                 const didntHave = !el.hasAttribute(spec.name);
                 const candidate = [spec.name];
                 let invalid = false;
                 if (spec.requiredEither) {
                     candidate.push(...spec.requiredEither);
-                    invalid = !candidate.some(attrName => el.hasAttribute(attrName));
+                    const activeCandidates = candidate.filter(n => !ignoreAttrs.has(n));
+                    invalid = !activeCandidates.some(attrName => el.hasAttribute(attrName));
                 }
                 else if (spec.required === true) {
                     invalid = attrMatches(el, spec.condition) && didntHave;
@@ -58,11 +88,11 @@ export default createRule({
                     const selector = typeof spec.required === 'string' ? spec.required : spec.required.join(',');
                     invalid = el.matches(selector) && didntHave;
                 }
-                candidate.sort();
+                const sortedCandidate = candidate.filter(n => !ignoreAttrs.has(n)).toSorted();
                 if (invalid) {
-                    const expects = candidate.length === 1
+                    const expects = sortedCandidate.length === 1
                         ? t('the "{0*}" {1}', spec.name, 'attribute')
-                        : t('{0} {1}', candidate
+                        : t('{0} {1}', sortedCandidate
                             .map(attrName => t('the "{0*}"', attrName))
                             // eslint-disable-next-line unicorn/no-array-reduce
                             .reduce((a, b) => t('{0} or {1}', a, b)), t('attribute'));

package/lib/required-attr/meta.d.ts

@@ -1,3 +1,4 @@
+/** Rule metadata for the `required-attr` rule, categorized as validation. */
 declare const _default: {
     readonly category: "validation";
 };

package/lib/required-attr/meta.js

@@ -1,3 +1,4 @@
+/** Rule metadata for the `required-attr` rule, categorized as validation. */
 export default {
     category: 'validation',
 };

package/lib/required-element/index.d.ts

@@ -1,5 +1,19 @@
+/**
+ * Configuration options for the required-element rule.
+ */
 type Options = {
+    /** Whether to skip validation for elements that contain mutable (dynamic) content. */
     ignoreHasMutableContents: boolean;
+    /** Whether to ignore omitted (ghost) elements that are implicitly created by the HTML parser. */
+    ignoreOmittedElements: boolean;
 };
+/**
+ * Rule that validates required child elements are present.
+ *
+ * Accepts an array of CSS selectors as the rule value. For the document level,
+ * reports if any matching element is missing from the entire document. For
+ * element-level overrides, checks that the specified child elements exist
+ * among the element's direct children.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<string[], Options>>;
 export default _default;

package/lib/required-element/index.js

@@ -1,16 +1,28 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
+/**
+ * Rule that validates required child elements are present.
+ *
+ * Accepts an array of CSS selectors as the rule value. For the document level,
+ * reports if any matching element is missing from the entire document. For
+ * element-level overrides, checks that the specified child elements exist
+ * among the element's direct children.
+ */
 export default createRule({
     meta: meta,
     defaultValue: [],
     defaultOptions: {
         ignoreHasMutableContents: true,
+        ignoreOmittedElements: true,
     },
     async verify({ document, report, t }) {
         const hasMutableContent = document.nodeList.some(n => n.is(n.ELEMENT_NODE) && n.hasMutableChildren());
         if (!hasMutableContent) {
             for (const query of document.rule.value) {
-                const exists = document.querySelectorAll(query);
+                const matched = document.querySelectorAll(query);
+                const exists = document.rule.options.ignoreOmittedElements
+                    ? [...matched].filter(el => !el.isOmitted)
+                    : [...matched];
                 if (exists.length === 0) {
                     const message = t('Require {0}', t('the "{0*}" {1}', query, 'element'));
                     report({
@@ -30,7 +42,7 @@ export default createRule({
                 return;
             }
             for (const query of el.rule.value) {
-                const exists = [...el.children].find(child => child.matches(query));
+                const exists = [...el.children].find(child => !(el.rule.options.ignoreOmittedElements && child.isOmitted) && child.matches(query));
                 if (!exists) {
                     const message = t('Require {0}', t('the "{0*}" {1}', query, 'element'));
                     report({

package/lib/required-element/meta.d.ts

@@ -1,3 +1,4 @@
+/** Rule metadata for the `required-element` rule, categorized as validation. */
 declare const _default: {
     readonly category: "validation";
 };

package/lib/required-element/meta.js

@@ -1,3 +1,4 @@
+/** Rule metadata for the `required-element` rule, categorized as validation. */
 export default {
     category: 'validation',
 };

package/lib/required-h1/index.d.ts

@@ -1,6 +1,18 @@
+/**
+ * Configuration options for the required-h1 rule.
+ */
 export interface Options {
+    /** Whether to report a violation when more than one `<h1>` element is found. */
     'expected-once': boolean;
+    /** Whether to apply this rule in document fragments (components, partials). */
     'in-document-fragment': boolean;
 }
+/**
+ * Rule that requires exactly one `<h1>` element in the document.
+ *
+ * Reports a violation when no `<h1>` is present. Optionally reports when
+ * multiple `<h1>` elements exist (controlled by `expected-once`). Can be
+ * configured to skip document fragments via the `in-document-fragment` option.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
 export default _default;

package/lib/required-h1/index.js

@@ -1,5 +1,12 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
+/**
+ * Rule that requires exactly one `<h1>` element in the document.
+ *
+ * Reports a violation when no `<h1>` is present. Optionally reports when
+ * multiple `<h1>` elements exist (controlled by `expected-once`). Can be
+ * configured to skip document fragments via the `in-document-fragment` option.
+ */
 export default createRule({
     meta: meta,
     defaultOptions: {

package/lib/required-h1/meta.d.ts

@@ -1,3 +1,4 @@
+/** Rule metadata for the `required-h1` rule, categorized as accessibility. */
 declare const _default: {
     readonly category: "a11y";
 };

package/lib/required-h1/meta.js

@@ -1,3 +1,4 @@
+/** Rule metadata for the `required-h1` rule, categorized as accessibility. */
 export default {
     category: 'a11y',
 };

package/lib/srcset-sizes-constraint/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Rule that enforces WHATWG constraints between the `srcset`, `sizes`,
+ * and `loading` attributes on `<img>` and `<source>` elements.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+export default _default;