@markuplint/rules 4.11.2 → 5.0.0-alpha.0

package/lib/invalid-attr/index.d.ts

@@ -1,37 +1,45 @@
 import type { AttributeType } from '@markuplint/ml-spec';
+import type { Pattern } from '@markuplint/types';
+/**
+ * Configuration options for the `invalid-attr` rule.
+ */
 type Option = {
     /**
+     * Attributes to allow beyond what the spec permits.
+     * Can override spec-level restrictions such as `noUse`.
+     *
      * @since 3.7.0
      */
-    allowAttrs?: (string | Attr)[] | Record<string, ValueRule>;
+    allowAttrs?: (string | Attr)[] | Record<string, AttributeType | Pattern>;
     /**
+     * Attributes to disallow in addition to spec restrictions.
+     *
      * @since 3.7.0
      */
-    disallowAttrs?: (string | Attr)[] | Record<string, ValueRule>;
+    disallowAttrs?: (string | Attr)[] | Record<string, AttributeType | Pattern>;
+    /** Attribute name prefix(es) to ignore during validation. */
     ignoreAttrNamePrefix?: string | string[];
+    /** Whether to allow additional properties for pretender elements (defaults to `true`). */
     allowToAddPropertiesForPretender?: boolean;
-    /**
-     * @deprecated Since version 3.7.0. Use `allowAttrs` or `disallowAttrs` instead.
-     * This option (`attr`) is now considered ambiguous and may lead to confusion.
-     * Please use the more explicit `allowAttrs` or `disallowAttrs` option
-     * to specify allowed attributes for the `invalid-attr` rule.
-     * @see {@link Option.allowAttrs}
-     * @see {@link Option.disallowAttrs}
-     */
-    attrs?: Record<string, ValueRule | {
-        disallowed: true;
-    }>;
 };
+/**
+ * Describes a single attribute with its name and expected value constraint.
+ */
 type Attr = {
+    /** The attribute name. */
     name: string;
-    value: AttributeType | ValueRule;
-};
-type ValueRule = {
-    enum: [string, ...string[]];
-} | {
-    pattern: string;
-} | {
-    type: AttributeType;
+    /** The expected attribute value type or validation rule. */
+    value: AttributeType | Pattern;
 };
+/**
+ * Rule that validates attributes against the HTML spec, allowed lists,
+ * and disallowed lists.
+ *
+ * Checks each attribute for: existence in the spec, correct value type,
+ * allowed/disallowed overrides from configuration, and typo suggestions
+ * via candidate matching. Supports `allowAttrs` and `disallowAttrs`.
+ * Non-existent attributes on elements that allow additional properties
+ * (pretenders) can be optionally permitted.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Option>>;
 export default _default;

package/lib/invalid-attr/index.js

@@ -1,9 +1,20 @@
 import { createRule, getAttrSpecs, getSpec } from '@markuplint/ml-core';
+import { check, isEnum, isPattern } from '@markuplint/types';
 import { attrCheck } from '../attr-check.js';
 import { log as ruleLog } from '../debug.js';
-import { isValidAttr, match } from '../helpers.js';
+import { isValidAttr } from '../helpers.js';
 import meta from './meta.js';
 const log = ruleLog.extend('invalid-attr');
+/**
+ * Rule that validates attributes against the HTML spec, allowed lists,
+ * and disallowed lists.
+ *
+ * Checks each attribute for: existence in the spec, correct value type,
+ * allowed/disallowed overrides from configuration, and typo suggestions
+ * via candidate matching. Supports `allowAttrs` and `disallowAttrs`.
+ * Non-existent attributes on elements that allow additional properties
+ * (pretenders) can be optionally permitted.
+ */
 export default createRule({
     meta: meta,
     defaultOptions: {},
@@ -47,19 +58,15 @@ export default createRule({
                 if (Array.isArray(attr.rule.options.allowAttrs)) {
                     for (const allowAttr of attr.rule.options.allowAttrs) {
                         if (typeof allowAttr === 'string') {
-                            allowAttrs[allowAttr] = { type: 'Any' };
+                            allowAttrs[allowAttr] = 'Any';
                             continue;
                         }
-                        if (isValueRule(allowAttr.value)) {
-                            allowAttrs[allowAttr.name] = allowAttr.value;
-                            continue;
-                        }
-                        allowAttrs[allowAttr.name] = { type: allowAttr.value };
+                        allowAttrs[allowAttr.name] = allowAttr.value;
                     }
                 }
                 else {
-                    for (const [attrName, valueRule] of Object.entries(attr.rule.options.allowAttrs)) {
-                        allowAttrs[attrName] = valueRule;
+                    for (const [attrName, attrType] of Object.entries(attr.rule.options.allowAttrs)) {
+                        allowAttrs[attrName] = attrType;
                     }
                 }
             }
@@ -67,99 +74,50 @@ export default createRule({
                 if (Array.isArray(attr.rule.options.disallowAttrs)) {
                     for (const disallowAttr of attr.rule.options.disallowAttrs) {
                         if (typeof disallowAttr === 'string') {
-                            disallowAttrs[disallowAttr] = { type: 'Any' };
+                            disallowAttrs[disallowAttr] = 'Any';
                             continue;
                         }
-                        if (isValueRule(disallowAttr.value)) {
-                            disallowAttrs[disallowAttr.name] = disallowAttr.value;
-                            continue;
-                        }
-                        disallowAttrs[disallowAttr.name] = { type: disallowAttr.value };
+                        disallowAttrs[disallowAttr.name] = disallowAttr.value;
                     }
                 }
                 else {
-                    for (const [attrName, valueRule] of Object.entries(attr.rule.options.disallowAttrs)) {
-                        disallowAttrs[attrName] = valueRule;
-                    }
-                }
-            }
-            if (attr.rule.options.attrs) {
-                for (const [attrName, valueRule] of Object.entries(attr.rule.options.attrs)) {
-                    if ('disallowed' in valueRule) {
-                        disallowAttrs[attrName] = { type: 'Any' };
-                    }
-                    else {
-                        allowAttrs[attrName] = valueRule;
+                    for (const [attrName, attrType] of Object.entries(attr.rule.options.disallowAttrs)) {
+                        disallowAttrs[attrName] = attrType;
                     }
                 }
             }
             const allowValue = allowAttrs[name] ?? null;
             const disallowValue = disallowAttrs[name] ?? null;
-            if (allowValue) {
-                if ('enum' in allowValue) {
-                    invalid = attrCheck(t, name.toLowerCase(), value, true, {
-                        name,
-                        type: {
-                            enum: allowValue.enum,
-                        },
-                        description: '',
-                    });
-                }
-                else if ('pattern' in allowValue) {
-                    if (!match(value, allowValue.pattern)) {
-                        invalid = {
-                            invalidType: 'invalid-value',
-                            message: t('{0} is unmatched with the below patterns: {1}', t('the "{0*}" {1}', name, 'attribute'), allowValue.pattern),
-                        };
-                    }
-                }
-                else if ('type' in allowValue) {
-                    invalid = attrCheck(t, name, value, true, { name, type: allowValue.type, description: '' });
-                }
+            if (allowValue !== null) {
+                invalid = attrCheck(t, name, value, true, {
+                    name,
+                    type: allowValue,
+                    description: '',
+                });
             }
-            else if (disallowValue) {
-                if ('enum' in disallowValue) {
-                    const checkResult = attrCheck(t, name.toLowerCase(), value, true, {
-                        name,
-                        type: {
-                            enum: disallowValue.enum,
-                        },
-                        description: '',
-                    });
-                    if (checkResult === false) {
-                        invalid = {
-                            invalidType: 'invalid-value',
-                            message: t('{0} is disallowed to accept the following values: {1}', t('the "{0*}" {1}', name, 'attribute'), t(disallowValue.enum)),
-                        };
-                    }
+            else if (disallowValue !== null) {
+                if (disallowValue === 'Any') {
+                    invalid = {
+                        invalidType: 'non-existent',
+                        message: t('{0} is disallowed', t('the "{0*}" {1}', name, 'attribute')),
+                    };
                 }
-                else if ('pattern' in disallowValue) {
-                    if (match(value, disallowValue.pattern)) {
-                        invalid = {
-                            invalidType: 'invalid-value',
-                            message: t('{0} is matched with the below disallowed patterns: {1}', t('the "{0*}" {1}', name, 'attribute'), disallowValue.pattern),
-                        };
-                    }
-                }
-                else if ('type' in disallowValue) {
-                    if (disallowValue.type === 'Any') {
-                        invalid = {
-                            invalidType: 'non-existent',
-                            message: t('{0} is disallowed', t('the "{0*}" {1}', name, 'attribute')),
-                        };
-                    }
-                    else {
-                        const checkResult = attrCheck(t, name, value, true, {
+                else {
+                    const checkResult = isPattern(disallowValue)
+                        ? check(value, disallowValue)
+                        : attrCheck(t, name, value, true, {
                             name,
-                            type: disallowValue.type,
+                            type: disallowValue,
                             description: '',
                         });
-                        if (checkResult === false) {
-                            invalid = {
-                                invalidType: 'invalid-value',
-                                message: t('{0} is disallowed', t('{0} of {1}', t('the {0}', 'type'), t('the "{0*}" {1}', name, 'attribute'))),
-                            };
-                        }
+                    const isMatched = isPattern(disallowValue)
+                        ? checkResult.matched
+                        : checkResult === false;
+                    if (isMatched) {
+                        invalid = {
+                            invalidType: 'invalid-value',
+                            message: createDisallowMessage(t, name, disallowValue),
+                        };
                     }
                 }
             }
@@ -216,29 +174,22 @@ export default createRule({
         });
     },
 });
-function isValueRule(
+/**
+ * Creates an appropriate disallow message based on the type structure.
+ *
+ * @param t - The i18n translator
+ * @param name - The attribute name
+ * @param type - The attribute type or pattern
+ * @returns A localized message string
+ */
+function createDisallowMessage(t, name, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-value) {
-    if (typeof value === 'string') {
-        return false;
-    }
-    if ('enum' in value) {
-        if (Object.keys(value).length > 1) {
-            return false;
-        }
-        return true;
-    }
-    if ('token' in value) {
-        return false;
-    }
-    if ('pattern' in value) {
-        return true;
-    }
-    if (value.type === 'integer' || value.type === 'float') {
-        return false;
+type) {
+    if (isPattern(type)) {
+        return t('{0} is matched with the below disallowed patterns: {1}', t('the "{0*}" {1}', name, 'attribute'), type.pattern);
     }
-    if (Object.keys(value).length > 1) {
-        return false;
+    if (typeof type !== 'string' && isEnum(type)) {
+        return t('{0} is disallowed to accept the following values: {1}', t('the "{0*}" {1}', name, 'attribute'), t(type.enum));
     }
-    return true;
+    return t('{0} is disallowed', t('{0} of {1}', t('the {0}', 'type'), t('the "{0*}" {1}', name, 'attribute')));
 }

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

@@ -1,3 +1,4 @@
+/** Rule metadata for `invalid-attr`: categorized as a validation rule. */
 declare const _default: {
     readonly category: "validation";
 };

package/lib/invalid-attr/meta.js

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

package/lib/label-has-control/index.d.ts

@@ -1,2 +1,9 @@
+/**
+ * Rule that validates `<label>` elements are properly associated with form controls.
+ *
+ * Checks that each label either wraps a control or has a `for` attribute,
+ * and warns when a label contains more than one form control (only the first
+ * is associated per the HTML spec).
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
 export default _default;

package/lib/label-has-control/index.js

@@ -1,6 +1,17 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
+/**
+ * CSS selector that matches form control elements eligible for label association.
+ * Excludes hidden inputs since they do not need labels.
+ */
 const controlSelector = ["input:not([type='hidden' i])", 'select', 'textarea'].join(',');
+/**
+ * Rule that validates `<label>` elements are properly associated with form controls.
+ *
+ * Checks that each label either wraps a control or has a `for` attribute,
+ * and warns when a label contains more than one form control (only the first
+ * is associated per the HTML spec).
+ */
 export default createRule({
     meta: meta,
     defaultSeverity: 'warning',

package/lib/label-has-control/meta.d.ts

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

package/lib/label-has-control/meta.js

@@ -1,3 +1,4 @@
+/** Rule metadata for the `label-has-control` rule, categorized as accessibility. */
 export default {
     category: 'a11y',
 };

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

@@ -1,8 +1,22 @@
+/**
+ * Configuration options for the landmark-roles rule.
+ */
 type Options = {
+    /** Landmark roles to exclude from validation. */
     ignoreRoles: Roles[];
+    /** Whether to require a unique accessible name when duplicate landmark roles exist. */
     labelEachArea: boolean;
 };
+/** Landmark roles that should appear at the top level of the document. */
 type TopLevelRoles = 'banner' | 'main' | 'complementary' | 'contentinfo';
+/** All recognized ARIA landmark roles for this rule. */
 type Roles = TopLevelRoles | 'form' | 'navigation' | 'region';
+/**
+ * Rule that validates proper usage of ARIA landmark roles.
+ *
+ * Checks that `banner`, `main`, `complementary`, and `contentinfo` landmarks are
+ * top-level (not nested inside other landmarks), and that when duplicate landmarks
+ * of the same role exist, each has a unique accessible name.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
 export default _default;

package/lib/landmark-roles/index.js

@@ -1,5 +1,6 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
+/** CSS selectors used to identify elements with each landmark role. */
 const selectors = {
     complementary: ['[role="complementary"]', 'aside'],
     contentinfo: ['[role="contentinfo"]'],
@@ -9,7 +10,15 @@ const selectors = {
     navigation: ['[role="navigation"]', 'nav'],
     region: ['[role="region"]', 'section[aria-labelledby]', 'section[aria-label]', 'section[title]'],
 };
+/** Roles that are required to be top-level landmarks per WAI-ARIA practices. */
 const topLevelRoles = ['banner', 'main', 'complementary', 'contentinfo'];
+/**
+ * Rule that validates proper usage of ARIA landmark roles.
+ *
+ * Checks that `banner`, `main`, `complementary`, and `contentinfo` landmarks are
+ * top-level (not nested inside other landmarks), and that when duplicate landmarks
+ * of the same role exist, each has a unique accessible name.
+ */
 export default createRule({
     meta: meta,
     defaultSeverity: 'warning',
@@ -105,11 +114,23 @@ export default createRule({
         }
     },
 });
+/**
+ * Collects all UUIDs of elements that have landmark roles.
+ *
+ * @param roleset - The mapping of roles to their matched elements.
+ * @returns A flat array of UUIDs for all landmark role elements.
+ */
 function landmarkRoleElementUUIDList(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 roleset) {
     return Object.values(roleset).flatMap(elements => elements.map(element => element.uuid));
 }
+/**
+ * Checks whether an element has an accessible label via `aria-label` or `aria-labelledby`.
+ *
+ * @param el - The landmark element to check.
+ * @returns `true` if the element has an accessible name, `false` otherwise.
+ */
 function hasLabel(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el) {

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

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

package/lib/landmark-roles/meta.js

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

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

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

package/lib/link-types/index.js

@@ -0,0 +1,180 @@
+import { createRule } from '@markuplint/ml-core';
+import { DEF_LINK_TYPE_WHATWG, ALLOWED_LINK_TYPE_MICROFORMATS, DEF_LINK_TYPE_MICROFORMATS_DROPPED, DEF_LINK_TYPE_MICROFORMATS_DROPPED_WITHOUT_PREJUDICE, DEF_LINK_TYPE_MICROFORMATS_REJECTED, DEF_LINK_TYPE_MICROFORMATS_NON_HTML_REL_VALUES, } from '@markuplint/types';
+import meta from './meta.js';
+const TARGET_ELEMENTS = new Set(['link', 'a', 'area', 'form']);
+/**
+ * Rule that validates link type keywords in the `rel` attribute on
+ * `<link>`, `<a>`, `<area>`, and `<form>` elements against the WHATWG
+ * standard and optionally the Microformats registry.
+ */
+export default createRule({
+    meta: meta,
+    defaultOptions: {
+        allowMicroformats: false,
+    },
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            if (!TARGET_ELEMENTS.has(el.localName)) {
+                return;
+            }
+            const relAttr = el.getAttributeNode('rel');
+            if (!relAttr) {
+                return;
+            }
+            if (relAttr.isDynamicValue) {
+                return;
+            }
+            const tokenList = relAttr.tokenList;
+            if (!tokenList || tokenList.length === 0) {
+                return;
+            }
+            const context = getElementContext(el);
+            if (!context) {
+                return;
+            }
+            const options = el.rule.options;
+            for (const tokenInfo of tokenList.allTokens()) {
+                const keyword = tokenInfo.raw;
+                const keywordLower = keyword.toLowerCase();
+                const message = validateKeyword(keywordLower, context, options, t);
+                if (message) {
+                    report({
+                        scope: el,
+                        line: tokenInfo.startLine,
+                        col: tokenInfo.startCol,
+                        raw: keyword,
+                        message,
+                    });
+                }
+            }
+        });
+    },
+});
+function getElementContext(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el) {
+    const tagName = el.localName;
+    switch (tagName) {
+        case 'link': {
+            if (el.closest('body') !== null) {
+                return 'body-link';
+            }
+            return 'link';
+        }
+        case 'a':
+        case 'area': {
+            return 'a-area';
+        }
+        case 'form': {
+            return 'form';
+        }
+        default: {
+            return null;
+        }
+    }
+}
+function validateKeyword(keyword, context, options, t) {
+    // Check WHATWG standard keywords
+    const whatwgDef = DEF_LINK_TYPE_WHATWG.find(def => def.keyword.toLowerCase() === keyword);
+    if (whatwgDef) {
+        return validateWhatwgKeyword(whatwgDef, context, t);
+    }
+    // Check dropped keywords
+    if (DEF_LINK_TYPE_MICROFORMATS_DROPPED.some(def => def.keyword.toLowerCase() === keyword)) {
+        return t('{0} is {1:c}', `"${keyword}"`, 'dropped');
+    }
+    // Check dropped without prejudice keywords
+    if (DEF_LINK_TYPE_MICROFORMATS_DROPPED_WITHOUT_PREJUDICE.some(def => def.keyword.toLowerCase() === keyword)) {
+        return t('{0} is {1:c}', `"${keyword}"`, 'dropped');
+    }
+    // Check rejected keywords
+    if (DEF_LINK_TYPE_MICROFORMATS_REJECTED.some(def => def.keyword.toLowerCase() === keyword)) {
+        return t('{0} is {1:c}', `"${keyword}"`, 'rejected');
+    }
+    // Check non-HTML rel values
+    if (DEF_LINK_TYPE_MICROFORMATS_NON_HTML_REL_VALUES.some(def => def.keyword.toLowerCase() === keyword)) {
+        return t('{0} is {1:c}', `"${keyword}"`, 'not allowed');
+    }
+    // Handle Microformats
+    const { allowMicroformats } = options;
+    if (allowMicroformats === false || allowMicroformats === undefined) {
+        return t('The "{0*}" {1} is {2:c}', keyword, 'keyword', 'not allowed');
+    }
+    if (allowMicroformats === true) {
+        return validateMicroformatKeyword(keyword, context, t);
+    }
+    // allowMicroformats is string[]
+    if (Array.isArray(allowMicroformats)) {
+        const isAllowed = allowMicroformats.some(allowed => allowed.toLowerCase() === keyword);
+        if (!isAllowed) {
+            return t('The "{0*}" {1} is {2:c}', keyword, 'keyword', 'not allowed');
+        }
+        // Even if in the allow list, check element context
+        const microDef = ALLOWED_LINK_TYPE_MICROFORMATS.find(def => def.keyword.toLowerCase() === keyword);
+        if (microDef) {
+            return validateMicroformatContext(microDef, context, t);
+        }
+        // Keyword is in the user's allow list but not in any registry — allow it
+        return null;
+    }
+    return null;
+}
+function validateWhatwgKeyword(def, context, t) {
+    switch (context) {
+        case 'link': {
+            if (def.link === 'not allowed') {
+                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"link" element');
+            }
+            return null;
+        }
+        case 'body-link': {
+            if (def.link === 'not allowed') {
+                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"link" element');
+            }
+            if (def.bodyOk !== 'Yes') {
+                return t('The "{0*}" {1} is not allowed on the {2} inside the {3}', def.keyword, 'keyword', '"link" element', '"body" element');
+            }
+            return null;
+        }
+        case 'a-area': {
+            if (def.a === 'not allowed') {
+                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"a" element');
+            }
+            return null;
+        }
+        case 'form': {
+            if (def.form === 'not allowed') {
+                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"form" element');
+            }
+            return null;
+        }
+    }
+}
+function validateMicroformatKeyword(keyword, context, t) {
+    const microDef = ALLOWED_LINK_TYPE_MICROFORMATS.find(def => def.keyword.toLowerCase() === keyword);
+    if (!microDef) {
+        return t('The "{0*}" {1} is {2:c}', keyword, 'keyword', 'not allowed');
+    }
+    return validateMicroformatContext(microDef, context, t);
+}
+function validateMicroformatContext(def, context, t) {
+    switch (context) {
+        case 'link':
+        case 'body-link': {
+            if (!def.link) {
+                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"link" element');
+            }
+            return null;
+        }
+        case 'a-area': {
+            if (!def.a) {
+                return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"a" element');
+            }
+            return null;
+        }
+        case 'form': {
+            // Microformats don't define form context; reject
+            return t('The "{0*}" {1} is not allowed on the {2}', def.keyword, 'keyword', '"form" element');
+        }
+    }
+}

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

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

package/lib/link-types/meta.js

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

package/lib/neighbor-popovers/index.d.ts

@@ -1,2 +1,10 @@
+/**
+ * Rule that detects perceptible content between a popover trigger and its target.
+ *
+ * When a `[popovertarget]` element or a `[commandfor]` element with a popover-related
+ * `command` attribute and its corresponding `[popover]` target exist in the DOM, any
+ * focusable elements, elements with accessible names, or non-whitespace text nodes
+ * between them are reported as violations.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
 export default _default;