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

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

@@ -1,24 +1,45 @@
 import { findChildren } from './find-children.js';
 /**
- * Represents a table as a grid model, splitting it into thead, tbody, and tfoot sections.
+ * HTML LS [§4.9.12.1 *Forming a table*](https://html.spec.whatwg.org/multipage/tables.html#forming-a-table)
+ * Step 8 clamps `colspan` to the range 1–1000.
+ */
+const MAX_COLSPAN = 1000;
+/**
+ * HTML LS [§4.9.12.1 *Forming a table*](https://html.spec.whatwg.org/multipage/tables.html#forming-a-table)
+ * Step 9 clamps `rowspan` to the range 0–65534.
+ */
+const MAX_ROWSPAN = 65_534;
+/**
+ * Models a `<table>` as the slot grid of HTML LS
+ * [§4.9.12.1 *Forming a table*](https://html.spec.whatwg.org/multipage/tables.html#forming-a-table).
+ *
+ * Shared by `no-table-cell-overlap`, `no-table-span-overflow`, `no-empty-table-track`, and
+ * `consistent-table-row-length` — the four rules split out of the former
+ * `table-row-column-alignment` rule, one per table model error / diagnostic this class models.
  *
- * 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.
+ * The algorithm is followed rather than approximated because every table model error those rules
+ * report is defined in terms of it: Step 6 decides which slot a cell is anchored to (a `colspan`
+ * after a `rowspan` continuation does *not* start at the cell's ordinal position), Steps 7 and 11
+ * decide how wide the table becomes, Step 14 defines cell overlap, and Step 20 defines rows and
+ * columns that no cell is anchored to.
+ *
+ * Two things the spec has no name for are tracked alongside:
+ *
+ * - **Row width** ({@link Row.slots} length). Rows narrower or wider than the rest of the
+ *   table are not a table model error — nu-validator reports them as warnings unless column
+ *   markup fixes the width — but they are `consistent-table-row-length`'s diagnostic and predate
+ *   the spec-level checks.
+ * - **Row group boundaries**. The spec's *ending a row group* algorithm clips a cell to its
+ *   row group, so slots are covered per group; {@link RowGroup.overflows} keeps the cells that
+ *   were clipped so `no-table-span-overflow` can report them.
  */
 export class Grid {
-    /** The grid model for the `<tbody>` section. */
-    tbodyGrid;
-    /** The grid model for the `<tfoot>` section. */
-    tfootGrid;
-    /** The grid model for the `<thead>` section. */
-    theadGrid;
-    /** The `<tr>` elements within `<tbody>`. */
-    #tbodyRowElements;
-    /** The `<tr>` elements within `<tfoot>`. */
-    #tfootRowElements;
-    /** The `<tr>` elements within `<thead>`. */
-    #theadRowElements;
+    /** Column ranges established by `<col>` / `<colgroup>`, in document order. */
+    columnMarkup;
+    /** The row groups of the table, in document order. */
+    rowGroups;
+    /** The number of slot columns in the table (spec: xwidth). */
+    xwidth;
     /**
      * Constructs a grid model from a `<table>` element.
      *
@@ -27,238 +48,290 @@ export class Grid {
     constructor(
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     table) {
-        const thead = findChildren(table, 'thead')[0];
-        const tbody = findChildren(table, 'tbody')[0];
-        const tfoot = findChildren(table, 'tfoot')[0];
-        this.#theadRowElements = thead ? findChildren(thead, 'tr') : [];
-        this.#tbodyRowElements = tbody ? findChildren(tbody, 'tr') : [];
-        this.#tfootRowElements = tfoot ? findChildren(tfoot, 'tr') : [];
-        this.theadGrid = createGrid(this.#theadRowElements);
-        this.tbodyGrid = createGrid(this.#tbodyRowElements);
-        this.tfootGrid = createGrid(this.#tfootRowElements);
-    }
-    /**
-     * Returns all `<tr>` elements across all table sections in document order.
-     *
-     * @returns Combined array of row elements from thead, tbody, and tfoot.
-     */
-    getAllRowElements() {
-        return [...this.#theadRowElements, ...this.#tbodyRowElements, ...this.#tfootRowElements];
+        this.columnMarkup = collectColumnMarkup(table);
+        // Column markup establishes the initial xwidth (spec: the *processing column groups* step).
+        let xwidth = this.columnMarkup.at(-1)?.right ?? 0;
+        const rowGroups = [];
+        for (const groupElement of findChildren(table, 'thead, tbody, tfoot')) {
+            const group = processRowGroup(groupElement, xwidth);
+            xwidth = group.xwidth;
+            rowGroups.push(group.rowGroup);
+        }
+        this.rowGroups = rowGroups;
+        this.xwidth = xwidth;
     }
-    /**
-     * 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),
-            ...this.tbodyGrid.filter(hasElementFilter),
-            ...this.tfootGrid.filter(hasElementFilter),
-        ];
+    /** @returns Every cell anchored in the table, in document order. */
+    getAnchors() {
+        return this.rowGroups.flatMap(group => group.anchors);
     }
     /**
-     * Determines the expected (base) column count for the table.
+     * Determines the expected (base) column count that rows are compared against.
      *
-     * Prefers the thead section if available, then tfoot, then tbody.
+     * Rows decide it, preferring `<thead>` then `<tfoot>` since a heading or footing
+     * row is the more deliberate declaration. Column markup is deliberately *not*
+     * consulted: HTML LS §4.9.12.1 Step 7 grows xwidth to fit a row that is wider
+     * than the `<col>` markup, so such a row is not an error (tracked as a
+     * nu-validator over-detection in `tests/external/snapshots/excluded-ids.json`).
+     * A row narrower than the column markup is caught by the Step 20 column scan
+     * instead, which reports the `<col>` that no cell ever starts in.
      *
      * @returns The base number of columns that rows should have.
      */
     getBaseColLength() {
-        if (this.theadGrid.length > 0) {
-            return getBaseColLength(this.theadGrid);
-        }
-        if (this.tfootGrid.length > 0) {
-            return getBaseColLength(this.tfootGrid);
-        }
-        return getBaseColLength(this.tbodyGrid);
+        const preferred = this.rowGroups.find(group => group.tagName === 'thead' && group.rows.length > 0) ??
+            this.rowGroups.find(group => group.tagName === 'tfoot' && group.rows.length > 0) ??
+            this.rowGroups.find(group => group.rows.length > 0);
+        return preferred ? getBaseColLength(preferred.rows) : 0;
     }
     /**
-     * Returns the grid and row elements for each table section (thead, tbody, tfoot).
+     * Collects the columns that no cell is anchored to (spec Step 20), merging
+     * neighbouring columns that the same element established into one range so a
+     * `colspan` overshooting by four columns is reported once, not four times.
      *
-     * @returns An array of objects, each containing the section grid and its row elements.
+     * @returns The offending ranges, in column order.
      */
-    getSections() {
-        return [
-            {
-                section: this.theadGrid,
-                elements: this.#theadRowElements,
-            },
-            {
-                section: this.tbodyGrid,
-                elements: this.#tbodyRowElements,
-            },
-            {
-                section: this.tfootGrid,
-                elements: this.#tfootRowElements,
-            },
-        ];
+    getColumnsWithoutAnchor() {
+        const anchors = this.getAnchors();
+        const anchored = new Set(anchors.map(anchor => anchor.x));
+        const ranges = [];
+        for (let x = 0; x < this.xwidth; x++) {
+            if (anchored.has(x)) {
+                continue;
+            }
+            const source = this.#findColumnSource(x, anchors);
+            if (!source) {
+                continue;
+            }
+            const last = ranges.at(-1);
+            if (last && last.source === source && last.right === x) {
+                ranges[ranges.length - 1] = { source, left: last.left, right: x + 1 };
+                continue;
+            }
+            ranges.push({ source, left: x, right: x + 1 });
+        }
+        return ranges;
+    }
+    /** @returns Every row of the table, in document order. */
+    getRows() {
+        return this.rowGroups.flatMap(group => group.rows);
     }
     /**
-     * Checks whether any cell in the table grid has been marked as overlapping.
+     * Checks whether any slot of the table is covered by more than one cell.
      *
-     * @returns `true` if any cell has the overlap marker `'x'`.
+     * @returns `true` if the table has a Step 14 cell overlap.
      */
     hasOverlapped() {
-        return (this.tbodyGrid.some(row => row.includes('x')) ||
-            this.tfootGrid.some(row => row.includes('x')) ||
-            this.theadGrid.some(row => row.includes('x')));
+        return this.rowGroups.some(group => group.hasOverlap);
     }
-    /** 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);
-        // eslint-disable-next-line no-console
-        console.table(this.tbodyGrid);
-        // eslint-disable-next-line no-console
-        console.table(this.tfootGrid);
+    /**
+     * Resolves which element is answerable for a column: the column markup that
+     * declared it, or else the cell whose `colspan` stretched the table over it.
+     *
+     * @param x - The column index.
+     * @param anchors - The anchors of the table.
+     * @returns The element, or `null` when nothing covers the column.
+     */
+    #findColumnSource(x, anchors) {
+        const markup = this.columnMarkup.find(range => range.left <= x && x < range.right);
+        if (markup) {
+            return markup.source;
+        }
+        const spanning = anchors.find(anchor => anchor.x < x && x < anchor.x + anchor.colspan);
+        return spanning?.cell ?? null;
     }
 }
 /**
- * Detects a rowspan that extends beyond the available rows in a table section.
+ * Maps each slot of a row to the index of the `<th>` / `<td>` anchored to it
+ * (counted among the row's own cells), or `null` for a slot the row does not anchor a cell to.
  *
- * When a grid row exists without a corresponding row element, it indicates
- * a rowspan overflow. Returns the offending `rowspan` attribute node if found.
+ * @param slots - The slots of a single row.
+ * @returns An array of cell indices or `null` values, one per slot.
+ */
+export function getIndexes(slots) {
+    let indexCounter = 0;
+    return slots.map(slot => (slot === '●' || slot === '◎' ? indexCounter++ : null));
+}
+/**
+ * Collects the column ranges that `<col>` and `<colgroup>` establish.
  *
- * @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`.
+ * A `<colgroup>` contributes its own `span` only when it has no `<col>` children,
+ * mirroring HTML LS §4.9.3: the `span` attribute of a `<colgroup>` "must not be
+ * specified if the element contains one or more `col` elements".
+ *
+ * @param table - The table element.
+ * @returns The ranges in document order.
  */
-export function getOverflowRowSpan(rows, 
+function collectColumnMarkup(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-rowElements) {
-    for (const [rowNum] of rows.entries()) {
-        const rowEl = rowElements[rowNum];
-        if (!rowEl) {
-            const prevRow = rows[rowNum - 1];
-            const prevRowEl = rowElements[rowNum - 1];
-            if (!prevRow || !prevRowEl) {
-                continue;
-            }
-            const spanStart = prevRow.indexOf('◎');
-            if (spanStart === -1) {
-                continue;
-            }
-            const indexes = getIndexes(prevRow);
-            const index = indexes[spanStart];
-            if (index == null) {
-                continue;
-            }
-            const cells = findChildren(prevRowEl, 'th, td');
-            const spanStartCell = cells[index];
-            if (!spanStartCell) {
-                continue;
-            }
-            const rowSpan = spanStartCell.getAttributeNode('rowspan');
-            if (!rowSpan) {
-                continue;
-            }
-            return {
-                rowSpan,
-            };
+table) {
+    const ranges = [];
+    let left = 0;
+    const append = (
+    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+    source) => {
+        const span = parseSpan(source.getAttribute('span'), 1, 1, MAX_COLSPAN);
+        ranges.push({ source, left, right: left + span });
+        left += span;
+    };
+    for (const child of findChildren(table, 'colgroup, col')) {
+        if (child.localName === 'col') {
+            append(child);
+            continue;
+        }
+        const cols = findChildren(child, 'col');
+        if (cols.length === 0) {
+            append(child);
+            continue;
+        }
+        for (const col of cols) {
+            append(col);
         }
     }
-    return null;
+    return ranges;
 }
 /**
- * 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.
+ * Calculates the base (expected) column count from the rows of a row group.
+ *
+ * For groups with 3 or more rows, uses the row width closest to the average so a
+ * single malformed row does not become the baseline. Otherwise uses the first row.
  *
- * @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.
+ * @param rows - The rows of a row group.
+ * @returns The base number of columns.
  */
-export function getIndexes(row) {
-    let indexCounter = 0;
-    return row.map(col => (col === '●' || col === '◎' ? indexCounter++ : null));
+function getBaseColLength(rows) {
+    if (rows.length < 3) {
+        return rows[0]?.slots.length ?? 0;
+    }
+    let totalCols = 0;
+    for (const row of rows) {
+        totalCols += row.slots.length;
+    }
+    const average = Math.round(totalCols / rows.length);
+    let closest = rows[0]?.slots.length ?? 0;
+    for (const row of rows) {
+        if (Math.abs(row.slots.length - average) < Math.abs(closest - average)) {
+            closest = row.slots.length;
+        }
+    }
+    return closest;
 }
 /**
- * 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.
+ * Parses a `colspan` / `rowspan` / `span` attribute value the way HTML LS does:
+ * a value that is missing or fails to parse falls back to the default, and a parsed
+ * value is clamped to the range the spec allows.
  *
- * @param grid - The 2D grid for a table section.
- * @returns The base number of columns.
+ * @param value - The raw attribute value.
+ * @param fallback - The value to use when the attribute is absent or fails to parse.
+ * @param min - The lower bound of the clamp range.
+ * @param max - The upper bound of the clamp range.
+ * @returns The effective span.
  */
-function getBaseColLength(grid) {
-    let baseColLength;
-    if (grid.length >= 3) {
-        const totalCols = grid.reduce((acc, row) => {
-            return acc + row.length;
-        }, 0);
-        const average = Math.round(totalCols / grid.length);
-        baseColLength = grid
-            // eslint-disable-next-line unicorn/no-array-reduce
-            .reduce((closest, row) => {
-            return Math.abs(row.length - average) < Math.abs(closest - average) ? row.length : closest;
-        }, grid[0]?.length ?? 0);
+function parseSpan(value, fallback, min, max) {
+    if (value == null) {
+        return fallback;
     }
-    else {
-        baseColLength = grid[0]?.length ?? 0;
+    const digits = /^[\t\n\f\r ]*(\d+)/.exec(value);
+    if (!digits?.[1]) {
+        return fallback;
     }
-    return baseColLength;
+    return Math.min(Math.max(Number.parseInt(digits[1], 10), min), max);
 }
 /**
- * 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.
+ * Runs the spec's *algorithm for processing rows* over one row group.
  *
- * @param rows - The `<tr>` elements to convert into a grid.
- * @returns A 2D array of cell types representing the table section layout.
+ * @param groupElement - The `<thead>` / `<tbody>` / `<tfoot>` element.
+ * @param initialXwidth - The table's xwidth before this group is processed.
+ * @returns The modelled row group and the xwidth the group grew the table to.
  */
-function createGrid(
+function processRowGroup(
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-rows) {
-    const rowSpans = new Set();
-    const matrix = [];
-    for (const [rowNum, row] of rows.entries()) {
-        const cols = findChildren(row, 'th, td');
-        let colNum = 0;
-        matrix[rowNum] = matrix[rowNum] ?? [];
-        for (const col of cols) {
-            const colSpan = Number.parseInt(col.getAttribute('colspan') ?? '1');
-            const rowSpan = Number.parseInt(col.getAttribute('rowspan') ?? '1');
-            for (let i = 0; i < colSpan; i++) {
-                const key = `${rowNum}:${colNum}`;
-                let spanStart = false;
-                if (colSpan > 1 && i === 0) {
-                    spanStart = true;
-                }
-                if (rowSpan > 1) {
-                    if (i === 0) {
-                        spanStart = true;
-                    }
-                    for (let i = 1; i <= rowSpan - 1; i++) {
-                        matrix[rowNum + i] = matrix[rowNum + i] ?? [];
-                        matrix[rowNum + i][colNum] = '↓';
-                        rowSpans.add(`${rowNum + i}:${colNum}`);
+groupElement, initialXwidth) {
+    const rowElements = findChildren(groupElement, 'tr');
+    const rowCount = rowElements.length;
+    /** The anchor covering each slot, keyed by `"row:column"`. */
+    const covered = new Map();
+    /** Slots a second cell tried to cover (spec Step 14). */
+    const overlapped = new Set();
+    const anchors = [];
+    const overflows = [];
+    const widths = [];
+    const anchorCounts = [];
+    let xwidth = initialXwidth;
+    for (const [y, rowElement] of rowElements.entries()) {
+        let xcurrent = 0;
+        let anchorCount = 0;
+        for (const cell of findChildren(rowElement, 'th, td')) {
+            const colspan = parseSpan(cell.getAttribute('colspan'), 1, 1, MAX_COLSPAN);
+            const declaredRowspan = parseSpan(cell.getAttribute('rowspan'), 1, 0, MAX_ROWSPAN);
+            const growsDownward = declaredRowspan === 0;
+            const rowspan = growsDownward ? Math.max(rowCount - y, 1) : declaredRowspan;
+            // Step 6
+            while (xcurrent < xwidth && covered.has(`${y}:${xcurrent}`)) {
+                xcurrent += 1;
+            }
+            // Step 7
+            if (xcurrent === xwidth) {
+                xwidth += 1;
+            }
+            // Step 11
+            xwidth = Math.max(xwidth, xcurrent + colspan);
+            const anchor = { cell, x: xcurrent, y, colspan, rowspan, growsDownward };
+            anchors.push(anchor);
+            anchorCount += 1;
+            // Steps 13 and 14. The bottom is clipped to the row group per *ending a row group*.
+            const bottom = Math.min(y + rowspan, rowCount);
+            for (let cy = y; cy < bottom; cy++) {
+                for (let cx = xcurrent; cx < xcurrent + colspan; cx++) {
+                    const key = `${cy}:${cx}`;
+                    if (covered.has(key)) {
+                        overlapped.add(key);
+                        continue;
                     }
+                    covered.set(key, anchor);
                 }
-                const addCol = rowSpans.has(key) ? 1 : 0;
-                if (matrix[rowNum]?.[colNum] === '↓' && !spanStart && colSpan > 1) {
-                    // Overlap
-                    matrix[rowNum][colNum] = 'x';
-                }
-                else {
-                    matrix[rowNum][colNum] = spanStart ? '◎' : addCol > 0 ? '↓' : colSpan > 1 ? '→' : '●';
-                }
-                if (addCol === 1) {
-                    matrix[rowNum].push('●');
-                }
-                colNum += 1;
             }
+            if (!growsDownward && y + rowspan > rowCount) {
+                overflows.push(anchor);
+            }
+            xcurrent += colspan;
+        }
+        // The row is as wide as its own cells plus the run of continuing spans that follows them.
+        while (covered.has(`${y}:${xcurrent}`)) {
+            xcurrent += 1;
         }
+        widths[y] = xcurrent;
+        anchorCounts[y] = anchorCount;
     }
-    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 === '◎');
+    const rows = rowElements.map((element, y) => {
+        const slots = [];
+        for (let x = 0; x < (widths[y] ?? 0); x++) {
+            const key = `${y}:${x}`;
+            if (overlapped.has(key)) {
+                slots.push('x');
+                continue;
+            }
+            const anchor = covered.get(key);
+            if (!anchor) {
+                continue;
+            }
+            slots.push(anchor.x === x && anchor.y === y
+                ? anchor.colspan > 1 || anchor.rowspan > 1
+                    ? '◎'
+                    : '●'
+                : anchor.y === y
+                    ? '→'
+                    : '↓');
+        }
+        return { element, slots, anchorCount: anchorCounts[y] ?? 0 };
+    });
+    return {
+        rowGroup: {
+            tagName: groupElement.localName,
+            rows,
+            anchors,
+            overflows,
+            hasOverlap: overlapped.size > 0,
+        },
+        xwidth,
+    };
 }

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

@@ -1,12 +1,10 @@
-/** A grid cell coordinate key in "row:column" format. */
-export type Key = `${number}:${number}`;
 /**
- * Represents the type of a cell in the table grid model.
+ * Represents what covers one slot of the table grid.
  *
- * - `'●'` - A regular cell (single-span).
- * - `'◎'` - The origin cell of a colspan or rowspan.
- * - `'↓'` - A cell occupied by a rowspan from a row above.
- * - `'→'` - A cell occupied by a colspan from a column to the left.
- * - `'x'` - An overlapping cell caused by conflicting spans.
+ * - `'●'` - A cell is anchored here and spans nothing else.
+ * - `'◎'` - A cell is anchored here and spans further columns and/or rows.
+ * - `'↓'` - Covered by a cell anchored in an earlier row.
+ * - `'→'` - Covered by a cell anchored earlier in the same row.
+ * - `'x'` - Covered by more than one cell (HTML LS §4.9.12.1 Step 14).
  */
 export type CellType = '●' | '◎' | '↓' | '→' | 'x';

package/lib/usemap-references-map/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Require the `usemap` attribute on an `<img>` element to be a valid
+ * hash-name reference to a `<map>` element. Per HTML LS's definition of
+ * "valid hash-name reference": a string consisting of "#" followed by a
+ * string that exactly matches the `name` attribute of an element of the
+ * referenced type in the same tree — matching is by `name`, not `id`, so
+ * `no-refer-to-non-existent-id` (which only tracks `id` references) never
+ * covers this attribute.
+ *
+ * @see https://html.spec.whatwg.org/multipage/image-maps.html#attr-hyperlink-usemap
+ * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-hash-name-reference
+ */
+declare const _default: Readonly<import("@markuplint/ml-core").RuleSeed<boolean, null>>;
+export default _default;

package/lib/usemap-references-map/index.js

@@ -0,0 +1,46 @@
+import { createRule } from '@markuplint/ml-core';
+import meta from './meta.js';
+/**
+ * Require the `usemap` attribute on an `<img>` element to be a valid
+ * hash-name reference to a `<map>` element. Per HTML LS's definition of
+ * "valid hash-name reference": a string consisting of "#" followed by a
+ * string that exactly matches the `name` attribute of an element of the
+ * referenced type in the same tree — matching is by `name`, not `id`, so
+ * `no-refer-to-non-existent-id` (which only tracks `id` references) never
+ * covers this attribute.
+ *
+ * @see https://html.spec.whatwg.org/multipage/image-maps.html#attr-hyperlink-usemap
+ * @see https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#valid-hash-name-reference
+ */
+export default createRule({
+    meta: meta,
+    defaultValue: true,
+    defaultOptions: null,
+    async verify({ document, report, t }) {
+        await document.walkOn('Element', el => {
+            if (el.localName !== 'img')
+                return;
+            if (el.pretenderContext?.type === 'pretender' && !el.hasAttribute('as'))
+                return;
+            const usemapAttr = el.getAttributeNode('usemap');
+            if (!usemapAttr)
+                return;
+            if (usemapAttr.isDynamicValue)
+                return;
+            const value = usemapAttr.value;
+            if (!value.startsWith('#') || value.length <= 1)
+                return;
+            const targetName = value.slice(1);
+            const target = [...document.querySelectorAll('map')].find(candidate => candidate.getAttribute('name') === targetName);
+            if (!target) {
+                report({
+                    scope: usemapAttr,
+                    line: usemapAttr.valueNode?.startLine,
+                    col: usemapAttr.valueNode?.startCol,
+                    raw: usemapAttr.valueNode?.raw,
+                    message: t('The "{0}" attribute of the "{1}" element must be a valid hash-name reference to a "{2}" element', 'usemap', 'img', 'map'),
+                });
+            }
+        });
+    },
+});

package/lib/usemap-references-map/meta.d.ts

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

package/lib/usemap-references-map/meta.js

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

package/lib/valid-importmap/index.d.ts

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