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

package/lib/no-always-matching-source/index.js

@@ -0,0 +1,100 @@
+import { createRule } from '@markuplint/ml-core';
+import { followingElementSiblings } from '../srcset-sizes-constraint/sibling-helpers.js';
+import meta from './meta.js';
+/** Violation message for an always-matching `<source>`. */
+const ALWAYS_MATCHING_SOURCE_MESSAGE = 'The "source" element must have a "media" or "type" attribute when it has a following sibling "source" or "img" element with a "srcset" attribute';
+/**
+ * HTML LS § the source element: when a `<source>` has a following sibling
+ * `<source>` or `<img>` element with a `srcset` attribute specified, it must
+ * have a usable `media` and/or `type` attribute, otherwise it "always
+ * matches" and shadows the following candidates. Split out of the former
+ * `srcset-sizes-constraint` rule's Check 6.
+ *
+ * Whether the current `<source>` itself has a `srcset` is irrelevant — the
+ * requirement is about distinguishing it from what follows, not about its
+ * own candidates.
+ */
+export default createRule({
+    meta,
+    async verify({ document, report }) {
+        await document.walkOn('Element', el => {
+            if (el.localName !== 'source') {
+                return;
+            }
+            // source is only relevant inside <picture>
+            if (el.parentElement?.localName !== 'picture') {
+                return;
+            }
+            // Skip if element has spread attributes (dynamic props)
+            if (el.hasSpreadAttr) {
+                return;
+            }
+            if (isAlwaysMatchingSource(el)) {
+                report({ scope: el, message: ALWAYS_MATCHING_SOURCE_MESSAGE });
+            }
+        });
+    },
+});
+/**
+ * Whether a `media` attribute value is "always matching" per HTML LS, i.e. it
+ * does not distinguish the `<source>` from its siblings.
+ *
+ * A value is always-matching when, after stripping leading and trailing ASCII
+ * whitespace, it is the empty string or an ASCII case-insensitive match for the
+ * string `"all"`.
+ *
+ * ASCII whitespace (TAB, LF, FF, CR, SPACE) is stripped explicitly rather than
+ * via `String.prototype.trim`, which would also strip non-ASCII whitespace such
+ * as NBSP. A media value padded with NBSP around "all" is NOT
+ * always-matching per the spec and must keep its distinguishing media query.
+ *
+ * @param value - The raw `media` attribute value
+ * @returns `true` if the value is empty or `"all"` (case-insensitive)
+ */
+function isAlwaysMatchingMedia(value) {
+    const normalized = value.replaceAll(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, '').toLowerCase();
+    return normalized === '' || normalized === 'all';
+}
+/**
+ * Whether a `<source>` "always matches" and so shadows the following
+ * candidates: it lacks a usable `media`/`type` attribute yet has a following
+ * sibling `<source>`/`<img>` with a `srcset` attribute. See HTML LS § the
+ * source element.
+ *
+ * A `type` attribute (any value, including dynamic) satisfies the requirement.
+ * A `media` attribute satisfies it only when its value is a non-always-matching
+ * media query; a dynamic value is unknown at lint time, so assume it qualifies
+ * to avoid false positives.
+ *
+ * @param el - The `<source>` element to test
+ * @returns `true` if the source must be reported as always-matching
+ */
+function isAlwaysMatchingSource(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el) {
+    const typeAttr = el.getAttributeNode('type');
+    const mediaAttr = el.getAttributeNode('media');
+    const hasUsableType = typeAttr != null;
+    const hasUsableMedia = mediaAttr != null && (mediaAttr.isDynamicValue || !isAlwaysMatchingMedia(mediaAttr.value));
+    return !hasUsableType && !hasUsableMedia && hasFollowingSrcsetSibling(el);
+}
+/**
+ * Whether the element has a following sibling `<source>` or `<img>` element
+ * with a `srcset` attribute specified.
+ *
+ * Per the spec the sibling does not have to be the immediately next sibling.
+ *
+ * @param el - The starting element to search from
+ * @returns `true` if such a following sibling exists
+ */
+function hasFollowingSrcsetSibling(
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+el) {
+    for (const sibling of followingElementSiblings(el)) {
+        if ((sibling.localName === 'source' || sibling.localName === 'img') &&
+            sibling.getAttributeNode('srcset') != null) {
+            return true;
+        }
+    }
+    return false;
+}

package/lib/no-always-matching-source/meta.d.ts

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

package/lib/no-always-matching-source/meta.js

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

package/lib/no-ambiguous-navigable-target-names/index.d.ts

@@ -1,10 +1,2 @@
-/**
- * Rule that warns against ambiguous navigable target names.
- *
- * Detects attribute values (e.g., `target`) that look like browsing context
- * keywords (such as `_blank`, `_self`) but are missing the leading underscore,
- * which would make them navigable target names instead of keywords. Suggests
- * adding the underscore prefix when applicable.
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
 export default _default;

package/lib/no-ambiguous-navigable-target-names/index.js

@@ -1,14 +1,6 @@
 import { createRule, getAttrSpecs } from '@markuplint/ml-core';
 import { valueCheck } from '../attr-check.js';
 import meta from './meta.js';
-/**
- * Rule that warns against ambiguous navigable target names.
- *
- * Detects attribute values (e.g., `target`) that look like browsing context
- * keywords (such as `_blank`, `_self`) but are missing the leading underscore,
- * which would make them navigable target names instead of keywords. Suggests
- * adding the underscore prefix when applicable.
- */
 export default createRule({
     meta: meta,
     defaultSeverity: 'warning',

package/lib/no-ambiguous-navigable-target-names/meta.d.ts

@@ -1,5 +1,4 @@
-/** Rule metadata for the `no-ambiguous-navigable-target-names` rule, categorized as accessibility. */
 declare const _default: {
-    readonly category: "a11y";
+    readonly category: "attributes";
 };
 export default _default;

package/lib/no-ambiguous-navigable-target-names/meta.js

@@ -1,4 +1,3 @@
-/** Rule metadata for the `no-ambiguous-navigable-target-names` rule, categorized as accessibility. */
 export default {
-    category: 'a11y',
+    category: 'attributes',
 };

package/lib/{wai-aria-required-owned-elements → no-aria-on-presentational-children}/index.d.ts

@@ -1,4 +1,3 @@
 import type { Options } from '../wai-aria/types.js';
-/** Warns when a role does not contain its required child roles. */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
 export default _default;

package/lib/{wai-aria-presentational-children → no-aria-on-presentational-children}/index.js

@@ -2,7 +2,6 @@ import { createRule, getSpec } from '@markuplint/ml-core';
 import { checkingPresentationalChildren } from '../wai-aria/checkings/presentational-children.js';
 import { defaultOptions } from '../wai-aria/default-options.js';
 import meta from './meta.js';
-/** Warns when ARIA attributes are set on descendants of roles with presentational children. */
 export default createRule({
     meta,
     defaultSeverity: 'warning',

package/lib/no-aria-on-unsupported-element/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Extracted from the former `wai-aria` umbrella rule (#3989), which always
+ * performed this check first, unconditionally, before any of its other
+ * (now independently-split) checks. No element in the bundled HTML / SVG /
+ * MathML spec data currently sets `globalAttrs['#ARIAAttrs']` to `false` —
+ * every element that declares the flag at all sets it `true` — so this rule
+ * has no reachable positive case against the current spec data; it exists
+ * to remain correct if a future spec update marks some element this way.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+export default _default;

package/lib/no-aria-on-unsupported-element/index.js

@@ -0,0 +1,35 @@
+import { createRule, getSpec } from '@markuplint/ml-core';
+import { Collection } from '../helpers.js';
+import meta from './meta.js';
+/**
+ * Extracted from the former `wai-aria` umbrella rule (#3989), which always
+ * performed this check first, unconditionally, before any of its other
+ * (now independently-split) checks. No element in the bundled HTML / SVG /
+ * MathML spec data currently sets `globalAttrs['#ARIAAttrs']` to `false` —
+ * every element that declares the flag at all sets it `true` — so this rule
+ * has no reachable positive case against the current spec data; it exists
+ * to remain correct if a future spec update marks some element this way.
+ */
+export default createRule({
+    meta: meta,
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            const elSpec = getSpec(el, document.specs.specs);
+            if (!elSpec) {
+                return;
+            }
+            if (elSpec.globalAttrs['#ARIAAttrs']) {
+                return;
+            }
+            const roleAttr = el.getAttributeNode('role');
+            const propAttrs = el.attributes.filter(attr => /^aria-/i.test(attr.name));
+            const ariaAttrs = new Collection(roleAttr, ...propAttrs);
+            for (const ariaAttr of ariaAttrs) {
+                report({
+                    scope: ariaAttr,
+                    message: t('{0} is {1:c}', t('the "{0*}" {1}', ariaAttr.name, 'attribute'), 'disallowed'),
+                });
+            }
+        });
+    },
+});

package/lib/no-aria-on-unsupported-element/meta.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    readonly category: "a11y";
+    readonly specConformance: {
+        readonly sources: readonly ["aria-in-html"];
+        readonly level: "must";
+        readonly cites: readonly ["https://w3c.github.io/html-aria/#docconformance"];
+    };
+};
+export default _default;

package/lib/no-aria-on-unsupported-element/meta.js

@@ -0,0 +1,8 @@
+export default {
+    category: 'a11y',
+    specConformance: {
+        sources: ['aria-in-html'],
+        level: 'must',
+        cites: ['https://w3c.github.io/html-aria/#docconformance'],
+    },
+};

package/lib/no-boolean-attr-value/index.d.ts

@@ -1,9 +1,2 @@
-/**
- * Rule that disallows explicit values on boolean attributes.
- *
- * Checks each attribute against the HTML spec and reports when a boolean
- * attribute (e.g., `disabled`, `checked`) is written with an explicit value
- * such as `disabled="disabled"` instead of the bare attribute name.
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
 export default _default;

package/lib/no-boolean-attr-value/index.js

@@ -1,13 +1,6 @@
 import { createRule, getAttrSpecs } from '@markuplint/ml-core';
 import { removeAttrValue } from '../helpers.js';
 import meta from './meta.js';
-/**
- * Rule that disallows explicit values on boolean attributes.
- *
- * Checks each attribute against the HTML spec and reports when a boolean
- * attribute (e.g., `disabled`, `checked`) is written with an explicit value
- * such as `disabled="disabled"` instead of the bare attribute name.
- */
 export default createRule({
     meta: meta,
     defaultSeverity: 'warning',

package/lib/no-boolean-attr-value/meta.d.ts

@@ -1,4 +1,3 @@
-/** Rule metadata for `no-boolean-attr-value`: categorized as a style rule. */
 declare const _default: {
     readonly category: "style";
     readonly fixable: true;

package/lib/no-boolean-attr-value/meta.js

@@ -1,4 +1,3 @@
-/** Rule metadata for `no-boolean-attr-value`: categorized as a style rule. */
 export default {
     category: 'style',
     fixable: true,

package/lib/no-broken-fragment-link/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Split out of the former `no-refer-to-non-existent-id` rule. Unlike the
+ * `DOMID`-typed attributes and ARIA ID references that rule covers, HTML LS
+ * does not treat a broken hyperlink fragment as a conformance violation —
+ * scrolling to a fragment simply does nothing when its target is absent
+ * (§ Scrolling to a fragment). Reporting it is still useful (almost always
+ * an author mistake), which is why the default severity stays `warning`
+ * rather than `no-refer-to-non-existent-id`'s `error`.
+ *
+ * @see https://html.spec.whatwg.org/multipage/browsing-the-web.html#scrolling-to-a-fragment
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, {
+    fragmentRefersNameAttr: boolean;
+}>>;
+export default _default;

package/lib/no-broken-fragment-link/index.js

@@ -0,0 +1,93 @@
+import { createRule } from '@markuplint/ml-core';
+import { decodeEntities, decodeHref } from '@markuplint/shared';
+import meta from './meta.js';
+/** CSS selector matching hyperlink elements that have an `href` attribute. */
+const HYPERLINK_SELECTOR = 'a[href], area[href]';
+/**
+ * Split out of the former `no-refer-to-non-existent-id` rule. Unlike the
+ * `DOMID`-typed attributes and ARIA ID references that rule covers, HTML LS
+ * does not treat a broken hyperlink fragment as a conformance violation —
+ * scrolling to a fragment simply does nothing when its target is absent
+ * (§ Scrolling to a fragment). Reporting it is still useful (almost always
+ * an author mistake), which is why the default severity stays `warning`
+ * rather than `no-refer-to-non-existent-id`'s `error`.
+ *
+ * @see https://html.spec.whatwg.org/multipage/browsing-the-web.html#scrolling-to-a-fragment
+ */
+export default createRule({
+    meta: meta,
+    defaultSeverity: 'warning',
+    defaultOptions: {
+        fragmentRefersNameAttr: false,
+    },
+    async verify({ document, report, t }) {
+        const idList = new Set();
+        const nameList = new Set();
+        let hasDynamicId = false;
+        let hasDynamicName = false;
+        const isMutable = document.nodeList.some(node => node.is(node.MARKUPLINT_PREPROCESSOR_BLOCK));
+        if (isMutable) {
+            return;
+        }
+        for (const el of document.querySelectorAll('[id]')) {
+            const attr = el.getAttributeNode('id');
+            if (!attr) {
+                continue;
+            }
+            if (attr.isDynamicValue) {
+                hasDynamicId = true;
+            }
+            if (attr.valueType !== 'code') {
+                idList.add(decodeEntities(attr.value));
+            }
+        }
+        if (hasDynamicId) {
+            return;
+        }
+        for (const el of document.querySelectorAll('[name]')) {
+            const attr = el.getAttributeNode('name');
+            if (!attr) {
+                continue;
+            }
+            if (attr.isDynamicValue) {
+                hasDynamicName = true;
+            }
+            if (attr.valueType !== 'code') {
+                nameList.add(decodeEntities(attr.value));
+            }
+        }
+        await document.walkOn('Element', el => {
+            if (el.rule.options.fragmentRefersNameAttr && hasDynamicName) {
+                return;
+            }
+            if (!el.matches(HYPERLINK_SELECTOR)) {
+                return;
+            }
+            const href = el.getAttributeNode('href');
+            if (!href) {
+                return;
+            }
+            const rawFragment = href.value.match(/^#(.+)/)?.[1];
+            if (rawFragment == null) {
+                return;
+            }
+            const decodedFragment = decodeHref(rawFragment);
+            // > 2. If fragment is the empty string, then return the special value top of the document.
+            // >
+            // > 9. If decodedFragment is an ASCII case-insensitive match for the string top, then return the top of the document.
+            if (decodedFragment === '' || /^top$/i.test(decodedFragment)) {
+                return;
+            }
+            if (!idList.has(decodedFragment) &&
+                (el.rule.options.fragmentRefersNameAttr ? !nameList.has(decodedFragment) : true)) {
+                report({
+                    scope: href,
+                    line: href.valueNode?.startLine,
+                    col: href.valueNode?.startCol,
+                    raw: href.valueNode?.raw,
+                    message: t('Missing {0}', t('"{0*}" ID', decodedFragment)),
+                });
+            }
+        });
+    },
+});

package/lib/no-broken-fragment-link/meta.d.ts

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

package/lib/no-broken-fragment-link/meta.js

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

package/lib/no-consecutive-br/index.d.ts

@@ -1,10 +1,2 @@
-/**
- * Rule that disallows consecutive `<br>` elements.
- *
- * Queries all `<br>` elements in the document and checks whether the next
- * non-whitespace sibling is another `<br>`. Consecutive line breaks are
- * typically a sign that a more semantic element (e.g., `<p>`) should be
- * used instead, which is important for accessibility.
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
 export default _default;

package/lib/no-consecutive-br/index.js

@@ -1,13 +1,5 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
-/**
- * Rule that disallows consecutive `<br>` elements.
- *
- * Queries all `<br>` elements in the document and checks whether the next
- * non-whitespace sibling is another `<br>`. Consecutive line breaks are
- * typically a sign that a more semantic element (e.g., `<p>`) should be
- * used instead, which is important for accessibility.
- */
 export default createRule({
     meta: meta,
     defaultSeverity: 'warning',

package/lib/no-consecutive-br/meta.d.ts

@@ -1,4 +1,3 @@
-/** Rule metadata for `no-consecutive-br`: categorized as an accessibility rule. */
 declare const _default: {
     readonly category: "a11y";
     readonly fixable: true;

package/lib/no-consecutive-br/meta.js

@@ -1,4 +1,3 @@
-/** Rule metadata for `no-consecutive-br`: categorized as an accessibility rule. */
 export default {
     category: 'a11y',
     fixable: true,

package/lib/no-content-after-body/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * HTML LS "after body" insertion mode:
+ *
+ * > An end-of-file token: Stop parsing.
+ * >
+ * > Anything else: Parse error. Switch the insertion mode to "in body" and
+ * > reprocess the token.
+ *
+ * Whitespace characters (U+0009/000A/000C/000D/0020) have their own case one
+ * step above ("process using the rules for the 'in body' insertion mode"
+ * without the parse error), so a trailing newline after `</body>` is normal
+ * and out of scope here — only a start tag or non-whitespace text reaching
+ * this insertion mode is the "Anything else" parse error. Because the
+ * reprocessing switches back to "in body", the offending content still ends
+ * up nested inside `<body>` in the resulting tree even though, in the
+ * source, it appears after `<body>`'s own end tag.
+ *
+ * Scoped to `<body>`'s direct children: anything deeper (e.g. text inside a
+ * later `<script>`) is that descendant's own content, not a stray token that
+ * arrived after the body boundary closed.
+ *
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-afterbody
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+export default _default;

package/lib/no-content-after-body/index.js

@@ -0,0 +1,51 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+/**
+ * HTML LS "after body" insertion mode:
+ *
+ * > An end-of-file token: Stop parsing.
+ * >
+ * > Anything else: Parse error. Switch the insertion mode to "in body" and
+ * > reprocess the token.
+ *
+ * Whitespace characters (U+0009/000A/000C/000D/0020) have their own case one
+ * step above ("process using the rules for the 'in body' insertion mode"
+ * without the parse error), so a trailing newline after `</body>` is normal
+ * and out of scope here — only a start tag or non-whitespace text reaching
+ * this insertion mode is the "Anything else" parse error. Because the
+ * reprocessing switches back to "in body", the offending content still ends
+ * up nested inside `<body>` in the resulting tree even though, in the
+ * source, it appears after `<body>`'s own end tag.
+ *
+ * Scoped to `<body>`'s direct children: anything deeper (e.g. text inside a
+ * later `<script>`) is that descendant's own content, not a stray token that
+ * arrived after the body boundary closed.
+ *
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-afterbody
+ */
+export default createRule({
+    meta: meta,
+    verify({ document, report, t }) {
+        const body = document.querySelector('body');
+        if (!body?.closeTag)
+            return;
+        const bodyCloseEnd = body.closeTag.startOffset + body.closeTag.raw.length;
+        for (const child of body.childNodes) {
+            if (child.startOffset < bodyCloseEnd)
+                continue;
+            if (child.is(child.ELEMENT_NODE)) {
+                report({
+                    scope: child,
+                    message: t('Content after the end tag of the "{0}" element is not allowed', 'body'),
+                });
+                continue;
+            }
+            if (child.is(child.TEXT_NODE) && child.raw.trim() !== '') {
+                report({
+                    scope: child,
+                    message: t('Content after the end tag of the "{0}" element is not allowed', 'body'),
+                });
+            }
+        }
+    },
+});

package/lib/no-content-after-body/meta.d.ts

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

package/lib/no-content-after-body/meta.js

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

package/lib/no-contradictory-aria-prop/index.d.ts

@@ -0,0 +1,10 @@
+import type { Options } from '../wai-aria/types.js';
+/**
+ * Split from the former `wai-aria-implicit-props` rule (#3989): the
+ * "contradictory" half. See `checkingContradictoryAriaProp`'s JSDoc for the
+ * full spec citation. Must-level (ARIA in HTML §6 conformance), so this rule
+ * uses the default `error` severity — contrast `no-redundant-aria-prop`'s
+ * should-level `warning`, which the former combined rule used uniformly.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/no-contradictory-aria-prop/index.js

@@ -0,0 +1,34 @@
+import { createRule, ariaSpecs, getAttrSpecs, getSpec } from '@markuplint/ml-core';
+import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
+import { checkingContradictoryAriaProp } from '../wai-aria/checkings/contradictory-aria-prop.js';
+import { defaultOptions } from '../wai-aria/default-options.js';
+import meta from './meta.js';
+/**
+ * Split from the former `wai-aria-implicit-props` rule (#3989): the
+ * "contradictory" half. See `checkingContradictoryAriaProp`'s JSDoc for the
+ * full spec citation. Must-level (ARIA in HTML §6 conformance), so this rule
+ * uses the default `error` severity — contrast `no-redundant-aria-prop`'s
+ * should-level `warning`, which the former combined rule used uniformly.
+ */
+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 { props: propSpecs } = ariaSpecs(document.specs, ariaVersion);
+            const attrSpecs = getAttrSpecs(el, document.specs);
+            for (const attr of propAttrs) {
+                report(checkingContradictoryAriaProp({ attr, propSpecs, attrSpecs }));
+            }
+        });
+    },
+});

package/lib/{wai-aria-abstract-role → no-default-aria-value}/index.d.ts

@@ -1,4 +1,3 @@
 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-default-value → no-default-aria-value}/index.js

@@ -3,7 +3,6 @@ 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',

package/lib/no-default-value/index.d.ts

@@ -1,9 +1,2 @@
-/**
- * Rule that disallows explicitly setting an attribute to its default value.
- *
- * Looks up each attribute's default value from the spec and reports when
- * the authored value matches the default, since the attribute can be
- * omitted entirely for the same effect.
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
 export default _default;

package/lib/no-default-value/index.js

@@ -1,13 +1,6 @@
 import { createRule, getAttrSpecs } from '@markuplint/ml-core';
 import { removeAttr, toNormalizedValue } from '../helpers.js';
 import meta from './meta.js';
-/**
- * Rule that disallows explicitly setting an attribute to its default value.
- *
- * Looks up each attribute's default value from the spec and reports when
- * the authored value matches the default, since the attribute can be
- * omitted entirely for the same effect.
- */
 export default createRule({
     meta: meta,
     defaultSeverity: 'warning',

package/lib/no-default-value/meta.d.ts

@@ -1,4 +1,3 @@
-/** Rule metadata for `no-default-value`: categorized as a style rule. */
 declare const _default: {
     readonly category: "style";
     readonly fixable: true;

package/lib/no-default-value/meta.js

@@ -1,4 +1,3 @@
-/** Rule metadata for `no-default-value`: categorized as a style rule. */
 export default {
     category: 'style',
     fixable: true,

package/lib/no-deprecated-aria-prop/index.d.ts

@@ -0,0 +1,3 @@
+import type { Options } from '../wai-aria/types.js';
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
+export default _default;

package/lib/{wai-aria-deprecated-props → no-deprecated-aria-prop}/index.js

@@ -3,7 +3,6 @@ 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',

package/lib/no-deprecated-attr/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, undefined>>;
+export default _default;