@markuplint/rules 4.11.2 → 4.18.0

package/lib/require-datetime/index.js

@@ -2,6 +2,14 @@ import { createRule } from '@markuplint/ml-core';
 import { check } from '@markuplint/types';
 import meta from './meta.js';
 import { getCandidateDatetimeString } from './utils.js';
+/**
+ * Rule that validates `<time>` elements without a `datetime` attribute have
+ * machine-readable date/time content.
+ *
+ * When a `<time>` element lacks the `datetime` attribute, this rule checks
+ * whether the text content is a valid datetime string. If not, it attempts
+ * to parse the content as natural language and suggests a `datetime` value.
+ */
 export default createRule({
     meta: meta,
     defaultOptions: {

package/lib/require-datetime/meta.d.ts

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

package/lib/require-datetime/meta.js

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

package/lib/require-datetime/types.d.ts

@@ -1,10 +1,17 @@
+/** Union of possible date/time component keys used in parsed datetime data. */
 export type DateTimeKey = 'year' | 'month' | 'day' | 'hour' | 'minute' | 'second' | 'ms';
+/** A partial record mapping date/time component keys to their numeric values. */
 export type DateTimeData = Partial<Record<DateTimeKey, number>>;
+/** Represents a parsed date/time value with optional timezone offset. */
 export type DateTime = {
+    /** The parsed date/time component values. */
     datetime: DateTimeData;
+    /** Timezone offset in minutes from UTC (e.g., -300 for UTC-5). */
     zone?: number;
 };
 /**
+ * Supported locale codes for natural language date/time parsing.
+ *
  * @see https://github.com/wanasit/chrono#locales
  */
 export type Lang = 'en' | 'ja' | 'fr' | 'nl' | 'ru' | 'de' | 'pt' | 'zh';

package/lib/require-datetime/utils.d.ts

@@ -1,11 +1,24 @@
 import type { DateTime, Lang } from './types.js';
 /**
- * Datetime-ish text to a datetime data
+ * Parses natural language datetime text into structured datetime data.
  *
- * @param content
- * @param langs
- * @param base Reference date for a test
- * @returns
+ * Tries multiple locale parsers and returns the first successful parse result
+ * with only the certain (non-implied) date/time components included.
+ *
+ * @param content - The text content to parse as a datetime.
+ * @param langs - Locale codes to attempt parsing with.
+ * @param base - Optional reference date for relative date parsing (e.g., "tomorrow").
+ * @returns Parsed datetime data with timezone, or `null` if parsing fails.
  */
 export declare function parseADatetime(content: string, langs: readonly Lang[], base?: Readonly<Date>): DateTime | null;
+/**
+ * Generates an HTML `datetime` attribute value from natural language text.
+ *
+ * Parses the text content using chrono-node and formats the result as an
+ * ISO 8601-like datetime string suitable for the `datetime` attribute.
+ *
+ * @param content - The text content to parse.
+ * @param langs - Locale codes to use for parsing. Defaults to all supported languages.
+ * @returns A formatted datetime string, or `null` if the content cannot be parsed.
+ */
 export declare function getCandidateDatetimeString(content: string, langs?: Lang[]): string | null;

package/lib/require-datetime/utils.js

@@ -1,12 +1,16 @@
 import * as chrono from 'chrono-node';
+/** Default set of languages to try when parsing natural language datetime text. */
 const defaultLangs = ['en', 'ja', 'fr', 'nl', 'ru', 'de', 'pt', 'zh'];
 /**
- * Datetime-ish text to a datetime data
+ * Parses natural language datetime text into structured datetime data.
  *
- * @param content
- * @param langs
- * @param base Reference date for a test
- * @returns
+ * Tries multiple locale parsers and returns the first successful parse result
+ * with only the certain (non-implied) date/time components included.
+ *
+ * @param content - The text content to parse as a datetime.
+ * @param langs - Locale codes to attempt parsing with.
+ * @param base - Optional reference date for relative date parsing (e.g., "tomorrow").
+ * @returns Parsed datetime data with timezone, or `null` if parsing fails.
  */
 export function parseADatetime(content, langs, base) {
     const date = parseTryMultipleLangs(content, langs, base);
@@ -43,6 +47,16 @@ export function parseADatetime(content, langs, base) {
     }
     return datetime;
 }
+/**
+ * Generates an HTML `datetime` attribute value from natural language text.
+ *
+ * Parses the text content using chrono-node and formats the result as an
+ * ISO 8601-like datetime string suitable for the `datetime` attribute.
+ *
+ * @param content - The text content to parse.
+ * @param langs - Locale codes to use for parsing. Defaults to all supported languages.
+ * @returns A formatted datetime string, or `null` if the content cannot be parsed.
+ */
 export function getCandidateDatetimeString(content, langs = defaultLangs) {
     const date = parseADatetime(content, langs);
     if (!date) {
@@ -60,6 +74,15 @@ export function getCandidateDatetimeString(content, langs = defaultLangs) {
     }
     return datetimeStr;
 }
+/**
+ * Converts parsed datetime data into an ISO 8601-like string.
+ *
+ * Produces different formats depending on which components are present
+ * (e.g., date-only, time-only, or combined date-time).
+ *
+ * @param date - The parsed date/time component data.
+ * @returns A formatted datetime string, or `null` if the components do not match any known format.
+ */
 function toDatetimeString(date) {
     if (only(date, ['year', 'month'])) {
         return `${f(date.year, 4)}-${f(date.month, 2)}`;
@@ -90,6 +113,17 @@ function toDatetimeString(date) {
     }
     return null;
 }
+/**
+ * Attempts to parse datetime text using multiple locale parsers sequentially.
+ *
+ * Returns the parsed start component from the first locale that produces a
+ * valid result (non-range, single datetime).
+ *
+ * @param content - The text content to parse.
+ * @param langs - Locale codes to try in order.
+ * @param base - Optional reference date for relative date parsing.
+ * @returns The parsed start component, or `null` if no locale succeeds.
+ */
 function parseTryMultipleLangs(content, langs, base) {
     for (const lang of langs) {
         const results = 
@@ -111,6 +145,16 @@ function parseTryMultipleLangs(content, langs, base) {
     }
     return null;
 }
+/**
+ * Type guard that checks if the given datetime data contains only the specified keys.
+ *
+ * @template K - The array of datetime keys to check for.
+ * @template U - Union of the key types.
+ * @template R - The resulting narrowed type with required properties.
+ * @param date - The datetime data to check.
+ * @param keys - The keys that should be the only ones present.
+ * @returns `true` if the date contains only the specified keys (and narrows the type).
+ */
 function only(date, keys) {
     const list = Object.keys(date);
     for (const exists of list) {
@@ -121,11 +165,11 @@ function only(date, keys) {
     return true;
 }
 /**
- * Formatter
+ * Formats a number with zero-padding to the specified width.
  *
- * @param n
- * @param pad zero padding
- * @returns
+ * @param n - The number to format.
+ * @param pad - The minimum number of digits in the output string.
+ * @returns The zero-padded string representation.
  */
 function f(n, pad) {
     return n.toString(10).padStart(pad, '0');

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

@@ -1,7 +1,20 @@
+/** The rule value: either a single attribute name or an array of required attribute descriptors. */
 type RequiredAttributes = string | (string | Attr)[];
+/**
+ * Descriptor for a required attribute with an optional set of allowed values.
+ */
 type Attr = {
+    /** The attribute name that is required. */
     name: string;
+    /** One or more allowed values for the attribute, if constrained. */
     value?: string | string[];
 };
+/**
+ * Rule that validates elements have all required attributes.
+ *
+ * Checks both HTML-spec-defined required attributes and custom required attributes
+ * specified in the rule configuration. Also validates that required attribute values
+ * match expected patterns when value constraints are provided.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<RequiredAttributes, undefined>>;
 export default _default;

package/lib/required-attr/index.js

@@ -1,6 +1,13 @@
 import { createRule, getAttrSpecs } from '@markuplint/ml-core';
 import { attrMatches, match } from '../helpers.js';
 import meta from './meta.js';
+/**
+ * Rule that validates elements have all required attributes.
+ *
+ * Checks both HTML-spec-defined required attributes and custom required attributes
+ * specified in the rule configuration. Also validates that required attribute values
+ * match expected patterns when value constraints are provided.
+ */
 export default createRule({
     meta: meta,
     defaultValue: [],

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

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

package/lib/required-attr/meta.js

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

package/lib/required-element/index.d.ts

@@ -1,5 +1,19 @@
+/**
+ * Configuration options for the required-element rule.
+ */
 type Options = {
+    /** Whether to skip validation for elements that contain mutable (dynamic) content. */
     ignoreHasMutableContents: boolean;
+    /** Whether to ignore omitted (ghost) elements that are implicitly created by the HTML parser. */
+    ignoreOmittedElements: boolean;
 };
+/**
+ * Rule that validates required child elements are present.
+ *
+ * Accepts an array of CSS selectors as the rule value. For the document level,
+ * reports if any matching element is missing from the entire document. For
+ * element-level overrides, checks that the specified child elements exist
+ * among the element's direct children.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<string[], Options>>;
 export default _default;

package/lib/required-element/index.js

@@ -1,16 +1,28 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
+/**
+ * Rule that validates required child elements are present.
+ *
+ * Accepts an array of CSS selectors as the rule value. For the document level,
+ * reports if any matching element is missing from the entire document. For
+ * element-level overrides, checks that the specified child elements exist
+ * among the element's direct children.
+ */
 export default createRule({
     meta: meta,
     defaultValue: [],
     defaultOptions: {
         ignoreHasMutableContents: true,
+        ignoreOmittedElements: false,
     },
     async verify({ document, report, t }) {
         const hasMutableContent = document.nodeList.some(n => n.is(n.ELEMENT_NODE) && n.hasMutableChildren());
         if (!hasMutableContent) {
             for (const query of document.rule.value) {
-                const exists = document.querySelectorAll(query);
+                const matched = document.querySelectorAll(query);
+                const exists = document.rule.options.ignoreOmittedElements
+                    ? [...matched].filter(el => !el.isOmitted)
+                    : [...matched];
                 if (exists.length === 0) {
                     const message = t('Require {0}', t('the "{0*}" {1}', query, 'element'));
                     report({
@@ -30,7 +42,7 @@ export default createRule({
                 return;
             }
             for (const query of el.rule.value) {
-                const exists = [...el.children].find(child => child.matches(query));
+                const exists = [...el.children].find(child => !(el.rule.options.ignoreOmittedElements && child.isOmitted) && child.matches(query));
                 if (!exists) {
                     const message = t('Require {0}', t('the "{0*}" {1}', query, 'element'));
                     report({

package/lib/required-element/meta.d.ts

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

package/lib/required-element/meta.js

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

package/lib/required-h1/index.d.ts

@@ -1,6 +1,18 @@
+/**
+ * Configuration options for the required-h1 rule.
+ */
 export interface Options {
+    /** Whether to report a violation when more than one `<h1>` element is found. */
     'expected-once': boolean;
+    /** Whether to apply this rule in document fragments (components, partials). */
     'in-document-fragment': boolean;
 }
+/**
+ * Rule that requires exactly one `<h1>` element in the document.
+ *
+ * Reports a violation when no `<h1>` is present. Optionally reports when
+ * multiple `<h1>` elements exist (controlled by `expected-once`). Can be
+ * configured to skip document fragments via the `in-document-fragment` option.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, Options>>;
 export default _default;

package/lib/required-h1/index.js

@@ -1,5 +1,12 @@
 import { createRule } from '@markuplint/ml-core';
 import meta from './meta.js';
+/**
+ * Rule that requires exactly one `<h1>` element in the document.
+ *
+ * Reports a violation when no `<h1>` is present. Optionally reports when
+ * multiple `<h1>` elements exist (controlled by `expected-once`). Can be
+ * configured to skip document fragments via the `in-document-fragment` option.
+ */
 export default createRule({
     meta: meta,
     defaultOptions: {

package/lib/required-h1/meta.d.ts

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

package/lib/required-h1/meta.js

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

package/lib/table-row-column-alignment/find-children.d.ts

@@ -1,2 +1,12 @@
 import type { Element } from '@markuplint/ml-core';
+/**
+ * Finds direct children of an element matching the given CSS selector, with caching.
+ *
+ * Results are cached by element UUID and selector to avoid redundant DOM traversals
+ * when the same element/selector combination is queried multiple times.
+ *
+ * @param el - The parent element to search within.
+ * @param selector - The CSS selector to match children against.
+ * @returns An array of matching child elements.
+ */
 export declare function findChildren(el: Element<boolean>, selector: string): Element<boolean, undefined>[];

package/lib/table-row-column-alignment/find-children.js

@@ -1,4 +1,15 @@
+/** Cache for `findChildren` results, keyed by element UUID and selector. */
 const findCache = {};
+/**
+ * Finds direct children of an element matching the given CSS selector, with caching.
+ *
+ * Results are cached by element UUID and selector to avoid redundant DOM traversals
+ * when the same element/selector combination is queried multiple times.
+ *
+ * @param el - The parent element to search within.
+ * @param selector - The CSS selector to match children against.
+ * @returns An array of matching child elements.
+ */
 export function findChildren(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 el, selector) {

package/lib/table-row-column-alignment/grid.d.ts

@@ -1,22 +1,82 @@
 import type { CellType } from './types.js';
 import type { Element } from '@markuplint/ml-core';
+/**
+ * Represents a table as a grid model, splitting it into thead, tbody, and tfoot sections.
+ *
+ * Each section is modeled as a 2D array of `CellType` values that account for
+ * `colspan` and `rowspan` attributes. Used by the `table-row-column-alignment`
+ * rule to detect misaligned rows and overlapping cells.
+ */
 export declare class Grid {
     #private;
+    /** The grid model for the `<tbody>` section. */
     readonly tbodyGrid: ReadonlyArray<ReadonlyArray<CellType>>;
+    /** The grid model for the `<tfoot>` section. */
     readonly tfootGrid: ReadonlyArray<ReadonlyArray<CellType>>;
+    /** The grid model for the `<thead>` section. */
     readonly theadGrid: ReadonlyArray<ReadonlyArray<CellType>>;
+    /**
+     * Constructs a grid model from a `<table>` element.
+     *
+     * @param table - The table element to model.
+     */
     constructor(table: Element<boolean>);
+    /**
+     * Returns all `<tr>` elements across all table sections in document order.
+     *
+     * @returns Combined array of row elements from thead, tbody, and tfoot.
+     */
     getAllRowElements(): Element<boolean, undefined>[];
+    /**
+     * Returns all grid rows that contain at least one actual cell element.
+     *
+     * @returns Combined array of grid rows from thead, tbody, and tfoot, filtered to rows with real cells.
+     */
     getAllRows(): (readonly CellType[])[];
+    /**
+     * Determines the expected (base) column count for the table.
+     *
+     * Prefers the thead section if available, then tfoot, then tbody.
+     *
+     * @returns The base number of columns that rows should have.
+     */
     getBaseColLength(): number;
+    /**
+     * Returns the grid and row elements for each table section (thead, tbody, tfoot).
+     *
+     * @returns An array of objects, each containing the section grid and its row elements.
+     */
     getSections(): {
         section: readonly (readonly CellType[])[];
         elements: readonly Element<boolean, undefined>[];
     }[];
+    /**
+     * Checks whether any cell in the table grid has been marked as overlapping.
+     *
+     * @returns `true` if any cell has the overlap marker `'x'`.
+     */
     hasOverlapped(): boolean;
+    /** Logs the grid data for all three table sections to the console (for debugging). */
     log(): void;
 }
+/**
+ * Detects a rowspan that extends beyond the available rows in a table section.
+ *
+ * When a grid row exists without a corresponding row element, it indicates
+ * a rowspan overflow. Returns the offending `rowspan` attribute node if found.
+ *
+ * @param rows - The grid rows for a single table section.
+ * @param rowElements - The `<tr>` elements for the section.
+ * @returns An object containing the overflowing `rowSpan` attribute, or `null`.
+ */
 export declare function getOverflowRowSpan(rows: ReadonlyArray<ReadonlyArray<CellType>>, rowElements: ReadonlyArray<Element<boolean>>): {
     rowSpan: import("@markuplint/ml-core").Attr<boolean, undefined>;
 } | null;
+/**
+ * Maps each cell in a grid row to its source cell index (for cells that correspond
+ * to actual `<td>`/`<th>` elements), or `null` for spanned cells.
+ *
+ * @param row - A single row of cell types from the grid model.
+ * @returns An array of cell indices or `null` values, one per grid column.
+ */
 export declare function getIndexes(row: readonly CellType[]): (number | null)[];

package/lib/table-row-column-alignment/grid.js

@@ -11,12 +11,27 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _Grid_tbodyRowElements, _Grid_tfootRowElements, _Grid_theadRowElements;
 import { findChildren } from './find-children.js';
+/**
+ * Represents a table as a grid model, splitting it into thead, tbody, and tfoot sections.
+ *
+ * Each section is modeled as a 2D array of `CellType` values that account for
+ * `colspan` and `rowspan` attributes. Used by the `table-row-column-alignment`
+ * rule to detect misaligned rows and overlapping cells.
+ */
 export class Grid {
+    /**
+     * Constructs a grid model from a `<table>` element.
+     *
+     * @param table - The table element to model.
+     */
     constructor(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     table) {
+        /** The `<tr>` elements within `<tbody>`. */
         _Grid_tbodyRowElements.set(this, void 0);
+        /** The `<tr>` elements within `<tfoot>`. */
         _Grid_tfootRowElements.set(this, void 0);
+        /** The `<tr>` elements within `<thead>`. */
         _Grid_theadRowElements.set(this, void 0);
         const thead = findChildren(table, 'thead')[0];
         const tbody = findChildren(table, 'tbody')[0];
@@ -28,9 +43,19 @@ export class Grid {
         this.tbodyGrid = createGrid(__classPrivateFieldGet(this, _Grid_tbodyRowElements, "f"));
         this.tfootGrid = createGrid(__classPrivateFieldGet(this, _Grid_tfootRowElements, "f"));
     }
+    /**
+     * Returns all `<tr>` elements across all table sections in document order.
+     *
+     * @returns Combined array of row elements from thead, tbody, and tfoot.
+     */
     getAllRowElements() {
         return [...__classPrivateFieldGet(this, _Grid_theadRowElements, "f"), ...__classPrivateFieldGet(this, _Grid_tbodyRowElements, "f"), ...__classPrivateFieldGet(this, _Grid_tfootRowElements, "f")];
     }
+    /**
+     * Returns all grid rows that contain at least one actual cell element.
+     *
+     * @returns Combined array of grid rows from thead, tbody, and tfoot, filtered to rows with real cells.
+     */
     getAllRows() {
         return [
             ...this.theadGrid.filter(hasElementFilter),
@@ -38,6 +63,13 @@ export class Grid {
             ...this.tfootGrid.filter(hasElementFilter),
         ];
     }
+    /**
+     * Determines the expected (base) column count for the table.
+     *
+     * Prefers the thead section if available, then tfoot, then tbody.
+     *
+     * @returns The base number of columns that rows should have.
+     */
     getBaseColLength() {
         if (this.theadGrid.length > 0) {
             return getBaseColLength(this.theadGrid);
@@ -47,6 +79,11 @@ export class Grid {
         }
         return getBaseColLength(this.tbodyGrid);
     }
+    /**
+     * Returns the grid and row elements for each table section (thead, tbody, tfoot).
+     *
+     * @returns An array of objects, each containing the section grid and its row elements.
+     */
     getSections() {
         return [
             {
@@ -63,11 +100,17 @@ export class Grid {
             },
         ];
     }
+    /**
+     * Checks whether any cell in the table grid has been marked as overlapping.
+     *
+     * @returns `true` if any cell has the overlap marker `'x'`.
+     */
     hasOverlapped() {
         return (this.tbodyGrid.some(row => row.includes('x')) ||
             this.tfootGrid.some(row => row.includes('x')) ||
             this.theadGrid.some(row => row.includes('x')));
     }
+    /** Logs the grid data for all three table sections to the console (for debugging). */
     log() {
         // eslint-disable-next-line no-console
         console.table(this.theadGrid);
@@ -78,6 +121,16 @@ export class Grid {
     }
 }
 _Grid_tbodyRowElements = new WeakMap(), _Grid_tfootRowElements = new WeakMap(), _Grid_theadRowElements = new WeakMap();
+/**
+ * Detects a rowspan that extends beyond the available rows in a table section.
+ *
+ * When a grid row exists without a corresponding row element, it indicates
+ * a rowspan overflow. Returns the offending `rowspan` attribute node if found.
+ *
+ * @param rows - The grid rows for a single table section.
+ * @param rowElements - The `<tr>` elements for the section.
+ * @returns An object containing the overflowing `rowSpan` attribute, or `null`.
+ */
 export function getOverflowRowSpan(rows, 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 rowElements) {
@@ -114,10 +167,26 @@ rowElements) {
     }
     return null;
 }
+/**
+ * Maps each cell in a grid row to its source cell index (for cells that correspond
+ * to actual `<td>`/`<th>` elements), or `null` for spanned cells.
+ *
+ * @param row - A single row of cell types from the grid model.
+ * @returns An array of cell indices or `null` values, one per grid column.
+ */
 export function getIndexes(row) {
     let indexCounter = 0;
     return row.map(col => (col === '●' || col === '◎' ? indexCounter++ : null));
 }
+/**
+ * Calculates the base (expected) column count from a section grid.
+ *
+ * For grids with 3 or more rows, uses the row length closest to the
+ * average to handle minor variations from spans. Otherwise uses the first row.
+ *
+ * @param grid - The 2D grid for a table section.
+ * @returns The base number of columns.
+ */
 function getBaseColLength(grid) {
     let baseColLength;
     if (grid.length >= 3) {
@@ -136,6 +205,16 @@ function getBaseColLength(grid) {
     }
     return baseColLength;
 }
+/**
+ * Builds a 2D grid model from an array of `<tr>` elements.
+ *
+ * Processes each row's `<th>` and `<td>` cells, expanding `colspan` and `rowspan`
+ * attributes into the grid. Marks cells with appropriate cell types including
+ * span origins, continuations, and overlaps.
+ *
+ * @param rows - The `<tr>` elements to convert into a grid.
+ * @returns A 2D array of cell types representing the table section layout.
+ */
 function createGrid(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 rows) {
@@ -181,6 +260,12 @@ rows) {
     }
     return matrix;
 }
+/**
+ * Filter predicate that returns `true` if a grid row contains at least one actual cell element.
+ *
+ * @param row - A single row of cell types.
+ * @returns `true` if the row has a regular or span-origin cell.
+ */
 function hasElementFilter(row) {
     return row.some(cell => cell === '●' || cell === '◎');
 }

package/lib/table-row-column-alignment/index.d.ts

@@ -1,2 +1,10 @@
+/**
+ * Rule that validates table row and column alignment.
+ *
+ * Builds a grid model of each `<table>` and checks that all rows have a
+ * consistent number of columns, that `colspan`/`rowspan` attributes do not
+ * cause cell overlap, and that `rowspan` values do not exceed the available
+ * rows in their table section.
+ */
 declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, undefined>>;
 export default _default;

package/lib/table-row-column-alignment/index.js

@@ -2,6 +2,14 @@ import { createRule } from '@markuplint/ml-core';
 import { findChildren } from './find-children.js';
 import { Grid, getIndexes, getOverflowRowSpan } from './grid.js';
 import meta from './meta.js';
+/**
+ * Rule that validates table row and column alignment.
+ *
+ * Builds a grid model of each `<table>` and checks that all rows have a
+ * consistent number of columns, that `colspan`/`rowspan` attributes do not
+ * cause cell overlap, and that `rowspan` values do not exceed the available
+ * rows in their table section.
+ */
 export default createRule({
     meta,
     defaultSeverity: 'warning',

package/lib/table-row-column-alignment/meta.d.ts

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

package/lib/table-row-column-alignment/meta.js

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