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

package/lib/wai-aria/checkings/element-supports-aria-prop.js

@@ -0,0 +1,83 @@
+import { ARIA_RECOMMENDED_VERSION, getARIA } from '@markuplint/ml-spec';
+/**
+ * Checks the ARIA in HTML element-specific `aria-*` restrictions: spec data
+ * may forbid every `aria-*` attribute on an element with no implicit role
+ * (`properties: false`, e.g. `input[type=hidden]`), whitelist a small set
+ * (`properties: { only: [...] }`, e.g. `<br>`/`<wbr>` accept only
+ * `aria-hidden`), or blacklist specific properties with a suggested
+ * alternative (`properties: { without: [...] }`).
+ *
+ * @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.
+ * @returns A violation if the element-specific restriction disallows the property.
+ */
+export const checkingElementSupportsAriaProp = ({ attr, role, propSpecs }) => 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));
+    // Spec data may set `properties: false` to forbid every aria-* attribute on
+    // elements that have no implicit role and accept no explicit role
+    // (e.g. `input[type=hidden]`). The role-based check (`role-supports-aria-prop`)
+    // does not cover this because `role` is null for such elements.
+    // Note: when an explicit `role=` is present, `role` is non-null and this
+    // branch is skipped — but `permitted-roles` already rejects the
+    // explicit role for elements whose spec says `permittedRoles: false`,
+    // so the user sees a violation either way.
+    if (!role && elAriaSpec?.properties === false) {
+        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}', attr.ownerElement.localName, 'element')),
+        };
+    }
+    // Spec data may set `properties: { only: [...] }` to whitelist a small
+    // set of aria-* attributes (e.g. `<br>` / `<wbr>` accept only
+    // `aria-hidden`). When the attribute is outside that whitelist, the
+    // element-specific restriction overrides the role-derived check.
+    //
+    // The schema permits entries in either bare-name form (`"aria-hidden"`)
+    // or name/value pair form (`{ name, value? }`). No html-spec entry
+    // currently uses the value form, so we only key on the name. If the
+    // value form becomes necessary later, mirror the value-matching path
+    // already implemented in the `properties.without` branch below.
+    if (elAriaSpec?.properties !== false && elAriaSpec?.properties?.only) {
+        const onlyNames = elAriaSpec.properties.only.map(o => (typeof o === 'string' ? o : o.name));
+        if (!onlyNames.includes(attr.name)) {
+            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}', attr.ownerElement.localName, 'element')),
+            };
+        }
+    }
+    if (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'}`))
+                                : ''),
+                };
+            }
+        }
+    }
+};

package/lib/wai-aria/checkings/prohibited-naming.d.ts

@@ -0,0 +1,35 @@
+import type { Options } from '../types.js';
+import type { AttrChecker } from '@markuplint/ml-core';
+import type { ARIAProperty, ARIARole } from '@markuplint/ml-spec';
+/**
+ * Checks the ARIA in HTML naming-prohibition constraint: 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.
+ *
+ * Autonomous custom elements (`<x-y>`, no `is=` attribute, no spec.<el>
+ * entry) are treated the same way: ARIA in HTML §4.4 forbids naming
+ * attrs unless an explicit role that supports naming is set. The
+ * `elementType === 'web-component'` discriminator excludes
+ * customised-built-in elements (`<button is="x-y">`) — those inherit
+ * the host element's namingProhibited flag through the regular path.
+ * `getComputedRole` returns null for custom elements even when a
+ * `role=` attribute is set (it can't validate the role against an
+ * unknown element's permittedRoles), so consult the raw attribute
+ * directly to detect "an explicit role that supports naming is set".
+ *
+ * @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.
+ * @returns A violation if a naming attribute is used on a naming-prohibited element.
+ */
+export declare const checkingProhibitedNaming: AttrChecker<boolean, Options, {
+    role: ARIARole | null;
+    propSpecs: readonly ARIAProperty[];
+}>;

package/lib/wai-aria/checkings/prohibited-naming.js

@@ -0,0 +1,64 @@
+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 the ARIA in HTML naming-prohibition constraint: 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.
+ *
+ * Autonomous custom elements (`<x-y>`, no `is=` attribute, no spec.<el>
+ * entry) are treated the same way: ARIA in HTML §4.4 forbids naming
+ * attrs unless an explicit role that supports naming is set. The
+ * `elementType === 'web-component'` discriminator excludes
+ * customised-built-in elements (`<button is="x-y">`) — those inherit
+ * the host element's namingProhibited flag through the regular path.
+ * `getComputedRole` returns null for custom elements even when a
+ * `role=` attribute is set (it can't validate the role against an
+ * unknown element's permittedRoles), so consult the raw attribute
+ * directly to detect "an explicit role that supports naming is set".
+ *
+ * @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.
+ * @returns A violation if a naming attribute is used on a naming-prohibited element.
+ */
+export const checkingProhibitedNaming = ({ attr, role, propSpecs }) => t => {
+    if (!/^aria-/i.test(attr.name)) {
+        return;
+    }
+    if (!NAMING_ATTRS.has(attr.name)) {
+        return;
+    }
+    if (role) {
+        return;
+    }
+    const ariaVersion = attr.rule.options?.version ??
+        attr.ownerMLDocument.ruleCommonSettings?.ariaVersion ??
+        ARIA_RECOMMENDED_VERSION;
+    const elAriaSpec = getARIA(attr.ownerMLDocument.specs, attr.ownerElement.localName, attr.ownerElement.namespaceURI, ariaVersion, attr.ownerElement.matches.bind(attr.ownerElement));
+    const isAutonomousCustomElement = attr.ownerElement.elementType === 'web-component' && !attr.ownerElement.hasAttribute('is');
+    const hasExplicitRoleAttr = isAutonomousCustomElement && (attr.ownerElement.getAttribute('role')?.trim() ?? '') !== '';
+    if (hasExplicitRoleAttr) {
+        return;
+    }
+    if (elAriaSpec?.namingProhibited !== true && !isAutonomousCustomElement) {
+        return;
+    }
+    const propSpec = propSpecs.find(p => p.name === attr.name);
+    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')),
+    };
+};

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

@@ -0,0 +1,23 @@
+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 is redundant because an equivalent native
+ * HTML attribute already conveys the same semantics with the same value —
+ * either the current value of that attribute, or (when absent) its implicit
+ * default.
+ *
+ * Many ARIA properties have equivalent HTML attributes (e.g., `aria-required`
+ * and `required`). ARIA in HTML §6 recommends using the native attribute in
+ * preference to the ARIA equivalent, so restating the same value via `aria-*`
+ * is superfluous.
+ *
+ * @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 redundantly restates an equivalent HTML attribute.
+ */
+export declare const checkingRedundantAriaProp: AttrChecker<boolean, Options, {
+    propSpecs: readonly ARIAProperty[];
+    attrSpecs: readonly Attribute[] | null;
+}>;

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

@@ -0,0 +1,53 @@
+import { resolveAttrEligibility } from '../../attr-eligibility.js';
+/**
+ * Checks whether an ARIA property is redundant because an equivalent native
+ * HTML attribute already conveys the same semantics with the same value —
+ * either the current value of that attribute, or (when absent) its implicit
+ * default.
+ *
+ * Many ARIA properties have equivalent HTML attributes (e.g., `aria-required`
+ * and `required`). ARIA in HTML §6 recommends using the native attribute in
+ * preference to the ARIA equivalent, so restating the same value via `aria-*`
+ * is superfluous.
+ *
+ * @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 redundantly restates an equivalent HTML attribute.
+ */
+export const checkingRedundantAriaProp = ({ attr, propSpecs, attrSpecs }) => t => {
+    if (!attrSpecs) {
+        return;
+    }
+    if (attr.isDynamicValue) {
+        return;
+    }
+    const propSpec = propSpecs.find(p => p.name === attr.name);
+    if (!propSpec?.equivalentHtmlAttrs) {
+        return;
+    }
+    for (const equivalentHtmlAttr of propSpec.equivalentHtmlAttrs) {
+        const eligibility = resolveAttrEligibility(equivalentHtmlAttr.htmlAttrName, attr.ownerElement, attrSpecs);
+        // Skip only when the native attribute doesn't apply to this element at all
+        // (unknown name, case mismatch, or an unmet condition) — mirrors the old
+        // `invalidType === 'non-existent'` check. `noUse` still proceeds: an
+        // explicitly-forbidden native attribute can still be "implicit" for
+        // equivalence purposes.
+        if (eligibility.status === 'unknown' ||
+            eligibility.status === 'case-mismatch' ||
+            eligibility.status === 'condition-not-met') {
+            continue;
+        }
+        if (!attr.ownerElement.hasAttribute(equivalentHtmlAttr.htmlAttrName)) {
+            continue;
+        }
+        const value = attr.value.trim().toLowerCase();
+        const targetAttrValue = attr.ownerElement.getAttribute(equivalentHtmlAttr.htmlAttrName);
+        if ((equivalentHtmlAttr.value == null && targetAttrValue === value) || equivalentHtmlAttr.value === value) {
+            return {
+                scope: attr,
+                message: t('{0} has {1}', t('the "{0*}" {1}', attr.name, `ARIA ${propSpec.type}`), t('the same {0} as {1}', 'semantics', t('{0} or {1}', t('the current "{0}" {1}', equivalentHtmlAttr.htmlAttrName, 'attribute'), t('the implicit "{0}" {1}', equivalentHtmlAttr.htmlAttrName, 'attribute')))),
+            };
+        }
+    }
+};

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

@@ -9,6 +9,10 @@ import { type ARIAProperty, type ARIARole } from '@markuplint/ml-spec';
  * properties. Implicit roles are skipped since the browser provides default semantics.
  * Alternative native HTML attributes that satisfy the requirement are also considered.
  *
+ * If a property declares `requiredCondition: 'focusable'` (currently only `separator`'s
+ * `aria-valuenow`), the requirement is gated by `mayBeFocusable`: a non-focusable
+ * separator no longer reports a missing `aria-valuenow`.
+ *
  * @param el - The element node to inspect for required properties.
  * @param role - The computed ARIA role (with an optional `isImplicit` flag).
  * @param propSpecs - The list of ARIA property specifications for type lookup.

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

@@ -1,4 +1,4 @@
-import { ARIA_RECOMMENDED_VERSION, getARIA } from '@markuplint/ml-spec';
+import { ARIA_RECOMMENDED_VERSION, getARIA, mayBeFocusable, } from '@markuplint/ml-spec';
 /**
  * Checks whether all required ARIA properties for the element's computed role are present.
  *
@@ -7,6 +7,10 @@ import { ARIA_RECOMMENDED_VERSION, getARIA } from '@markuplint/ml-spec';
  * properties. Implicit roles are skipped since the browser provides default semantics.
  * Alternative native HTML attributes that satisfy the requirement are also considered.
  *
+ * If a property declares `requiredCondition: 'focusable'` (currently only `separator`'s
+ * `aria-valuenow`), the requirement is gated by `mayBeFocusable`: a non-focusable
+ * separator no longer reports a missing `aria-valuenow`.
+ *
  * @param el - The element node to inspect for required properties.
  * @param role - The computed ARIA role (with an optional `isImplicit` flag).
  * @param propSpecs - The list of ARIA property specifications for type lookup.
@@ -19,8 +23,17 @@ export const checkingRequiredProp = ({ el, role, propSpecs }) => t => {
     if (role.isImplicit) {
         return;
     }
-    const requiredProps = role.ownedProperties.filter(s => s.required).map(s => s.name);
-    for (const requiredProp of requiredProps) {
+    const requiredProps = role.ownedProperties.filter(s => {
+        if (!s.required)
+            return false;
+        // `requiredCondition: 'focusable'` makes the property required only when the
+        // element may be focusable (e.g. `separator`'s `aria-valuenow`).
+        if (s.requiredCondition === 'focusable' && !mayBeFocusable(el, el.ownerMLDocument.specs)) {
+            return false;
+        }
+        return true;
+    });
+    for (const { name: requiredProp } of requiredProps) {
         const has = el.attributes.some(attr => {
             const attrName = attr.name.toLowerCase();
             return attrName === requiredProp;

package/lib/wai-aria/checkings/role-supports-aria-prop.d.ts

@@ -0,0 +1,20 @@
+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 supported by the element's
+ * computed role, per the role's WAI-ARIA definition (`ownedProperties`).
+ *
+ * When the element has no computed role, there is nothing to check here —
+ * a role-less element with `aria-*` restrictions is `element-supports-aria-prop`'s
+ * concern instead.
+ *
+ * @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.
+ * @returns A violation if the property is not supported by the given role.
+ */
+export declare const checkingRoleSupportsAriaProp: AttrChecker<boolean, Options, {
+    role: ARIARole | null;
+    propSpecs: readonly ARIAProperty[];
+}>;

package/lib/wai-aria/checkings/role-supports-aria-prop.js

@@ -0,0 +1,30 @@
+/**
+ * Checks whether an ARIA property or state is supported by the element's
+ * computed role, per the role's WAI-ARIA definition (`ownedProperties`).
+ *
+ * When the element has no computed role, there is nothing to check here —
+ * a role-less element with `aria-*` restrictions is `element-supports-aria-prop`'s
+ * concern instead.
+ *
+ * @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.
+ * @returns A violation if the property is not supported by the given role.
+ */
+export const checkingRoleSupportsAriaProp = ({ attr, role, propSpecs }) => t => {
+    if (!/^aria-/i.test(attr.name)) {
+        return;
+    }
+    if (!role) {
+        return;
+    }
+    const statesAndProp = role.ownedProperties.find(p => p.name === attr.name);
+    if (statesAndProp) {
+        return;
+    }
+    const propSpec = propSpecs.find(p => p.name === attr.name);
+    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/tab-requires-tabpanel.d.ts

@@ -0,0 +1,19 @@
+import type { Options } from '../types.js';
+import type { ElementChecker } from '@markuplint/ml-core';
+import type { ARIARole } from '@markuplint/ml-spec';
+/**
+ * Checks that an active `tab` role element has a corresponding `tabpanel` role element.
+ *
+ * The correspondence is resolved the same way ARIA in HTML authors are expected to
+ * express it: the tab's `aria-controls` idref list points to a `tabpanel`, or some
+ * `tabpanel` element's `aria-labelledby` idref list points back at the tab's own `id`.
+ *
+ * @see https://www.w3.org/TR/wai-aria-1.3/#tab — "Authors MUST ensure that if a tab
+ * is active, a corresponding tabpanel that represents the active tab is rendered."
+ * @param el - The element node to inspect.
+ * @param role - The computed ARIA role of the element.
+ * @returns A violation if the active tab has no corresponding tabpanel.
+ */
+export declare const checkingTabRequiresTabpanel: ElementChecker<boolean, Options, {
+    role?: ARIARole | null;
+}>;

package/lib/wai-aria/checkings/tab-requires-tabpanel.js

@@ -0,0 +1,56 @@
+import { ARIA_RECOMMENDED_VERSION, getComputedRole } from '@markuplint/ml-spec';
+/**
+ * Checks that an active `tab` role element has a corresponding `tabpanel` role element.
+ *
+ * The correspondence is resolved the same way ARIA in HTML authors are expected to
+ * express it: the tab's `aria-controls` idref list points to a `tabpanel`, or some
+ * `tabpanel` element's `aria-labelledby` idref list points back at the tab's own `id`.
+ *
+ * @see https://www.w3.org/TR/wai-aria-1.3/#tab — "Authors MUST ensure that if a tab
+ * is active, a corresponding tabpanel that represents the active tab is rendered."
+ * @param el - The element node to inspect.
+ * @param role - The computed ARIA role of the element.
+ * @returns A violation if the active tab has no corresponding tabpanel.
+ */
+export const checkingTabRequiresTabpanel = ({ el, role }) => t => {
+    if (role?.name !== 'tab') {
+        return;
+    }
+    const selectedAttr = el.getAttributeNode('aria-selected');
+    if (!selectedAttr || selectedAttr.isDynamicValue || selectedAttr.value !== 'true') {
+        return;
+    }
+    const document = el.ownerMLDocument;
+    const ariaVersion = el.rule.options?.version ?? document.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;
+    const isTabpanel = (candidate) => getComputedRole(document.specs, candidate, ariaVersion).role?.name === 'tabpanel';
+    const controlsAttr = el.getAttributeNode('aria-controls');
+    if (controlsAttr && !controlsAttr.isDynamicValue) {
+        const hasControlledTabpanel = controlsAttr.value
+            .split(/\s+/)
+            .filter(Boolean)
+            .some(id => {
+            const target = document.getElementById(id);
+            return !!target && isTabpanel(target);
+        });
+        if (hasControlledTabpanel) {
+            return;
+        }
+    }
+    const idAttr = el.getAttributeNode('id');
+    if (idAttr && !idAttr.isDynamicValue) {
+        const tabId = idAttr.value;
+        const hasLabellingTabpanel = [...document.querySelectorAll('[aria-labelledby]')].some(candidate => {
+            const labelledbyAttr = candidate.getAttributeNode('aria-labelledby');
+            if (!labelledbyAttr || labelledbyAttr.isDynamicValue)
+                return false;
+            return labelledbyAttr.value.split(/\s+/).includes(tabId) && isTabpanel(candidate);
+        });
+        if (hasLabellingTabpanel) {
+            return;
+        }
+    }
+    return {
+        scope: el,
+        message: t('{0} requires {1}', t('an active "{0*}" {1}', 'tab', 'role'), t('a corresponding "{0*}" {1}', 'tabpanel', 'role')),
+    };
+};

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

@@ -9,6 +9,7 @@ export const defaultOptions = {
     checkingAllowedAccessibilityChildRoles: true,
     checkingRequiredOwnedElements: true,
     checkingRequiredAccessibilityParentRole: true,
+    checkingTabRequiresTabpanel: true,
     checkingPresentationalChildren: false,
     checkingInteractionInHidden: false,
     disallowSetImplicitRole: true,

package/lib/wai-aria/types.d.ts

@@ -23,6 +23,8 @@ export type Options = {
     checkingRequiredOwnedElements: boolean;
     /** Whether to verify "Required Accessibility Parent Role" (ARIA 1.3 name) / "Required Context Role" (ARIA 1.2 name). */
     checkingRequiredAccessibilityParentRole: boolean;
+    /** Whether to verify that an active `tab` role has a corresponding `tabpanel` role. */
+    checkingTabRequiresTabpanel: boolean;
     /** Whether to warn when ARIA attributes are set on descendants of presentational-children roles. */
     checkingPresentationalChildren: boolean;
     /** Whether to warn about focusable interactive elements hidden via `aria-hidden`. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/rules",
-	"version": "5.0.0-rc.2",
+	"version": "5.0.0-rc.5",
 	"description": "Built-in rules of markuplint",
 	"repository": {
 		"type": "git",
@@ -10,7 +10,7 @@
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
 	"license": "MIT",
 	"engines": {
-		"node": ">=22"
+		"node": ">=24"
 	},
 	"type": "module",
 	"exports": {
@@ -31,12 +31,13 @@
 		"./lib/permitted-contents/debug.js": "./lib/permitted-contents/debug.browser.js"
 	},
 	"dependencies": {
-		"@markuplint/html-spec": "5.0.0-rc.2",
-		"@markuplint/ml-core": "5.0.0-rc.2",
-		"@markuplint/ml-spec": "5.0.0-rc.2",
-		"@markuplint/selector": "5.0.0-rc.2",
-		"@markuplint/shared": "5.0.0-rc.2",
-		"@markuplint/types": "5.0.0-rc.2",
+		"@markuplint/html-spec": "5.0.0-rc.5",
+		"@markuplint/ml-config": "5.0.0-rc.5",
+		"@markuplint/ml-core": "5.0.0-rc.5",
+		"@markuplint/ml-spec": "5.0.0-rc.5",
+		"@markuplint/selector": "5.0.0-rc.5",
+		"@markuplint/shared": "5.0.0-rc.5",
+		"@markuplint/types": "5.0.0-rc.5",
 		"@mdn/browser-compat-data": "^7.3.2",
 		"@types/debug": "4.1.13",
 		"ansi-colors": "4.1.3",
@@ -44,7 +45,7 @@
 		"chrono-node": "2.9.0",
 		"debug": "4.4.3",
 		"image-size": "^2.0.2",
-		"type-fest": "5.5.0"
+		"type-fest": "5.6.0"
 	},
-	"gitHead": "e43763858d9234c417053becc73dbd088c1e7ea6"
+	"gitHead": "8d87463af2ff3f1b83fb28da20f1819362cf3555"
 }