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

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

@@ -1,9 +1,15 @@
 import { createRule, ariaSpecs, getAttrSpecs, getSpec } from '@markuplint/ml-core';
 import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
-import { checkingImplicitProps } from '../wai-aria/checkings/implicit-props.js';
+import { checkingRedundantAriaProp } from '../wai-aria/checkings/redundant-aria-prop.js';
 import { defaultOptions } from '../wai-aria/default-options.js';
 import meta from './meta.js';
-/** Warns when an ARIA property duplicates or contradicts semantics provided by a native HTML attribute. */
+/**
+ * Split from the former `wai-aria-implicit-props` rule (#3989): the
+ * "redundant" half. See `checkingRedundantAriaProp`'s JSDoc for the full
+ * spec citation. Should-level (ARIA in HTML §6 recommends the native
+ * attribute), so this rule keeps the former rule's `warning` default —
+ * contrast `no-contradictory-aria-prop`'s `error`.
+ */
 export default createRule({
     meta,
     defaultSeverity: 'warning',
@@ -22,7 +28,7 @@ export default createRule({
             const { props: propSpecs } = ariaSpecs(document.specs, ariaVersion);
             const attrSpecs = getAttrSpecs(el, document.specs);
             for (const attr of propAttrs) {
-                report(checkingImplicitProps({ attr, propSpecs, attrSpecs }));
+                report(checkingRedundantAriaProp({ attr, propSpecs, attrSpecs }));
             }
         });
     },

package/lib/no-redundant-aria-prop/meta.d.ts

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

package/lib/no-redundant-aria-prop/meta.js

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

package/lib/no-redundant-role/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-implicit-role → no-redundant-role}/index.js

@@ -2,7 +2,6 @@ import { createRule, getSpec } from '@markuplint/ml-core';
 import { checkingImplicitRole } from '../wai-aria/checkings/implicit-role.js';
 import { defaultOptions } from '../wai-aria/default-options.js';
 import meta from './meta.js';
-/** Warns when the explicit role attribute duplicates the element's implicit role. */
 export default createRule({
     meta,
     defaultSeverity: 'warning',

package/lib/no-redundant-role/meta.d.ts

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

package/lib/no-redundant-role/meta.js

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

package/lib/no-refer-to-non-existent-id/index.d.ts

@@ -1,14 +1,5 @@
 import type { ARIAVersion } from '@markuplint/ml-spec';
-/**
- * Rule that validates all ID references in attributes point to existing elements.
- *
- * Checks DOMID and DOMID-list attributes (e.g., `for`, `aria-labelledby`),
- * ARIA ID reference properties, and fragment identifiers in hyperlinks (`href="#id"`).
- * Reports any reference to an ID that does not exist in the document. Skips
- * validation when dynamic IDs or preprocessor blocks are detected.
- */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<import("@markuplint/ml-core").RuleConfigValue, {
     ariaVersion: ARIAVersion | undefined;
-    fragmentRefersNameAttr: boolean;
 }>>;
 export default _default;

package/lib/no-refer-to-non-existent-id/index.js

@@ -1,28 +1,15 @@
 import { createRule, getAttrSpecs, ariaSpecs } from '@markuplint/ml-core';
 import { ARIA_RECOMMENDED_VERSION } from '@markuplint/ml-spec';
-import { decodeEntities, decodeHref } from '@markuplint/shared';
+import { decodeEntities } 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]';
-/**
- * Rule that validates all ID references in attributes point to existing elements.
- *
- * Checks DOMID and DOMID-list attributes (e.g., `for`, `aria-labelledby`),
- * ARIA ID reference properties, and fragment identifiers in hyperlinks (`href="#id"`).
- * Reports any reference to an ID that does not exist in the document. Skips
- * validation when dynamic IDs or preprocessor blocks are detected.
- */
 export default createRule({
     meta: meta,
     defaultOptions: {
         ariaVersion: undefined,
-        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;
@@ -42,18 +29,6 @@ export default createRule({
         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('Attr', attr => {
             const attrSpec = getAttrSpecs(attr.ownerElement, document.specs);
             if (!attrSpec) {
@@ -131,41 +106,5 @@ export default createRule({
                 }
             }
         });
-        /**
-         * @see https://html.spec.whatwg.org/multipage/browsing-the-web.html#scrolling-to-a-fragment
-         */
-        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-refer-to-non-existent-id/meta.d.ts

@@ -1,5 +1,4 @@
-/** Rule metadata for the `no-refer-to-non-existent-id` rule, categorized as accessibility. */
 declare const _default: {
-    readonly category: "a11y";
+    readonly category: "references";
 };
 export default _default;

package/lib/no-refer-to-non-existent-id/meta.js

@@ -1,4 +1,3 @@
-/** Rule metadata for the `no-refer-to-non-existent-id` rule, categorized as accessibility. */
 export default {
-    category: 'a11y',
+    category: 'references',
 };

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

@@ -0,0 +1,27 @@
+import type { AttributeType } from '@markuplint/ml-spec';
+import type { Pattern } from '@markuplint/types';
+/**
+ * Configuration options for the `no-restricted-attr` rule.
+ */
+type Option = {
+    /**
+     * Attributes to disallow, in addition to whatever the HTML spec (checked
+     * by `no-unknown-attr` / `no-disallowed-attr` / `no-invalid-attr-value`)
+     * already restricts. This is the rule's only concern — narrow, purely
+     * user-defined denylisting, independent of spec conformance.
+     *
+     * @since 3.7.0
+     */
+    disallowAttrs?: (string | Attr)[] | Record<string, AttributeType | Pattern>;
+};
+/**
+ * Describes a single attribute with its name and expected value constraint.
+ */
+type Attr = {
+    /** The attribute name. */
+    name: string;
+    /** The expected attribute value type or validation rule. */
+    value: AttributeType | Pattern;
+};
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Option>>;
+export default _default;

package/lib/no-restricted-attr/index.js

@@ -0,0 +1,96 @@
+import { createRule } from '@markuplint/ml-core';
+import { check, isEnum, isPattern } from '@markuplint/types';
+import { attrCheck } from '../attr-check.js';
+import meta from './meta.js';
+function disallowedTypes(disallowAttrs) {
+    const map = new Map();
+    if (!disallowAttrs) {
+        return map;
+    }
+    if (Array.isArray(disallowAttrs)) {
+        for (const disallowAttr of disallowAttrs) {
+            if (typeof disallowAttr === 'string') {
+                map.set(disallowAttr, 'Any');
+                continue;
+            }
+            map.set(disallowAttr.name, disallowAttr.value);
+        }
+    }
+    else {
+        for (const [name, type] of Object.entries(disallowAttrs)) {
+            map.set(name, type);
+        }
+    }
+    return map;
+}
+export default createRule({
+    meta: meta,
+    defaultOptions: {},
+    async verify({ document, report, t }) {
+        await document.walkOn('Attr', attr => {
+            if (attr.isDirective) {
+                return;
+            }
+            const name = attr.name;
+            const value = attr.value;
+            const valueNode = attr.valueNode;
+            const attrName = attr.nameNode;
+            const disallowValue = disallowedTypes(attr.rule.options.disallowAttrs).get(name);
+            if (disallowValue === undefined) {
+                return;
+            }
+            if (disallowValue === 'Any') {
+                report({
+                    scope: attr,
+                    message: t('{0} is disallowed', t('the "{0*}" {1}', name, 'attribute')),
+                    line: attrName?.startLine,
+                    col: attrName?.startCol,
+                    raw: attrName?.raw,
+                });
+                return;
+            }
+            if (attr.isDynamicValue) {
+                return;
+            }
+            const checkResult = isPattern(disallowValue)
+                ? check(value, disallowValue)
+                : attrCheck(t, name, value, true, {
+                    name,
+                    type: disallowValue,
+                    description: '',
+                });
+            const isMatched = isPattern(disallowValue)
+                ? checkResult.matched
+                : checkResult === false;
+            if (!isMatched) {
+                return;
+            }
+            report({
+                scope: attr,
+                message: createDisallowMessage(t, name, disallowValue),
+                line: valueNode?.startLine,
+                col: valueNode?.startCol,
+                raw: value,
+            });
+        });
+    },
+});
+/**
+ * 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
+type) {
+    if (isPattern(type)) {
+        return t('{0} is matched with the below disallowed patterns: {1}', t('the "{0*}" {1}', name, 'attribute'), type.pattern);
+    }
+    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 t('{0} is disallowed', t('{0} of {1}', t('the {0}', 'type'), t('the "{0*}" {1}', name, 'attribute')));
+}

package/lib/no-restricted-attr/meta.d.ts

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

package/lib/no-restricted-attr/meta.js

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

package/lib/no-restricted-element/index.d.ts

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

package/lib/{disallowed-element → no-restricted-element}/index.js

@@ -1,12 +1,5 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
-/**
- * Rule that disallows elements matching the configured CSS selectors.
- *
- * Accepts an array of selector strings as its value. Queries the document
- * (and per-element overrides) for matching elements and reports each one
- * as disallowed.
- */
 export default createRule({
     meta: meta,
     defaultValue: [],
@@ -27,10 +20,16 @@ export default createRule({
             }
             for (const query of el.rule.value) {
                 const elements = el.querySelectorAll(query);
-                for (const el of elements) {
+                for (const found of elements) {
                     const message = t('{0} is disallowed', t('the "{0*}" {1}', query, 'element'));
                     report({
+                        // `scope` resolves the rule's `reason`/`reasonOnly` (the node-level rule
+                        // setting is mapped to `el`, not to `found`), so it must stay `el`.
+                        // Location comes from `line`/`col`/`raw`, which take precedence over the scope's.
                         scope: el,
+                        line: found.startLine,
+                        col: found.startCol,
+                        raw: found.raw,
                         message,
                     });
                 }

package/lib/no-restricted-element/meta.d.ts

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

package/lib/no-restricted-element/meta.js

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

package/lib/no-skipped-heading-level/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Rule that warns when a heading skips a level relative to the previous
+ * heading lead.
+ *
+ * Per HTML LS §4.3.11, the constraint applies only to a heading "following
+ * another heading lead". A document whose first heading is at any level
+ * (e.g., an article fragment starting with h3) has no lead, so it is
+ * unaffected and never fires on the first heading.
+ *
+ * @see https://html.spec.whatwg.org/multipage/sections.html#headings-and-outlines-2
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, null>>;
+export default _default;

package/lib/{heading-levels → no-skipped-heading-level}/index.js

@@ -1,20 +1,25 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
 /**
- * Rule that validates heading levels (h1-h6) are not skipped.
+ * Rule that warns when a heading skips a level relative to the previous
+ * heading lead.
  *
- * Ensures that heading elements appear in a sequential order without
- * gaps (e.g., an h4 must not follow an h2 directly without an h3 in between).
+ * Per HTML LS §4.3.11, the constraint applies only to a heading "following
+ * another heading lead". A document whose first heading is at any level
+ * (e.g., an article fragment starting with h3) has no lead, so it is
+ * unaffected and never fires on the first heading.
+ *
+ * @see https://html.spec.whatwg.org/multipage/sections.html#headings-and-outlines-2
  */
 export default createRule({
     meta: meta,
     defaultOptions: null,
     verify({ document, report, t }) {
         const headings = document.querySelectorAll('h1, h2, h3, h4, h5, h6');
-        let prevLevel = 1;
+        let prevLevel = null;
         for (const heading of headings) {
             const level = Number.parseInt(heading.nodeName.slice(1));
-            if (prevLevel + 1 < level) {
+            if (prevLevel !== null && prevLevel + 1 < level) {
                 report({
                     scope: heading,
                     message: t('{0} must not be skipped', t('Heading levels')),

package/lib/no-skipped-heading-level/meta.d.ts

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

package/lib/no-skipped-heading-level/meta.js

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

package/lib/no-stray-head-or-body-tag/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * HTML LS "in body" insertion mode:
+ *
+ * > A start tag whose tag name is "body": Parse error. If the stack of open
+ * > elements has only one node on it, or if the second element on the stack
+ * > of open elements is not a body element, or if there is a template
+ * > element on the stack of open elements, then ignore the token […].
+ * > Otherwise, set the frameset-ok flag to "not ok" […]
+ *
+ * "in body" insertion mode, "Any other end tag":
+ *
+ * > Initialize node to be the current node […]. If node's tag name […] is
+ * > not the same as the tag name of the token, then this is a parse error.
+ *
+ * Neither of these fires by the presence of disallowed `<head>` content
+ * itself (the "in head" insertion mode's own "Anything else" clause that
+ * pops an implicitly-invalid element out of head carries no "parse error"
+ * wording) — they fire only when the *source* still contains a literal
+ * `</head>` or `<body>` token that arrives once the parser has moved on.
+ * `@markuplint/html-parser`'s `nodeize` folds a token the tree constructor
+ * discards into the surrounding text node's `raw` span rather than
+ * dropping the bytes, so a genuinely-consumed stray/duplicate tag survives
+ * as plain text content — this rule looks for exactly that residue.
+ *
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inbody
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+export default _default;

package/lib/no-stray-head-or-body-tag/index.js

@@ -0,0 +1,61 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+/**
+ * Content whose element is one of these has RAWTEXT/RCDATA parsing (HTML LS
+ * "generic raw text element parsing algorithm" / "generic RCDATA element
+ * parsing algorithm"): the parser never re-tokenizes tag-shaped substrings
+ * inside it, so a literal `<body` or `</head` there is ordinary text, not a
+ * candidate for either check below.
+ */
+const RAW_TEXT_CONTAINERS = new Set(['script', 'style', 'title', 'textarea', 'xmp']);
+const STRAY_HEAD_END_TAG = /<\/head(?=[\s/>])/i;
+const DUPLICATE_BODY_START_TAG = /<body(?=[\s/>])/i;
+/**
+ * HTML LS "in body" insertion mode:
+ *
+ * > A start tag whose tag name is "body": Parse error. If the stack of open
+ * > elements has only one node on it, or if the second element on the stack
+ * > of open elements is not a body element, or if there is a template
+ * > element on the stack of open elements, then ignore the token […].
+ * > Otherwise, set the frameset-ok flag to "not ok" […]
+ *
+ * "in body" insertion mode, "Any other end tag":
+ *
+ * > Initialize node to be the current node […]. If node's tag name […] is
+ * > not the same as the tag name of the token, then this is a parse error.
+ *
+ * Neither of these fires by the presence of disallowed `<head>` content
+ * itself (the "in head" insertion mode's own "Anything else" clause that
+ * pops an implicitly-invalid element out of head carries no "parse error"
+ * wording) — they fire only when the *source* still contains a literal
+ * `</head>` or `<body>` token that arrives once the parser has moved on.
+ * `@markuplint/html-parser`'s `nodeize` folds a token the tree constructor
+ * discards into the surrounding text node's `raw` span rather than
+ * dropping the bytes, so a genuinely-consumed stray/duplicate tag survives
+ * as plain text content — this rule looks for exactly that residue.
+ *
+ * @see https://html.spec.whatwg.org/multipage/parsing.html#parsing-main-inbody
+ */
+export default createRule({
+    meta: meta,
+    async verify({ document, report, t }) {
+        await document.walkOn('Text', text => {
+            const parent = text.parentNode;
+            const parentLocalName = parent && 'localName' in parent ? parent.localName : '';
+            if (RAW_TEXT_CONTAINERS.has(parentLocalName))
+                return;
+            if (STRAY_HEAD_END_TAG.test(text.raw)) {
+                report({
+                    scope: text,
+                    message: t('{0} detected', t('a stray "{0}" end tag', 'head')),
+                });
+            }
+            if (DUPLICATE_BODY_START_TAG.test(text.raw)) {
+                report({
+                    scope: text,
+                    message: t('{0} detected', t('a duplicate "{0}" start tag', 'body')),
+                });
+            }
+        });
+    },
+});

package/lib/no-stray-head-or-body-tag/meta.d.ts

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

package/lib/no-stray-head-or-body-tag/meta.js

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

package/lib/no-table-cell-overlap/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * HTML LS [§4.9.12.1 *Forming a table*](https://html.spec.whatwg.org/multipage/tables.html#forming-a-table)
+ * Step 14 table model error: two cells anchored so that a slot is covered twice.
+ *
+ * Split from the original `table-row-column-alignment` rule. This is the one check the sibling
+ * splits (`no-table-span-overflow`, `no-empty-table-track`, `consistent-table-row-length`) all
+ * skip a table for: once two cells claim the same slot, every column and width derived from the
+ * grid model is speculative, so reporting them would bury the one error the author has to fix
+ * first.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+export default _default;

package/lib/no-table-cell-overlap/index.js

@@ -0,0 +1,30 @@
+import { createRule } from '@markuplint/ml-core';
+import { Grid } from '../table-row-column-alignment/grid.js';
+import meta from './meta.js';
+/**
+ * HTML LS [§4.9.12.1 *Forming a table*](https://html.spec.whatwg.org/multipage/tables.html#forming-a-table)
+ * Step 14 table model error: two cells anchored so that a slot is covered twice.
+ *
+ * Split from the original `table-row-column-alignment` rule. This is the one check the sibling
+ * splits (`no-table-span-overflow`, `no-empty-table-track`, `consistent-table-row-length`) all
+ * skip a table for: once two cells claim the same slot, every column and width derived from the
+ * grid model is speculative, so reporting them would bury the one error the author has to fix
+ * first.
+ */
+export default createRule({
+    meta,
+    verify({ document, report, t }) {
+        const tables = document.querySelectorAll('table');
+        for (const table of tables) {
+            const grid = new Grid(table);
+            if (grid.hasOverlapped()) {
+                report({
+                    scope: table,
+                    message: t(
+                    //
+                    '{0} are causing {1}', t(['rowspan', 'colspan'], true), 'cell overlap'),
+                });
+            }
+        }
+    },
+});

package/lib/no-table-cell-overlap/meta.d.ts

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

package/lib/no-table-cell-overlap/meta.js

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

package/lib/no-table-span-overflow/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * HTML LS §4.9.12 ("A cell cannot cover slots that are from two or more row groups."): a cell
+ * whose `rowspan` reaches past the last row of its `<thead>` / `<tbody>` / `<tfoot>` is clipped
+ * to the row group by the *ending a row group* algorithm, which is itself the table model error
+ * this rule reports.
+ *
+ * Split from the original `table-row-column-alignment` rule. Skips a table that
+ * `no-table-cell-overlap` already reports on — once two cells claim the same slot, the grid
+ * model's row groups are no longer reliable.
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
+export default _default;

package/lib/no-table-span-overflow/index.js

@@ -0,0 +1,37 @@
+import { createRule } from '@markuplint/ml-core';
+import { Grid } from '../table-row-column-alignment/grid.js';
+import meta from './meta.js';
+/**
+ * HTML LS §4.9.12 ("A cell cannot cover slots that are from two or more row groups."): a cell
+ * whose `rowspan` reaches past the last row of its `<thead>` / `<tbody>` / `<tfoot>` is clipped
+ * to the row group by the *ending a row group* algorithm, which is itself the table model error
+ * this rule reports.
+ *
+ * Split from the original `table-row-column-alignment` rule. Skips a table that
+ * `no-table-cell-overlap` already reports on — once two cells claim the same slot, the grid
+ * model's row groups are no longer reliable.
+ */
+export default createRule({
+    meta,
+    verify({ document, report, t }) {
+        const tables = document.querySelectorAll('table');
+        for (const table of tables) {
+            const grid = new Grid(table);
+            if (grid.hasOverlapped()) {
+                continue;
+            }
+            for (const rowGroup of grid.rowGroups) {
+                for (const overflow of rowGroup.overflows) {
+                    const rowSpan = overflow.cell.getAttributeNode('rowspan');
+                    if (!rowSpan) {
+                        continue;
+                    }
+                    report({
+                        scope: rowSpan,
+                        message: t('Exceeds the number of available {0}', 'rows'),
+                    });
+                }
+            }
+        }
+    },
+});

package/lib/no-table-span-overflow/meta.d.ts

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

package/lib/no-table-span-overflow/meta.js

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

package/lib/no-unclosed-element-at-eof/index.d.ts

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