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

package/lib/label-no-multiple-controls/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Enforce the descendant-control constraints on a `<label>` element.
+ *
+ * Per HTML LS §4.10.4 content model: "Phrasing content, but with no
+ * descendant labelable elements unless it is the element's labeled
+ * control, and no descendant label elements." The labeled control is
+ * either the element whose ID equals the `for` attribute (when set to
+ * a labelable element in the same tree) or the first labelable
+ * descendant in tree order.
+ *
+ * Two branches follow from that definition:
+ *
+ * - `for` resolves to an external labelable element → no descendant
+ *   form control may appear inside the label (the labeled control is
+ *   outside).
+ * - Otherwise → at most one descendant form control; the first in tree
+ *   order is the labeled control, any subsequent ones are excess.
+ *
+ * ID existence itself is delegated to `no-refer-to-non-existent-id`;
+ * `for` referencing a non-labelable element is delegated to
+ * `label-for-references-labelable`. This rule only inspects the label
+ * subtree once the target's category has been classified.
+ *
+ * The `for` target lookup uses `document.querySelectorAll('[id]')` per
+ * matching label, not a cached id map. Kept in sync with
+ * `label-for-references-labelable` on purpose — the number of `<label>`
+ * elements per document is typically small, so a shared id-index would
+ * amortize poorly and split rule ownership across a helper module.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, null>>;
+export default _default;

package/lib/label-no-multiple-controls/index.js

@@ -0,0 +1,104 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+/**
+ * The HTML LS list of form-control descendants that may appear under a
+ * `<label>` element. Per the spec only one of these may exist per label,
+ * and only when the label is not already bound to an external labeled
+ * control via `for`.
+ *
+ * @see https://html.spec.whatwg.org/multipage/forms.html#the-label-element
+ */
+const FORM_CONTROL_SELECTOR = ['button', 'input', 'meter', 'output', 'progress', 'select', 'textarea'].join(',');
+/**
+ * Labelable elements per HTML LS §4.10.2 *Categories: Labelable elements*.
+ * The set matches `label-for-references-labelable`; kept in sync to
+ * classify the target of `for` consistently across both rules.
+ *
+ * @see https://html.spec.whatwg.org/multipage/forms.html#category-label
+ */
+const LABELABLE_SELECTOR = [
+    'button',
+    'input:not([type="hidden" i])',
+    'meter',
+    'output',
+    'progress',
+    'select',
+    'textarea',
+].join(',');
+/**
+ * Enforce the descendant-control constraints on a `<label>` element.
+ *
+ * Per HTML LS §4.10.4 content model: "Phrasing content, but with no
+ * descendant labelable elements unless it is the element's labeled
+ * control, and no descendant label elements." The labeled control is
+ * either the element whose ID equals the `for` attribute (when set to
+ * a labelable element in the same tree) or the first labelable
+ * descendant in tree order.
+ *
+ * Two branches follow from that definition:
+ *
+ * - `for` resolves to an external labelable element → no descendant
+ *   form control may appear inside the label (the labeled control is
+ *   outside).
+ * - Otherwise → at most one descendant form control; the first in tree
+ *   order is the labeled control, any subsequent ones are excess.
+ *
+ * ID existence itself is delegated to `no-refer-to-non-existent-id`;
+ * `for` referencing a non-labelable element is delegated to
+ * `label-for-references-labelable`. This rule only inspects the label
+ * subtree once the target's category has been classified.
+ *
+ * The `for` target lookup uses `document.querySelectorAll('[id]')` per
+ * matching label, not a cached id map. Kept in sync with
+ * `label-for-references-labelable` on purpose — the number of `<label>`
+ * elements per document is typically small, so a shared id-index would
+ * amortize poorly and split rule ownership across a helper module.
+ */
+export default createRule({
+    meta: meta,
+    defaultValue: true,
+    defaultOptions: null,
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            if (el.localName !== 'label')
+                return;
+            // Pretender labels have unknown descendants until the `as` attribute pins the type.
+            if (el.pretenderContext?.type === 'pretender' && !el.hasAttribute('as'))
+                return;
+            const controls = [...el.querySelectorAll(FORM_CONTROL_SELECTOR)];
+            if (controls.length === 0)
+                return;
+            const forAttr = el.getAttributeNode('for');
+            const hasExternalLabeledControl = (() => {
+                if (!forAttr || forAttr.isDynamicValue)
+                    return false;
+                const target = [...document.querySelectorAll('[id]')].find(candidate => candidate.getAttribute('id') === forAttr.value);
+                if (!target)
+                    return false;
+                // A descendant with a matching id is still the label's labeled control
+                // per the same-tree resolution rule; treat only truly external targets
+                // as the external-labeled-control case.
+                if (el.contains(target))
+                    return false;
+                return target.matches(LABELABLE_SELECTOR);
+            })();
+            if (hasExternalLabeledControl) {
+                for (const control of controls) {
+                    report({
+                        scope: control,
+                        message: t('The "{0}" element must not contain a form-control descendant when the "{1}" attribute references an external labelable element', 'label', 'for'),
+                    });
+                }
+                return;
+            }
+            if (controls.length <= 1)
+                return;
+            for (const control of controls.slice(1)) {
+                report({
+                    scope: control,
+                    message: t('The "{0}" element may contain at most one form-control descendant ({1})', 'label', 'button, input, meter, output, progress, select, or textarea'),
+                });
+            }
+        });
+    },
+});

package/lib/label-no-multiple-controls/meta.d.ts

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

package/lib/label-no-multiple-controls/meta.js

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

package/lib/landmark-roles/roles.d.ts

@@ -0,0 +1,32 @@
+import type { Element } from '@markuplint/ml-core';
+import type { PlainData } from '@markuplint/ml-config';
+/**
+ * Shared by the two rules split out of the former `landmark-roles` rule:
+ * `no-nested-top-level-landmark` and `require-landmark-label`. Both need the
+ * same set of landmark-role elements; only what each rule does with that set
+ * differs.
+ */
+/** Landmark roles that APG requires to be top-level (not nested in another landmark). */
+export type TopLevelRoles = 'banner' | 'main' | 'contentinfo' | 'complementary';
+/** All recognized ARIA landmark roles for these rules. */
+export type Roles = TopLevelRoles | 'form' | 'navigation' | 'region';
+/** A mapping from each landmark role to its matched elements in the document. */
+export type RoleSet<O extends PlainData> = {
+    [role in Roles]: Element<boolean, O>[];
+};
+/**
+ * Collects every landmark-role element in the document, keyed by role.
+ *
+ * @param document - The document to search.
+ * @returns The mapping from role to its matched elements.
+ */
+export declare function computeLandmarkRoles<O extends PlainData>(document: {
+    querySelectorAll(selector: string): Iterable<Element<boolean, O>>;
+}): RoleSet<O>;
+/**
+ * Collects all UUIDs of elements that have landmark roles.
+ *
+ * @param roleset - The mapping of roles to their matched elements.
+ * @returns A flat array of UUIDs for all landmark role elements.
+ */
+export declare function landmarkRoleElementUUIDList<O extends PlainData>(roleset: RoleSet<O>): string[];

package/lib/landmark-roles/roles.js

@@ -0,0 +1,73 @@
+/** CSS selectors used to identify elements with each landmark role. */
+const selectors = {
+    complementary: ['[role="complementary"]', 'aside'],
+    contentinfo: ['[role="contentinfo"]'],
+    form: ['[role="form"]', 'form[aria-labelledby]', 'form[aria-label]', 'form[title]'],
+    banner: ['[role="banner"]'],
+    main: ['[role="main"]', 'main'],
+    navigation: ['[role="navigation"]', 'nav'],
+    region: ['[role="region"]', 'section[aria-labelledby]', 'section[aria-label]', 'section[title]'],
+};
+/**
+ * Collects every landmark-role element in the document, keyed by role.
+ *
+ * @param document - The document to search.
+ * @returns The mapping from role to its matched elements.
+ */
+export function computeLandmarkRoles(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+document) {
+    const roles = {
+        complementary: [...document.querySelectorAll(selectors.complementary.join(','))],
+        contentinfo: [...document.querySelectorAll(selectors.contentinfo.join(','))],
+        form: [...document.querySelectorAll(selectors.form.join(','))],
+        banner: [...document.querySelectorAll(selectors.banner.join(','))],
+        main: [...document.querySelectorAll(selectors.main.join(','))],
+        navigation: [...document.querySelectorAll(selectors.navigation.join(','))],
+        region: [...document.querySelectorAll(selectors.region.join(','))],
+    };
+    /**
+     * `<header>`
+     *
+     * @cite https://www.w3.org/WAI/ARIA/apg/practices/landmark-regions/
+     *
+     * > When in context of the body element. The header element is not a banner landmark when it is a descendant of the following HTML sectioning elements:
+     * > - article
+     * > - aside
+     * > - main
+     * > - nav
+     * > - section
+     */
+    const headers = [...document.querySelectorAll('header')].filter(header => {
+        return !header.closest('article, aside, main, nav, section');
+    });
+    roles.banner.push(...headers);
+    /**
+     * `<footer>`
+     *
+     * @cite https://www.w3.org/WAI/ARIA/apg/practices/landmark-regions/
+     *
+     * > When in context of the body element. The footer element is not a contentinfo landmark when it is a descendant of the following HTML sectioning elements:
+     * > - article
+     * > - aside
+     * > - main
+     * > - nav
+     * > - section
+     */
+    const footers = [...document.querySelectorAll('footer')].filter(footer => {
+        return !footer.closest('article, aside, main, nav, section');
+    });
+    roles.contentinfo.push(...footers);
+    return roles;
+}
+/**
+ * Collects all UUIDs of elements that have landmark roles.
+ *
+ * @param roleset - The mapping of roles to their matched elements.
+ * @returns A flat array of UUIDs for all landmark role elements.
+ */
+export function landmarkRoleElementUUIDList(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+roleset) {
+    return Object.values(roleset).flatMap(elements => elements.map(element => element.uuid));
+}

package/lib/link-types/index.d.ts

@@ -1,10 +1,5 @@
 type Options = {
     readonly allowMicroformats?: boolean | readonly string[];
 };
-/**
- * Rule that validates link type keywords in the `rel` attribute on
- * `<link>`, `<a>`, `<area>`, and `<form>` elements against the WHATWG
- * standard and optionally the Microformats registry.
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
 export default _default;

package/lib/link-types/index.js

@@ -2,15 +2,14 @@ import { createRule } from '@markuplint/ml-core';
 import { DEF_LINK_TYPE_WHATWG, ALLOWED_LINK_TYPE_MICROFORMATS, DEF_LINK_TYPE_MICROFORMATS_DROPPED, DEF_LINK_TYPE_MICROFORMATS_DROPPED_WITHOUT_PREJUDICE, DEF_LINK_TYPE_MICROFORMATS_REJECTED, DEF_LINK_TYPE_MICROFORMATS_NON_HTML_REL_VALUES, } from '@markuplint/types';
 import meta from './meta.js';
 const TARGET_ELEMENTS = new Set(['link', 'a', 'area', 'form']);
-/**
- * Rule that validates link type keywords in the `rel` attribute on
- * `<link>`, `<a>`, `<area>`, and `<form>` elements against the WHATWG
- * standard and optionally the Microformats registry.
- */
 export default createRule({
     meta: meta,
+    // HTML LS §4.6.6 the rel attribute requires conformance checkers to accept
+    // keywords registered on the microformats wiki (proposed or ratified) as
+    // extensions to this specification, so accepting them is the spec-conformant
+    // default rather than an opt-in.
     defaultOptions: {
-        allowMicroformats: false,
+        allowMicroformats: true,
     },
     async verify({ document, report, t }) {
         await document.walkOn('Element', el => {

package/lib/link-types/meta.d.ts

@@ -1,5 +1,4 @@
-/** Rule metadata for the `link-types` rule, categorized as validation. */
 declare const _default: {
-    readonly category: "validation";
+    readonly category: "attributes";
 };
 export default _default;

package/lib/link-types/meta.js

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

package/lib/map-id-name-match/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Require that a `<map>` element's `id` attribute, when present, has
+ * the same value as its `name` attribute. Per HTML LS §4.8.13:
+ * "If the id attribute is also specified, both attributes must have
+ * the same value."
+ *
+ * @see https://html.spec.whatwg.org/multipage/image-maps.html#the-map-element
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, null>>;
+export default _default;

package/lib/map-id-name-match/index.js

@@ -0,0 +1,39 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+/**
+ * Require that a `<map>` element's `id` attribute, when present, has
+ * the same value as its `name` attribute. Per HTML LS §4.8.13:
+ * "If the id attribute is also specified, both attributes must have
+ * the same value."
+ *
+ * @see https://html.spec.whatwg.org/multipage/image-maps.html#the-map-element
+ */
+export default createRule({
+    meta: meta,
+    defaultValue: true,
+    defaultOptions: null,
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            if (el.localName !== 'map')
+                return;
+            // Pretender maps with no `as` pin: attributes are unknown until typed.
+            if (el.pretenderContext?.type === 'pretender' && !el.hasAttribute('as'))
+                return;
+            const idAttr = el.getAttributeNode('id');
+            const nameAttr = el.getAttributeNode('name');
+            if (!idAttr || !nameAttr)
+                return;
+            if (idAttr.isDynamicValue || nameAttr.isDynamicValue)
+                return;
+            if (idAttr.value === nameAttr.value)
+                return;
+            report({
+                scope: idAttr,
+                line: idAttr.valueNode?.startLine,
+                col: idAttr.valueNode?.startCol,
+                raw: idAttr.valueNode?.raw,
+                message: t('The "{0}" attribute on a "{1}" element must have the same value as the "{2}" attribute', 'id', 'map', 'name'),
+            });
+        });
+    },
+});

package/lib/map-id-name-match/meta.d.ts

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

package/lib/map-id-name-match/meta.js

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

package/lib/meta-charset-position/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * HTML LS §4.2.5.4 Specifying the document's character encoding:
+ *
+ * > The element containing the character encoding declaration must be
+ * > serialized completely within the first 1024 bytes of the document.
+ *
+ * The limit is a byte count, not a character count — `Buffer.byteLength`
+ * measures the UTF-8-encoded prefix rather than `String#length`, so
+ * multi-byte characters before the declaration are counted at their actual
+ * encoded size.
+ *
+ * @see https://html.spec.whatwg.org/multipage/semantics.html#charset
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+export default _default;

package/lib/meta-charset-position/index.js

@@ -0,0 +1,31 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+const BYTE_LIMIT = 1024;
+/**
+ * HTML LS §4.2.5.4 Specifying the document's character encoding:
+ *
+ * > The element containing the character encoding declaration must be
+ * > serialized completely within the first 1024 bytes of the document.
+ *
+ * The limit is a byte count, not a character count — `Buffer.byteLength`
+ * measures the UTF-8-encoded prefix rather than `String#length`, so
+ * multi-byte characters before the declaration are counted at their actual
+ * encoded size.
+ *
+ * @see https://html.spec.whatwg.org/multipage/semantics.html#charset
+ */
+export default createRule({
+    meta: meta,
+    verify({ document, report, t }) {
+        const declarations = document.querySelectorAll('meta[charset], meta[http-equiv="content-type" i]');
+        for (const el of declarations) {
+            const byteOffset = Buffer.byteLength(document.raw.slice(0, el.startOffset), 'utf8');
+            if (byteOffset < BYTE_LIMIT)
+                continue;
+            report({
+                scope: el,
+                message: t('The character encoding declaration must be within the first {0} bytes of the document', String(BYTE_LIMIT)),
+            });
+        }
+    },
+});

package/lib/meta-charset-position/meta.d.ts

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

package/lib/meta-charset-position/meta.js

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

package/lib/meter-value-bounds/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Enforce HTML LS §4.10.14 inequalities for `<meter>`:
+ * minimum ≤ value ≤ maximum, plus minimum ≤ low/high/optimum ≤ maximum
+ * and low ≤ high when both are specified. Defaults: min=0, max=1,
+ * value=min.
+ *
+ * @see https://html.spec.whatwg.org/multipage/form-elements.html#the-meter-element
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, null>>;
+export default _default;

package/lib/meter-value-bounds/index.js

@@ -0,0 +1,123 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+const DEFAULT_MIN = 0;
+const DEFAULT_MAX = 1;
+function parseFloatAttr(raw) {
+    if (raw === undefined)
+        return null;
+    const trimmed = raw.trim();
+    if (trimmed === '')
+        return null;
+    const n = Number(trimmed);
+    return Number.isFinite(n) ? n : null;
+}
+/**
+ * Enforce HTML LS §4.10.14 inequalities for `<meter>`:
+ * minimum ≤ value ≤ maximum, plus minimum ≤ low/high/optimum ≤ maximum
+ * and low ≤ high when both are specified. Defaults: min=0, max=1,
+ * value=min.
+ *
+ * @see https://html.spec.whatwg.org/multipage/form-elements.html#the-meter-element
+ */
+export default createRule({
+    meta: meta,
+    defaultValue: true,
+    defaultOptions: null,
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            if (el.localName !== 'meter')
+                return;
+            // Pretender meters with no `as` pin: descendants/attributes are unknown until typed.
+            if (el.pretenderContext?.type === 'pretender' && !el.hasAttribute('as'))
+                return;
+            const valueAttr = el.getAttributeNode('value');
+            const minAttr = el.getAttributeNode('min');
+            const maxAttr = el.getAttributeNode('max');
+            const lowAttr = el.getAttributeNode('low');
+            const highAttr = el.getAttributeNode('high');
+            const optimumAttr = el.getAttributeNode('optimum');
+            if (valueAttr?.isDynamicValue ||
+                minAttr?.isDynamicValue ||
+                maxAttr?.isDynamicValue ||
+                lowAttr?.isDynamicValue ||
+                highAttr?.isDynamicValue ||
+                optimumAttr?.isDynamicValue) {
+                return;
+            }
+            const valueNum = parseFloatAttr(valueAttr?.value);
+            const minNum = parseFloatAttr(minAttr?.value);
+            const maxNum = parseFloatAttr(maxAttr?.value);
+            const lowNum = parseFloatAttr(lowAttr?.value);
+            const highNum = parseFloatAttr(highAttr?.value);
+            const optimumNum = parseFloatAttr(optimumAttr?.value);
+            // Authored-but-unparsable values are reported by `no-invalid-attr-value`; skip the bounds
+            // check entirely so we don't compound the diagnostic noise.
+            if ((valueAttr && valueNum === null) ||
+                (minAttr && minNum === null) ||
+                (maxAttr && maxNum === null) ||
+                (lowAttr && lowNum === null) ||
+                (highAttr && highNum === null) ||
+                (optimumAttr && optimumNum === null)) {
+                return;
+            }
+            const minValue = minNum ?? DEFAULT_MIN;
+            const maxValue = maxNum ?? DEFAULT_MAX;
+            const valueValue = valueNum ?? minValue;
+            const reportLE = (lowerName, lowerAttr, upperName, upperAttr, upperDefault) => {
+                const upperDesc = upperAttr
+                    ? t('the value of the "{0}" attribute', upperName)
+                    : t('{0} when the "{1}" attribute is absent', upperDefault === 1 ? 'one' : String(upperDefault), upperName);
+                const message = t('The value of the "{0}" attribute must be less than or equal to {1}', lowerName, upperDesc);
+                const scope = lowerAttr ?? upperAttr;
+                if (scope) {
+                    report({
+                        scope: scope,
+                        line: scope.valueNode?.startLine,
+                        col: scope.valueNode?.startCol,
+                        raw: scope.valueNode?.raw,
+                        message: message,
+                    });
+                }
+                else {
+                    report({ scope: el, message: message });
+                }
+            };
+            if (minValue > maxValue) {
+                reportLE('min', minAttr, 'max', maxAttr, DEFAULT_MAX);
+            }
+            if (minValue > valueValue) {
+                reportLE('min', minAttr, 'value', valueAttr, DEFAULT_MIN);
+            }
+            if (valueValue > maxValue) {
+                reportLE('value', valueAttr, 'max', maxAttr, DEFAULT_MAX);
+            }
+            if (lowAttr && lowNum !== null) {
+                if (minValue > lowNum) {
+                    reportLE('min', minAttr, 'low', lowAttr, DEFAULT_MIN);
+                }
+                if (lowNum > maxValue) {
+                    reportLE('low', lowAttr, 'max', maxAttr, DEFAULT_MAX);
+                }
+            }
+            if (highAttr && highNum !== null) {
+                if (minValue > highNum) {
+                    reportLE('min', minAttr, 'high', highAttr, DEFAULT_MIN);
+                }
+                if (highNum > maxValue) {
+                    reportLE('high', highAttr, 'max', maxAttr, DEFAULT_MAX);
+                }
+            }
+            if (optimumAttr && optimumNum !== null) {
+                if (minValue > optimumNum) {
+                    reportLE('min', minAttr, 'optimum', optimumAttr, DEFAULT_MIN);
+                }
+                if (optimumNum > maxValue) {
+                    reportLE('optimum', optimumAttr, 'max', maxAttr, DEFAULT_MAX);
+                }
+            }
+            if (lowAttr && highAttr && lowNum !== null && highNum !== null && lowNum > highNum) {
+                reportLE('low', lowAttr, 'high', highAttr, 0);
+            }
+        });
+    },
+});

package/lib/meter-value-bounds/meta.d.ts

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

package/lib/meter-value-bounds/meta.js

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

package/lib/{wai-aria-required-props → no-abstract-role}/index.d.ts

@@ -1,4 +1,3 @@
 import type { Options } from '../wai-aria/types.js';
-/** Warns when required ARIA properties for a role are missing. */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
 export default _default;

package/lib/{wai-aria-abstract-role → no-abstract-role}/index.js

@@ -2,7 +2,6 @@ import { createRule, getSpec } from '@markuplint/ml-core';
 import { checkingAbstractRole } from '../wai-aria/checkings/abstract-role.js';
 import { defaultOptions } from '../wai-aria/default-options.js';
 import meta from './meta.js';
-/** Warns when an abstract WAI-ARIA role is used directly in content. */
 export default createRule({
     meta,
     defaultOptions,

package/lib/no-always-matching-source/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * HTML LS § the source element: when a `<source>` has a following sibling
+ * `<source>` or `<img>` element with a `srcset` attribute specified, it must
+ * have a usable `media` and/or `type` attribute, otherwise it "always
+ * matches" and shadows the following candidates. Split out of the former
+ * `srcset-sizes-constraint` rule's Check 6.
+ *
+ * Whether the current `<source>` itself has a `srcset` is irrelevant — the
+ * requirement is about distinguishing it from what follows, not about its
+ * own candidates.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+export default _default;