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

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

@@ -1,4 +1,4 @@
-import type { ContentModelResult, Element, Options, Specs } from './types.js';
+import type { ContentModelResult, Element, Mode, Options, Specs, TagRule } from './types.js';
 import type { ContentModel } from '@markuplint/ml-spec';
 import type { ReadonlyDeep } from 'type-fest';
 /**
@@ -16,4 +16,4 @@ import type { ReadonlyDeep } from 'type-fest';
  * @param options - Validation behavior options.
  * @returns An array of content model results describing any violations found.
  */
-export declare function start(contents: ReadonlyDeep<ContentModel['contents']>, el: Element, specs: Specs, options: Options): ContentModelResult[];
+export declare function start(contents: ReadonlyDeep<ContentModel['contents']>, el: Element, rules: readonly TagRule[], specs: Specs, options: Options, mode: Mode): ContentModelResult[];

package/lib/permitted-contents/start.js

@@ -17,7 +17,7 @@ import { representTransparentNodes } from './represent-transparent-nodes.js';
  */
 export function start(contents, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-el, specs, options) {
+el, rules, specs, options, mode) {
     const childNodesPatterns = options.evaluateConditionalChildNodes
         ? el.conditionalChildNodes().map(childNodes => [...childNodes])
         : [[...el.childNodes].filter(child => !(child.is(child.TEXT_NODE) && child.isWhitespace()))];
@@ -53,9 +53,9 @@ el, specs, options) {
                 },
             ];
         }
-        const patterns = representTransparentNodes(childNodes, specs, options);
+        const patterns = representTransparentNodes(childNodes, rules, specs, options, mode);
         return patterns.flatMap(({ nodes, errors }) => {
-            const result = order(contents, nodes, specs, options, 0);
+            const result = order(contents, nodes, rules, specs, options, 0, mode);
             return [
                 {
                     type: result.type,

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

@@ -103,6 +103,20 @@ export type TransparentModel = {
 export type TagRule = {
     readonly tag: string;
 } & ReadonlyDeep<ContentModel>;
+/**
+ * Which identity of a pretendered element is being evaluated during a
+ * content-model check. `'pretended'` is the default view: the element is
+ * validated against the HTML spec for the pretender target name (e.g. a
+ * `<Breadcrumbs>` pretending to `<nav>` is validated as `<nav>`).
+ * `'origin'` re-runs the validation with the pretender context suppressed,
+ * so the element is validated against any user-defined tag rule keyed on
+ * the original AST name (e.g. `Breadcrumbs`).
+ *
+ * The mode is threaded through every helper so that selector matching,
+ * transparent-model resolution, and content-model lookups all agree on the
+ * same view of the element identity.
+ */
+export type Mode = 'origin' | 'pretended';
 /**
  * Options for the permitted-contents rule that control validation behavior.
  */

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

@@ -1,4 +1,4 @@
-import type { ChildNode, Hints, MissingNodeReason, RepeatSign, Specs } from './types.js';
+import type { ChildNode, Hints, MissingNodeReason, Mode, RepeatSign, Specs } from './types.js';
 import type { PermittedContentPattern, PermittedContentChoice, PermittedContentOneOrMore, PermittedContentOptional, PermittedContentRequire, PermittedContentTransparent, PermittedContentZeroOrMore, Model } from '@markuplint/ml-spec';
 import type { ReadonlyDeep } from 'type-fest';
 /**
@@ -16,12 +16,21 @@ export declare function isModel(model: ReadonlyDeep<Model | PermittedContentPatt
  * selector engine. Returns whether the node matched and, if not, the deepest
  * unmatched descendant node for diagnostic purposes.
  *
+ * When `mode === 'origin'` and the node has an active pretender context, the
+ * context is temporarily suppressed so that the selector engine reads the
+ * element's original AST identity (`rawName` / original attrs) instead of the
+ * pretender target. The mutation mirrors the pattern already used by
+ * `MLElement.matchMLSelector` and is safe because the selector engine runs
+ * synchronously — the original context is restored in `finally` before the
+ * call returns.
+ *
  * @param selector - The CSS selector string to test against.
  * @param node - The child node to test.
  * @param specs - The spec data passed to the selector engine for attribute resolution.
+ * @param mode - Which identity to match against (`'pretended'` is the default view).
  * @returns An object with `matched: true` if the node matches, or `matched: false` with an optional `not` node.
  */
-export declare function matches(selector: string, node: ChildNode, specs: Specs): {
+export declare function matches(selector: string, node: ChildNode, specs: Specs, mode: Mode): {
     matched: boolean;
     not?: undefined;
 } | {

package/lib/permitted-contents/utils.js

@@ -31,29 +31,78 @@ export function isModel(model) {
  * selector engine. Returns whether the node matched and, if not, the deepest
  * unmatched descendant node for diagnostic purposes.
  *
+ * When `mode === 'origin'` and the node has an active pretender context, the
+ * context is temporarily suppressed so that the selector engine reads the
+ * element's original AST identity (`rawName` / original attrs) instead of the
+ * pretender target. The mutation mirrors the pattern already used by
+ * `MLElement.matchMLSelector` and is safe because the selector engine runs
+ * synchronously — the original context is restored in `finally` before the
+ * call returns.
+ *
  * @param selector - The CSS selector string to test against.
  * @param node - The child node to test.
  * @param specs - The spec data passed to the selector engine for attribute resolution.
+ * @param mode - Which identity to match against (`'pretended'` is the default view).
  * @returns An object with `matched: true` if the node matches, or `matched: false` with an optional `not` node.
  */
 export function matches(selector, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, specs) {
-    const selectorResult = createSelector(selector, specs).search(node);
-    const matched = selectorResult.filter((r) => r.matched);
-    if (matched.length > 0) {
+node, specs, mode) {
+    let savedPretenderContext = null;
+    if (mode === 'origin') {
+        savedPretenderContext = suppressPretender(node);
+    }
+    try {
+        const selectorResult = createSelector(selector, specs).search(node);
+        const matched = selectorResult.filter((r) => r.matched);
+        if (matched.length > 0) {
+            return {
+                matched: true,
+            };
+        }
+        const not = selectorResult
+            .flatMap(r => (r.matched ? [] : (r.not ?? [])))
+            .flatMap(descendants)
+            .shift();
         return {
-            matched: true,
+            matched: false,
+            not,
         };
     }
-    const not = selectorResult
-        .flatMap(r => (r.matched ? [] : (r.not ?? [])))
-        .flatMap(descendants)
-        .shift();
-    return {
-        matched: false,
-        not,
-    };
+    finally {
+        if (savedPretenderContext) {
+            restorePretender(node, savedPretenderContext);
+        }
+    }
+}
+/**
+ * Temporarily hides the pretender context on an element so that selector
+ * matching sees its original AST identity. Returns the saved context for
+ * later restoration, or `null` if the node is not an element with an active
+ * pretender.
+ */
+function suppressPretender(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+node) {
+    if (!node.is(node.ELEMENT_NODE)) {
+        return null;
+    }
+    const pretenderContext = node.pretenderContext;
+    if (pretenderContext?.type !== 'pretender') {
+        return null;
+    }
+    node.pretenderContext = null;
+    return pretenderContext;
+}
+/**
+ * Restores a pretender context previously saved by {@link suppressPretender}.
+ */
+function restorePretender(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+node, saved) {
+    if (node.is(node.ELEMENT_NODE)) {
+        node.pretenderContext = saved;
+    }
 }
 /**
  * Traverses a chain of nested `:has()` selector results to find the deepest

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

@@ -7,7 +7,8 @@ import type { ARIAProperty, ARIARole } from '@markuplint/ml-spec';
  * 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).
+ * 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.

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

@@ -1,11 +1,19 @@
 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).
+ * 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.
@@ -14,18 +22,32 @@ import { ARIA_RECOMMENDED_VERSION, getARIA } from '@markuplint/ml-spec';
  * @returns A violation if the property is not allowed on the given role or element.
  */
 export const checkingDisallowedProp = ({ attr, role, propSpecs, disallowSetImplicitProps }) => t => {
-    if (!role) {
-        return;
-    }
     if (!/^aria-/i.test(attr.name)) {
         return;
     }
     const ariaVersion = attr.rule.options?.version ??
         attr.ownerMLDocument.ruleCommonSettings?.ariaVersion ??
         ARIA_RECOMMENDED_VERSION;
-    const statesAndProp = role.ownedProperties.find(p => p.name === attr.name);
     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) {

package/lib/wai-aria/checkings/permitted-roles.js

@@ -15,13 +15,26 @@ export const checkingPermittedRoles = ({ attr }) => t => {
         ARIA_RECOMMENDED_VERSION;
     const el = attr.ownerElement;
     const permittedRoles = getPermittedRoles(el, ariaVersion, attr.ownerMLDocument.specs);
+    const tokens = attr.tokenList?.allTokens();
+    // When no explicit role is permitted on this element, report against each token
+    // so the offending role name is preserved in the message (same scope as the
+    // per-token branch below). If there are no tokens, fall back to the whole attr.
     if (permittedRoles.length === 0) {
+        if (!tokens || tokens.length === 0) {
+            return {
+                scope: attr,
+                message: t('{0} according to {1}', t('Cannot overwrite {0}', t('{0} of {1}', t('the {0}', 'role'), t('the "{0*}" {1}', el.localName, 'element'))), 'ARIA in HTML specification'),
+            };
+        }
+        const firstToken = tokens[0];
+        if (!firstToken) {
+            return;
+        }
         return {
-            scope: attr,
-            message: t('{0} according to {1}', t('Cannot overwrite {0}', t('{0} of {1}', t('the {0}', 'role'), t('the "{0*}" {1}', el.localName, 'element'))), 'ARIA in HTML specification'),
+            scope: firstToken,
+            message: t('{0} according to {1}', t('Cannot overwrite {0} to {1}', t('the "{0*}" {1}', firstToken.raw, 'role'), t('the "{0*}" {1}', el.localName, 'element')), 'ARIA in HTML specification'),
         };
     }
-    const tokens = attr.tokenList?.allTokens();
     if (!tokens) {
         return;
     }

package/lib/wai-aria/checkings/required-accessibility-parent-role.js

@@ -41,7 +41,7 @@ export const checkingRequiredAccessibilityParentRole = ({ el, computed }) => t =
         // `ariaSpecs().roles` returns raw spec data where the field is always
         // `requiredContextRole` for all versions. The fallback to
         // `requiredAccessibilityParentRole` is a defensive guard in case
-        // the spec-generator changes the field name in the future.
+        // the generator changes the field name in the future.
         const parentRoles = roleSpec.requiredContextRole ?? roleSpec.requiredAccessibilityParentRole;
         if (parentRoles && parentRoles.length > 0) {
             return {

package/lib/wai-aria/default-options.d.ts

@@ -0,0 +1,5 @@
+import type { Options } from './types.js';
+/**
+ * Default options shared by the `wai-aria` rule and all `wai-aria-*` sub-rules.
+ */
+export declare const defaultOptions: Options;

package/lib/wai-aria/default-options.js

@@ -0,0 +1,18 @@
+/**
+ * Default options shared by the `wai-aria` rule and all `wai-aria-*` sub-rules.
+ */
+export const defaultOptions = {
+    checkingValue: true,
+    checkingDeprecatedRole: true,
+    checkingDeprecatedProps: true,
+    permittedAriaRoles: true,
+    checkingAllowedAccessibilityChildRoles: true,
+    checkingRequiredOwnedElements: true,
+    checkingRequiredAccessibilityParentRole: true,
+    checkingPresentationalChildren: false,
+    checkingInteractionInHidden: false,
+    disallowSetImplicitRole: true,
+    disallowSetImplicitProps: true,
+    disallowDefaultValue: false,
+    version: undefined,
+};

package/lib/wai-aria/index.js

@@ -1,6 +1,7 @@
 import { createRule, getAttrSpecs, getComputedRole, ariaSpecs, getSpec } from '@markuplint/ml-core';
 import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
 import { Collection } from '../helpers.js';
+import { defaultOptions } from './default-options.js';
 import { checkingAbstractRole } from './checkings/abstract-role.js';
 import { checkingDefaultValue } from './checkings/default-value.js';
 import { checkingDeprecatedProps } from './checkings/deprecated-props.js';
@@ -30,21 +31,7 @@ import meta from './meta.js';
  */
 export default createRule({
     meta: meta,
-    defaultOptions: {
-        checkingValue: true,
-        checkingDeprecatedRole: true,
-        checkingDeprecatedProps: true,
-        permittedAriaRoles: true,
-        checkingAllowedAccessibilityChildRoles: true,
-        checkingRequiredOwnedElements: true,
-        checkingRequiredAccessibilityParentRole: true,
-        checkingPresentationalChildren: false,
-        checkingInteractionInHidden: false,
-        disallowSetImplicitRole: true,
-        disallowSetImplicitProps: true,
-        disallowDefaultValue: false,
-        version: undefined,
-    },
+    defaultOptions,
     async verify({ document, report, t }) {
         await document.walkOn('Element', el => {
             const roleAttr = el.getAttributeNode('role');
@@ -80,10 +67,12 @@ export default createRule({
                 if (el.rule.options.checkingDeprecatedRole) {
                     report(checkingDeprecatedRole({ attr: roleAttr, role: computed.role }));
                 }
-                if (el.rule.options.disallowSetImplicitRole) {
-                    report(checkingImplicitRole({ attr: roleAttr }));
-                }
-                if (el.rule.options.permittedAriaRoles) {
+                // If the explicit role duplicates the implicit role, surface only that
+                // (more specific) message. Otherwise fall through to the general
+                // permitted-roles check to avoid emitting two violations for the same
+                // offending token.
+                const implicitRoleViolated = el.rule.options.disallowSetImplicitRole && report(checkingImplicitRole({ attr: roleAttr }));
+                if (el.rule.options.permittedAriaRoles && !implicitRoleViolated) {
                     report(checkingPermittedRoles({ attr: roleAttr }));
                 }
             }

package/lib/wai-aria-abstract-role/index.d.ts

@@ -0,0 +1,4 @@
+import type { Options } from '../wai-aria/types.js';
+/** Warns when an abstract WAI-ARIA role is used directly in content. */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/wai-aria-abstract-role/index.js

@@ -0,0 +1,22 @@
+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,
+    async verify({ document, report }) {
+        await document.walkOn('Element', el => {
+            const roleAttr = el.getAttributeNode('role');
+            if (!roleAttr)
+                return;
+            const elSpec = getSpec(el, document.specs.specs);
+            if (!elSpec)
+                return;
+            if (!elSpec.globalAttrs['#ARIAAttrs'])
+                return;
+            report(checkingAbstractRole({ attr: roleAttr }));
+        });
+    },
+});

package/lib/wai-aria-abstract-role/meta.d.ts

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

package/lib/wai-aria-abstract-role/meta.js

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

package/lib/wai-aria-default-value/index.d.ts

@@ -0,0 +1,4 @@
+import type { Options } from '../wai-aria/types.js';
+/** Warns when an ARIA property is explicitly set to its spec-defined default value. */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/wai-aria-default-value/index.js

@@ -0,0 +1,28 @@
+import { createRule, ariaSpecs, getSpec } from '@markuplint/ml-core';
+import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
+import { checkingDefaultValue } from '../wai-aria/checkings/default-value.js';
+import { defaultOptions } from '../wai-aria/default-options.js';
+import meta from './meta.js';
+/** Warns when an ARIA property is explicitly set to its spec-defined default value. */
+export default createRule({
+    meta,
+    defaultSeverity: 'warning',
+    defaultOptions,
+    async verify({ document, report }) {
+        await document.walkOn('Element', el => {
+            const elSpec = getSpec(el, document.specs.specs);
+            if (!elSpec)
+                return;
+            if (!elSpec.globalAttrs['#ARIAAttrs'])
+                return;
+            const propAttrs = el.attributes.filter(attr => /^aria-/i.test(attr.name));
+            if (propAttrs.length === 0)
+                return;
+            const ariaVersion = el.rule.options?.version ?? document.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;
+            const { props: propSpecs } = ariaSpecs(document.specs, ariaVersion);
+            for (const attr of propAttrs) {
+                report(checkingDefaultValue({ attr, propSpecs }));
+            }
+        });
+    },
+});

package/lib/wai-aria-default-value/meta.d.ts

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

package/lib/wai-aria-default-value/meta.js

@@ -0,0 +1,4 @@
+/** Rule metadata for the `wai-aria-default-value` rule, categorized under accessibility. */
+export default {
+    category: 'a11y',
+};

package/lib/wai-aria-deprecated-props/index.d.ts

@@ -0,0 +1,4 @@
+import type { Options } from '../wai-aria/types.js';
+/** Warns when a deprecated ARIA property or state is used on a role. */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/wai-aria-deprecated-props/index.js

@@ -0,0 +1,29 @@
+import { createRule, getComputedRole, ariaSpecs, getSpec } from '@markuplint/ml-core';
+import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
+import { checkingDeprecatedProps } from '../wai-aria/checkings/deprecated-props.js';
+import { defaultOptions } from '../wai-aria/default-options.js';
+import meta from './meta.js';
+/** Warns when a deprecated ARIA property or state is used on a role. */
+export default createRule({
+    meta,
+    defaultSeverity: 'warning',
+    defaultOptions,
+    async verify({ document, report }) {
+        await document.walkOn('Element', el => {
+            const elSpec = getSpec(el, document.specs.specs);
+            if (!elSpec)
+                return;
+            if (!elSpec.globalAttrs['#ARIAAttrs'])
+                return;
+            const propAttrs = el.attributes.filter(attr => /^aria-/i.test(attr.name));
+            if (propAttrs.length === 0)
+                return;
+            const ariaVersion = el.rule.options?.version ?? document.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;
+            const computed = getComputedRole(document.specs, el, ariaVersion);
+            const { props: propSpecs } = ariaSpecs(document.specs, ariaVersion);
+            for (const attr of propAttrs) {
+                report(checkingDeprecatedProps({ attr, role: computed.role, propSpecs }));
+            }
+        });
+    },
+});

package/lib/wai-aria-deprecated-props/meta.d.ts

@@ -0,0 +1,5 @@
+/** Rule metadata for the `wai-aria-deprecated-props` rule, categorized under accessibility. */
+declare const _default: {
+    readonly category: "a11y";
+};
+export default _default;

package/lib/wai-aria-deprecated-props/meta.js

@@ -0,0 +1,4 @@
+/** Rule metadata for the `wai-aria-deprecated-props` rule, categorized under accessibility. */
+export default {
+    category: 'a11y',
+};

package/lib/wai-aria-deprecated-role/index.d.ts

@@ -0,0 +1,4 @@
+import type { Options } from '../wai-aria/types.js';
+/** Warns when a deprecated WAI-ARIA role is used. */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/wai-aria-deprecated-role/index.js

@@ -0,0 +1,26 @@
+import { createRule, getComputedRole, getSpec } from '@markuplint/ml-core';
+import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
+import { checkingDeprecatedRole } from '../wai-aria/checkings/deprecated-role.js';
+import { defaultOptions } from '../wai-aria/default-options.js';
+import meta from './meta.js';
+/** Warns when a deprecated WAI-ARIA role is used. */
+export default createRule({
+    meta,
+    defaultSeverity: 'warning',
+    defaultOptions,
+    async verify({ document, report }) {
+        await document.walkOn('Element', el => {
+            const roleAttr = el.getAttributeNode('role');
+            if (!roleAttr)
+                return;
+            const elSpec = getSpec(el, document.specs.specs);
+            if (!elSpec)
+                return;
+            if (!elSpec.globalAttrs['#ARIAAttrs'])
+                return;
+            const ariaVersion = el.rule.options?.version ?? document.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;
+            const computed = getComputedRole(document.specs, el, ariaVersion);
+            report(checkingDeprecatedRole({ attr: roleAttr, role: computed.role }));
+        });
+    },
+});

package/lib/wai-aria-deprecated-role/meta.d.ts

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

package/lib/wai-aria-deprecated-role/meta.js

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

package/lib/wai-aria-disallowed-props/index.d.ts

@@ -0,0 +1,4 @@
+import type { Options } from '../wai-aria/types.js';
+/** Warns when an ARIA property or state is not allowed on the element's computed role. */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/wai-aria-disallowed-props/index.js

@@ -0,0 +1,33 @@
+import { createRule, getComputedRole, ariaSpecs, getSpec } from '@markuplint/ml-core';
+import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
+import { checkingDisallowedProp } from '../wai-aria/checkings/disallowed-prop.js';
+import { defaultOptions } from '../wai-aria/default-options.js';
+import meta from './meta.js';
+/** Warns when an ARIA property or state is not allowed on the element's computed role. */
+export default createRule({
+    meta,
+    defaultOptions,
+    async verify({ document, report }) {
+        await document.walkOn('Element', el => {
+            const elSpec = getSpec(el, document.specs.specs);
+            if (!elSpec)
+                return;
+            if (!elSpec.globalAttrs['#ARIAAttrs'])
+                return;
+            const propAttrs = el.attributes.filter(attr => /^aria-/i.test(attr.name));
+            if (propAttrs.length === 0)
+                return;
+            const ariaVersion = el.rule.options?.version ?? document.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;
+            const computed = getComputedRole(document.specs, el, ariaVersion);
+            const { props: propSpecs } = ariaSpecs(document.specs, ariaVersion);
+            for (const attr of propAttrs) {
+                report(checkingDisallowedProp({
+                    attr,
+                    role: computed.role,
+                    propSpecs,
+                    disallowSetImplicitProps: true,
+                }));
+            }
+        });
+    },
+});

package/lib/wai-aria-disallowed-props/meta.d.ts

@@ -0,0 +1,5 @@
+/** Rule metadata for the `wai-aria-disallowed-props` rule, categorized under accessibility. */
+declare const _default: {
+    readonly category: "a11y";
+};
+export default _default;

package/lib/wai-aria-disallowed-props/meta.js

@@ -0,0 +1,4 @@
+/** Rule metadata for the `wai-aria-disallowed-props` rule, categorized under accessibility. */
+export default {
+    category: 'a11y',
+};

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

@@ -0,0 +1,4 @@
+import type { Options } from '../wai-aria/types.js';
+/** Warns when an ARIA property duplicates or contradicts semantics provided by a native HTML attribute. */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/wai-aria-implicit-props/index.js

@@ -0,0 +1,29 @@
+import { createRule, ariaSpecs, getAttrSpecs, getSpec } from '@markuplint/ml-core';
+import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
+import { checkingImplicitProps } from '../wai-aria/checkings/implicit-props.js';
+import { defaultOptions } from '../wai-aria/default-options.js';
+import meta from './meta.js';
+/** Warns when an ARIA property duplicates or contradicts semantics provided by a native HTML attribute. */
+export default createRule({
+    meta,
+    defaultSeverity: 'warning',
+    defaultOptions,
+    async verify({ document, report }) {
+        await document.walkOn('Element', el => {
+            const elSpec = getSpec(el, document.specs.specs);
+            if (!elSpec)
+                return;
+            if (!elSpec.globalAttrs['#ARIAAttrs'])
+                return;
+            const propAttrs = el.attributes.filter(attr => /^aria-/i.test(attr.name));
+            if (propAttrs.length === 0)
+                return;
+            const ariaVersion = el.rule.options?.version ?? document.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;
+            const { props: propSpecs } = ariaSpecs(document.specs, ariaVersion);
+            const attrSpecs = getAttrSpecs(el, document.specs);
+            for (const attr of propAttrs) {
+                report(checkingImplicitProps({ attr, propSpecs, attrSpecs }));
+            }
+        });
+    },
+});