asciidoclint 0.5.0

package/dist/rules/AD004.js

@@ -0,0 +1,58 @@
+import { countTableCells } from "./utils.js";
+export const AD004 = {
+    id: "AD004",
+    alias: "table-cell-count",
+    description: "Table source should not contain cells omitted from rendered output",
+    tags: ["core", "table"],
+    parser: "document",
+    docs: {
+        summary: "A table should not end with incomplete cells that Asciidoctor omits from the rendered output.",
+        fixability: "no",
+        fixHelper: "Add missing table cells, remove leftover cells, or make intended row and column spans explicit so every source cell appears in the rendered table.",
+        badExamples: [{ code: "[cols=\"1,1\"]\n|===\n| one | two | omitted\n|===" }],
+        goodExamples: [{ code: "[cols=\"1,1\"]\n|===\n| one | two\n|===" }],
+    },
+    function: ({ document }, onError) => {
+        for (const block of document.blocks.filter((entry) => entry.type === "table")) {
+            if (!block.range.end || block.attributes.format || block.attributes.separator) {
+                continue;
+            }
+            const file = document.files.find((entry) => entry.file === block.range.start.file);
+            if (!file) {
+                continue;
+            }
+            if (containsNestedDefaultPsvTable(file.lines, block.range.start.line, block.range.end.line)) {
+                continue;
+            }
+            const sourceCells = countSourceCells(file.lines, block.range.start.line, block.range.end.line);
+            const renderedCells = block.table?.renderedCellCount;
+            if (renderedCells !== undefined && sourceCells > renderedCells) {
+                onError({
+                    severity: "warning",
+                    message: `Table source has ${sourceCells - renderedCells} cell${sourceCells - renderedCells === 1 ? "" : "s"} that Asciidoctor did not render`,
+                    range: { start: block.range.start },
+                    fixHelper: "Add the missing cells, remove the extra cells, or make the intended row and column spans explicit.",
+                });
+            }
+        }
+    },
+};
+function countSourceCells(lines, startLine, endLine) {
+    let count = 0;
+    for (let index = startLine; index < endLine - 1; index += 1) {
+        const line = lines[index] ?? "";
+        if (line.trim() === "|===") {
+            continue;
+        }
+        count += countTableCells(line);
+    }
+    return count;
+}
+function containsNestedDefaultPsvTable(lines, startLine, endLine) {
+    for (let index = startLine; index < endLine - 1; index += 1) {
+        if ((lines[index] ?? "").trim() === "|===") {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/rules/AD005.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const AD005: Rule;

package/dist/rules/AD005.js

@@ -0,0 +1,31 @@
+export const AD005 = {
+    id: "AD005",
+    alias: "explicit-document-title",
+    description: "Root documents should provide an explicit document title",
+    tags: ["core", "headings"],
+    parser: "document",
+    docs: {
+        summary: "A root AsciiDoc document should have an explicit document title, either as a level-0 title, :doctitle:, :title:, or a wrapper title include.",
+        rationale: "Document titles are optional in Asciidoctor article and book documents, but explicit titles make generated metadata and visible document structure more predictable.",
+        fixability: "no",
+        fixHelper: "Add an explicit '= Title', ':doctitle:', or ':title:' to the root document, or make the wrapper document include a title page as its first include.",
+        badExamples: [{ code: "== Overview\n\nContent." }],
+        goodExamples: [
+            { code: "= Product Guide\n\n== Overview\n\nContent." },
+            { code: ":doctitle: Product Guide\n\n== Overview\n\nContent." },
+            { code: ":title: Product Guide\n\n== Overview\n\nContent." },
+            { code: ":doctype: book\n\n= Product Guide\n\n= Part One\n\n== Chapter One" },
+            { code: "include::title-page.adoc[]\ninclude::chapter.adoc[]\n\n// title-page.adoc\n= Product Guide" },
+        ],
+    },
+    function: ({ document }, onError) => {
+        if (!document.sections.some((section) => section.level === 0) && !document.attributes.title && !document.attributes.doctitle) {
+            onError({
+                severity: "info",
+                message: "Document is missing an explicit document title",
+                range: { start: { file: document.file, line: 1, column: 1 } },
+                fixHelper: "Add a document title such as '= Title' before the first section, or set :title: / :doctitle: in the header.",
+            });
+        }
+    },
+};

package/dist/rules/AD006.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const AD006: Rule;

package/dist/rules/AD006.js

@@ -0,0 +1,53 @@
+import path from "node:path";
+export const AD006 = {
+    id: "AD006",
+    alias: "included-document-title",
+    description: "Included AsciiDoc files should not introduce a level-0 title without level offset",
+    tags: ["core", "include", "headings"],
+    parser: "document",
+    docs: {
+        summary: "Included files should not introduce article level-0 sections unless the include applies leveloffset or intentionally supplies the root document title.",
+        rationale: "A level-0 title inside an article include creates an invalid extra level-0 section unless the including document explicitly offsets section levels. Wrapper documents may intentionally use their first include as the root document title, and book documents may intentionally include level-0 parts.",
+        fixability: "no",
+        fixHelper: "For article parents, add leveloffset to the include or change the included file heading to the section level expected by the parent. Keep the level-0 heading only for wrapper-title includes or doctype=book part files.",
+        badExamples: [{ code: "= Root Title\n\ninclude::chapter.adoc[]\n\n// chapter.adoc\n= Chapter Title" }],
+        goodExamples: [
+            { code: "include::chapter.adoc[leveloffset=+1]\n\n// chapter.adoc\n= Chapter Title" },
+            { code: "include::title-page.adoc[]\ninclude::chapter.adoc[]\n\n// title-page.adoc\n= Document Title" },
+            { code: ":doctype: book\n\n= Book Title\n\ninclude::part-one.adoc[]\n\n// part-one.adoc\n= Part One\n\n== Chapter One" },
+        ],
+    },
+    function: ({ document }, onError) => {
+        const includesWithoutLevelOffset = document.includes
+            .filter((include) => include.status === "resolved" && include.resolvedTarget)
+            .filter((include) => include.attributes.leveloffset === undefined)
+            .map((include) => ({ ...include, resolvedTarget: path.resolve(include.resolvedTarget) }));
+        for (const section of document.sections) {
+            const include = includesWithoutLevelOffset.find((record) => record.resolvedTarget === path.resolve(section.range.start.file));
+            if (section.level === 0
+                && include
+                && document.attributes.doctype !== "book"
+                && !isRootTitleInclude(document.file, include, section, document.sections)) {
+                onError({
+                    severity: "error",
+                    message: "Included file starts with a level-0 document title",
+                    range: section.range,
+                    fixHelper: "Add leveloffset to the include directive in the parent file or change this included heading to the section level expected by the parent.",
+                });
+            }
+        }
+    },
+};
+function isRootTitleInclude(rootFile, include, section, sections) {
+    const root = path.resolve(rootFile);
+    if (path.resolve(include.range.start.file) !== root) {
+        return false;
+    }
+    const firstLevelZero = sections.find((candidate) => candidate.level === 0);
+    if (!firstLevelZero || path.resolve(firstLevelZero.range.start.file) !== path.resolve(section.range.start.file)) {
+        return false;
+    }
+    return !sections.some((candidate) => candidate.level === 0
+        && path.resolve(candidate.range.start.file) === root
+        && candidate.range.start.line < include.range.start.line);
+}

package/dist/rules/AD007.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const AD007: Rule;

package/dist/rules/AD007.js

@@ -0,0 +1,39 @@
+import { isLineInProtectedBlock } from "./utils.js";
+export const AD007 = {
+    id: "AD007",
+    alias: "heading-depth-limit",
+    description: "Section headings should not exceed Asciidoctor's supported depth",
+    tags: ["core", "headings"],
+    parser: "text",
+    docs: {
+        summary: "AsciiDoc section heading markers should stay within Asciidoctor's supported level range.",
+        rationale: "Asciidoctor only recognizes section levels 0 through 5. Deeper heading-like lines render as paragraph text, so the intended section disappears from the document outline.",
+        fixability: "no",
+        fixHelper: "Reduce the heading marker to six or fewer = / # characters, or split the content into a separate document if the hierarchy is too deep.",
+        badExamples: [{ code: "= Title\n\n======= Too Deep" }],
+        goodExamples: [{ code: "= Title\n\n== Parent\n\n=== Child\n\n==== Level 3\n\n===== Level 4\n\n====== Deepest Supported" }],
+    },
+    function: ({ document }, onError) => {
+        for (const file of document.files) {
+            for (let index = 0; index < file.lines.length; index += 1) {
+                const line = file.lines[index] ?? "";
+                if (isLineInProtectedBlock(document, file.file, index + 1)) {
+                    continue;
+                }
+                const marker = unsupportedHeadingMarker(line);
+                if (!marker) {
+                    continue;
+                }
+                onError({
+                    severity: "error",
+                    message: `Heading marker ${marker} exceeds Asciidoctor's supported section depth`,
+                    range: { start: { file: file.file, line: index + 1, column: 1 } },
+                    fixHelper: "Reduce the heading depth to level 5 or less, or split the content into a separate document.",
+                });
+            }
+        }
+    },
+};
+function unsupportedHeadingMarker(line) {
+    return line.match(/^(={7,}|#{7,})\s+\S/)?.[1];
+}

package/dist/rules/AD008.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const AD008: Rule;

package/dist/rules/AD008.js

@@ -0,0 +1,88 @@
+import { isExemptBeforeListLine, isLineComment, isLineInProtectedBlock, isLineInTableBlock, isListMarkerLine } from "./utils.js";
+export const AD008 = {
+    id: "AD008",
+    alias: "blank-before-list",
+    description: "Lists should be separated from preceding paragraph text",
+    tags: ["core", "lists", "blank_lines"],
+    parser: "text",
+    docs: {
+        summary: "A list should have a blank line before the first list item unless it follows another structural line.",
+        rationale: "Without a blank line, Asciidoctor treats a would-be list marker after paragraph text as paragraph continuation text, so the intended list is not created.",
+        fixability: "safe",
+        fixHelper: "Insert one blank line before the list marker.",
+        badExamples: [{ code: "Paragraph\n* item" }],
+        goodExamples: [{ code: "Paragraph\n\n* item" }],
+    },
+    function: ({ document }, onError) => {
+        for (const file of document.files) {
+            for (let index = 1; index < file.lines.length; index += 1) {
+                const line = file.lines[index] ?? "";
+                if (isLineComment(line)
+                    || !isListMarkerLine(line)
+                    || isIndentedListMarkerLine(line)
+                    || isLineInProtectedBlock(document, file.file, index + 1)
+                    || isLineInTableBlock(document, file.file, index + 1)) {
+                    continue;
+                }
+                const previous = file.lines[index - 1] ?? "";
+                if (isExemptBeforeListLine(previous)) {
+                    continue;
+                }
+                if (hasTableCellContextBefore(file.lines, index)) {
+                    continue;
+                }
+                if (hasContinuationContextBefore(file.lines, index)) {
+                    continue;
+                }
+                const lineNumber = index + 1;
+                onError({
+                    severity: "warning",
+                    message: "List should be preceded by a blank line",
+                    range: { start: { file: file.file, line: lineNumber, column: 1 } },
+                    fix: {
+                        applicability: "safe",
+                        edits: [{
+                                file: file.file,
+                                range: {
+                                    start: { file: file.file, line: lineNumber, column: 1 },
+                                    end: { file: file.file, line: lineNumber, column: 1 },
+                                },
+                                replacement: "\n",
+                            }],
+                    },
+                });
+            }
+        }
+    },
+};
+function hasContinuationContextBefore(lines, index) {
+    for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+        const trimmed = (lines[cursor] ?? "").trim();
+        if (trimmed === "") {
+            return false;
+        }
+        if (trimmed === "+") {
+            return true;
+        }
+        if (isListMarkerLine(lines[cursor] ?? "")) {
+            return true;
+        }
+    }
+    return false;
+}
+function isIndentedListMarkerLine(line) {
+    return /^\s+\S/.test(line);
+}
+function hasTableCellContextBefore(lines, index) {
+    for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+        const trimmed = (lines[cursor] ?? "").trim();
+        if (trimmed === "") {
+            continue;
+        }
+        if (/^a\|/.test(trimmed) || /(^|\s)a\|\s*$/.test(trimmed) || /\sa\|\s*\S*$/.test(trimmed)) {
+            return true;
+        }
+        return false;
+    }
+    return false;
+}

package/dist/rules/AD010.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const AD010: Rule;

package/dist/rules/AD010.js

@@ -0,0 +1,39 @@
+import { hasTitleImmediatelyBefore } from "./utils.js";
+export const AD010 = {
+    id: "AD010",
+    alias: "table-title",
+    description: "Table blocks should have a title",
+    tags: ["core", "table"],
+    parser: "document",
+    docs: {
+        summary: "A block table should have a preceding .Title line.",
+        rationale: "Table titles make rendered tables referenceable and easier to review.",
+        fixability: "no",
+        fixHelper: "Add a table title using .Title immediately before the table metadata, or set title=\"...\" in the table attribute list.",
+        badExamples: [{ code: "|===\n| A | B\n|===" }],
+        goodExamples: [{ code: ".Register fields\n|===\n| A | B\n|===" }],
+    },
+    function: ({ document }, onError) => {
+        const files = new Map(document.files.map((file) => [file.file, file.lines]));
+        for (const block of document.blocks.filter((entry) => entry.type === "table")) {
+            const lines = files.get(block.range.start.file);
+            if (!lines) {
+                continue;
+            }
+            const index = block.range.start.line - 1;
+            if (isTableCellLine(lines[index - 1] ?? "") || block.title || hasTitleImmediatelyBefore(lines, index)) {
+                continue;
+            }
+            onError({
+                severity: "warning",
+                message: "Table block should have a title",
+                range: { start: { file: block.range.start.file, line: block.range.start.line, column: 1 } },
+                fixHelper: "Add a .Title line immediately before the table.",
+            });
+        }
+    },
+};
+function isTableCellLine(line) {
+    const trimmed = line.trim();
+    return trimmed.startsWith("|") && trimmed !== "|===";
+}

package/dist/rules/AD011.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const AD011: Rule;

package/dist/rules/AD011.js

@@ -0,0 +1,31 @@
+export const AD011 = {
+    id: "AD011",
+    alias: "image-title",
+    description: "Block images should have a title",
+    tags: ["core", "image"],
+    parser: "document",
+    docs: {
+        summary: "A block image should have a preceding .Title line.",
+        rationale: "Image titles preserve figure intent and make generated output easier to navigate.",
+        fixability: "no",
+        fixHelper: "Add a figure title using .Title immediately before the image, or set title=\"...\" in the block image macro.",
+        badExamples: [{ code: "image::diagram.png[Architecture]" }],
+        goodExamples: [{ code: ".Architecture overview\nimage::diagram.png[Architecture]" }],
+    },
+    function: ({ document }, onError) => {
+        for (const block of document.blocks.filter((entry) => entry.type === "image")) {
+            if (block.title || hasExemptImageRole(block.attributes.role)) {
+                continue;
+            }
+            onError({
+                severity: "warning",
+                message: "Block image should have a title",
+                range: { start: block.range.start },
+                fixHelper: "Add a .Title line, [title=\"...\"], or a title attribute to the image macro.",
+            });
+        }
+    },
+};
+function hasExemptImageRole(role) {
+    return typeof role === "string" && /\bcover-image\b/i.test(role);
+}

package/dist/rules/AD012.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const AD012: Rule;

package/dist/rules/AD012.js

@@ -0,0 +1,28 @@
+export const AD012 = {
+    id: "AD012",
+    alias: "diagram-title",
+    description: "Diagram blocks should have a title",
+    tags: ["core", "diagram"],
+    parser: "document",
+    docs: {
+        summary: "A diagram block should have a preceding .Title line.",
+        rationale: "Diagram titles make generated figures understandable and referenceable.",
+        fixability: "no",
+        fixHelper: "Add a diagram title using .Title immediately before the diagram block metadata, or set title=\"...\" in the diagram attribute list.",
+        badExamples: [{ code: "[mermaid]\n----\ngraph LR\n----" }],
+        goodExamples: [{ code: ".System flow\n[mermaid]\n----\ngraph LR\n----" }],
+    },
+    function: ({ document }, onError) => {
+        for (const block of document.blocks.filter((entry) => entry.type === "diagram")) {
+            if (block.title) {
+                continue;
+            }
+            onError({
+                severity: "warning",
+                message: "Diagram block should have a title",
+                range: { start: block.range.start },
+                fixHelper: "Add a .Title line or title=\"...\" metadata to the diagram block.",
+            });
+        }
+    },
+};

package/dist/rules/AD013.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const AD013: Rule;

package/dist/rules/AD013.js

@@ -0,0 +1,43 @@
+import { isLineInProtectedBlock } from "./utils.js";
+export const AD013 = {
+    id: "AD013",
+    alias: "standalone-inline-image",
+    description: "Standalone image macros should use block image syntax",
+    tags: ["core", "image"],
+    parser: "text",
+    docs: {
+        summary: "A line containing only an inline image macro should be written as a block image macro.",
+        rationale: "Standalone inline image macros can render with paragraph spacing and caption behavior that differs from figures.",
+        fixability: "unsafe",
+        fixHelper: "Use image::target[alt] for standalone figures, and reserve image:target[alt] for inline images inside text.",
+        badExamples: [{ code: "image:diagram.png[Architecture]" }],
+        goodExamples: [{ code: "image::diagram.png[Architecture]" }],
+    },
+    function: ({ document }, onError) => {
+        for (const file of document.files) {
+            for (const [index, line] of file.lines.entries()) {
+                const match = line.match(/^image:(?!:)(\S.*\[[^\]]*]\s*)$/);
+                if (!match || isLineInProtectedBlock(document, file.file, index + 1)) {
+                    continue;
+                }
+                const lineNumber = index + 1;
+                onError({
+                    severity: "warning",
+                    message: "Standalone image macro should use block image syntax",
+                    range: { start: { file: file.file, line: lineNumber, column: 1 } },
+                    fix: {
+                        applicability: "unsafe",
+                        edits: [{
+                                file: file.file,
+                                range: {
+                                    start: { file: file.file, line: lineNumber, column: 7 },
+                                    end: { file: file.file, line: lineNumber, column: 7 },
+                                },
+                                replacement: ":",
+                            }],
+                    },
+                });
+            }
+        }
+    },
+};

package/dist/rules/AD016.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const AD016: Rule;

package/dist/rules/AD016.js

@@ -0,0 +1,83 @@
+import { isLineInProtectedBlock } from "./utils.js";
+const captionPattern = /^Figure\s+\d+(?:[-.]\d+)?[:.]\s+(\S.*)$/i;
+export const AD016 = {
+    id: "AD016",
+    alias: "malformed-figure-caption",
+    description: "Figure captions should use AsciiDoc title syntax",
+    tags: ["core", "image", "diagram"],
+    parser: "document",
+    docs: {
+        summary: "A figure caption line adjacent to an image or diagram should be an AsciiDoc block title.",
+        rationale: "Plain Figure lines imported from DOCX or Markdown do not become AsciiDoc block titles.",
+        badExamples: [{ code: "Figure 1: Architecture\nimage::architecture.png[Architecture]" }],
+        goodExamples: [{ code: ".Architecture\nimage::architecture.png[Architecture]" }],
+        fixability: "no",
+        fixHelper: "Move the caption immediately before the image or diagram and convert it to a .Title line without the generated Figure number.",
+    },
+    function: ({ document }, onError) => {
+        const files = new Map(document.files.map((file) => [file.file, file.lines]));
+        for (const file of document.files) {
+            for (const [index, line] of file.lines.entries()) {
+                if (!line.trim().startsWith("image::") || isLineInProtectedBlock(document, file.file, index + 1)) {
+                    continue;
+                }
+                const before = findCaptionBefore(file.lines, index);
+                if (before !== undefined) {
+                    reportCaption(onError, file.file, before + 1, file.lines[before] ?? "", "before");
+                }
+            }
+        }
+        for (const block of document.blocks.filter((entry) => entry.type === "image" || entry.type === "diagram")) {
+            const lines = files.get(block.range.start.file);
+            if (!lines) {
+                continue;
+            }
+            const before = findCaptionBefore(lines, block.range.start.line - 1, block.type === "diagram");
+            if (before !== undefined) {
+                reportCaption(onError, block.range.start.file, before + 1, lines[before] ?? "", "before");
+            }
+            const after = findCaptionAfter(lines, block.range.end?.line ?? findDelimitedBlockEnd(lines, block.range.start.line - 1));
+            if (after !== undefined) {
+                reportCaption(onError, block.range.start.file, after + 1, lines[after] ?? "", "after");
+            }
+        }
+    },
+};
+function findCaptionBefore(lines, blockStartIndex, allowDiagramStyleLine = false) {
+    let cursor = blockStartIndex - 1;
+    if (allowDiagramStyleLine && isDiagramStyleLine(lines[cursor] ?? "")) {
+        cursor -= 1;
+    }
+    return captionPattern.test((lines[cursor] ?? "").trim()) ? cursor : undefined;
+}
+function findCaptionAfter(lines, blockEndLine) {
+    if (!blockEndLine) {
+        return undefined;
+    }
+    const index = blockEndLine;
+    return captionPattern.test((lines[index] ?? "").trim()) ? index : undefined;
+}
+function findDelimitedBlockEnd(lines, blockStartIndex) {
+    const delimiter = lines[blockStartIndex]?.trim();
+    if (!delimiter || !["----", "....", "++++", "____", "===="].includes(delimiter)) {
+        return blockStartIndex + 1;
+    }
+    for (let index = blockStartIndex + 1; index < lines.length; index += 1) {
+        if ((lines[index] ?? "").trim() === delimiter) {
+            return index + 1;
+        }
+    }
+    return blockStartIndex + 1;
+}
+function isDiagramStyleLine(line) {
+    return /^\[[^\]]+\]\s*$/.test(line.trim());
+}
+function reportCaption(onError, file, line, caption, position) {
+    const title = caption.trim().match(captionPattern)?.[1] ?? "caption text";
+    onError({
+        severity: "warning",
+        message: `Figure caption should use AsciiDoc title syntax${position === "after" ? " before the figure" : ""}`,
+        range: { start: { file, line, column: 1 } },
+        fixHelper: `Use .${title} immediately before the image or diagram so Asciidoctor generates the Figure number.`,
+    });
+}

package/dist/rules/AD017.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const AD017: Rule;

package/dist/rules/AD017.js

@@ -0,0 +1,53 @@
+const captionPattern = /^Table\s+\d+(?:[-.]\d+)?[:.]\s+(\S.*)$/i;
+export const AD017 = {
+    id: "AD017",
+    alias: "malformed-table-caption",
+    description: "Table captions should use AsciiDoc title syntax",
+    tags: ["core", "table"],
+    parser: "document",
+    docs: {
+        summary: "A table caption line adjacent to a table should be an AsciiDoc block title.",
+        rationale: "Plain Table lines imported from DOCX or Markdown do not become AsciiDoc block titles.",
+        badExamples: [{ code: "Table 1: Registers\n|===\n| Name | Value\n|===" }],
+        goodExamples: [{ code: ".Registers\n|===\n| Name | Value\n|===" }],
+        fixability: "no",
+        fixHelper: "Move the caption immediately before the table and convert it to a .Title line without the generated Table number.",
+    },
+    function: ({ document }, onError) => {
+        const files = new Map(document.files.map((file) => [file.file, file.lines]));
+        for (const block of document.blocks.filter((entry) => entry.type === "table")) {
+            const lines = files.get(block.range.start.file);
+            if (!lines) {
+                continue;
+            }
+            const before = findCaptionBefore(lines, block.range.start.line - 1);
+            if (before !== undefined) {
+                reportCaption(onError, block.range.start.file, before + 1, lines[before] ?? "", "before");
+            }
+            const after = findCaptionAfter(lines, block.range.end?.line);
+            if (after !== undefined) {
+                reportCaption(onError, block.range.start.file, after + 1, lines[after] ?? "", "after");
+            }
+        }
+    },
+};
+function findCaptionBefore(lines, blockStartIndex) {
+    const cursor = blockStartIndex - 1;
+    return captionPattern.test((lines[cursor] ?? "").trim()) ? cursor : undefined;
+}
+function findCaptionAfter(lines, blockEndLine) {
+    if (!blockEndLine) {
+        return undefined;
+    }
+    const index = blockEndLine;
+    return captionPattern.test((lines[index] ?? "").trim()) ? index : undefined;
+}
+function reportCaption(onError, file, line, caption, position) {
+    const title = caption.trim().match(captionPattern)?.[1] ?? "caption text";
+    onError({
+        severity: "warning",
+        message: `Table caption should use AsciiDoc title syntax${position === "after" ? " before the table" : ""}`,
+        range: { start: { file, line, column: 1 } },
+        fixHelper: `Use .${title} immediately before the table so Asciidoctor generates the Table number.`,
+    });
+}

package/dist/rules/AD019.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../types.js";
+export declare const AD019: Rule;