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

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

@@ -1,139 +0,0 @@
-import { createRule, getAttrSpecs, getSpec } from '@markuplint/ml-core';
-import { checkAttributeSupport, checkElementSupport } from './compat-data.js';
-import meta from './meta.js';
-import { clearBrowserslistCache, resolveTargetBrowsers } from './resolve-browsers.js';
-/**
- * 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.
- */
-export default createRule({
-    meta: meta,
-    defaultSeverity: 'warning',
-    defaultOptions: {
-        checkExperimental: false,
-        checkNonStandard: false,
-    },
-    async verify({ document, report, t }) {
-        const options = document.rule.options;
-        const targetBrowsers = resolveTargetBrowsers(document.filename, {
-            browserslist: options.browserslist,
-            browserslistConfig: options.browserslistConfig,
-            browserslistEnv: options.browserslistEnv,
-        });
-        const hasTargetBrowsers = targetBrowsers != null && targetBrowsers.length > 0;
-        const checkExperimental = options.checkExperimental ?? false;
-        const checkNonStandard = options.checkNonStandard ?? false;
-        // If no browserslist config and no experimental/nonStandard check, rule is no-op
-        if (!hasTargetBrowsers && !checkExperimental && !checkNonStandard) {
-            return;
-        }
-        const ignoreFeatures = new Set(options.ignoreFeatures);
-        await document.walkOn('Element', async (el) => {
-            // Only check HTML elements
-            if (el.namespaceURI !== 'http://www.w3.org/1999/xhtml' || el.elementType !== 'html') {
-                return;
-            }
-            const elName = el.localName;
-            const elOptions = el.rule.options;
-            const elIgnoreFeatures = new Set(elOptions.ignoreFeatures ?? ignoreFeatures);
-            // Check element itself
-            if (!elIgnoreFeatures.has(elName)) {
-                // Experimental check (spec-based, no BCD needed)
-                if (elOptions.checkExperimental ?? checkExperimental) {
-                    const spec = getSpec(el, document.specs.specs);
-                    if (spec?.experimental) {
-                        report({
-                            scope: el,
-                            message: t('{0} is {1:c}', t('the "{0*}" {1}', elName, 'element'), 'experimental'),
-                        });
-                    }
-                }
-                // NonStandard check (spec-based, no BCD needed)
-                if (elOptions.checkNonStandard ?? checkNonStandard) {
-                    const spec = getSpec(el, document.specs.specs);
-                    if (spec?.nonStandard) {
-                        report({
-                            scope: el,
-                            message: t('{0} is {1:c}', t('the "{0*}" {1}', elName, 'element'), 'non-standard'),
-                        });
-                    }
-                }
-                // Browser support check (BCD-based)
-                if (hasTargetBrowsers) {
-                    const unsupported = await checkElementSupport(elName, targetBrowsers);
-                    if (unsupported.length > 0) {
-                        report({
-                            scope: el,
-                            message: formatUnsupportedMessage(t, elName, 'element', unsupported),
-                        });
-                    }
-                }
-            }
-            // Check attributes
-            const attrSpecs = getAttrSpecs(el, document.specs);
-            for (const attr of el.attributes) {
-                if (attr.isDirective) {
-                    continue;
-                }
-                const attrName = attr.name;
-                const ignoreKey = `${elName}[${attrName}]`;
-                if (elIgnoreFeatures.has(ignoreKey)) {
-                    continue;
-                }
-                const attrSpec = attrSpecs?.find(s => s.name === attrName);
-                // Experimental attribute check
-                if ((elOptions.checkExperimental ?? checkExperimental) && attrSpec?.experimental) {
-                    report({
-                        scope: attr,
-                        line: attr.nameNode?.startLine,
-                        col: attr.nameNode?.startCol,
-                        raw: attr.nameNode?.raw,
-                        message: t('{0} is {1:c}', t('the "{0*}" {1}', attrName, 'attribute'), 'experimental'),
-                    });
-                }
-                // NonStandard attribute check
-                if ((elOptions.checkNonStandard ?? checkNonStandard) && attrSpec?.nonStandard) {
-                    report({
-                        scope: attr,
-                        line: attr.nameNode?.startLine,
-                        col: attr.nameNode?.startCol,
-                        raw: attr.nameNode?.raw,
-                        message: t('{0} is {1:c}', t('the "{0*}" {1}', attrName, 'attribute'), 'non-standard'),
-                    });
-                }
-                // Browser support attribute check
-                if (hasTargetBrowsers) {
-                    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-features/meta.d.ts

@@ -1,5 +0,0 @@
-/** Rule metadata for `no-unsupported-features`: categorized as a validation rule. */
-declare const _default: {
-    readonly category: "validation";
-};
-export default _default;

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

@@ -1,4 +0,0 @@
-/** Rule metadata for `no-unsupported-features`: categorized as a validation rule. */
-export default {
-    category: 'validation',
-};

package/lib/no-use-event-handler-attr/index.d.ts

@@ -1,18 +0,0 @@
-/** Configuration options for the `no-use-event-handler-attr` rule. */
-type Options = {
-    /** Attribute name pattern(s) to exclude from the check. */
-    ignore?: string | string[];
-};
-/**
- * Rule that disallows inline event handler attributes (e.g., `onclick`,
- * `onchange`).
- *
- * Reports any attribute on an HTML element whose name starts with `on`,
- * indicating an inline event handler. An `ignore` option allows specific
- * attribute names or patterns to be excluded from the check.
- *
- * The value can be `true` (disallow all event handlers) or a `string[]`
- * of event names (without the `on` prefix) to selectively disallow.
- */
-declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean | readonly string[], Options>>;
-export default _default;

package/lib/no-use-event-handler-attr/meta.d.ts

@@ -1,5 +0,0 @@
-/** Rule metadata for `no-use-event-handler-attr`: categorized as a maintainability rule. */
-declare const _default: {
-    readonly category: "maintainability";
-};
-export default _default;

package/lib/no-use-event-handler-attr/meta.js

@@ -1,4 +0,0 @@
-/** Rule metadata for `no-use-event-handler-attr`: categorized as a maintainability rule. */
-export default {
-    category: 'maintainability',
-};

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

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

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

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

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

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

package/lib/required-attr/meta.js

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

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

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

package/lib/required-element/meta.js

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

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

@@ -1,18 +0,0 @@
-/**
- * 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/meta.d.ts

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

package/lib/required-h1/meta.js

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

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

@@ -1,6 +0,0 @@
-/**
- * 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;

package/lib/srcset-sizes-constraint/index.js

@@ -1,108 +0,0 @@
-import { createRule } from '@markuplint/ml-core';
-import meta from './meta.js';
-import { hasSizesAuto, parseSrcset } from './parse-srcset.js';
-/**
- * Rule that enforces WHATWG constraints between the `srcset`, `sizes`,
- * and `loading` attributes on `<img>` and `<source>` elements.
- */
-export default createRule({
-    meta: 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 sizesValue = sizesAttr?.value ?? null;
-            const sizesIsDynamic = sizesAttr?.isDynamicValue;
-            // Parse srcset unless dynamic
-            const parsed = srcsetIsDynamic ? null : parseSrcset(srcsetAttr.value);
-            // Check 2: width and density descriptors must not be mixed
-            if (parsed && parsed.hasWidth && (parsed.hasDensity || parsed.hasImplied)) {
-                report({
-                    scope: el,
-                    line: srcsetAttr.valueNode?.startLine,
-                    col: srcsetAttr.valueNode?.startCol,
-                    raw: srcsetAttr.valueNode?.raw,
-                    message: 'The "srcset" attribute must not mix width and pixel density descriptors',
-                });
-            }
-            // Check 1: 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',
-                });
-            }
-            // Check 3: img[sizes=auto] → loading=lazy required
-            if (localName === 'img' && sizesValue != null && !sizesIsDynamic && hasSizesAuto(sizesValue)) {
-                const loading = el.getAttribute('loading');
-                if (loading !== 'lazy') {
-                    report({
-                        scope: el,
-                        line: sizesAttr.valueNode?.startLine,
-                        col: sizesAttr.valueNode?.startCol,
-                        raw: sizesAttr.valueNode?.raw,
-                        message: 'The "sizes" attribute with "auto" requires the "loading" attribute to be "lazy"',
-                    });
-                }
-            }
-            // Check 4: source[sizes=auto] → following sibling img must have loading=lazy
-            if (localName === 'source' && sizesValue != null && !sizesIsDynamic && hasSizesAuto(sizesValue)) {
-                const img = findFollowingImg(el);
-                if (!img || img.getAttribute('loading') !== 'lazy') {
-                    report({
-                        scope: el,
-                        line: sizesAttr.valueNode?.startLine,
-                        col: sizesAttr.valueNode?.startCol,
-                        raw: sizesAttr.valueNode?.raw,
-                        message: 'The "source" element with sizes="auto" requires the following sibling "img" element to have loading="lazy"',
-                    });
-                }
-            }
-            // Check 5: img with w descriptors → sizes required
-            if (localName === 'img' && parsed && parsed.hasWidth && !sizesAttr) {
-                report({
-                    scope: el,
-                    message: 'The "sizes" attribute is required when the "srcset" attribute uses width descriptors',
-                });
-            }
-        });
-    },
-});
-/**
- * Find the first following sibling `<img>` element.
- * Per the spec, the img does not have to be the immediately next sibling.
- *
- * @param el - The starting element to search from
- * @returns The first following sibling `<img>` element, or `null` if none found
- */
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-function findFollowingImg(el) {
-    let sibling = el.nextElementSibling;
-    while (sibling != null) {
-        if (sibling.localName === 'img') {
-            return sibling;
-        }
-        sibling = sibling.nextElementSibling;
-    }
-    return null;
-}

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

@@ -1,5 +0,0 @@
-/** Rule metadata for `srcset-sizes-constraint`: categorized as a validation rule. */
-declare const _default: {
-    readonly category: "validation";
-};
-export default _default;

package/lib/srcset-sizes-constraint/meta.js

@@ -1,4 +0,0 @@
-/** Rule metadata for `srcset-sizes-constraint`: categorized as a validation rule. */
-export default {
-    category: 'validation',
-};

package/lib/table-row-column-alignment/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * Rule that validates table row and column alignment.
- *
- * Builds a grid model of each `<table>` and checks that all rows have a
- * consistent number of columns, that `colspan`/`rowspan` attributes do not
- * cause cell overlap, and that `rowspan` values do not exceed the available
- * rows in their table section.
- */
-declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
-export default _default;

package/lib/table-row-column-alignment/index.js

@@ -1,97 +0,0 @@
-import { createRule } from '@markuplint/ml-core';
-import { findChildren } from './find-children.js';
-import { Grid, getIndexes, getOverflowRowSpan } from './grid.js';
-import meta from './meta.js';
-/**
- * Rule that validates table row and column alignment.
- *
- * Builds a grid model of each `<table>` and checks that all rows have a
- * consistent number of columns, that `colspan`/`rowspan` attributes do not
- * cause cell overlap, and that `rowspan` values do not exceed the available
- * rows in their table section.
- */
-export default createRule({
-    meta,
-    defaultSeverity: 'warning',
-    verify({ document, report, t }) {
-        const tables = document.querySelectorAll('table');
-        for (const table of tables) {
-            const grid = new Grid(table);
-            const baseColLength = grid.getBaseColLength();
-            // grid.log();
-            if (grid.hasOverlapped()) {
-                report({
-                    scope: table,
-                    message: t(
-                    //
-                    '{0} are causing {1}', t(['rowspan', 'colspan'], true), 'cell overlap'),
-                });
-                break;
-            }
-            for (const { section, elements } of grid.getSections()) {
-                const overflow = getOverflowRowSpan(section, elements);
-                if (overflow) {
-                    report({
-                        scope: overflow.rowSpan,
-                        message: t('Exceeds the number of available {0}', 'rows'),
-                    });
-                }
-            }
-            const rows = grid.getAllRows();
-            const rowElements = grid.getAllRowElements();
-            for (const [rowNum, row] of rows.entries()) {
-                const colLength = row.length;
-                const rowEl = rowElements[rowNum];
-                if (!rowEl) {
-                    continue;
-                }
-                // Skip validation for rows that have expected column count differences due to rowspan/colspan
-                const cells = findChildren(rowEl, 'th, td');
-                let actualCellCount = 0;
-                for (const cell of cells) {
-                    const colspan = Number.parseInt(cell.getAttribute('colspan') ?? '1');
-                    actualCellCount += colspan;
-                }
-                // Check for rowspan cells occupying spaces in this row
-                const rowspanOccupiedCount = row.filter(cell => cell === '↓').length;
-                const expectedColumnCount = actualCellCount + rowspanOccupiedCount;
-                // Skip validation if the structure is valid accounting for spans
-                if (expectedColumnCount === baseColLength || actualCellCount + rowspanOccupiedCount === baseColLength) {
-                    continue;
-                }
-                // Debug log
-                // console.log(`Row ${rowNum}: baseColLength=${baseColLength}, colLength=${colLength}, actualCellCount=${actualCellCount}, rowspanOccupiedCount=${rowspanOccupiedCount}, expectedColumnCount=${expectedColumnCount}`);
-                const indexes = getIndexes(row);
-                if (colLength > baseColLength) {
-                    const index = indexes.slice(baseColLength)[0];
-                    const cells = findChildren(rowEl, 'th, td');
-                    const unexpected = typeof index === 'number' ? cells[index] : null;
-                    if (!unexpected) {
-                        const spanStart = cells.findLast(cell => Number.parseInt(cell.getAttribute('colspan') ?? '1') > 1);
-                        const colSpan = spanStart?.getAttributeNode('colspan');
-                        if (!colSpan) {
-                            continue;
-                        }
-                        report({
-                            scope: colSpan,
-                            message: t('Exceeds the number of available {0}', 'columns'),
-                        });
-                        continue;
-                    }
-                    const diff = colLength - baseColLength;
-                    report({
-                        scope: unexpected,
-                        message: t('{0} extra {1} in {2}', t(`${diff}`), t(diff === 1 ? 'column' : 'columns'), t('a {0}', t('row'))),
-                    });
-                }
-                if (colLength < baseColLength && expectedColumnCount < baseColLength) {
-                    const diff = baseColLength - colLength;
-                    report({
-                        scope: rowEl,
-                        message: t('{0} missing {1} in {2}', t(`${diff}`), t(diff === 1 ? 'column' : 'columns'), t('a {0}', t('row'))),
-                    });
-                }
-            }
-        }
-    },
-});

package/lib/table-row-column-alignment/meta.d.ts

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

package/lib/table-row-column-alignment/meta.js

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

package/lib/use-list/meta.d.ts

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

package/lib/use-list/meta.js

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

package/lib/wai-aria/checkings/disallowed-prop.d.ts

@@ -1,23 +0,0 @@
-import type { Options } from '../types.js';
-import type { AttrChecker } from '@markuplint/ml-core';
-import type { ARIAProperty, ARIARole } from '@markuplint/ml-spec';
-/**
- * Checks whether an ARIA property or state is disallowed on the element's computed role.
- *
- * Each ARIA role defines a set of supported states and properties. This checker reports
- * usage of ARIA attributes that are not in that set. It also considers element-specific
- * restrictions from the ARIA in HTML specification (e.g., properties that should not
- * be used on certain native HTML elements, and naming prohibition for elements with
- * no implicit role such as `<cite>` or `<abbr>`).
- *
- * @param attr - The ARIA attribute node to inspect.
- * @param role - The computed ARIA role of the element.
- * @param propSpecs - The list of ARIA property specifications for type lookup.
- * @param disallowSetImplicitProps - Whether to also enforce element-specific restrictions.
- * @returns A violation if the property is not allowed on the given role or element.
- */
-export declare const checkingDisallowedProp: AttrChecker<boolean, Options, {
-    role: ARIARole | null;
-    propSpecs: readonly ARIAProperty[];
-    disallowSetImplicitProps: boolean;
-}>;

package/lib/wai-aria/checkings/disallowed-prop.js

@@ -1,84 +0,0 @@
-import { ARIA_RECOMMENDED_VERSION, getARIA } from '@markuplint/ml-spec';
-/**
- * ARIA naming attributes subject to the "naming prohibition" constraint
- * defined by ARIA in HTML.
- *
- * @see https://w3c.github.io/html-aria/#dfn-naming-prohibited
- */
-const NAMING_ATTRS = new Set(['aria-label', 'aria-labelledby', 'aria-braillelabel']);
-/**
- * Checks whether an ARIA property or state is disallowed on the element's computed role.
- *
- * Each ARIA role defines a set of supported states and properties. This checker reports
- * usage of ARIA attributes that are not in that set. It also considers element-specific
- * restrictions from the ARIA in HTML specification (e.g., properties that should not
- * be used on certain native HTML elements, and naming prohibition for elements with
- * no implicit role such as `<cite>` or `<abbr>`).
- *
- * @param attr - The ARIA attribute node to inspect.
- * @param role - The computed ARIA role of the element.
- * @param propSpecs - The list of ARIA property specifications for type lookup.
- * @param disallowSetImplicitProps - Whether to also enforce element-specific restrictions.
- * @returns A violation if the property is not allowed on the given role or element.
- */
-export const checkingDisallowedProp = ({ attr, role, propSpecs, disallowSetImplicitProps }) => t => {
-    if (!/^aria-/i.test(attr.name)) {
-        return;
-    }
-    const ariaVersion = attr.rule.options?.version ??
-        attr.ownerMLDocument.ruleCommonSettings?.ariaVersion ??
-        ARIA_RECOMMENDED_VERSION;
-    const propSpec = propSpecs.find(p => p.name === attr.name);
-    const elAriaSpec = getARIA(attr.ownerMLDocument.specs, attr.ownerElement.localName, attr.ownerElement.namespaceURI, ariaVersion, attr.ownerElement.matches.bind(attr.ownerElement));
-    // Naming prohibition (ARIA in HTML): elements with namingProhibited=true
-    // must not use aria-label / aria-labelledby / aria-braillelabel unless
-    // an explicit role that supports naming is set. When `role` is null and
-    // the element is namingProhibited, the naming attrs are prohibited.
-    // At time of writing, the affected elements (implicitRole=false +
-    // namingProhibited=true in html-spec) are:
-    //   abbr, cite, figcaption, kbd, label, legend, mark, rt, var
-    // This list is not hard-coded here; it is derived from html-spec data.
-    if (!role && NAMING_ATTRS.has(attr.name) && elAriaSpec?.namingProhibited === true) {
-        return {
-            scope: attr,
-            message: t('{0:c} on {1}', t('{0} is {1:c}', t('the "{0*}" {1}', attr.name, `ARIA ${propSpec?.type ?? 'property'}`), 'prohibited'), t('the "{0*}" {1}', attr.ownerElement.localName, 'element')),
-        };
-    }
-    if (!role) {
-        return;
-    }
-    const statesAndProp = role.ownedProperties.find(p => p.name === attr.name);
-    if (disallowSetImplicitProps && elAriaSpec?.properties !== false && elAriaSpec?.properties?.without) {
-        for (const ignore of elAriaSpec.properties.without) {
-            if (ignore.name === attr.name) {
-                const hasNativeAttr = ignore.alt?.method === 'set-attr' && attr.ownerElement.hasAttribute(ignore.alt.target);
-                return {
-                    scope: attr,
-                    message: t('{0:c} on {1}', t(ignore.type === 'must-not'
-                        ? '{0} must not {1}'
-                        : ignore.type === 'should-not'
-                            ? '{0} should not {1}'
-                            : '{0} is not recommended to {1}', 
-                    // {0}
-                    t('the "{0*}" {1}', attr.name, `ARIA ${propSpec?.type ?? 'property'}`), 
-                    // {1}
-                    'use'), t('the "{0*}" {1}', attr.ownerElement.localName, 'element')) +
-                        (hasNativeAttr
-                            ? t('. ') +
-                                t('As its {0} is already provided by {1}', t('state'), t('the "{0*}" {1}', ignore.alt.target, 'attribute'))
-                            : ignore.alt
-                                ? t('. ') +
-                                    t('{0} if you {1} {2}', t(ignore.alt.method === 'remove-attr' ? 'Remove {0}' : 'Add {0}', t('the "{0*}" {1}', ignore.alt.target, 'attribute')), 'use', t('the {0}', `ARIA ${propSpec?.type ?? 'property'}`))
-                                : ''),
-                };
-            }
-        }
-    }
-    if (statesAndProp) {
-        return;
-    }
-    return {
-        scope: attr,
-        message: t('{0:c} on {1}', t('{0} is {1:c}', t('the "{0*}" {1}', attr.name, `ARIA ${propSpec?.type ?? 'property'}`), 'disallowed'), t('the "{0*}" {1}', role.name, 'role')),
-    };
-};

package/lib/wai-aria/checkings/implicit-props.d.ts

@@ -1,20 +0,0 @@
-import type { Options } from '../types.js';
-import type { AttrChecker } from '@markuplint/ml-core';
-import type { ARIAProperty, Attribute } from '@markuplint/ml-spec';
-/**
- * Checks whether an ARIA property duplicates or contradicts semantics already
- * provided by an equivalent native HTML attribute.
- *
- * Many ARIA properties have equivalent HTML attributes (e.g., `aria-required` and `required`).
- * This checker reports when an ARIA property is redundant because the native attribute
- * already conveys the same semantics, or when the ARIA value contradicts the native attribute.
- *
- * @param attr - The ARIA attribute node to inspect.
- * @param propSpecs - The list of ARIA property specifications for equivalence lookup.
- * @param attrSpecs - The HTML attribute specifications for the element.
- * @returns A violation if the ARIA property duplicates or contradicts an equivalent HTML attribute.
- */
-export declare const checkingImplicitProps: AttrChecker<boolean, Options, {
-    propSpecs: readonly ARIAProperty[];
-    attrSpecs: readonly Attribute[] | null;
-}>;