@markuplint/rules 4.11.2 → 5.0.0-alpha.0

package/lib/wai-aria/checkings/required-owned-elements.js

@@ -1,14 +1,23 @@
-import { getComputedRole, isRequiredOwnedElement } from '@markuplint/ml-spec';
+import { ARIA_RECOMMENDED_VERSION, getComputedRole, isRequiredOwnedElement, isTransparentForOwnership, } from '@markuplint/ml-spec';
 /**
- * Required Owned Elements
+ * Checks whether an element with a role that has "Allowed Accessibility Child Roles"
+ * (called "Required Owned Elements" in ARIA 1.2) actually contains children
+ * with the expected roles.
+ *
+ * For example, a `list` role must own at least one element with the `listitem` role.
+ * This checker respects `aria-busy="true"` (which signals that content is still loading),
+ * preprocessor blocks, and mutable children from template engines.
  *
  * @see https://w3c.github.io/aria/#mustContain
+ * @param el - The element node to inspect for allowed accessibility child roles.
+ * @param role - The computed ARIA role of the element, which defines allowed accessibility child roles.
+ * @returns A violation if the role requires owned elements and none are found.
  */
 export const checkingRequiredOwnedElements = ({ el, role }) => t => {
     if (!role) {
         return;
     }
-    if (role.requiredOwnedElements.length === 0) {
+    if (role.allowedAccessibilityChildRoles.length === 0) {
         return;
     }
     /**
@@ -25,22 +34,8 @@ export const checkingRequiredOwnedElements = ({ el, role }) => t => {
         return;
     }
     // TODO: Needs to resolve `aria-own`
-    const children = [...el.childNodes].map(child => {
-        if (child.is(child.ELEMENT_NODE)) {
-            if (child.matches('[aria-busy="true" i]')) {
-                return [child, 'BUSY'];
-            }
-            const computedChild = getComputedRole(child.ownerMLDocument.specs, child, child.rule.options.version);
-            if (role.requiredOwnedElements.some(ownedRole => isRequiredOwnedElement(computedChild.el, computedChild.role, ownedRole, child.ownerMLDocument.specs, child.rule.options.version))) {
-                return [child, 'REQUIRED'];
-            }
-            return [child, 'OTHER'];
-        }
-        else if (child.is(child.MARKUPLINT_PREPROCESSOR_BLOCK)) {
-            return [child, 'PB'];
-        }
-        return [null, 'NO_ELEMENT'];
-    });
+    const ariaVersion = el.rule.options?.version ?? el.ownerMLDocument.ruleCommonSettings?.ariaVersion ?? ARIA_RECOMMENDED_VERSION;
+    const children = classifyChildren(el, role, ariaVersion);
     if (children.some(([, type]) => type === 'BUSY')) {
         return;
     }
@@ -75,18 +70,25 @@ export const checkingRequiredOwnedElements = ({ el, role }) => t => {
     if (mayBeBeforeCreated(el)) {
         return {
             scope: el,
-            message: t('{0}. Or, {1}', t('{0} requires {1}', t('the {0}', 'child element'), role.requiredOwnedElements.length === 1 && role.requiredOwnedElements[0]
-                ? t('the "{0*}" {1}', role.requiredOwnedElements[0], 'role')
-                : t('the {0}', 'roles') + `: ${t(role.requiredOwnedElements)}`), t('require {0}', 'aria-busy="true"')),
+            message: t('{0}. Or, {1}', t('{0} requires {1}', t('the {0}', 'child element'), role.allowedAccessibilityChildRoles.length === 1 && role.allowedAccessibilityChildRoles[0]
+                ? t('the "{0*}" {1}', role.allowedAccessibilityChildRoles[0], 'role')
+                : t('the {0}', 'roles') + `: ${t(role.allowedAccessibilityChildRoles)}`), t('require {0}', 'aria-busy="true"')),
         };
     }
     return {
         scope: el,
-        message: t('{0} expects {1}', t('the "{0*}" {1}', role.name, 'role'), role.requiredOwnedElements.length === 1 && role.requiredOwnedElements[0]
-            ? t('the "{0*}" {1}', role.requiredOwnedElements[0], 'role')
-            : t('the {0}', 'roles') + `: ${t(role.requiredOwnedElements)}`),
+        message: t('{0} expects {1}', t('the "{0*}" {1}', role.name, 'role'), role.allowedAccessibilityChildRoles.length === 1 && role.allowedAccessibilityChildRoles[0]
+            ? t('the "{0*}" {1}', role.allowedAccessibilityChildRoles[0], 'role')
+            : t('the {0}', 'roles') + `: ${t(role.allowedAccessibilityChildRoles)}`),
     };
 };
+/**
+ * Determines whether the element's children may not yet exist (e.g., empty or
+ * containing only `<script>` / `<template>` elements that could dynamically create content).
+ *
+ * @param el - The element to inspect.
+ * @returns `true` if the element is empty or only contains script/template children.
+ */
 function mayBeBeforeCreated(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el) {
@@ -97,3 +99,45 @@ el) {
         return ['script', 'template'].includes(child.localName);
     });
 }
+/**
+ * Classifies the child nodes of an element for "Allowed Accessibility Child Roles" validation.
+ *
+ * In ARIA 1.3, elements whose computed role is transparent for ownership
+ * (e.g., `generic`) are traversed recursively so that their descendants
+ * are evaluated as if they were direct children of the owning element.
+ *
+ * @param el - The parent element whose children to classify.
+ * @param role - The ARIA role of the parent, which defines allowed child roles.
+ * @param version - The WAI-ARIA version for version-gated transparency behavior.
+ * @returns An array of classified child nodes.
+ */
+function classifyChildren(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el, role, version) {
+    const result = [];
+    for (const child of el.childNodes) {
+        if (child.is(child.ELEMENT_NODE)) {
+            if (child.matches('[aria-busy="true" i]')) {
+                result.push([child, 'BUSY']);
+                continue;
+            }
+            const computedChild = getComputedRole(child.ownerMLDocument.specs, child, version);
+            if (role.allowedAccessibilityChildRoles.some(ownedRole => isRequiredOwnedElement(computedChild.el, computedChild.role, ownedRole, child.ownerMLDocument.specs, version))) {
+                result.push([child, 'REQUIRED']);
+                continue;
+            }
+            if (isTransparentForOwnership(computedChild.role?.name, version)) {
+                result.push(...classifyChildren(child, role, version));
+                continue;
+            }
+            result.push([child, 'OTHER']);
+        }
+        else if (child.is(child.MARKUPLINT_PREPROCESSOR_BLOCK)) {
+            result.push([child, 'PB']);
+        }
+        else {
+            result.push([null, 'NO_ELEMENT']);
+        }
+    }
+    return result;
+}

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

@@ -1,6 +1,19 @@
 import type { Options } from '../types.js';
 import type { ElementChecker } from '@markuplint/ml-core';
 import { type ARIAProperty, type ARIARole } from '@markuplint/ml-spec';
+/**
+ * Checks whether all required ARIA properties for the element's computed role are present.
+ *
+ * Each ARIA role may define required states and properties (e.g., `slider` requires
+ * `aria-valuenow`). This checker verifies that explicitly-set roles have their required
+ * properties. Implicit roles are skipped since the browser provides default semantics.
+ * Alternative native HTML attributes that satisfy the requirement are also considered.
+ *
+ * @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.
+ * @returns A violation if a required property is missing and no native alternative is present.
+ */
 export declare const checkingRequiredProp: ElementChecker<boolean, Options, {
     role?: (ARIARole & {
         isImplicit?: boolean;

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

@@ -1,4 +1,17 @@
-import { getARIA } from '@markuplint/ml-spec';
+import { ARIA_RECOMMENDED_VERSION, getARIA } from '@markuplint/ml-spec';
+/**
+ * Checks whether all required ARIA properties for the element's computed role are present.
+ *
+ * Each ARIA role may define required states and properties (e.g., `slider` requires
+ * `aria-valuenow`). This checker verifies that explicitly-set roles have their required
+ * properties. Implicit roles are skipped since the browser provides default semantics.
+ * Alternative native HTML attributes that satisfy the requirement are also considered.
+ *
+ * @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.
+ * @returns A violation if a required property is missing and no native alternative is present.
+ */
 export const checkingRequiredProp = ({ el, role, propSpecs }) => t => {
     if (!role) {
         return;
@@ -14,7 +27,10 @@ export const checkingRequiredProp = ({ el, role, propSpecs }) => t => {
         });
         if (!has) {
             const propSpec = propSpecs.find(p => p.name === requiredProp);
-            const elAriaSpec = getARIA(el.ownerMLDocument.specs, el.localName, el.namespaceURI, el.rule.options.version, el.matches.bind(el));
+            const ariaVersion = el.rule.options?.version ??
+                el.ownerMLDocument.ruleCommonSettings?.ariaVersion ??
+                ARIA_RECOMMENDED_VERSION;
+            const elAriaSpec = getARIA(el.ownerMLDocument.specs, el.localName, el.namespaceURI, ariaVersion, el.matches.bind(el));
             const alt = elAriaSpec?.properties === false
                 ? null
                 : (elAriaSpec?.properties?.without?.find(p => p.name === requiredProp)?.alt ?? null);

package/lib/wai-aria/checkings/value.d.ts

@@ -1,13 +1,36 @@
 import type { Options } from '../types.js';
 import type { AttrChecker } from '@markuplint/ml-core';
 import type { ARIAProperty, ARIARole } from '@markuplint/ml-spec';
+/**
+ * Checks whether the value of an ARIA property or state conforms to its expected type.
+ *
+ * ARIA properties have specific value types (token, token list, true/false, tristate,
+ * integer, number, string, ID reference, etc.). This checker validates the attribute
+ * value against the property's expected type and allowed enum values.
+ * Role-specific conditional value types are also considered.
+ *
+ * @param attr - The ARIA attribute node to inspect.
+ * @param role - The computed ARIA role, used to resolve conditional value types.
+ * @param propSpecs - The list of ARIA property specifications for value type lookup.
+ * @param booleanish - Whether the document supports booleanish attribute values (e.g., JSX).
+ * @returns A violation if the attribute value does not match the expected type.
+ */
 export declare const checkingValue: AttrChecker<boolean, Options, {
     role?: ARIARole | null;
     propSpecs: readonly ARIAProperty[];
     booleanish?: boolean;
 }>;
 /**
+ * Validates a raw ARIA value against the expected value type defined in the specification.
+ *
+ * Supports token, token list, string, ID reference, true/false, tristate,
+ * true/false/undefined, integer, and number value types.
  *
  * @see https://www.w3.org/TR/wai-aria-1.2/#propcharacteristic_value
+ * @param type - The ARIA value type (e.g., `"token"`, `"true/false"`, `"integer"`).
+ * @param value - The raw attribute value to validate.
+ * @param tokenEnum - The list of allowed token values for token-based types.
+ * @param booleanish - Whether empty string is accepted as a boolean `true` value.
+ * @returns `true` if the value is valid for the given type, `false` otherwise.
  */
 export declare function checkAriaValue(type: string, value: string, tokenEnum: readonly string[], booleanish?: boolean): boolean;

package/lib/wai-aria/checkings/value.js

@@ -1,3 +1,17 @@
+/**
+ * Checks whether the value of an ARIA property or state conforms to its expected type.
+ *
+ * ARIA properties have specific value types (token, token list, true/false, tristate,
+ * integer, number, string, ID reference, etc.). This checker validates the attribute
+ * value against the property's expected type and allowed enum values.
+ * Role-specific conditional value types are also considered.
+ *
+ * @param attr - The ARIA attribute node to inspect.
+ * @param role - The computed ARIA role, used to resolve conditional value types.
+ * @param propSpecs - The list of ARIA property specifications for value type lookup.
+ * @param booleanish - Whether the document supports booleanish attribute values (e.g., JSX).
+ * @returns A violation if the attribute value does not match the expected type.
+ */
 export const checkingValue = ({ attr, role, propSpecs, booleanish }) => t => {
     if (attr.isDynamicValue) {
         return;
@@ -15,6 +29,15 @@ export const checkingValue = ({ attr, role, propSpecs, booleanish }) => t => {
                 : ''),
     };
 };
+/**
+ * Validates an ARIA property value against its specification, considering role-specific conditional types.
+ *
+ * @param propSpec - The ARIA property specification, or `undefined` if the property is unknown.
+ * @param currentValue - The current attribute value to validate.
+ * @param role - The name of the computed role, used to resolve conditional value types.
+ * @param booleanish - Whether booleanish values (empty string as `true`) are accepted.
+ * @returns An object containing the validation result and, for enum types, the allowed values.
+ */
 function checkAria(propSpec, currentValue, role, booleanish) {
     if (!propSpec) {
         return {
@@ -40,8 +63,17 @@ function checkAria(propSpec, currentValue, role, booleanish) {
     };
 }
 /**
+ * Validates a raw ARIA value against the expected value type defined in the specification.
+ *
+ * Supports token, token list, string, ID reference, true/false, tristate,
+ * true/false/undefined, integer, and number value types.
  *
  * @see https://www.w3.org/TR/wai-aria-1.2/#propcharacteristic_value
+ * @param type - The ARIA value type (e.g., `"token"`, `"true/false"`, `"integer"`).
+ * @param value - The raw attribute value to validate.
+ * @param tokenEnum - The list of allowed token values for token-based types.
+ * @param booleanish - Whether empty string is accepted as a boolean `true` value.
+ * @returns `true` if the value is valid for the given type, `false` otherwise.
  */
 export function checkAriaValue(type, value, tokenEnum, booleanish) {
     switch (type) {

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

@@ -1,3 +1,13 @@
 import type { Options } from './types.js';
+/**
+ * WAI-ARIA rule for markuplint.
+ *
+ * Validates the correct usage of WAI-ARIA roles, states, and properties
+ * on HTML elements. This rule performs a comprehensive set of checks including
+ * role validity, property values, required owned elements, and conformance
+ * with the ARIA in HTML specification.
+ *
+ * Individual checks can be toggled on or off via the rule's options.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
 export default _default;

package/lib/wai-aria/index.js

@@ -13,10 +13,21 @@ import { checkingNoGlobalProp } from './checkings/no-global-prop.js';
 import { checkingNonExistentRole } from './checkings/non-existent-role.js';
 import { checkingPermittedRoles } from './checkings/permitted-roles.js';
 import { checkingPresentationalChildren } from './checkings/presentational-children.js';
+import { checkingRequiredAccessibilityParentRole } from './checkings/required-accessibility-parent-role.js';
 import { checkingRequiredOwnedElements } from './checkings/required-owned-elements.js';
 import { checkingRequiredProp } from './checkings/required-prop.js';
 import { checkingValue } from './checkings/value.js';
 import meta from './meta.js';
+/**
+ * WAI-ARIA rule for markuplint.
+ *
+ * Validates the correct usage of WAI-ARIA roles, states, and properties
+ * on HTML elements. This rule performs a comprehensive set of checks including
+ * role validity, property values, required owned elements, and conformance
+ * with the ARIA in HTML specification.
+ *
+ * Individual checks can be toggled on or off via the rule's options.
+ */
 export default createRule({
     meta: meta,
     defaultOptions: {
@@ -24,13 +35,15 @@ export default createRule({
         checkingDeprecatedRole: true,
         checkingDeprecatedProps: true,
         permittedAriaRoles: true,
+        checkingAllowedAccessibilityChildRoles: true,
         checkingRequiredOwnedElements: true,
+        checkingRequiredAccessibilityParentRole: true,
         checkingPresentationalChildren: false,
         checkingInteractionInHidden: false,
         disallowSetImplicitRole: true,
         disallowSetImplicitProps: true,
         disallowDefaultValue: false,
-        version: ARIA_RECOMMENDED_VERSION,
+        version: undefined,
     },
     async verify({ document, report, t }) {
         await document.walkOn('Element', el => {
@@ -50,8 +63,9 @@ export default createRule({
                 }
                 return;
             }
-            const computed = getComputedRole(document.specs, el, el.rule.options.version);
-            const { props: propSpecs } = ariaSpecs(document.specs, el.rule.options.version);
+            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);
             if (roleAttr) {
                 if (report(checkingNonExistentRole({ attr: roleAttr }))) {
                     return;
@@ -59,6 +73,9 @@ export default createRule({
                 if (report(checkingAbstractRole({ attr: roleAttr }))) {
                     return;
                 }
+                if (el.rule.options.checkingRequiredAccessibilityParentRole) {
+                    report(checkingRequiredAccessibilityParentRole({ el, computed }));
+                }
                 report(checkingRequiredProp({ el, role: computed.role, propSpecs }));
                 if (el.rule.options.checkingDeprecatedRole) {
                     report(checkingDeprecatedRole({ attr: roleAttr, role: computed.role }));
@@ -94,7 +111,8 @@ export default createRule({
                     report(checkingNoGlobalProp({ attr, propSpecs }));
                 }
             }
-            if (el.rule.options.checkingRequiredOwnedElements) {
+            if (el.rule.options.checkingAllowedAccessibilityChildRoles &&
+                el.rule.options.checkingRequiredOwnedElements) {
                 report(checkingRequiredOwnedElements({ el, role: computed.role }));
             }
             if (el.rule.options.checkingPresentationalChildren) {

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

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

package/lib/wai-aria/meta.js

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

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

@@ -1,14 +1,38 @@
 import type { ARIAVersion } from '@markuplint/ml-spec';
+/**
+ * Configuration options for the `wai-aria` rule.
+ *
+ * Each boolean flag enables or disables a specific WAI-ARIA validation check.
+ * The `version` field determines which ARIA specification version to validate against.
+ */
 export type Options = {
+    /** Whether to validate ARIA property and state values against their expected types. */
     checkingValue: boolean;
+    /** Whether to report usage of deprecated ARIA properties and states. */
     checkingDeprecatedProps: boolean;
+    /** Whether to report usage of deprecated ARIA roles. */
     checkingDeprecatedRole: boolean;
+    /** Whether to enforce the list of permitted ARIA roles for each element. */
     permittedAriaRoles: boolean;
+    /** Whether to verify "Allowed Accessibility Child Roles" (ARIA 1.3 name). */
+    checkingAllowedAccessibilityChildRoles: boolean;
+    /**
+     * @deprecated Use `checkingAllowedAccessibilityChildRoles` instead.
+     * Retained for backward compatibility.
+     */
     checkingRequiredOwnedElements: boolean;
+    /** Whether to verify "Required Accessibility Parent Role" (ARIA 1.3 name) / "Required Context Role" (ARIA 1.2 name). */
+    checkingRequiredAccessibilityParentRole: 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`. */
     checkingInteractionInHidden: boolean;
+    /** Whether to disallow explicitly setting a role that matches the element's implicit role. */
     disallowSetImplicitRole: boolean;
+    /** Whether to disallow explicitly setting ARIA properties that duplicate the element's native semantics. */
     disallowSetImplicitProps: boolean;
+    /** Whether to disallow explicitly setting an ARIA property to its default value. */
     disallowDefaultValue: boolean;
-    version: ARIAVersion;
+    /** The WAI-ARIA specification version to validate against. */
+    version?: ARIAVersion;
 };

package/package.json

@@ -1,10 +1,13 @@
 {
 	"name": "@markuplint/rules",
-	"version": "4.11.2",
+	"version": "5.0.0-alpha.0",
 	"description": "Built-in rules of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
 	"license": "MIT",
+	"engines": {
+		"node": ">=22"
+	},
 	"type": "module",
 	"exports": {
 		".": {
@@ -24,18 +27,20 @@
 		"./lib/permitted-contents/debug.js": "./lib/permitted-contents/debug.browser.js"
 	},
 	"dependencies": {
-		"@markuplint/html-spec": "4.16.1",
-		"@markuplint/ml-core": "4.13.2",
-		"@markuplint/ml-spec": "4.10.1",
-		"@markuplint/selector": "4.7.7",
-		"@markuplint/shared": "4.4.12",
-		"@markuplint/types": "4.8.1",
+		"@markuplint/html-spec": "5.0.0-alpha.0",
+		"@markuplint/ml-core": "5.0.0-alpha.0",
+		"@markuplint/ml-spec": "5.0.0-alpha.0",
+		"@markuplint/selector": "5.0.0-alpha.0",
+		"@markuplint/shared": "5.0.0-alpha.0",
+		"@markuplint/types": "5.0.0-alpha.0",
+		"@mdn/browser-compat-data": "^7.3.2",
 		"@types/debug": "4.1.12",
-		"@ungap/structured-clone": "1.3.0",
 		"ansi-colors": "4.1.3",
-		"chrono-node": "2.8.4",
+		"browserslist": "^4.28.1",
+		"chrono-node": "2.9.0",
 		"debug": "4.4.3",
-		"type-fest": "4.41.0"
+		"image-size": "^2.0.2",
+		"type-fest": "5.4.4"
 	},
-	"gitHead": "6213ea30269ef404f030e67bbcc7fc7443ec1060"
+	"gitHead": "13dcfc84ec83d87360c720e253383b60767e1b56"
 }

package/schema.json

@@ -24,6 +24,9 @@
 				"class-naming": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/class-naming/schema.json"
 				},
+				"correct-aspect-ratio": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/correct-aspect-ratio/schema.json"
+				},
 				"deprecated-attr": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/deprecated-attr/schema.json"
 				},
@@ -57,6 +60,9 @@
 				"landmark-roles": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/landmark-roles/schema.json"
 				},
+				"link-types": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/link-types/schema.json"
+				},
 				"neighbor-popovers": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/neighbor-popovers/schema.json"
 				},
@@ -87,6 +93,9 @@
 				"no-refer-to-non-existent-id": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/no-refer-to-non-existent-id/schema.json"
 				},
+				"no-unsupported-features": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/no-unsupported-features/schema.json"
+				},
 				"no-use-event-handler-attr": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/no-use-event-handler-attr/schema.json"
 				},
@@ -96,12 +105,18 @@
 				"placeholder-label-option": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/placeholder-label-option/schema.json"
 				},
+				"redundant-accessible-name": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/redundant-accessible-name/schema.json"
+				},
 				"require-accessible-name": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/require-accessible-name/schema.json"
 				},
 				"require-datetime": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/require-datetime/schema.json"
 				},
+				"require-dialog-autofocus": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/require-dialog-autofocus/schema.json"
+				},
 				"required-attr": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/required-attr/schema.json"
 				},
@@ -111,6 +126,9 @@
 				"required-h1": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/required-h1/schema.json"
 				},
+				"srcset-sizes-constraint": {
+					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/srcset-sizes-constraint/schema.json"
+				},
 				"table-row-column-alignment": {
 					"$ref": "https://raw.githubusercontent.com/markuplint/markuplint/main/packages/%40markuplint/rules/src/table-row-column-alignment/schema.json"
 				},